VladPolskiy/blender-addons-contrib
1
0
Fork 0
mirror of https://github.com/blender/blender-addons-contrib.git synced 2025-08-01 15:48:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
ec18c7ea552c096e2bcbaa82ceccf0cbc99f88c0
blender-addons-contrib/np_station/np_point_copy.py
Campbell Barton 5c755ab594 Update 'bl_info' use 'doc_url' instead of 'wiki_url'
2020-03-05 12:26:13 +11:00

1298 lines
52 KiB
Python
Raw Blame History

# ##### 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)
Reference in New Issue View Git Blame Copy Permalink