space_view_3d_display_tools.py
Public
Actions

Authored By

	Jordi Vall-llovera Medina (jordiart)
	Nov 13 2013, 4:10 PM

Size

43 KB

Subscribers

None

space_view_3d_display_tools.py
View Options

	# space_view_3d_display_tools.py Copyright (C) 2012, Jordi Vall-llovera
	#
	# Multiple display tools for fast navigate/interact with the viewport
	#
	# *** BEGIN GPL LICENSE BLOCK ***
	#
	#
	# This program is free software; you can redistribute it and/or
	# modify it under the terms of the GNU General Public License
	# as published by the Free Software Foundation; either version 2
	# of the License, or (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program; if not, write to the Free Software Foundation,
	# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	#
	# *** END GPL LICENCE BLOCK ***

	bl_info = {
	"name": "Display Tools",
	"author": "Jordi Vall-llovera Medina",
	"version": (1, 2, 6),
	"blender": (2, 6, 4),
	"location": "Toolshelf",
	"description": "Display tools for fast navigate/interact with the viewport",
	"warning": "",
	"wiki_url": "http://jordiart3d.blogspot.com.es/",
	"tracker_url": "",
	"category": "3D View"}

	"""
	Additional links:
	Author Site: http://jordiart3d.blogspot.com.es/
	"""

	import bpy

	from bpy.props import IntProperty, BoolProperty, FloatProperty, EnumProperty

	# init delay variables
	bpy.types.Scene.Delay = bpy.props.BoolProperty(
	default = False,
	description = "Activate delay return to normal viewport mode")

	bpy.types.Scene.DelayTime = bpy.props.IntProperty(
	default = 30,
	min = 1,
	max = 500,
	soft_min = 10,
	soft_max = 250,
	description = "Delay time to return to normal viewport\
	mode after move your mouse cursor")

	bpy.types.Scene.DelayTimeGlobal = bpy.props.IntProperty(
	default = 30,
	min = 1,
	max = 500,
	soft_min = 10,
	soft_max = 250,
	description = "Delay time to return to normal viewport\
	mode after move your mouse cursor")

	#init variable for fast navigate
	bpy.types.Scene.EditActive = bpy.props.BoolProperty(
	default = True,
	description = "Activate for fast navigate in edit mode too")

	#Fast Navigate toggle function
	def trigger_fast_navigate(trigger):
	scene = bpy.context.scene
	scene.FastNavigateStop = False

	if trigger == True:
	trigger = False
	else:
	trigger = True

	#Control how to display particles during fast navigate
	def display_particles(mode):
	scene = bpy.context.scene

	if mode == True:
	for particles in bpy.data.particles:
	if particles.type == 'EMITTER':
	particles.draw_method = 'DOT'
	particles.draw_percentage = 100
	else:
	particles.draw_method = 'RENDER'
	particles.draw_percentage = 100
	else:
	for particles in bpy.data.particles:
	if particles.type == 'EMITTER':
	particles.draw_method = 'DOT'
	particles.draw_percentage = scene.ParticlesPercentageDisplay
	else:
	particles.draw_method = 'RENDER'
	particles.draw_percentage = scene.ParticlesPercentageDisplay

	#Do repetitive fast navigate related stuff
	def fast_navigate_stuff(self, context, event):
	scene = bpy.context.scene
	view = context.space_data

	if bpy.context.area.type != 'VIEW_3D':
	return self.cancel(context)

	if event.type == 'ESC' or event.type == 'RET' or event.type == 'SPACE':
	return self.cancel(context)

	if scene.FastNavigateStop == True:
	return self.cancel(context)

	#fast navigate while orbit/panning
	if event.type == 'MIDDLEMOUSE':
	if scene.Delay == True:
	if scene.DelayTime < scene.DelayTimeGlobal:
	scene.DelayTime += 1
	view.viewport_shade = scene.FastMode
	self.mode = False

	#fast navigate while transform operations
	if event.type == 'G' or event.type == 'R' or event.type == 'S':
	if scene.Delay == True:
	if scene.DelayTime < scene.DelayTimeGlobal:
	scene.DelayTime += 1
	view.viewport_shade = scene.FastMode
	self.mode = False

	#fast navigate while menu popups or duplicates
	if event.type == 'W' or event.type == 'D' or event.type == 'L'\
	or event.type == 'U' or event.type == 'I' or event.type == 'M'\
	or event.type == 'A' or event.type == 'B':
	if scene.Delay == True:
	if scene.DelayTime < scene.DelayTimeGlobal:
	scene.DelayTime += 1
	view.viewport_shade = scene.FastMode
	self.mode = False

	#fast navigate while numpad navigation
	if event.type == 'NUMPAD_PERIOD' or event.type == 'NUMPAD_1'\
	or event.type == 'NUMPAD_2' or event.type == 'NUMPAD_3'\
	or event.type == 'NUMPAD_4' or event.type == 'NUMPAD_5'\
	or event.type == 'NUMPAD_6' or event.type == 'NUMPAD_7'\
	or event.type == 'NUMPAD_8' or event.type == 'NUMPAD_9':
	if scene.Delay == True:
	if scene.DelayTime < scene.DelayTimeGlobal:
	scene.DelayTime += 1
	view.viewport_shade = scene.FastMode
	self.mode = False

	#fast navigate while zooming with mousewheel too
	if event.type == 'WHEELUPMOUSE' or event.type == 'WHEELDOWNMOUSE':
	scene.DelayTime = scene.DelayTimeGlobal
	view.viewport_shade = scene.FastMode
	self.mode = False

	if event.type == 'MOUSEMOVE':
	if scene.Delay == True:
	if scene.DelayTime == 0:
	scene.DelayTime = scene.DelayTimeGlobal
	view.viewport_shade = scene.OriginalMode
	self.mode = True
	else:
	view.viewport_shade = scene.OriginalMode
	self.mode = True

	if scene.Delay == True:
	scene.DelayTime -= 1
	if scene.DelayTime == 0:
	scene.DelayTime = scene.DelayTimeGlobal
	view.viewport_shade = scene.OriginalMode
	self.mode = True

	if scene.ShowParticles == False:
	for particles in bpy.data.particles:
	if particles.type == 'EMITTER':
	particles.draw_method = 'NONE'
	else:
	particles.draw_method = 'NONE'
	else:
	display_particles(self.mode)

	#Fast Navigate operator
	class FastNavigate(bpy.types.Operator):
	"""Operator that runs Fast navigate in modal mode"""
	bl_idname = "view3d.fast_navigate_operator"
	bl_label = "Fast Navigate"
	trigger = BoolProperty(default = False)
	mode = BoolProperty(default = False)
	scene = bpy.context.scene
	scene.DelayTime = scene.DelayTimeGlobal

	def modal(self, context, event):
	scene = bpy.context.scene
	view = context.space_data

	if scene.EditActive == True:
	fast_navigate_stuff(self, context ,event)
	return {'PASS_THROUGH'}
	else:
	obj = context.active_object
	if obj:
	if obj.mode != 'EDIT':
	fast_navigate_stuff(self, context ,event)
	return {'PASS_THROUGH'}
	else:
	return {'PASS_THROUGH'}
	else:
	fast_navigate_stuff(self, context ,event)
	return {'PASS_THROUGH'}

	def execute(self, context):
	context.window_manager.modal_handler_add(self)
	trigger_fast_navigate(self.trigger)
	return {'RUNNING_MODAL'}

	def cancel(self, context):
	scene = context.scene
	for particles in bpy.data.particles:
	particles.draw_percentage = scene.InitialParticles
	return {'CANCELLED'}

	#Fast Navigate Stop
	def fast_navigate_stop(context):
	scene = bpy.context.scene
	scene.FastNavigateStop = True

	#Fast Navigate Stop Operator
	class FastNavigateStop(bpy.types.Operator):
	'''Stop Fast Navigate Operator'''
	bl_idname = "view3d.fast_navigate_stop"
	bl_label = "Stop"
	FastNavigateStop = IntProperty(name = "FastNavigateStop",
	description = "Stop fast navigate mode",
	default = 0)

	def execute(self,context):
	fast_navigate_stop(context)
	return {'FINISHED'}

	#Drawtype textured
	def draw_textured(context):
	view = context.space_data
	view.viewport_shade = 'TEXTURED'
	bpy.context.scene.game_settings.material_mode = 'GLSL'
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.draw_type = 'TEXTURED'
	else:
	for obj in selection:
	obj.draw_type = 'TEXTURED'

	class DisplayTextured(bpy.types.Operator):
	'''Display objects in textured mode'''
	bl_idname = "view3d.display_textured"
	bl_label = "Textured"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	draw_textured(context)
	return {'FINISHED'}

	#Drawtype solid
	def draw_solid(context):
	view = context.space_data
	view.viewport_shade = 'TEXTURED'
	bpy.context.scene.game_settings.material_mode = 'GLSL'
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.draw_type = 'SOLID'
	else:
	for obj in selection:
	obj.draw_type = 'SOLID'

	class DisplaySolid(bpy.types.Operator):
	'''Display objects in solid mode'''
	bl_idname = "view3d.display_solid"
	bl_label = "Solid"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	draw_solid(context)
	return {'FINISHED'}

	#Drawtype wire
	def draw_wire(context):
	view = context.space_data
	view.viewport_shade = 'TEXTURED'
	bpy.context.scene.game_settings.material_mode = 'GLSL'
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.draw_type = 'WIRE'
	else:
	for obj in selection:
	obj.draw_type = 'WIRE'

	class DisplayWire(bpy.types.Operator):
	'''Display objects in wireframe mode'''
	bl_idname = "view3d.display_wire"
	bl_label = "Wire"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	draw_wire(context)
	return {'FINISHED'}

	#Drawtype bounds
	def draw_bounds(context):
	view = context.space_data
	view.viewport_shade = 'TEXTURED'
	bpy.context.scene.game_settings.material_mode = 'GLSL'
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.draw_type = 'BOUNDS'
	else:
	for obj in selection:
	obj.draw_type = 'BOUNDS'

	class DisplayBounds(bpy.types.Operator):
	'''Display objects in bounds mode'''
	bl_idname = "view3d.display_bounds"
	bl_label = "Bounds"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	draw_bounds(context)
	return {'FINISHED'}

	#Shade smooth
	def shade_smooth(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	bpy.ops.object.select_all(action = 'TOGGLE')
	bpy.ops.object.shade_smooth()
	bpy.ops.object.select_all(action = 'TOGGLE')
	else:
	obj = context.active_object
	if obj.mode == 'OBJECT':
	for obj in selection:
	bpy.ops.object.shade_smooth()
	else:
	bpy.ops.mesh.faces_shade_smooth()

	class DisplayShadeSmooth(bpy.types.Operator):
	'''Display shade smooth meshes'''
	bl_idname = "view3d.display_shade_smooth"
	bl_label = "Smooth"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	shade_smooth(context)
	return {'FINISHED'}

	#Shade flat
	def shade_flat(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	bpy.ops.object.select_all(action = 'TOGGLE')
	bpy.ops.object.shade_flat()
	bpy.ops.object.select_all(action = 'TOGGLE')
	else:
	obj = context.active_object
	if obj.mode == 'OBJECT':
	for obj in selection:
	bpy.ops.object.shade_flat()
	else:
	bpy.ops.mesh.faces_shade_flat()

	class DisplayShadeFlat(bpy.types.Operator):
	'''Display shade flat meshes'''
	bl_idname = "view3d.display_shade_flat"
	bl_label = "Flat"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	shade_flat(context)
	return {'FINISHED'}

	#Shadeless on
	def shadeless_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.materials:
	obj.use_shadeless = True
	else:
	for sel in selection:
	if sel.type == 'MESH':
	materials = sel.data.materials
	for mat in materials:
	mat.use_shadeless = True

	class DisplayShadelessOn(bpy.types.Operator):
	'''Display shadeless material'''
	bl_idname = "view3d.display_shadeless_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	shadeless_on(context)
	return {'FINISHED'}

	#Shadeless off
	def shadeless_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.materials:
	obj.use_shadeless = False
	else:
	for sel in selection:
	if sel.type == 'MESH':
	materials = sel.data.materials
	for mat in materials:
	mat.use_shadeless = False

	class DisplayShadelessOff(bpy.types.Operator):
	'''Display shaded material'''
	bl_idname = "view3d.display_shadeless_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	shadeless_off(context)
	return {'FINISHED'}

	#Wireframe on
	def wire_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_wire = True

	for mesh in bpy.data.meshes:
	mesh.show_all_edges = True
	else:
	for obj in selection:
	obj.show_wire = True

	for sel in selection:
	if sel.type == 'MESH':
	mesh = sel.data
	mesh.show_all_edges = True

	class DisplayWireframeOn(bpy.types.Operator):
	'''Display wireframe overlay on'''
	bl_idname = "view3d.display_wire_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	wire_on(context)
	return {'FINISHED'}

	#Wireframe off
	def wire_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_wire = False

	for mesh in bpy.data.meshes:
	mesh.show_all_edges = False
	else:
	for obj in selection:
	obj.show_wire = False

	for sel in selection:
	if sel.type == 'MESH':
	mesh = sel.data
	mesh.show_all_edges = False

	class DisplayWireframeOff(bpy.types.Operator):
	'''Display wireframe overlay off'''
	bl_idname = "view3d.display_wire_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	wire_off(context)
	return {'FINISHED'}

	#Bounds on
	def bounds_on(context):
	scene = context.scene
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_bounds = True
	obj.draw_bounds_type = scene.BoundingMode
	else:
	for obj in selection:
	obj.show_bounds = True
	obj.draw_bounds_type = scene.BoundingMode

	class DisplayBoundsOn(bpy.types.Operator):
	'''Display Bounding box overlay on'''
	bl_idname = "view3d.display_bounds_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	bounds_on(context)
	return {'FINISHED'}

	#Wireframe off
	def bounds_off(context):
	scene = context.scene
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_bounds = False
	else:
	for obj in selection:
	obj.show_bounds = False

	class DisplayBoundsOff(bpy.types.Operator):
	'''Display Bounding box overlay off'''
	bl_idname = "view3d.display_bounds_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	bounds_off(context)
	return {'FINISHED'}

	#Double Sided on
	def double_sided_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for mesh in bpy.data.meshes:
	mesh.show_double_sided = True
	else:
	for sel in selection:
	if sel.type == 'MESH':
	mesh = sel.data
	mesh.show_double_sided = True

	class DisplayDoubleSidedOn(bpy.types.Operator):
	'''Turn on face double shaded mode'''
	bl_idname = "view3d.display_double_sided_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	double_sided_on(context)
	return {'FINISHED'}

	#Double Sided off
	def double_sided_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for mesh in bpy.data.meshes:
	mesh.show_double_sided = False
	else:
	for sel in selection:
	if sel.type == 'MESH':
	mesh = sel.data
	mesh.show_double_sided = False

	class DisplayDoubleSidedOff(bpy.types.Operator):
	'''Turn off face double sided shade mode'''
	bl_idname = "view3d.display_double_sided_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	double_sided_off(context)
	return {'FINISHED'}

	#XRay on
	def x_ray_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_x_ray = True
	else:
	for obj in selection:
	obj.show_x_ray = True

	class DisplayXRayOn(bpy.types.Operator):
	'''X-Ray display on'''
	bl_idname = "view3d.display_x_ray_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	x_ray_on(context)
	return {'FINISHED'}

	#XRay off
	def x_ray_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	obj.show_x_ray = False
	else:
	for obj in selection:
	obj.show_x_ray = False

	class DisplayXRayOff(bpy.types.Operator):
	'''X-Ray display off'''
	bl_idname = "view3d.display_x_ray_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	x_ray_off(context)
	return {'FINISHED'}

	#Init properties for scene
	bpy.types.Scene.FastNavigateStop = bpy.props.BoolProperty(
	name = "Fast Navigate Stop",
	description = "Stop fast navigate mode",
	default = False)

	bpy.types.Scene.OriginalMode = bpy.props.EnumProperty(
	items = [('TEXTURED', 'Texture', 'Texture display mode'),
	('SOLID', 'Solid', 'Solid display mode')],
	name = "Normal",
	default = 'SOLID')

	bpy.types.Scene.BoundingMode = bpy.props.EnumProperty(
	items = [('BOX', 'Box', 'Box shape'),
	('SPHERE', 'Sphere', 'Sphere shape'),
	('CYLINDER', 'Cylinder', 'Cylinder shape'),
	('CONE', 'Cone', 'Cone shape')],
	name = "BB Mode")

	bpy.types.Scene.FastMode = bpy.props.EnumProperty(
	items = [('WIREFRAME', 'Wireframe', 'Wireframe display'),
	('BOUNDBOX', 'Bounding Box', 'Bounding Box display')],
	name = "Fast")

	bpy.types.Scene.ShowParticles = bpy.props.BoolProperty(
	name = "Show Particles",
	description = "Show or hide particles on fast navigate mode",
	default = True)

	bpy.types.Scene.ParticlesPercentageDisplay = bpy.props.IntProperty(
	name = "Display",
	description = "Display only a percentage of particles",
	default = 25,
	min = 0,
	max = 100,
	soft_min = 0,
	soft_max = 100,
	subtype = 'FACTOR')

	bpy.types.Scene.InitialParticles = bpy.props.IntProperty(
	name = "Count for initial particle setting before enter fast navigate",
	description = "Display a percentage value of particles",
	default = 100,
	min = 0,
	max = 100,
	soft_min = 0,
	soft_max = 100)

	#Set Render Settings
	def set_render_settings(conext):
	scene = bpy.context.scene
	render = bpy.context.scene.render
	view = bpy.context.space_data
	render.simplify_subdivision = 0
	render.simplify_shadow_samples = 0
	render.simplify_child_particles = 0
	render.simplify_ao_sss = 0

	class DisplaySimplify(bpy.types.Operator):
	'''Display scene simplified'''
	bl_idname = "view3d.display_simplify"
	bl_label = "Reset"

	Mode = EnumProperty(
	items = [('WIREFRAME', 'Wireframe', ''),
	('BOUNDBOX', 'Bounding Box', '')],
	name = "Mode")

	ShowParticles = BoolProperty(
	name = "ShowParticles",
	description = "Show or hide particles on fast navigate mode",
	default = True)

	ParticlesPercentageDisplay = IntProperty(
	name = "Display",
	description = "Display a percentage value of particles",
	default = 25,
	min = 0,
	max = 100,
	soft_min = 0,
	soft_max = 100,
	subtype = 'FACTOR')

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	set_render_settings(context)
	return {'FINISHED'}

	#Display Modifiers Render on
	def modifiers_render_on(context):
	scene = bpy.context.scene
	bpy.types.Scene.Symplify = IntProperty(
	name = "Integer",description = "Enter an integer")
	scene['Simplify'] = 1
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_render = True
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_render = True

	class DisplayModifiersRenderOn(bpy.types.Operator):
	'''Display modifiers in render'''
	bl_idname = "view3d.display_modifiers_render_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_render_on(context)
	return {'FINISHED'}

	#Display Modifiers Render off
	def modifiers_render_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_render = False
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_render = False

	class DisplayModifiersRenderOff(bpy.types.Operator):
	'''Hide modifiers in render'''
	bl_idname = "view3d.display_modifiers_render_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_render_off(context)
	return {'FINISHED'}

	#Display Modifiers Viewport on
	def modifiers_viewport_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_viewport = True
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_viewport = True

	class DisplayModifiersViewportOn(bpy.types.Operator):
	'''Display modifiers in viewport'''
	bl_idname = "view3d.display_modifiers_viewport_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_viewport_on(context)
	return {'FINISHED'}

	#Display Modifiers Viewport off
	def modifiers_viewport_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_viewport = False
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_viewport = False

	class DisplayModifiersViewportOff(bpy.types.Operator):
	'''Hide modifiers in viewport'''
	bl_idname = "view3d.display_modifiers_viewport_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_viewport_off(context)
	return {'FINISHED'}

	#Display Modifiers Edit on
	def modifiers_edit_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_in_editmode = True
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_in_editmode = True

	class DisplayModifiersEditOn(bpy.types.Operator):
	'''Display modifiers during edit mode'''
	bl_idname = "view3d.display_modifiers_edit_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_edit_on(context)
	return {'FINISHED'}

	#Display Modifiers Edit off
	def modifiers_edit_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_in_editmode = False
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_in_editmode = False

	class DisplayModifiersEditOff(bpy.types.Operator):
	'''Hide modifiers during edit mode'''
	bl_idname = "view3d.display_modifiers_edit_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_edit_off(context)
	return {'FINISHED'}

	#Display Modifiers Cage on
	def modifiers_cage_on(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_on_cage = True
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_on_cage = True

	class DisplayModifiersCageOn(bpy.types.Operator):
	'''Display modifiers editing cage during edit mode'''
	bl_idname = "view3d.display_modifiers_cage_on"
	bl_label = "On"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_cage_on(context)
	return {'FINISHED'}

	#Display Modifiers Cage off
	def modifiers_cage_off(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_on_cage = False
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_on_cage = False

	class DisplayModifiersCageOff(bpy.types.Operator):
	'''Hide modifiers editing cage during edit mode'''
	bl_idname = "view3d.display_modifiers_cage_off"
	bl_label = "Off"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_cage_off(context)
	return {'FINISHED'}

	#Display Modifiers Expand
	def modifiers_expand(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_expanded = True
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_expanded = True

	class DisplayModifiersExpand(bpy.types.Operator):
	'''Expand all modifiers on modifier stack'''
	bl_idname = "view3d.display_modifiers_expand"
	bl_label = "Expand"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_expand(context)
	return {'FINISHED'}

	#Display Modifiers Collapse
	def modifiers_collapse(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	mod.show_expanded = False
	else:
	for obj in selection:
	for mod in obj.modifiers:
	mod.show_expanded = False

	class DisplayModifiersCollapse(bpy.types.Operator):
	'''Collapse all modifiers on modifier stack'''
	bl_idname = "view3d.display_modifiers_collapse"
	bl_label = "Collapse"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_collapse(context)
	return {'FINISHED'}

	#Apply modifiers
	def modifiers_apply(context):
	selection = bpy.context.selected_objects

	if not(selection):
	bpy.ops.object.select_all(action = 'TOGGLE')
	bpy.ops.object.convert(target = 'MESH', keep_original = False)
	bpy.ops.object.select_all(action = 'TOGGLE')
	else:
	for mesh in selection:
	if mesh.type == "MESH":
	bpy.ops.object.convert(target='MESH', keep_original = False)

	class DisplayModifiersApply(bpy.types.Operator):
	'''Apply modifiers'''
	bl_idname = "view3d.display_modifiers_apply"
	bl_label = "Apply All"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_apply(context)
	return {'FINISHED'}

	#Delete modifiers
	def modifiers_delete(context):
	selection = bpy.context.selected_objects

	if not(selection):
	for obj in bpy.data.objects:
	for mod in obj.modifiers:
	bpy.context.scene.objects.active = obj
	bpy.ops.object.modifier_remove(modifier = mod.name)
	else:
	for obj in selection:
	for mod in obj.modifiers:
	bpy.context.scene.objects.active = obj
	bpy.ops.object.modifier_remove(modifier = mod.name)

	class DisplayModifiersDelete(bpy.types.Operator):
	'''Delete modifiers'''
	bl_idname = "view3d.display_modifiers_delete"
	bl_label = "Delete All"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_delete(context)
	return {'FINISHED'}

	#Put dummy modifier for boost subsurf
	def modifiers_set_dummy(context):
	selection = bpy.context.selected_objects

	if not(selection):
	print("funciona")
	for object in bpy.data.objects:
	if object.type == "MESH":
	mod = object.modifiers.new(type = 'SIMPLE_DEFORM',\
	name = "Dummy")
	mod.factor = 0
	else:
	for object in selection:
	if object.type == "MESH":
	mod = object.modifiers.new(type = 'SIMPLE_DEFORM',\
	name = "Dummy")
	mod.factor = 0

	class DisplayAddDummy(bpy.types.Operator):
	'''Add a dummy simple deform modifier to boost\
	subsurf modifier viewport performance'''
	bl_idname = "view3d.display_modifiers_set_dummy"
	bl_label = "Put Dummy"

	@classmethod
	def poll(cls, context):
	return True

	def execute(self, context):
	modifiers_set_dummy(context)
	return {'FINISHED'}

	# main class for Fast Navigate
	class VIEW3D_PT_FastNavigate(bpy.types.Panel):
	bl_space_type = "VIEW_3D"
	bl_region_type = "TOOLS"
	bl_label = "Fast Navigate"
	bl_options = {"DEFAULT_CLOSED"}

	def draw(self, context):
	layout = self.layout

	# Tools
	scene = context.scene
	row = layout.row(align=True)
	row.alignment = 'LEFT'
	row.operator("view3d.fast_navigate_operator")
	row.operator("view3d.fast_navigate_stop")
	layout.label("Settings :")
	row = layout.row()
	box = row.box()
	box.prop(scene,"OriginalMode")
	box.prop(scene,"FastMode")
	box.prop(scene, "EditActive", "Edit mode")
	box.prop(scene, "Delay")
	box.prop(scene, "DelayTimeGlobal", "Delay time")
	box.alignment = 'LEFT'
	box.prop(scene,"ShowParticles")
	box.prop(scene,"ParticlesPercentageDisplay")

	# main class for Display Mode
	class VIEW3D_PT_DisplayMode(bpy.types.Panel):
	bl_space_type = "VIEW_3D"
	bl_region_type = "TOOLS"
	bl_label = "Display Mode"
	bl_options = {"DEFAULT_CLOSED"}

	def draw(self, context):
	layout = self.layout

	# Tools
	col = layout.column()
	col.alignment = 'EXPAND'
	row = col.row()
	row.operator("view3d.display_textured" , icon ='TEXTURE_SHADED')
	row.operator("view3d.display_solid" , icon ='SOLID')
	col = layout.column()
	col.alignment = 'EXPAND'
	row = col.row()
	row.operator("view3d.display_wire" , icon = 'WIRE')
	row.operator("view3d.display_bounds" , icon = 'BBOX')

	# main class for Shading Setup
	class VIEW3D_PT_ShadingSetup(bpy.types.Panel):
	bl_space_type = "VIEW_3D"
	bl_region_type = "TOOLS"
	bl_label = "Shading Setup"
	bl_options = {"DEFAULT_CLOSED"}

	def draw(self, context):
	layout = self.layout

	# Tools
	col = layout.column(align=True)
	row = col.row()
	row.operator("view3d.display_shade_smooth")
	row.operator("view3d.display_shade_flat")
	row = col.row()
	row.operator("view3d.display_shadeless_on", "Shadeless On",\
	icon = 'SOLID')
	row.operator("view3d.display_shadeless_off",\
	"Shadeless Off", icon = 'SOLID')
	row = col.row()
	row.operator("view3d.display_wire_on", "Wire On", icon = 'WIRE')
	row.operator("view3d.display_wire_off", "Wire Off", icon = 'WIRE')
	row = col.row()
	row.operator("view3d.display_bounds_on", "Bounds On", icon = 'BBOX')
	row.operator("view3d.display_bounds_off", "Bounds Off", icon = 'BBOX')
	row = col.row()
	row.operator("view3d.display_double_sided_on",\
	"DSided On", icon = 'MESH_DATA')
	row.operator("view3d.display_double_sided_off",\
	"DSided Off", icon = 'MESH_DATA')
	row = col.row()
	row.operator("view3d.display_x_ray_on",\
	"XRay On", icon = 'GHOST_ENABLED')
	row.operator("view3d.display_x_ray_off",\
	"XRay Off", icon = 'GHOST_ENABLED')
	row = col.row()
	row.separator()
	row = col.row()

	scene = context.scene
	row.prop(scene, "BoundingMode")

	# main class for Scene Visualization
	class VIEW3D_PT_SceneVisualization(bpy.types.Panel):
	bl_space_type = "VIEW_3D"
	bl_region_type = "TOOLS"
	bl_label = "Scene Visualization"
	bl_options = {"DEFAULT_CLOSED"}

	def draw(self, context):
	layout = self.layout

	# Tools
	scene = context.scene
	render = scene.render
	space = context.space_data
	layout.prop(space, "show_manipulator")
	layout.prop(space, "show_outline_selected")
	layout.prop(space, "show_only_render")
	layout.prop(space, "show_textured_solid")
	layout.prop(space, "show_backface_culling")
	layout.prop(space, "show_all_objects_origin")
	layout.prop(render,"use_simplify", "Simplify")
	if scene.render.use_simplify == True:
	layout.label("Settings :")
	row = layout.row()
	box = row.box()
	box.prop(render, "simplify_subdivision", "Subdivision")
	box.prop(render, "simplify_shadow_samples", "Shadow Samples")
	box.prop(render, "simplify_child_particles", "Child Particles")
	box.prop(render, "simplify_ao_sss", "AO and SSS")
	layout.operator("view3d.display_simplify")

	# main class for Modifier Tools
	class VIEW3D_PT_ModifierTools(bpy.types.Panel):
	bl_space_type = "VIEW_3D"
	bl_region_type = "TOOLS"
	bl_label = "Modifier Tools"
	bl_options = {"DEFAULT_CLOSED"}

	def draw(self, context):
	layout = self.layout

	# Tools
	layout.label("Modifiers", icon = 'MODIFIER')
	col = layout.column(align=True)
	col.alignment = 'EXPAND'
	row = col.row()
	row.operator("view3d.display_modifiers_render_on",\
	icon = 'RENDER_STILL')
	row.operator("view3d.display_modifiers_render_off")
	row.operator("view3d.display_modifiers_viewport_on",
	icon = 'RESTRICT_VIEW_OFF')
	row.operator("view3d.display_modifiers_viewport_off")
	col = layout.column(align=True)
	col.alignment = 'EXPAND'
	row = col.row()
	row.operator("view3d.display_modifiers_edit_on", icon = 'EDITMODE_HLT')
	row.operator("view3d.display_modifiers_edit_off")
	row.operator("view3d.display_modifiers_cage_on",\
	icon = 'EDITMODE_DEHLT')
	row.operator("view3d.display_modifiers_cage_off")
	row = layout.row(align=True)
	row.operator("view3d.display_modifiers_expand", icon = 'TRIA_DOWN')
	row.operator("view3d.display_modifiers_collapse", icon = 'TRIA_RIGHT')
	row = layout.row(align=True)
	row.operator("view3d.display_modifiers_apply", icon = 'MODIFIER')
	row.operator("view3d.display_modifiers_delete", icon = 'X')
	row = layout.row(align=True)
	row.operator("view3d.display_modifiers_set_dummy",\
	icon = 'OUTLINER_OB_ARMATURE')

	# register the classes
	def register():
	bpy.utils.register_class(FastNavigate)
	bpy.utils.register_class(DisplayTextured)
	bpy.utils.register_class(DisplaySolid)
	bpy.utils.register_class(DisplayWire)
	bpy.utils.register_class(DisplayBounds)
	bpy.utils.register_class(DisplayWireframeOn)
	bpy.utils.register_class(DisplayWireframeOff)
	bpy.utils.register_class(DisplayBoundsOn)
	bpy.utils.register_class(DisplayBoundsOff)
	bpy.utils.register_class(DisplayShadeSmooth)
	bpy.utils.register_class(DisplayShadeFlat)
	bpy.utils.register_class(DisplayShadelessOn)
	bpy.utils.register_class(DisplayShadelessOff)
	bpy.utils.register_class(DisplayDoubleSidedOn)
	bpy.utils.register_class(DisplayDoubleSidedOff)
	bpy.utils.register_class(DisplayXRayOn)
	bpy.utils.register_class(DisplayXRayOff)
	bpy.utils.register_class(DisplayModifiersRenderOn)
	bpy.utils.register_class(DisplayModifiersRenderOff)
	bpy.utils.register_class(DisplayModifiersViewportOn)
	bpy.utils.register_class(DisplayModifiersViewportOff)
	bpy.utils.register_class(DisplayModifiersEditOn)
	bpy.utils.register_class(DisplayModifiersEditOff)
	bpy.utils.register_class(DisplayModifiersCageOn)
	bpy.utils.register_class(DisplayModifiersCageOff)
	bpy.utils.register_class(DisplayModifiersExpand)
	bpy.utils.register_class(DisplayModifiersCollapse)
	bpy.utils.register_class(DisplayModifiersApply)
	bpy.utils.register_class(DisplayModifiersDelete)
	bpy.utils.register_class(DisplayAddDummy)
	bpy.utils.register_class(DisplaySimplify)
	bpy.utils.register_module(__name__)
	pass

	def unregister():
	bpy.utils.unregister_class(FastNavigate)
	bpy.utils.unregister_class(DisplayTextured)
	bpy.utils.unregister_class(DisplaySolid)
	bpy.utils.unregister_class(DisplayWire)
	bpy.utils.unregister_class(DisplayBounds)
	bpy.utils.unregister_class(DisplayShadeSmooth)
	bpy.utils.unregister_class(DisplayShadeFlat)
	bpy.utils.unregister_class(DisplayShadelessOn)
	bpy.utils.unregister_class(DisplayShadelessOff)
	bpy.utils.unregister_class(DisplayWireframeOn)
	bpy.utils.unregister_class(DisplayWireframeOff)
	bpy.utils.unregister_class(DisplayBoundsOn)
	bpy.utils.unregister_class(DisplayBoundsOff)
	bpy.utils.unregister_class(DisplayDoubleSidedOn)
	bpy.utils.unregister_class(DisplayDoubleSidedOff)
	bpy.utils.unregister_class(DisplayXRayOn)
	bpy.utils.unregister_class(DisplayXRayOff)
	bpy.utils.unregister_class(DisplayModifiersRenderOn)
	bpy.utils.unregister_class(DisplayModifiersRenderOff)
	bpy.utils.unregister_class(DisplayModifiersViewportOn)
	bpy.utils.unregister_class(DisplayModifiersViewportOff)
	bpy.utils.unregister_class(DisplayModifiersEditOn)
	bpy.utils.unregister_class(DisplayModifiersEditOff)
	bpy.utils.unregister_class(DisplayModifiersCageOn)
	bpy.utils.unregister_class(DisplayModifiersCageOff)
	bpy.utils.unregister_class(DisplayModifiersExpand)
	bpy.utils.unregister_class(DisplayModifiersCollapse)
	bpy.utils.unregister_class(DisplayModifiersApply)
	bpy.utils.unregister_class(DisplayModifiersDelete)
	bpy.utils.unregister_class(DisplayAddDummy)
	bpy.utils.unregister_class(DisplaySimplify)
	bpy.utils.unregister_module(__name__)
	pass

	if __name__ == "__main__":
	register()

File Metadata

Mime Type: text/x-python
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 7a/63/ec38c72947ed4364c8e404cb4465

space_view_3d_display_tools.pyPublicActions

space_view_3d_display_tools.pyView Options

File Metadata

Event Timeline

space_view_3d_display_tools.py
Public
Actions

space_view_3d_display_tools.py
View Options