# ##### 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 Copy', 'author':'Okavango & the Blenderartists community', 'version': (0, 2, 0), 'blender': (2, 75, 0), 'location': 'View3D', 'warning': '', 'description': 'Duplicates 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 NP020PointCopy(bpy.types.Macro): bl_idname = 'object.np_020_point_copy' bl_label = 'NP 020 Point Copy' 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 NP020PC: 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)) # Defining the scene update algorithm that will track the state of the objects during modal transforms, which is otherwise impossible: @persistent def NPPC_scene_update(context): #np_print('00_SceneUpdate_START') if bpy.data.objects.is_updated: np_print('NPPC_update1') mode = NP020PC.mode flag = NP020PC.flag #np_print(mode, flag) take = NP020PC.take place = NP020PC.place if flag in ('RUNTRANSZERO', 'RUNTRANSFIRST','RUNTRANSNEXT', 'NAVTRANSZERO', 'NAVTRANSFIRST', 'NAVTRANSNEXT'): np_print('NPPC_update2') NP020PC.takeloc3d = take.location NP020PC.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 NPPCGetContext(bpy.types.Operator): bl_idname = 'object.np_pc_get_context' bl_label = 'NP PC Get Context' bl_options = {'INTERNAL'} def execute(self, context): if bpy.context.selected_objects == []: self.report({'WARNING'}, "Please select objects first") return {'CANCELLED'} NP020PC.use_snap = copy.deepcopy(bpy.context.tool_settings.use_snap) NP020PC.snap_element = copy.deepcopy(bpy.context.tool_settings.snap_element) NP020PC.snap_target = copy.deepcopy(bpy.context.tool_settings.snap_target) NP020PC.pivot_point = copy.deepcopy(bpy.context.space_data.pivot_point) NP020PC.trans_orient = copy.deepcopy(bpy.context.space_data.transform_orientation) NP020PC.curloc = copy.deepcopy(bpy.context.scene.cursor.location) NP020PC.acob = bpy.context.active_object if bpy.context.mode == 'OBJECT': NP020PC.edit_mode = 'OBJECT' elif bpy.context.mode in ('EDIT_MESH', 'EDIT_CURVE', 'EDIT_SURFACE', 'EDIT_TEXT', 'EDIT_ARMATURE', 'EDIT_METABALL', 'EDIT_LATTICE'): NP020PC.edit_mode = 'EDIT' elif bpy.context.mode == 'POSE': NP020PC.edit_mode = 'POSE' elif bpy.context.mode == 'SCULPT': NP020PC.edit_mode = 'SCULPT' elif bpy.context.mode == 'PAINT_WEIGHT': NP020PC.edit_mode = 'WEIGHT_PAINT' elif bpy.context.mode == 'PAINT_TEXTURE': NP020PC.edit_mode = 'TEXTURE_PAINT' elif bpy.context.mode == 'PAINT_VERTEX': NP020PC.edit_mode = 'VERTEX_PAINT' elif bpy.context.mode == 'PARTICLE': NP020PC.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 = ', NP020PC.flag) return {'FINISHED'} # Defining the operator for aquiring the list of selected objects and storing them for later re-calls: class NPPCGetSelection(bpy.types.Operator): bl_idname = 'object.np_pc_get_selection' bl_label = 'NP PC Get Selection' bl_options = {'INTERNAL'} def execute(self, context): # Reading and storing the selection: NP020PC.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 NPPCGetMouseloc(bpy.types.Operator): bl_idname = 'object.np_pc_get_mouseloc' bl_label = 'NP PC Get Mouseloc' bl_options = {'INTERNAL'} def modal(self, context, event): region = context.region rv3d = context.region_data co2d = ((event.mouse_region_x, event.mouse_region_y)) view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, co2d) enterloc = view3d_utils.region_2d_to_origin_3d(region, rv3d, co2d) + view_vector/5 NP020PC.enterloc = copy.deepcopy(enterloc) #np_print('02_RadMouseloc_FINISHED', ';', 'flag = ', NP020PC.flag) return{'FINISHED'} def invoke(self,context,event): args = (self,context) context.window_manager.modal_handler_add(self) #np_print('02_ReadMouseloc_INVOKED_FINISHED', ';', 'flag = ', NP020PC.flag) return {'RUNNING_MODAL'} # Defining the operator that will generate 'take' and 'place' points at the spot marked by mouse, preparing for translation: class NPPCAddHelpers(bpy.types.Operator): bl_idname = 'object.np_pc_add_helpers' bl_label = 'NP PC Add Helpers' bl_options = {'INTERNAL'} def execute(self, context): np_print('03_AddHelpers_START', ';', 'flag = ', NP020PC.flag) enterloc = NP020PC.enterloc bpy.ops.object.add(type = 'MESH',location = enterloc) take = bpy.context.active_object take.name = 'NP_PC_take' NP020PC.take = take bpy.ops.object.add(type = 'MESH',location = enterloc) place = bpy.context.active_object place.name = 'NP_PC_place' NP020PC.place = place return{'FINISHED'} # Defining the operator that will change some of the system settings and prepare objects for the operation: class NPPCPrepareContext(bpy.types.Operator): bl_idname = 'object.np_pc_prepare_context' bl_label = 'NP PC Prepare Context' bl_options = {'INTERNAL'} def execute(self, context): take = NP020PC.take place = NP020PC.place take.select_set(True) place.select_set(True) bpy.context.view_layer.objects.active = place bpy.context.tool_settings.use_snap = False bpy.context.tool_settings.snap_element = 'VERTEX' bpy.context.tool_settings.snap_target = 'ACTIVE' bpy.context.space_data.pivot_point = 'ACTIVE_ELEMENT' bpy.context.space_data.transform_orientation = 'GLOBAL' NP020PC.flag = 'RUNTRANSZERO' return{'FINISHED'} # Defining the operator that will let the user translate take and place points to the desired 'take' location. It also uses some listening operators that clean up the leftovers should the user interrupt the command. Many thanks to CoDEmanX and lukas_t: class NPPCRunTranslate(bpy.types.Operator): bl_idname = 'object.np_pc_run_translate' bl_label = 'NP PC Run Translate' bl_options = {'INTERNAL'} #np_print('04_RunTrans_START',';','NP020PC.flag = ', NP020PC.flag) count = 0 def modal(self,context,event): context.area.tag_redraw() flag = NP020PC.flag take = NP020PC.take place = NP020PC.place selob = NP020PC.selob self.count += 1 if self.count == 1: bpy.ops.transform.translate('INVOKE_DEFAULT') np_print('04_RunTrans_count_1_INVOKE_DEFAULT', ';', 'flag = ', NP020PC.flag) elif event.type in ('LEFTMOUSE','RET','NUMPAD_ENTER') and event.value == 'RELEASE': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') if flag == 'RUNTRANSZERO': take.select_set(False) place.select_set(False) NP020PC.firsttake3d = copy.deepcopy(take.location) for ob in selob: ob.select_set(True) bpy.ops.object.duplicate() NP020PC.nextob = bpy.context.selected_objects NP020PC.prevob = selob place.select_set(True) NP020PC.flag = 'RUNTRANSFIRST_break' elif flag == 'RUNTRANSFIRST': NP020PC.deltavec_safe = copy.deepcopy(NP020PC.deltavec) np_print('deltavec_safe = ', NP020PC.deltavec_safe) NP020PC.ar13d = copy.deepcopy(take.location) NP020PC.ar23d = copy.deepcopy(place.location) place.select_set(False) bpy.ops.object.duplicate() prevob = NP020PC.prevob nextob = NP020PC.nextob NP020PC.arob = prevob NP020PC.prevob = nextob NP020PC.nextob = bpy.context.selected_objects NP020PC.selob = nextob take.location = copy.deepcopy(place.location) place.select_set(True) NP020PC.flag = 'RUNTRANSNEXT_break' elif flag == 'RUNTRANSNEXT': NP020PC.deltavec_safe = copy.deepcopy(NP020PC.deltavec) np_print('deltavec_safe = ', NP020PC.deltavec_safe) NP020PC.ar13d = copy.deepcopy(take.location) NP020PC.ar23d = copy.deepcopy(place.location) place.select_set(False) bpy.ops.object.duplicate() prevob = NP020PC.prevob nextob = NP020PC.nextob NP020PC.arob = prevob NP020PC.prevob = nextob NP020PC.nextob = bpy.context.selected_objects NP020PC.selob = nextob take.location = copy.deepcopy(place.location) place.select_set(True) NP020PC.flag = 'RUNTRANSNEXT_break' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04_RunTrans_left_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'SPACE' and event.value == 'RELEASE': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') take.hide = True place.hide = True self.co2d = ((event.mouse_region_x, event.mouse_region_y)) co2d = self.co2d region = context.region rv3d = context.region_data away = view3d_utils.region_2d_to_origin_3d(region, rv3d, co2d) - place.location away = away.length placeloc3d = NP020PC.placeloc3d awayloc = copy.deepcopy(placeloc3d) NP020PC.awayloc = awayloc NP020PC.away = copy.deepcopy(away) if flag == 'RUNTRANSZERO': NP020PC.flag = 'NAVTRANSZERO' elif flag == 'RUNTRANSFIRST': nextob = NP020PC.nextob for ob in nextob: ob.hide = True NP020PC.flag = 'NAVTRANSFIRST' elif flag == 'RUNTRANSNEXT': nextob = NP020PC.nextob for ob in nextob: ob.hide = True NP020PC.flag = 'NAVTRANSNEXT' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04_RunTrans_space_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'RIGHTMOUSE': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') if flag == 'RUNTRANSZERO': NP020PC.flag = 'EXIT' elif flag == 'RUNTRANSFIRST': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob bpy.ops.object.delete('EXEC_DEFAULT') for ob in nextob: ob.select_set(True) NP020PC.selob = prevob NP020PC.flag = 'EXIT' elif flag == 'RUNTRANSNEXT': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob bpy.ops.object.delete('EXEC_DEFAULT') for ob in nextob: ob.select_set(True) NP020PC.selob = prevob NP020PC.flag = 'EXIT' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04_RunTrans_rmb_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'ESC': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') if flag == 'RUNTRANSZERO': NP020PC.flag = 'EXIT' elif flag == 'RUNTRANSFIRST': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) NP020PC.flag = 'EXIT' elif flag == 'RUNTRANSNEXT': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob NP020PC.selob = prevob bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) NP020PC.flag = 'EXIT' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04_RunTrans_rmb_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} np_print('04_RunTrans_count_PASS_THROUGH',';','flag = ', NP020PC.flag) return{'PASS_THROUGH'} def invoke(self, context, event): #np_print('04_RunTrans_INVOKE_START') flag = NP020PC.flag selob = NP020PC.selob #np_print('flag = ', flag) if context.area.type == 'VIEW_3D': if flag in ('RUNTRANSZERO', 'RUNTRANSFIRST', 'RUNTRANSNEXT'): args = (self, context) self._handle = bpy.types.SpaceView3D.draw_handler_add(DRAW_RunTranslate, args, 'WINDOW', 'POST_PIXEL') context.window_manager.modal_handler_add(self) np_print('04_RunTrans_INVOKED_RUNNING_MODAL',';','flag = ', NP020PC.flag) return {'RUNNING_MODAL'} else: #np_print('04_RunTrans_INVOKE_DECLINED_FINISHED',';','flag = ', flag) return {'FINISHED'} else: self.report({'WARNING'}, "View3D not found, cannot run operator") flag = 'WARNING3D' NP020PC.flag = flag np_print('04_RunTrans_INVOKE_DECLINED_FINISHED',';','flag = ', NP020PC.flag) return {'CANCELLED'} # Defining the set of instructions that will draw the OpenGL elements on the screen during the execution of RunTranslate operator: def DRAW_RunTranslate(self, context): np_print('04_DRAW_RunTrans_START',';','flag = ', NP020PC.flag) addon_prefs = context.preferences.addons[__package__].preferences flag = NP020PC.flag takeloc3d = NP020PC.takeloc3d placeloc3d = NP020PC.placeloc3d region = context.region rv3d = context.region_data if flag in ('RUNTRANSZERO', 'RUNTRANSFIRST', 'RUNTRANSNEXT'): takeloc2d = view3d_utils.location_3d_to_region_2d(region, rv3d, takeloc3d) placeloc2d = view3d_utils.location_3d_to_region_2d(region, rv3d, placeloc3d) if flag == 'NAVTRANSZERO': takeloc2d = self.co2d placeloc2d = self.co2d if flag in ('NAVTRANSFIRST', 'NAVTRANSNEXT'): takeloc2d = view3d_utils.location_3d_to_region_2d(region, rv3d, takeloc3d) placeloc2d = self.co2d ''' if flag in ('RUNTRANSNEXT', 'NAVTRANSNEXT'): ardist_num = NP020PC.ar23d - NP020PC.ar13d ardist_num = ardist_num.length * dist_scale ar12d = view3d_utils.location_3d_to_region_2d(region, rv3d, NP020PC.ar13d) ar22d = view3d_utils.location_3d_to_region_2d(region, rv3d, NP020PC.ar23d) ardist_num = abs(round(ardist_num,2)) if suffix is not None: ardist = str(ardist_num)+suffix else: ardist = str(ardist_num) NP020PC.ardist = ardist ardist_loc = (ar12d + ar22d) /2 ''' # DRAWING START: bgl.glEnable(bgl.GL_BLEND) if flag == 'RUNTRANSZERO': instruct = 'select the take point' keys_aff = 'LMB - confirm, CTRL - snap, MMB - lock axis, NUMPAD - value' keys_nav = 'SPACE - navigate' keys_neg = 'ESC / RMB - cancel copy' badge_mode = 'RUN' message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'RUNTRANSFIRST': instruct = 'select the placement point' keys_aff = 'LMB - confirm, CTRL - snap, MMB - lock axis, NUMPAD - value' keys_nav = 'SPACE - navigate' keys_neg = 'ESC / RMB - cancel copy' badge_mode = 'RUN' message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'RUNTRANSNEXT': instruct = 'select the placement point' keys_aff = 'LMB - confirm, CTRL - snap, MMB - lock axis, NUMPAD - value' keys_nav = 'SPACE - navigate' keys_neg = 'ESC / RMB - cancel current' badge_mode = 'RUN' message_main = 'CTRL+SNAP' message_aux = None aux_num = None aux_str = None elif flag == 'NAVTRANSZERO': instruct = 'navigate for better placement of take point' keys_aff = 'MMB / SCROLL - navigate' keys_nav = 'LMB / SPACE - leave navigate' keys_neg = 'ESC / RMB - cancel copy' badge_mode = 'NAV' message_main = 'NAVIGATE' message_aux = None aux_num = None aux_str = None elif flag == 'NAVTRANSFIRST': instruct = 'navigate for better selection of placement point' keys_aff = 'MMB / SCROLL - navigate' keys_nav = 'LMB / SPACE - leave navigate' keys_neg = 'ESC / RMB - cancel copy' badge_mode = 'NAV' message_main = 'NAVIGATE' message_aux = None aux_num = None aux_str = None elif flag == 'NAVTRANSNEXT': instruct = 'navigate for better selection of placement point' keys_aff = 'MMB / SCROLL - navigate' keys_nav = 'LMB / SPACE - leave navigate' keys_neg = 'ESC / RMB - cancel current' badge_mode = 'NAV' message_main = 'NAVIGATE' message_aux = None aux_num = None aux_str = None # ON-SCREEN INSTRUCTIONS: display_instructions(region, rv3d, instruct, keys_aff, keys_nav, keys_neg) # MOUSE BADGE: co2d = placeloc2d symbol = [[23, 34], [23, 32], [19, 32], [19, 36], [21, 36], [21, 38], [25, 38], [25, 34], [23, 34], [23, 36], [21, 36]] display_cursor_badge(co2d, symbol, badge_mode, message_main, message_aux, aux_num, aux_str) # LINE: display_line_between_two_points(region, rv3d, takeloc3d, placeloc3d) # DISTANCE: display_distance_between_two_points(region, rv3d, takeloc3d, placeloc3d) NP020PC.deltavec = copy.deepcopy(display_distance_between_two_points(region, rv3d, takeloc3d, placeloc3d)[0]) #DRAWING END: bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) np_print('04_DRAW_RunTrans_FINISHED',';','flag = ', NP020PC.flag) # Defining the operator that will enable navigation if user calls it: class NPPCNavTranslate(bpy.types.Operator): bl_idname = "object.np_pc_nav_translate" bl_label = "NP PC Nav Translate" bl_options = {'INTERNAL'} np_print('04a_NavTrans_START',';','flag = ', NP020PC.flag) def modal(self,context,event): context.area.tag_redraw() flag = NP020PC.flag take = NP020PC.take place = NP020PC.place if event.type == 'MOUSEMOVE': self.co2d = ((event.mouse_region_x, event.mouse_region_y)) region = context.region rv3d = context.region_data co2d = self.co2d view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, co2d) pointloc = view3d_utils.region_2d_to_origin_3d(region, rv3d, co2d) + view_vector * NP020PC.away NP020PC.placeloc3d = copy.deepcopy(pointloc) np_print('04a_NavTrans_mousemove',';','flag = ', NP020PC.flag) elif event.type in {'LEFTMOUSE', 'SPACE'} and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') self.co2d = ((event.mouse_region_x, event.mouse_region_y)) region = context.region rv3d = context.region_data co2d = self.co2d view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, co2d) enterloc = view3d_utils.region_2d_to_origin_3d(region, rv3d, co2d) + view_vector*NP020PC.away placeloc3d = NP020PC.placeloc3d navdelta = enterloc - NP020PC.awayloc take.hide = False place.hide = False np_print('flag = ', flag) if flag == 'NAVTRANSZERO': takeloc3d = enterloc placeloc3d = enterloc take.location = enterloc place.location = enterloc NP020PC.flag = 'RUNTRANSZERO' elif flag == 'NAVTRANSFIRST': takeloc3d = NP020PC.takeloc3d placeloc3d = enterloc place.location = enterloc nextob = NP020PC.nextob for ob in nextob: ob.hide = False place.select_set(False) bpy.ops.transform.translate(value = navdelta) place.select_set(True) NP020PC.flag = 'RUNTRANSFIRST' elif flag == 'NAVTRANSNEXT': takeloc3d = NP020PC.takeloc3d placeloc3d = enterloc place.location = enterloc nextob = NP020PC.nextob for ob in nextob: ob.hide = False place.select_set(False) bpy.ops.transform.translate(value = navdelta) place.select_set(True) NP020PC.flag = 'RUNTRANSNEXT' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' NP020PC.take = take NP020PC.place = place NP020PC.takeloc3d = takeloc3d NP020PC.placeloc3d = placeloc3d np_print('04a_NavTrans_left_space_FINISHED',';','flag = ', NP020PC.flag) return {'FINISHED'} elif event.type == 'RIGHTMOUSE': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') take.hide = False place.hide = False if flag == 'NAVTRANSZERO': place.select_set(False) NP020PC.flag = 'EXIT' elif flag == 'NAVTRANSFIRST': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob for ob in nextob: ob.hide = False bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) NP020PC.flag = 'EXIT' elif flag == 'NAVTRANSNEXT': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob for ob in nextob: ob.hide = False bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) bpy.ops.object.delete('EXEC_DEFAULT') NP020PC.flag = 'ARRAYTRANS' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04a_NavTrans_rmb_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'ESC': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') take.hide = False place.hide = False if flag == 'NAVTRANSZERO': place.select_set(False) NP020PC.flag = 'EXIT' elif flag == 'NAVTRANSFIRST': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob for ob in nextob: ob.hide = False bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) NP020PC.flag = 'EXIT' elif flag == 'NAVTRANSNEXT': place.select_set(False) prevob = NP020PC.prevob nextob = NP020PC.nextob NP020PC.selob = prevob for ob in nextob: ob.hide = False bpy.ops.object.delete('EXEC_DEFAULT') for ob in prevob: ob.select_set(True) NP020PC.flag = 'EXIT' else: np_print('UNKNOWN FLAG') NP020PC.flag = 'EXIT' np_print('04a_NavTrans_esc_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type in {'MIDDLEMOUSE', 'WHEELUPMOUSE', 'WHEELDOWNMOUSE'}: np_print('04a_NavTrans_middle_wheel_any_PASS_THROUGH') return {'PASS_THROUGH'} np_print('04a_NavTrans_INVOKED_RUNNING_MODAL',';','flag = ', NP020PC.flag) return {'RUNNING_MODAL'} def invoke(self, context, event): #np_print('04a_NavTrans_INVOKE_START') flag = NP020PC.flag #np_print('flag = ', flag) self.co2d = ((event.mouse_region_x, event.mouse_region_y)) if flag in ('NAVTRANSZERO', 'NAVTRANSFIRST', 'NAVTRANSNEXT'): args = (self, context) self._handle = bpy.types.SpaceView3D.draw_handler_add(DRAW_RunTranslate, args, 'WINDOW', 'POST_PIXEL') context.window_manager.modal_handler_add(self) np_print('04a_run_NAV_INVOKE_a_RUNNING_MODAL',';','flag = ', NP020PC.flag) return {'RUNNING_MODAL'} else: #np_print('04a_run_NAV_INVOKE_a_FINISHED',';','flag = ', flag) return {'FINISHED'} # Defining the operator that will enable the return to RunTrans cycle by reseting the 'break' flag: class NPPCPrepareNext(bpy.types.Operator): bl_idname = 'object.np_pc_prepare_next' bl_label = 'NP PC Prepare Next' bl_options = {'INTERNAL'} def execute(self, context): np_print('05_PrepareNext_START',';','flag = ', NP020PC.flag) if NP020PC.flag == 'RUNTRANSFIRST_break': NP020PC.flag = 'RUNTRANSFIRST' if NP020PC.flag == 'RUNTRANSNEXT_break': NP020PC.flag = 'RUNTRANSNEXT' np_print('05_PrepareNext_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} ''' # Defining the operator that will collect the necessary data and the generate the array with an input dialogue for number of items: class NPPCArrayTranslate(bpy.types.Operator): bl_idname = "object.np_pc_array_translate" bl_label = "NP PC Array Translate" bl_options = {'INTERNAL'} np_print('06_ArrayTrans_START',';','flag = ', NP020PC.flag) def modal(self,context,event): np_print('06_ArrayTrans_START',';','flag = ', NP020PC.flag) context.area.tag_redraw() flag = NP020PC.flag ardict = NP020PC.ardict arob = NP020PC.arob np_print('ardict = ', ardict) if event.type == 'MOUSEMOVE': self.co2d = ((event.mouse_region_x, event.mouse_region_y)) np_print('04a_NavTrans_mousemove',';','flag = ', NP020PC.flag) elif event.type in ('LEFTMOUSE', 'RIGHTMOUSE') and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') NP020PC.flag = 'EXIT' np_print('06_ArrayTrans_rmb_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.ctrl and event.type == 'WHEELUPMOUSE' or event.type == 'UP_ARROW' and event.value == 'PRESS': for ob in arob: ar = ardict[ob][0] deltavec_start = Vector(ardict[ob][1]) count = ardict[ob][2] if ar.fit_type == 'FIXED_COUNT': ar.count = ar.count+1 count = count + 1 elif ar.fit_type == 'FIT_LENGTH' and count == 3: ar.fit_type = 'FIXED_COUNT' ar.constant_offset_displace = deltavec_start ar.count = 2 count = 2 elif ar.fit_type == 'FIT_LENGTH' and count >3: count = count - 1 ar.constant_offset_displace.length = ar.fit_length/(count-1) ardict[ob][2] = count NP020PC.fit_type = ar.fit_type NP020PC.count = count bpy.context.view_layer.update() elif event.ctrl and event.type == 'WHEELDOWNMOUSE' or event.type == 'DOWN_ARROW' and event.value == 'PRESS': for ob in arob: ar = ardict[ob][0] deltavec_start = Vector(ardict[ob][1]) count = ardict[ob][2] if ar.fit_type == 'FIXED_COUNT' and count > 2: ar.count = ar.count-1 count = count - 1 elif ar.fit_type == 'FIXED_COUNT' and count == 2: ar.fit_type = 'FIT_LENGTH' ar.fit_length = deltavec_start.length ar.constant_offset_displace.length = ar.fit_length/2 count = 3 elif ar.fit_type == 'FIT_LENGTH': count = count + 1 ar.constant_offset_displace.length = ar.fit_length/(count-1) ardict[ob][2] = count NP020PC.fit_type = ar.fit_type NP020PC.count = count bpy.context.view_layer.update() elif event.type in ('RET', 'NUMPAD_ENTER') and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') selob = bpy.context.selected_objects bpy.ops.object.select_all(action='DESELECT') for ob in arob: ob.select = True bpy.ops.object.modifier_apply(modifier = ardict[ob][0].name) ob.select = False for ob in selob: ob.select = True NP020PC.flag = 'EXIT' np_print('06_ArrayTrans_enter_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.ctrl and event.type == 'TAB' and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') if NP020PC.fit_type == 'FIXED_COUNT': value = NP020PC.ar23d - NP020PC.ar13d else: value = (NP020PC.ar23d - NP020PC.ar13d)/(NP020PC.count - 1) selob = bpy.context.selected_objects bpy.ops.object.select_all(action='DESELECT') for ob in arob: ob.select = True ob.modifiers.remove(ardict[ob][0]) np_print('NP020PC.count', NP020PC.count) for i in range(1, NP020PC.count): bpy.ops.object.duplicate(linked = True) bpy.ops.transform.translate(value = value) bpy.ops.object.select_all(action='DESELECT') for ob in selob: ob.select = True NP020PC.flag = 'EXIT' np_print('06_ArrayTrans_ctrl_tab_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'TAB' and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') if NP020PC.fit_type == 'FIXED_COUNT': value = NP020PC.ar23d - NP020PC.ar13d else: value = (NP020PC.ar23d - NP020PC.ar13d)/(NP020PC.count - 1) selob = bpy.context.selected_objects bpy.ops.object.select_all(action='DESELECT') for ob in arob: ob.select = True ob.modifiers.remove(ardict[ob][0]) np_print('NP020PC.count', NP020PC.count) for i in range(1, NP020PC.count): bpy.ops.object.duplicate() bpy.ops.transform.translate(value = value) bpy.ops.object.select_all(action='DESELECT') for ob in selob: ob.select = True NP020PC.flag = 'EXIT' np_print('06_ArrayTrans_tab_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type == 'ESC' and event.value == 'PRESS': bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW') for ob in arob: ob.modifiers.remove(ardict[ob][0]) NP020PC.flag = 'EXIT' np_print('06_ArrayTrans_esc_FINISHED',';','flag = ', NP020PC.flag) return{'FINISHED'} elif event.type in {'MIDDLEMOUSE', 'WHEELUPMOUSE', 'WHEELDOWNMOUSE'}: np_print('06_ArrayTrans_middle_wheel_any_PASS_THROUGH') return {'PASS_THROUGH'} np_print('06_ArrayTrans_INVOKED_RUNNING_MODAL',';','flag = ', NP020PC.flag) return {'RUNNING_MODAL'} def invoke(self, context, event): np_print('06_ArrayTrans_INVOKE_START') flag = NP020PC.flag self.co2d = ((event.mouse_region_x, event.mouse_region_y)) if flag == 'ARRAYTRANS': arob = NP020PC.arob np_print('deltavec_safe = ', NP020PC.deltavec_safe) ardict = {} for ob in arob: deltavec = copy.deepcopy(NP020PC.deltavec_safe) np_print('deltavec = ', deltavec) loc, rot, sca = ob.matrix_world.decompose() rot = ob.rotation_euler rot = rot.to_quaternion() sca = ob.scale np_print(loc, rot, sca, ob.matrix_world) np_print('deltavec = ', deltavec) deltavec.rotate(rot.conjugated()) np_print('sca.length', sca.length) deltavec[0] = deltavec[0] / sca[0] deltavec[1] = deltavec[1] / sca[1] deltavec[2] = deltavec[2] / sca[2] np_print('deltavec = ', deltavec) deltavec_trans = deltavec.to_tuple(4) arcur = ob.modifiers.new(name = '', type = 'ARRAY') arcur.fit_type = 'FIXED_COUNT' arcur.use_relative_offset = False arcur.use_constant_offset = True arcur.constant_offset_displace = deltavec_trans arcur.count = 5 ardict[ob] = [] ardict[ob].append(arcur) ardict[ob].append(deltavec_trans) ardict[ob].append(arcur.count) NP020PC.selob = arob NP020PC.ardict = ardict NP020PC.count = 5 NP020PC.fit_type = 'FIXED_COUNT' selob = NP020PC.selob lenselob = len(selob) for i, ob in enumerate(selob): ob.select = True if i == lenselob-1: bpy.context.scene.objects.active = ob args = (self, context) self._handle = bpy.types.SpaceView3D.draw_handler_add(DRAW_ArrayTrans, args, 'WINDOW', 'POST_PIXEL') context.window_manager.modal_handler_add(self) np_print('06_ArayTrans_INVOKE_a_RUNNING_MODAL',';','flag = ', NP020PC.flag) return {'RUNNING_MODAL'} else: np_print('06_ArrayTrans_INVOKE_DENIED',';','flag = ', NP020PC.flag) return {'FINISHED'} ''' ''' # Defining the set of instructions that will draw the OpenGL elements on the screen during the execution of ArrayTrans operator: def DRAW_ArrayTrans(self, context): np_print('06a_DRAW_ArrayTrans_START',';','flag = ', NP020PC.flag) addon_prefs = context.preferences.addons[__package__].preferences badge = addon_prefs.nppc_badge badge_size = addon_prefs.nppc_badge_size # DRAWING START: bgl.glEnable(bgl.GL_BLEND) # MOUSE BADGE: if badge == True: square = [[17, 30], [17, 40], [27, 40], [27, 30]] rectangle = [[27, 30], [27, 40], [67, 40], [67, 30]] icon = copy.deepcopy(NP020PC.icon) np_print('icon', icon) ipx = 29 ipy = 33 for co in square: co[0] = round((co[0] * badge_size),0) -(badge_size*10) + self.co2d[0] co[1] = round((co[1] * badge_size),0) -(badge_size*25) + self.co2d[1] for co in rectangle: co[0] = round((co[0] * badge_size),0) -(badge_size*10) + self.co2d[0] co[1] = round((co[1] * badge_size),0) -(badge_size*25) + self.co2d[1] for co in icon: co[0] = round((co[0] * badge_size),0) -(badge_size*10) + self.co2d[0] co[1] = round((co[1] * badge_size),0) -(badge_size*25) + self.co2d[1] ipx = round((ipx * badge_size),0) -(badge_size*10) + self.co2d[0] ipy = round((ipy * badge_size),0) -(badge_size*25) + self.co2d[1] ipsize = int(6* badge_size) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x,y in square: bgl.glVertex2f(x,y) bgl.glEnd() bgl.glColor4f(0.5, 0.75, 0.0, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x,y in rectangle: bgl.glVertex2f(x,y) bgl.glEnd() bgl.glColor4f(0.2, 0.15, 0.55, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x,y in rectangle: bgl.glVertex2f(x,(y-(badge_size*35))) bgl.glEnd() bgl.glColor4f(1.0, 1.0, 1.0, 1.0) font_id = 0 blf.position(font_id,ipx,ipy,0) blf.size(font_id,ipsize,72) blf.draw(font_id,'NAVIGATE') blf.position(font_id,ipx,(ipy-(badge_size*35)),0) blf.size(font_id,ipsize,72) blf.draw(font_id,'CTRL+SCRL') bgl.glColor4f(1,1,1,1) blf.position(font_id,ipx,(int(ipy-badge_size*25)),0) blf.size(font_id,(int(badge_size*24)),72) if NP020PC.fit_type == 'FIT_LENGTH': blf.draw(font_id,'/' + str(NP020PC.count)) else: blf.draw(font_id,str(NP020PC.count)) bgl.glColor4f(1.0, 1.0, 1.0, 1.0) bgl.glBegin(bgl.GL_LINE_STRIP) for x,y in icon: bgl.glVertex2f(x,y) bgl.glEnd() # ON-SCREEN INSTRUCTIONS: font_id = 0 bgl.glColor4f(1,1,1,0.35) blf.size(font_id,88,72) blf.position(font_id,5,74,0) blf.draw(font_id,'N') blf.size(font_id,28,72) blf.position(font_id,22,74,0) blf.draw(font_id,'P') blf.enable(font_id, ROTATION) bgl.glColor4f(1,1,1,0.40) ang = radians(90) blf.size(font_id,19,72) blf.rotation(font_id,ang) blf.position(font_id,78,73,0) blf.draw(font_id,'PC 002') blf.disable(font_id, ROTATION) main='SPECIFY NUMBER OF ITEMS IN ARRAY' bgl.glColor4f(0,0.5,0,1) blf.size(font_id,11,72) blf.position(font_id,93,105,0) blf.draw(font_id,'MMB, SCROLL - navigate') blf.position(font_id,93,90,0) blf.draw(font_id,'CTRL+SCROLL, UPARROW / DOWNARROW - number of items') blf.position(font_id,93,75,0) blf.draw(font_id,'LMB, RMB - confirm and keep array, ENTER - apply as one, TAB - apply as separate, CTRL+TAB - apply as instanced') bgl.glColor4f(1,0,0,1) blf.position(font_id,93,60,0) blf.draw(font_id,'ESC - cancel array') bgl.glColor4f(0.0, 0.0, 0.0, 0.5) blf.position(font_id,93,124,0) blf.size(font_id,16,72) blf.draw(font_id,main) bgl.glColor4f(1,1,1,1) blf.position(font_id,94,125,0) blf.size(font_id,16,72) blf.draw(font_id,main) region = context.region rv3d = context.region_data ar12d = view3d_utils.location_3d_to_region_2d(region, rv3d, NP020PC.ar13d) ar22d = view3d_utils.location_3d_to_region_2d(region, rv3d, NP020PC.ar23d) ardist = NP020PC.ardist ardist_loc = (ar12d + ar22d) /2 # ARMARKERS: markersize = badge_size*2.5 triangle = [[0, 0], [-1, 1], [1, 1]] triangle = [[0, 0], [-1, 1], [1, 1]] for co in triangle: co[0] = int(co[0] * markersize * 3) + ar12d[0] co[1] = int(co[1] * markersize * 3) + ar12d[1] bgl.glColor4f(0.4, 0.15, 0.75, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x,y in triangle: bgl.glVertex2f(x,y) bgl.glEnd() triangle = [[0, 0], [-1, 1], [1, 1]] for co in triangle: co[0] = int(co[0] * markersize * 3) + ar22d[0] co[1] = int(co[1] * markersize * 3) + ar22d[1] bgl.glColor4f(0.4, 0.15, 0.75, 1.0) bgl.glBegin(bgl.GL_TRIANGLE_FAN) for x,y in triangle: bgl.glVertex2f(x,y) bgl.glEnd() # AR NUMERICAL DISTANCE: np_print('ardist = ', ardist, 'ardist_loc = ', ardist_loc) bgl.glColor4f(0.4, 0.15, 0.75, 1.0) font_id = 0 blf.size(font_id, 20, 72) blf.position(font_id, ardist_loc[0], ardist_loc[1], 0) blf.draw(font_id, ardist) #DRAWING END: bgl.glLineWidth(1) bgl.glDisable(bgl.GL_BLEND) bgl.glColor4f(0.0, 0.0, 0.0, 1.0) np_print('06a_DRAW_ArrayTrans_FINISHED',';','flag = ', NP020PC.flag) ''' # Restoring the object selection and system settings from before the operator activation. Deleting the helpers after successful translation, reseting all viewport options and reselecting previously selected objects: class NPPCRestoreContext(bpy.types.Operator): bl_idname = "object.np_pc_restore_context" bl_label = "NP PC Restore Context" bl_options = {'INTERNAL'} def execute(self, context): np_print('07_CleanExit_START',';','flag = ', NP020PC.flag) flag = NP020PC.flag selob = NP020PC.selob take = NP020PC.take place = NP020PC.place bpy.ops.object.select_all(action='DESELECT') take.select_set(True) place.select_set(True) bpy.ops.object.delete('EXEC_DEFAULT') lenselob = len(selob) for i, ob in enumerate(selob): ob.select_set(True) if i == lenselob-1: bpy.context.view_layer.objects.active = ob NP020PC.take = None NP020PC.place = None NP020PC.takeloc3d = (0.0,0.0,0.0) NP020PC.placeloc3d = (0.0,0.0,0.0) NP020PC.dist = None NP020PC.mode = 'MOVE' NP020PC.flag = 'NONE' NP020PC.ardict = {} NP020PC.deltavec = Vector ((0, 0, 0)) NP020PC.deltavec_safe = Vector ((0, 0, 0)) bpy.context.tool_settings.use_snap = NP020PC.use_snap bpy.context.tool_settings.snap_element = NP020PC.snap_element bpy.context.tool_settings.snap_target = NP020PC.snap_target bpy.context.space_data.pivot_point = NP020PC.pivot_point bpy.context.space_data.transform_orientation = NP020PC.trans_orient #if NP020PC.acob is not None: #bpy.context.scene.objects.active = NP020PC.acob #bpy.ops.object.mode_set(mode = NP020PC.edit_mode) np_print('07_CleanExit_FINISHED',';','flag = ', NP020PC.flag) return {'FINISHED'} ''' # Defining the settings of the addon in the User preferences / addons tab: class NPPCPreferences(bpy.types.AddonPreferences): # this must match the addon name, use '__package__' # when defining this in a submodule of a python package. bl_idname = __name__ dist_scale = bpy.props.FloatProperty( name='Unit scale', description='Distance multiplier (for example, for cm use 100)', default=100, min=0, step=1, precision=3) suffix = bpy.props.EnumProperty( name='Unit suffix', items=(("'","'",''), ('"','"',''), ('thou','thou',''), ('km','km',''), ('m','m',''), ('cm','cm',''), ('mm','mm',''), ('nm','nm',''), ('None','None','')), default='cm', description='Add a unit extension after the numerical distance ') badge = bpy.props.BoolProperty( name='Mouse badge', description='Use the graphical badge near the mouse cursor', default=True) badge_size = bpy.props.FloatProperty( name='size', description='Size of the mouse badge, the default is 2.0', default=2, min=0.5, step=10, precision=1) col_line_main_DEF = bpy.props.BoolProperty( name='Default', description='Use the default color', default=True) col_line_shadow_DEF = bpy.props.BoolProperty( name='Default', description='Use the default color', default=True) col_num_main_DEF = bpy.props.BoolProperty( name='Default', description='Use the default color', default=True) col_num_shadow_DEF = bpy.props.BoolProperty( name='Default', description='Use the default color', default=True) col_line_main = bpy.props.FloatVectorProperty(name='', default=(1.0, 1.0, 1.0, 1.0), size=4, subtype="COLOR", min=0, max=1, description = 'Color of the measurement line, to disable it set alpha to 0.0') col_line_shadow = bpy.props.FloatVectorProperty(name='', default=(0.1, 0.1, 0.1, 0.25), size=4, subtype="COLOR", min=0, max=1, description = 'Color of the line shadow, to disable it set alpha to 0.0') col_num_main = bpy.props.FloatVectorProperty(name='', default=(0.1, 0.1, 0.1, 0.75), size=4, subtype="COLOR", min=0, max=1, description = 'Color of the number, to disable it set alpha to 0.0') col_num_shadow = bpy.props.FloatVectorProperty(name='', default=(1.0, 1.0, 1.0, 1.0), size=4, subtype="COLOR", min=0, max=1, description = 'Color of the number shadow, to disable it set alpha to 0.0') def draw(self, context): layout = self.layout split = layout.split() col = split.column() col.prop(self, "dist_scale") col = split.column() col.prop(self, "suffix") split = layout.split() col = split.column() col.label(text='Line Main COLOR') col.prop(self, "col_line_main_DEF") if self.col_line_main_DEF == False: col.prop(self, "col_line_main") col = split.column() col.label(text='Line Shadow COLOR') col.prop(self, "col_line_shadow_DEF") if self.col_line_shadow_DEF == False: col.prop(self, "col_line_shadow") col = split.column() col.label(text='Numerical Main COLOR') col.prop(self, "col_num_main_DEF") if self.col_num_main_DEF == False: col.prop(self, "col_num_main") col = split.column() col.label(text='Numerical Shadow COLOR') col.prop(self, "col_num_shadow_DEF") if self.col_num_shadow_DEF == False: col.prop(self, "col_num_shadow") split = layout.split() col = split.column() col.prop(self, "badge") col = split.column() if self.badge == True: col.prop(self, "badge_size") col = split.column() col = split.column() ''' # This is the actual addon process, the algorithm that defines the order of operator activation inside the main macro: def register(): #bpy.utils.register_class(NPPCPreferences) #bpy.utils.register_module(__name__) bpy.app.handlers.scene_update_post.append(NPPC_scene_update) NP020PointCopy.define('OBJECT_OT_np_pc_get_context') NP020PointCopy.define('OBJECT_OT_np_pc_get_selection') NP020PointCopy.define('OBJECT_OT_np_pc_get_mouseloc') NP020PointCopy.define('OBJECT_OT_np_pc_add_helpers') NP020PointCopy.define('OBJECT_OT_np_pc_prepare_context') for i in range(1, 50): for i in range(1, 10): NP020PointCopy.define('OBJECT_OT_np_pc_run_translate') NP020PointCopy.define('OBJECT_OT_np_pc_nav_translate') NP020PointCopy.define('OBJECT_OT_np_pc_prepare_next') #NP020PointCopy.define('OBJECT_OT_np_pc_array_translate') NP020PointCopy.define('OBJECT_OT_np_pc_restore_context') def unregister(): #pass #bpy.utils.unregister_class(NPPCPreferences) #bpy.utils.unregister_module(__name__) bpy.app.handlers.scene_update_post.remove(NPPC_scene_update)