mirror of
http://CODE.RHODECODE.COM/u/O/O/O
synced 2024-09-20 03:16:41 -04:00
1360 lines
43 KiB
Python
1360 lines
43 KiB
Python
# 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() |