remove duplicated scripts: T51110
authormeta-androcto <meta.androcto1@gmail.com>
Fri, 7 Apr 2017 09:15:40 +0000 (19:15 +1000)
committermeta-androcto <meta.androcto1@gmail.com>
Fri, 7 Apr 2017 09:15:40 +0000 (19:15 +1000)
17 files changed:
add_mesh_chain_rope/__init__.py [deleted file]
add_mesh_chain_rope/oscurart_chain_maker.py [deleted file]
add_mesh_chain_rope/oscurart_rope_maker.py [deleted file]
add_test_scene_elements/__init__.py [deleted file]
add_test_scene_elements/add_light_template.py [deleted file]
add_test_scene_elements/camera_turnaround.py [deleted file]
add_test_scene_elements/scene_camera.py [deleted file]
add_test_scene_elements/scene_materials.py [deleted file]
add_test_scene_elements/scene_objects.py [deleted file]
add_test_scene_elements/scene_objects_cycles.py [deleted file]
add_test_scene_elements/scene_texture_render.py [deleted file]
add_test_scene_elements/trilighting.py [deleted file]
mesh_easylattice.py [deleted file]
object_drop_to_ground.py [deleted file]
object_laplace_lightning.py [deleted file]
object_mangle_tools.py [deleted file]
space_view3d_arrange_on_curve.py [deleted file]

diff --git a/add_mesh_chain_rope/__init__.py b/add_mesh_chain_rope/__init__.py
deleted file mode 100644 (file)
index eac23b0..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-bl_info = {
-    "name": "Oscurart Chain and Rope Maker",
-    "author": "Oscurart",
-    "version": (1, 1),
-    "blender": (2, 63, 0),
-    "location": "Add > Mesh",
-    "description": "Create chains and ropes along armatures/curves",
-    "warning": "",
-    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
-        "Scripts/Add_Mesh/Oscurart_Chain_Rope_Maker",
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    "category": "Object"}
-
-
-import bpy
-from .oscurart_rope_maker import *
-from .oscurart_chain_maker import *
-
-def register():
-    bpy.utils.register_class(OBJECT_OT_add_object)
-    bpy.types.INFO_MT_curve_add.append(oscRopeButton)
-    bpy.utils.register_module(__name__)
-    bpy.types.INFO_MT_mesh_add.append(menu_oscChain)
-
-def unregister():
-    bpy.utils.unregister_class(OBJECT_OT_add_object)
-    bpy.types.INFO_MT_curve_add.remove(oscRopeButton)
-    bpy.utils.unregister_module(__name__)
-    bpy.types.INFO_MT_mesh_add.remove(menu_oscChain)
-
-if __name__ == "__main__":
-    register()
-
-
-
-
-
diff --git a/add_mesh_chain_rope/oscurart_chain_maker.py b/add_mesh_chain_rope/oscurart_chain_maker.py
deleted file mode 100644 (file)
index c6b8a04..0000000
+++ /dev/null
@@ -1,190 +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": "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",
-    "tracker_url": "",
-    "category": "Object"}
-
-
-
-
-
-import bpy
-
-
-def makeChain (self, context, mult, curverig):
-
-    if bpy.context.active_object.type == 'ARMATURE':
-        bpy.ops.object.mode_set(mode='OBJECT')
-        VAR_SWITCH=abs(1)
-        ARMATURE=bpy.context.active_object
-        def creahuesocero(hueso):
-            ## CREO DATA PARA ESLABON
-            mesh=bpy.data.meshes.new("objectData"+str(hueso.name))
-            object=bpy.data.objects.new("EslabonCero"+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)]
-            )
-            bpy.context.scene.objects.link(object)
-            ## ESCALO EL HUESO
-            bpy.data.objects['EslabonCero'+str(hueso.name)].scale= (hueso.length*mult,hueso.length*mult,hueso.length*mult)
-            ## EMPARENTO
-            bpy.data.objects['EslabonCero'+str(hueso.name)].parent=ARMATURE
-            bpy.data.objects['EslabonCero'+str(hueso.name)].parent_type = 'BONE'
-            bpy.data.objects['EslabonCero'+str(hueso.name)].parent_bone=hueso.name
-        def creahuesonoventa(hueso):
-            ## CREO DATA PARA ESLABON
-            mesh=bpy.data.meshes.new("objectData"+str(hueso.name))
-            object=bpy.data.objects.new("EslabonNov"+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)]
-            )
-            bpy.context.scene.objects.link(object)
-            ## ESCALO EL HUESO
-            bpy.data.objects['EslabonNov'+str(hueso.name)].scale= (hueso.length*mult,hueso.length*mult,hueso.length*mult)
-            ## EMPARENTO
-            bpy.data.objects['EslabonNov'+str(hueso.name)].parent=ARMATURE
-            bpy.data.objects['EslabonNov'+str(hueso.name)].parent_type = 'BONE'
-            bpy.data.objects['EslabonNov'+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
-                print(VAR_SWITCH)
-            else :
-                VAR_SWITCH = 1
-                print(VAR_SWITCH)
-        # SI NO TILDAMOS CURVERIG
-        if curverig == True:
-            # VARIABLES
-            LISTA_POINTC=[]
-            ACTARM=bpy.context.active_object
-            # CREO DATA , OBJETO Y LO CONECTO A LA ESCENA
-            crv= bpy.data.curves.new("CurvaCable", "CURVE")
-            obCable=bpy.data.objects.new("Cable",crv)
-            bpy.context.scene.objects.link(obCable)
-            # SETEO ATRIBUTOS
-            crv.dimensions = "3D"
-            crv.resolution_u = 10
-            crv.resolution_v = 10
-            crv.twist_mode = "MINIMUM"
-            # CREO LISTA DE COORDENADAS DE TAIL Y HEAD
-            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
-            ))
-            print("huesos: "+ str(len(ACTARM.data.bones)))
-            for hueso in ACTARM.data.bones:
-                LISTA_POINTC.append((hueso.tail_local[0],hueso.tail_local[1],hueso.tail_local[2],1))
-            # CREO EL SPLINE
-            spline=crv.splines.new("NURBS")
-            lencoord= len(LISTA_POINTC)
-            print("lencoord--> :"+str(lencoord))
-            rango=range(lencoord)
-            spline.points.add(lencoord-1)
-            for punto in rango:
-                spline.points[punto].co = LISTA_POINTC[punto]
-                print(LISTA_POINTC[punto])
-            # SETEO ENDPOINT
-            bpy.data.objects['Cable'].data.splines[0].use_endpoint_u= True
-            # SELECCIONO LA CURVA
-            bpy.ops.object.select_all(action='DESELECT')
-            bpy.data.objects['Cable'].select=1
-            bpy.context.scene.objects.active=bpy.data.objects['Cable']
-            # PASO A EDIT
-            bpy.ops.object.mode_set(mode='EDIT')
-            # CREO 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
-            # PASO A SELECCIONAR LOS OBJETOS
-            bpy.ops.object.mode_set(mode='OBJECT')
-            bpy.ops.object.select_all(action='DESELECT')
-            ACTARM.select=1
-            bpy.context.scene.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]
-            # SETEO 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
-            # VUELVO A OBJECT MODE
-            bpy.ops.object.mode_set(mode='OBJECT')
-    else:
-        self.report({'WARNING'}, "Active Object must be an Armature")
-
-
-#---------------
-from bpy.props import *
-
-class MESH_OT_chain_maker(bpy.types.Operator):
-    bl_idname="mesh.primitive_oscurart_chain_add"
-    bl_label="Oscurart Chain"
-    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):
-        return (context.object is not None)
-
-    def execute(self, context):
-        makeChain(self, context, self.multiplier,self.curverig)
-        return {'FINISHED'}
-
-def menu_oscChain(self, context):
-    self.layout.operator("mesh.primitive_oscurart_chain_add",
-        text="Oscurart Chain",
-        icon='LINKED')
-
-def register():
-   bpy.utils.register_module(__name__)
-   bpy.types.INFO_MT_mesh_add.append(menu_oscChain)
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-    bpy.types.INFO_MT_mesh_add.remove(menu_oscChain)
-
-
-if __name__ == "__main__":
-    register()
\ No newline at end of file
diff --git a/add_mesh_chain_rope/oscurart_rope_maker.py b/add_mesh_chain_rope/oscurart_rope_maker.py
deleted file mode 100644 (file)
index 338d1ed..0000000
+++ /dev/null
@@ -1,197 +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": "Oscurart Rope Maker",
-    "author": "Oscurart",
-    "version": (1,1),
-    "blender": (2, 56, 0),
-    "location": "Add > Curve > Oscurart Rope",
-    "description": "Create ropes",
-    "warning": "",
-    "wiki_url": "oscurart.blogspot.com",
-    "tracker_url": "",
-    "category": "Object"}
-
-
-
-import bpy, math
-
-
-
-
-
-def makeRope (context, DISTPOS, curvaResU, radius, FE, CUERDAS, stResU,DIAMETRO):
-
-    # CREO DATA , OBJETO Y LO CONECTO A LA ESCENA
-    crv= bpy.data.curves.new("CurvaCable", "CURVE")
-    obCable=bpy.data.objects.new("Cable",crv)
-    bpy.context.scene.objects.link(obCable)
-
-    # SETEO ATRIBUTOS
-    crv.dimensions = "3D"
-    crv.resolution_u = 10
-    crv.resolution_v = 10
-    crv.twist_mode = "MINIMUM"
-
-    # LISTA DE COMPONENTES
-    coordenadas= [
-        (0,radius,0,radius),
-        (radius,0,0,radius),
-        (0,-radius,0,radius),
-        (-radius,0,0,radius)
-    ]
-
-
-
-    # CREO EL SPLINE
-    spline=crv.splines.new("NURBS")
-    lencoord= len(coordenadas)
-    #print("lencoord--> :"+str(lencoord))
-    rango=range(lencoord)
-    spline.points.add(lencoord-1)
-    for punto in rango:
-        spline.points[punto].co = coordenadas[punto]
-        #print(punto)
-
-
-    # MODIFICACIONES DE DATA
-    spline.use_cyclic_u = True
-    spline.resolution_u = curvaResU
-    spline.order_u = 3
-    spline.use_endpoint_u = True
-
-
-    ## ==CREO CADENAS==
-
-    ## DIVIDO EL RADIO POR LA CANTIDAD DE LINEAS Y SETEO UNA LISTA
-
-    GRADOS=[]
-    VALORPORPARTE=[]
-    DIVISION=360/CUERDAS
-    TAJADA=0
-
-    for parte in range(0,CUERDAS):
-        GRADOS.append(TAJADA)
-        TAJADA+=DIVISION
-
-
-
-    for GRAD in GRADOS:
-
-
-        # VARIABLES
-        FC=0
-        VARLISTVER=[]
-
-        VARANGLEY=0
-        VARANGLEZ=90
-        VARPOSX=0
-        EDGEINDEX=0
-        # DEFINO EL PESO PARA LAS COORDENADAS
-        WEIGHT = 1
-
-        while FC < FE:
-            ## CREA 3 CADENAS EN 0 90 Y 180 GRADOS
-            VARLISTVER.append((VARPOSX, math.sin(math.radians(GRAD))/(1/DIAMETRO) , math.sin(math.radians(GRAD+90))/(1/DIAMETRO),WEIGHT))
-
-            GRAD += 30
-            FC += 1
-            VARPOSX += DISTPOS
-
-
-
-        # CREO DATA , OBJETO Y LO CONECTO A LA ESCENA
-        crv= bpy.data.curves.new("curvaData", "CURVE")
-        ob=bpy.data.objects.new("Curva",crv)
-        bpy.context.scene.objects.link(ob)
-
-        # SETEO ATRIBUTOS
-        crv.dimensions = "3D"
-        crv.resolution_u = 10
-        crv.resolution_v = 10
-        crv.twist_mode = "MINIMUM"
-
-        # LISTA DE COMPONENTES
-        coordenadas= VARLISTVER
-
-
-
-        # CREO EL SPLINE
-        spline=crv.splines.new("NURBS")
-        lencoord= len(coordenadas)
-        #print("lencoord--> :"+str(lencoord))
-        rango=range(lencoord)
-        spline.points.add(lencoord-1)
-        for punto in rango:
-            spline.points[punto].co = coordenadas[punto]
-            #print(punto)
-
-
-        # MODIFICACIONES DE DATA
-        spline.use_cyclic_u = False
-        spline.resolution_u = stResU
-        spline.order_u = 3
-        spline.use_endpoint_u = True
-
-        ob.data.bevel_object= bpy.data.objects["Cable"]
-
-        #print(VARLISTVER)
-
-#---------------
-from bpy.props import *
-
-class OBJECT_OT_add_object(bpy.types.Operator):
-    bl_idname="curve.primitive_osc_rope_add"
-    bl_label="Oscurart Rope"
-    bl_options={'REGISTER','UNDO'}
-
-    strands = IntProperty (name="Strands", default=5 , min=1, max=1000, step=1)
-    diameter = FloatProperty (name="Diameter", default=1 , min=0, max=1000)
-    distPos= FloatProperty (name="Stretch", default=1 , min=0.01, max=100.0)
-    vertices= IntProperty (name="Length", default=10 , min=0, max=1000, step=1)
-    distResU= IntProperty (name="Resolution V", default=5 , min=1, max=1000, step=1)
-    stResU= IntProperty (name="Resolution U", default=5 , min=1, max=1000, step=1)
-    radio= FloatProperty (name="Radius", default=1 , min=0, max=1000)
-
-    def execute(self, context):
-        makeRope(context,
-            self.distPos,self.distResU,self.radio,self.vertices,self.strands, self.stResU,self.diameter)
-        return {'FINISHED'}
-
-# Registration
-
-def oscRopeButton(self, context):
-    self.layout.operator(
-        OBJECT_OT_add_object.bl_idname,
-        text="Oscurart Rope",
-        icon="PLUGIN")
-
-
-def register():
-    bpy.utils.register_class(OBJECT_OT_add_object)
-    bpy.types.INFO_MT_curve_add.append(oscRopeButton)
-
-
-def unregister():
-    bpy.utils.unregister_class(OBJECT_OT_add_object)
-    bpy.types.INFO_MT_curve_add.remove(oscRopeButton)
-
-
-if __name__ == '__main__':
-    register()
diff --git a/add_test_scene_elements/__init__.py b/add_test_scene_elements/__init__.py
deleted file mode 100644 (file)
index 6874a7a..0000000
+++ /dev/null
@@ -1,146 +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 #####
-# by meta-androcto #
-
-bl_info = {
-    "name": "Test Scene, Light, Camera",
-    "author": "Meta Androcto",
-    "version": (0, 2),
-    "blender": (2, 77, 0),
-    "location": "View3D > Add > Scene Elements",
-    "description": "Add Scenes & Lights, Objects.",
-    "warning": "",
-    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6"
-    "/Py/Scripts",
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    "category": "Object"}
-
-
-if "bpy" in locals():
-    import importlib
-    importlib.reload(scene_camera)
-    importlib.reload(scene_materials)
-    importlib.reload(scene_objects)
-    importlib.reload(scene_objects_cycles)
-    importlib.reload(scene_texture_render)
-    importlib.reload(add_light_template)
-    importlib.reload(trilighting)
-    importlib.reload(camera_turnaround)
-
-else:
-    from . import scene_camera
-    from . import scene_materials
-    from . import scene_objects
-    from . import scene_objects_cycles
-    from . import scene_texture_render
-    from . import add_light_template
-    from . import trilighting
-    from . import camera_turnaround
-
-import bpy
-
-
-class INFO_MT_scene_elements_add(bpy.types.Menu):
-    # Define the "mesh objects" menu
-    bl_idname = "INFO_MT_scene_elements"
-    bl_label = "Test scenes"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("camera.add_scene",
-                        text="Scene_Camera")
-        layout.operator("materials.add_scene",
-                        text="Scene_Objects_BI")
-        layout.operator("plane.add_scene",
-                        text="Scene_Plane")
-        layout.operator("objects_cycles.add_scene",
-                        text="Scene_Objects_Cycles")
-        layout.operator("objects_texture.add_scene",
-                        text="Scene_Textures_Cycles")
-
-class INFO_MT_mesh_lamps_add(bpy.types.Menu):
-    # Define the "mesh objects" menu
-    bl_idname = "INFO_MT_scene_lamps"
-    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")
-
-class INFO_MT_mesh_cameras_add(bpy.types.Menu):
-    # Define the "mesh objects" menu
-    bl_idname = "INFO_MT_scene_cameras"
-    bl_label = "Camera Sets"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.rotate_around",
-                        text="Turnaround Camera")
-
-# Define menu
-def menu(self, context):
-
-    layout = self.layout
-    layout.operator_context = 'INVOKE_REGION_WIN'
-    self.layout.separator()
-    self.layout.menu("INFO_MT_scene_elements", icon="SCENE_DATA")
-    self.layout.menu("INFO_MT_scene_lamps", icon="LAMP_SPOT")
-    self.layout.menu("INFO_MT_scene_cameras", icon="OUTLINER_DATA_CAMERA")
-
-# Addons Preferences
-
-
-class AddonPreferences(bpy.types.AddonPreferences):
-    bl_idname = __name__
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Lighting Sets:")
-        layout.label(text="Spots, Points & Tri Lights")
-        layout.label(text="Test Scenes:")
-        layout.label(text="Basic pre-built test scenes Cycles & BI")
-
-
-def register():
-    camera_turnaround.register()
-    bpy.utils.register_module(__name__)
-    # Add "Extras" menu to the "Add Mesh" menu
-    bpy.types.INFO_MT_add.append(menu)
-    try:
-        bpy.types.VIEW3D_MT_AddMenu.prepend(menu)
-    except:
-        pass
-
-def unregister():
-    camera_turnaround.unregister()
-    # Remove "Extras" menu from the "Add Mesh" menu.
-    bpy.types.INFO_MT_add.remove(menu)
-    try:
-        bpy.types.VIEW3D_MT_AddMenu.remove(menu)
-    except:
-        pass
-    bpy.utils.unregister_module(__name__)
-
-if __name__ == "__main__":
-    register()
diff --git a/add_test_scene_elements/add_light_template.py b/add_test_scene_elements/add_light_template.py
deleted file mode 100644 (file)
index 36fc6a0..0000000
+++ /dev/null
@@ -1,119 +0,0 @@
-# gpl: author rebellion
-
-'''
-bl_info = {
-    "name": "Light Template",
-    "author": "Rebellion",
-    "version": (1, 0),
-    "blender": (2, 7, 0),
-    "location": "View3D > Add > Lights Template",
-    "description": "Adds  a light/camera template to your scene",
-    "warning": "",
-    "wiki_url": "",
-    "category": "Camera"}
-'''
-
-import bpy
-from bpy.types import Operator
-from bpy.props import BoolProperty
-from bpy_extras.object_utils import AddObjectHelper, object_data_add
-from mathutils import Vector
-
-
-def add_lamps(self, context):
-
-    if self.bKeyLight:
-        keyLight = bpy.data.lamps.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.scene.objects.link(ob)
-        ob.rotation_euler[2] = -0.785398
-
-    if self.bFillLight:
-        fillLight = bpy.data.lamps.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.scene.objects.link(ob)
-        ob.rotation_euler[2] = 0.785398
-        ob.data.energy = 0.3
-
-    if self.bBackLight:
-        backLight = bpy.data.lamps.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.scene.objects.link(ob)
-        ob.rotation_euler[2] = 3.14159
-        ob.data.energy = 0.2
-
-    if self.camera_constraint:
-        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):
-    """Add light template"""
-    bl_idname = "object.add_light_template"
-    bl_label = "Add Light Template"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    camera = None
-    target = None
-
-    bKeyLight = BoolProperty(name="Key Light", default=True)
-    bFillLight = BoolProperty(name="Fill Light")
-    bBackLight = BoolProperty(name="Back Light")
-
-    camera_constraint = BoolProperty(name="Camera Constraint")
-
-    def execute(self, context):
-
-        objects = bpy.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_lamps(self, context)
-        return {'FINISHED'}
diff --git a/add_test_scene_elements/camera_turnaround.py b/add_test_scene_elements/camera_turnaround.py
deleted file mode 100644 (file)
index 5dd1920..0000000
+++ /dev/null
@@ -1,256 +0,0 @@
-# gpl: author Antonio Vazquez (antonioya)
-
-bl_info = {
-    "name": "Turnaround camera around object",
-    "author": "Antonio Vazquez (antonioya)",
-    "version": (0, 2, 4),
-    "blender": (2, 68, 0),
-    "location": "View3D > Toolshelf > Turnaround camera",
-    "description": "Add a camera rotation around selected object.",
-    "category": "Camera"}
-
-
-import bpy
-import math
-
-# Action class
-class RunAction(bpy.types.Operator):
-    bl_idname = "object.rotate_around"
-    bl_label = "Turnaround"
-    bl_description = "Create camera rotation around selected object"
-
-# Execute
-    def execute(self, context):
-
-# Save old data
-        scene = context.scene
-        selectobject = context.active_object
-        camera = bpy.data.objects[bpy.context.scene.camera.name]
-        savedcursor = bpy.context.scene.cursor_location.copy()  # cursor position
-        savedframe = scene.frame_current
-        if scene.use_cursor is False:
-            bpy.ops.view3d.snap_cursor_to_selected()
-
-# Create empty and parent
-        bpy.ops.object.empty_add(type='PLAIN_AXES')
-        myempty = bpy.data.objects[bpy.context.active_object.name]
-
-        myempty.location = selectobject.location
-        savedstate = myempty.matrix_world
-        myempty.parent = selectobject
-        myempty.name = 'MCH_Rotation_target'
-        myempty.matrix_world = savedstate
-
-# Parent camera to empty
-
-        savedstate = camera.matrix_world
-        camera.parent = myempty
-        camera.matrix_world = savedstate
-
-# Now add revolutions
-# (make empty active object)
-
-        bpy.ops.object.select_all(False)
-        myempty.select = True
-        bpy.context.scene.objects.active = myempty
-# save current configuration
-        savedinterpolation = context.user_preferences.edit.keyframe_new_interpolation_type
-# change interpolation mode
-        context.user_preferences.edit.keyframe_new_interpolation_type = 'LINEAR'
-# create first frame
-        myempty.rotation_euler = (0, 0, 0)
-        myempty.empty_draw_size = 0.1
-        bpy.context.scene.frame_set(scene.frame_start)
-        myempty.keyframe_insert(data_path='rotation_euler', frame=scene.frame_start)
-# Dolly zoom
-        if scene.dolly_zoom != "0":
-            bpy.data.cameras[camera.name].lens = scene.camera_from_lens
-            bpy.data.cameras[camera.name].keyframe_insert('lens', frame=scene.frame_start)
-
-# Calculate rotation XYZ
-        if scene.inverse_x:
-            ix = -1
-        else:
-            ix = 1
-
-        if scene.inverse_y:
-            iy = -1
-        else:
-            iy = 1
-
-        if scene.inverse_z:
-            iz = -1
-        else:
-            iz = 1
-
-        xrot = (math.pi * 2) * scene.camera_revol_x * ix
-        yrot = (math.pi * 2) * scene.camera_revol_y * iy
-        zrot = (math.pi * 2) * scene.camera_revol_z * iz
-
-# create middle frame
-        if scene.back_forw is True:
-            myempty.rotation_euler = (xrot, yrot, zrot)
-            myempty.keyframe_insert(data_path='rotation_euler', frame=((scene.frame_end - scene.frame_start) / 2))
-# reverse
-            xrot *= -1
-            yrot *= -1
-            zrot = 0
-
-# Dolly zoom
-        if scene.dolly_zoom == "2":
-            bpy.data.cameras[camera.name].lens = scene.camera_to_lens
-            bpy.data.cameras[camera.name].keyframe_insert('lens', frame=((scene.frame_end - scene.frame_start) / 2))
-
-# create last frame
-        myempty.rotation_euler = (xrot, yrot, zrot)
-        myempty.keyframe_insert(data_path='rotation_euler', frame=scene.frame_end)
-# Dolly zoom
-        if scene.dolly_zoom != "0":
-            if scene.dolly_zoom == "1":
-                bpy.data.cameras[camera.name].lens = scene.camera_to_lens  # final
-            else:
-                bpy.data.cameras[camera.name].lens = scene.camera_from_lens  # back to init
-
-            bpy.data.cameras[camera.name].keyframe_insert('lens', frame=scene.frame_end)
-
-# Track constraint
-        if scene.track is True:
-            bpy.context.scene.objects.active = camera
-            bpy.ops.object.constraint_add(type='TRACK_TO')
-            bpy.context.object.constraints[-1].track_axis = 'TRACK_NEGATIVE_Z'
-            bpy.context.object.constraints[-1].up_axis = 'UP_Y'
-            bpy.context.object.constraints[-1].target = bpy.data.objects[myempty.name]
-
-# back previous configuration
-        context.user_preferences.edit.keyframe_new_interpolation_type = savedinterpolation
-        bpy.context.scene.cursor_location = savedcursor
-
-
-# Back to old selection
-        bpy.ops.object.select_all(False)
-        selectobject.select = True
-        bpy.context.scene.objects.active = selectobject
-        bpy.context.scene.frame_set(savedframe)
-
-        return {'FINISHED'}
-
-# UI Class
-
-class PanelUI(bpy.types.Panel):
-    bl_label = "Turnaround Camera"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_category = "Animation"
-    bl_options = {'DEFAULT_CLOSED'}
-
-# Draw UI
-
-    def draw(self, context):
-        layout = self.layout
-        scene = context.scene
-        try:
-            bpy.context.scene.camera.name
-        except AttributeError:
-            row = layout.row(align=False)
-            row.label("No defined camera for scene", icon="ERROR")
-            return
-
-        if context.active_object is not None:
-            if context.active_object.type != 'CAMERA':
-                buf = context.active_object.name
-                row = layout.row(align=False)
-                row.operator("object.rotate_around", icon='OUTLINER_DATA_CAMERA')
-                row.label(buf, icon='MESH_DATA')
-                row = layout.row()
-                row.prop(scene, "use_cursor")
-                row = layout.row(align=False)
-                row.prop(scene, "camera")
-                row = layout.row()
-                row.prop(scene, "frame_start")
-                row.prop(scene, "frame_end")
-                row = layout.row()
-                row.prop(scene, "camera_revol_x")
-                row.prop(scene, "camera_revol_y")
-                row.prop(scene, "camera_revol_z")
-                row = layout.row()
-                row.prop(scene, "inverse_x")
-                row.prop(scene, "inverse_y")
-                row.prop(scene, "inverse_z")
-                row = layout.row()
-                row.prop(scene, "back_forw")
-                row = layout.row()
-                row.prop(scene, "dolly_zoom")
-                if scene.dolly_zoom != "0":
-                    row = layout.row()
-                    row.prop(scene, "camera_from_lens")
-                    row.prop(scene, "camera_to_lens")
-                row = layout.row()
-                row.prop(scene, "track")
-
-            else:
-                buf = "No valid object selected"
-                layout.label(buf, icon='MESH_DATA')
-
-# Registration
-
-def register():
-    bpy.utils.register_class(RunAction)
-    bpy.utils.register_class(PanelUI)
-
-# Define properties
-    bpy.types.Scene.camera_revol_x = bpy.props.FloatProperty(name='X', min=0, max=25,
-                                                             default=0, precision=2,
-                                                             description='Number total of revolutions in X axis')
-    bpy.types.Scene.camera_revol_y = bpy.props.FloatProperty(name='Y', min=0, max=25,
-                                                             default=0, precision=2,
-                                                             description='Number total of revolutions in Y axis')
-    bpy.types.Scene.camera_revol_z = bpy.props.FloatProperty(name='Z', min=0, max=25,
-                                                             default=1, precision=2,
-                                                             description='Number total of revolutions in Z axis')
-
-    bpy.types.Scene.inverse_x = bpy.props.BoolProperty(name="-X", description="Inverse rotation", default=False)
-    bpy.types.Scene.inverse_y = bpy.props.BoolProperty(name="-Y", description="Inverse rotation", default=False)
-    bpy.types.Scene.inverse_z = bpy.props.BoolProperty(name="-Z", description="Inverse rotation", default=False)
-    bpy.types.Scene.use_cursor = bpy.props.BoolProperty(name="Use cursor position",
-                                                        description="Use cursor position instead of object origin",
-                                                        default=False)
-    bpy.types.Scene.back_forw = bpy.props.BoolProperty(name="Back and forward",
-                                                       description="Create back and forward animation",
-                                                       default=False)
-
-    bpy.types.Scene.dolly_zoom = bpy.props.EnumProperty(items=(('0', "None", ""),
-                                                               ('1', "Dolly zoom", ""),
-                                                               ('2', "Dolly zoom B/F", "")),
-                                                        name="Lens Effects",
-                                                        description="Create a camera lens movement")
-
-    bpy.types.Scene.camera_from_lens = bpy.props.FloatProperty(name='From', min=1, max=500, default=35,
-                                                               precision=3,
-                                                               description='Start lens value')
-    bpy.types.Scene.camera_to_lens = bpy.props.FloatProperty(name='To', min=1, max=500, default=35, precision=3,
-                                                             description='End lens value')
-
-    bpy.types.Scene.track = bpy.props.BoolProperty(name="Create track constraint",
-                                                   description="Add a track constraint to the camera",
-                                                   default=False)
-
-
-def unregister():
-    bpy.utils.unregister_class(RunAction)
-    bpy.utils.unregister_class(PanelUI)
-
-    del bpy.types.Scene.camera_revol_x
-    del bpy.types.Scene.camera_revol_y
-    del bpy.types.Scene.camera_revol_z
-    del bpy.types.Scene.inverse_x
-    del bpy.types.Scene.inverse_y
-    del bpy.types.Scene.inverse_z
-    del bpy.types.Scene.use_cursor
-    del bpy.types.Scene.back_forw
-    del bpy.types.Scene.dolly_zoom
-    del bpy.types.Scene.camera_from_lens
-    del bpy.types.Scene.camera_to_lens
-    del bpy.types.Scene.track
-
-if __name__ == "__main__":
-    register()
diff --git a/add_test_scene_elements/scene_camera.py b/add_test_scene_elements/scene_camera.py
deleted file mode 100644 (file)
index 81da0fb..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-import mathutils
-import math
-from math import pi
-from bpy.props import *
-from mathutils import Vector
-
-
-class add_scene_camera(bpy.types.Operator):
-    bl_idname = "camera.add_scene"
-    bl_label = "Camera Only"
-    bl_description = "Empty scene with Camera"
-    bl_register = True
-    bl_undo = True
-
-    def execute(self, context):
-        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_camera"
-
-# 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("Camera_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.draw_size = 0.1
-        bpy.ops.view3d.viewnumpad(type='CAMERA')
-        return {"FINISHED"}
diff --git a/add_test_scene_elements/scene_materials.py b/add_test_scene_elements/scene_materials.py
deleted file mode 100644 (file)
index 905c7df..0000000
+++ /dev/null
@@ -1,176 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-import mathutils
-import math
-from math import pi
-from bpy.props import *
-from mathutils import Vector
-
-
-class add_BI_scene(bpy.types.Operator):
-    bl_idname = "materials.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Materials Scene with Objects"
-    bl_register = True
-    bl_undo = True
-
-    def execute(self, context):
-        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.draw_size = 0.1
-        bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-# add point lamp
-        bpy.ops.object.lamp_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.lamp_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 #
-### 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, view_align=False, 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), constraint_orientation='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
-
-        return {"FINISHED"}
diff --git a/add_test_scene_elements/scene_objects.py b/add_test_scene_elements/scene_objects.py
deleted file mode 100644 (file)
index 4cf9534..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-import mathutils
-import math
-from math import pi
-from bpy.props import *
-from mathutils import Vector
-
-
-class add_plane_scene(bpy.types.Operator):
-    bl_idname = "plane.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Scene with 'infinite' plane"
-    bl_register = True
-    bl_undo = True
-
-    def execute(self, context):
-        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_plane"
-
-# 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("Plane_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.draw_size = 0.1
-        bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-# add point lamp
-        bpy.ops.object.lamp_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.lamp_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 plane
-        bpy.ops.mesh.primitive_plane_add(radius=50, view_align=False, 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), constraint_orientation='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
-        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
-
-# 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
-
-        return {"FINISHED"}
diff --git a/add_test_scene_elements/scene_objects_cycles.py b/add_test_scene_elements/scene_objects_cycles.py
deleted file mode 100644 (file)
index 763523d..0000000
+++ /dev/null
@@ -1,130 +0,0 @@
-
-
-import bpy
-import mathutils
-import math
-from math import pi
-from bpy.props import *
-from mathutils import Vector
-
-
-class add_cycles_scene(bpy.types.Operator):
-    bl_idname = "objects_cycles.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Cycles Scene with Objects"
-    bl_register = True
-    bl_undo = True
-
-    def execute(self, context):
-        blend_data = context.blend_data
-        ob = bpy.context.active_object
-
-# 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.draw_size = 0.1
-        bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-# add point lamp
-        bpy.ops.object.lamp_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.lamp_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, view_align=False, 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
-
-
-# Back to Scene
-        sc = bpy.context.scene
-
-        return {'FINISHED'}
diff --git a/add_test_scene_elements/scene_texture_render.py b/add_test_scene_elements/scene_texture_render.py
deleted file mode 100644 (file)
index ce3c19a..0000000
+++ /dev/null
@@ -1,72 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-import mathutils
-import math
-from math import pi
-from bpy.props import *
-from mathutils import Vector
-
-
-class add_texture_scene(bpy.types.Operator):
-    bl_idname = "objects_texture.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Cycles Scene with Objects"
-    bl_register = True
-    bl_undo = True
-
-    def execute(self, context):
-        blend_data = context.blend_data
-        ob = bpy.context.active_object
-
-# 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), view_align = True)
-        cam = bpy.context.active_object.data
-        cam.lens = 35
-        cam.draw_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
-
-        return {'FINISHED'}
diff --git a/add_test_scene_elements/trilighting.py b/add_test_scene_elements/trilighting.py
deleted file mode 100644 (file)
index a381f1b..0000000
+++ /dev/null
@@ -1,147 +0,0 @@
-# gpl: author Daniel Schalla
-
-'''
-bl_info = {
-    "name": "Tri-Lighting Creator",
-    "category": "Object",
-    "author": "Daniel Schalla",
-    "version": (1, 0),
-    "blender": (2, 75, 0),
-    "location": "Object Mode > Toolbar > Add Tri-Lighting",
-    "description": "Add 3 Point Lighting to selected Object"
-}
-'''
-
-import bpy
-import mathutils
-from bpy.props import *
-import math
-
-
-class TriLighting(bpy.types.Operator):
-    """TriL ightning"""
-    bl_idname = "object.trilighting"
-    bl_label = "Tri-Lighting Creator"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    height = bpy.props.FloatProperty(name="Height", default=5)
-    distance = bpy.props.FloatProperty(name="Distance", default=5, min=0.1, subtype="DISTANCE")
-    energy = bpy.props.IntProperty(name="Base Energy", default=3, min=1)
-    contrast = bpy.props.IntProperty(name="Contrast", default=50, min=-100, max=100, subtype="PERCENTAGE")
-    leftangle = bpy.props.IntProperty(name="Left Angle", default=26, min=1, max=90, subtype="ANGLE")
-    rightangle = bpy.props.IntProperty(name="Right Angle", default=45, min=1, max=90, subtype="ANGLE")
-    backangle = bpy.props.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 type off Key Light you would like',
-                               items=Light_Type_List, default='HEMI')
-
-    secondarytype = EnumProperty(attr='tl_type',
-                                 name='Fill+Back Type',
-                                 description='Choose the type off secondary Light you would like',
-                                 items=Light_Type_List, default='POINT')
-
-    def execute(self, context):
-        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)
-            scene.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.scene.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
-
-        print(self.contrast)
-# 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 = math.sqrt((pow(delta_position.x, 2) + pow(delta_position.y, 2) + pow(delta_position.z, 2)))
-        single_vector = (1 / vector_length) * delta_position
-
-# Calc back position
-        singleback_vector = single_vector.copy()
-        singleback_vector.x = math.cos(math.radians(self.backangle)) * single_vector.x + (-math.sin(math.radians(self.backangle)) * single_vector.y)
-        singleback_vector.y = math.sin(math.radians(self.backangle)) * single_vector.x + (math.cos(math.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.lamps.new(name="TriLamp-Back", type=self.secondarytype)
-        backData.energy = backEnergy
-
-        backLamp = bpy.data.objects.new(name="TriLamp-Back", object_data=backData)
-        scene.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 = math.cos(math.radians(self.rightangle)) * single_vector.x + (-math.sin(math.radians(self.rightangle)) * single_vector.y)
-        singleright_vector.y = math.sin(math.radians(self.rightangle)) * single_vector.x + (math.cos(math.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.lamps.new(name="TriLamp-Fill", type=self.secondarytype)
-        rightData.energy = fillEnergy
-        rightLamp = bpy.data.objects.new(name="TriLamp-Fill", object_data=rightData)
-        scene.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 = math.cos(math.radians(-self.leftangle)) * single_vector.x + (-math.sin(math.radians(-self.leftangle)) * single_vector.y)
-        singleleft_vector.y = math.sin(math.radians(-self.leftangle)) * single_vector.x + (math.cos(math.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.lamps.new(name="TriLamp-Key", type=self.primarytype)
-        leftData.energy = keyEnergy
-
-        leftLamp = bpy.data.objects.new(name="TriLamp-Key", object_data=leftData)
-        scene.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"
-
-        return {'FINISHED'}
-
diff --git a/mesh_easylattice.py b/mesh_easylattice.py
deleted file mode 100644 (file)
index 7e98a95..0000000
+++ /dev/null
@@ -1,428 +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, 5),
-    "blender": (2, 66, 0),
-    "location": "View3D > Easy Lattice",
-    "description": "Create a lattice for shape editing",
-    "warning": "",
-    "wiki_url": "http://wiki.blender.org/index.php/Easy_Lattice_Editing_Addon",
-    "tracker_url": "https://bitbucket.org/kursad/blender_addons_easylattice/src",
-    "category": "Mesh"}
-
-
-import bpy
-import mathutils
-import math
-
-# Cleanup
-def modifiersDelete( obj ):
-
-    for mod in obj.modifiers:
-        print(mod)
-        if mod.name == "latticeeasytemp":
-            try:
-                if mod.object == bpy.data.objects['LatticeEasytTemp']:
-                    print("applying modifier")
-                    bpy.ops.object.modifier_apply( apply_as = 'DATA', modifier = mod.name )
-
-            except:
-                bpy.ops.object.modifier_remove( modifier = mod.name )
-
-# Cleanup
-def modifiersApplyRemove( obj ):
-
-#     print("passed object is", obj)
-#     print("current object is", bpy.context.active_object)
-
-    bpy.ops.object.select_all( action = 'DESELECT' )
-    bpy.ops.object.select_pattern(pattern=obj.name, extend=False)
-    bpy.context.scene.objects.active=obj
-
-    for mod in obj.modifiers:
-#         print("modifier is ", mod)
-        if mod.name == "latticeeasytemp":
-#             try:
-            if mod.object == bpy.data.objects['LatticeEasytTemp']:
-#                 print("mod object is ", mod.object)
-#                 print("applying modifier", mod," - ", mod.name)
-
-                #obj.select= True
-#                 print("current object is", bpy.context.active_object)
-                bpy.ops.object.modifier_apply( apply_as = 'DATA', modifier = mod.name )
-                #obj.modifiers.remove(mod)
-
-#             except:
-#                 bpy.ops.object.modifier_remove( modifier = mod.name )
-
-
-# Cleanup
-def latticeDelete(obj):
-    bpy.ops.object.select_all( action = 'DESELECT' )
-    for ob in bpy.context.scene.objects:
-         if "LatticeEasytTemp" in ob.name:
-             ob.select = True
-    bpy.ops.object.delete( use_global = False )
-
-    #select the original object back
-    obj.select=True
-
-def createLattice( obj, size, pos, props ):
-    # Create lattice and object
-    lat = bpy.data.lattices.new( 'LatticeEasytTemp' )
-    ob = bpy.data.objects.new( 'LatticeEasytTemp', lat )
-
-    loc,rot,scl = getTransformations( obj )
-
-    #get the combined rotation matrix and apply to the lattice
-    #ob.matrix_world=buildRot_WorldMat(obj)*ob.matrix_world
-
-    #the position comes from the bbox
-    ob.location = pos
-        #ob.location=(pos.x+loc.x,pos.y+loc.y,pos.z+loc.z)
-
-    #the size  from bbox
-    ob.scale = size
-        #ob.scale=(size.x*scl.x, size.y*scl.y,size.z*scl.z)
-
-    #the rotation comes from the combined obj world matrix which was converted to euler pairs.
-    ob.rotation_euler = buildRot_World(obj)
-
-    ob.show_x_ray = True
-    # Link object to scene
-    scn = bpy.context.scene
-    scn.objects.link( ob )
-    scn.objects.active = ob
-    scn.update()
-
-    # Set lattice attributes
-    lat.interpolation_type_u = props[3]
-    lat.interpolation_type_v = props[3]
-    lat.interpolation_type_w = props[3]
-
-    lat.use_outside = False
-
-    lat.points_u = props[0]
-    lat.points_v = props[1]
-    lat.points_w = props[2]
-
-    #Set lattice points
-    '''s = 0.0
-    points = [
-        (-s,-s,-s), (s,-s,-s), (-s,s,-s), (s,s,-s),
-        (-s,-s,s), (s,-s,s), (-s,s,s), (s,s,s)
-    ]
-    for n,pt in enumerate(lat.points):
-        for k in range(3):
-            #pt.co[k] = points[n][k]
-    '''
-
-    return ob
-
-
-def selectedVerts_Grp( obj ):
-#     vertices=bpy.context.active_object.data.vertices
-    vertices = obj.data.vertices
-
-    selverts = []
-
-    if obj.mode == "EDIT":
-        bpy.ops.object.editmode_toggle()
-
-    for grp in obj.vertex_groups:
-
-        if "templatticegrp" in grp.name:
-            bpy.ops.object.vertex_group_set_active( group = grp.name )
-            bpy.ops.object.vertex_group_remove()
-
-    tempgroup = obj.vertex_groups.new( "templatticegrp" )
-
-    # selverts=[vert for vert in vertices if vert.select==True]
-    for vert in vertices:
-        if vert.select == True:
-            selverts.append( vert )
-            tempgroup.add( [vert.index], 1.0, "REPLACE" )
-
-    # print(selverts)
-
-    return selverts
-
-def getTransformations( obj ):
-    rot = obj.rotation_euler
-    loc = obj.location
-    size = obj.scale
-
-    return [loc, rot, size]
-
-def findBBox( obj, selvertsarray ):
-
-#     mat = buildTrnSclMat( obj )
-    mat =buildTrnScl_WorldMat(obj)
-
-    mat_world = obj.matrix_world
-
-    minx, miny, minz = selvertsarray[0].co
-    maxx, maxy, maxz = selvertsarray[0].co
-
-    c = 1
-#     for vert in selvertsarray:
-    for c in range( len( selvertsarray ) ):
-        # co=obj.matrix_world*vert.co.to_4d()
-
-#         co = vert.co
-        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
-
-#         print("local cord", selvertsarray[c].co)
-#         print("world cord", co)
-        c += 1
-
-#     print("total verts", len(selvertsarray))
-#     print("counted verts",c)
-
-    # Based on world coords
-#     print("-> minx miny minz",minx, miny, minz )
-#     print("-> maxx maxy maxz",maxx, maxy, maxz )
-
-    minpoint = mathutils.Vector( ( minx, miny, minz ) )
-    maxpoint = mathutils.Vector( ( maxx, maxy, maxz ) )
-
-    # middle point has to be calculated based on the real world matrix
-    #middle = mat_world * mathutils.Vector((x_sum, y_sum, z_sum))/float(c)
-    middle = ( ( minpoint + maxpoint ) / 2 )
-
-    minpoint = mat * minpoint  # Calculate only based on loc/scale
-    maxpoint = mat * maxpoint  # Calculate only based on loc/scale
-    middle = mat_world * middle  # the middle has to be calculated based on the real world matrix
-
-    size = maxpoint - minpoint
-    size = mathutils.Vector( ( abs( size.x ), abs( size.y ), abs( size.z ) ) )
-
-    # local coords
-    #####################################################
-    '''minpoint=mathutils.Vector((minx,miny,minz))
-    maxpoint=mathutils.Vector((maxx,maxy,maxz))
-    middle=mathutils.Vector( (x_sum/float(len(selvertsarray)), y_sum/float(len(selvertsarray)), z_sum/float(len(selvertsarray))) )
-    size=maxpoint-minpoint
-    size=mathutils.Vector((abs(size.x),abs(size.y),abs(size.z)))
-    '''
-    #####################################################
-
-
-    return [minpoint, maxpoint, size, middle  ]
-
-
-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 obejct level if there is any
-    mat_trans = mathutils.Matrix.Translation( obj.location )
-    mat_scale = mathutils.Matrix.Scale( obj.scale[0], 4, ( 1, 0, 0 ) )
-    mat_scale *= mathutils.Matrix.Scale( obj.scale[1], 4, ( 0, 1, 0 ) )
-    mat_scale *= mathutils.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 obejct level if there is any
-    loc,rot,scl=obj.matrix_world.decompose()
-    mat_trans = mathutils.Matrix.Translation( loc)
-
-    mat_scale = mathutils.Matrix.Scale( scl[0], 4, ( 1, 0, 0 ) )
-    mat_scale *= mathutils.Matrix.Scale( scl[1], 4, ( 0, 1, 0 ) )
-    mat_scale *= mathutils.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 = mathutils.Matrix.Rotation(rot[0], 4,'X')
-    mat_rot *= mathutils.Matrix.Rotation(rot[1],4,'Z')
-    mat_rot *= mathutils.Matrix.Rotation(rot[2], 4,'Y')
-    return mat_rot
-
-#Feature use
-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 obejct level if there is any
-    loc,rot,scl=obj.matrix_world.decompose()
-    mat_trans = mathutils.Matrix.Translation( loc)
-
-    return mat_trans
-
-#Feature use
-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 obejct level if there is any
-    loc,rot,scl=obj.matrix_world.decompose()
-
-    mat_scale = mathutils.Matrix.Scale( scl[0], 4, ( 1, 0, 0 ) )
-    mat_scale *= mathutils.Matrix.Scale( scl[1], 4, ( 0, 1, 0 ) )
-    mat_scale *= mathutils.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 run( lat_props ):
-
-#     print("<-------------------------------->")
-    #obj = bpy.context.active_object
-    obj = bpy.context.object
-
-    if obj.type == "MESH":
-        # set global property for the currently active latticed object
-        bpy.types.Scene.activelatticeobject = bpy.props.StringProperty( name = "currentlatticeobject", default = "" )
-        bpy.types.Scene.activelatticeobject = obj.name
-
-        modifiersDelete( obj )
-        selvertsarray = selectedVerts_Grp( obj )
-        bbox = findBBox( obj, selvertsarray )
-
-        size = bbox[2]
-        pos = bbox[3]
-
-#         print("lattce size, pos", size, " ", pos)
-        latticeDelete(obj)
-        lat = createLattice( obj, size, pos, lat_props )
-
-        modif = obj.modifiers.new( "latticeeasytemp", "LATTICE" )
-        modif.object = lat
-        modif.vertex_group = "templatticegrp"
-
-
-        bpy.ops.object.select_all( action = 'DESELECT' )
-        bpy.ops.object.select_pattern(pattern=lat.name, extend=False)
-        bpy.context.scene.objects.active=lat
-
-        bpy.context.scene.update()
-        bpy.ops.object.mode_set( mode = 'EDIT' )
-
-    if obj.type == "LATTICE":
-
-
-        if bpy.types.Scene.activelatticeobject:
-            name = bpy.types.Scene.activelatticeobject
-            print("last active latticed object", name)
-
-            #Are we in edit lattice mode? If so move on to object mode
-            if obj.mode=="EDIT":
-                bpy.ops.object.editmode_toggle()
-
-            for ob in bpy.context.scene.objects:
-                if ob.name == name:  # found the object with the lattice mod
-                    print("apply mod on", ob)
-                    object = ob
-                    modifiersApplyRemove(object)
-                    #modifiersDelete( object )  # apply the modifier and delete the lattice
-                    latticeDelete(obj)
-
-    return
-
-
-def main( context, latticeprops ):
-    run( latticeprops )
-
-class EasyLattice( bpy.types.Operator ):
-    """Tooltip"""
-    bl_idname = "object.easy_lattice"
-    bl_label = "Easy Lattice Creator"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-
-    lat_u = bpy.props.IntProperty( name = "Lattice u", default = 3 )
-    lat_w = bpy.props.IntProperty( name = "Lattice w", default = 3 )
-    lat_m = bpy.props.IntProperty( name = "Lattice m", default = 3 )
-
-    lat_types = ( ( '0', 'KEY_LINEAR', '0' ), ( '1', 'KEY_CARDINAL', '1' ), ( '2', 'KEY_BSPLINE', '2' ) )
-    lat_type = bpy.props.EnumProperty( name = "Lattice Type", items = lat_types, default = '0' )
-
-
-    @classmethod
-    def poll( cls, context ):
-        return context.active_object is not None
-
-    def execute( self, context ):
-
-        lat_u = self.lat_u
-        lat_w = self.lat_w
-        lat_m = self.lat_m
-
-        # this is a reference to the "items" used to generate the
-        # enum property.
-        lat_type = self.lat_types[int( self.lat_type )][1]
-        lat_props = [lat_u, lat_w, lat_m, lat_type]
-
-        main( context, lat_props )
-        return {'FINISHED'}
-
-    def invoke( self, context, event ):
-        wm = context.window_manager
-        return wm.invoke_props_dialog( self )
-
-def menu_draw( self, context ):
-    self.layout.operator_context = 'INVOKE_REGION_WIN'
-    self.layout.operator( EasyLattice.bl_idname, "Easy Lattice" )
-
-def register():
-    bpy.utils.register_class( EasyLattice )
-    # bpy.utils.register
-    # menu_func = (lambda self, context: self.layout.operator('EasyLattice'))
-    # bpy.types.VIEW3D_PT_tools_objectmode.append(menu_draw)
-    bpy.types.VIEW3D_MT_edit_mesh_specials.append( menu_draw )
-
-
-def unregister():
-    bpy.utils.unregister_class( EasyLattice )
-    # bpy.types.VIEW3D_PT_tools_objectmode.remove(menu_draw)
-    bpy.types.VIEW3D_MT_edit_mesh_specials.remove( menu_draw )
-
-if __name__ == "__main__":
-    register()
-    # run()
-#     bpy.ops.object.easy_lattice()
-
-
-
-
diff --git a/object_drop_to_ground.py b/object_drop_to_ground.py
deleted file mode 100644 (file)
index 1aabe43..0000000
+++ /dev/null
@@ -1,218 +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': 'Drop to Ground',
-    'author': 'Unnikrishnan(kodemax), Florian Meyer(testscreenings)',
-    'version': (1, 2),
-    "blender": (2, 71, 0),
-    'location': '3D View > Toolshelf > Tools Tab',
-    'description': 'Drop selected objects on active object',
-    'warning': '',
-    'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.6/Py/'
-        'Scripts/Object/Drop_to_ground',
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    'category': 'Object'}
-
-
-import bpy, bmesh
-from mathutils import *
-from bpy.types import Operator
-from bpy.props import *
-
-def get_align_matrix(location, normal):
-    up = Vector((0,0,1))
-    angle = normal.angle(up)
-    axis = up.cross(normal)
-    mat_rot = Matrix.Rotation(angle, 4, axis)
-    mat_loc = Matrix.Translation(location)
-    mat_align = mat_rot * mat_loc
-    return mat_align
-
-def transform_ground_to_world(sc, ground):
-    tmpMesh = ground.to_mesh(sc, True, 'PREVIEW')
-    tmpMesh.transform(ground.matrix_world)
-    tmp_ground = bpy.data.objects.new('tmpGround', tmpMesh)
-    sc.objects.link(tmp_ground)
-    sc.update()
-    return tmp_ground
-
-def get_lowest_world_co_from_mesh(ob, mat_parent=None):
-    bme = bmesh.new()
-    bme.from_mesh(ob.data)
-    mat_to_world = ob.matrix_world.copy()
-    if mat_parent:
-        mat_to_world = mat_parent * mat_to_world
-    lowest=None
-    #bme.verts.index_update() #probably not needed
-    for v in bme.verts:
-        if not lowest:
-            lowest = v
-        if (mat_to_world * v.co).z < (mat_to_world * lowest.co).z:
-            lowest = v
-    lowest_co = mat_to_world * lowest.co
-    bme.free()
-    return lowest_co
-
-def get_lowest_world_co(context, ob, mat_parent=None):
-    if ob.type == 'MESH':
-        return get_lowest_world_co_from_mesh(ob)
-
-    elif ob.type == 'EMPTY' and ob.dupli_type == 'GROUP':
-        if not ob.dupli_group:
-            return None
-
-        else:
-            lowest_co = None
-            for ob_l in ob.dupli_group.objects:
-                if ob_l.type == 'MESH':
-                    lowest_ob_l = get_lowest_world_co_from_mesh(ob_l, ob.matrix_world)
-                    if not lowest_co:
-                        lowest_co = lowest_ob_l
-                    if lowest_ob_l.z < lowest_co.z:
-                        lowest_co = lowest_ob_l
-
-            return lowest_co
-
-def drop_objects(self, context):
-    ground = context.object
-    obs = context.selected_objects
-    obs.remove(ground)
-    tmp_ground = transform_ground_to_world(context.scene, ground)
-    down = Vector((0, 0, -10000))
-
-    for ob in obs:
-        if self.use_origin:
-            lowest_world_co = ob.location
-        else:
-            lowest_world_co = get_lowest_world_co(context, ob)
-        if not lowest_world_co:
-            print(ob.type, 'is not supported. Failed to drop', ob.name)
-            continue
-        is_hit, hit_location, hit_normal, hit_index = tmp_ground.ray_cast(lowest_world_co, down)
-        if not is_hit:
-            print(ob.name, 'didn\'t hit the ground')
-            continue
-
-        # simple drop down
-        to_ground_vec =  hit_location - lowest_world_co
-        ob.location += to_ground_vec
-
-        # drop with align to hit normal
-        if self.align:
-            to_center_vec = ob.location - hit_location #vec: hit_loc to origin
-            # rotate object to align with face normal
-            mat_normal = get_align_matrix(hit_location, hit_normal)
-            rot_euler = mat_normal.to_euler()
-            mat_ob_tmp = ob.matrix_world.copy().to_3x3()
-            mat_ob_tmp.rotate(rot_euler)
-            mat_ob_tmp = mat_ob_tmp.to_4x4()
-            ob.matrix_world = mat_ob_tmp
-            # move_object to hit_location
-            ob.location = hit_location
-            # move object above surface again
-            to_center_vec.rotate(rot_euler)
-            ob.location += to_center_vec
-
-
-    #cleanup
-    bpy.ops.object.select_all(action='DESELECT')
-    tmp_ground.select = True
-    bpy.ops.object.delete('EXEC_DEFAULT')
-    for ob in obs:
-        ob.select = True
-    ground.select = True
-
-#################################################################
-class OBJECT_OT_drop_to_ground(Operator):
-    """Drop selected objects on active object"""
-    bl_idname = "object.drop_on_active"
-    bl_label = "Drop to Ground"
-    bl_options = {'REGISTER', 'UNDO'}
-    bl_description = "Drop selected objects on active object"
-
-    align = BoolProperty(
-            name="Align to ground",
-            description="Aligns the object to the ground",
-            default=True)
-    use_origin = BoolProperty(
-            name="Use Center",
-            description="Drop to objects origins",
-            default=False)
-
-    ##### POLL #####
-    @classmethod
-    def poll(cls, context):
-        return len(context.selected_objects) >= 2
-
-    ##### EXECUTE #####
-    def execute(self, context):
-        print('\nDropping Objects')
-        drop_objects(self, context)
-        return {'FINISHED'}
-
-#################################################################
-class drop_help(bpy.types.Operator):
-       bl_idname = 'help.drop'
-       bl_label = ''
-
-       def draw(self, context):
-               layout = self.layout
-               layout.label("To use:")
-               layout.label("Name the base object 'Ground'")
-               layout.label("Select the object/s to drop")
-               layout.label("Then Shift Select 'Ground'")
-
-       def execute(self, context):
-               return {'FINISHED'}
-
-       def invoke(self, context, event):
-               return context.window_manager.invoke_popup(self, width = 300)
-               
-class Drop_Operator_Panel(bpy.types.Panel):
-    bl_label = "Drop To Ground"
-    bl_region_type = "TOOLS" #UI possible too
-    bl_space_type = "VIEW_3D"
-    bl_options = {'DEFAULT_CLOSED'}
-    bl_context = "objectmode"
-    bl_category = "Tools"
-
-    def draw(self,context):
-        sce = context.scene
-        layout = self.layout
-        row = layout.row()
-        row = layout.split(0.80)
-        row.operator(OBJECT_OT_drop_to_ground.bl_idname,
-                         text="Drop to Ground")
-        row.operator('help.drop', icon = 'INFO')
-
-
-
-# register the class
-def register():
-    bpy.utils.register_module(__name__)
-
-    pass
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-
-    pass
-
-if __name__ == "__main__":
-    register()
diff --git a/object_laplace_lightning.py b/object_laplace_lightning.py
deleted file mode 100644 (file)
index 3c42767..0000000
+++ /dev/null
@@ -1,1276 +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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# ***** END GPL LICENCE BLOCK *****
-bl_info = {
-    "name": "Laplacian Lightning",
-    "author": "teldredge",
-    "version": (0, 2, 7),
-    "blender": (2, 71, 0),
-    "location": "View3D > Toolshelf > Create Tab",
-    "description": "Lightning mesh generator using laplacian growth algorithm",
-    "warning": "Beta",
-    "wiki_url": "http://www.funkboxing.com/wordpress/?p=301",
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    "category": "Object"}
-        
-######################################################################
-######################################################################
-##################### BLENDER LAPLACIAN LIGHTNING ####################
-############################ teldredge ###############################
-######################## www.funkboxing.com ##########################
-################# https://developer.blender.org/T27189 ###############
-######################################################################
-######################## using algorithm from ########################
-######################################################################
-############## FAST SIMULATION OF LAPLACIAN GROWTH (FSLG) ############
-#################### http://gamma.cs.unc.edu/FRAC/ ###################
-######################################################################
-###################### and a few ideas ideas from ####################
-######################################################################
-##### FAST ANIMATION OF LIGHTNING USING AN ADAPTIVE MESH (FALUAM) ####
-################ http://gamma.cs.unc.edu/FAST_LIGHTNING/ #############
-######################################################################
-######################################################################
-"""           -----RELEASE LOG/NOTES/PONTIFICATIONS-----
-v0.1.0 - 04.11.11
-    basic generate functions and UI
-    object creation report (Custom Properties: FSLG_REPORT)
-v0.2.0 - 04.15.11
-    started spelling laplacian right.
-    add curve function (not in UI) ...twisting problem
-    classify stroke by MAIN path, h-ORDER paths, TIP paths
-    jitter cells for mesh creation
-    add materials if present
-v0.2.1 - 04.16.11
-    mesh classification speedup
-v0.2.2 - 04.21.11
-    fxns to write/read array to file 
-    restrict growth to insulator cells (object bounding box)
-    origin/ground defineable by object
-    gridunit more like 'resolution'
-v0.2.3 - 04.24.11
-    cloud attractor object (termintates loop if hit)
-    secondary path orders (hOrder) disabled in UI (set to 1)
-v0.2.4 - 04.26.11
-    fixed object selection in UI
-    will not run if required object not selected   
-    moved to view 3d > toolbox
-v0.2.5 - 05.08.11
-    testing for 2.57b
-    single mesh output (for build modifier)
-    speedups (dist fxn)
-v0.2.6 - 06.20.11
-    scale/pos on 'write to cubes' works now
-    if origin obj is mesh, uses all verts as initial charges
-    semi-helpful tooltips
-    speedups, faster dedupe fxn, faster classification
-    use any shape mesh obj as insulator mesh
-        must have rot=0, scale=1, origin set to geometry
-        often fails to block bolt with curved/complex shapes
-    separate single and multi mesh creation
-v0.2.7 - 01.05.13
-    fixed the issue that prevented enabling the add-on
-    fixed makeMeshCube fxn
-    disabled visualization for voxels
-
-v0.x -
-    -prevent create_setup_objects from generating duplicates
-    -fix vis fxn to only buildCPGraph once for VM or VS
-    -improve list fxns (rid of ((x,y,z),w) and use (x,y,z,w)), use 'sets'
-    -create python cmodule for a few of most costly fxns
-        i have pretty much no idea how to do this yet
-    -cloud and insulator can be groups of MESH objs
-    -text output, possibly to save on interrupt, allow continue from text
-    -?hook modifiers from tips->sides->main, weight w/ vert groups
-    -user defined 'attractor' path
-    -fix add curve function
-    -animated arcs via. ionization path    
-    -environment map boundary conditions - requires Eqn. 15 from FSLG.
-    -assign wattage at each segment for HDRI
-    -?default settings for -lightning, -teslacoil, -spark/arc
-    -fix hOrder functionality
-    -multiple 'MAIN' brances for non-lightning discharges
-    -n-symmetry option, create mirror images, snowflakes, etc...
-"""
-
-######################################################################
-######################################################################
-######################################################################
-import bpy
-import time
-import random
-from math import sqrt
-from mathutils import Vector
-import struct
-import bisect
-import os.path
-notZero = 0.0000000001
-#scn = bpy.context.scene
-winmgr = bpy.context.window_manager
-
-######################################################################
-########################### UTILITY FXNS #############################
-######################################################################
-def within(x,y,d):
-###---CHECK IF x-d <= y <= x+d
-    if x-d <= y and x + d >= y:
-        return True
-    else: return False
-
-def dist(ax, ay, az ,bx, by, bz):
-    dv = Vector((ax,ay,az)) - Vector((bx,by,bz))
-    d = dv.length
-    return d
-
-def splitList(aList, idx):
-    ll = []
-    for x in aList:
-        ll.append(x[idx])
-    return ll
-
-def splitListCo(aList):
-    ll = []
-    for p in aList:
-        ll.append((p[0], p[1], p[2]))
-    return ll
-
-def getLowHigh(aList):
-    tLow = aList[0]; tHigh = aList[0]
-    for a in aList:
-        if a < tLow: tLow = a
-        if a > tHigh: tHigh = a
-    return tLow, tHigh
-
-def weightedRandomChoice(aList):
-    tL = []
-    tweight = 0
-    for a in range(len(aList)):
-        idex = a; weight = aList[a]
-        if weight > 0.0:
-            tweight += weight
-            tL.append((tweight, idex))
-    i = bisect.bisect(tL, (random.uniform(0, tweight), None))    
-    r = tL[i][1]
-    return r
-
-def getStencil3D_26(x,y,z):
-    nL = []
-    for xT in range(x-1, x+2):
-        for yT in range(y-1, y+2):
-            for zT in range(z-1, z+2):
-                nL.append((xT, yT, zT))
-    nL.remove((x,y,z))
-    return nL
-
-def jitterCells(aList, jit):
-    j = jit/2
-    bList = []
-    for a in aList:
-        ax = a[0] + random.uniform(-j, j)
-        ay = a[1] + random.uniform(-j, j)
-        az = a[2] + random.uniform(-j, j)
-        bList.append((ax, ay, az))
-    return bList
-
-def deDupe(seq, idfun=None): 
-###---THANKS TO THIS GUY - http://www.peterbe.com/plog/uniqifiers-benchmark
-    if idfun is None:
-        def idfun(x): return x
-    seen = {}
-    result = []
-    for item in seq:
-        marker = idfun(item)
-        if marker in seen: continue
-        seen[marker] = 1
-        result.append(item)
-    return result
-
-######################################################################
-######################## VISUALIZATION FXNS ##########################
-######################################################################
-def writeArrayToVoxel(arr, filename):
-    gridS = 64
-    half = int(gridS/2)
-    bitOn = 255
-    aGrid = [[[0 for z in range(gridS)] for y in range(gridS)] for x in range(gridS)]
-    for a in arr:
-        try:
-            aGrid[a[0]+half][a[1]+half][a[2]+half] = bitOn
-        except:
-            print('Particle beyond voxel domain')
-    file = open(filename, "wb")
-    for z in range(gridS):
-        for y in range(gridS):
-            for x in range(gridS):
-                file.write(struct.pack('B', aGrid[x][y][z]))
-    file.flush()
-    file.close()
-        
-def writeArrayToFile(arr, filename):
-    file = open(filename, "w")
-    for a in arr:
-        tstr = str(a[0]) + ',' + str(a[1]) + ',' + str(a[2]) + '\n'
-        file.write(tstr)
-    file.close
-
-def readArrayFromFile(filename):
-    file = open(filename, "r")
-    arr = []
-    for f in file:
-        pt = f[0:-1].split(',')
-        arr.append((int(pt[0]), int(pt[1]), int(pt[2])))
-    return arr
-
-def makeMeshCube_OLD(msize):
-    msize = msize/2
-    mmesh = bpy.data.meshes.new('q')
-    mmesh.vertices.add(8)
-    mmesh.vertices[0].co = [-msize, -msize, -msize]
-    mmesh.vertices[1].co = [-msize,  msize, -msize]
-    mmesh.vertices[2].co = [ msize,  msize, -msize]
-    mmesh.vertices[3].co = [ msize, -msize, -msize]
-    mmesh.vertices[4].co = [-msize, -msize,  msize]
-    mmesh.vertices[5].co = [-msize,  msize,  msize]
-    mmesh.vertices[6].co = [ msize,  msize,  msize]
-    mmesh.vertices[7].co = [ msize, -msize,  msize]
-    mmesh.faces.add(6)
-    mmesh.faces[0].vertices_raw = [0,1,2,3]
-    mmesh.faces[1].vertices_raw = [0,4,5,1]
-    mmesh.faces[2].vertices_raw = [2,1,5,6]
-    mmesh.faces[3].vertices_raw = [3,2,6,7]
-    mmesh.faces[4].vertices_raw = [0,3,7,4]
-    mmesh.faces[5].vertices_raw = [5,4,7,6]
-    mmesh.update(calc_edges=True)
-    return(mmesh)
-
-def makeMeshCube(msize):
-    m2 = msize/2
-    #verts = [(0,0,0),(0,5,0),(5,5,0),(5,0,0),(0,0,5),(0,5,5),(5,5,5),(5,0,5)]
-    verts = [(-m2,-m2,-m2),(-m2,m2,-m2),(m2,m2,-m2),(m2,-m2,-m2),
-             (-m2,-m2,m2),(-m2,m2,m2),(m2,m2,m2),(m2,-m2,m2)]
-    faces = [(0,1,2,3), (4,5,6,7), (0,4,5,1), (1,5,6,2), (2,6,7,3), (3,7,4,0)]
-    #Define mesh and object
-    mmesh = bpy.data.meshes.new("Cube")
-    #mobject = bpy.data.objects.new("Cube", mmesh)
-    #Set location and scene of object
-    #mobject.location = bpy.context.scene.cursor_location
-    #bpy.context.scene.objects.link(mobject)
-    #Create mesh
-    mmesh.from_pydata(verts,[],faces)
-    mmesh.update(calc_edges=True)
-    return(mmesh)
-
-def writeArrayToCubes(arr, gridBU, orig, cBOOL = False, jBOOL = True):
-    for a in arr:
-        x = a[0]; y = a[1]; z = a[2]
-        me = makeMeshCube(gridBU)
-        ob = bpy.data.objects.new('xCUBE', me)
-        ob.location.x = (x*gridBU) + orig[0]
-        ob.location.y = (y*gridBU) + orig[1]
-        ob.location.z = (z*gridBU) + orig[2]
-        if cBOOL: ###---!!!MOSTLY UNUSED
-            ###   POS+BLUE, NEG-RED, ZERO:BLACK
-            col = (1.0, 1.0, 1.0, 1.0)
-            if a[3] == 0: col = (0.0, 0.0, 0.0, 1.0)
-            if a[3] < 0: col = (-a[3], 0.0, 0.0, 1.0)
-            if a[3] > 0: col = (0.0, 0.0, a[3], 1.0)                
-            ob.color = col
-        bpy.context.scene.objects.link(ob)
-        bpy.context.scene.update()
-    if jBOOL:
-        ###---SELECTS ALL CUBES w/ ?bpy.ops.object.join() b/c
-        ###   CAN'T JOIN ALL CUBES TO A SINGLE MESH RIGHT... ARGH...
-        for q in bpy.context.scene.objects:
-            q.select = False
-            if q.name[0:5] == 'xCUBE':
-                q.select = True
-                bpy.context.scene.objects.active = q
-
-def addVert(ob, pt, conni = -1):
-    mmesh = ob.data
-    mmesh.vertices.add(1)
-    vcounti = len(mmesh.vertices)-1
-    mmesh.vertices[vcounti].co = [pt[0], pt[1], pt[2]]
-    if conni > -1:
-        mmesh.edges.add(1)
-        ecounti = len(mmesh.edges)-1
-        mmesh.edges[ecounti].vertices = [conni, vcounti]
-        mmesh.update()
-
-def addEdge(ob, va, vb):
-    mmesh = ob.data
-    mmesh.edges.add(1)
-    ecounti = len(mmesh.edges)-1
-    mmesh.edges[ecounti].vertices = [va, vb]
-    mmesh.update()    
-
-def newMesh(mname):
-    mmesh = bpy.data.meshes.new(mname)
-    omesh = bpy.data.objects.new(mname, mmesh)
-    bpy.context.scene.objects.link(omesh)
-    return omesh      
-
-def writeArrayToMesh(mname, arr, gridBU, rpt = None):
-    mob = newMesh(mname)
-    mob.scale = (gridBU, gridBU, gridBU)
-    if rpt: addReportProp(mob, rpt)
-    addVert(mob, arr[0], -1)
-    for ai in range(1, len(arr)):
-        a = arr[ai]
-        addVert(mob, a, ai-1)
-    return mob        
-
-###---!!!OUT OF ORDER - SOME PROBLEM WITH IT ADDING (0,0,0)
-def writeArrayToCurves(cname, arr, gridBU, bd = .05, rpt = None):
-    cur = bpy.data.curves.new('fslg_curve', 'CURVE')
-    cur.use_fill_front = False
-    cur.use_fill_back = False    
-    cur.bevel_depth = bd
-    cur.bevel_resolution = 2    
-    cob = bpy.data.objects.new(cname, cur)
-    cob.scale = (gridBU, gridBU, gridBU)
-    if rpt: addReportProp(cob, rpt)
-    bpy.context.scene.objects.link(cob)
-    cur.splines.new('BEZIER')
-    cspline = cur.splines[0]
-    div = 1 ###   SPACING FOR HANDLES (2 - 1/2 WAY, 1 - NEXT BEZIER)
-    for a in range(len(arr)):
-        cspline.bezier_points.add(1)
-        bp = cspline.bezier_points[len(cspline.bezier_points)-1]
-        if a-1 < 0: hL = arr[a]
-        else:
-            hx = arr[a][0] - ((arr[a][0]-arr[a-1][0]) / div)
-            hy = arr[a][1] - ((arr[a][1]-arr[a-1][1]) / div)
-            hz = arr[a][2] - ((arr[a][2]-arr[a-1][2]) / div)
-            hL = (hx,hy,hz)
-        
-        if a+1 > len(arr)-1: hR = arr[a]
-        else:
-            hx = arr[a][0] + ((arr[a+1][0]-arr[a][0]) / div)
-            hy = arr[a][1] + ((arr[a+1][1]-arr[a][1]) / div)
-            hz = arr[a][2] + ((arr[a+1][2]-arr[a][2]) / div)
-            hR = (hx,hy,hz)
-        bp.co = arr[a]
-        bp.handle_left = hL
-        bp.handle_right = hR
-
-def addArrayToMesh(mob, arr):
-    addVert(mob, arr[0], -1)
-    mmesh = mob.data
-    vcounti = len(mmesh.vertices)-1
-    for ai in range(1, len(arr)):
-        a = arr[ai]
-        addVert(mob, a, len(mmesh.vertices)-1)
-
-def addMaterial(ob, matname):
-    mat = bpy.data.materials[matname]
-    ob.active_material = mat
-
-def writeStokeToMesh(arr, jarr, MAINi, HORDERi, TIPSi, orig, gs, rpt=None):
-    ###---MAIN BRANCH
-    print('   WRITING MAIN BRANCH')
-    llmain = []
-    for x in MAINi:
-        llmain.append(jarr[x])
-    mob = writeArrayToMesh('la0MAIN', llmain, gs)
-    mob.location = orig       
-
-    ###---hORDER BRANCHES
-    for hOi in range(len(HORDERi)):
-        print('   WRITING ORDER', hOi)        
-        hO = HORDERi[hOi]
-        hob = newMesh('la1H'+str(hOi))
-
-        for y in hO:
-            llHO = []
-            for x in y:
-                llHO.append(jarr[x])
-            addArrayToMesh(hob, llHO)
-        hob.scale = (gs, gs, gs)
-        hob.location = orig
-
-    ###---TIPS
-    print('   WRITING TIP PATHS')    
-    tob = newMesh('la2TIPS')
-    for y in  TIPSi:
-        llt = []        
-        for x in y:
-            llt.append(jarr[x])
-        addArrayToMesh(tob, llt)
-    tob.scale = (gs, gs, gs)
-    tob.location = orig
-
-    ###---ADD MATERIALS TO OBJECTS (IF THEY EXIST)    
-    try:
-        addMaterial(mob, 'edgeMAT-h0')
-        addMaterial(hob, 'edgeMAT-h1')
-        addMaterial(tob, 'edgeMAT-h2')
-        print('   ADDED MATERIALS')
-    except: print('   MATERIALS NOT FOUND')
-    ###---ADD GENERATION REPORT TO ALL MESHES
-    if rpt:
-        addReportProp(mob, rpt)
-        addReportProp(hob, rpt)
-        addReportProp(tob, rpt)                
-
-def writeStokeToSingleMesh(arr, jarr, orig, gs, mct, rpt=None): 
-    sgarr = buildCPGraph(arr, mct)
-    llALL = []
-
-    Aob = newMesh('laALL')
-    for pt in jarr:
-        addVert(Aob, pt)
-    for cpi in range(len(sgarr)):
-        ci = sgarr[cpi][0]
-        pi = sgarr[cpi][1]
-        addEdge(Aob, pi, ci)
-    Aob.location = orig
-    Aob.scale = ((gs,gs,gs))
-
-    if rpt:
-        addReportProp(Aob, rpt)
-
-def visualizeArray(cg, oob, gs, vm, vs, vc, vv, rst):
-###---IN: (cellgrid, origin, gridscale,
-###   mulimesh, single mesh, cubes, voxels, report sting)
-    origin = oob.location
-
-    ###---DEAL WITH VERT MULTI-ORIGINS
-    oct = 2
-    if oob.type == 'MESH': oct = len(oob.data.vertices)
-
-    ###---JITTER CELLS
-    if vm or vs: cjarr = jitterCells(cg, 1)
-
-
-    if vm:  ###---WRITE ARRAY TO MULTI MESH
-        
-        aMi, aHi, aTi = classifyStroke(cg, oct, winmgr.HORDER)
-        print(':::WRITING TO MULTI-MESH')        
-        writeStokeToMesh(cg, cjarr, aMi, aHi, aTi, origin, gs, rst)
-        print(':::MULTI-MESH WRITTEN')
-
-    if vs:  ###---WRITE TO SINGLE MESH
-        print(':::WRITING TO SINGLE MESH')         
-        writeStokeToSingleMesh(cg, cjarr, origin, gs, oct, rst)
-        print(':::SINGLE MESH WRITTEN')
-        
-    if vc:  ###---WRITE ARRAY TO CUBE OBJECTS
-        print(':::WRITING TO CUBES')
-        writeArrayToCubes(cg, gs, origin)
-        print(':::CUBES WRITTEN')
-
-    if vv:  ###---WRITE ARRAY TO VOXEL DATA FILE
-        print(':::WRITING TO VOXELS')
-        fname = "FSLGvoxels.raw"
-        path = os.path.dirname(bpy.data.filepath)
-        writeArrayToVoxel(cg, path + "\\" + fname)
-        print(':::VOXEL DATA WRITTEN TO - ', path + "\\" + fname)
-
-    ###---READ/WRITE ARRAY TO FILE (MIGHT NOT BE NECESSARY)
-    #tfile = 'c:\\testarr.txt'
-    #writeArrayToFile(cg, tfile)
-    #cg = readArrayFromFile(tfile)
-
-    ###---READ/WRITE ARRAY TO CURVES (OUT OF ORDER)
-    #writeArrayToCurves('laMAIN', llmain, .10, .25)        
-
-######################################################################
-########################### ALGORITHM FXNS ###########################
-########################## FROM FALUAM PAPER #########################
-###################### PLUS SOME STUFF I MADE UP #####################
-######################################################################
-def buildCPGraph(arr, sti = 2):
-###---IN -XYZ ARRAY AS BUILT BY GENERATOR
-###---OUT -[(CHILDindex, PARENTindex)]
-###   sti - start index, 2 for Empty, len(me.vertices) for Mesh
-    sgarr = []
-    sgarr.append((1, 0)) #
-    for ai in range(sti, len(arr)):
-        cs = arr[ai]
-        cpts = arr[0:ai]
-        cslap = getStencil3D_26(cs[0], cs[1], cs[2])
-
-        for nc in cslap:
-            ct = cpts.count(nc)
-            if ct>0:
-                cti = cpts.index(nc)
-        sgarr.append((ai, cti))
-    return sgarr
-
-def buildCPGraph_WORKINPROGRESS(arr, sti = 2):
-###---IN -XYZ ARRAY AS BUILT BY GENERATOR
-###---OUT -[(CHILDindex, PARENTindex)]
-###   sti - start index, 2 for Empty, len(me.vertices) for Mesh
-    sgarr = []
-    sgarr.append((1, 0)) #
-    ctix = 0
-    for ai in range(sti, len(arr)):            
-        cs = arr[ai]
-        #cpts = arr[0:ai]
-        cpts = arr[ctix:ai]
-        cslap = getStencil3D_26(cs[0], cs[1], cs[2])
-        for nc in cslap:
-            ct = cpts.count(nc)
-            if ct>0:
-                #cti = cpts.index(nc)
-                cti = ctix + cpts.index(nc)
-                ctix = cpts.index(nc)
-                               
-        sgarr.append((ai, cti))
-    return sgarr
-
-def findChargePath(oc, fc, ngraph, restrict = [], partial = True):
-    ###---oc -ORIGIN CHARGE INDEX, fc -FINAL CHARGE INDEX
-    ###---ngraph -NODE GRAPH, restrict- INDEX OF SITES CANNOT TRAVERSE
-    ###---partial -RETURN PARTIAL PATH IF RESTRICTION ENCOUNTERD
-    cList = splitList(ngraph, 0)
-    pList = splitList(ngraph, 1)
-    aRi = []
-    cNODE = fc
-    for x in range(len(ngraph)):
-        pNODE = pList[cList.index(cNODE)]
-        aRi.append(cNODE)
-        cNODE = pNODE
-        npNODECOUNT = cList.count(pNODE)
-        if cNODE == oc:             ###   STOP IF ORIGIN FOUND
-            aRi.append(cNODE)       ###   RETURN PATH
-            return aRi
-        if npNODECOUNT == 0:        ###   STOP IF NO PARENTS
-            return []               ###   RETURN []
-        if pNODE in restrict:       ###   STOP IF PARENT IS IN RESTRICTION
-            if partial:             ###   RETURN PARTIAL OR []
-                aRi.append(cNODE)
-                return aRi
-            else: return []
-
-def findTips(arr):
-    lt = []
-    for ai in arr[0:len(arr)-1]:
-        a = ai[0]
-        cCOUNT = 0
-        for bi in arr:
-            b = bi[1]
-            if a == b:
-                cCOUNT += 1
-        if cCOUNT == 0:
-            lt.append(a)
-    return lt
-
-def findChannelRoots(path, ngraph, restrict = []):
-    roots = []
-    for ai in range(len(ngraph)):
-        chi = ngraph[ai][0]
-        par = ngraph[ai][1]
-        if par in path and not chi in path and \
-            not chi in restrict:        
-            roots.append(par)
-    droots = deDupe(roots)
-    return droots
-
-def findChannels(roots, tips, ngraph, restrict):
-    cPATHS = []
-    for ri in range(len(roots)):
-        r = roots[ri]
-        sL = 1
-        sPATHi = []
-        for ti in range(len(tips)):
-            t = tips[ti]
-            if t < r: continue
-            tPATHi = findChargePath(r, t, ngraph, restrict, False)
-            tL = len(tPATHi)
-            if tL > sL:
-                if countChildrenOnPath(tPATHi, ngraph) > 1:
-                    sL = tL
-                    sPATHi = tPATHi
-                    tTEMP = t; tiTEMP = ti
-        if len(sPATHi) > 0:
-            print('   found path/idex from', ri, 'of', 
-                  len(roots), 'possible | tips:', tTEMP, tiTEMP)
-            cPATHS.append(sPATHi)
-            tips.remove(tTEMP)
-    return cPATHS
-
-def findChannels_WORKINPROGRESS(roots, ttips, ngraph, restrict):
-    cPATHS = []
-    tips = list(ttips)
-    for ri in range(len(roots)):
-        r = roots[ri]
-        sL = 1
-        sPATHi = []
-        tipREMOVE = [] ###---CHECKED TIP INDEXES, TO BE REMOVED FOR NEXT LOOP
-        for ti in range(len(tips)):
-            t = tips[ti]            
-            #print('-CHECKING RT/IDEX:', r, ri, 'AGAINST TIP', t, ti)
-            #if t < r: continue
-            if ti < ri: continue
-            tPATHi = findChargePath(r, t, ngraph, restrict, False)
-            tL = len(tPATHi)
-            if tL > sL:
-                if countChildrenOnPath(tPATHi, ngraph) > 1:
-                    sL = tL
-                    sPATHi = tPATHi
-                    tTEMP = t; tiTEMP = ti
-            if tL > 0:
-                tipREMOVE.append(t)                    
-        if len(sPATHi) > 0:
-            print('   found path from root idex', ri, 'of', 
-                   len(roots), 'possible roots | #oftips=', len(tips))
-            cPATHS.append(sPATHi)
-        for q in tipREMOVE:  tips.remove(q)
-
-    return cPATHS
-
-def countChildrenOnPath(aPath, ngraph, quick = True):
-    ###---RETURN HOW MANY BRANCHES 
-    ###   COUNT WHEN NODE IS A PARENT >1 TIMES
-    ###   quick -STOP AND RETURN AFTER FIRST
-    cCOUNT = 0
-    pList = splitList(ngraph,1)
-    for ai in range(len(aPath)-1):
-        ap = aPath[ai]
-        pc = pList.count(ap)
-        if quick and pc > 1: 
-            return pc
-    return cCOUNT
-
-###---CLASSIFY CHANNELS INTO 'MAIN', 'hORDER/SECONDARY' and 'SIDE'
-def classifyStroke(sarr, mct, hORDER = 1):
-    print(':::CLASSIFYING STROKE')
-    ###---BUILD CHILD/PARENT GRAPH (INDEXES OF sarr)  
-    sgarr = buildCPGraph(sarr, mct)
-
-    ###---FIND MAIN CHANNEL 
-    print('   finding MAIN')
-    oCharge = sgarr[0][1]
-    fCharge = sgarr[len(sgarr)-1][0]
-    aMAINi = findChargePath(oCharge, fCharge, sgarr)
-    
-    ###---FIND TIPS
-    print('   finding TIPS')
-    aTIPSi = findTips(sgarr)
-
-    ###---FIND hORDER CHANNEL ROOTS
-    ###   hCOUNT = ORDERS BEWTEEN MAIN and SIDE/TIPS
-    ###   !!!STILL BUGGY!!!
-    hRESTRICT = list(aMAINi)    ### ADD TO THIS AFTER EACH TIME
-    allHPATHSi = []             ### ALL hO PATHS: [[h0], [h1]...]
-    curPATHSi = [aMAINi]        ### LIST OF PATHS FIND ROOTS ON
-    for h in range(hORDER):
-        allHPATHSi.append([])
-        for pi in range(len(curPATHSi)):     ###   LOOP THROUGH ALL PATHS IN THIS ORDER
-            p = curPATHSi[pi]
-            ###   GET ROOTS FOR THIS PATH
-            aHROOTSi = findChannelRoots(p, sgarr, hRESTRICT)
-            print('   found', len(aHROOTSi), 'roots in ORDER', h, ':#paths:', len(curPATHSi))
-            ### GET CHANNELS FOR THESE ROOTS
-            if len(aHROOTSi) == 0:
-                print('NO ROOTS FOR FOUND FOR CHANNEL')
-                aHPATHSi = []
-                continue
-            else:
-                aHPATHSiD = findChannels(aHROOTSi, aTIPSi, sgarr, hRESTRICT)
-                aHPATHSi = aHPATHSiD
-                allHPATHSi[h] += aHPATHSi
-                ###   SET THESE CHANNELS AS RESTRICTIONS FOR NEXT ITERATIONS
-                for hri in aHPATHSi:
-                    hRESTRICT += hri
-        curPATHSi = aHPATHSi
-    
-    ###---SIDE BRANCHES, FINAL ORDER OF HEIRARCHY
-    ###   FROM TIPS THAT ARE NOT IN AN EXISTING PATH
-    ###   BACK TO ANY OTHER POINT THAT IS ALREADY ON A PATH
-    aDRAWNi = []
-    aDRAWNi += aMAINi
-    for oH in allHPATHSi:
-        for o in oH:
-            aDRAWNi += o
-    aTPATHSi = []
-    for a in aTIPSi:
-        if not a in aDRAWNi:
-            aPATHi = findChargePath(oCharge, a, sgarr, aDRAWNi)
-            aDRAWNi += aPATHi
-            aTPATHSi.append(aPATHi)
-            
-    return aMAINi, allHPATHSi, aTPATHSi
-
-def voxelByVertex(ob, gs):
-###---'VOXELIZES' VERTS IN A MESH TO LIST [(x,y,z),(x,y,z)]
-###   W/ RESPECT GSCALE AND OB ORIGIN (B/C SHOULD BE ORIGIN OBJ)
-    orig = ob.location
-    ll = []
-    for v in ob.data.vertices:
-        x = int( v.co.x / gs )
-        y = int( v.co.y / gs )
-        z = int( v.co.z / gs )      
-        ll.append((x,y,z))
-    return ll
-    
-def voxelByRays(ob, orig, gs):
-###--- MESH INTO A 3DGRID W/ RESPECT GSCALE AND BOLT ORIGIN
-###   -DOES NOT TAKE OBJECT ROTATION/SCALE INTO ACCOUNT
-###   -THIS IS A HORRIBLE, INEFFICIENT FUNCTION
-###    MAYBE THE RAYCAST/GRID THING ARE A BAD IDEA. BUT I 
-###    HAVE TO 'VOXELIZE THE OBJECT W/ RESCT TO GSCALE/ORIGIN
-    bbox = ob.bound_box
-    bbxL = bbox[0][0]; bbxR = bbox[4][0]
-    bbyL = bbox[0][1]; bbyR = bbox[2][1]
-    bbzL = bbox[0][2]; bbzR = bbox[1][2]
-    xct = int((bbxR - bbxL) / gs)
-    yct = int((bbyR - bbyL) / gs)
-    zct = int((bbzR - bbzL) / gs)
-    xs = int(xct/2); ys = int(yct/2); zs = int(zct/2)
-    print('  CASTING', xct, '/', yct, '/', zct, 'cells, total:', xct*yct*zct, 'in obj-', ob.name)    
-    ll = []
-    rc = 100    ###---DISTANCE TO CAST FROM
-    ###---RAYCAST TOP/BOTTOM
-    print('  RAYCASTING TOP/BOTTOM')
-    for x in range(xct):
-        for y in range(yct):
-            xco = bbxL + (x*gs);  yco = bbyL + (y*gs)
-            v1 = ((xco, yco,  rc));    v2 = ((xco, yco, -rc))            
-            vz1 = ob.ray_cast(v1,v2);   vz2 = ob.ray_cast(v2,v1)            
-            if vz1[2] != -1: ll.append((x-xs, y-ys, int(vz1[0][2] * (1/gs)) ))
-            if vz2[2] != -1: ll.append((x-xs, y-ys, int(vz2[0][2] * (1/gs)) ))
-    ###---RAYCAST FRONT/BACK
-    print('  RAYCASTING FRONT/BACK')    
-    for x in range(xct):
-        for z in range(zct):
-            xco = bbxL + (x*gs);  zco = bbzL + (z*gs)
-            v1 = ((xco, rc,  zco));    v2 = ((xco, -rc, zco))            
-            vy1 = ob.ray_cast(v1,v2);   vy2 = ob.ray_cast(v2,v1)            
-            if vy1[2] != -1: ll.append((x-xs, int(vy1[0][1] * (1/gs)), z-zs))
-            if vy2[2] != -1: ll.append((x-xs, int(vy2[0][1] * (1/gs)), z-zs))
-    ###---RAYCAST LEFT/RIGHT
-    print('  RAYCASTING LEFT/RIGHT')
-    for y in range(yct):
-        for z in range(zct):
-            yco = bbyL + (y*gs);  zco = bbzL + (z*gs)
-            v1 = ((rc, yco,  zco));    v2 = ((-rc, yco, zco))            
-            vx1 = ob.ray_cast(v1,v2);   vx2 = ob.ray_cast(v2,v1)            
-            if vx1[2] != -1: ll.append((int(vx1[0][0] * (1/gs)), y-ys, z-zs))            
-            if vx2[2] != -1: ll.append((int(vx2[0][0] * (1/gs)), y-ys, z-zs))
-
-    ###---ADD IN NEIGHBORS SO BOLT WONT GO THRU
-    nlist = []
-    for l in ll:
-        nl = getStencil3D_26(l[0], l[1], l[2])
-        nlist += nl
-
-    ###---DEDUPE
-    print('  ADDED NEIGHBORS, DEDUPING...')    
-    rlist = deDupe(ll+nlist)
-    qlist = []
-    
-    ###---RELOCATE GRID W/ RESPECT GSCALE AND BOLT ORIGIN
-    ###   !!!NEED TO ADD IN OBJ ROT/SCALE HERE SOMEHOW...
-    od = Vector(( (ob.location[0] - orig[0]) / gs,
-                  (ob.location[1] - orig[1]) / gs,
-                  (ob.location[2] - orig[2]) / gs ))
-    for r in rlist:
-        qlist.append((r[0]+int(od[0]), r[1]+int(od[1]), r[2]+int(od[2]) ))
-
-    return qlist
-
-def fakeGroundChargePlane(z, charge):
-    eCL = []
-    xy = abs(z)/2
-    eCL += [(0, 0, z, charge)]    
-    eCL += [(xy, 0, z, charge)]
-    eCL += [(0, xy, z, charge)]
-    eCL += [(-xy, 0, z, charge)]
-    eCL += [(0, -xy, z, charge)]
-    return eCL
-
-def addCharges(ll, charge):
-###---IN: ll - [(x,y,z), (x,y,z)], charge - w
-###   OUT clist - [(x,y,z,w), (x,y,z,w)]
-    clist = []
-    for l in ll:
-        clist.append((l[0], l[1], l[2], charge))
-    return clist
-        
-######################################################################
-########################### ALGORITHM FXNS ###########################
-############################## FROM FSLG #############################
-######################################################################
-def getGrowthProbability_KEEPFORREFERENCE(uN, aList):
-    ###---IN: uN -USER TERM, cList -CANDIDATE SITES, oList -CANDIDATE SITE CHARGES
-    ###   OUT: LIST OF [(XYZ), POT, PROB]
-    cList = splitList(aList, 0)
-    oList = splitList(aList, 1)
-    Omin, Omax = getLowHigh(oList)
-    if Omin == Omax: Omax += notZero; Omin -= notZero
-    PdL = []
-    E = 0
-    E = notZero   ###===DIVISOR FOR (FSLG - Eqn. 12)
-    for o in oList:
-        Uj = (o - Omin) / (Omax - Omin) ###===(FSLG - Eqn. 13)
-        E += pow(Uj, uN)
-    for oi in range(len(oList)):
-        o = oList[oi]
-        Ui = (o - Omin) / (Omax - Omin)
-        Pd = (pow(Ui, uN)) / E ###===(FSLG - Eqn. 12)
-        PdINT = Pd * 100
-        PdL.append(Pd)
-    return PdL 
-
-###---WORK IN PROGRESS, TRYING TO SPEED THESE UP
-def fslg_e13(x, min, max, u): return pow((x - min) / (max - min), u)
-def addit(x,y):return x+y
-def fslg_e12(x, min, max, u, e): return (fslg_e13(x, min, max, u) / e) * 100
-
-def getGrowthProbability(uN, aList):
-    ###---IN: uN -USER TERM, cList -CANDIDATE SITES, oList -CANDIDATE SITE CHARGES
-    ###   OUT: LIST OF PROB
-    cList = splitList(aList, 0)
-    oList = splitList(aList, 1)
-    Omin, Omax = getLowHigh(oList)
-    if Omin == Omax: Omax += notZero; Omin -= notZero
-    PdL = []
-    E = notZero
-    minL = [Omin for q in range(len(oList))]
-    maxL = [Omax for q in range(len(oList))]
-    uNL =  [uN   for q in range(len(oList))]
-    E = sum(map(fslg_e13, oList, minL, maxL, uNL))
-    EL = [E for q in range(len(oList))]
-    mp = map(fslg_e12, oList, minL, maxL, uNL, EL)
-    for m in mp: PdL.append(m)
-    return PdL 
-
-def updatePointCharges(p, cList, eList = []):
-    ###---IN: pNew -NEW GROWTH CELL
-    ###       cList -OLD CANDIDATE SITES, eList -SAME
-    ###   OUT: LIST OF NEW CHARGE AT CANDIDATE SITES
-    r1 = 1/2        ###===(FSLG - Eqn. 10)
-    nOiL = []    
-    for oi in range(len(cList)):
-        o = cList[oi][1]
-        c = cList[oi][0]
-        iOe = 0
-        rit = dist(c[0], c[1], c[2], p[0], p[1], p[2])        
-        iOe += (1 - (r1/rit))
-        Oit =  o + iOe            
-        nOiL.append((c, Oit))
-    return nOiL
-
-def initialPointCharges(pList, cList, eList = []):
-    ###---IN: p -CHARGED CELL (XYZ), cList -CANDIDATE SITES (XYZ, POT, PROB)
-    ###   OUT: cList -WITH POTENTIAL CALCULATED 
-    r1 = 1/2        ###===(FSLG - Eqn. 10)
-    npList = []
-    for p in pList:
-        npList.append(((p[0], p[1], p[2]), 1.0))
-    for e in eList:
-        npList.append(((e[0], e[1], e[2]), e[3]))
-    OiL = []
-    for i in cList:
-        Oi = 0
-        for j in npList:
-            if i != j[0]:
-                rij = dist(i[0], i[1], i[2], j[0][0], j[0][1], j[0][2])
-                Oi += (1 - (r1 / rij)) * j[1] ### CHARGE INFLUENCE
-        OiL.append(((i[0], i[1], i[2]), Oi))
-    return OiL
-
-def getCandidateSites(aList, iList = []):
-    ###---IN: aList -(X,Y,Z) OF CHARGED CELL SITES, iList -insulator sites
-    ###   OUT: CANDIDATE LIST OF GROWTH SITES [(X,Y,Z)]
-    tt1 = time.clock()    
-    cList = []
-    for c in aList:
-        tempList = getStencil3D_26(c[0], c[1], c[2])
-        for t in tempList:
-            if not t in aList and not t in iList:
-                cList.append(t)
-    ncList = deDupe(cList)
-    tt2 = time.clock() 
-    #print('FXNTIMER:getCandidateSites:', tt2-tt1, 'check 26 against:', len(aList)+len(iList))    
-    return ncList
-
-######################################################################
-############################# SETUP FXNS #############################
-######################################################################
-def setupObjects():
-    #if winmgr.OOB == "" or winmgr.OOB.name not in scene...
-    oOB = bpy.data.objects.new('ELorigin', None)
-    oOB.location = ((0,0,10))
-    bpy.context.scene.objects.link(oOB)
-
-    gOB = bpy.data.objects.new('ELground', None)
-    gOB.empty_draw_type = 'ARROWS'
-    bpy.context.scene.objects.link(gOB)
-    
-    cME = makeMeshCube(1)
-    cOB = bpy.data.objects.new('ELcloud', cME)
-    cOB.location = ((-2,8,12))
-    cOB.hide_render = True    
-    bpy.context.scene.objects.link(cOB)
-    
-    iME = makeMeshCube(1)
-    for v in iME.vertices: 
-        xyl = 6.5; zl = .5
-        v.co[0] = v.co[0] * xyl
-        v.co[1] = v.co[1] * xyl
-        v.co[2] = v.co[2] * zl
-    iOB = bpy.data.objects.new('ELinsulator', iME)    
-    iOB.location = ((0,0,5))
-    iOB.hide_render = True
-    bpy.context.scene.objects.link(iOB)
-
-    try:
-        winmgr.OOB = 'ELorigin'
-        winmgr.GOB = 'ELground'
-        winmgr.COB = 'ELcloud'
-        winmgr.IOB = 'ELinsulator'
-    except: pass
-
-def checkSettings():
-    check = True
-    if winmgr.OOB == "": 
-        print('ERROR: NO ORIGIN OBJECT SELECTED')
-        check = False
-    if winmgr.GROUNDBOOL and winmgr.GOB == "":
-        print('ERROR: NO GROUND OBJECT SELECTED')
-        check = False
-    if winmgr.CLOUDBOOL and winmgr.COB == "":
-        print('ERROR: NO CLOUD OBJECT SELECTED')        
-        check = False
-    if winmgr.IBOOL and winmgr.IOB == "":
-        print('ERROR: NO INSULATOR OBJECT SELECTED')        
-        check = False
-    #should make a popup here
-    return check
-
-
-######################################################################
-############################### MAIN #################################
-######################################################################
-def FSLG():
-###======FAST SIMULATION OF LAPLACIAN GROWTH======###
-    print('\n<<<<<<------GO GO GADGET: FAST SIMULATION OF LAPLACIAN GROWTH!')
-    tc1 = time.clock()
-    TSTEPS = winmgr.TSTEPS
-
-    #obORIGIN = scn.objects[winmgr.OOB]    
-    #obGROUND = scn.objects[winmgr.GOB]
-    obORIGIN = bpy.context.scene.objects[winmgr.OOB]
-    obGROUND = bpy.context.scene.objects[winmgr.GOB]        
-    winmgr.ORIGIN = obORIGIN.location
-    winmgr.GROUNDZ = int((obGROUND.location[2] - winmgr.ORIGIN[2]) / winmgr.GSCALE)
-    
-    ###====== 1) INSERT INTIAL CHARGE(S) POINT (USES VERTS IF MESH)
-    cgrid = [(0, 0, 0)]
-    if obORIGIN.type == 'MESH':
-        print("<<<<<<------ORIGIN OBJECT IS MESH, 'VOXELIZING' INTIAL CHARGES FROM VERTS")
-        cgrid = voxelByVertex(obORIGIN, winmgr.GSCALE)
-        if winmgr.VMMESH:
-            print("<<<<<<------CANNOT CLASSIFY STROKE FROM VERT ORIGINS YET, NO MULTI-MESH OUTPUT")
-            winmgr.VMMESH = False; winmgr.VSMESH = True
-
-    ###---GROUND CHARGE CELL / INSULATOR LISTS (eChargeList/icList)
-    eChargeList = []; icList = []
-    if winmgr.GROUNDBOOL:
-        eChargeList = fakeGroundChargePlane(winmgr.GROUNDZ, winmgr.GROUNDC)
-    if winmgr.CLOUDBOOL:
-        print("<<<<<<------'VOXELIZING' CLOUD OBJECT (COULD TAKE SOME TIME)")
-        obCLOUD = bpy.context.scene.objects[winmgr.COB]
-        eChargeListQ = voxelByRays(obCLOUD, winmgr.ORIGIN, winmgr.GSCALE)
-        eChargeList = addCharges(eChargeListQ, winmgr.CLOUDC)
-        print('<<<<<<------CLOUD OBJECT CELL COUNT = ', len(eChargeList) )        
-    if winmgr.IBOOL:
-        print("<<<<<<------'VOXELIZING' INSULATOR OBJECT (COULD TAKE SOME TIME)")
-        obINSULATOR = bpy.context.scene.objects[winmgr.IOB]
-        icList = voxelByRays(obINSULATOR, winmgr.ORIGIN, winmgr.GSCALE)
-        print('<<<<<<------INSULATOR OBJECT CELL COUNT = ', len(icList) )
-        #writeArrayToCubes(icList, winmgr.GSCALE, winmgr.ORIGIN)
-        #return 'THEEND'
-        
-    ###====== 2) LOCATE CANDIDATE SITES AROUND CHARGE
-    cSites = getCandidateSites(cgrid, icList)
-    
-    ###====== 3) CALC POTENTIAL AT EACH SITE (Eqn. 10)
-    cSites = initialPointCharges(cgrid, cSites, eChargeList)
-    
-    ts = 1
-    while ts <= TSTEPS:
-        ###====== 1) SELECT NEW GROWTH SITE (Eqn. 12)
-        ###===GET PROBABILITIES AT CANDIDATE SITES
-        gProbs = getGrowthProbability(winmgr.BIGVAR, cSites)
-        ###===CHOOSE NEW GROWTH SITE BASED ON PROBABILITIES
-        gSitei = weightedRandomChoice(gProbs)
-        gsite  = cSites[gSitei][0]
-
-        ###====== 2) ADD NEW POINT CHARGE AT GROWTH SITE
-        ###===ADD NEW GROWTH CELL TO GRID
-        cgrid.append(gsite)
-        ###===REMOVE NEW GROWTH CELL FROM CANDIDATE SITES
-        cSites.remove(cSites[gSitei])
-
-        ###====== 3) UPDATE POTENTIAL AT CANDIDATE SITES (Eqn. 11)
-        cSites = updatePointCharges(gsite, cSites, eChargeList)        
-
-        ###====== 4) ADD NEW CANDIDATES SURROUNDING GROWTH SITE
-        ###===GET CANDIDATE 'STENCIL'
-        ncSitesT = getCandidateSites([gsite], icList)
-        ###===REMOVE CANDIDATES ALREADY IN CANDIDATE LIST OR CHARGE GRID
-        ncSites = []
-        cSplit = splitList(cSites, 0)
-        for cn in ncSitesT:
-            if not cn in cSplit and \
-            not cn in cgrid:
-                ncSites.append((cn, 0))
-
-        ###====== 5) CALC POTENTIAL AT NEW CANDIDATE SITES (Eqn. 10)
-        ncSplit = splitList(ncSites, 0)        
-        ncSites = initialPointCharges(cgrid, ncSplit, eChargeList)
-
-        ###===ADD NEW CANDIDATE SITES TO CANDIDATE LIST
-        for ncs in ncSites:
-            cSites.append(ncs)
-
-        ###===ITERATION COMPLETE
-        istr1 = ':::T-STEP: ' + str(ts) + '/' + str(TSTEPS) 
-        istr12 = ' | GROUNDZ: ' + str(winmgr.GROUNDZ) + ' | '
-        istr2 = 'CANDS: ' + str(len(cSites)) + ' | '
-        istr3 = 'GSITE: ' + str(gsite)
-        print(istr1 + istr12 + istr2 + istr3)        
-        ts += 1
-        
-        ###---EARLY TERMINATION FOR GROUND/CLOUD STRIKE
-        if winmgr.GROUNDBOOL:
-            if gsite[2] == winmgr.GROUNDZ:
-                ts = TSTEPS+1
-                print('<<<<<<------EARLY TERMINATION DUE TO GROUNDSTRIKE')
-                continue
-        if winmgr.CLOUDBOOL:
-            #if gsite in cloudList:
-            if gsite in splitListCo(eChargeList):
-                ts = TSTEPS+1
-                print('<<<<<<------EARLY TERMINATION DUE TO CLOUDSTRIKE')
-                continue            
-
-    tc2 = time.clock()
-    tcRUN = tc2 - tc1
-    print('<<<<<<------LAPLACIAN GROWTH LOOP COMPLETED: ' + str(len(cgrid)) + ' / ' + str(tcRUN)[0:5] + ' SECONDS')
-    print('<<<<<<------VISUALIZING DATA')
-
-    reportSTRING = getReportString(tcRUN)    
-    ###---VISUALIZE ARRAY
-    visualizeArray(cgrid, obORIGIN, winmgr.GSCALE, winmgr.VMMESH, winmgr.VSMESH, winmgr.VCUBE, winmgr.VVOX, reportSTRING)
-    print('<<<<<<------COMPLETE')
-
-######################################################################
-################################ GUI #################################
-######################################################################
-###---NOT IN UI
-bpy.types.WindowManager.ORIGIN = bpy.props.FloatVectorProperty(name = "origin charge")
-bpy.types.WindowManager.GROUNDZ = bpy.props.IntProperty(name = "ground Z coordinate")
-bpy.types.WindowManager.HORDER = bpy.props.IntProperty(name = "secondary paths orders")
-###---IN UI
-bpy.types.WindowManager.TSTEPS = bpy.props.IntProperty(
-    name = "iterations", description = "number of cells to create, will end early if hits ground plane or cloud")
-bpy.types.WindowManager.GSCALE = bpy.props.FloatProperty(
-    name = "grid unit size", description = "scale of cells, .25 = 4 cells per blenderUnit")
-bpy.types.WindowManager.BIGVAR = bpy.props.FloatProperty(
-    name = "straightness", description = "straightness/branchiness of bolt, <2 is mush, >12 is staight line, 6.3 is good")
-bpy.types.WindowManager.GROUNDBOOL = bpy.props.BoolProperty(
-    name = "use ground object", description = "use ground plane or not")
-bpy.types.WindowManager.GROUNDC = bpy.props.IntProperty(
-    name = "ground charge", description = "charge of ground plane")
-bpy.types.WindowManager.CLOUDBOOL = bpy.props.BoolProperty(
-    name = "use cloud object", description = "use cloud obj, attracts and terminates like ground but any obj instead of z plane, can slow down loop if obj is large, overrides ground")
-bpy.types.WindowManager.CLOUDC = bpy.props.IntProperty(
-    name = "cloud charge", description = "charge of a cell in cloud object (so total charge also depends on obj size)")
-
-bpy.types.WindowManager.VMMESH = bpy.props.BoolProperty(
-    name = "multi mesh", description = "output to multi-meshes for different materials on main/sec/side branches")
-bpy.types.WindowManager.VSMESH = bpy.props.BoolProperty(
-    name = "single mesh", description = "output to single mesh for using build modifier and particles for effects")
-bpy.types.WindowManager.VCUBE = bpy.props.BoolProperty(
-    name = "cubes", description = "CTRL-J after run to JOIN, outputs a bunch of cube objest, mostly for testing")
-bpy.types.WindowManager.VVOX = bpy.props.BoolProperty(        
-    name = "voxel (experimental)", description = "output to a voxel file to bpy.data.filepath\FSLGvoxels.raw - doesn't work well right now")
-bpy.types.WindowManager.IBOOL = bpy.props.BoolProperty(
-    name = "use insulator object", description = "use insulator mesh object to prevent growth of bolt in areas")
-bpy.types.WindowManager.OOB = bpy.props.StringProperty(description = "origin of bolt, can be an Empty, if obj is mesh will use all verts as charges")
-bpy.types.WindowManager.GOB = bpy.props.StringProperty(description = "object to use as ground plane, uses z coord only")
-bpy.types.WindowManager.COB = bpy.props.StringProperty(description = "object to use as cloud, best to use a cube")
-bpy.types.WindowManager.IOB = bpy.props.StringProperty(description = "object to use as insulator, 'voxelized' before generating bolt, can be slow")
-
-###---DEFAULT USER SETTINGS
-winmgr.TSTEPS = 350
-winmgr.HORDER = 1
-winmgr.GSCALE = 0.12
-winmgr.BIGVAR = 6.3
-winmgr.GROUNDBOOL = True
-winmgr.GROUNDC = -250
-winmgr.CLOUDBOOL = False
-winmgr.CLOUDC = -1
-winmgr.VMMESH = True
-winmgr.VSMESH = False
-winmgr.VCUBE = False
-winmgr.VVOX = False
-winmgr.IBOOL = False
-try:
-    winmgr.OOB = "ELorigin"
-    winmgr.GOB = "ELground"
-    winmgr.COB = "ELcloud"
-    winmgr.IOB = "ELinsulator"    
-except: pass
-
-###---TESTING USER SETTINGS
-if False:
-#if True:
-    winmgr.TSTEPS = 40
-    #winmgr.HORDER = 1
-    #winmgr.GSCALE = 0.12    
-    #winmgr.BIGVAR = 6.3
-    winmgr.GROUNDBOOL = True
-    #winmgr.GROUNDC = -500
-    winmgr.CLOUDBOOL = True
-    #winmgr.CLOUDC = -5
-    #winmgr.VMMESH = True
-    #winmgr.VSMESH = True
-    #winmgr.VCUBE = True
-    #winmgr.VVOX = True
-    winmgr.IBOOL = True
-
-class runFSLGLoopOperator(bpy.types.Operator):
-    '''By The Mighty Hammer Of Thor!!!'''
-    bl_idname = "object.runfslg_operator"
-    bl_label = "run FSLG Loop Operator"
-
-    def execute(self, context):
-        if checkSettings():
-            FSLG()
-        else: pass
-        return {'FINISHED'}
-    
-class setupObjectsOperator(bpy.types.Operator):
-    '''create origin/ground/cloud/insulator objects'''
-    bl_idname = "object.setup_objects_operator"
-    bl_label = "Setup Objects Operator"
-
-    def execute(self, context):
-        setupObjects()        
-        return {'FINISHED'}    
-
-class OBJECT_PT_fslg(bpy.types.Panel):
-    bl_label = "Laplacian Lightning - v0.2.6"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_context = "objectmode"
-    bl_category = "Create"
-    bl_options = {'DEFAULT_CLOSED'}
-
-    def draw(self, context):
-        scn = context.scene
-        layout = self.layout
-        colR = layout.column()        
-        #row1 = layout.row()
-        #colL = row1.column()
-        #colR = row1.column()
-        colR.label('-for progress open console-')
-        colR.label('Help > Toggle System Console')        
-        colR.prop(winmgr, 'TSTEPS')
-        colR.prop(winmgr, 'GSCALE')        
-        colR.prop(winmgr, 'BIGVAR')
-        colR.operator('object.setup_objects_operator', text = 'create setup objects')        
-        colR.label('origin object')
-        colR.prop_search(winmgr, "OOB",  context.scene, "objects")        
-        colR.prop(winmgr, 'GROUNDBOOL')
-        colR.prop_search(winmgr, "GOB",  context.scene, "objects")        
-        colR.prop(winmgr, 'GROUNDC') 
-        colR.prop(winmgr, 'CLOUDBOOL')
-        colR.prop_search(winmgr, "COB",  context.scene, "objects")        
-        colR.prop(winmgr, 'CLOUDC')
-        colR.prop(winmgr, 'IBOOL')
-        colR.prop_search(winmgr, "IOB",  context.scene, "objects")
-        colR.operator('object.runfslg_operator', text = 'generate lightning')
-        #col.prop(winmgr, 'HORDER')
-        colR.prop(winmgr, 'VMMESH')
-        colR.prop(winmgr, 'VSMESH')        
-        colR.prop(winmgr, 'VCUBE')
-        #colR.prop(winmgr, 'VVOX')
-
-def getReportString(rtime):
-    rSTRING1 = 't:' + str(winmgr.TSTEPS) + ',sc:' + str(winmgr.GSCALE)[0:4] + ',uv:' + str(winmgr.BIGVAR)[0:4] + ',' 
-    rSTRING2 = 'ori:' + str(winmgr. ORIGIN[0]) + '/' + str(winmgr. ORIGIN[1]) + '/' + str(winmgr. ORIGIN[2]) + ','
-    rSTRING3 = 'gz:' + str(winmgr.GROUNDZ) + ',gc:' + str(winmgr.GROUNDC) + ',rtime:' + str(int(rtime))
-    return rSTRING1 + rSTRING2 + rSTRING3
-
-def addReportProp(ob, str):
-    bpy.types.Object.FSLG_REPORT = bpy.props.StringProperty(
-          name = 'fslg_report', default = '')
-    ob.FSLG_REPORT = str
-        
-def register():
-    bpy.utils.register_class(runFSLGLoopOperator)    
-    bpy.utils.register_class(setupObjectsOperator)
-    bpy.utils.register_class(OBJECT_PT_fslg)
-
-def unregister():
-    bpy.utils.unregister_class(runFSLGLoopOperator)    
-    bpy.utils.unregister_class(setupObjectsOperator)    
-    bpy.utils.unregister_class(OBJECT_PT_fslg)
-
-if __name__ == "__main__":
-    ### RUN FOR TESTING
-    #FSLG()
-    
-    ### UI
-    register()
-    pass
-
-###########################
-##### FXN BENCHMARKS ######
-###########################
-def BENCH():
-    print('\n\n\n--->BEGIN BENCHMARK')
-    bt0 = time.clock()
-    ###---MAKE A BIG LIST
-    tsize = 25
-    tlist = []
-    for x in range(tsize):
-        for y in range(tsize):
-            for z in range(tsize):
-                tlist.append((x,y,z))
-                tlist.append((x,y,z))
-
-    ###---FUNCTION TO TEST
-    bt1 = time.clock()
-
-    #ll = deDupe(tlist)
-    #ll = f5(tlist)
-    print('LENS - ', len(tlist), len(ll) )
-
-    bt2 = time.clock()
-    btRUNb = bt2 - bt1
-    btRUNa = bt1 - bt0
-    print('--->SETUP TIME    : ', btRUNa)
-    print('--->BENCHMARK TIME: ', btRUNb)
-    print('--->GRIDSIZE: ', tsize, ' - ', tsize*tsize*tsize)
-    
-#BENCH()
-
-######################################################################
-############################### THE END ##############################
-######################################################################
diff --git a/object_mangle_tools.py b/object_mangle_tools.py
deleted file mode 100644 (file)
index 7688425..0000000
+++ /dev/null
@@ -1,208 +0,0 @@
-# mangle_tools.py (c) 2011 Phil Cote (cotejrp1)
-#
-# ***** 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 LICENCE BLOCK *****
-
-bl_info = {
-    "name": "Mangle Tools",
-    "author": "Phil Cote",
-    "version": (0, 2),
-    "blender": (2, 71, 0),
-    "location": "View3D > Toolshelf > Tools Tab",
-    "description": "Set of tools to mangle curves, meshes, and shape keys",
-    "warning": "", # used for warning icon and text in addons panel
-    "wiki_url": "",
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    "category": "Object"}
-
-
-import bpy
-import random
-import time
-from math import pi
-import bmesh
-
-def move_coordinate(context, co, is_curve=False):
-    xyz_const = context.scene.constraint_vector
-    random.seed(time.time())
-    multiplier = 1
-
-    # For curves, we base the multiplier on the circumference formula.
-    # This helps make curve changes more noticable.
-    if is_curve:
-        multiplier = 2 * pi
-    random_mag = context.scene.random_magnitude
-    if xyz_const[0]:
-        co.x += .01 * random.randrange( -random_mag, random_mag ) * multiplier
-    if xyz_const[1]:
-        co.y += .01 * random.randrange( -random_mag, random_mag )  * multiplier
-    if xyz_const[2]:
-        co.z += .01 * random.randrange( -random_mag, random_mag ) * multiplier
-
-
-class MeshManglerOperator(bpy.types.Operator):
-    """Push vertices on the selected object around in random """ \
-    """directions to create a crumpled look"""
-    bl_idname = "ba.mesh_mangler"
-    bl_label = "Mangle Mesh"
-    bl_options = { "REGISTER", "UNDO" }
-
-    @classmethod
-    def poll(cls, context):
-        ob = context.active_object
-        return ob != None and ob.type == 'MESH'
-
-    def execute(self, context):
-        mesh = context.active_object.data
-        bm = bmesh.new()
-        bm.from_mesh(mesh)
-        verts, faces = bm.verts, bm.faces
-        randomMag = context.scene.random_magnitude
-        random.seed( time.time() )
-
-        if mesh.shape_keys != None:
-            self.report({'INFO'}, "Cannot mangle mesh: Shape keys present")
-            return {'CANCELLED'}
-
-        for vert in verts:
-            xVal = .01 * random.randrange( -randomMag, randomMag )
-            yVal = .01 * random.randrange( -randomMag, randomMag)
-            zVal = .01 * random.randrange( -randomMag, randomMag )
-            vert.co.x = vert.co.x + xVal
-            vert.co.y = vert.co.y + yVal
-            vert.co.z = vert.co.z + zVal
-
-        bm.to_mesh(mesh)
-        mesh.update()
-        return {'FINISHED'}
-
-
-class AnimanglerOperator(bpy.types.Operator):
-    """Make a shape key and pushes the verts around on it """ \
-    """to set up for random pulsating animation"""
-    bl_idname = "ba.ani_mangler"
-    bl_label = "Mangle Shape Key"
-
-
-    @classmethod
-    def poll(cls, context):
-        ob = context.active_object
-        return ob != None and ob.type in [ 'MESH', 'CURVE' ]
-
-    def execute(self, context):
-        scn = context.scene
-        mangleName = scn.mangle_name
-        ob = context.object
-        shapeKey = ob.shape_key_add( name=mangleName )
-        verts = shapeKey.data
-
-        for vert in verts:
-            move_coordinate(context, vert.co, is_curve=ob.type=='CURVE')
-
-        return {'FINISHED'}
-
-
-class CurveManglerOp(bpy.types.Operator):
-    """Mangle a curve to the degree the user specifies"""
-    bl_idname = "ba.curve_mangler"
-    bl_label = "Mangle Curve"
-    bl_options = { 'REGISTER', 'UNDO' }
-
-    @classmethod
-    def poll(cls, context):
-        ob = context.active_object
-        return ob != None and ob.type == "CURVE"
-
-
-    def execute(self, context):
-
-        ob = context.active_object
-        if ob.data.shape_keys != None:
-            self.report({'INFO'}, "Cannot mangle curve.  Shape keys present")
-            return {'CANCELLED'}
-        splines = context.object.data.splines
-
-        for spline in splines:
-            if spline.type == 'BEZIER':
-                points = spline.bezier_points
-            elif spline.type in {'POLY', 'NURBS'}:
-                points = spline.points
-
-            for point in points:
-                move_coordinate(context, point.co, is_curve=True)
-
-        return {'FINISHED'}
-
-
-class MangleToolsPanel(bpy.types.Panel):
-    bl_label = "Mangle Tools"
-    bl_space_type = "VIEW_3D"
-    bl_context = "objectmode"
-    bl_region_type="TOOLS"
-    bl_category = "Tools"
-    bl_options = {'DEFAULT_CLOSED'}
-
-
-    def draw(self, context):
-        scn = context.scene
-        layout = self.layout
-        col = layout.column()
-        col.prop(scn, "constraint_vector")
-        col.prop(scn, "random_magnitude")
-
-        col.operator("ba.curve_mangler")
-        col.operator("ba.mesh_mangler")
-        col.separator()
-        col.prop(scn, "mangle_name")
-        col.operator("ba.ani_mangler")
-
-
-IntProperty = bpy.props.IntProperty
-StringProperty = bpy.props.StringProperty
-BoolVectorProperty = bpy.props.BoolVectorProperty
-
-def register():
-    bpy.utils.register_class(AnimanglerOperator)
-    bpy.utils.register_class(MeshManglerOperator)
-    bpy.utils.register_class(CurveManglerOp)
-    bpy.utils.register_class(MangleToolsPanel)
-    scnType = bpy.types.Scene
-
-
-    scnType.constraint_vector = BoolVectorProperty(name="Mangle Constraint",
-                                default=(True,True,True),
-                                subtype='XYZ',
-                                description="Constrains Mangle Direction")
-
-    scnType.random_magnitude = IntProperty( name = "Mangle Severity",
-                              default = 10, min = 1, max = 30,
-                              description = "Severity of mangling")
-
-    scnType.mangle_name = StringProperty(name="Shape Key Name",
-                             default="mangle",
-                             description="Name given for mangled shape keys")
-def unregister():
-    bpy.utils.unregister_class(AnimanglerOperator)
-    bpy.utils.unregister_class(MeshManglerOperator)
-    bpy.utils.unregister_class(MangleToolsPanel)
-    bpy.utils.unregister_class(CurveManglerOp)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/space_view3d_arrange_on_curve.py b/space_view3d_arrange_on_curve.py
deleted file mode 100644 (file)
index 3ee9ddb..0000000
+++ /dev/null
@@ -1,311 +0,0 @@
-bl_info = {
-    "name": "Arrange on Curve",
-    "author": "Mano-Wii",
-    "version": (6, 3, 0),
-    "blender": (2, 7, 7),
-    "location": "View3D > TOOLS > Mano-Wii > Dist_Mano",
-    "description": "Arrange objects along a curve",
-    "warning": "Select curve",
-    "wiki_url" : "http://blenderartists.org/forum/showthread.php?361029-Specify-an-object-from-a-list-with-all-selectable-objects",
-    "tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
-    "category": "3D View"
-    }
-
-import bpy, mathutils
-
-FLT_MIN = 0.004
-
-class PanelDupliCurve(bpy.types.Panel) :
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_context = "objectmode"
-    bl_category = "Tools"
-    bl_label = "Duplicate on curve"
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.mode == 'OBJECT' and context.object.type == 'CURVE'
-
-    def draw(self, context) :
-        layout = self.layout
-        layout.prop(context.scene, "use_selected")
-        if not context.scene.use_selected:
-            layout.prop(context.scene, "select_type", expand=True)
-            if context.scene.select_type == 'O':
-                layout.column(align = True).prop_search(context.scene, "objeto_arranjar", bpy.data, "objects")
-            elif context.scene.select_type == 'G':
-                layout.column(align = True).prop_search(context.scene, "objeto_arranjar", bpy.data, "groups")
-        if context.object.type == 'CURVE':
-            layout.operator("object.arranjar_numa_curva", text = "Arrange Objects")
-
-class DupliCurve(bpy.types.Operator):
-    bl_idname = "object.arranjar_numa_curva"
-    bl_label = "Arrange Objects"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    use_distance = bpy.props.EnumProperty(
-        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 = bpy.props.FloatProperty(
-        name = "Distance",
-        description = "Distancia entre objetos",
-        default = 1.0,
-        min = FLT_MIN,
-        soft_min = 0.1,
-        unit='LENGTH',
-      )
-
-    object_qt = bpy.props.IntProperty(
-        name = "Quantity",
-        description = "Object amount.",
-        default = 2,
-        min = 0,
-      )
-
-    scale = bpy.props.FloatProperty(
-        name = "Scale",
-        description = "Object Scale",
-        default = 1.0,
-        min = FLT_MIN,
-        unit='LENGTH',
-      )
-
-    Yaw = bpy.props.FloatProperty(default=0.0,name="X", unit='ROTATION')
-    Pitch = bpy.props.FloatProperty(default=0.0,name="Y", unit='ROTATION')
-    Roll = bpy.props.FloatProperty(default=0.0,name="Z", unit='ROTATION')
-
-    max_angle = bpy.props.FloatProperty(default = 1.57079, max = 3.141592, name="Angle", unit='ROTATION')
-    offset = bpy.props.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(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)
-
-        if context.scene.use_selected:
-            G_Objeto = context.selected_objects
-            G_Objeto.remove(curve)
-            if not G_Objeto:
-                return {'CANCELLED'}
-        elif context.scene.select_type == 'O':
-            G_Objeto = bpy.data.objects[context.scene.objeto_arranjar],
-        elif context.scene.select_type == 'G':
-            G_Objeto = bpy.data.groups[context.scene.objeto_arranjar].objects
-        #qt = 0 #(To see in System Console)
-        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
-
-        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.scene.objects.link(obj)
-                            obj.matrix_world = quat*yawMatrix*pitchMatrix*rollMatrix
-                            obj.matrix_world.translation = point - v_norm*dx # Putting in the correct position
-                            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
-                    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.scene.objects.link(obj)
-                            obj.matrix_world = quat*yawMatrix*pitchMatrix*rollMatrix
-                            obj.matrix_world.translation = point - v_norm*dx # Putting in the correct position
-                            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
-                #leng += FLT_MIN
-                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
-                    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
-                        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.scene.objects.link(obj)
-                            obj.matrix_world = quat*yawMatrix*pitchMatrix*rollMatrix
-                            obj.matrix_world.translation = point - v_norm*dx # Putting in the correct position
-                            obj.scale *= self.scale
-                        last_point = point
-
-        return {"FINISHED"}
-
-def register():
-    bpy.utils.register_module(__name__)
-    bpy.types.Scene.use_selected = bpy.props.BoolProperty(
-        name='Use Selected',
-        description='Use the selected objects to duplicate',
-        default=True,
-        )
-    bpy.types.Scene.objeto_arranjar = bpy.props.StringProperty(name="")
-    bpy.types.Scene.select_type = bpy.props.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 unregister() :
-    bpy.utils.unregister_module(__name__)
-    del bpy.types.Scene.objeto_arranjar
-    del bpy.types.Scene.use_selected
-    del bpy.types.Scene.select_type
-
-if __name__ == "__main__" :
-    register()