np_point_array.py

# ##### 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 #####

'''

DESCRIPTION:

Makes a copy (duplicate) of objects using snap points. Emulates the functionality of the standard 'copy' command in CAD applications, with vertex snapping. Optionally, using selected objects and last distance used, makes an array of selected objects.


INSTALLATION:

Unzip and place .py file to scripts / addons_contrib folder. In User Preferences / Addons tab, search with Testing filter - NP Point Copy and check the box.
Now you have the operator in your system. If you press Save User Preferences, you will have it at your disposal every time you run Blender.


SHORTCUTS:

After successful installation of the addon, the NP Point Copy operator should be registered in your system. Enter User Preferences / Input, and under that, 3DView / Object mode. At the bottom of the list click the 'Add new' button. In the operator field type object.np_point_copy_xxx (xxx being the number of the version) and assign a shortcut key of your preference. At the moment i am using 'C' for 'copy', as in standard CAD applications. I rarely use circle selection so letter 'C' is free.


USAGE:

You can run the operator with spacebar search - NP Point Copy, or shortcut key if you assigned it.
Select a point anywhere in the scene (holding CTRL enables snapping). This will be your 'take' point.
Move your mouse and click to a point anywhere in the scene with the left mouse button (LMB), in relation to the 'take' point and the operator will duplicate the selected objects at that position (again CTRL - snap enables snapping to objects around the scene). You can continue duplicating objects in the same way. When you want to finish the process, press ESC or RMB. If you want to make an array of the copied objects in relation to the last pair, press the 'ENTER' button (ENT). The command will automatically read the direction and the distance between the last pair of copied objects and present an interface to specify the number of arrayed copies. You specify the number with CTRL + mouse scroll, with the possibility to go below the amount of 2 which changes the mode of array to division.  You confirm the array with RMB / ENTER / TAB key or cancel it with ESC. Pressing RMB at the end will confirm the array and keep it as a modifier in the modifier stack, ENTER will apply the modifier as a single object and remove the modifier, while TAB would apply the modifier as an array of separate individual objects and remove the modifier from the modifier stack.
If at any point you lose sight of the next point you want to snap to, you can press SPACE to go to NAVIGATION mode in which you can change the point of view. When your next point is clearly in your field of view, you return to normal mode by pressing SPACE again or LMB.
Middle mouse button (MMB) enables axis constraint during snapping, while numpad keys enable numerical input for the copy distance.


ADDON SETTINGS:

Below the addon name in the user preferences / addon tab, you can find a couple of settings that control the behavior of the addon:

Unit scale: Distance multiplier for various unit scenarios
Suffix: Unit abbreviation after the numerical distance
Custom colors: Default or custom colors for graphical elements
Mouse badge: Option to display a small cursor label


IMPORTANT PERFORMANCE NOTES:

None so far.

'''

bl_info = {
    'name':'NP 020 Point Array',
    'author':'Okavango & the Blenderartists community',
    'version': (0, 2, 0),
    'blender': (2, 75, 0),
    'location': 'View3D',
    'warning': '',
    'description': 'Makes a directional array of selected objects using "take" and "place" snap points',
    'doc_url': '',
    'category': '3D View'}

import bpy
import copy
import bmesh
import bgl
import blf
import mathutils
from bpy_extras import view3d_utils
from bpy.app.handlers import persistent
from mathutils import Vector, Matrix
from blf import ROTATION
from math import radians
from bpy.props import *

from .utils_geometry import *
from .utils_graphics import *
from .utils_function import *

# Defining the main class - the macro:

class NP020PointArray(bpy.types.Macro):
    bl_idname = 'object.np_020_point_array'
    bl_label = 'NP 020 Point Array'
    bl_options = {'UNDO'}


# Defining the storage class that will serve as a variable bank for exchange among the classes. Later, this bank will receive more variables with their values for safe keeping, as the program goes on:

class NP020PA:

    take = None
    place = None
    takeloc3d = (0.0,0.0,0.0)
    placeloc3d = (0.0,0.0,0.0)
    dist = None
    mode = 'MOVE'
    flag = 'NONE'
    deltavec = Vector ((0, 0, 0))
    deltavec_safe = Vector ((0, 0, 0))
    prevob = None
    nextob = None

# Defining the scene update algorithm that will track the state of the objects during modal transforms, which is otherwise impossible:

@persistent
def NPPA_scene_update(context):

    #np_print('00_SceneUpdate_START')
    if bpy.data.objects.is_updated:
        np_print('NPPA_update1')
        mode = NP020PA.mode
        flag = NP020PA.flag
        #np_print(mode, flag)
        take = NP020PA.take
        place = NP020PA.place
        if flag in ('RUNTRANSZERO', 'RUNTRANSFIRST','RUNTRANSNEXT', 'NAVTRANSZERO', 'NAVTRANSFIRST', 'NAVTRANSNEXT'):
            np_print('NPPA_update2')
            NP020PA.takeloc3d = take.location
            NP020PA.placeloc3d = place.location
    #np_print('up3')
    #np_print('00_SceneUpdate_FINISHED')


# Defining the first of the classes from the macro, that will gather the current system settings set by the user. Some of the system settings will be changed during the process, and will be restored when macro has completed.

class NPPAGetContext(bpy.types.Operator):
    bl_idname = 'object.np_pa_get_context'
    bl_label = 'NP PA Get Context'
    bl_options = {'INTERNAL'}

    def execute(self, context):
        if bpy.context.selected_objects == []:
            self.report({'WARNING'}, "Please select objects first")
            return {'CANCELLED'}
        NP020PA.use_snap = copy.deepcopy(bpy.context.tool_settings.use_snap)
        NP020PA.snap_element = copy.deepcopy(bpy.context.tool_settings.snap_element)
        NP020PA.snap_target = copy.deepcopy(bpy.context.tool_settings.snap_target)
        NP020PA.pivot_point = copy.deepcopy(bpy.context.space_data.pivot_point)
        NP020PA.trans_orient = copy.deepcopy(bpy.context.space_data.transform_orientation)
        NP020PA.curloc = copy.deepcopy(bpy.context.scene.cursor.location)
        NP020PA.acob = bpy.context.active_object
        if bpy.context.mode == 'OBJECT':
            NP020PA.edit_mode = 'OBJECT'
        elif bpy.context.mode in ('EDIT_MESH', 'EDIT_CURVE', 'EDIT_SURFACE', 'EDIT_TEXT', 'EDIT_ARMATURE', 'EDIT_METABALL', 'EDIT_LATTICE'):
            NP020PA.edit_mode = 'EDIT'
        elif bpy.context.mode == 'POSE':
            NP020PA.edit_mode = 'POSE'
        elif bpy.context.mode == 'SCULPT':
            NP020PA.edit_mode = 'SCULPT'
        elif bpy.context.mode == 'PAINT_WEIGHT':
            NP020PA.edit_mode = 'WEIGHT_PAINT'
        elif bpy.context.mode == 'PAINT_TEXTURE':
            NP020PA.edit_mode = 'TEXTURE_PAINT'
        elif bpy.context.mode == 'PAINT_VERTEX':
            NP020PA.edit_mode = 'VERTEX_PAINT'
        elif bpy.context.mode == 'PARTICLE':
            NP020PA.edit_mode = 'PARTICLE_EDIT'
        return {'FINISHED'}
        # Changing to OBJECT mode which will be the context for the procedure:
        if bpy.context.mode not in ('OBJECT'):
            bpy.ops.object.mode_set(mode = 'OBJECT')
        # De-selecting objects in prepare for other processes in the script:
        bpy.ops.object.select_all(action = 'DESELECT')
        np_print('01_ReadContext_FINISHED', ';', 'flag = ', NP020PA.flag)
        return {'FINISHED'}


# Defining the operator for aquiring the list of selected objects and storing them for later re-calls:

class NPPAGetSelection(bpy.types.Operator):
    bl_idname = 'object.np_pa_get_selection'
    bl_label = 'NP PA Get Selection'
    bl_options = {'INTERNAL'}

    def execute(self, context):
        # Reading and storing the selection:
        NP020PA.selob = bpy.context.selected_objects
        return {'FINISHED'}


# Defining the operator that will read the mouse position in 3D when the command is activated and store it as a location for placing the 'take' and 'place' points under the mouse:

class NPPAGetMouseloc(bpy.types.Operator):
    bl_idname = 'object.np_pa_get_mouseloc'
    bl_label = 'NP PA Get Mouseloc'
    bl_options = {'INTERNAL'}