Patrick Foley
912f61f9f5
Changed the menu operators:
Expand Mask by Topology (hotkey Shift A)
Expand Mask by Normals (hotkey Shift Alt A)
Expand Face Set by Topology (hotkey Shift W)
Expand Active Face Set (hotkey Shift Alt W)
so that their hotkeys would appear in their menu entries.
Resolves #104023
Co-authored-by: DisquietingFridge <30654622+DisquietingFridge@users.noreply.github.com>
Pull Request: blender/blender#104568
8265 lines
275 KiB
Python
8265 lines
275 KiB
Python
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
import bpy
|
|
from bpy.types import (
|
|
Header,
|
|
Menu,
|
|
Panel,
|
|
)
|
|
from bl_ui.properties_paint_common import (
|
|
UnifiedPaintPanel,
|
|
brush_basic_texpaint_settings,
|
|
)
|
|
from bl_ui.properties_grease_pencil_common import (
|
|
AnnotationDataPanel,
|
|
AnnotationOnionSkin,
|
|
GreasePencilMaterialsPanel,
|
|
GreasePencilVertexcolorPanel,
|
|
)
|
|
from bl_ui.space_toolsystem_common import (
|
|
ToolActivePanelHelper,
|
|
)
|
|
from bpy.app.translations import (
|
|
pgettext_iface as iface_,
|
|
pgettext_tip as tip_,
|
|
contexts as i18n_contexts,
|
|
)
|
|
|
|
class VIEW3D_HT_tool_header(Header):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'TOOL_HEADER'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
self.draw_tool_settings(context)
|
|
|
|
layout.separator_spacer()
|
|
|
|
self.draw_mode_settings(context)
|
|
|
|
def draw_tool_settings(self, context):
|
|
layout = self.layout
|
|
tool_mode = context.mode
|
|
|
|
# Active Tool
|
|
# -----------
|
|
from bl_ui.space_toolsystem_common import ToolSelectPanelHelper
|
|
tool = ToolSelectPanelHelper.draw_active_tool_header(context, layout,
|
|
tool_key=('VIEW_3D', tool_mode),)
|
|
|
|
# Object Mode Options
|
|
# -------------------
|
|
|
|
# Example of how tool_settings can be accessed as pop-overs.
|
|
|
|
# TODO(campbell): editing options should be after active tool options
|
|
# (obviously separated for from the users POV)
|
|
draw_fn = getattr(_draw_tool_settings_context_mode, tool_mode, None)
|
|
if draw_fn is not None:
|
|
if tool_mode == "SCULPT":
|
|
is_valid_context = draw_fn(self, context, layout, tool)
|
|
else:
|
|
is_valid_context = draw_fn(context, layout, tool)
|
|
|
|
def draw_3d_brush_settings(layout, tool_mode):
|
|
if tool_mode == "SCULPT":
|
|
layout.popover("VIEW3D_PT_tools_brush_settings_channels", text="Brush")
|
|
else:
|
|
layout.popover("VIEW3D_PT_tools_brush_settings", text="Brush")
|
|
|
|
if tool_mode not in ('PAINT_WEIGHT', 'SCULPT'):
|
|
layout.popover("VIEW3D_PT_tools_brush_texture")
|
|
|
|
if tool_mode == 'PAINT_TEXTURE':
|
|
layout.popover("VIEW3D_PT_tools_mask_texture")
|
|
|
|
layout.popover("VIEW3D_PT_tools_brush_stroke")
|
|
|
|
if tool_mode == 'SCULPT':
|
|
layout.popover("VIEW3D_PT_sculpt_automasking")
|
|
|
|
sub = layout.row()
|
|
sub.ui_units_x = 5
|
|
sub.popover("VIEW3D_PT_tools_brush_falloff_popover")
|
|
|
|
# why show this in the header? it takes up too much space - joeedh
|
|
#layout.popover("VIEW3D_PT_tools_brush_display")
|
|
|
|
# NOTE: general mode options should be added to `draw_mode_settings`.
|
|
if tool_mode == 'SCULPT':
|
|
if is_valid_context:
|
|
draw_3d_brush_settings(layout, tool_mode)
|
|
elif tool_mode == 'PAINT_VERTEX':
|
|
if is_valid_context:
|
|
draw_3d_brush_settings(layout, tool_mode)
|
|
elif tool_mode == 'PAINT_WEIGHT':
|
|
if is_valid_context:
|
|
draw_3d_brush_settings(layout, tool_mode)
|
|
elif tool_mode == 'PAINT_TEXTURE':
|
|
if is_valid_context:
|
|
draw_3d_brush_settings(layout, tool_mode)
|
|
elif tool_mode == 'EDIT_ARMATURE':
|
|
pass
|
|
elif tool_mode == 'EDIT_CURVE':
|
|
pass
|
|
elif tool_mode == 'EDIT_MESH':
|
|
pass
|
|
elif tool_mode == 'POSE':
|
|
pass
|
|
elif tool_mode == 'PARTICLE':
|
|
# Disable, only shows "Brush" panel, which is already in the
|
|
# top-bar.
|
|
# if tool.has_datablock:
|
|
# layout.popover_group(context=".paint_common", **popover_kw)
|
|
pass
|
|
elif tool_mode == 'PAINT_GPENCIL':
|
|
if is_valid_context:
|
|
brush = context.tool_settings.gpencil_paint.brush
|
|
if brush:
|
|
if brush.gpencil_tool != 'ERASE':
|
|
if brush.gpencil_tool != 'TINT':
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_brush_advanced")
|
|
|
|
if brush.gpencil_tool not in {'FILL', 'TINT'}:
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_brush_stroke")
|
|
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_paint_appearance")
|
|
elif tool_mode == 'SCULPT_GPENCIL':
|
|
if is_valid_context:
|
|
brush = context.tool_settings.gpencil_sculpt_paint.brush
|
|
if brush:
|
|
tool = brush.gpencil_sculpt_tool
|
|
if tool in {'SMOOTH', 'RANDOMIZE'}:
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_sculpt_brush_popover")
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_sculpt_appearance")
|
|
elif tool_mode == 'WEIGHT_GPENCIL':
|
|
if is_valid_context:
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_weight_appearance")
|
|
elif tool_mode == 'VERTEX_GPENCIL':
|
|
if is_valid_context:
|
|
layout.popover("VIEW3D_PT_tools_grease_pencil_vertex_appearance")
|
|
|
|
def draw_mode_settings(self, context):
|
|
layout = self.layout
|
|
mode_string = context.mode
|
|
|
|
def row_for_mirror():
|
|
row = layout.row(align=True)
|
|
row.label(icon='MOD_MIRROR')
|
|
sub = row.row(align=True)
|
|
sub.scale_x = 0.6
|
|
return row, sub
|
|
|
|
if mode_string == 'EDIT_ARMATURE':
|
|
_row, sub = row_for_mirror()
|
|
sub.prop(context.object.data, "use_mirror_x", text="X", toggle=True)
|
|
elif mode_string == 'POSE':
|
|
_row, sub = row_for_mirror()
|
|
sub.prop(context.object.pose, "use_mirror_x", text="X", toggle=True)
|
|
elif mode_string in {'EDIT_MESH', 'PAINT_WEIGHT', 'SCULPT', 'PAINT_VERTEX', 'PAINT_TEXTURE'}:
|
|
# Mesh Modes, Use Mesh Symmetry
|
|
row, sub = row_for_mirror()
|
|
sub.prop(context.object, "use_mesh_mirror_x", text="X", toggle=True)
|
|
sub.prop(context.object, "use_mesh_mirror_y", text="Y", toggle=True)
|
|
sub.prop(context.object, "use_mesh_mirror_z", text="Z", toggle=True)
|
|
|
|
if mode_string == 'EDIT_MESH':
|
|
tool_settings = context.tool_settings
|
|
layout.prop(tool_settings, "use_mesh_automerge", text="")
|
|
elif mode_string == 'PAINT_WEIGHT':
|
|
row.popover(panel="VIEW3D_PT_tools_weightpaint_symmetry_for_topbar", text="")
|
|
elif mode_string == 'SCULPT':
|
|
row.popover(panel="VIEW3D_PT_sculpt_symmetry_for_topbar", text="")
|
|
elif mode_string == 'PAINT_VERTEX':
|
|
row.popover(panel="VIEW3D_PT_tools_vertexpaint_symmetry_for_topbar", text="")
|
|
elif mode_string == 'SCULPT_CURVES':
|
|
_row, sub = row_for_mirror()
|
|
sub.prop(context.object.data, "use_mirror_x", text="X", toggle=True)
|
|
sub.prop(context.object.data, "use_mirror_y", text="Y", toggle=True)
|
|
sub.prop(context.object.data, "use_mirror_z", text="Z", toggle=True)
|
|
|
|
# Expand panels from the side-bar as popovers.
|
|
popover_kw = {"space_type": 'VIEW_3D', "region_type": 'UI', "category": "Tool"}
|
|
|
|
if mode_string == 'SCULPT':
|
|
layout.popover_group(context=".sculpt_mode", **popover_kw)
|
|
elif mode_string == 'PAINT_VERTEX':
|
|
layout.popover_group(context=".vertexpaint", **popover_kw)
|
|
elif mode_string == 'PAINT_WEIGHT':
|
|
layout.popover_group(context=".weightpaint", **popover_kw)
|
|
elif mode_string == 'PAINT_TEXTURE':
|
|
layout.popover_group(context=".imagepaint", **popover_kw)
|
|
elif mode_string == 'EDIT_TEXT':
|
|
layout.popover_group(context=".text_edit", **popover_kw)
|
|
elif mode_string == 'EDIT_ARMATURE':
|
|
layout.popover_group(context=".armature_edit", **popover_kw)
|
|
elif mode_string == 'EDIT_METABALL':
|
|
layout.popover_group(context=".mball_edit", **popover_kw)
|
|
elif mode_string == 'EDIT_LATTICE':
|
|
layout.popover_group(context=".lattice_edit", **popover_kw)
|
|
elif mode_string == 'EDIT_CURVE':
|
|
layout.popover_group(context=".curve_edit", **popover_kw)
|
|
elif mode_string == 'EDIT_MESH':
|
|
layout.popover_group(context=".mesh_edit", **popover_kw)
|
|
elif mode_string == 'POSE':
|
|
layout.popover_group(context=".posemode", **popover_kw)
|
|
elif mode_string == 'PARTICLE':
|
|
layout.popover_group(context=".particlemode", **popover_kw)
|
|
elif mode_string == 'OBJECT':
|
|
layout.popover_group(context=".objectmode", **popover_kw)
|
|
elif mode_string in {'PAINT_GPENCIL', 'EDIT_GPENCIL', 'SCULPT_GPENCIL', 'WEIGHT_GPENCIL'}:
|
|
# Grease pencil layer.
|
|
gpl = context.active_gpencil_layer
|
|
if gpl and gpl.info is not None:
|
|
text = gpl.info
|
|
maxw = 25
|
|
if len(text) > maxw:
|
|
text = text[:maxw - 5] + '..' + text[-3:]
|
|
else:
|
|
text = ""
|
|
|
|
layout.label(text="Layer:")
|
|
sub = layout.row()
|
|
sub.ui_units_x = 8
|
|
sub.popover(panel="TOPBAR_PT_gpencil_layers",
|
|
text=text,)
|
|
|
|
class _draw_tool_settings_context_mode:
|
|
@staticmethod
|
|
def SCULPT(header, context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
try:
|
|
row = layout.row()
|
|
row.operator_context = 'INVOKE_DEFAULT'
|
|
row.scale_y = 1.25
|
|
row.operator("sculpt.call_brush_palette", text="Palette")
|
|
except:
|
|
pass
|
|
|
|
paint = context.tool_settings.sculpt
|
|
row = layout.row()
|
|
row.ui_units_x = 4
|
|
row.template_ID_preview(paint, "brush", rows=3, cols=8, hide_buttons=True)
|
|
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
tool_settings = context.tool_settings
|
|
capabilities = brush.sculpt_capabilities
|
|
|
|
if capabilities.has_color:
|
|
#note we swap the labels here so users don't get confused.
|
|
row = layout.row(align=True)
|
|
row.ui_units_x = 4.5
|
|
row.prop_enum(context.space_data.shading, "color_type", "VERTEX", text="Colors")
|
|
row.prop_enum(context.space_data.shading, "color_type", "MATERIAL", text="Normal")
|
|
|
|
sculpt = tool_settings.sculpt
|
|
|
|
row1 = layout.row(align=True)
|
|
row1.use_property_split = False
|
|
row1.use_property_decorate = False
|
|
|
|
name_size_overrides = {
|
|
"accumulate" : ["Accu..", 2.5] #needs an icon
|
|
}
|
|
|
|
scene_radius = UnifiedPaintPanel.get_channel_value(context, brush, "radius_unit") == "SCENE"
|
|
|
|
for ch in brush.channels:
|
|
show_in_header = ch.show_in_header
|
|
|
|
if ch.idname == "radius" and scene_radius:
|
|
ch = brush.channels["unprojected_radius"]
|
|
|
|
final_ch = ch
|
|
|
|
if ch.inherit:
|
|
sculpt.channels.ensure(ch)
|
|
final_ch = sculpt.channels[ch.idname]
|
|
|
|
if show_in_header:
|
|
row = row1.row(align=False).row(align=True)
|
|
row.use_property_split = False
|
|
row.use_property_decorate = False
|
|
layoutuse_property_split = False
|
|
|
|
text = ch.name if ch.type in ["BOOL", "FLOAT", "INT"] else ""
|
|
|
|
if final_ch.type in ["VEC3", "VEC4"]:
|
|
row.ui_units_x = 2
|
|
text = ""
|
|
elif final_ch.type in ["INT", "FLOAT"]:
|
|
row.ui_units_x = 7
|
|
elif final_ch.type == "BOOL":
|
|
row.ui_units_x = 4
|
|
elif final_ch.type in ["ENUM", "BITMASK"]:
|
|
row.ui_units_x = 3
|
|
|
|
if len(text) > 0 and ch.idname in name_size_overrides:
|
|
text, row.ui_units_x = name_size_overrides[ch.idname]
|
|
|
|
row.prop(final_ch, "value", slider=True, expand=False, text=text)
|
|
|
|
sd = context.tool_settings.sculpt
|
|
sd.channels.ensure(ch)
|
|
|
|
if ch.mappings["PRESSURE"].inherit_mode != "NEVER":
|
|
pressurech = final_ch
|
|
|
|
if final_ch == ch and ch.mappings["PRESSURE"].inherit_mode == "ALWAYS":
|
|
sd = context.tool_settings.sculpt
|
|
sd.channels.ensure(ch)
|
|
pressurech = sd.channels[ch.idname]
|
|
else:
|
|
pressurech = ch
|
|
|
|
if ch.type in ["FLOAT", "INT"]:
|
|
row.prop(pressurech.mappings["PRESSURE"], "enabled", text="", icon="STYLUS_PRESSURE")
|
|
|
|
#UnifiedPaintPanel.channel_unified(row, context, brush,
|
|
#ch.idname, header=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def PAINT_TEXTURE(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
paint = context.tool_settings.image_paint
|
|
layout.template_ID_preview(paint, "brush", rows=3, cols=8, hide_buttons=True)
|
|
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
brush_basic_texpaint_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def PAINT_VERTEX(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
paint = context.tool_settings.vertex_paint
|
|
layout.template_ID_preview(paint, "brush", rows=3, cols=8, hide_buttons=True)
|
|
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
brush_basic_texpaint_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def PAINT_WEIGHT(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
paint = context.tool_settings.weight_paint
|
|
layout.template_ID_preview(paint, "brush", rows=3, cols=8, hide_buttons=True)
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
capabilities = brush.weight_paint_capabilities
|
|
if capabilities.has_weight:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"weight",
|
|
unified_name="use_unified_weight",
|
|
slider=True,
|
|
header=True)
|
|
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"size",
|
|
pressure_name="use_pressure_size",
|
|
unified_name="use_unified_size",
|
|
slider=True,
|
|
text="Radius",
|
|
header=True)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
pressure_name="use_pressure_strength",
|
|
unified_name="use_unified_strength",
|
|
header=True
|
|
)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def PAINT_GPENCIL(context, layout, tool):
|
|
if tool is None:
|
|
return False
|
|
|
|
if tool.idname == "builtin.cutter":
|
|
row = layout.row(align=True)
|
|
row.prop(context.tool_settings.gpencil_sculpt, "intersection_threshold")
|
|
return False
|
|
elif not tool.has_datablock:
|
|
return False
|
|
|
|
paint = context.tool_settings.gpencil_paint
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
gp_settings = brush.gpencil_settings
|
|
|
|
row = layout.row(align=True)
|
|
tool_settings = context.scene.tool_settings
|
|
settings = tool_settings.gpencil_paint
|
|
row.template_ID_preview(settings, "brush", rows=3, cols=8, hide_buttons=True)
|
|
|
|
if context.object and brush.gpencil_tool in {'FILL', 'DRAW'}:
|
|
from bl_ui.properties_paint_common import (
|
|
brush_basic__draw_color_selector,
|
|
)
|
|
brush_basic__draw_color_selector(context, layout, brush, gp_settings, None)
|
|
|
|
if context.object and brush.gpencil_tool == 'TINT':
|
|
row.separator(factor=0.4)
|
|
row.prop_with_popover(brush, "color", text="", panel="TOPBAR_PT_gpencil_vertexcolor")
|
|
|
|
from bl_ui.properties_paint_common import (
|
|
brush_basic_gpencil_paint_settings,
|
|
)
|
|
brush_basic_gpencil_paint_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def SCULPT_GPENCIL(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
paint = context.tool_settings.gpencil_sculpt_paint
|
|
brush = paint.brush
|
|
|
|
from bl_ui.properties_paint_common import (
|
|
brush_basic_gpencil_sculpt_settings,
|
|
)
|
|
brush_basic_gpencil_sculpt_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def WEIGHT_GPENCIL(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
paint = context.tool_settings.gpencil_weight_paint
|
|
brush = paint.brush
|
|
|
|
from bl_ui.properties_paint_common import (
|
|
brush_basic_gpencil_weight_settings,
|
|
)
|
|
brush_basic_gpencil_weight_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def VERTEX_GPENCIL(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
paint = context.tool_settings.gpencil_vertex_paint
|
|
brush = paint.brush
|
|
|
|
row = layout.row(align=True)
|
|
tool_settings = context.scene.tool_settings
|
|
settings = tool_settings.gpencil_vertex_paint
|
|
row.template_ID_preview(settings, "brush", rows=3, cols=8, hide_buttons=True)
|
|
|
|
if brush.gpencil_vertex_tool not in {'BLUR', 'AVERAGE', 'SMEAR'}:
|
|
row.separator(factor=0.4)
|
|
row.prop_with_popover(brush, "color", text="", panel="TOPBAR_PT_gpencil_vertexcolor")
|
|
|
|
from bl_ui.properties_paint_common import (
|
|
brush_basic_gpencil_vertex_settings,
|
|
)
|
|
|
|
brush_basic_gpencil_vertex_settings(layout, context, brush, compact=True)
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def PARTICLE(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
# See: 'VIEW3D_PT_tools_brush', basically a duplicate
|
|
settings = context.tool_settings.particle_edit
|
|
brush = settings.brush
|
|
tool = settings.tool
|
|
if tool == 'NONE':
|
|
return False
|
|
|
|
layout.prop(brush, "size", slider=True)
|
|
if tool == 'ADD':
|
|
layout.prop(brush, "count")
|
|
|
|
layout.prop(settings, "use_default_interpolate")
|
|
layout.prop(brush, "steps", slider=True)
|
|
layout.prop(settings, "default_key_count", slider=True)
|
|
else:
|
|
layout.prop(brush, "strength", slider=True)
|
|
|
|
if tool == 'LENGTH':
|
|
layout.row().prop(brush, "length_mode", expand=True)
|
|
elif tool == 'PUFF':
|
|
layout.row().prop(brush, "puff_mode", expand=True)
|
|
layout.prop(brush, "use_puff_volume")
|
|
elif tool == 'COMB':
|
|
row = layout.row()
|
|
row.active = settings.is_editable
|
|
row.prop(settings, "use_emitter_deflect", text="Deflect Emitter")
|
|
sub = row.row(align=True)
|
|
sub.active = settings.use_emitter_deflect
|
|
sub.prop(settings, "emitter_distance", text="Distance")
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def SCULPT_CURVES(context, layout, tool):
|
|
if (tool is None) or (not tool.has_datablock):
|
|
return False
|
|
|
|
tool_settings = context.tool_settings
|
|
paint = tool_settings.curves_sculpt
|
|
|
|
brush = paint.brush
|
|
if brush is None:
|
|
return False
|
|
|
|
UnifiedPaintPanel.prop_unified(
|
|
layout,
|
|
context,
|
|
brush,
|
|
"size",
|
|
unified_name="use_unified_size",
|
|
pressure_name="use_pressure_size",
|
|
text="Radius",
|
|
slider=True,
|
|
header=True,
|
|
)
|
|
|
|
if brush.curves_sculpt_tool not in {'ADD', 'DELETE'}:
|
|
UnifiedPaintPanel.prop_unified(
|
|
layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
unified_name="use_unified_strength",
|
|
pressure_name="use_pressure_strength",
|
|
header=True,
|
|
)
|
|
|
|
curves_tool = brush.curves_sculpt_tool
|
|
|
|
if curves_tool == 'COMB':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'ADD':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.prop(brush.curves_sculpt_settings, "add_amount")
|
|
layout.popover("VIEW3D_PT_curves_sculpt_add_shape", text="Curve Shape")
|
|
layout.prop(brush, "use_frontface", text="Front Faces Only")
|
|
elif curves_tool == 'GROW_SHRINK':
|
|
layout.prop(brush, "direction", expand=True, text="")
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_curves_sculpt_grow_shrink_scaling", text="Scaling")
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'SNAKE_HOOK':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'DELETE':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
elif curves_tool == 'SELECTION_PAINT':
|
|
layout.prop(brush, "direction", expand=True, text="")
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'PINCH':
|
|
layout.prop(brush, "direction", expand=True, text="")
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'SMOOTH':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'PUFF':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
elif curves_tool == 'DENSITY':
|
|
layout.prop(brush, "falloff_shape", expand=True)
|
|
row = layout.row(align=True)
|
|
row.prop(brush.curves_sculpt_settings, "density_mode", text="", expand=True)
|
|
row = layout.row(align=True)
|
|
row.prop(brush.curves_sculpt_settings, "minimum_distance", text="Distance Min")
|
|
row.operator_context = 'INVOKE_REGION_WIN'
|
|
row.operator("sculpt_curves.min_distance_edit", text="", icon='DRIVER_DISTANCE')
|
|
row = layout.row(align=True)
|
|
row.enabled = brush.curves_sculpt_settings.density_mode != 'REMOVE'
|
|
row.prop(brush.curves_sculpt_settings, "density_add_attempts", text="Count Max")
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
layout.popover("VIEW3D_PT_curves_sculpt_add_shape", text="Curve Shape")
|
|
elif curves_tool == "SLIDE":
|
|
layout.popover("VIEW3D_PT_tools_brush_falloff")
|
|
|
|
|
|
class VIEW3D_HT_header(Header):
|
|
bl_space_type = 'VIEW_3D'
|
|
|
|
@staticmethod
|
|
def draw_xform_template(layout, context):
|
|
obj = context.active_object
|
|
object_mode = 'OBJECT' if obj is None else obj.mode
|
|
has_pose_mode = ((object_mode == 'POSE') or (object_mode == 'WEIGHT_PAINT' and context.pose_object is not None))
|
|
|
|
tool_settings = context.tool_settings
|
|
|
|
# Mode & Transform Settings
|
|
scene = context.scene
|
|
|
|
# Orientation
|
|
if object_mode in {'OBJECT', 'EDIT', 'EDIT_GPENCIL'} or has_pose_mode:
|
|
orient_slot = scene.transform_orientation_slots[0]
|
|
row = layout.row(align=True)
|
|
|
|
sub = row.row()
|
|
sub.ui_units_x = 4
|
|
sub.prop_with_popover(orient_slot,
|
|
"type",
|
|
text="",
|
|
panel="VIEW3D_PT_transform_orientations",)
|
|
|
|
# Pivot
|
|
if object_mode in {'OBJECT', 'EDIT', 'EDIT_GPENCIL', 'SCULPT_GPENCIL'} or has_pose_mode:
|
|
layout.prop(tool_settings, "transform_pivot_point", text="", icon_only=True)
|
|
|
|
# Snap
|
|
show_snap = False
|
|
if obj is None:
|
|
show_snap = True
|
|
else:
|
|
if (object_mode not in {
|
|
'SCULPT', 'SCULPT_CURVES', 'VERTEX_PAINT', 'WEIGHT_PAINT', 'TEXTURE_PAINT',
|
|
'PAINT_GPENCIL', 'SCULPT_GPENCIL', 'WEIGHT_GPENCIL', 'VERTEX_GPENCIL',
|
|
}) or has_pose_mode:
|
|
show_snap = True
|
|
else:
|
|
|
|
paint_settings = UnifiedPaintPanel.paint_settings(context)
|
|
|
|
if paint_settings:
|
|
brush = paint_settings.brush
|
|
if brush and hasattr(brush, "stroke_method") and brush.stroke_method == 'CURVE':
|
|
show_snap = True
|
|
|
|
if show_snap:
|
|
snap_items = bpy.types.ToolSettings.bl_rna.properties["snap_elements"].enum_items
|
|
snap_elements = tool_settings.snap_elements
|
|
if len(snap_elements) == 1:
|
|
text = ""
|
|
for elem in snap_elements:
|
|
icon = snap_items[elem].icon
|
|
break
|
|
else:
|
|
text = "Mix"
|
|
icon = 'NONE'
|
|
del snap_items, snap_elements
|
|
|
|
row = layout.row(align=True)
|
|
row.prop(tool_settings, "use_snap", text="")
|
|
|
|
sub = row.row(align=True)
|
|
sub.popover(panel="VIEW3D_PT_snapping",
|
|
icon=icon,
|
|
text=text,)
|
|
|
|
# Proportional editing
|
|
if object_mode in {'EDIT', 'PARTICLE_EDIT', 'SCULPT_GPENCIL', 'EDIT_GPENCIL', 'OBJECT'}:
|
|
row = layout.row(align=True)
|
|
kw = {}
|
|
if object_mode == 'OBJECT':
|
|
attr = "use_proportional_edit_objects"
|
|
else:
|
|
attr = "use_proportional_edit"
|
|
|
|
if tool_settings.use_proportional_edit:
|
|
if tool_settings.use_proportional_connected:
|
|
kw["icon"] = 'PROP_CON'
|
|
elif tool_settings.use_proportional_projected:
|
|
kw["icon"] = 'PROP_PROJECTED'
|
|
else:
|
|
kw["icon"] = 'PROP_ON'
|
|
else:
|
|
kw["icon"] = 'PROP_OFF'
|
|
|
|
row.prop(tool_settings, attr, icon_only=True, **kw)
|
|
sub = row.row(align=True)
|
|
sub.active = getattr(tool_settings, attr)
|
|
sub.prop_with_popover(tool_settings,
|
|
"proportional_edit_falloff",
|
|
text="",
|
|
icon_only=True,
|
|
panel="VIEW3D_PT_proportional_edit",)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
tool_settings = context.tool_settings
|
|
view = context.space_data
|
|
shading = view.shading
|
|
|
|
layout.row(align=True).template_header()
|
|
|
|
row = layout.row(align=True)
|
|
obj = context.active_object
|
|
# mode_string = context.mode
|
|
object_mode = 'OBJECT' if obj is None else obj.mode
|
|
has_pose_mode = ((object_mode == 'POSE') or (object_mode == 'WEIGHT_PAINT' and context.pose_object is not None))
|
|
|
|
# Note: This is actually deadly in case enum_items have to be
|
|
# dynamically generated
|
|
# (because internal RNA array iterator will free everything
|
|
# immediately...).
|
|
# XXX This is an RNA internal issue, not sure how to fix it.
|
|
# Note: Tried to add an accessor to get translated UI strings instead
|
|
# of manual call
|
|
# to pgettext_iface below, but this fails because translated
|
|
# enumitems
|
|
# are always dynamically allocated.
|
|
act_mode_item = bpy.types.Object.bl_rna.properties["mode"].enum_items[object_mode]
|
|
act_mode_i18n_context = bpy.types.Object.bl_rna.properties["mode"].translation_context
|
|
|
|
sub = row.row(align=True)
|
|
sub.ui_units_x = 5.5
|
|
sub.operator_menu_enum(
|
|
"object.mode_set", "mode",
|
|
text=iface_(act_mode_item.name, act_mode_i18n_context),
|
|
icon=act_mode_item.icon,
|
|
)
|
|
del act_mode_item
|
|
|
|
layout.template_header_3D_mode()
|
|
|
|
# Contains buttons like Mode, Pivot, Layer, Mesh Select Mode...
|
|
if obj:
|
|
# Particle edit
|
|
if object_mode == 'PARTICLE_EDIT':
|
|
row = layout.row()
|
|
row.prop(tool_settings.particle_edit, "select_mode", text="", expand=True)
|
|
elif object_mode in {'EDIT', 'SCULPT_CURVES'} and obj.type == 'CURVES':
|
|
curves = obj.data
|
|
|
|
row = layout.row(align=True)
|
|
domain = curves.selection_domain
|
|
row.operator(
|
|
"curves.set_selection_domain",
|
|
text="",
|
|
icon='CURVE_BEZCIRCLE',
|
|
depress=(domain == 'POINT'),
|
|
).domain = 'POINT'
|
|
row.operator(
|
|
"curves.set_selection_domain",
|
|
text="",
|
|
icon='CURVE_PATH',
|
|
depress=(domain == 'CURVE'),
|
|
).domain = 'CURVE'
|
|
|
|
# Grease Pencil
|
|
if obj and obj.type == 'GPENCIL' and context.gpencil_data:
|
|
gpd = context.gpencil_data
|
|
|
|
if gpd.is_stroke_paint_mode:
|
|
row = layout.row()
|
|
sub = row.row(align=True)
|
|
sub.prop(tool_settings, "use_gpencil_draw_onback", text="", icon='MOD_OPACITY')
|
|
sub.separator(factor=0.4)
|
|
sub.prop(tool_settings, "use_gpencil_automerge_strokes", text="")
|
|
sub.separator(factor=0.4)
|
|
sub.prop(tool_settings, "use_gpencil_weight_data_add", text="", icon='WPAINT_HLT')
|
|
sub.separator(factor=0.4)
|
|
sub.prop(tool_settings, "use_gpencil_draw_additive", text="", icon='FREEZE')
|
|
|
|
# Select mode for Editing
|
|
if gpd.use_stroke_edit_mode:
|
|
row = layout.row(align=True)
|
|
row.prop_enum(tool_settings, "gpencil_selectmode_edit", text="", value='POINT')
|
|
row.prop_enum(tool_settings, "gpencil_selectmode_edit", text="", value='STROKE')
|
|
|
|
subrow = row.row(align=True)
|
|
subrow.enabled = not gpd.use_curve_edit
|
|
subrow.prop_enum(tool_settings, "gpencil_selectmode_edit", text="", value='SEGMENT')
|
|
|
|
# Curve edit submode
|
|
row = layout.row(align=True)
|
|
row.prop(gpd, "use_curve_edit", text="",
|
|
icon='IPO_BEZIER')
|
|
sub = row.row(align=True)
|
|
sub.active = gpd.use_curve_edit
|
|
sub.popover(panel="VIEW3D_PT_gpencil_curve_edit",
|
|
text="Curve Editing",)
|
|
|
|
# Select mode for Sculpt
|
|
if gpd.is_stroke_sculpt_mode:
|
|
row = layout.row(align=True)
|
|
row.prop(tool_settings, "use_gpencil_select_mask_point", text="")
|
|
row.prop(tool_settings, "use_gpencil_select_mask_stroke", text="")
|
|
row.prop(tool_settings, "use_gpencil_select_mask_segment", text="")
|
|
|
|
# Select mode for Vertex Paint
|
|
if gpd.is_stroke_vertex_mode:
|
|
row = layout.row(align=True)
|
|
row.prop(tool_settings, "use_gpencil_vertex_select_mask_point", text="")
|
|
row.prop(tool_settings, "use_gpencil_vertex_select_mask_stroke", text="")
|
|
row.prop(tool_settings, "use_gpencil_vertex_select_mask_segment", text="")
|
|
|
|
if gpd.is_stroke_paint_mode:
|
|
row = layout.row(align=True)
|
|
row.prop(gpd, "use_multiedit", text="", icon='GP_MULTIFRAME_EDITING')
|
|
|
|
if (gpd.use_stroke_edit_mode or gpd.is_stroke_sculpt_mode or gpd.is_stroke_weight_mode or gpd.is_stroke_vertex_mode):
|
|
row = layout.row(align=True)
|
|
row.prop(gpd, "use_multiedit", text="", icon='GP_MULTIFRAME_EDITING')
|
|
|
|
sub = row.row(align=True)
|
|
sub.enabled = gpd.use_multiedit
|
|
sub.popover(panel="VIEW3D_PT_gpencil_multi_frame",
|
|
text="Multiframe",)
|
|
|
|
overlay = view.overlay
|
|
|
|
VIEW3D_MT_editor_menus.draw_collapsible(context, layout)
|
|
|
|
layout.separator_spacer()
|
|
|
|
if object_mode in {'PAINT_GPENCIL', 'SCULPT_GPENCIL'}:
|
|
# Grease pencil
|
|
if object_mode == 'PAINT_GPENCIL':
|
|
layout.prop_with_popover(tool_settings,
|
|
"gpencil_stroke_placement_view3d",
|
|
text="",
|
|
panel="VIEW3D_PT_gpencil_origin",)
|
|
|
|
if object_mode in {'PAINT_GPENCIL', 'SCULPT_GPENCIL'}:
|
|
layout.prop_with_popover(tool_settings.gpencil_sculpt,
|
|
"lock_axis",
|
|
text="",
|
|
panel="VIEW3D_PT_gpencil_lock",)
|
|
|
|
if object_mode == 'PAINT_GPENCIL':
|
|
# FIXME: this is bad practice!
|
|
# Tool options are to be displayed in the topbar.
|
|
if context.workspace.tools.from_space_view3d_mode(object_mode).idname == "builtin_brush.Draw":
|
|
settings = tool_settings.gpencil_sculpt.guide
|
|
row = layout.row(align=True)
|
|
row.prop(settings, "use_guide", text="", icon='GRID')
|
|
sub = row.row(align=True)
|
|
sub.active = settings.use_guide
|
|
sub.popover(
|
|
panel="VIEW3D_PT_gpencil_guide",
|
|
text="Guides",
|
|
)
|
|
if object_mode == 'SCULPT_GPENCIL':
|
|
layout.popover(
|
|
panel="VIEW3D_PT_gpencil_sculpt_automasking",
|
|
text="",
|
|
icon='MOD_MASK',
|
|
)
|
|
elif object_mode == 'SCULPT':
|
|
layout.popover(
|
|
panel="VIEW3D_PT_sculpt_automasking",
|
|
text="",
|
|
icon='MOD_MASK',
|
|
)
|
|
else:
|
|
# Transform settings depending on tool header visibility
|
|
VIEW3D_HT_header.draw_xform_template(layout, context)
|
|
|
|
layout.separator_spacer()
|
|
|
|
# Viewport Settings
|
|
layout.popover(panel="VIEW3D_PT_object_type_visibility",
|
|
icon_value=view.icon_from_show_object_viewport,
|
|
text="",)
|
|
|
|
# Gizmo toggle & popover.
|
|
row = layout.row(align=True)
|
|
# FIXME: place-holder icon.
|
|
row.prop(view, "show_gizmo", text="", toggle=True, icon='GIZMO')
|
|
sub = row.row(align=True)
|
|
sub.active = view.show_gizmo
|
|
sub.popover(panel="VIEW3D_PT_gizmo_display",
|
|
text="",)
|
|
|
|
# Overlay toggle & popover.
|
|
row = layout.row(align=True)
|
|
row.prop(overlay, "show_overlays", icon='OVERLAY', text="")
|
|
sub = row.row(align=True)
|
|
sub.active = overlay.show_overlays
|
|
sub.popover(panel="VIEW3D_PT_overlay", text="")
|
|
|
|
row = layout.row()
|
|
row.active = (object_mode == 'EDIT') or (shading.type in {'WIREFRAME', 'SOLID'})
|
|
|
|
# While exposing `shading.show_xray(_wireframe)` is correct.
|
|
# this hides the key shortcut from users: T70433.
|
|
if has_pose_mode:
|
|
draw_depressed = overlay.show_xray_bone
|
|
elif shading.type == 'WIREFRAME':
|
|
draw_depressed = shading.show_xray_wireframe
|
|
else:
|
|
draw_depressed = shading.show_xray
|
|
row.operator("view3d.toggle_xray",
|
|
text="",
|
|
icon='XRAY',
|
|
depress=draw_depressed,)
|
|
|
|
row = layout.row(align=True)
|
|
row.prop(shading, "type", text="", expand=True)
|
|
sub = row.row(align=True)
|
|
# TODO, currently render shading type ignores mesh two-side, until it's
|
|
# supported
|
|
# show the shading popover which shows double-sided option.
|
|
|
|
# sub.enabled = shading.type != 'RENDERED'
|
|
sub.popover(panel="VIEW3D_PT_shading", text="")
|
|
|
|
|
|
class VIEW3D_MT_editor_menus(Menu):
|
|
bl_label = ""
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
obj = context.active_object
|
|
mode_string = context.mode
|
|
edit_object = context.edit_object
|
|
gp_edit = obj and obj.mode in {'EDIT_GPENCIL', 'PAINT_GPENCIL', 'SCULPT_GPENCIL',
|
|
'WEIGHT_GPENCIL', 'VERTEX_GPENCIL'}
|
|
ts = context.scene.tool_settings
|
|
|
|
layout.menu("VIEW3D_MT_view")
|
|
|
|
# Select Menu
|
|
if gp_edit:
|
|
if mode_string not in {'PAINT_GPENCIL', 'WEIGHT_GPENCIL'}:
|
|
if (mode_string == 'SCULPT_GPENCIL' and (ts.use_gpencil_select_mask_point or ts.use_gpencil_select_mask_stroke or ts.use_gpencil_select_mask_segment)):
|
|
layout.menu("VIEW3D_MT_select_gpencil")
|
|
elif mode_string == 'EDIT_GPENCIL':
|
|
layout.menu("VIEW3D_MT_select_gpencil")
|
|
elif mode_string == 'VERTEX_GPENCIL':
|
|
layout.menu("VIEW3D_MT_select_gpencil")
|
|
elif mode_string in {'PAINT_WEIGHT', 'PAINT_VERTEX', 'PAINT_TEXTURE'}:
|
|
mesh = obj.data
|
|
if mesh.use_paint_mask:
|
|
layout.menu("VIEW3D_MT_select_paint_mask")
|
|
elif mesh.use_paint_mask_vertex and mode_string in {'PAINT_WEIGHT', 'PAINT_VERTEX'}:
|
|
layout.menu("VIEW3D_MT_select_paint_mask_vertex")
|
|
elif mode_string not in {'SCULPT', 'SCULPT_CURVES'}:
|
|
layout.menu("VIEW3D_MT_select_%s" % mode_string.lower())
|
|
|
|
if gp_edit:
|
|
pass
|
|
elif mode_string == 'OBJECT':
|
|
layout.menu("VIEW3D_MT_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
elif mode_string == 'EDIT_MESH':
|
|
layout.menu("VIEW3D_MT_mesh_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
elif mode_string == 'EDIT_CURVE':
|
|
layout.menu("VIEW3D_MT_curve_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
elif mode_string == 'EDIT_SURFACE':
|
|
layout.menu("VIEW3D_MT_surface_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
elif mode_string == 'EDIT_METABALL':
|
|
layout.menu("VIEW3D_MT_metaball_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
elif mode_string == 'EDIT_ARMATURE':
|
|
layout.menu("TOPBAR_MT_edit_armature_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
|
|
if gp_edit:
|
|
if obj and obj.mode == 'PAINT_GPENCIL':
|
|
layout.menu("VIEW3D_MT_draw_gpencil")
|
|
elif obj and obj.mode == 'EDIT_GPENCIL':
|
|
layout.menu("VIEW3D_MT_edit_gpencil")
|
|
layout.menu("VIEW3D_MT_edit_gpencil_stroke")
|
|
layout.menu("VIEW3D_MT_edit_gpencil_point")
|
|
elif obj and obj.mode == 'WEIGHT_GPENCIL':
|
|
layout.menu("VIEW3D_MT_weight_gpencil")
|
|
if obj and obj.mode == 'VERTEX_GPENCIL':
|
|
layout.menu("VIEW3D_MT_paint_gpencil")
|
|
|
|
elif edit_object:
|
|
layout.menu("VIEW3D_MT_edit_%s" % edit_object.type.lower())
|
|
|
|
if mode_string == 'EDIT_MESH':
|
|
layout.menu("VIEW3D_MT_edit_mesh_vertices")
|
|
layout.menu("VIEW3D_MT_edit_mesh_edges")
|
|
layout.menu("VIEW3D_MT_edit_mesh_faces")
|
|
layout.menu("VIEW3D_MT_uv_map", text="UV")
|
|
elif mode_string in {'EDIT_CURVE', 'EDIT_SURFACE'}:
|
|
layout.menu("VIEW3D_MT_edit_curve_ctrlpoints")
|
|
layout.menu("VIEW3D_MT_edit_curve_segments")
|
|
|
|
elif obj:
|
|
if mode_string not in {'PAINT_TEXTURE', 'SCULPT_CURVES'}:
|
|
layout.menu("VIEW3D_MT_%s" % mode_string.lower())
|
|
if mode_string == 'SCULPT':
|
|
layout.menu("VIEW3D_MT_mask")
|
|
layout.menu("VIEW3D_MT_face_sets")
|
|
if mode_string == 'SCULPT_CURVES':
|
|
layout.menu("VIEW3D_MT_select_sculpt_curves")
|
|
layout.menu("VIEW3D_MT_sculpt_curves")
|
|
|
|
else:
|
|
layout.menu("VIEW3D_MT_object")
|
|
|
|
|
|
# ********** Menu **********
|
|
|
|
|
|
# ********** Utilities **********
|
|
class ShowHideMenu:
|
|
bl_label = "Show/Hide"
|
|
_operator_name = ""
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("%s.reveal" % self._operator_name)
|
|
layout.operator("%s.hide" % self._operator_name, text="Hide Selected").unselected = False
|
|
layout.operator("%s.hide" % self._operator_name, text="Hide Unselected").unselected = True
|
|
|
|
|
|
# Standard transforms which apply to all cases (mix-in class, not used
|
|
# directly).
|
|
class VIEW3D_MT_transform_base:
|
|
bl_label = "Transform"
|
|
bl_category = "View"
|
|
|
|
# TODO: get rid of the custom text strings?
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator("transform.translate")
|
|
layout.operator("transform.rotate")
|
|
layout.operator("transform.resize", text="Scale")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.tosphere", text="To Sphere")
|
|
layout.operator("transform.shear", text="Shear")
|
|
layout.operator("transform.bend", text="Bend")
|
|
layout.operator("transform.push_pull", text="Push/Pull")
|
|
|
|
if context.mode in {'EDIT_MESH', 'EDIT_ARMATURE', 'EDIT_SURFACE', 'EDIT_CURVE',
|
|
'EDIT_LATTICE', 'EDIT_METABALL'}:
|
|
layout.operator("transform.vertex_warp", text="Warp")
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("transform.vertex_random", text="Randomize").offset = 0.1
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
|
|
# Generic transform menu - geometry types
|
|
class VIEW3D_MT_transform(VIEW3D_MT_transform_base, Menu):
|
|
def draw(self, context):
|
|
# base menu
|
|
VIEW3D_MT_transform_base.draw(self, context)
|
|
|
|
# generic...
|
|
layout = self.layout
|
|
if context.mode == 'EDIT_MESH':
|
|
layout.operator("transform.shrink_fatten", text="Shrink/Fatten")
|
|
layout.operator("transform.skin_resize")
|
|
elif context.mode == 'EDIT_CURVE':
|
|
layout.operator("transform.transform", text="Radius").mode = 'CURVE_SHRINKFATTEN'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.translate", text="Move Texture Space").texture_space = True
|
|
layout.operator("transform.resize", text="Scale Texture Space").texture_space = True
|
|
|
|
|
|
# Object-specific extensions to Transform menu
|
|
class VIEW3D_MT_transform_object(VIEW3D_MT_transform_base, Menu):
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
# base menu
|
|
VIEW3D_MT_transform_base.draw(self, context)
|
|
|
|
# object-specific option follow...
|
|
layout.separator()
|
|
|
|
layout.operator("transform.translate", text="Move Texture Space").texture_space = True
|
|
layout.operator("transform.resize", text="Scale Texture Space").texture_space = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
# XXX see alignmenu() in edit.c of b2.4x to get this working
|
|
layout.operator("transform.transform", text="Align to Transform Orientation").mode = 'ALIGN'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.randomize_transform")
|
|
layout.operator("object.align")
|
|
|
|
# TODO: there is a strange context bug here.
|
|
"""
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator("object.transform_axis_target")
|
|
"""
|
|
|
|
|
|
# Armature EditMode extensions to Transform menu
|
|
class VIEW3D_MT_transform_armature(VIEW3D_MT_transform_base, Menu):
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
# base menu
|
|
VIEW3D_MT_transform_base.draw(self, context)
|
|
|
|
# armature specific extensions follow...
|
|
obj = context.object
|
|
if obj.type == 'ARMATURE' and obj.mode in {'EDIT', 'POSE'}:
|
|
if obj.data.display_type == 'BBONE':
|
|
layout.separator()
|
|
|
|
layout.operator("transform.transform", text="Scale BBone").mode = 'BONE_SIZE'
|
|
elif obj.data.display_type == 'ENVELOPE':
|
|
layout.separator()
|
|
|
|
layout.operator("transform.transform", text="Scale Envelope Distance").mode = 'BONE_SIZE'
|
|
layout.operator("transform.transform", text="Scale Radius").mode = 'BONE_ENVELOPE'
|
|
|
|
if context.edit_object and context.edit_object.type == 'ARMATURE':
|
|
layout.separator()
|
|
|
|
layout.operator("armature.align")
|
|
|
|
|
|
class VIEW3D_MT_mirror(Menu):
|
|
bl_label = "Mirror"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("transform.mirror", text="Interactive Mirror")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
|
|
for (space_name, space_id) in (("Global", 'GLOBAL'), ("Local", 'LOCAL')):
|
|
for axis_index, axis_name in enumerate("XYZ"):
|
|
props = layout.operator("transform.mirror",
|
|
text="%s %s" % (axis_name, iface_(space_name)),
|
|
translate=False)
|
|
props.constraint_axis[axis_index] = True
|
|
props.orient_type = space_id
|
|
|
|
if space_id == 'GLOBAL':
|
|
layout.separator()
|
|
|
|
|
|
class VIEW3D_MT_snap(Menu):
|
|
bl_label = "Snap"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("view3d.snap_selected_to_grid", text="Selection to Grid")
|
|
layout.operator("view3d.snap_selected_to_cursor", text="Selection to Cursor").use_offset = False
|
|
layout.operator("view3d.snap_selected_to_cursor", text="Selection to Cursor (Keep Offset)").use_offset = True
|
|
layout.operator("view3d.snap_selected_to_active", text="Selection to Active")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.snap_cursor_to_selected", text="Cursor to Selected")
|
|
layout.operator("view3d.snap_cursor_to_center", text="Cursor to World Origin")
|
|
layout.operator("view3d.snap_cursor_to_grid", text="Cursor to Grid")
|
|
layout.operator("view3d.snap_cursor_to_active", text="Cursor to Active")
|
|
|
|
|
|
class VIEW3D_MT_uv_map(Menu):
|
|
bl_label = "UV Mapping"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("uv.unwrap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
layout.operator("uv.smart_project")
|
|
layout.operator("uv.lightmap_pack")
|
|
layout.operator("uv.follow_active_quads")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("uv.cube_project")
|
|
layout.operator("uv.cylinder_project")
|
|
layout.operator("uv.sphere_project")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator("uv.project_from_view").scale_to_bounds = False
|
|
layout.operator("uv.project_from_view", text="Project from View (Bounds)").scale_to_bounds = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.mark_seam").clear = False
|
|
layout.operator("mesh.mark_seam", text="Clear Seam").clear = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("uv.reset")
|
|
|
|
|
|
# ********** View menus **********
|
|
class VIEW3D_MT_view(Menu):
|
|
bl_label = "View"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
|
|
layout.prop(view, "show_region_toolbar")
|
|
layout.prop(view, "show_region_ui")
|
|
layout.prop(view, "show_region_tool_header")
|
|
layout.prop(view, "show_region_hud")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_selected", text="Frame Selected").use_all_regions = False
|
|
if view.region_quadviews:
|
|
layout.operator("view3d.view_selected", text="Frame Selected (Quad View)").use_all_regions = True
|
|
|
|
layout.operator("view3d.view_all").center = False
|
|
layout.operator("view3d.view_persportho", text="Perspective/Orthographic")
|
|
layout.menu("VIEW3D_MT_view_local")
|
|
layout.prop(view, "show_viewer", text="Viewer Node")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_view_cameras", text="Cameras")
|
|
|
|
layout.separator()
|
|
layout.menu("VIEW3D_MT_view_viewpoint")
|
|
layout.menu("VIEW3D_MT_view_navigation")
|
|
layout.menu("VIEW3D_MT_view_align")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.menu("VIEW3D_MT_view_regions", text="View Regions")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("screen.animation_play", text="Play Animation")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator(
|
|
"render.opengl",
|
|
text="Viewport Render Image",
|
|
icon='RENDER_STILL',
|
|
)
|
|
layout.operator(
|
|
"render.opengl",
|
|
text="Viewport Render Animation",
|
|
icon='RENDER_ANIMATION',
|
|
).animation = True
|
|
props = layout.operator(
|
|
"render.opengl",
|
|
text="Viewport Render Keyframes",
|
|
icon='RENDER_ANIMATION',
|
|
)
|
|
props.animation = True
|
|
props.render_keyed_only = True
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("INFO_MT_area")
|
|
|
|
|
|
class VIEW3D_MT_view_local(Menu):
|
|
bl_label = "Local View"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("view3d.localview", text="Toggle Local View")
|
|
layout.operator("view3d.localview_remove_from")
|
|
|
|
|
|
class VIEW3D_MT_view_cameras(Menu):
|
|
bl_label = "Cameras"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("view3d.object_as_camera")
|
|
layout.operator("view3d.view_camera", text="Active Camera")
|
|
layout.operator("view3d.view_center_camera")
|
|
|
|
|
|
class VIEW3D_MT_view_viewpoint(Menu):
|
|
bl_label = "Viewpoint"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("view3d.view_camera", text="Camera", text_ctxt=i18n_contexts.editor_view3d)
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_axis", text="Top", text_ctxt=i18n_contexts.editor_view3d).type = 'TOP'
|
|
layout.operator("view3d.view_axis", text="Bottom", text_ctxt=i18n_contexts.editor_view3d).type = 'BOTTOM'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_axis", text="Front", text_ctxt=i18n_contexts.editor_view3d).type = 'FRONT'
|
|
layout.operator("view3d.view_axis", text="Back", text_ctxt=i18n_contexts.editor_view3d).type = 'BACK'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_axis", text="Right", text_ctxt=i18n_contexts.editor_view3d).type = 'RIGHT'
|
|
layout.operator("view3d.view_axis", text="Left", text_ctxt=i18n_contexts.editor_view3d).type = 'LEFT'
|
|
|
|
|
|
class VIEW3D_MT_view_navigation(Menu):
|
|
bl_label = "Navigation"
|
|
|
|
def draw(self, _context):
|
|
from math import pi
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("view3d.view_orbit", "type")
|
|
props = layout.operator("view3d.view_orbit", text="Orbit Opposite")
|
|
props.type = 'ORBITRIGHT'
|
|
props.angle = pi
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_roll", text="Roll Left").type = 'LEFT'
|
|
layout.operator("view3d.view_roll", text="Roll Right").type = 'RIGHT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_enum("view3d.view_pan", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.zoom", text="Zoom In").delta = 1
|
|
layout.operator("view3d.zoom", text="Zoom Out").delta = -1
|
|
layout.operator("view3d.zoom_border", text="Zoom Region...")
|
|
layout.operator("view3d.dolly", text="Dolly View...")
|
|
layout.operator("view3d.zoom_camera_1_to_1", text="Zoom Camera 1:1")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.fly")
|
|
layout.operator("view3d.walk")
|
|
|
|
|
|
class VIEW3D_MT_view_align(Menu):
|
|
bl_label = "Align View"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_view_align_selected")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.camera_to_view", text="Align Active Camera to View")
|
|
layout.operator("view3d.camera_to_view_selected", text="Align Active Camera to Selected")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_all", text="Center Cursor and Frame All").center = True
|
|
layout.operator("view3d.view_center_cursor")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.view_lock_to_active")
|
|
layout.operator("view3d.view_lock_clear")
|
|
|
|
|
|
class VIEW3D_MT_view_align_selected(Menu):
|
|
bl_label = "Align View to Active"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
props = layout.operator("view3d.view_axis", text="Top", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'TOP'
|
|
|
|
props = layout.operator("view3d.view_axis", text="Bottom", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'BOTTOM'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("view3d.view_axis", text="Front", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'FRONT'
|
|
|
|
props = layout.operator("view3d.view_axis", text="Back", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'BACK'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("view3d.view_axis", text="Right", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'RIGHT'
|
|
|
|
props = layout.operator("view3d.view_axis", text="Left", text_ctxt=i18n_contexts.editor_view3d)
|
|
props.align_active = True
|
|
props.type = 'LEFT'
|
|
|
|
|
|
class VIEW3D_MT_view_regions(Menu):
|
|
bl_label = "View Regions"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("view3d.clip_border", text="Clipping Region...")
|
|
layout.operator("view3d.render_border", text="Render Region...")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.clear_render_border")
|
|
|
|
|
|
# ********** Select menus, suffix from context.mode **********
|
|
class VIEW3D_MT_select_object_more_less(Menu):
|
|
bl_label = "Select More/Less"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout = self.layout
|
|
|
|
layout.operator("object.select_more", text="More")
|
|
layout.operator("object.select_less", text="Less")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("object.select_hierarchy", text="Parent")
|
|
props.extend = False
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("object.select_hierarchy", text="Child")
|
|
props.extend = False
|
|
props.direction = 'CHILD'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("object.select_hierarchy", text="Extend Parent")
|
|
props.extend = True
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("object.select_hierarchy", text="Extend Child")
|
|
props.extend = True
|
|
props.direction = 'CHILD'
|
|
|
|
|
|
class VIEW3D_MT_select_object(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.select_all", text="All").action = 'SELECT'
|
|
layout.operator("object.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("object.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.select_by_type", "type", text="Select All by Type")
|
|
layout.operator("object.select_camera", text="Select Active Camera")
|
|
layout.operator("object.select_mirror")
|
|
layout.operator("object.select_random", text="Select Random")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_select_object_more_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.select_grouped", "type", text="Select Grouped")
|
|
layout.operator_menu_enum("object.select_linked", "type", text="Select Linked")
|
|
layout.operator("object.select_pattern", text="Select Pattern...")
|
|
|
|
|
|
class VIEW3D_MT_select_pose_more_less(Menu):
|
|
bl_label = "Select More/Less"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout = self.layout
|
|
|
|
props = layout.operator("pose.select_hierarchy", text="Parent")
|
|
props.extend = False
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("pose.select_hierarchy", text="Child")
|
|
props.extend = False
|
|
props.direction = 'CHILD'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("pose.select_hierarchy", text="Extend Parent")
|
|
props.extend = True
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("pose.select_hierarchy", text="Extend Child")
|
|
props.extend = True
|
|
props.direction = 'CHILD'
|
|
|
|
|
|
class VIEW3D_MT_select_pose(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.select_all", text="All").action = 'SELECT'
|
|
layout.operator("pose.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("pose.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.select_mirror")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.select_constraint_target", text="Constraint Target")
|
|
layout.operator("pose.select_linked", text="Linked")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_select_pose_more_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("pose.select_grouped", "type", text="Grouped")
|
|
layout.operator("object.select_pattern", text="Select Pattern...")
|
|
|
|
|
|
class VIEW3D_MT_select_particle(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("particle.select_all", text="All").action = 'SELECT'
|
|
layout.operator("particle.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("particle.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_linked", text="Select Linked")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_more")
|
|
layout.operator("particle.select_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_random")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_roots", text="Roots")
|
|
layout.operator("particle.select_tips", text="Tips")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_similar(Menu):
|
|
bl_label = "Select Similar"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("mesh.select_similar", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.select_similar_region", text="Face Regions")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_by_trait(Menu):
|
|
bl_label = "Select All by Trait"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
if tool_settings.mesh_select_mode[2] is False:
|
|
layout.operator("mesh.select_non_manifold", text="Non Manifold")
|
|
layout.operator("mesh.select_loose", text="Loose Geometry")
|
|
layout.operator("mesh.select_interior_faces", text="Interior Faces")
|
|
layout.operator("mesh.select_face_by_sides", text="Faces by Sides")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.select_ungrouped", text="Ungrouped Vertices")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_more_less(Menu):
|
|
bl_label = "Select More/Less"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.select_more", text="More")
|
|
layout.operator("mesh.select_less", text="Less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.select_next_item", text="Next Active")
|
|
layout.operator("mesh.select_prev_item", text="Previous Active")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_linked(Menu):
|
|
bl_label = "Select Linked"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.select_linked", text="Linked")
|
|
layout.operator("mesh.shortest_path_select", text="Shortest Path")
|
|
layout.operator("mesh.faces_select_linked_flat", text="Linked Flat Faces")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_loops(Menu):
|
|
bl_label = "Select Loops"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.loop_multi_select", text="Edge Loops").ring = False
|
|
layout.operator("mesh.loop_multi_select", text="Edge Rings").ring = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.loop_to_region")
|
|
layout.operator("mesh.region_to_loop")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_mesh(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
# primitive
|
|
layout.operator("mesh.select_all", text="All").action = 'SELECT'
|
|
layout.operator("mesh.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("mesh.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
# numeric
|
|
layout.operator("mesh.select_random", text="Select Random")
|
|
layout.operator("mesh.select_nth")
|
|
|
|
layout.separator()
|
|
|
|
# geometric
|
|
layout.operator("mesh.edges_select_sharp", text="Select Sharp Edges")
|
|
|
|
layout.separator()
|
|
|
|
# other ...
|
|
layout.menu("VIEW3D_MT_edit_mesh_select_similar")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_select_by_trait")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_select_more_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_select_loops")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_select_linked")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.select_axis", text="Side of Active")
|
|
layout.operator("mesh.select_mirror")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_curve(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curve.select_all", text="All").action = 'SELECT'
|
|
layout.operator("curve.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("curve.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.select_random")
|
|
layout.operator("curve.select_nth")
|
|
layout.operator("curve.select_linked", text="Select Linked")
|
|
layout.operator("curve.select_similar", text="Select Similar")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.de_select_first")
|
|
layout.operator("curve.de_select_last")
|
|
layout.operator("curve.select_next")
|
|
layout.operator("curve.select_previous")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.select_more")
|
|
layout.operator("curve.select_less")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_surface(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curve.select_all", text="All").action = 'SELECT'
|
|
layout.operator("curve.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("curve.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.select_random")
|
|
layout.operator("curve.select_nth")
|
|
layout.operator("curve.select_linked", text="Select Linked")
|
|
layout.operator("curve.select_similar", text="Select Similar")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.select_row")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.select_more")
|
|
layout.operator("curve.select_less")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_text(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("font.select_all", text="All")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.move_select", text="Previous Block").type = 'PREVIOUS_PAGE'
|
|
layout.operator("font.move_select", text="Next Block").type = 'NEXT_PAGE'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.move_select", text="Line Begin").type = 'LINE_BEGIN'
|
|
layout.operator("font.move_select", text="Line End").type = 'LINE_END'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.move_select", text="Previous Line").type = 'PREVIOUS_LINE'
|
|
layout.operator("font.move_select", text="Next Line").type = 'NEXT_LINE'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.move_select", text="Previous Word").type = 'PREVIOUS_WORD'
|
|
layout.operator("font.move_select", text="Next Word").type = 'NEXT_WORD'
|
|
|
|
|
|
class VIEW3D_MT_select_edit_metaball(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mball.select_all", text="All").action = 'SELECT'
|
|
layout.operator("mball.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("mball.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mball.select_random_metaelems")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("mball.select_similar", "type", text="Similar")
|
|
|
|
|
|
class VIEW3D_MT_edit_lattice_context_menu(Menu):
|
|
bl_label = "Lattice Context Menu"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.operator_menu_enum("lattice.flip", "axis")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("lattice.make_regular")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_lattice(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("lattice.select_all", text="All").action = 'SELECT'
|
|
layout.operator("lattice.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("lattice.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("lattice.select_mirror")
|
|
layout.operator("lattice.select_random")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("lattice.select_more")
|
|
layout.operator("lattice.select_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("lattice.select_ungrouped", text="Ungrouped Vertices")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_armature(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("armature.select_all", text="All").action = 'SELECT'
|
|
layout.operator("armature.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("armature.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.select_mirror")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.select_more", text="More")
|
|
layout.operator("armature.select_less", text="Less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.select_linked", text="Linked")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("armature.select_hierarchy", text="Parent")
|
|
props.extend = False
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("armature.select_hierarchy", text="Child")
|
|
props.extend = False
|
|
props.direction = 'CHILD'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("armature.select_hierarchy", text="Extend Parent")
|
|
props.extend = True
|
|
props.direction = 'PARENT'
|
|
|
|
props = layout.operator("armature.select_hierarchy", text="Extend Child")
|
|
props.extend = True
|
|
props.direction = 'CHILD'
|
|
|
|
layout.operator_menu_enum("armature.select_similar", "type", text="Similar")
|
|
layout.operator("object.select_pattern", text="Select Pattern...")
|
|
|
|
|
|
class VIEW3D_MT_paint_gpencil(Menu):
|
|
bl_label = "Paint"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.vertex_color_set", text="Set Color Attribute")
|
|
layout.operator("gpencil.stroke_reset_vertex_color")
|
|
layout.separator()
|
|
layout.operator("gpencil.vertex_color_invert", text="Invert")
|
|
layout.operator("gpencil.vertex_color_levels", text="Levels")
|
|
layout.operator("gpencil.vertex_color_hsv", text="Hue Saturation Value")
|
|
layout.operator("gpencil.vertex_color_brightness_contrast", text="Bright/Contrast")
|
|
|
|
|
|
class VIEW3D_MT_select_gpencil(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.select_all", text="All").action = 'SELECT'
|
|
layout.operator("gpencil.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("gpencil.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.select_box")
|
|
layout.operator("gpencil.select_circle")
|
|
layout.operator_menu_enum("gpencil.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.select_linked", text="Linked")
|
|
layout.operator("gpencil.select_alternate")
|
|
layout.operator("gpencil.select_random")
|
|
layout.operator_menu_enum("gpencil.select_grouped", "type", text="Grouped")
|
|
|
|
if context.mode == 'VERTEX_GPENCIL':
|
|
layout.operator("gpencil.select_vertex_color", text="Color Attribute")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.select_first")
|
|
layout.operator("gpencil.select_last")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.select_more")
|
|
layout.operator("gpencil.select_less")
|
|
|
|
|
|
class VIEW3D_MT_select_paint_mask(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("paint.face_select_all", text="All").action = 'SELECT'
|
|
layout.operator("paint.face_select_all", text="None").action = 'DESELECT'
|
|
layout.operator("paint.face_select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("paint.face_select_linked", text="Linked")
|
|
|
|
|
|
class VIEW3D_MT_select_paint_mask_vertex(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("paint.vert_select_all", text="All").action = 'SELECT'
|
|
layout.operator("paint.vert_select_all", text="None").action = 'DESELECT'
|
|
layout.operator("paint.vert_select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.select_box")
|
|
layout.operator("view3d.select_circle")
|
|
layout.operator_menu_enum("view3d.select_lasso", "mode")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("paint.vert_select_ungrouped", text="Ungrouped Vertices")
|
|
layout.operator("paint.vert_select_linked", text="Select Linked")
|
|
|
|
|
|
class VIEW3D_MT_select_edit_curves(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curves.select_all", text="All").action = 'SELECT'
|
|
layout.operator("curves.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("curves.select_all", text="Invert").action = 'INVERT'
|
|
layout.operator("curves.select_random", text="Random")
|
|
layout.operator("curves.select_end", text="Endpoints")
|
|
|
|
|
|
class VIEW3D_MT_select_sculpt_curves(Menu):
|
|
bl_label = "Select"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curves.select_all", text="All").action = 'SELECT'
|
|
layout.operator("curves.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("curves.select_all", text="Invert").action = 'INVERT'
|
|
layout.operator("sculpt_curves.select_random", text="Random")
|
|
layout.operator("curves.select_end", text="Endpoints")
|
|
layout.operator("sculpt_curves.select_grow", text="Grow")
|
|
|
|
|
|
class VIEW3D_MT_mesh_add(Menu):
|
|
bl_idname = "VIEW3D_MT_mesh_add"
|
|
bl_label = "Mesh"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("mesh.primitive_plane_add", text="Plane", icon='MESH_PLANE')
|
|
layout.operator("mesh.primitive_cube_add", text="Cube", icon='MESH_CUBE')
|
|
layout.operator("mesh.primitive_circle_add", text="Circle", icon='MESH_CIRCLE')
|
|
layout.operator("mesh.primitive_uv_sphere_add", text="UV Sphere", icon='MESH_UVSPHERE')
|
|
layout.operator("mesh.primitive_ico_sphere_add", text="Ico Sphere", icon='MESH_ICOSPHERE')
|
|
layout.operator("mesh.primitive_cylinder_add", text="Cylinder", icon='MESH_CYLINDER')
|
|
layout.operator("mesh.primitive_cone_add", text="Cone", icon='MESH_CONE')
|
|
layout.operator("mesh.primitive_torus_add", text="Torus", icon='MESH_TORUS')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.primitive_grid_add", text="Grid", icon='MESH_GRID')
|
|
layout.operator("mesh.primitive_monkey_add", text="Monkey", icon='MESH_MONKEY')
|
|
|
|
|
|
class VIEW3D_MT_curve_add(Menu):
|
|
bl_idname = "VIEW3D_MT_curve_add"
|
|
bl_label = "Curve"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("curve.primitive_bezier_curve_add", text="Bezier", icon='CURVE_BEZCURVE')
|
|
layout.operator("curve.primitive_bezier_circle_add", text="Circle", icon='CURVE_BEZCIRCLE')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.primitive_nurbs_curve_add", text="Nurbs Curve", icon='CURVE_NCURVE')
|
|
layout.operator("curve.primitive_nurbs_circle_add", text="Nurbs Circle", icon='CURVE_NCIRCLE')
|
|
layout.operator("curve.primitive_nurbs_path_add", text="Path", icon='CURVE_PATH')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.curves_empty_hair_add", text="Empty Hair", icon='CURVES_DATA')
|
|
|
|
experimental = context.preferences.experimental
|
|
if experimental.use_new_curves_tools:
|
|
layout.operator("object.curves_random_add", text="Random", icon='CURVES_DATA')
|
|
|
|
|
|
class VIEW3D_MT_surface_add(Menu):
|
|
bl_idname = "VIEW3D_MT_surface_add"
|
|
bl_label = "Surface"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("surface.primitive_nurbs_surface_curve_add", text="Nurbs Curve", icon='SURFACE_NCURVE')
|
|
layout.operator("surface.primitive_nurbs_surface_circle_add", text="Nurbs Circle", icon='SURFACE_NCIRCLE')
|
|
layout.operator("surface.primitive_nurbs_surface_surface_add", text="Nurbs Surface", icon='SURFACE_NSURFACE')
|
|
layout.operator("surface.primitive_nurbs_surface_cylinder_add",
|
|
text="Nurbs Cylinder", icon='SURFACE_NCYLINDER')
|
|
layout.operator("surface.primitive_nurbs_surface_sphere_add", text="Nurbs Sphere", icon='SURFACE_NSPHERE')
|
|
layout.operator("surface.primitive_nurbs_surface_torus_add", text="Nurbs Torus", icon='SURFACE_NTORUS')
|
|
|
|
|
|
class VIEW3D_MT_edit_metaball_context_menu(Menu):
|
|
bl_label = "Metaball Context Menu"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
# Add
|
|
layout.operator("mball.duplicate_move")
|
|
|
|
layout.separator()
|
|
|
|
# Modify
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
# Remove
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("mball.delete_metaelems", text="Delete")
|
|
|
|
|
|
class VIEW3D_MT_metaball_add(Menu):
|
|
bl_idname = "VIEW3D_MT_metaball_add"
|
|
bl_label = "Metaball"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator_enum("object.metaball_add", "type")
|
|
|
|
|
|
class TOPBAR_MT_edit_curve_add(Menu):
|
|
bl_idname = "TOPBAR_MT_edit_curve_add"
|
|
bl_label = "Add"
|
|
bl_translation_context = i18n_contexts.operator_default
|
|
|
|
def draw(self, context):
|
|
is_surf = context.active_object.type == 'SURFACE'
|
|
|
|
layout = self.layout
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
|
|
if is_surf:
|
|
VIEW3D_MT_surface_add.draw(self, context)
|
|
else:
|
|
VIEW3D_MT_curve_add.draw(self, context)
|
|
|
|
|
|
class TOPBAR_MT_edit_armature_add(Menu):
|
|
bl_idname = "TOPBAR_MT_edit_armature_add"
|
|
bl_label = "Armature"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("armature.bone_primitive_add", text="Single Bone", icon='BONE_DATA')
|
|
|
|
|
|
class VIEW3D_MT_armature_add(Menu):
|
|
bl_idname = "VIEW3D_MT_armature_add"
|
|
bl_label = "Armature"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("object.armature_add", text="Single Bone", icon='BONE_DATA')
|
|
|
|
|
|
class VIEW3D_MT_light_add(Menu):
|
|
bl_idname = "VIEW3D_MT_light_add"
|
|
bl_context = i18n_contexts.id_light
|
|
bl_label = "Light"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator_enum("object.light_add", "type")
|
|
|
|
|
|
class VIEW3D_MT_lightprobe_add(Menu):
|
|
bl_idname = "VIEW3D_MT_lightprobe_add"
|
|
bl_label = "Light Probe"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator_enum("object.lightprobe_add", "type")
|
|
|
|
|
|
class VIEW3D_MT_camera_add(Menu):
|
|
bl_idname = "VIEW3D_MT_camera_add"
|
|
bl_label = "Camera"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("object.camera_add", text="Camera", icon='OUTLINER_OB_CAMERA')
|
|
|
|
|
|
class VIEW3D_MT_volume_add(Menu):
|
|
bl_idname = "VIEW3D_MT_volume_add"
|
|
bl_label = "Volume"
|
|
bl_translation_context = i18n_contexts.id_id
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("object.volume_import", text="Import OpenVDB...", icon='OUTLINER_DATA_VOLUME')
|
|
layout.operator("object.volume_add", text="Empty",
|
|
text_ctxt=i18n_contexts.id_volume,
|
|
icon='OUTLINER_DATA_VOLUME')
|
|
|
|
|
|
class VIEW3D_MT_add(Menu):
|
|
bl_label = "Add"
|
|
bl_translation_context = i18n_contexts.operator_default
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
# NOTE: don't use 'EXEC_SCREEN' or operators won't get the `v3d` context.
|
|
|
|
# NOTE: was `EXEC_AREA`, but this context does not have the `rv3d`, which prevents
|
|
# "align_view" to work on first call (see T32719).
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
|
|
# layout.operator_menu_enum("object.mesh_add", "type", text="Mesh",
|
|
# icon='OUTLINER_OB_MESH')
|
|
layout.menu("VIEW3D_MT_mesh_add", icon='OUTLINER_OB_MESH')
|
|
|
|
# layout.operator_menu_enum("object.curve_add", "type", text="Curve",
|
|
# icon='OUTLINER_OB_CURVE')
|
|
layout.menu("VIEW3D_MT_curve_add", icon='OUTLINER_OB_CURVE')
|
|
# layout.operator_menu_enum("object.surface_add", "type", text="Surface", icon='OUTLINER_OB_SURFACE')
|
|
|
|
layout.menu("VIEW3D_MT_surface_add", icon='OUTLINER_OB_SURFACE')
|
|
layout.menu("VIEW3D_MT_metaball_add", text="Metaball", icon='OUTLINER_OB_META')
|
|
layout.operator("object.text_add", text="Text", icon='OUTLINER_OB_FONT')
|
|
if context.preferences.experimental.use_new_point_cloud_type:
|
|
layout.operator("object.pointcloud_add", text="Point Cloud", icon='OUTLINER_OB_POINTCLOUD')
|
|
layout.menu("VIEW3D_MT_volume_add", text="Volume", icon='OUTLINER_OB_VOLUME')
|
|
layout.operator_menu_enum("object.gpencil_add", "type", text="Grease Pencil", icon='OUTLINER_OB_GREASEPENCIL')
|
|
|
|
layout.separator()
|
|
|
|
if VIEW3D_MT_armature_add.is_extended():
|
|
layout.menu("VIEW3D_MT_armature_add", icon='OUTLINER_OB_ARMATURE')
|
|
else:
|
|
layout.operator("object.armature_add", text="Armature", icon='OUTLINER_OB_ARMATURE')
|
|
|
|
layout.operator("object.add", text="Lattice", icon='OUTLINER_OB_LATTICE').type = 'LATTICE'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.empty_add", "type", text="Empty",
|
|
text_ctxt=i18n_contexts.id_id,
|
|
icon='OUTLINER_OB_EMPTY')
|
|
layout.menu("VIEW3D_MT_image_add", text="Image", icon='OUTLINER_OB_IMAGE')
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_light_add", icon='OUTLINER_OB_LIGHT')
|
|
layout.menu("VIEW3D_MT_lightprobe_add", icon='OUTLINER_OB_LIGHTPROBE')
|
|
|
|
layout.separator()
|
|
|
|
if VIEW3D_MT_camera_add.is_extended():
|
|
layout.menu("VIEW3D_MT_camera_add", icon='OUTLINER_OB_CAMERA')
|
|
else:
|
|
VIEW3D_MT_camera_add.draw(self, context)
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.speaker_add", text="Speaker", icon='OUTLINER_OB_SPEAKER')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.effector_add", "type", text="Force Field", icon='OUTLINER_OB_FORCE_FIELD')
|
|
|
|
layout.separator()
|
|
|
|
has_collections = bool(bpy.data.collections)
|
|
col = layout.column()
|
|
col.enabled = has_collections
|
|
|
|
if not has_collections or len(bpy.data.collections) > 10:
|
|
col.operator_context = 'INVOKE_REGION_WIN'
|
|
col.operator("object.collection_instance_add",
|
|
text="Collection Instance..." if has_collections else "No Collections to Instance",
|
|
icon='OUTLINER_OB_GROUP_INSTANCE',)
|
|
else:
|
|
col.operator_menu_enum("object.collection_instance_add",
|
|
"collection",
|
|
text="Collection Instance",
|
|
icon='OUTLINER_OB_GROUP_INSTANCE',)
|
|
|
|
|
|
class VIEW3D_MT_image_add(Menu):
|
|
bl_label = "Add Image"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("object.load_reference_image", text="Reference", icon='IMAGE_REFERENCE')
|
|
layout.operator("object.load_background_image", text="Background", icon='IMAGE_BACKGROUND')
|
|
|
|
|
|
class VIEW3D_MT_object_relations(Menu):
|
|
bl_label = "Relations"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.make_override_library", text="Make Library Override...")
|
|
|
|
layout.operator("object.make_dupli_face")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.make_local", "type", text="Make Local...")
|
|
layout.menu("VIEW3D_MT_make_single_user")
|
|
|
|
|
|
class VIEW3D_MT_object_liboverride(Menu):
|
|
bl_label = "Library Override"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.make_override_library", text="Make")
|
|
layout.operator("object.reset_override_library", text="Reset")
|
|
layout.operator("object.clear_override_library", text="Clear")
|
|
|
|
|
|
class VIEW3D_MT_object(Menu):
|
|
bl_context = "objectmode"
|
|
bl_label = "Object"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_transform_object")
|
|
layout.operator_menu_enum("object.origin_set", text="Set Origin", property="type")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_object_clear")
|
|
layout.menu("VIEW3D_MT_object_apply")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.duplicate_move")
|
|
layout.operator("object.duplicate_move_linked")
|
|
layout.operator("object.join")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("view3d.copybuffer", text="Copy Objects", icon='COPYDOWN')
|
|
layout.operator("view3d.pastebuffer", text="Paste Objects", icon='PASTEDOWN')
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_asset")
|
|
layout.menu("VIEW3D_MT_object_parent")
|
|
layout.menu("VIEW3D_MT_object_collection")
|
|
layout.menu("VIEW3D_MT_object_relations")
|
|
layout.menu("VIEW3D_MT_object_liboverride")
|
|
layout.menu("VIEW3D_MT_object_constraints")
|
|
layout.menu("VIEW3D_MT_object_track")
|
|
layout.menu("VIEW3D_MT_make_links")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.shade_smooth")
|
|
layout.operator("object.shade_smooth", text="Shade Auto Smooth").use_auto_smooth = True
|
|
layout.operator("object.shade_flat")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_animation")
|
|
layout.menu("VIEW3D_MT_object_rigid_body")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_quick_effects")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_convert")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_showhide")
|
|
layout.menu("VIEW3D_MT_object_cleanup")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("object.delete", text="Delete").use_global = False
|
|
layout.operator("object.delete", text="Delete Global").use_global = True
|
|
|
|
|
|
class VIEW3D_MT_object_animation(Menu):
|
|
bl_label = "Animation"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("anim.keyframe_insert_menu", text="Insert Keyframe...")
|
|
layout.operator("anim.keyframe_delete_v3d", text="Delete Keyframes...")
|
|
layout.operator("anim.keyframe_clear_v3d", text="Clear Keyframes...")
|
|
layout.operator("anim.keying_set_active_set", text="Change Keying Set...")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("nla.bake", text="Bake Action...")
|
|
layout.operator("gpencil.bake_mesh_animation", text="Bake Mesh to Grease Pencil...")
|
|
layout.operator("gpencil.bake_grease_pencil_animation", text="Bake Object Transform to Grease Pencil...")
|
|
|
|
|
|
class VIEW3D_MT_object_rigid_body(Menu):
|
|
bl_label = "Rigid Body"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("rigidbody.objects_add", text="Add Active").type = 'ACTIVE'
|
|
layout.operator("rigidbody.objects_add", text="Add Passive").type = 'PASSIVE'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("rigidbody.objects_remove", text="Remove")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("rigidbody.shape_change", text="Change Shape")
|
|
layout.operator("rigidbody.mass_calculate", text="Calculate Mass")
|
|
layout.operator("rigidbody.object_settings_copy", text="Copy from Active")
|
|
layout.operator("object.visual_transform_apply", text="Apply Transformation")
|
|
layout.operator("rigidbody.bake_to_keyframes", text="Bake to Keyframes")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("rigidbody.connect", text="Connect")
|
|
|
|
|
|
class VIEW3D_MT_object_clear(Menu):
|
|
bl_label = "Clear"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.location_clear", text="Location").clear_delta = False
|
|
layout.operator("object.rotation_clear", text="Rotation").clear_delta = False
|
|
layout.operator("object.scale_clear", text="Scale").clear_delta = False
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.origin_clear", text="Origin")
|
|
|
|
|
|
class VIEW3D_MT_object_context_menu(Menu):
|
|
bl_label = "Object Context Menu"
|
|
|
|
def draw(self, context):
|
|
|
|
layout = self.layout
|
|
view = context.space_data
|
|
|
|
obj = context.object
|
|
|
|
selected_objects_len = len(context.selected_objects)
|
|
|
|
# If nothing is selected
|
|
# (disabled for now until it can be made more useful).
|
|
'''
|
|
if selected_objects_len == 0:
|
|
|
|
layout.menu("VIEW3D_MT_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
layout.operator("view3d.pastebuffer", text="Paste Objects", icon='PASTEDOWN')
|
|
|
|
return
|
|
'''
|
|
|
|
# If something is selected
|
|
|
|
# Individual object types.
|
|
if obj is None:
|
|
pass
|
|
|
|
elif obj.type == 'CAMERA':
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("view3d.object_as_camera", text="Set Active Camera")
|
|
|
|
if obj.data.type == 'PERSP':
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Focal Length")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.lens"
|
|
props.input_scale = 0.1
|
|
if obj.data.lens_unit == 'MILLIMETERS':
|
|
props.header_text = tip_("Camera Focal Length: %.1fmm")
|
|
else:
|
|
props.header_text = tip_("Camera Focal Length: %.1f\u00B0")
|
|
|
|
else:
|
|
props = layout.operator("wm.context_modal_mouse", text="Camera Lens Scale")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.ortho_scale"
|
|
props.input_scale = 0.01
|
|
props.header_text = tip_("Camera Lens Scale: %.3f")
|
|
|
|
if not obj.data.dof.focus_object:
|
|
if view and view.camera == obj and view.region_3d.view_perspective == 'CAMERA':
|
|
props = layout.operator("ui.eyedropper_depth", text="DOF Distance (Pick)")
|
|
else:
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Focus Distance")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.dof.focus_distance"
|
|
props.input_scale = 0.02
|
|
props.header_text = tip_("Focus Distance: %.3f")
|
|
|
|
layout.separator()
|
|
|
|
elif obj.type in {'CURVE', 'FONT'}:
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Extrusion")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.extrude"
|
|
props.input_scale = 0.01
|
|
props.header_text = tip_("Extrude: %.3f")
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Offset")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.offset"
|
|
props.input_scale = 0.01
|
|
props.header_text = tip_("Offset: %.3f")
|
|
|
|
layout.separator()
|
|
|
|
elif obj.type == 'EMPTY':
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Empty Display Size")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "empty_display_size"
|
|
props.input_scale = 0.01
|
|
props.header_text = tip_("Empty Display Size: %.3f")
|
|
|
|
layout.separator()
|
|
|
|
if obj.empty_display_type == 'IMAGE':
|
|
layout.operator("gpencil.trace_image")
|
|
|
|
layout.separator()
|
|
|
|
elif obj.type == 'LIGHT':
|
|
light = obj.data
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Light Power")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.energy"
|
|
props.input_scale = 1.0
|
|
props.header_text = tip_("Light Power: %.3f")
|
|
|
|
if light.type == 'AREA':
|
|
if light.shape in {'RECTANGLE', 'ELLIPSE'}:
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Area Light X Size")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.size"
|
|
props.header_text = tip_("Light Size X: %.3f")
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Area Light Y Size")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.size_y"
|
|
props.header_text = tip_("Light Size Y: %.3f")
|
|
else:
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Area Light Size")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.size"
|
|
props.header_text = tip_("Light Size: %.3f")
|
|
|
|
elif light.type in {'SPOT', 'POINT'}:
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Light Radius")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.shadow_soft_size"
|
|
props.header_text = tip_("Light Radius: %.3f")
|
|
|
|
elif light.type == 'SUN':
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Sun Light Angle")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.angle"
|
|
props.header_text = tip_("Light Angle: %.3f")
|
|
|
|
if light.type == 'SPOT':
|
|
layout.separator()
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Spot Light Size")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.spot_size"
|
|
props.input_scale = 0.01
|
|
props.header_text = tip_("Spot Size: %.2f")
|
|
|
|
props = layout.operator("wm.context_modal_mouse", text="Adjust Spot Light Blend")
|
|
props.data_path_iter = "selected_editable_objects"
|
|
props.data_path_item = "data.spot_blend"
|
|
props.input_scale = -0.01
|
|
props.header_text = tip_("Spot Blend: %.2f")
|
|
|
|
layout.separator()
|
|
|
|
# Shared among some object types.
|
|
if obj is not None:
|
|
if obj.type in {'MESH', 'CURVE', 'SURFACE'}:
|
|
layout.operator("object.shade_smooth")
|
|
layout.operator("object.shade_smooth", text="Shade Auto Smooth").use_auto_smooth = True
|
|
layout.operator("object.shade_flat", text="Shade Flat")
|
|
|
|
layout.separator()
|
|
|
|
if obj.type in {'MESH', 'CURVE', 'SURFACE', 'ARMATURE', 'GPENCIL'}:
|
|
if selected_objects_len > 1:
|
|
layout.operator("object.join")
|
|
|
|
if obj.type in {'MESH', 'CURVE', 'CURVES', 'SURFACE', 'POINTCLOUD', 'META', 'FONT'}:
|
|
layout.operator_menu_enum("object.convert", "target")
|
|
|
|
if obj.type == 'GPENCIL':
|
|
layout.operator_menu_enum("gpencil.convert", "type", text="Convert To")
|
|
|
|
if (obj.type in {
|
|
'MESH', 'CURVE', 'CURVES', 'SURFACE', 'GPENCIL', 'LATTICE', 'ARMATURE', 'META', 'FONT', 'POINTCLOUD',
|
|
} or (obj.type == 'EMPTY' and obj.instance_collection is not None)):
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator_menu_enum("object.origin_set", text="Set Origin", property="type")
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
|
|
layout.separator()
|
|
|
|
# Shared among all object types
|
|
layout.operator("view3d.copybuffer", text="Copy Objects", icon='COPYDOWN')
|
|
layout.operator("view3d.pastebuffer", text="Paste Objects", icon='PASTEDOWN')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.duplicate_move", icon='DUPLICATE')
|
|
layout.operator("object.duplicate_move_linked")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("wm.call_panel", text="Rename Active Object...")
|
|
props.name = "TOPBAR_PT_name"
|
|
props.keep_open = False
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
layout.menu("VIEW3D_MT_object_parent")
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
if view and view.local_view:
|
|
layout.operator("view3d.localview_remove_from")
|
|
else:
|
|
layout.operator("object.move_to_collection")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("anim.keyframe_insert_menu", text="Insert Keyframe...")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("object.delete", text="Delete").use_global = False
|
|
|
|
|
|
class VIEW3D_MT_object_shading(Menu):
|
|
# XXX, this menu is a place to store shading operator in object mode
|
|
bl_label = "Shading"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("object.shade_smooth", text="Smooth")
|
|
layout.operator("object.shade_flat", text="Flat")
|
|
|
|
|
|
class VIEW3D_MT_object_apply(Menu):
|
|
bl_label = "Apply"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
# Need invoke for the popup confirming the multi-user data operation
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
|
|
props = layout.operator("object.transform_apply", text="Location", text_ctxt=i18n_contexts.default)
|
|
props.location, props.rotation, props.scale = True, False, False
|
|
|
|
props = layout.operator("object.transform_apply", text="Rotation", text_ctxt=i18n_contexts.default)
|
|
props.location, props.rotation, props.scale = False, True, False
|
|
|
|
props = layout.operator("object.transform_apply", text="Scale", text_ctxt=i18n_contexts.default)
|
|
props.location, props.rotation, props.scale = False, False, True
|
|
|
|
props = layout.operator("object.transform_apply", text="All Transforms", text_ctxt=i18n_contexts.default)
|
|
props.location, props.rotation, props.scale = True, True, True
|
|
|
|
props = layout.operator("object.transform_apply", text="Rotation & Scale", text_ctxt=i18n_contexts.default)
|
|
props.location, props.rotation, props.scale = False, True, True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.transforms_to_deltas",
|
|
text="Location to Deltas",
|
|
text_ctxt=i18n_contexts.default,).mode = 'LOC'
|
|
layout.operator("object.transforms_to_deltas",
|
|
text="Rotation to Deltas",
|
|
text_ctxt=i18n_contexts.default,).mode = 'ROT'
|
|
layout.operator("object.transforms_to_deltas",
|
|
text="Scale to Deltas",
|
|
text_ctxt=i18n_contexts.default,).mode = 'SCALE'
|
|
|
|
layout.operator("object.transforms_to_deltas",
|
|
text="All Transforms to Deltas",
|
|
text_ctxt=i18n_contexts.default,).mode = 'ALL'
|
|
layout.operator("object.anim_transforms_to_deltas")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.visual_transform_apply",
|
|
text="Visual Transform",
|
|
text_ctxt=i18n_contexts.default,)
|
|
layout.operator("object.convert",
|
|
text="Visual Geometry to Mesh",
|
|
text_ctxt=i18n_contexts.default,).target = 'MESH'
|
|
layout.operator("object.duplicates_make_real")
|
|
layout.operator("object.parent_inverse_apply",
|
|
text="Parent Inverse",
|
|
text_ctxt=i18n_contexts.default)
|
|
|
|
|
|
class VIEW3D_MT_object_parent(Menu):
|
|
bl_label = "Parent"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
operator_context_default = layout.operator_context
|
|
|
|
layout.operator_enum("object.parent_set", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("object.parent_no_inverse_set")
|
|
layout.operator_context = operator_context_default
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_enum("object.parent_clear", "type")
|
|
|
|
|
|
class VIEW3D_MT_object_track(Menu):
|
|
bl_label = "Track"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("object.track_set", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_enum("object.track_clear", "type")
|
|
|
|
|
|
class VIEW3D_MT_object_collection(Menu):
|
|
bl_label = "Collection"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.move_to_collection")
|
|
layout.operator("object.link_to_collection")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("collection.create")
|
|
# layout.operator_menu_enum("collection.objects_remove", "collection")
|
|
# # BUGGY
|
|
layout.operator("collection.objects_remove")
|
|
layout.operator("collection.objects_remove_all")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("collection.objects_add_active")
|
|
layout.operator("collection.objects_remove_active")
|
|
|
|
|
|
class VIEW3D_MT_object_constraints(Menu):
|
|
bl_label = "Constraints"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.constraint_add_with_targets")
|
|
layout.operator("object.constraints_copy")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.constraints_clear")
|
|
|
|
|
|
class VIEW3D_MT_object_quick_effects(Menu):
|
|
bl_label = "Quick Effects"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.quick_fur")
|
|
layout.operator("object.quick_explode")
|
|
layout.operator("object.quick_smoke")
|
|
layout.operator("object.quick_liquid")
|
|
|
|
|
|
class VIEW3D_MT_object_showhide(Menu):
|
|
bl_label = "Show/Hide"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.hide_view_clear")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.hide_view_set", text="Hide Selected").unselected = False
|
|
layout.operator("object.hide_view_set", text="Hide Unselected").unselected = True
|
|
|
|
|
|
class VIEW3D_MT_object_cleanup(Menu):
|
|
bl_label = "Clean Up"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.vertex_group_clean", text="Clean Vertex Group Weights").group_select_mode = 'ALL'
|
|
layout.operator("object.vertex_group_limit_total", text="Limit Total Vertex Groups").group_select_mode = 'ALL'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.material_slot_remove_unused", text="Remove Unused Material Slots")
|
|
|
|
|
|
class VIEW3D_MT_object_asset(Menu):
|
|
bl_label = "Asset"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("asset.mark")
|
|
layout.operator("asset.clear", text="Clear Asset").set_fake_user = False
|
|
layout.operator("asset.clear", text="Clear Asset (Set Fake User)").set_fake_user = True
|
|
|
|
|
|
class VIEW3D_MT_make_single_user(Menu):
|
|
bl_label = "Make Single User"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
|
|
props = layout.operator("object.make_single_user", text="Object")
|
|
props.object = True
|
|
props.obdata = props.material = props.animation = props.obdata_animation = False
|
|
|
|
props = layout.operator("object.make_single_user", text="Object & Data")
|
|
props.object = props.obdata = True
|
|
props.material = props.animation = props.obdata_animation = False
|
|
|
|
props = layout.operator("object.make_single_user", text="Object & Data & Materials")
|
|
props.object = props.obdata = props.material = True
|
|
props.animation = props.obdata_animation = False
|
|
|
|
props = layout.operator("object.make_single_user", text="Materials")
|
|
props.material = True
|
|
props.object = props.obdata = props.animation = props.obdata_animation = False
|
|
|
|
props = layout.operator("object.make_single_user", text="Object Animation")
|
|
props.animation = True
|
|
props.object = props.obdata = props.material = props.obdata_animation = False
|
|
|
|
props = layout.operator("object.make_single_user", text="Object Data Animation")
|
|
props.obdata_animation = props.obdata = True
|
|
props.object = props.material = props.animation = False
|
|
|
|
|
|
class VIEW3D_MT_object_convert(Menu):
|
|
bl_label = "Convert"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
ob = context.active_object
|
|
|
|
if ob and ob.type == 'GPENCIL' and context.gpencil_data:
|
|
layout.operator_enum("gpencil.convert", "type")
|
|
else:
|
|
layout.operator_enum("object.convert", "target")
|
|
|
|
# Potrace lib dependency.
|
|
if bpy.app.build_options.potrace:
|
|
layout.operator("gpencil.trace_image", icon='OUTLINER_OB_GREASEPENCIL')
|
|
|
|
if ob and ob.type == 'CURVES':
|
|
layout.operator("curves.convert_to_particle_system", text="Particle System")
|
|
|
|
|
|
class VIEW3D_MT_make_links(Menu):
|
|
bl_label = "Link/Transfer Data"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
operator_context_default = layout.operator_context
|
|
|
|
if len(bpy.data.scenes) > 10:
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator("object.make_links_scene", text="Link Objects to Scene...", icon='OUTLINER_OB_EMPTY')
|
|
else:
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator_menu_enum("object.make_links_scene", "scene", text="Link Objects to Scene")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = operator_context_default
|
|
|
|
layout.operator_enum("object.make_links_data", "type") # inline
|
|
|
|
layout.operator("object.join_uvs", text="Copy UV Maps")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.data_transfer")
|
|
layout.operator("object.datalayout_transfer")
|
|
|
|
|
|
class VIEW3D_MT_brush_paint_modes(Menu):
|
|
bl_label = "Enabled Modes"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
settings = UnifiedPaintPanel.paint_settings(context)
|
|
brush = settings.brush
|
|
|
|
layout.prop(brush, "use_paint_sculpt", text="Sculpt")
|
|
layout.prop(brush, "use_paint_uv_sculpt", text="UV Sculpt")
|
|
layout.prop(brush, "use_paint_vertex", text="Vertex Paint")
|
|
layout.prop(brush, "use_paint_weight", text="Weight Paint")
|
|
layout.prop(brush, "use_paint_image", text="Texture Paint")
|
|
layout.prop(brush, "use_paint_sculpt_curves", text="Sculpt Curves")
|
|
|
|
|
|
class VIEW3D_MT_paint_vertex(Menu):
|
|
bl_label = "Paint"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("paint.vertex_color_set")
|
|
layout.operator("paint.vertex_color_smooth")
|
|
layout.operator("paint.vertex_color_dirt")
|
|
layout.operator("paint.vertex_color_from_weight")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("paint.vertex_color_invert", text="Invert")
|
|
layout.operator("paint.vertex_color_levels", text="Levels")
|
|
layout.operator("paint.vertex_color_hsv", text="Hue Saturation Value")
|
|
layout.operator("paint.vertex_color_brightness_contrast", text="Bright/Contrast")
|
|
|
|
|
|
class VIEW3D_MT_hook(Menu):
|
|
bl_label = "Hooks"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.operator_context = 'EXEC_AREA'
|
|
layout.operator("object.hook_add_newob")
|
|
layout.operator("object.hook_add_selob").use_bone = False
|
|
layout.operator("object.hook_add_selob", text="Hook to Selected Object Bone").use_bone = True
|
|
|
|
if any([mod.type == 'HOOK' for mod in context.active_object.modifiers]):
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.hook_assign", "modifier")
|
|
layout.operator_menu_enum("object.hook_remove", "modifier")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.hook_select", "modifier")
|
|
layout.operator_menu_enum("object.hook_reset", "modifier")
|
|
layout.operator_menu_enum("object.hook_recenter", "modifier")
|
|
|
|
|
|
class VIEW3D_MT_vertex_group(Menu):
|
|
bl_label = "Vertex Groups"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_AREA'
|
|
layout.operator("object.vertex_group_assign_new")
|
|
|
|
ob = context.active_object
|
|
if ob.mode == 'EDIT' or (ob.mode == 'WEIGHT_PAINT' and ob.type == 'MESH' and ob.data.use_paint_mask_vertex):
|
|
if ob.vertex_groups.active:
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_group_assign", text="Assign to Active Group")
|
|
layout.operator("object.vertex_group_remove_from",
|
|
text="Remove from Active Group",).use_all_groups = False
|
|
layout.operator("object.vertex_group_remove_from", text="Remove from All").use_all_groups = True
|
|
|
|
if ob.vertex_groups.active:
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("object.vertex_group_set_active", "group", text="Set Active Group")
|
|
layout.operator("object.vertex_group_remove", text="Remove Active Group").all = False
|
|
layout.operator("object.vertex_group_remove", text="Remove All Groups").all = True
|
|
|
|
|
|
class VIEW3D_MT_gpencil_vertex_group(Menu):
|
|
bl_label = "Vertex Groups"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_AREA'
|
|
ob = context.active_object
|
|
|
|
layout.operator("object.vertex_group_add", text="Add New Group")
|
|
ob = context.active_object
|
|
if ob.vertex_groups.active:
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.vertex_group_assign", text="Assign")
|
|
layout.operator("gpencil.vertex_group_remove_from", text="Remove")
|
|
|
|
layout.operator("gpencil.vertex_group_select", text="Select")
|
|
layout.operator("gpencil.vertex_group_deselect", text="Deselect")
|
|
|
|
|
|
class VIEW3D_MT_paint_weight_lock(Menu):
|
|
bl_label = "Vertex Group Locks"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("object.vertex_group_lock", icon='LOCKED', text="Lock All")
|
|
op.action, op.mask = 'LOCK', 'ALL'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Lock Selected")
|
|
op.action, op.mask = 'LOCK', 'SELECTED'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Lock Unselected")
|
|
op.action, op.mask = 'LOCK', 'UNSELECTED'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Lock Only Selected")
|
|
op.action, op.mask = 'LOCK', 'INVERT_UNSELECTED'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Lock Only Unselected")
|
|
op.action, op.mask = 'UNLOCK', 'INVERT_UNSELECTED'
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("object.vertex_group_lock", icon='UNLOCKED', text="Unlock All")
|
|
op.action, op.mask = 'UNLOCK', 'ALL'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Unlock Selected")
|
|
op.action, op.mask = 'UNLOCK', 'SELECTED'
|
|
|
|
op = layout.operator("object.vertex_group_lock", text="Unlock Unselected")
|
|
op.action, op.mask = 'UNLOCK', 'UNSELECTED'
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("object.vertex_group_lock", icon='ARROW_LEFTRIGHT', text="Invert Locks")
|
|
op.action, op.mask = 'INVERT', 'ALL'
|
|
|
|
|
|
class VIEW3D_MT_paint_weight(Menu):
|
|
bl_label = "Weights"
|
|
|
|
@staticmethod
|
|
def draw_generic(layout, is_editmode=False):
|
|
|
|
if not is_editmode:
|
|
|
|
layout.operator("paint.weight_from_bones", text="Assign Automatic from Bones").type = 'AUTOMATIC'
|
|
layout.operator("paint.weight_from_bones", text="Assign from Bone Envelopes").type = 'ENVELOPES'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_group_normalize_all", text="Normalize All")
|
|
layout.operator("object.vertex_group_normalize", text="Normalize")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_group_mirror", text="Mirror")
|
|
layout.operator("object.vertex_group_invert", text="Invert")
|
|
layout.operator("object.vertex_group_clean", text="Clean")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_group_quantize", text="Quantize")
|
|
layout.operator("object.vertex_group_levels", text="Levels")
|
|
layout.operator("object.vertex_group_smooth", text="Smooth")
|
|
|
|
if not is_editmode:
|
|
props = layout.operator("object.data_transfer", text="Transfer Weights")
|
|
props.use_reverse_transfer = True
|
|
props.data_type = 'VGROUP_WEIGHTS'
|
|
|
|
layout.operator("object.vertex_group_limit_total", text="Limit Total")
|
|
layout.operator("object.vertex_group_fix", text="Fix Deforms")
|
|
|
|
if not is_editmode:
|
|
layout.separator()
|
|
|
|
layout.operator("paint.weight_set")
|
|
|
|
layout.menu("VIEW3D_MT_paint_weight_lock", text="Locks")
|
|
|
|
def draw(self, _context):
|
|
self.draw_generic(self.layout, is_editmode=False)
|
|
|
|
|
|
class VIEW3D_MT_sculpt(Menu):
|
|
bl_label = "Sculpt"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
props = layout.operator("paint.hide_show", text="Show All")
|
|
props.action = 'SHOW'
|
|
props.area = 'ALL'
|
|
|
|
props = layout.operator("paint.hide_show", text="Box Show")
|
|
props.action = 'SHOW'
|
|
props.area = 'INSIDE'
|
|
|
|
props = layout.operator("paint.hide_show", text="Box Hide")
|
|
props.action = 'HIDE'
|
|
props.area = 'INSIDE'
|
|
|
|
props = layout.operator("paint.hide_show", text="Hide Masked")
|
|
props.action = 'HIDE'
|
|
props.area = 'MASKED'
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_sculpt_set_pivot", text="Set Pivot")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("sculpt.optimize")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.transfer_mode", text="Transfer Sculpt Mode")
|
|
|
|
|
|
class VIEW3D_MT_sculpt_curves(Menu):
|
|
bl_label = "Curves"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curves.snap_curves_to_surface", text="Snap to Deformed Surface").attach_mode = 'DEFORM'
|
|
layout.operator("curves.snap_curves_to_surface", text="Snap to Nearest Surface").attach_mode = 'NEAREST'
|
|
layout.separator()
|
|
layout.operator("curves.convert_to_particle_system", text="Convert to Particle System")
|
|
|
|
|
|
class VIEW3D_MT_mask(Menu):
|
|
bl_label = "Mask"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
props = layout.operator("paint.mask_flood_fill", text="Invert Mask")
|
|
props.mode = 'INVERT'
|
|
|
|
props = layout.operator("paint.mask_flood_fill", text="Fill Mask")
|
|
props.mode = 'VALUE'
|
|
props.value = 1
|
|
|
|
props = layout.operator("paint.mask_flood_fill", text="Clear Mask")
|
|
props.mode = 'VALUE'
|
|
props.value = 0
|
|
|
|
props = layout.operator("paint.mask_box_gesture", text="Box Mask")
|
|
props.mode = 'VALUE'
|
|
props.value = 0
|
|
|
|
props = layout.operator("paint.mask_lasso_gesture", text="Lasso Mask")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Smooth Mask")
|
|
props.filter_type = 'SMOOTH'
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Sharpen Mask")
|
|
props.filter_type = 'SHARPEN'
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Grow Mask")
|
|
props.filter_type = 'GROW'
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Shrink Mask")
|
|
props.filter_type = 'SHRINK'
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Increase Contrast")
|
|
props.filter_type = 'CONTRAST_INCREASE'
|
|
props.auto_iteration_count = False
|
|
|
|
props = layout.operator("sculpt.mask_filter", text="Decrease Contrast")
|
|
props.filter_type = 'CONTRAST_DECREASE'
|
|
props.auto_iteration_count = False
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("sculpt.expand", text="Expand Mask by Topology")
|
|
props.target = 'MASK'
|
|
props.falloff_type = 'GEODESIC'
|
|
props.invert = False
|
|
props.use_auto_mask = False
|
|
props.use_mask_preserve = True
|
|
|
|
props = layout.operator("sculpt.expand", text="Expand Mask by Normals")
|
|
props.target = 'MASK'
|
|
props.falloff_type = 'NORMALS'
|
|
props.invert = False
|
|
props.use_mask_preserve = True
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("mesh.paint_mask_extract", text="Mask Extract")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("mesh.paint_mask_slice", text="Mask Slice")
|
|
props.fill_holes = False
|
|
props.new_object = False
|
|
props = layout.operator("mesh.paint_mask_slice", text="Mask Slice and Fill Holes")
|
|
props.new_object = False
|
|
props = layout.operator("mesh.paint_mask_slice", text="Mask Slice to New Object")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("sculpt.mask_from_cavity", text="Mask From Cavity")
|
|
props.settings_source = "OPERATOR"
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_random_mask", text="Random Mask")
|
|
|
|
|
|
class VIEW3D_MT_face_sets(Menu):
|
|
bl_label = "Face Sets"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("sculpt.face_sets_create", text="Face Set from Masked")
|
|
op.mode = 'MASKED'
|
|
|
|
op = layout.operator("sculpt.face_sets_create", text="Face Set from Visible")
|
|
op.mode = 'VISIBLE'
|
|
|
|
op = layout.operator("sculpt.face_sets_create", text="Face Set from Edit Mode Selection")
|
|
op.mode = 'SELECTION'
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_face_sets_init", text="Initialize Face Sets")
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("sculpt.face_set_edit", text="Grow Face Set")
|
|
op.mode = 'GROW'
|
|
|
|
op = layout.operator("sculpt.face_set_edit", text="Shrink Face Set")
|
|
op.mode = 'SHRINK'
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("sculpt.expand", text="Expand Face Set by Topology")
|
|
props.target = 'FACE_SETS'
|
|
props.falloff_type = 'GEODESIC'
|
|
props.invert = False
|
|
props.use_mask_preserve = False
|
|
props.use_modify_active = False
|
|
|
|
props = layout.operator("sculpt.expand", text="Expand Active Face Set")
|
|
props.target = 'FACE_SETS'
|
|
props.falloff_type = 'BOUNDARY_FACE_SET'
|
|
props.invert = False
|
|
props.use_mask_preserve = False
|
|
props.use_modify_active = True
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("mesh.face_set_extract", text="Extract Face Set")
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("sculpt.face_set_change_visibility", text="Invert Visible Face Sets")
|
|
op.mode = 'INVERT'
|
|
|
|
op = layout.operator("sculpt.reveal_all", text="Show All Face Sets")
|
|
|
|
layout.separator()
|
|
|
|
op = layout.operator("sculpt.face_sets_randomize_colors", text="Randomize Colors")
|
|
|
|
|
|
class VIEW3D_MT_sculpt_set_pivot(Menu):
|
|
bl_label = "Sculpt Set Pivot"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
props = layout.operator("sculpt.set_pivot_position", text="Pivot to Origin")
|
|
props.mode = 'ORIGIN'
|
|
|
|
props = layout.operator("sculpt.set_pivot_position", text="Pivot to Unmasked")
|
|
props.mode = 'UNMASKED'
|
|
|
|
props = layout.operator("sculpt.set_pivot_position", text="Pivot to Mask Border")
|
|
props.mode = 'BORDER'
|
|
|
|
props = layout.operator("sculpt.set_pivot_position", text="Pivot to Active Vertex")
|
|
props.mode = 'ACTIVE'
|
|
|
|
props = layout.operator("sculpt.set_pivot_position", text="Pivot to Surface Under Cursor")
|
|
props.mode = 'SURFACE'
|
|
|
|
|
|
class VIEW3D_MT_face_sets_init(Menu):
|
|
bl_label = "Face Sets Init"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Loose Parts")
|
|
op.mode = 'LOOSE_PARTS'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Face Set Boundaries")
|
|
op.mode = 'FACE_SET_BOUNDARIES'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Materials")
|
|
op.mode = 'MATERIALS'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Normals")
|
|
op.mode = 'NORMALS'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By UV Seams")
|
|
op.mode = 'UV_SEAMS'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Edge Creases")
|
|
op.mode = 'CREASES'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Edge Bevel Weight")
|
|
op.mode = 'BEVEL_WEIGHT'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Sharp Edges")
|
|
op.mode = 'SHARP_EDGES'
|
|
|
|
op = layout.operator("sculpt.face_sets_init", text="By Face Maps")
|
|
op.mode = 'FACE_MAPS'
|
|
|
|
|
|
class VIEW3D_MT_random_mask(Menu):
|
|
bl_label = "Random Mask"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("sculpt.mask_init", text="Per Vertex")
|
|
op.mode = 'RANDOM_PER_VERTEX'
|
|
|
|
op = layout.operator("sculpt.mask_init", text="Per Face Set")
|
|
op.mode = 'RANDOM_PER_FACE_SET'
|
|
|
|
op = layout.operator("sculpt.mask_init", text="Per Loose Part")
|
|
op.mode = 'RANDOM_PER_LOOSE_PART'
|
|
|
|
|
|
class VIEW3D_MT_particle(Menu):
|
|
bl_label = "Particle"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
|
|
particle_edit = tool_settings.particle_edit
|
|
|
|
layout.operator("particle.mirror")
|
|
|
|
layout.operator("particle.remove_doubles")
|
|
|
|
layout.separator()
|
|
|
|
if particle_edit.select_mode == 'POINT':
|
|
layout.operator("particle.subdivide")
|
|
|
|
layout.operator("particle.unify_length")
|
|
layout.operator("particle.rekey")
|
|
layout.operator("particle.weight_set")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_particle_showhide")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.delete")
|
|
|
|
|
|
class VIEW3D_MT_particle_context_menu(Menu):
|
|
bl_label = "Particle Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
|
|
particle_edit = tool_settings.particle_edit
|
|
|
|
layout.operator("particle.rekey")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.delete")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.remove_doubles")
|
|
layout.operator("particle.unify_length")
|
|
|
|
if particle_edit.select_mode == 'POINT':
|
|
layout.operator("particle.subdivide")
|
|
|
|
layout.operator("particle.weight_set")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.mirror")
|
|
|
|
if particle_edit.select_mode == 'POINT':
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_all", text="All").action = 'SELECT'
|
|
layout.operator("particle.select_all", text="None").action = 'DESELECT'
|
|
layout.operator("particle.select_all", text="Invert").action = 'INVERT'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_roots")
|
|
layout.operator("particle.select_tips")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_random")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_more")
|
|
layout.operator("particle.select_less")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("particle.select_linked", text="Select Linked")
|
|
|
|
|
|
class VIEW3D_MT_particle_showhide(ShowHideMenu, Menu):
|
|
_operator_name = "particle"
|
|
|
|
|
|
class VIEW3D_MT_pose(Menu):
|
|
bl_label = "Pose"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_transform_armature")
|
|
|
|
layout.menu("VIEW3D_MT_pose_transform")
|
|
layout.menu("VIEW3D_MT_pose_apply")
|
|
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_animation")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_pose_slide")
|
|
layout.menu("VIEW3D_MT_pose_propagate")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.copy", icon='COPYDOWN')
|
|
layout.operator("pose.paste", icon='PASTEDOWN').flipped = False
|
|
layout.operator("pose.paste", icon='PASTEFLIPDOWN', text="Paste Pose Flipped").flipped = True
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_pose_motion")
|
|
layout.menu("VIEW3D_MT_pose_group")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_object_parent")
|
|
layout.menu("VIEW3D_MT_pose_ik")
|
|
layout.menu("VIEW3D_MT_pose_constraints")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_pose_names")
|
|
layout.operator("pose.quaternions_flip")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'INVOKE_AREA'
|
|
layout.operator("armature.armature_layers", text="Change Armature Layers...")
|
|
layout.operator("pose.bone_layers", text="Change Bone Layers...")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_pose_showhide")
|
|
layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings")
|
|
|
|
|
|
class VIEW3D_MT_pose_transform(Menu):
|
|
bl_label = "Clear Transform"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.transforms_clear", text="All")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.loc_clear", text="Location")
|
|
layout.operator("pose.rot_clear", text="Rotation")
|
|
layout.operator("pose.scale_clear", text="Scale")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.user_transforms_clear", text="Reset Unkeyed")
|
|
|
|
|
|
class VIEW3D_MT_pose_slide(Menu):
|
|
bl_label = "In-Betweens"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.push_rest")
|
|
layout.operator("pose.relax_rest")
|
|
layout.operator("pose.push")
|
|
layout.operator("pose.relax")
|
|
layout.operator("pose.breakdown")
|
|
layout.operator("pose.blend_to_neighbor")
|
|
|
|
|
|
class VIEW3D_MT_pose_propagate(Menu):
|
|
bl_label = "Propagate"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.propagate", text="To Next Keyframe").mode = 'NEXT_KEY'
|
|
layout.operator("pose.propagate", text="To Last Keyframe (Make Cyclic)").mode = 'LAST_KEY'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.propagate", text="On Selected Keyframes").mode = 'SELECTED_KEYS'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.propagate", text="On Selected Markers").mode = 'SELECTED_MARKERS'
|
|
|
|
|
|
class VIEW3D_MT_pose_motion(Menu):
|
|
bl_label = "Motion Paths"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.paths_calculate", text="Calculate")
|
|
layout.operator("pose.paths_clear", text="Clear")
|
|
|
|
|
|
class VIEW3D_MT_pose_group(Menu):
|
|
bl_label = "Bone Groups"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
pose = context.active_object.pose
|
|
|
|
layout.operator_context = 'EXEC_AREA'
|
|
layout.operator("pose.group_assign", text="Assign to New Group").type = 0
|
|
|
|
if pose.bone_groups:
|
|
active_group = pose.bone_groups.active_index + 1
|
|
layout.operator("pose.group_assign", text="Assign to Group").type = active_group
|
|
|
|
layout.separator()
|
|
|
|
# layout.operator_context = 'INVOKE_AREA'
|
|
layout.operator("pose.group_unassign")
|
|
layout.operator("pose.group_remove")
|
|
|
|
|
|
class VIEW3D_MT_pose_ik(Menu):
|
|
bl_label = "Inverse Kinematics"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.ik_add")
|
|
layout.operator("pose.ik_clear")
|
|
|
|
|
|
class VIEW3D_MT_pose_constraints(Menu):
|
|
bl_label = "Constraints"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.constraint_add_with_targets", text="Add (with Targets)...")
|
|
layout.operator("pose.constraints_copy")
|
|
layout.operator("pose.constraints_clear")
|
|
|
|
|
|
class VIEW3D_MT_pose_names(Menu):
|
|
bl_label = "Names"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("pose.autoside_names", text="Auto-Name Left/Right").axis = 'XAXIS'
|
|
layout.operator("pose.autoside_names", text="Auto-Name Front/Back").axis = 'YAXIS'
|
|
layout.operator("pose.autoside_names", text="Auto-Name Top/Bottom").axis = 'ZAXIS'
|
|
layout.operator("pose.flip_names")
|
|
|
|
|
|
class VIEW3D_MT_pose_showhide(ShowHideMenu, Menu):
|
|
_operator_name = "pose"
|
|
|
|
|
|
class VIEW3D_MT_pose_apply(Menu):
|
|
bl_label = "Apply"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("pose.armature_apply").selected = False
|
|
layout.operator("pose.armature_apply", text="Apply Selected as Rest Pose").selected = True
|
|
layout.operator("pose.visual_transform_apply")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("object.assign_property_defaults")
|
|
props.process_bones = True
|
|
|
|
|
|
class VIEW3D_MT_pose_context_menu(Menu):
|
|
bl_label = "Pose Context Menu"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("anim.keyframe_insert_menu", text="Insert Keyframe...")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.copy", icon='COPYDOWN')
|
|
layout.operator("pose.paste", icon='PASTEDOWN').flipped = False
|
|
layout.operator("pose.paste", icon='PASTEFLIPDOWN', text="Paste X-Flipped Pose").flipped = True
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("wm.call_panel", text="Rename Active Bone...")
|
|
props.name = "TOPBAR_PT_name"
|
|
props.keep_open = False
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.push")
|
|
layout.operator("pose.relax")
|
|
layout.operator("pose.breakdown")
|
|
layout.operator("pose.blend_to_neighbor")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.paths_calculate", text="Calculate Motion Paths")
|
|
layout.operator("pose.paths_clear", text="Clear Motion Paths")
|
|
layout.operator("pose.paths_update", text="Update Armature Motion Paths")
|
|
layout.operator("object.paths_update_visible", text="Update All Motion Paths")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.hide").unselected = False
|
|
layout.operator("pose.reveal")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("pose.user_transforms_clear")
|
|
|
|
|
|
class BoneOptions:
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
options = ["show_wire",
|
|
"use_deform",
|
|
"use_envelope_multiply",
|
|
"use_inherit_rotation",]
|
|
|
|
if context.mode == 'EDIT_ARMATURE':
|
|
bone_props = bpy.types.EditBone.bl_rna.properties
|
|
data_path_iter = "selected_bones"
|
|
opt_suffix = ""
|
|
options.append("lock")
|
|
else: # pose-mode
|
|
bone_props = bpy.types.Bone.bl_rna.properties
|
|
data_path_iter = "selected_pose_bones"
|
|
opt_suffix = "bone."
|
|
|
|
for opt in options:
|
|
props = layout.operator("wm.context_collection_boolean_set", text=bone_props[opt].name,
|
|
text_ctxt=i18n_contexts.default)
|
|
props.data_path_iter = data_path_iter
|
|
props.data_path_item = opt_suffix + opt
|
|
props.type = self.type
|
|
|
|
|
|
class VIEW3D_MT_bone_options_toggle(Menu, BoneOptions):
|
|
bl_label = "Toggle Bone Options"
|
|
type = 'TOGGLE'
|
|
|
|
|
|
class VIEW3D_MT_bone_options_enable(Menu, BoneOptions):
|
|
bl_label = "Enable Bone Options"
|
|
type = 'ENABLE'
|
|
|
|
|
|
class VIEW3D_MT_bone_options_disable(Menu, BoneOptions):
|
|
bl_label = "Disable Bone Options"
|
|
type = 'DISABLE'
|
|
|
|
|
|
# ********** Edit Menus, suffix from ob.type **********
|
|
class VIEW3D_MT_edit_mesh(Menu):
|
|
bl_label = "Mesh"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
with_bullet = bpy.app.build_options.bullet
|
|
|
|
layout.menu("VIEW3D_MT_transform")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.duplicate_move", text="Duplicate")
|
|
layout.menu("VIEW3D_MT_edit_mesh_extrude")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_merge", text="Merge")
|
|
layout.menu("VIEW3D_MT_edit_mesh_split", text="Split")
|
|
layout.operator_menu_enum("mesh.separate", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.bisect")
|
|
layout.operator("mesh.knife_project")
|
|
layout.operator("mesh.knife_tool")
|
|
|
|
if with_bullet:
|
|
layout.operator("mesh.convex_hull")
|
|
|
|
layout.operator("mesh.fair_vertices", text="Fair")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.symmetrize")
|
|
layout.operator("mesh.symmetry_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_normals")
|
|
layout.menu("VIEW3D_MT_edit_mesh_shading")
|
|
layout.menu("VIEW3D_MT_edit_mesh_weights")
|
|
layout.operator_menu_enum("mesh.sort_elements", "type", text="Sort Elements...")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_showhide")
|
|
layout.menu("VIEW3D_MT_edit_mesh_clean")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_context_menu(Menu):
|
|
bl_label = ""
|
|
|
|
def draw(self, context):
|
|
|
|
def count_selected_items_for_objects_in_mode():
|
|
selected_verts_len = 0
|
|
selected_edges_len = 0
|
|
selected_faces_len = 0
|
|
for ob in context.objects_in_mode_unique_data:
|
|
v, e, f = ob.data.count_selected_items()
|
|
selected_verts_len += v
|
|
selected_edges_len += e
|
|
selected_faces_len += f
|
|
return (selected_verts_len, selected_edges_len, selected_faces_len)
|
|
|
|
is_vert_mode, is_edge_mode, is_face_mode = context.tool_settings.mesh_select_mode
|
|
selected_verts_len, selected_edges_len, selected_faces_len = count_selected_items_for_objects_in_mode()
|
|
|
|
del count_selected_items_for_objects_in_mode
|
|
|
|
layout = self.layout
|
|
|
|
with_freestyle = bpy.app.build_options.freestyle
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
# If nothing is selected
|
|
# (disabled for now until it can be made more useful).
|
|
'''
|
|
# If nothing is selected
|
|
if not (selected_verts_len or selected_edges_len or selected_faces_len):
|
|
layout.menu("VIEW3D_MT_mesh_add", text="Add", text_ctxt=i18n_contexts.operator_default)
|
|
|
|
return
|
|
'''
|
|
|
|
# Else something is selected
|
|
|
|
row = layout.row()
|
|
|
|
if is_vert_mode:
|
|
col = row.column(align=True)
|
|
|
|
col.label(text="Vertex Context Menu", icon='VERTEXSEL')
|
|
col.separator()
|
|
|
|
# Additive Operators
|
|
col.operator("mesh.subdivide", text="Subdivide")
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.extrude_vertices_move", text="Extrude Vertices")
|
|
col.operator("mesh.bevel", text="Bevel Vertices").affect = 'VERTICES'
|
|
|
|
if selected_verts_len > 1:
|
|
col.separator()
|
|
col.operator("mesh.edge_face_add", text="New Edge/Face from Vertices")
|
|
col.operator("mesh.vert_connect_path", text="Connect Vertex Path")
|
|
col.operator("mesh.vert_connect", text="Connect Vertex Pairs")
|
|
|
|
col.separator()
|
|
|
|
# Deform Operators
|
|
col.operator("transform.push_pull", text="Push/Pull")
|
|
col.operator("transform.shrink_fatten", text="Shrink/Fatten")
|
|
col.operator("transform.shear", text="Shear")
|
|
col.operator("transform.vert_slide", text="Slide Vertices")
|
|
col.operator_context = 'EXEC_REGION_WIN'
|
|
col.operator("transform.vertex_random", text="Randomize Vertices").offset = 0.1
|
|
col.operator("mesh.vertices_smooth", text="Smooth Vertices").factor = 0.5
|
|
col.operator_context = 'INVOKE_REGION_WIN'
|
|
col.operator("mesh.vertices_smooth_laplacian", text="Smooth Laplacian")
|
|
|
|
col.separator()
|
|
|
|
col.menu("VIEW3D_MT_mirror", text="Mirror Vertices")
|
|
col.menu("VIEW3D_MT_snap", text="Snap Vertices")
|
|
|
|
col.separator()
|
|
|
|
# Removal Operators
|
|
if selected_verts_len > 1:
|
|
col.menu("VIEW3D_MT_edit_mesh_merge", text="Merge Vertices")
|
|
col.operator("mesh.split")
|
|
col.operator_menu_enum("mesh.separate", "type")
|
|
col.operator("mesh.dissolve_verts")
|
|
col.operator("mesh.delete", text="Delete Vertices").type = 'VERT'
|
|
|
|
if is_edge_mode:
|
|
col = row.column(align=True)
|
|
col.label(text="Edge Context Menu", icon='EDGESEL')
|
|
col.separator()
|
|
|
|
# Additive Operators
|
|
col.operator("mesh.subdivide", text="Subdivide")
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.extrude_edges_move", text="Extrude Edges")
|
|
col.operator("mesh.bevel", text="Bevel Edges").affect = 'EDGES'
|
|
if selected_edges_len >= 2:
|
|
col.operator("mesh.bridge_edge_loops")
|
|
if selected_edges_len >= 1:
|
|
col.operator("mesh.edge_face_add", text="New Face from Edges")
|
|
if selected_edges_len >= 2:
|
|
col.operator("mesh.fill")
|
|
|
|
col.separator()
|
|
|
|
props = col.operator("mesh.loopcut_slide")
|
|
props.TRANSFORM_OT_edge_slide.release_confirm = False
|
|
col.operator("mesh.offset_edge_loops_slide")
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.knife_tool")
|
|
col.operator("mesh.bisect")
|
|
|
|
col.separator()
|
|
|
|
# Deform Operators
|
|
col.operator("mesh.edge_rotate", text="Rotate Edge CW").use_ccw = False
|
|
col.operator("transform.edge_slide")
|
|
col.operator("mesh.edge_split")
|
|
|
|
col.separator()
|
|
|
|
# Edge Flags
|
|
col.operator("transform.edge_crease")
|
|
col.operator("transform.edge_bevelweight")
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.mark_seam").clear = False
|
|
col.operator("mesh.mark_seam", text="Clear Seam").clear = True
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.mark_sharp")
|
|
col.operator("mesh.mark_sharp", text="Clear Sharp").clear = True
|
|
|
|
if with_freestyle:
|
|
col.separator()
|
|
|
|
col.operator("mesh.mark_freestyle_edge").clear = False
|
|
col.operator("mesh.mark_freestyle_edge", text="Clear Freestyle Edge").clear = True
|
|
|
|
col.separator()
|
|
|
|
# Removal Operators
|
|
col.operator("mesh.unsubdivide")
|
|
col.operator("mesh.split")
|
|
col.operator_menu_enum("mesh.separate", "type")
|
|
col.operator("mesh.dissolve_edges")
|
|
col.operator("mesh.delete", text="Delete Edges").type = 'EDGE'
|
|
|
|
if is_face_mode:
|
|
col = row.column(align=True)
|
|
|
|
col.label(text="Face Context Menu", icon='FACESEL')
|
|
col.separator()
|
|
|
|
# Additive Operators
|
|
col.operator("mesh.subdivide", text="Subdivide")
|
|
|
|
col.separator()
|
|
|
|
col.operator("view3d.edit_mesh_extrude_move_normal", text="Extrude Faces")
|
|
col.operator("view3d.edit_mesh_extrude_move_shrink_fatten", text="Extrude Faces Along Normals")
|
|
col.operator("mesh.extrude_faces_move", text="Extrude Individual Faces")
|
|
|
|
col.operator("mesh.inset")
|
|
col.operator("mesh.poke")
|
|
|
|
if selected_faces_len >= 2:
|
|
col.operator("mesh.bridge_edge_loops", text="Bridge Faces")
|
|
|
|
col.separator()
|
|
|
|
# Modify Operators
|
|
col.menu("VIEW3D_MT_uv_map", text="UV Unwrap Faces")
|
|
|
|
col.separator()
|
|
|
|
props = col.operator("mesh.quads_convert_to_tris")
|
|
props.quad_method = props.ngon_method = 'BEAUTY'
|
|
col.operator("mesh.tris_convert_to_quads")
|
|
|
|
col.separator()
|
|
|
|
col.operator("mesh.faces_shade_smooth")
|
|
col.operator("mesh.faces_shade_flat")
|
|
|
|
col.separator()
|
|
|
|
# Removal Operators
|
|
col.operator("mesh.unsubdivide")
|
|
col.operator("mesh.split")
|
|
col.operator_menu_enum("mesh.separate", "type")
|
|
col.operator("mesh.dissolve_faces")
|
|
col.operator("mesh.delete", text="Delete Faces").type = 'FACE'
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_select_mode(Menu):
|
|
bl_label = "Mesh Select Mode"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator("mesh.select_mode", text="Vertex", icon='VERTEXSEL').type = 'VERT'
|
|
layout.operator("mesh.select_mode", text="Edge", icon='EDGESEL').type = 'EDGE'
|
|
layout.operator("mesh.select_mode", text="Face", icon='FACESEL').type = 'FACE'
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_extrude(Menu):
|
|
bl_label = "Extrude"
|
|
|
|
_extrude_funcs = {
|
|
'VERT': lambda layout:
|
|
layout.operator("mesh.extrude_vertices_move", text="Extrude Vertices"),
|
|
'EDGE': lambda layout:
|
|
layout.operator("mesh.extrude_edges_move", text="Extrude Edges"),
|
|
'REGION': lambda layout:
|
|
layout.operator("view3d.edit_mesh_extrude_move_normal", text="Extrude Faces"),
|
|
'REGION_VERT_NORMAL': lambda layout:
|
|
layout.operator("view3d.edit_mesh_extrude_move_shrink_fatten", text="Extrude Faces Along Normals"),
|
|
'FACE': lambda layout:
|
|
layout.operator("mesh.extrude_faces_move", text="Extrude Individual Faces"),
|
|
'MANIFOLD': lambda layout:
|
|
layout.operator("view3d.edit_mesh_extrude_manifold_normal", text="Extrude Manifold"),
|
|
}
|
|
|
|
@staticmethod
|
|
def extrude_options(context):
|
|
tool_settings = context.tool_settings
|
|
select_mode = tool_settings.mesh_select_mode
|
|
mesh = context.object.data
|
|
|
|
menu = []
|
|
if mesh.total_face_sel:
|
|
menu += ['REGION', 'REGION_VERT_NORMAL', 'FACE', 'MANIFOLD']
|
|
if mesh.total_edge_sel and (select_mode[0] or select_mode[1]):
|
|
menu += ['EDGE']
|
|
if mesh.total_vert_sel and select_mode[0]:
|
|
menu += ['VERT']
|
|
|
|
# should never get here
|
|
return menu
|
|
|
|
def draw(self, context):
|
|
from math import pi
|
|
|
|
layout = self.layout
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
for menu_id in self.extrude_options(context):
|
|
self._extrude_funcs[menu_id](layout)
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.extrude_repeat")
|
|
layout.operator("mesh.spin").angle = pi * 2
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_vertices(Menu):
|
|
bl_label = "Vertex"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("mesh.extrude_vertices_move", text="Extrude Vertices")
|
|
layout.operator("mesh.dupli_extrude_cursor").rotate_source = True
|
|
layout.operator("mesh.bevel", text="Bevel Vertices").affect = 'VERTICES'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.edge_face_add", text="New Edge/Face from Vertices")
|
|
layout.operator("mesh.vert_connect_path", text="Connect Vertex Path")
|
|
layout.operator("mesh.vert_connect", text="Connect Vertex Pairs")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("mesh.rip_move", text="Rip Vertices")
|
|
props.MESH_OT_rip.use_fill = False
|
|
props = layout.operator("mesh.rip_move", text="Rip Vertices and Fill")
|
|
props.MESH_OT_rip.use_fill = True
|
|
layout.operator("mesh.rip_edge_move", text="Rip Vertices and Extend")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.vert_slide", text="Slide Vertices")
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("mesh.vertices_smooth", text="Smooth Vertices").factor = 0.5
|
|
layout.operator("mesh.vertices_smooth_laplacian", text="Smooth Vertices (Laplacian)")
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.vert_crease")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.blend_from_shape")
|
|
layout.operator("mesh.shape_propagate_to_all", text="Propagate to Shapes")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_vertex_group")
|
|
layout.menu("VIEW3D_MT_hook")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_parent_set")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_edges(Menu):
|
|
bl_label = "Edge"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
with_freestyle = bpy.app.build_options.freestyle
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("mesh.extrude_edges_move", text="Extrude Edges")
|
|
layout.operator("mesh.bevel", text="Bevel Edges").affect = 'EDGES'
|
|
layout.operator("mesh.bridge_edge_loops")
|
|
layout.operator("mesh.screw")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.subdivide")
|
|
layout.operator("mesh.subdivide_edgering")
|
|
layout.operator("mesh.unsubdivide")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.edge_rotate", text="Rotate Edge CW").use_ccw = False
|
|
layout.operator("mesh.edge_rotate", text="Rotate Edge CCW").use_ccw = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.edge_slide")
|
|
props = layout.operator("mesh.loopcut_slide")
|
|
props.TRANSFORM_OT_edge_slide.release_confirm = False
|
|
layout.operator("mesh.offset_edge_loops_slide")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.edge_crease")
|
|
layout.operator("transform.edge_bevelweight")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.mark_seam").clear = False
|
|
layout.operator("mesh.mark_seam", text="Clear Seam").clear = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.mark_sharp")
|
|
layout.operator("mesh.mark_sharp", text="Clear Sharp").clear = True
|
|
|
|
layout.operator("mesh.mark_sharp", text="Mark Sharp from Vertices").use_verts = True
|
|
props = layout.operator("mesh.mark_sharp", text="Clear Sharp from Vertices")
|
|
props.use_verts = True
|
|
props.clear = True
|
|
|
|
if with_freestyle:
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.mark_freestyle_edge").clear = False
|
|
layout.operator("mesh.mark_freestyle_edge", text="Clear Freestyle Edge").clear = True
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_faces_data(Menu):
|
|
bl_label = "Face Data"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
with_freestyle = bpy.app.build_options.freestyle
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("mesh.colors_rotate")
|
|
layout.operator("mesh.colors_reverse")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.uvs_rotate")
|
|
layout.operator("mesh.uvs_reverse")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.flip_quad_tessellation")
|
|
|
|
if with_freestyle:
|
|
layout.separator()
|
|
layout.operator("mesh.mark_freestyle_face").clear = False
|
|
layout.operator("mesh.mark_freestyle_face", text="Clear Freestyle Face").clear = True
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_faces(Menu):
|
|
bl_label = "Face"
|
|
bl_idname = "VIEW3D_MT_edit_mesh_faces"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
layout.operator("view3d.edit_mesh_extrude_move_normal", text="Extrude Faces")
|
|
layout.operator("view3d.edit_mesh_extrude_move_shrink_fatten", text="Extrude Faces Along Normals")
|
|
layout.operator("mesh.extrude_faces_move", text="Extrude Individual Faces")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.inset")
|
|
layout.operator("mesh.poke")
|
|
props = layout.operator("mesh.quads_convert_to_tris")
|
|
props.quad_method = props.ngon_method = 'BEAUTY'
|
|
layout.operator("mesh.tris_convert_to_quads")
|
|
layout.operator("mesh.solidify", text="Solidify Faces")
|
|
layout.operator("mesh.wireframe")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.fill")
|
|
layout.operator("mesh.fill_grid")
|
|
layout.operator("mesh.beautify_fill")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.intersect")
|
|
layout.operator("mesh.intersect_boolean")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.face_split_by_edges")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.faces_shade_smooth")
|
|
layout.operator("mesh.faces_shade_flat")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_faces_data")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_normals_select_strength(Menu):
|
|
bl_label = "Select by Face Strength"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Weak")
|
|
op.set = False
|
|
op.face_strength = 'WEAK'
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Medium")
|
|
op.set = False
|
|
op.face_strength = 'MEDIUM'
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Strong")
|
|
op.set = False
|
|
op.face_strength = 'STRONG'
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_normals_set_strength(Menu):
|
|
bl_label = "Set Face Strength"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Weak")
|
|
op.set = True
|
|
op.face_strength = 'WEAK'
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Medium")
|
|
op.set = True
|
|
op.face_strength = 'MEDIUM'
|
|
|
|
op = layout.operator("mesh.mod_weighted_strength", text="Strong")
|
|
op.set = True
|
|
op.face_strength = 'STRONG'
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_normals_average(Menu):
|
|
bl_label = "Average"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.average_normals", text="Custom Normal").average_type = 'CUSTOM_NORMAL'
|
|
layout.operator("mesh.average_normals", text="Face Area").average_type = 'FACE_AREA'
|
|
layout.operator("mesh.average_normals", text="Corner Angle").average_type = 'CORNER_ANGLE'
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_normals(Menu):
|
|
bl_label = "Normals"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.flip_normals", text="Flip")
|
|
layout.operator("mesh.normals_make_consistent", text="Recalculate Outside").inside = False
|
|
layout.operator("mesh.normals_make_consistent", text="Recalculate Inside").inside = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.set_normals_from_faces", text="Set from Faces")
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
layout.operator("transform.rotate_normal", text="Rotate...")
|
|
layout.operator("mesh.point_normals", text="Point to Target...")
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
|
|
layout.operator("mesh.merge_normals", text="Merge")
|
|
layout.operator("mesh.split_normals", text="Split")
|
|
layout.menu("VIEW3D_MT_edit_mesh_normals_average", text="Average")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.normals_tools", text="Copy Vectors").mode = 'COPY'
|
|
layout.operator("mesh.normals_tools", text="Paste Vectors").mode = 'PASTE'
|
|
|
|
layout.operator("mesh.smooth_normals", text="Smooth Vectors")
|
|
layout.operator("mesh.normals_tools", text="Reset Vectors").mode = 'RESET'
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_mesh_normals_select_strength")
|
|
layout.menu("VIEW3D_MT_edit_mesh_normals_set_strength")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_shading(Menu):
|
|
bl_label = "Shading"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.faces_shade_smooth", text="Smooth Faces")
|
|
layout.operator("mesh.faces_shade_flat", text="Flat Faces")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.mark_sharp", text="Smooth Edges").clear = True
|
|
layout.operator("mesh.mark_sharp", text="Sharp Edges")
|
|
|
|
layout.separator()
|
|
|
|
props = layout.operator("mesh.mark_sharp", text="Smooth Vertices")
|
|
props.use_verts = True
|
|
props.clear = True
|
|
|
|
layout.operator("mesh.mark_sharp", text="Sharp Vertices").use_verts = True
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_weights(Menu):
|
|
bl_label = "Weights"
|
|
|
|
def draw(self, _context):
|
|
VIEW3D_MT_paint_weight.draw_generic(self.layout, is_editmode=True)
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_clean(Menu):
|
|
bl_label = "Clean Up"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.delete_loose")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.decimate")
|
|
layout.operator("mesh.dissolve_degenerate")
|
|
layout.operator("mesh.dissolve_limited")
|
|
layout.operator("mesh.face_make_planar")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.vert_connect_nonplanar")
|
|
layout.operator("mesh.vert_connect_concave")
|
|
layout.operator("mesh.remove_doubles")
|
|
layout.operator("mesh.fill_holes")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_delete(Menu):
|
|
bl_label = "Delete"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("mesh.delete", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.dissolve_verts")
|
|
layout.operator("mesh.dissolve_edges")
|
|
layout.operator("mesh.dissolve_faces")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.dissolve_limited")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.edge_collapse")
|
|
layout.operator("mesh.delete_edgeloop", text="Edge Loops")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_merge(Menu):
|
|
bl_label = "Merge"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("mesh.merge", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mesh.remove_doubles", text="By Distance")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_split(Menu):
|
|
bl_label = "Split"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mesh.split", text="Selection")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_enum("mesh.edge_split", "type")
|
|
|
|
|
|
class VIEW3D_MT_edit_mesh_showhide(ShowHideMenu, Menu):
|
|
_operator_name = "mesh"
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil_delete(Menu):
|
|
bl_label = "Delete"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("gpencil.delete", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_enum("gpencil.dissolve", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.delete", text="Delete Active Keyframe (Active Layer)").type = 'FRAME'
|
|
layout.operator("gpencil.active_frames_delete_all", text="Delete Active Keyframes (All Layers)")
|
|
|
|
# Edit Curve
|
|
# draw_curve is used by VIEW3D_MT_edit_curve and VIEW3D_MT_edit_surface
|
|
def draw_curve(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_transform")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.spin")
|
|
layout.operator("curve.duplicate_move")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.split")
|
|
layout.operator("curve.separate")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.cyclic_toggle")
|
|
layout.operator_menu_enum("curve.spline_type_set", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_curve_showhide")
|
|
layout.menu("VIEW3D_MT_edit_curve_clean")
|
|
layout.menu("VIEW3D_MT_edit_curve_delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_curve(Menu):
|
|
bl_label = "Curve"
|
|
|
|
draw = draw_curve
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_ctrlpoints(Menu):
|
|
bl_label = "Control Points"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
edit_object = context.edit_object
|
|
|
|
if edit_object.type in {'CURVE', 'SURFACE'}:
|
|
layout.operator("curve.extrude_move")
|
|
layout.operator("curve.vertex_add")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.make_segment")
|
|
|
|
layout.separator()
|
|
|
|
if edit_object.type == 'CURVE':
|
|
layout.operator("transform.tilt")
|
|
layout.operator("curve.tilt_clear")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("curve.handle_type_set", "type")
|
|
layout.operator("curve.normals_make_consistent")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.smooth")
|
|
if edit_object.type == 'CURVE':
|
|
layout.operator("curve.smooth_tilt")
|
|
layout.operator("curve.smooth_radius")
|
|
layout.operator("curve.smooth_weight")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_hook")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_parent_set")
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_segments(Menu):
|
|
bl_label = "Segments"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curve.subdivide")
|
|
layout.operator("curve.switch_direction")
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_clean(Menu):
|
|
bl_label = "Clean Up"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("curve.decimate")
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_context_menu(Menu):
|
|
bl_label = "Curve Context Menu"
|
|
|
|
def draw(self, _context):
|
|
# TODO(campbell): match mesh vertex menu.
|
|
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
|
|
# Add
|
|
layout.operator("curve.subdivide")
|
|
layout.operator("curve.extrude_move")
|
|
layout.operator("curve.make_segment")
|
|
layout.operator("curve.duplicate_move")
|
|
|
|
layout.separator()
|
|
|
|
# Transform
|
|
layout.operator("transform.transform", text="Radius").mode = 'CURVE_SHRINKFATTEN'
|
|
layout.operator("transform.tilt")
|
|
layout.operator("curve.tilt_clear")
|
|
layout.operator("curve.smooth")
|
|
layout.operator("curve.smooth_tilt")
|
|
layout.operator("curve.smooth_radius")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
# Modify
|
|
layout.operator_menu_enum("curve.spline_type_set", "type")
|
|
layout.operator_menu_enum("curve.handle_type_set", "type")
|
|
layout.operator("curve.cyclic_toggle")
|
|
layout.operator("curve.switch_direction")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.normals_make_consistent")
|
|
layout.operator("curve.spline_weight_set")
|
|
layout.operator("curve.radius_set")
|
|
|
|
layout.separator()
|
|
|
|
# Remove
|
|
layout.operator("curve.split")
|
|
layout.operator("curve.decimate")
|
|
layout.operator("curve.separate")
|
|
layout.operator("curve.dissolve_verts")
|
|
layout.operator("curve.delete", text="Delete Segment").type = 'SEGMENT'
|
|
layout.operator("curve.delete", text="Delete Point").type = 'VERT'
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_delete(Menu):
|
|
bl_label = "Delete"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_enum("curve.delete", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("curve.dissolve_verts")
|
|
|
|
|
|
class VIEW3D_MT_edit_curve_showhide(ShowHideMenu, Menu):
|
|
_operator_name = "curve"
|
|
|
|
|
|
class VIEW3D_MT_edit_surface(Menu):
|
|
bl_label = "Surface"
|
|
|
|
draw = draw_curve
|
|
|
|
|
|
class VIEW3D_MT_edit_font_chars(Menu):
|
|
bl_label = "Special Characters"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("font.text_insert", text="Copyright").text = "\u00A9"
|
|
layout.operator("font.text_insert", text="Registered Trademark").text = "\u00AE"
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_insert", text="Degree Sign").text = "\u00B0"
|
|
layout.operator("font.text_insert", text="Multiplication Sign").text = "\u00D7"
|
|
layout.operator("font.text_insert", text="Circle").text = "\u008A"
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_insert", text="Superscript 1").text = "\u00B9"
|
|
layout.operator("font.text_insert", text="Superscript 2").text = "\u00B2"
|
|
layout.operator("font.text_insert", text="Superscript 3").text = "\u00B3"
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_insert", text="Double >>").text = "\u00BB"
|
|
layout.operator("font.text_insert", text="Double <<").text = "\u00AB"
|
|
layout.operator("font.text_insert", text="Promillage").text = "\u2030"
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_insert", text="Dutch Florin").text = "\u00A4"
|
|
layout.operator("font.text_insert", text="British Pound").text = "\u00A3"
|
|
layout.operator("font.text_insert", text="Japanese Yen").text = "\u00A5"
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_insert", text="German S").text = "\u00DF"
|
|
layout.operator("font.text_insert", text="Spanish Question Mark").text = "\u00BF"
|
|
layout.operator("font.text_insert", text="Spanish Exclamation Mark").text = "\u00A1"
|
|
|
|
|
|
class VIEW3D_MT_edit_font_kerning(Menu):
|
|
bl_label = "Kerning"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
ob = context.active_object
|
|
text = ob.data
|
|
kerning = text.edit_format.kerning
|
|
|
|
layout.operator("font.change_spacing", text="Decrease Kerning").delta = -1
|
|
layout.operator("font.change_spacing", text="Increase Kerning").delta = 1
|
|
layout.operator("font.change_spacing", text="Reset Kerning").delta = -kerning
|
|
|
|
|
|
class VIEW3D_MT_edit_font_delete(Menu):
|
|
bl_label = "Delete"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("font.delete", text="Previous Character").type = 'PREVIOUS_CHARACTER'
|
|
layout.operator("font.delete", text="Next Character").type = 'NEXT_CHARACTER'
|
|
layout.operator("font.delete", text="Previous Word").type = 'PREVIOUS_WORD'
|
|
layout.operator("font.delete", text="Next Word").type = 'NEXT_WORD'
|
|
|
|
|
|
class VIEW3D_MT_edit_font(Menu):
|
|
bl_label = "Text"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("font.text_cut", text="Cut")
|
|
layout.operator("font.text_copy", text="Copy", icon='COPYDOWN')
|
|
layout.operator("font.text_paste", text="Paste", icon='PASTEDOWN')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.text_paste_from_file")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.case_set", text="To Uppercase").case = 'UPPER'
|
|
layout.operator("font.case_set", text="To Lowercase").case = 'LOWER'
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_font_chars")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.style_toggle", text="Toggle Bold", icon='BOLD').style = 'BOLD'
|
|
layout.operator("font.style_toggle", text="Toggle Italic", icon='ITALIC').style = 'ITALIC'
|
|
layout.operator("font.style_toggle", text="Toggle Underline", icon='UNDERLINE').style = 'UNDERLINE'
|
|
layout.operator("font.style_toggle", text="Toggle Small Caps", icon='SMALL_CAPS').style = 'SMALL_CAPS'
|
|
|
|
layout.menu("VIEW3D_MT_edit_font_kerning")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_font_delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_font_context_menu(Menu):
|
|
bl_label = "Text Context Menu"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
|
|
layout.operator("font.text_cut", text="Cut")
|
|
layout.operator("font.text_copy", text="Copy", icon='COPYDOWN')
|
|
layout.operator("font.text_paste", text="Paste", icon='PASTEDOWN')
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("font.select_all")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_font")
|
|
|
|
|
|
class VIEW3D_MT_edit_meta(Menu):
|
|
bl_label = "Metaball"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_transform")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("mball.duplicate_metaelems")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_meta_showhide")
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("mball.delete_metaelems", text="Delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_meta_showhide(Menu):
|
|
bl_label = "Show/Hide"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("mball.reveal_metaelems")
|
|
layout.operator("mball.hide_metaelems", text="Hide Selected").unselected = False
|
|
layout.operator("mball.hide_metaelems", text="Hide Unselected").unselected = True
|
|
|
|
|
|
class VIEW3D_MT_edit_lattice(Menu):
|
|
bl_label = "Lattice"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_transform")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
layout.operator_menu_enum("lattice.flip", "axis")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("lattice.make_regular")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("object.vertex_parent_set")
|
|
|
|
|
|
class VIEW3D_MT_edit_armature(Menu):
|
|
bl_label = "Armature"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
edit_object = context.edit_object
|
|
arm = edit_object.data
|
|
|
|
layout.menu("VIEW3D_MT_transform_armature")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
layout.menu("VIEW3D_MT_edit_armature_roll")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.extrude_move")
|
|
layout.operator("armature.click_extrude")
|
|
|
|
if arm.use_mirror_x:
|
|
layout.operator("armature.extrude_forked")
|
|
|
|
layout.operator("armature.duplicate_move")
|
|
layout.operator("armature.fill")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.split")
|
|
layout.operator("armature.separate")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.subdivide", text="Subdivide")
|
|
layout.operator("armature.switch_direction", text="Switch Direction")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.symmetrize")
|
|
layout.menu("VIEW3D_MT_edit_armature_names")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_context = 'INVOKE_DEFAULT'
|
|
layout.operator("armature.armature_layers")
|
|
layout.operator("armature.bone_layers")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_armature_parent")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_armature_delete")
|
|
|
|
|
|
class VIEW3D_MT_armature_context_menu(Menu):
|
|
bl_label = "Armature Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
edit_object = context.edit_object
|
|
arm = edit_object.data
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
# Add
|
|
layout.operator("armature.subdivide", text="Subdivide")
|
|
layout.operator("armature.duplicate_move", text="Duplicate")
|
|
layout.operator("armature.extrude_move")
|
|
if arm.use_mirror_x:
|
|
layout.operator("armature.extrude_forked")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.fill")
|
|
|
|
layout.separator()
|
|
|
|
# Modify
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("VIEW3D_MT_snap")
|
|
layout.operator("armature.symmetrize")
|
|
layout.operator("armature.switch_direction", text="Switch Direction")
|
|
layout.menu("VIEW3D_MT_edit_armature_names")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_armature_parent")
|
|
|
|
layout.separator()
|
|
|
|
# Remove
|
|
layout.operator("armature.split")
|
|
layout.operator("armature.separate")
|
|
layout.operator("armature.dissolve")
|
|
layout.operator("armature.delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_armature_names(Menu):
|
|
bl_label = "Names"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'EXEC_REGION_WIN'
|
|
layout.operator("armature.autoside_names", text="Auto-Name Left/Right").type = 'XAXIS'
|
|
layout.operator("armature.autoside_names", text="Auto-Name Front/Back").type = 'YAXIS'
|
|
layout.operator("armature.autoside_names", text="Auto-Name Top/Bottom").type = 'ZAXIS'
|
|
layout.operator("armature.flip_names", text="Flip Names")
|
|
|
|
|
|
class VIEW3D_MT_edit_armature_parent(Menu):
|
|
bl_label = "Parent"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("armature.parent_set", text="Make")
|
|
layout.operator("armature.parent_clear", text="Clear")
|
|
|
|
|
|
class VIEW3D_MT_edit_armature_roll(Menu):
|
|
bl_label = "Bone Roll"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator_menu_enum("armature.calculate_roll", "type")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.transform", text="Set Roll").mode = 'BONE_ROLL'
|
|
layout.operator("armature.roll_clear")
|
|
|
|
|
|
class VIEW3D_MT_edit_armature_delete(Menu):
|
|
bl_label = "Delete"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator_context = 'EXEC_AREA'
|
|
|
|
layout.operator("armature.delete", text="Bones")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("armature.dissolve", text="Dissolve Bones")
|
|
|
|
|
|
# ********** Grease Pencil menus **********
|
|
class VIEW3D_MT_gpencil_autoweights(Menu):
|
|
bl_label = "Generate Weights"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("gpencil.generate_weights", text="With Empty Groups").mode = 'NAME'
|
|
layout.operator("gpencil.generate_weights", text="With Automatic Weights").mode = 'AUTO'
|
|
|
|
|
|
class VIEW3D_MT_gpencil_simplify(Menu):
|
|
bl_label = "Simplify"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("gpencil.stroke_simplify_fixed", text="Fixed")
|
|
layout.operator("gpencil.stroke_simplify", text="Adaptive")
|
|
layout.operator("gpencil.stroke_sample", text="Sample")
|
|
|
|
|
|
class VIEW3D_MT_draw_gpencil(Menu):
|
|
bl_label = "Draw"
|
|
|
|
def draw(self, _context):
|
|
|
|
layout = self.layout
|
|
|
|
layout.menu("GPENCIL_MT_layer_active", text="Active Layer")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_gpencil_animation")
|
|
layout.operator("gpencil.interpolate_sequence", text="Interpolate Sequence")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_gpencil_showhide")
|
|
layout.menu("GPENCIL_MT_cleanup")
|
|
|
|
|
|
class VIEW3D_MT_assign_material(Menu):
|
|
bl_label = "Assign Material"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
ob = context.active_object
|
|
mat_active = ob.active_material
|
|
|
|
for slot in ob.material_slots:
|
|
mat = slot.material
|
|
if mat:
|
|
layout.operator("gpencil.stroke_change_color", text=mat.name,
|
|
icon='LAYER_ACTIVE' if mat == mat_active else 'BLANK1').material = mat.name
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil(Menu):
|
|
bl_label = "Grease Pencil"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_edit_gpencil_transform")
|
|
layout.menu("VIEW3D_MT_mirror")
|
|
layout.menu("GPENCIL_MT_snap")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("GPENCIL_MT_layer_active", text="Active Layer")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_gpencil_animation")
|
|
layout.operator("gpencil.interpolate_sequence", text="Interpolate Sequence")
|
|
|
|
layout.separator()
|
|
|
|
# Cut, Copy, Paste
|
|
layout.operator("gpencil.duplicate_move", text="Duplicate")
|
|
layout.operator("gpencil.stroke_split", text="Split")
|
|
layout.operator("gpencil.copy", text="Copy", icon='COPYDOWN')
|
|
layout.operator("gpencil.paste", text="Paste", icon='PASTEDOWN').type = 'ACTIVE'
|
|
layout.operator("gpencil.paste", text="Paste by Layer").type = 'LAYER'
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_weight_gpencil")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_edit_gpencil_showhide")
|
|
|
|
layout.operator_menu_enum("gpencil.stroke_separate", "mode", text="Separate")
|
|
layout.menu("GPENCIL_MT_cleanup")
|
|
|
|
layout.separator()
|
|
|
|
# Remove
|
|
layout.menu("VIEW3D_MT_edit_gpencil_delete")
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil_stroke(Menu):
|
|
bl_label = "Stroke"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
settings = context.tool_settings.gpencil_sculpt
|
|
|
|
layout.operator("gpencil.stroke_subdivide", text="Subdivide").only_selected = False
|
|
layout.menu("VIEW3D_MT_gpencil_simplify")
|
|
layout.operator("gpencil.stroke_trim", text="Trim")
|
|
layout.operator("gpencil.stroke_outline", text="Outline")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator_menu_enum("gpencil.stroke_join", "type", text="Join")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("GPENCIL_MT_move_to_layer")
|
|
layout.menu("VIEW3D_MT_assign_material")
|
|
layout.operator("gpencil.set_active_material", text="Set as Active Material")
|
|
layout.operator_menu_enum("gpencil.stroke_arrange", "direction", text="Arrange")
|
|
|
|
layout.separator()
|
|
|
|
# Convert
|
|
op = layout.operator("gpencil.stroke_cyclical_set", text="Close")
|
|
op.type = 'CLOSE'
|
|
op.geometry = True
|
|
layout.operator("gpencil.stroke_cyclical_set", text="Toggle Cyclic").type = 'TOGGLE'
|
|
layout.operator_menu_enum("gpencil.stroke_caps_set", text="Toggle Caps", property="type")
|
|
layout.operator("gpencil.stroke_flip", text="Switch Direction")
|
|
layout.operator("gpencil.stroke_start_set", text="Set Start Point")
|
|
|
|
layout.separator()
|
|
layout.operator("gpencil.stroke_normalize", text="Normalize Thickness").mode = 'THICKNESS'
|
|
layout.operator("gpencil.stroke_normalize", text="Normalize Opacity").mode = 'OPACITY'
|
|
layout.prop(settings, "use_scale_thickness", text="Scale Thickness")
|
|
|
|
layout.separator()
|
|
layout.operator("gpencil.reset_transform_fill", text="Reset Fill Transform")
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil_point(Menu):
|
|
bl_label = "Point"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.extrude_move", text="Extrude")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.stroke_smooth", text="Smooth").only_selected = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.stroke_merge", text="Merge")
|
|
|
|
# TODO: add new RIP operator
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_gpencil_vertex_group")
|
|
|
|
|
|
class VIEW3D_MT_weight_gpencil(Menu):
|
|
bl_label = "Weights"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.vertex_group_normalize_all", text="Normalize All")
|
|
layout.operator("gpencil.vertex_group_normalize", text="Normalize")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.vertex_group_invert", text="Invert")
|
|
layout.operator("gpencil.vertex_group_smooth", text="Smooth")
|
|
|
|
layout.separator()
|
|
|
|
layout.menu("VIEW3D_MT_gpencil_autoweights")
|
|
|
|
|
|
class VIEW3D_MT_gpencil_animation(Menu):
|
|
bl_label = "Animation"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
ob = context.active_object
|
|
return ob and ob.type == 'GPENCIL' and ob.mode != 'OBJECT'
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.blank_frame_add", text="Insert Blank Keyframe (Active Layer)")
|
|
layout.operator("gpencil.blank_frame_add", text="Insert Blank Keyframe (All Layers)").all_layers = True
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.frame_duplicate", text="Duplicate Active Keyframe (Active Layer)")
|
|
layout.operator("gpencil.frame_duplicate", text="Duplicate Active Keyframe (All Layers)").mode = 'ALL'
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.delete", text="Delete Active Keyframe (Active Layer)").type = 'FRAME'
|
|
layout.operator("gpencil.active_frames_delete_all", text="Delete Active Keyframes (All Layers)")
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil_transform(Menu):
|
|
bl_label = "Transform"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("transform.translate")
|
|
layout.operator("transform.rotate")
|
|
layout.operator("transform.resize", text="Scale")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("transform.bend", text="Bend")
|
|
layout.operator("transform.shear", text="Shear")
|
|
layout.operator("transform.tosphere", text="To Sphere")
|
|
layout.operator("transform.transform", text="Shrink/Fatten").mode = 'GPENCIL_SHRINKFATTEN'
|
|
|
|
|
|
class VIEW3D_MT_edit_gpencil_showhide(Menu):
|
|
bl_label = "Show/Hide"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.operator("gpencil.reveal", text="Show All Layers")
|
|
|
|
layout.separator()
|
|
|
|
layout.operator("gpencil.hide", text="Hide Active Layer").unselected = False
|
|
layout.operator("gpencil.hide", text="Hide Inactive Layers").unselected = True
|
|
|
|
|
|
class VIEW3D_MT_edit_curves(Menu):
|
|
bl_label = "Curves"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.menu("VIEW3D_MT_transform")
|
|
layout.separator()
|
|
|
|
|
|
class VIEW3D_MT_object_mode_pie(Menu):
|
|
bl_label = "Mode"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
pie = layout.menu_pie()
|
|
pie.operator_enum("object.mode_set", "mode")
|
|
|
|
|
|
class VIEW3D_MT_view_pie(Menu):
|
|
bl_label = "View"
|
|
bl_idname = "VIEW3D_MT_view_pie"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
pie = layout.menu_pie()
|
|
pie.operator_enum("view3d.view_axis", "type")
|
|
pie.operator("view3d.view_camera", text="View Camera", icon='CAMERA_DATA')
|
|
pie.operator("view3d.view_selected", text="View Selected", icon='ZOOM_SELECTED')
|
|
|
|
|
|
class VIEW3D_MT_transform_gizmo_pie(Menu):
|
|
bl_label = "View"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
pie = layout.menu_pie()
|
|
# 1: Left
|
|
pie.operator("view3d.transform_gizmo_set", text="Move").type = {'TRANSLATE'}
|
|
# 2: Right
|
|
pie.operator("view3d.transform_gizmo_set", text="Rotate").type = {'ROTATE'}
|
|
# 3: Down
|
|
pie.operator("view3d.transform_gizmo_set", text="Scale").type = {'SCALE'}
|
|
# 4: Up
|
|
pie.prop(context.space_data, "show_gizmo", text="Show Gizmos", icon='GIZMO')
|
|
# 5: Up/Left
|
|
pie.operator("view3d.transform_gizmo_set", text="All").type = {'TRANSLATE', 'ROTATE', 'SCALE'}
|
|
|
|
|
|
class VIEW3D_MT_shading_pie(Menu):
|
|
bl_label = "Shading"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
view = context.space_data
|
|
|
|
pie.prop(view.shading, "type", expand=True)
|
|
|
|
|
|
class VIEW3D_MT_shading_ex_pie(Menu):
|
|
bl_label = "Shading"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
view = context.space_data
|
|
|
|
pie.prop_enum(view.shading, "type", value='WIREFRAME')
|
|
pie.prop_enum(view.shading, "type", value='SOLID')
|
|
|
|
# Note this duplicates "view3d.toggle_xray" logic, so we can see the
|
|
# active item: T58661.
|
|
if context.pose_object:
|
|
pie.prop(view.overlay, "show_xray_bone", icon='XRAY')
|
|
else:
|
|
xray_active = ((context.mode == 'EDIT_MESH') or (view.shading.type in {'SOLID', 'WIREFRAME'}))
|
|
if xray_active:
|
|
sub = pie
|
|
else:
|
|
sub = pie.row()
|
|
sub.active = False
|
|
sub.prop(view.shading,
|
|
"show_xray_wireframe" if (view.shading.type == 'WIREFRAME') else "show_xray",
|
|
text="Toggle X-Ray",
|
|
icon='XRAY',)
|
|
|
|
pie.prop(view.overlay, "show_overlays", text="Toggle Overlays", icon='OVERLAY')
|
|
|
|
pie.prop_enum(view.shading, "type", value='MATERIAL')
|
|
pie.prop_enum(view.shading, "type", value='RENDERED')
|
|
|
|
|
|
class VIEW3D_MT_pivot_pie(Menu):
|
|
bl_label = "Pivot Point"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
obj = context.active_object
|
|
mode = context.mode
|
|
|
|
pie.prop_enum(context.scene.tool_settings, "transform_pivot_point", value='BOUNDING_BOX_CENTER')
|
|
pie.prop_enum(context.scene.tool_settings, "transform_pivot_point", value='CURSOR')
|
|
pie.prop_enum(context.scene.tool_settings, "transform_pivot_point", value='INDIVIDUAL_ORIGINS')
|
|
pie.prop_enum(context.scene.tool_settings, "transform_pivot_point", value='MEDIAN_POINT')
|
|
pie.prop_enum(context.scene.tool_settings, "transform_pivot_point", value='ACTIVE_ELEMENT')
|
|
if (obj is None) or (mode in {'OBJECT', 'POSE', 'WEIGHT_PAINT'}):
|
|
pie.prop(context.scene.tool_settings, "use_transform_pivot_point_align")
|
|
if mode == 'EDIT_GPENCIL':
|
|
pie.prop(context.scene.tool_settings.gpencil_sculpt, "use_scale_thickness")
|
|
|
|
|
|
class VIEW3D_MT_orientations_pie(Menu):
|
|
bl_label = "Orientation"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
scene = context.scene
|
|
|
|
pie.prop(scene.transform_orientation_slots[0], "type", expand=True)
|
|
|
|
|
|
class VIEW3D_MT_snap_pie(Menu):
|
|
bl_label = "Snap"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
pie.operator("view3d.snap_cursor_to_grid", text="Cursor to Grid", icon='CURSOR')
|
|
pie.operator("view3d.snap_selected_to_grid", text="Selection to Grid", icon='RESTRICT_SELECT_OFF')
|
|
pie.operator("view3d.snap_cursor_to_selected", text="Cursor to Selected", icon='CURSOR')
|
|
pie.operator("view3d.snap_selected_to_cursor",
|
|
text="Selection to Cursor",
|
|
icon='RESTRICT_SELECT_OFF',).use_offset = False
|
|
pie.operator("view3d.snap_selected_to_cursor",
|
|
text="Selection to Cursor (Keep Offset)",
|
|
icon='RESTRICT_SELECT_OFF',).use_offset = True
|
|
pie.operator("view3d.snap_selected_to_active", text="Selection to Active", icon='RESTRICT_SELECT_OFF')
|
|
pie.operator("view3d.snap_cursor_to_center", text="Cursor to World Origin", icon='CURSOR')
|
|
pie.operator("view3d.snap_cursor_to_active", text="Cursor to Active", icon='CURSOR')
|
|
|
|
|
|
class VIEW3D_MT_proportional_editing_falloff_pie(Menu):
|
|
bl_label = "Proportional Editing Falloff"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
tool_settings = context.scene.tool_settings
|
|
|
|
pie.prop(tool_settings, "proportional_edit_falloff", expand=True)
|
|
|
|
|
|
class VIEW3D_MT_sculpt_mask_edit_pie(Menu):
|
|
bl_label = "Mask Edit"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
op = pie.operator("paint.mask_flood_fill", text="Invert Mask")
|
|
op.mode = 'INVERT'
|
|
op = pie.operator("paint.mask_flood_fill", text="Clear Mask")
|
|
op.mode = 'VALUE'
|
|
op.value = 0.0
|
|
op = pie.operator("sculpt.mask_filter", text="Smooth Mask")
|
|
op.filter_type = 'SMOOTH'
|
|
op = pie.operator("sculpt.mask_filter", text="Sharpen Mask")
|
|
op.filter_type = 'SHARPEN'
|
|
op = pie.operator("sculpt.mask_filter", text="Grow Mask")
|
|
op.filter_type = 'GROW'
|
|
op = pie.operator("sculpt.mask_filter", text="Shrink Mask")
|
|
op.filter_type = 'SHRINK'
|
|
op = pie.operator("sculpt.mask_filter", text="Increase Contrast")
|
|
op.filter_type = 'CONTRAST_INCREASE'
|
|
op.auto_iteration_count = False
|
|
op = pie.operator("sculpt.mask_filter", text="Decrease Contrast")
|
|
op.filter_type = 'CONTRAST_DECREASE'
|
|
op.auto_iteration_count = False
|
|
|
|
op = pie.operator("sculpt.ipmask_filter", text='IPMask Smooth')
|
|
op.filter_type = "SMOOTH_SHARPEN"
|
|
op.iterations = 1
|
|
|
|
op = pie.operator("sculpt.ipmask_filter", text='IPMask Grow')
|
|
op.filter_type = "GROW_SHRINK"
|
|
op.iterations = 1
|
|
|
|
op = pie.operator("sculpt.ipmask_filter", text='IPMask Harder')
|
|
op.filter_type = "HARDER_SOFTER"
|
|
op.iterations = 1
|
|
|
|
op = pie.operator("sculpt.ipmask_filter", text='IPMask Contrast')
|
|
op.filter_type = "CONTRAST"
|
|
op.iterations = 1
|
|
|
|
class VIEW3D_MT_sculpt_automasking_pie(Menu):
|
|
bl_label = "Automasking"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
tool_settings = context.tool_settings
|
|
sculpt = tool_settings.sculpt
|
|
|
|
ch = UnifiedPaintPanel.get_channel(context, sculpt.brush, "automasking")
|
|
|
|
keys = ["TOPOLOGY", "FACE_SETS", "BOUNDARY_EDGE", "BOUNDARY_FACE_SETS", "CAVITY", "CAVITY_INVERTED", "BRUSH_NORMAL", "VIEW_NORMAL"]
|
|
|
|
for item in ch.enum_items:
|
|
if item.identifier not in keys:
|
|
keys.append(item.identifier)
|
|
|
|
for key in keys:
|
|
print(key)
|
|
pie.prop_enum(ch, "value", key)
|
|
|
|
class VIEW3D_MT_sculpt_gpencil_automasking_pie(Menu):
|
|
bl_label = "Automasking"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
tool_settings = context.tool_settings
|
|
|
|
pie.prop(tool_settings.gpencil_sculpt, "use_automasking_stroke", text="Stroke")
|
|
pie.prop(tool_settings.gpencil_sculpt, "use_automasking_layer_stroke", text="Layer")
|
|
pie.prop(tool_settings.gpencil_sculpt, "use_automasking_material_stroke", text="Material")
|
|
pie.prop(tool_settings.gpencil_sculpt, "use_automasking_layer_active", text="Active Layer")
|
|
pie.prop(tool_settings.gpencil_sculpt, "use_automasking_material_active", text="Active Material")
|
|
|
|
|
|
class VIEW3D_MT_sculpt_face_sets_edit_pie(Menu):
|
|
|
|
bl_label = "Face Sets Edit"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
op = pie.operator("sculpt.face_sets_create", text="Face Set from Masked")
|
|
op.mode = 'MASKED'
|
|
|
|
op = pie.operator("sculpt.face_sets_create", text="Face Set from Visible")
|
|
op.mode = 'VISIBLE'
|
|
|
|
op = pie.operator("sculpt.face_set_change_visibility", text="Invert Visible")
|
|
op.mode = 'INVERT'
|
|
|
|
op = pie.operator("sculpt.reveal_all", text="Show All")
|
|
|
|
op = pie.operator("sculpt.face_sets_init", text='Init by UV Seams')
|
|
op.mode = 'UV_SEAMS'
|
|
|
|
op = pie.operator("sculpt.face_sets_init", text='Init by Loose Parts')
|
|
op.mode = 'LOOSE_PARTS'
|
|
|
|
op = pie.operator("sculpt.face_sets_init", text='Init by Face Sets Boundaries')
|
|
op.mode = 'FACE_SET_BOUNDARIES'
|
|
|
|
op = pie.operator("sculpt.face_sets_create", text='Face Set from Selection')
|
|
op.mode = 'SELECTION'
|
|
|
|
|
|
class VIEW3D_MT_wpaint_vgroup_lock_pie(Menu):
|
|
bl_label = "Vertex Group Locks"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
pie = layout.menu_pie()
|
|
|
|
# 1: Left
|
|
op = pie.operator("object.vertex_group_lock", icon='LOCKED', text="Lock All")
|
|
op.action, op.mask = 'LOCK', 'ALL'
|
|
# 2: Right
|
|
op = pie.operator("object.vertex_group_lock", icon='UNLOCKED', text="Unlock All")
|
|
op.action, op.mask = 'UNLOCK', 'ALL'
|
|
# 3: Down
|
|
op = pie.operator("object.vertex_group_lock", icon='UNLOCKED', text="Unlock Selected")
|
|
op.action, op.mask = 'UNLOCK', 'SELECTED'
|
|
# 4: Up
|
|
op = pie.operator("object.vertex_group_lock", icon='LOCKED', text="Lock Selected")
|
|
op.action, op.mask = 'LOCK', 'SELECTED'
|
|
# 5: Up/Left
|
|
op = pie.operator("object.vertex_group_lock", icon='LOCKED', text="Lock Unselected")
|
|
op.action, op.mask = 'LOCK', 'UNSELECTED'
|
|
# 6: Up/Right
|
|
op = pie.operator("object.vertex_group_lock", text="Lock Only Selected")
|
|
op.action, op.mask = 'LOCK', 'INVERT_UNSELECTED'
|
|
# 7: Down/Left
|
|
op = pie.operator("object.vertex_group_lock", text="Lock Only Unselected")
|
|
op.action, op.mask = 'UNLOCK', 'INVERT_UNSELECTED'
|
|
# 8: Down/Right
|
|
op = pie.operator("object.vertex_group_lock", text="Invert Locks")
|
|
op.action, op.mask = 'INVERT', 'ALL'
|
|
|
|
|
|
# ********** Panel **********
|
|
class VIEW3D_PT_active_tool(Panel, ToolActivePanelHelper):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "Tool"
|
|
# See comment below.
|
|
# bl_options = {'HIDE_HEADER'}
|
|
|
|
# Don't show in properties editor.
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.area.type == 'VIEW_3D'
|
|
|
|
|
|
# FIXME(campbell): remove this second panel once 'HIDE_HEADER' works with
|
|
# category tabs,
|
|
# Currently pinning allows ordering headerless panels below panels with
|
|
# headers.
|
|
class VIEW3D_PT_active_tool_duplicate(Panel, ToolActivePanelHelper):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "Tool"
|
|
bl_options = {'HIDE_HEADER'}
|
|
|
|
# Only show in properties editor.
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.area.type != 'VIEW_3D'
|
|
|
|
|
|
class VIEW3D_PT_view3d_properties(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "View"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
|
|
layout.use_property_split = True
|
|
layout.use_property_decorate = False # No animation.
|
|
|
|
col = layout.column()
|
|
|
|
subcol = col.column()
|
|
subcol.active = bool(view.region_3d.view_perspective != 'CAMERA' or view.region_quadviews)
|
|
subcol.prop(view, "lens", text="Focal Length")
|
|
|
|
subcol = col.column(align=True)
|
|
subcol.prop(view, "clip_start", text="Clip Start")
|
|
subcol.prop(view, "clip_end", text="End")
|
|
|
|
layout.separator()
|
|
|
|
col = layout.column(align=False, heading="Local Camera")
|
|
col.use_property_decorate = False
|
|
row = col.row(align=True)
|
|
sub = row.row(align=True)
|
|
sub.prop(view, "use_local_camera", text="")
|
|
sub = sub.row(align=True)
|
|
sub.enabled = view.use_local_camera
|
|
sub.prop(view, "camera", text="")
|
|
|
|
layout.separator()
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(view, "use_render_border")
|
|
col.active = view.region_3d.view_perspective != 'CAMERA'
|
|
|
|
|
|
class VIEW3D_PT_view3d_lock(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "View Lock"
|
|
bl_parent_id = "VIEW3D_PT_view3d_properties"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.use_property_split = True
|
|
layout.use_property_decorate = False # No animation.
|
|
|
|
view = context.space_data
|
|
|
|
col = layout.column(align=True)
|
|
sub = col.column()
|
|
sub.active = bool(view.region_3d.view_perspective != 'CAMERA' or view.region_quadviews)
|
|
|
|
sub.prop(view, "lock_object")
|
|
lock_object = view.lock_object
|
|
if lock_object:
|
|
if lock_object.type == 'ARMATURE':
|
|
sub.prop_search(view, "lock_bone", lock_object.data,
|
|
"edit_bones" if lock_object.mode == 'EDIT'
|
|
else "bones",
|
|
text="Bone",)
|
|
|
|
col = layout.column(heading="Lock", align=True)
|
|
if not lock_object:
|
|
col.prop(view, "lock_cursor", text="To 3D Cursor")
|
|
col.prop(view, "lock_camera", text="Camera to View")
|
|
|
|
|
|
class VIEW3D_PT_view3d_cursor(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "3D Cursor"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
cursor = context.scene.cursor
|
|
|
|
layout.column().prop(cursor, "location", text="Location")
|
|
rotation_mode = cursor.rotation_mode
|
|
if rotation_mode == 'QUATERNION':
|
|
layout.column().prop(cursor, "rotation_quaternion", text="Rotation")
|
|
elif rotation_mode == 'AXIS_ANGLE':
|
|
layout.column().prop(cursor, "rotation_axis_angle", text="Rotation")
|
|
else:
|
|
layout.column().prop(cursor, "rotation_euler", text="Rotation")
|
|
layout.prop(cursor, "rotation_mode", text="")
|
|
|
|
|
|
class VIEW3D_PT_collections(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "Collections"
|
|
bl_options = {'DEFAULT_CLOSED'}
|
|
|
|
def _draw_collection(self, layout, view_layer, use_local_collections, collection, index):
|
|
need_separator = index
|
|
for child in collection.children:
|
|
index += 1
|
|
|
|
if child.exclude:
|
|
continue
|
|
|
|
if child.collection.hide_viewport:
|
|
continue
|
|
|
|
if need_separator:
|
|
layout.separator()
|
|
need_separator = False
|
|
|
|
icon = 'BLANK1'
|
|
# has_objects = True
|
|
if child.has_selected_objects(view_layer):
|
|
icon = 'LAYER_ACTIVE'
|
|
elif child.has_objects():
|
|
icon = 'LAYER_USED'
|
|
else:
|
|
# has_objects = False
|
|
pass
|
|
|
|
row = layout.row()
|
|
row.use_property_decorate = False
|
|
sub = row.split(factor=0.98)
|
|
subrow = sub.row()
|
|
subrow.alignment = 'LEFT'
|
|
subrow.operator("object.hide_collection", text=child.name, icon=icon, emboss=False,).collection_index = index
|
|
|
|
sub = row.split()
|
|
subrow = sub.row(align=True)
|
|
subrow.alignment = 'RIGHT'
|
|
if not use_local_collections:
|
|
subrow.active = collection.is_visible # Parent collection runtime visibility
|
|
subrow.prop(child, "hide_viewport", text="", emboss=False)
|
|
else:
|
|
subrow.active = collection.visible_get() # Parent collection runtime visibility
|
|
icon = 'HIDE_OFF' if child.visible_get() else 'HIDE_ON'
|
|
props = subrow.operator("object.hide_collection", text="", icon=icon, emboss=False)
|
|
props.collection_index = index
|
|
props.toggle = True
|
|
|
|
for child in collection.children:
|
|
index = self._draw_collection(layout, view_layer, use_local_collections, child, index)
|
|
|
|
return index
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.use_property_split = False
|
|
|
|
view = context.space_data
|
|
view_layer = context.view_layer
|
|
|
|
layout.use_property_split = True
|
|
layout.prop(view, "use_local_collections")
|
|
layout.separator()
|
|
|
|
# We pass index 0 here because the index is increased
|
|
# so the first real index is 1
|
|
# And we start with index as 1 because we skip the master collection
|
|
self._draw_collection(layout, view_layer, view.use_local_collections, view_layer.layer_collection, 0)
|
|
|
|
|
|
class VIEW3D_PT_object_type_visibility(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "View Object Types"
|
|
bl_ui_units_x = 7
|
|
|
|
# Allows derived classes to pass view data other than context.space_data.
|
|
# This is used by the official VR add-on, which passes XrSessionSettings
|
|
# since VR has a 3D view that only exists for the duration of the VR session.
|
|
def draw_ex(self, _context, view, show_select):
|
|
layout = self.layout
|
|
layout.use_property_split = True
|
|
layout.use_property_decorate = False
|
|
|
|
layout.label(text="Object Types Visibility")
|
|
layout.separator()
|
|
col = layout.column()
|
|
|
|
attr_object_types = (# Geometry
|
|
("mesh", "Mesh"),
|
|
("curve", "Curve"),
|
|
("surf", "Surface"),
|
|
("meta", "Meta"),
|
|
("font", "Text"),
|
|
("curves", "Hair Curves"),
|
|
("pointcloud", "Point Cloud"),
|
|
("volume", "Volume"),
|
|
("grease_pencil", "Grease Pencil"),
|
|
(None, None),
|
|
# Other
|
|
("armature", "Armature"),
|
|
("lattice", "Lattice"),
|
|
("empty", "Empty"),
|
|
("light", "Light"),
|
|
("light_probe", "Light Probe"),
|
|
("camera", "Camera"),
|
|
("speaker", "Speaker"),)
|
|
|
|
for attr, attr_name in attr_object_types:
|
|
if attr is None:
|
|
col.separator()
|
|
continue
|
|
|
|
if attr == "curves" and not hasattr(bpy.data, "hair_curves"):
|
|
continue
|
|
elif attr == "pointcloud" and not hasattr(bpy.data, "pointclouds"):
|
|
continue
|
|
|
|
attr_v = "show_object_viewport_" + attr
|
|
icon_v = 'HIDE_OFF' if getattr(view, attr_v) else 'HIDE_ON'
|
|
|
|
row = col.row(align=True)
|
|
row.alignment = 'RIGHT'
|
|
|
|
row.label(text=attr_name)
|
|
row.prop(view, attr_v, text="", icon=icon_v, emboss=False)
|
|
|
|
if show_select:
|
|
attr_s = "show_object_select_" + attr
|
|
icon_s = 'RESTRICT_SELECT_OFF' if getattr(view, attr_s) else 'RESTRICT_SELECT_ON'
|
|
|
|
rowsub = row.row(align=True)
|
|
rowsub.active = getattr(view, attr_v)
|
|
rowsub.prop(view, attr_s, text="", icon=icon_s, emboss=False)
|
|
|
|
def draw(self, context):
|
|
view = context.space_data
|
|
self.draw_ex(context, view, True)
|
|
|
|
|
|
class VIEW3D_PT_shading(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Shading"
|
|
bl_ui_units_x = 12
|
|
|
|
@classmethod
|
|
def get_shading(cls, context):
|
|
# Get settings from 3D viewport or OpenGL render engine
|
|
view = context.space_data
|
|
if view.type == 'VIEW_3D':
|
|
return view.shading
|
|
else:
|
|
return context.scene.display.shading
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.label(text="Viewport Shading")
|
|
|
|
|
|
class VIEW3D_PT_shading_lighting(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Lighting"
|
|
bl_parent_id = 'VIEW3D_PT_shading'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
engine = context.scene.render.engine
|
|
return shading.type in {'SOLID', 'MATERIAL'} or engine == 'BLENDER_EEVEE' and shading.type == 'RENDERED'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
|
|
col = layout.column()
|
|
split = col.split(factor=0.9)
|
|
|
|
if shading.type == 'SOLID':
|
|
split.row().prop(shading, "light", expand=True)
|
|
col = split.column()
|
|
|
|
split = layout.split(factor=0.9)
|
|
col = split.column()
|
|
sub = col.row()
|
|
|
|
if shading.light == 'STUDIO':
|
|
prefs = context.preferences
|
|
system = prefs.system
|
|
|
|
if not system.use_studio_light_edit:
|
|
sub.scale_y = 0.6 # smaller studiolight preview
|
|
sub.template_icon_view(shading, "studio_light", scale_popup=3.0)
|
|
else:
|
|
sub.prop(system,
|
|
"use_studio_light_edit",
|
|
text="Disable Studio Light Edit",
|
|
icon='NONE',
|
|
toggle=True,)
|
|
|
|
col = split.column()
|
|
col.operator("preferences.studiolight_show", emboss=False, text="", icon='PREFERENCES')
|
|
|
|
split = layout.split(factor=0.9)
|
|
col = split.column()
|
|
|
|
row = col.row()
|
|
row.prop(shading, "use_world_space_lighting", text="", icon='WORLD', toggle=True)
|
|
row = row.row()
|
|
row.active = shading.use_world_space_lighting
|
|
row.prop(shading, "studiolight_rotate_z", text="Rotation")
|
|
col = split.column() # to align properly with above
|
|
|
|
elif shading.light == 'MATCAP':
|
|
sub.scale_y = 0.6 # smaller matcap preview
|
|
sub.template_icon_view(shading, "studio_light", scale_popup=3.0)
|
|
|
|
col = split.column()
|
|
col.operator("preferences.studiolight_show", emboss=False, text="", icon='PREFERENCES')
|
|
col.operator("view3d.toggle_matcap_flip", emboss=False, text="", icon='ARROW_LEFTRIGHT')
|
|
|
|
elif shading.type == 'MATERIAL':
|
|
col.prop(shading, "use_scene_lights")
|
|
col.prop(shading, "use_scene_world")
|
|
col = layout.column()
|
|
split = col.split(factor=0.9)
|
|
|
|
if not shading.use_scene_world:
|
|
col = split.column()
|
|
sub = col.row()
|
|
sub.scale_y = 0.6
|
|
sub.template_icon_view(shading, "studio_light", scale_popup=3)
|
|
|
|
col = split.column()
|
|
col.operator("preferences.studiolight_show", emboss=False, text="", icon='PREFERENCES')
|
|
|
|
split = layout.split(factor=0.9)
|
|
col = split.column()
|
|
|
|
row = col.row()
|
|
row.prop(shading, "use_studiolight_view_rotation", text="", icon='WORLD', toggle=True)
|
|
row = row.row()
|
|
row.prop(shading, "studiolight_rotate_z", text="Rotation")
|
|
|
|
col.prop(shading, "studiolight_intensity")
|
|
col.prop(shading, "studiolight_background_alpha")
|
|
col.prop(shading, "studiolight_background_blur")
|
|
col = split.column() # to align properly with above
|
|
|
|
elif shading.type == 'RENDERED':
|
|
col.prop(shading, "use_scene_lights_render")
|
|
col.prop(shading, "use_scene_world_render")
|
|
|
|
if not shading.use_scene_world_render:
|
|
col = layout.column()
|
|
split = col.split(factor=0.9)
|
|
|
|
col = split.column()
|
|
sub = col.row()
|
|
sub.scale_y = 0.6
|
|
sub.template_icon_view(shading, "studio_light", scale_popup=3)
|
|
|
|
col = split.column()
|
|
col.operator("preferences.studiolight_show", emboss=False, text="", icon='PREFERENCES')
|
|
|
|
split = layout.split(factor=0.9)
|
|
col = split.column()
|
|
col.prop(shading, "studiolight_rotate_z", text="Rotation")
|
|
col.prop(shading, "studiolight_intensity")
|
|
col.prop(shading, "studiolight_background_alpha")
|
|
col.prop(shading, "studiolight_background_blur")
|
|
col = split.column() # to align properly with above
|
|
class VIEW3D_PT_shading_color(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Color"
|
|
bl_parent_id = 'VIEW3D_PT_shading'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
return shading.type in {'WIREFRAME', 'SOLID'}
|
|
|
|
def _draw_color_type(self, context):
|
|
layout = self.layout
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
|
|
layout.grid_flow(columns=3, align=True).prop(shading, "color_type", expand=True)
|
|
if shading.color_type == 'SINGLE':
|
|
layout.row().prop(shading, "single_color", text="")
|
|
|
|
def _draw_background_color(self, context):
|
|
layout = self.layout
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
|
|
layout.row().label(text="Background")
|
|
layout.row().prop(shading, "background_type", expand=True)
|
|
if shading.background_type == 'VIEWPORT':
|
|
layout.row().prop(shading, "background_color", text="")
|
|
|
|
def draw(self, context):
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
if shading.type == 'WIREFRAME':
|
|
self.layout.row().prop(shading, "wireframe_color_type", expand=True)
|
|
else:
|
|
self._draw_color_type(context)
|
|
self.layout.separator()
|
|
self._draw_background_color(context)
|
|
|
|
|
|
class VIEW3D_PT_shading_options(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Options"
|
|
bl_parent_id = 'VIEW3D_PT_shading'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
return shading.type in {'WIREFRAME', 'SOLID'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
|
|
col = layout.column()
|
|
|
|
if shading.type == 'SOLID':
|
|
col.prop(shading, "show_backface_culling")
|
|
|
|
row = col.row(align=True)
|
|
|
|
if shading.type == 'WIREFRAME':
|
|
row.prop(shading, "show_xray_wireframe", text="")
|
|
sub = row.row()
|
|
sub.active = shading.show_xray_wireframe
|
|
sub.prop(shading, "xray_alpha_wireframe", text="X-Ray")
|
|
elif shading.type == 'SOLID':
|
|
row.prop(shading, "show_xray", text="")
|
|
sub = row.row()
|
|
sub.active = shading.show_xray
|
|
sub.prop(shading, "xray_alpha", text="X-Ray")
|
|
# X-ray mode is off when alpha is 1.0
|
|
xray_active = shading.show_xray and shading.xray_alpha != 1
|
|
|
|
row = col.row(align=True)
|
|
row.prop(shading, "show_shadows", text="")
|
|
row.active = not xray_active
|
|
sub = row.row(align=True)
|
|
sub.active = shading.show_shadows
|
|
sub.prop(shading, "shadow_intensity", text="Shadow")
|
|
sub.popover(panel="VIEW3D_PT_shading_options_shadow",
|
|
icon='PREFERENCES',
|
|
text="",)
|
|
|
|
col = layout.column()
|
|
|
|
row = col.row()
|
|
row.active = not xray_active
|
|
row.prop(shading, "show_cavity")
|
|
|
|
if shading.show_cavity and not xray_active:
|
|
row.prop(shading, "cavity_type", text="Type")
|
|
|
|
if shading.cavity_type in {'WORLD', 'BOTH'}:
|
|
col.label(text="World Space")
|
|
sub = col.row(align=True)
|
|
sub.prop(shading, "cavity_ridge_factor", text="Ridge")
|
|
sub.prop(shading, "cavity_valley_factor", text="Valley")
|
|
sub.popover(panel="VIEW3D_PT_shading_options_ssao",
|
|
icon='PREFERENCES',
|
|
text="",)
|
|
|
|
if shading.cavity_type in {'SCREEN', 'BOTH'}:
|
|
col.label(text="Screen Space")
|
|
sub = col.row(align=True)
|
|
sub.prop(shading, "curvature_ridge_factor", text="Ridge")
|
|
sub.prop(shading, "curvature_valley_factor", text="Valley")
|
|
|
|
row = col.row()
|
|
row.active = not xray_active
|
|
row.prop(shading, "use_dof", text="Depth of Field")
|
|
|
|
if shading.type in {'WIREFRAME', 'SOLID'}:
|
|
row = layout.split()
|
|
row.prop(shading, "show_object_outline")
|
|
sub = row.row()
|
|
sub.active = shading.show_object_outline
|
|
sub.prop(shading, "object_outline_color", text="")
|
|
|
|
if shading.type == 'SOLID':
|
|
col = layout.column()
|
|
if shading.light in {'STUDIO', 'MATCAP'}:
|
|
col.active = shading.selected_studio_light.has_specular_highlight_pass
|
|
col.prop(shading, "show_specular_highlight", text="Specular Lighting")
|
|
|
|
|
|
class VIEW3D_PT_shading_options_shadow(Panel):
|
|
bl_label = "Shadow Settings"
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.use_property_split = True
|
|
scene = context.scene
|
|
|
|
col = layout.column()
|
|
col.prop(scene.display, "light_direction")
|
|
col.prop(scene.display, "shadow_shift")
|
|
col.prop(scene.display, "shadow_focus")
|
|
|
|
|
|
class VIEW3D_PT_shading_options_ssao(Panel):
|
|
bl_label = "SSAO Settings"
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.use_property_split = True
|
|
scene = context.scene
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(scene.display, "matcap_ssao_samples")
|
|
col.prop(scene.display, "matcap_ssao_distance")
|
|
col.prop(scene.display, "matcap_ssao_attenuation")
|
|
|
|
|
|
class VIEW3D_PT_shading_render_pass(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Render Pass"
|
|
bl_parent_id = 'VIEW3D_PT_shading'
|
|
COMPAT_ENGINES = {'BLENDER_EEVEE'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return ((context.space_data.shading.type == 'MATERIAL') or (context.engine in cls.COMPAT_ENGINES and context.space_data.shading.type == 'RENDERED'))
|
|
|
|
def draw(self, context):
|
|
shading = context.space_data.shading
|
|
|
|
layout = self.layout
|
|
layout.prop(shading, "render_pass", text="")
|
|
|
|
|
|
class VIEW3D_PT_shading_compositor(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Compositor"
|
|
bl_parent_id = 'VIEW3D_PT_shading'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.space_data.shading.type in {'MATERIAL', 'RENDERED'}
|
|
|
|
def draw(self, context):
|
|
shading = context.space_data.shading
|
|
|
|
import gpu
|
|
is_supported = (gpu.capabilities.compute_shader_support_get()
|
|
and gpu.capabilities.shader_image_load_store_support_get())
|
|
|
|
row = self.layout.row()
|
|
row.active = is_supported
|
|
row.prop(shading, "use_compositor", expand=True)
|
|
if shading.use_compositor != "DISABLED" and not is_supported:
|
|
self.layout.label(text="Compositor not supported on this platform", icon='ERROR')
|
|
|
|
|
|
class VIEW3D_PT_gizmo_display(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Gizmos"
|
|
bl_ui_units_x = 8
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
scene = context.scene
|
|
view = context.space_data
|
|
|
|
col = layout.column()
|
|
col.label(text="Viewport Gizmos")
|
|
col.separator()
|
|
|
|
col.active = view.show_gizmo
|
|
colsub = col.column()
|
|
colsub.prop(view, "show_gizmo_navigate", text="Navigate")
|
|
colsub.prop(view, "show_gizmo_tool", text="Active Tools")
|
|
colsub.prop(view, "show_gizmo_context", text="Active Object")
|
|
|
|
layout.separator()
|
|
|
|
col = layout.column()
|
|
col.active = view.show_gizmo and view.show_gizmo_context
|
|
col.label(text="Object Gizmos")
|
|
col.prop(scene.transform_orientation_slots[1], "type", text="")
|
|
col.prop(view, "show_gizmo_object_translate", text="Move")
|
|
col.prop(view, "show_gizmo_object_rotate", text="Rotate")
|
|
col.prop(view, "show_gizmo_object_scale", text="Scale")
|
|
|
|
layout.separator()
|
|
|
|
# Match order of object type visibility
|
|
col = layout.column()
|
|
col.active = view.show_gizmo
|
|
col.label(text="Empty")
|
|
col.prop(view, "show_gizmo_empty_image", text="Image")
|
|
col.prop(view, "show_gizmo_empty_force_field", text="Force Field")
|
|
col.label(text="Light")
|
|
col.prop(view, "show_gizmo_light_size", text="Size")
|
|
col.prop(view, "show_gizmo_light_look_at", text="Look At")
|
|
col.label(text="Camera")
|
|
col.prop(view, "show_gizmo_camera_lens", text="Lens")
|
|
col.prop(view, "show_gizmo_camera_dof_distance", text="Focus Distance")
|
|
|
|
|
|
class VIEW3D_PT_overlay(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Overlays"
|
|
bl_ui_units_x = 13
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.label(text="Viewport Overlays")
|
|
|
|
|
|
class VIEW3D_PT_overlay_guides(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Guides"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
scene = context.scene
|
|
|
|
overlay = view.overlay
|
|
shading = view.shading
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
split = col.split()
|
|
sub = split.column()
|
|
|
|
row = sub.row()
|
|
row_el = row.column()
|
|
row_el.prop(overlay, "show_ortho_grid", text="Grid")
|
|
grid_active = bool(view.region_quadviews or (view.region_3d.is_orthographic_side_view and not view.region_3d.is_perspective))
|
|
row_el.active = grid_active
|
|
row.prop(overlay, "show_floor", text="Floor", text_ctxt=i18n_contexts.editor_view3d)
|
|
|
|
if overlay.show_floor or overlay.show_ortho_grid:
|
|
sub = col.row(align=True)
|
|
sub.active = ((overlay.show_floor and not view.region_3d.is_orthographic_side_view) or (overlay.show_ortho_grid and grid_active))
|
|
sub.prop(overlay, "grid_scale", text="Scale")
|
|
sub = sub.row(align=True)
|
|
sub.active = scene.unit_settings.system == 'NONE'
|
|
sub.prop(overlay, "grid_subdivisions", text="Subdivisions")
|
|
|
|
sub = split.column()
|
|
row = sub.row()
|
|
row.label(text="Axes")
|
|
|
|
subrow = row.row(align=True)
|
|
subrow.prop(overlay, "show_axis_x", text="X", toggle=True)
|
|
subrow.prop(overlay, "show_axis_y", text="Y", toggle=True)
|
|
subrow.prop(overlay, "show_axis_z", text="Z", toggle=True)
|
|
|
|
split = col.split()
|
|
sub = split.column()
|
|
sub.prop(overlay, "show_text", text="Text Info")
|
|
sub.prop(overlay, "show_stats", text="Statistics")
|
|
|
|
sub = split.column()
|
|
sub.prop(overlay, "show_cursor", text="3D Cursor")
|
|
sub.prop(overlay, "show_annotation", text="Annotations")
|
|
|
|
if shading.type == 'MATERIAL':
|
|
row = col.row()
|
|
row.active = shading.render_pass == 'COMBINED'
|
|
row.prop(overlay, "show_look_dev")
|
|
|
|
|
|
class VIEW3D_PT_overlay_object(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Objects"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column(align=True)
|
|
col.active = display_all
|
|
|
|
split = col.split()
|
|
|
|
sub = split.column(align=True)
|
|
sub.prop(overlay, "show_extras", text="Extras")
|
|
sub.prop(overlay, "show_relationship_lines")
|
|
sub.prop(overlay, "show_outline_selected")
|
|
|
|
sub = split.column(align=True)
|
|
sub.prop(overlay, "show_bones", text="Bones")
|
|
sub.prop(overlay, "show_motion_paths")
|
|
sub.prop(overlay, "show_object_origins", text="Origins")
|
|
subsub = sub.column()
|
|
subsub.active = overlay.show_object_origins
|
|
subsub.prop(overlay, "show_object_origins_all", text="Origins (All)")
|
|
|
|
|
|
class VIEW3D_PT_overlay_geometry(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Geometry"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
is_wireframes = view.shading.type == 'WIREFRAME'
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
row = col.row(align=True)
|
|
if not is_wireframes:
|
|
row.prop(overlay, "show_wireframes", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.show_wireframes or is_wireframes
|
|
sub.prop(overlay, "wireframe_threshold", text="Wireframe")
|
|
sub.prop(overlay, "wireframe_opacity", text="Opacity")
|
|
|
|
row = col.row(align=True)
|
|
row.active = view.show_viewer
|
|
row.prop(overlay, "show_viewer_attribute", text="")
|
|
subrow = row.row(align=True)
|
|
subrow.active = overlay.show_viewer_attribute
|
|
subrow.prop(overlay, "viewer_attribute_opacity", text="Viewer Node")
|
|
|
|
row = col.row(align=True)
|
|
|
|
# These properties should be always available in the UI for all modes
|
|
# other than Object.
|
|
# Even when the Fade Inactive Geometry overlay is not affecting the
|
|
# current active object depending on its mode, it will always affect
|
|
# the rest of the scene.
|
|
if context.mode != 'OBJECT':
|
|
row.prop(overlay, "show_fade_inactive", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.show_fade_inactive
|
|
sub.prop(overlay, "fade_inactive_alpha", text="Fade Inactive Geometry")
|
|
|
|
col = layout.column(align=True)
|
|
col.active = display_all
|
|
|
|
col.prop(overlay, "show_face_orientation")
|
|
|
|
# sub.prop(overlay, "show_onion_skins")
|
|
class VIEW3D_PT_overlay_motion_tracking(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Motion Tracking"
|
|
|
|
def draw_header(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
layout.active = display_all
|
|
layout.prop(view, "show_reconstruction", text=self.bl_label)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
if view.show_reconstruction:
|
|
split = col.split()
|
|
|
|
sub = split.column(align=True)
|
|
sub.active = view.show_reconstruction
|
|
sub.prop(view, "show_camera_path", text="Camera Path")
|
|
|
|
sub = split.column()
|
|
sub.prop(view, "show_bundle_names", text="Marker Names")
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
col.label(text="Tracks")
|
|
row = col.row(align=True)
|
|
row.prop(view, "tracks_display_type", text="")
|
|
row.prop(view, "tracks_display_size", text="Size")
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_mesh(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Mesh Edit Mode"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_MESH'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
shading = view.shading
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
is_any_solid_shading = not (shading.show_xray or (shading.type == 'WIREFRAME'))
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
split = col.split()
|
|
|
|
sub = split.column()
|
|
sub.active = is_any_solid_shading
|
|
sub.prop(overlay, "show_edges", text="Edges")
|
|
sub = split.column()
|
|
sub.prop(overlay, "show_faces", text="Faces")
|
|
sub = split.column()
|
|
sub.active = is_any_solid_shading
|
|
sub.prop(overlay, "show_face_center", text="Center")
|
|
|
|
row = col.row(align=True)
|
|
row.prop(overlay, "show_edge_crease", text="Creases", toggle=True)
|
|
row.prop(overlay, "show_edge_sharp", text="Sharp", text_ctxt=i18n_contexts.plural, toggle=True)
|
|
row.prop(overlay, "show_edge_bevel_weight", text="Bevel", toggle=True)
|
|
row.prop(overlay, "show_edge_seams", text="Seams", toggle=True)
|
|
|
|
if context.preferences.view.show_developer_ui:
|
|
col.label(text="Developer")
|
|
col.prop(overlay, "show_extra_indices", text="Indices")
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_mesh_shading(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay_edit_mesh'
|
|
bl_label = "Shading"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_MESH'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
shading = view.shading
|
|
overlay = view.overlay
|
|
tool_settings = context.tool_settings
|
|
display_all = overlay.show_overlays
|
|
statvis = tool_settings.statvis
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
col.prop(overlay, "show_occlude_wire")
|
|
|
|
col.prop(overlay, "show_weight", text="Vertex Group Weights")
|
|
if overlay.show_weight:
|
|
row = col.split(factor=0.33)
|
|
row.label(text="Zero Weights")
|
|
sub = row.row()
|
|
sub.prop(tool_settings, "vertex_group_user", expand=True)
|
|
|
|
if shading.type == 'WIREFRAME':
|
|
xray = shading.show_xray_wireframe and shading.xray_alpha_wireframe < 1.0
|
|
elif shading.type == 'SOLID':
|
|
xray = shading.show_xray and shading.xray_alpha < 1.0
|
|
else:
|
|
xray = False
|
|
statvis_active = not xray
|
|
row = col.row()
|
|
row.active = statvis_active
|
|
row.prop(overlay, "show_statvis", text="Mesh Analysis")
|
|
if overlay.show_statvis:
|
|
col = col.column()
|
|
col.active = statvis_active
|
|
|
|
sub = col.split()
|
|
sub.label(text="Type")
|
|
sub.prop(statvis, "type", text="")
|
|
|
|
statvis_type = statvis.type
|
|
if statvis_type == 'OVERHANG':
|
|
row = col.row(align=True)
|
|
row.prop(statvis, "overhang_min", text="Minimum")
|
|
row.prop(statvis, "overhang_max", text="Maximum")
|
|
col.row().prop(statvis, "overhang_axis", expand=True)
|
|
elif statvis_type == 'THICKNESS':
|
|
row = col.row(align=True)
|
|
row.prop(statvis, "thickness_min", text="Minimum")
|
|
row.prop(statvis, "thickness_max", text="Maximum")
|
|
col.prop(statvis, "thickness_samples")
|
|
elif statvis_type == 'INTERSECT':
|
|
pass
|
|
elif statvis_type == 'DISTORT':
|
|
row = col.row(align=True)
|
|
row.prop(statvis, "distort_min", text="Minimum")
|
|
row.prop(statvis, "distort_max", text="Maximum")
|
|
elif statvis_type == 'SHARP':
|
|
row = col.row(align=True)
|
|
row.prop(statvis, "sharp_min", text="Minimum")
|
|
row.prop(statvis, "sharp_max", text="Maximum")
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_mesh_measurement(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay_edit_mesh'
|
|
bl_label = "Measurement"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_MESH'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
split = col.split()
|
|
|
|
sub = split.column()
|
|
sub.prop(overlay, "show_extra_edge_length", text="Edge Length")
|
|
sub.prop(overlay, "show_extra_edge_angle", text="Edge Angle")
|
|
|
|
sub = split.column()
|
|
sub.prop(overlay, "show_extra_face_area", text="Face Area")
|
|
sub.prop(overlay, "show_extra_face_angle", text="Face Angle")
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_mesh_normals(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay_edit_mesh'
|
|
bl_label = "Normals"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_MESH'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
row = col.row(align=True)
|
|
row.prop(overlay, "show_vertex_normals", text="", icon='NORMALS_VERTEX')
|
|
row.prop(overlay, "show_split_normals", text="", icon='NORMALS_VERTEX_FACE')
|
|
row.prop(overlay, "show_face_normals", text="", icon='NORMALS_FACE')
|
|
|
|
sub = row.row(align=True)
|
|
sub.active = overlay.show_vertex_normals or overlay.show_face_normals or overlay.show_split_normals
|
|
if overlay.use_normals_constant_screen_size:
|
|
sub.prop(overlay, "normals_constant_screen_size", text="Size")
|
|
else:
|
|
sub.prop(overlay, "normals_length", text="Size")
|
|
|
|
row.prop(overlay, "use_normals_constant_screen_size", text="", icon='FIXED_SIZE')
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_mesh_freestyle(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Freestyle"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_MESH' and bpy.app.build_options.freestyle
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
row = col.row()
|
|
row.prop(overlay, "show_freestyle_edge_marks", text="Edge Marks")
|
|
row.prop(overlay, "show_freestyle_face_marks", text="Face Marks")
|
|
|
|
|
|
class VIEW3D_PT_overlay_edit_curve(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Curve Edit Mode"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'EDIT_CURVE'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
row = col.row()
|
|
row.prop(overlay, "display_handle", text="Handles")
|
|
|
|
row = col.row()
|
|
row.prop(overlay, "show_curve_normals", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.show_curve_normals
|
|
sub.prop(overlay, "normals_length", text="Normals")
|
|
|
|
|
|
class VIEW3D_PT_overlay_sculpt(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_context = ".sculpt_mode"
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Sculpt"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return (context.mode == 'SCULPT' and (context.sculpt_object and context.tool_settings.sculpt))
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
sculpt = tool_settings.sculpt
|
|
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
|
|
row = layout.row(align=True)
|
|
row.prop(overlay, "sculpt_show_mask", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.sculpt_show_mask
|
|
sub.prop(overlay, "sculpt_mode_mask_opacity", text="Mask")
|
|
|
|
row = layout.row(align=True)
|
|
row.prop(overlay, "sculpt_show_face_sets", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.sculpt_show_face_sets
|
|
row.prop(overlay, "sculpt_mode_face_sets_opacity", text="Face Sets")
|
|
|
|
row = layout.row(align=True)
|
|
row.prop(overlay, "sculpt_mode_use_face_set_moire")
|
|
|
|
if overlay.sculpt_mode_use_face_set_moire:
|
|
row = layout.row(align=True)
|
|
row.prop(overlay, "sculpt_mode_face_sets_moire_seed", text="Seed")
|
|
row.prop(overlay, "sculpt_mode_face_sets_moire_scale", text="Size")
|
|
row.prop(overlay, "use_sculpt_mode_face_sets_moire", text="Size")
|
|
|
|
|
|
class VIEW3D_PT_overlay_sculpt_curves(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_context = ".curves_sculpt"
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Sculpt"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'SCULPT_CURVES' and (context.object)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
sculpt = tool_settings.sculpt
|
|
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
|
|
row = layout.row(align=True)
|
|
row.active = overlay.show_overlays
|
|
row.prop(overlay, "sculpt_mode_mask_opacity", text="Selection Opacity")
|
|
|
|
|
|
class VIEW3D_PT_overlay_bones(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Bones"
|
|
|
|
@staticmethod
|
|
def is_using_wireframe(context):
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
|
|
if shading.type == 'WIREFRAME' or shading.show_xray:
|
|
return True
|
|
|
|
mode = context.mode
|
|
|
|
if mode in {'POSE', 'PAINT_WEIGHT'}:
|
|
armature = context.pose_object
|
|
elif mode == 'EDIT_ARMATURE':
|
|
armature = context.edit_object
|
|
else:
|
|
return False
|
|
|
|
return armature and armature.display_type == 'WIRE'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
mode = context.mode
|
|
return (
|
|
(mode == 'POSE') or
|
|
(mode == 'PAINT_WEIGHT' and context.pose_object) or
|
|
(mode in {'EDIT_ARMATURE', 'OBJECT'} and
|
|
VIEW3D_PT_overlay_bones.is_using_wireframe(context))
|
|
)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
mode = context.mode
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
if mode == 'POSE':
|
|
row = col.row()
|
|
row.prop(overlay, "show_xray_bone", text="")
|
|
sub = row.row()
|
|
sub.active = display_all and overlay.show_xray_bone
|
|
sub.prop(overlay, "xray_alpha_bone", text="Fade Geometry")
|
|
elif mode == 'PAINT_WEIGHT':
|
|
row = col.row()
|
|
row.prop(overlay, "show_xray_bone")
|
|
|
|
if VIEW3D_PT_overlay_bones.is_using_wireframe(context):
|
|
col.prop(overlay, "bone_wire_alpha")
|
|
|
|
|
|
class VIEW3D_PT_overlay_texture_paint(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Texture Paint"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'PAINT_TEXTURE'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
col.prop(overlay, "texture_paint_mode_opacity")
|
|
|
|
|
|
class VIEW3D_PT_overlay_vertex_paint(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Vertex Paint"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'PAINT_VERTEX'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
col.prop(overlay, "vertex_paint_mode_opacity")
|
|
col.prop(overlay, "show_paint_wire")
|
|
|
|
|
|
class VIEW3D_PT_overlay_weight_paint(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Weight Paint"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'PAINT_WEIGHT'
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
display_all = overlay.show_overlays
|
|
|
|
col = layout.column()
|
|
col.active = display_all
|
|
|
|
col.prop(overlay, "weight_paint_mode_opacity", text="Opacity")
|
|
row = col.split(factor=0.33)
|
|
row.label(text="Zero Weights")
|
|
sub = row.row()
|
|
sub.prop(context.tool_settings, "vertex_group_user", expand=True)
|
|
|
|
col.prop(overlay, "show_wpaint_contours")
|
|
col.prop(overlay, "show_paint_wire")
|
|
|
|
|
|
class VIEW3D_PT_snapping(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Snapping"
|
|
|
|
def draw(self, context):
|
|
tool_settings = context.tool_settings
|
|
snap_elements = tool_settings.snap_elements
|
|
obj = context.active_object
|
|
object_mode = 'OBJECT' if obj is None else obj.mode
|
|
|
|
layout = self.layout
|
|
col = layout.column()
|
|
col.label(text="Snap To")
|
|
col.prop(tool_settings, "snap_elements", expand=True)
|
|
|
|
col.separator()
|
|
if 'INCREMENT' in snap_elements:
|
|
col.prop(tool_settings, "use_snap_grid_absolute")
|
|
|
|
if snap_elements != {'INCREMENT'}:
|
|
if snap_elements != {'FACE_NEAREST'}:
|
|
col.label(text="Snap With")
|
|
row = col.row(align=True)
|
|
row.prop(tool_settings, "snap_target", expand=True)
|
|
|
|
if obj:
|
|
col.label(text="Target Selection")
|
|
col_targetsel = col.column(align=True)
|
|
if object_mode == 'EDIT' and obj.type not in {'LATTICE', 'META', 'FONT'}:
|
|
col_targetsel.prop(
|
|
tool_settings,
|
|
"use_snap_self",
|
|
text="Include Active",
|
|
icon='EDITMODE_HLT',
|
|
)
|
|
col_targetsel.prop(
|
|
tool_settings,
|
|
"use_snap_edit",
|
|
text="Include Edited",
|
|
icon='OUTLINER_DATA_MESH',
|
|
)
|
|
col_targetsel.prop(
|
|
tool_settings,
|
|
"use_snap_nonedit",
|
|
text="Include Non-Edited",
|
|
icon='OUTLINER_OB_MESH',
|
|
)
|
|
col_targetsel.prop(
|
|
tool_settings,
|
|
"use_snap_selectable",
|
|
text="Exclude Non-Selectable",
|
|
icon='RESTRICT_SELECT_OFF',
|
|
)
|
|
|
|
if object_mode in {'OBJECT', 'POSE', 'EDIT', 'WEIGHT_PAINT'}:
|
|
col.prop(tool_settings, "use_snap_align_rotation")
|
|
|
|
col.prop(tool_settings, "use_snap_backface_culling")
|
|
|
|
if 'FACE' in snap_elements:
|
|
col.prop(tool_settings, "use_snap_project")
|
|
|
|
if 'FACE_NEAREST' in snap_elements:
|
|
col.prop(tool_settings, "use_snap_to_same_target")
|
|
if object_mode == 'EDIT':
|
|
col.prop(tool_settings, "snap_face_nearest_steps")
|
|
|
|
if 'VOLUME' in snap_elements:
|
|
col.prop(tool_settings, "use_snap_peel_object")
|
|
|
|
col.label(text="Affect")
|
|
row = col.row(align=True)
|
|
row.prop(tool_settings, "use_snap_translate", text="Move", toggle=True)
|
|
row.prop(tool_settings, "use_snap_rotate", text="Rotate", toggle=True)
|
|
row.prop(tool_settings, "use_snap_scale", text="Scale", toggle=True)
|
|
|
|
|
|
class VIEW3D_PT_proportional_edit(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Proportional Editing"
|
|
bl_ui_units_x = 8
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
col = layout.column()
|
|
col.active = (tool_settings.use_proportional_edit_objects if context.mode == 'OBJECT'
|
|
else tool_settings.use_proportional_edit)
|
|
|
|
if context.mode != 'OBJECT':
|
|
col.prop(tool_settings, "use_proportional_connected")
|
|
sub = col.column()
|
|
sub.active = not tool_settings.use_proportional_connected
|
|
sub.prop(tool_settings, "use_proportional_projected")
|
|
col.separator()
|
|
|
|
col.prop(tool_settings, "proportional_edit_falloff", expand=True)
|
|
|
|
|
|
class VIEW3D_PT_transform_orientations(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Transform Orientations"
|
|
bl_ui_units_x = 8
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.label(text="Transform Orientations")
|
|
|
|
scene = context.scene
|
|
orient_slot = scene.transform_orientation_slots[0]
|
|
orientation = orient_slot.custom_orientation
|
|
|
|
row = layout.row()
|
|
col = row.column()
|
|
col.prop(orient_slot, "type", expand=True)
|
|
row.operator("transform.create_orientation", text="", icon='ADD', emboss=False).use = True
|
|
|
|
if orientation:
|
|
row = layout.row(align=False)
|
|
row.prop(orientation, "name", text="", icon='OBJECT_ORIGIN')
|
|
row.operator("transform.delete_orientation", text="", icon='X', emboss=False)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_origin(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Stroke Placement"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
tool_settings = context.tool_settings
|
|
gpd = context.gpencil_data
|
|
|
|
layout.label(text="Stroke Placement")
|
|
|
|
row = layout.row()
|
|
col = row.column()
|
|
col.prop(tool_settings, "gpencil_stroke_placement_view3d", expand=True)
|
|
|
|
if tool_settings.gpencil_stroke_placement_view3d == 'SURFACE':
|
|
row = layout.row()
|
|
row.label(text="Offset")
|
|
row = layout.row()
|
|
row.prop(gpd, "zdepth_offset", text="")
|
|
|
|
if tool_settings.gpencil_stroke_placement_view3d == 'STROKE':
|
|
row = layout.row()
|
|
row.label(text="Target")
|
|
row = layout.row()
|
|
row.prop(tool_settings, "gpencil_stroke_snap_mode", expand=True)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_lock(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Drawing Plane"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
layout.label(text="Drawing Plane")
|
|
|
|
row = layout.row()
|
|
col = row.column()
|
|
col.prop(context.tool_settings.gpencil_sculpt, "lock_axis", expand=True)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_guide(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Guides"
|
|
|
|
def draw(self, context):
|
|
settings = context.tool_settings.gpencil_sculpt.guide
|
|
|
|
layout = self.layout
|
|
layout.label(text="Guides")
|
|
|
|
col = layout.column()
|
|
col.active = settings.use_guide
|
|
col.prop(settings, "type", expand=True)
|
|
|
|
if settings.type in {'ISO', 'PARALLEL', 'RADIAL'}:
|
|
col.prop(settings, "angle")
|
|
row = col.row(align=True)
|
|
|
|
col.prop(settings, "use_snapping")
|
|
if settings.use_snapping:
|
|
|
|
if settings.type == 'RADIAL':
|
|
col.prop(settings, "angle_snap")
|
|
else:
|
|
col.prop(settings, "spacing")
|
|
|
|
if settings.type in {'CIRCULAR', 'RADIAL'} or settings.use_snapping:
|
|
col.label(text="Reference Point")
|
|
row = col.row(align=True)
|
|
row.prop(settings, "reference_point", expand=True)
|
|
if settings.reference_point == 'CUSTOM':
|
|
col.prop(settings, "location", text="Custom Location")
|
|
elif settings.reference_point == 'OBJECT':
|
|
col.prop(settings, "reference_object", text="Object Location")
|
|
if not settings.reference_object:
|
|
col.label(text="No object selected, using cursor")
|
|
|
|
|
|
class VIEW3D_PT_overlay_gpencil_options(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = ""
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.object and context.object.type == 'GPENCIL'
|
|
|
|
def draw_header(self, context):
|
|
layout = self.layout
|
|
layout.label(text={
|
|
'PAINT_GPENCIL': iface_("Draw Grease Pencil"),
|
|
'EDIT_GPENCIL': iface_("Edit Grease Pencil"),
|
|
'SCULPT_GPENCIL': iface_("Sculpt Grease Pencil"),
|
|
'WEIGHT_GPENCIL': iface_("Weight Grease Pencil"),
|
|
'VERTEX_GPENCIL': iface_("Vertex Grease Pencil"),
|
|
'OBJECT': iface_("Grease Pencil"),
|
|
}[context.mode], translate=False)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
|
|
layout.prop(overlay, "use_gpencil_onion_skin", text="Onion Skin")
|
|
|
|
col = layout.column()
|
|
row = col.row()
|
|
row.prop(overlay, "use_gpencil_grid", text="")
|
|
sub = row.row(align=True)
|
|
sub.active = overlay.use_gpencil_grid
|
|
sub.prop(overlay, "gpencil_grid_opacity", text="Canvas", slider=True)
|
|
sub.prop(overlay, "use_gpencil_canvas_xray", text="", icon='XRAY')
|
|
|
|
row = col.row()
|
|
row.prop(overlay, "use_gpencil_fade_layers", text="")
|
|
sub = row.row()
|
|
sub.active = overlay.use_gpencil_fade_layers
|
|
sub.prop(overlay, "gpencil_fade_layer", text="Fade Inactive Layers", slider=True)
|
|
|
|
row = col.row()
|
|
row.prop(overlay, "use_gpencil_fade_objects", text="")
|
|
sub = row.row(align=True)
|
|
sub.active = overlay.use_gpencil_fade_objects
|
|
sub.prop(overlay, "gpencil_fade_objects", text="Fade Inactive Objects", slider=True)
|
|
sub.prop(overlay, "use_gpencil_fade_gp_objects", text="", icon='OUTLINER_OB_GREASEPENCIL')
|
|
|
|
if context.object.mode in {'EDIT_GPENCIL', 'SCULPT_GPENCIL', 'WEIGHT_GPENCIL', 'VERTEX_GPENCIL'}:
|
|
split = layout.split()
|
|
col = split.column()
|
|
col.prop(overlay, "use_gpencil_edit_lines", text="Edit Lines")
|
|
col = split.column()
|
|
col.prop(overlay, "use_gpencil_multiedit_line_only", text="Only in Multiframe")
|
|
|
|
if context.object.mode == 'EDIT_GPENCIL':
|
|
gpd = context.object.data
|
|
split = layout.split()
|
|
col = split.column()
|
|
col.prop(overlay, "use_gpencil_show_directions")
|
|
col = split.column()
|
|
col.prop(overlay, "use_gpencil_show_material_name", text="Material Name")
|
|
|
|
if not gpd.use_curve_edit:
|
|
layout.prop(overlay, "vertex_opacity", text="Vertex Opacity", slider=True)
|
|
else:
|
|
# Handles for Curve Edit
|
|
layout.prop(overlay, "display_handle", text="Handles")
|
|
|
|
if context.object.mode == 'SCULPT_GPENCIL':
|
|
layout.prop(overlay, "vertex_opacity", text="Vertex Opacity", slider=True)
|
|
|
|
if context.object.mode in {'PAINT_GPENCIL', 'VERTEX_GPENCIL'}:
|
|
layout.label(text="Vertex Paint")
|
|
row = layout.row()
|
|
shading = VIEW3D_PT_shading.get_shading(context)
|
|
row.enabled = shading.type not in {'WIREFRAME', 'RENDERED'}
|
|
row.prop(overlay, "gpencil_vertex_paint_opacity", text="Opacity", slider=True)
|
|
|
|
|
|
class VIEW3D_PT_quad_view(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "Quad View"
|
|
bl_options = {'DEFAULT_CLOSED'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
view = context.space_data
|
|
return view.region_quadviews
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
view = context.space_data
|
|
|
|
region = view.region_quadviews[2]
|
|
col = layout.column()
|
|
col.prop(region, "lock_rotation")
|
|
row = col.row()
|
|
row.enabled = region.lock_rotation
|
|
row.prop(region, "show_sync_view")
|
|
row = col.row()
|
|
row.enabled = region.lock_rotation and region.show_sync_view
|
|
row.prop(region, "use_box_clip")
|
|
|
|
|
|
# Annotation properties
|
|
class VIEW3D_PT_grease_pencil(AnnotationDataPanel, Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
|
|
# NOTE: this is just a wrapper around the generic GP Panel
|
|
class VIEW3D_PT_annotation_onion(AnnotationOnionSkin, Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_parent_id = 'VIEW3D_PT_grease_pencil'
|
|
|
|
# NOTE: this is just a wrapper around the generic GP Panel
|
|
class TOPBAR_PT_annotation_layers(Panel, AnnotationDataPanel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Layers"
|
|
bl_ui_units_x = 14
|
|
|
|
|
|
class VIEW3D_PT_view3d_stereo(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "View"
|
|
bl_label = "Stereoscopy"
|
|
bl_options = {'DEFAULT_CLOSED'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
scene = context.scene
|
|
|
|
multiview = scene.render.use_multiview
|
|
return multiview
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
|
|
basic_stereo = context.scene.render.views_format == 'STEREO_3D'
|
|
|
|
col = layout.column()
|
|
col.row().prop(view, "stereo_3d_camera", expand=True)
|
|
|
|
col.label(text="Display")
|
|
row = col.row()
|
|
row.active = basic_stereo
|
|
row.prop(view, "show_stereo_3d_cameras")
|
|
row = col.row()
|
|
row.active = basic_stereo
|
|
split = row.split()
|
|
split.prop(view, "show_stereo_3d_convergence_plane")
|
|
split = row.split()
|
|
split.prop(view, "stereo_3d_convergence_plane_alpha", text="Alpha")
|
|
split.active = view.show_stereo_3d_convergence_plane
|
|
row = col.row()
|
|
split = row.split()
|
|
split.prop(view, "show_stereo_3d_volume")
|
|
split = row.split()
|
|
split.active = view.show_stereo_3d_volume
|
|
split.prop(view, "stereo_3d_volume_alpha", text="Alpha")
|
|
|
|
|
|
class VIEW3D_PT_context_properties(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_category = "Item"
|
|
bl_label = "Properties"
|
|
bl_options = {'DEFAULT_CLOSED'}
|
|
|
|
@staticmethod
|
|
def _active_context_member(context):
|
|
obj = context.object
|
|
if obj:
|
|
object_mode = obj.mode
|
|
if object_mode == 'POSE':
|
|
return "active_pose_bone"
|
|
elif object_mode == 'EDIT' and obj.type == 'ARMATURE':
|
|
return "active_bone"
|
|
else:
|
|
return "object"
|
|
|
|
return ""
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
import rna_prop_ui
|
|
member = cls._active_context_member(context)
|
|
|
|
if member:
|
|
context_member, member = rna_prop_ui.rna_idprop_context_value(context, member, object)
|
|
return context_member and rna_prop_ui.rna_idprop_has_properties(context_member)
|
|
|
|
return False
|
|
|
|
def draw(self, context):
|
|
import rna_prop_ui
|
|
member = VIEW3D_PT_context_properties._active_context_member(context)
|
|
|
|
if member:
|
|
# Draw with no edit button
|
|
rna_prop_ui.draw(self.layout, context, member, object, use_edit=False)
|
|
|
|
|
|
# Grease Pencil Object - Multiframe falloff tools
|
|
class VIEW3D_PT_gpencil_multi_frame(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Multi Frame"
|
|
|
|
def draw(self, context):
|
|
gpd = context.gpencil_data
|
|
settings = context.tool_settings.gpencil_sculpt
|
|
|
|
layout = self.layout
|
|
col = layout.column(align=True)
|
|
col.prop(settings, "use_multiframe_falloff")
|
|
|
|
# Falloff curve
|
|
if gpd.use_multiedit and settings.use_multiframe_falloff:
|
|
layout.template_curve_mapping(settings, "multiframe_falloff_curve", brush=True)
|
|
|
|
|
|
# Grease Pencil Object - Curve Editing tools
|
|
class VIEW3D_PT_gpencil_curve_edit(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Curve Editing"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
gpd = context.gpencil_data
|
|
col = layout.column(align=True)
|
|
col.prop(gpd, "edit_curve_resolution")
|
|
col.prop(gpd, "curve_edit_threshold")
|
|
col.prop(gpd, "curve_edit_corner_angle")
|
|
col.prop(gpd, "use_adaptive_curve_resolution")
|
|
|
|
|
|
class VIEW3D_MT_gpencil_edit_context_menu(Menu):
|
|
bl_label = ""
|
|
|
|
def draw(self, context):
|
|
|
|
is_point_mode = context.tool_settings.gpencil_selectmode_edit == 'POINT'
|
|
is_stroke_mode = context.tool_settings.gpencil_selectmode_edit == 'STROKE'
|
|
is_segment_mode = context.tool_settings.gpencil_selectmode_edit == 'SEGMENT'
|
|
|
|
layout = self.layout
|
|
|
|
layout.operator_context = 'INVOKE_REGION_WIN'
|
|
|
|
row = layout.row()
|
|
|
|
if is_point_mode or is_segment_mode:
|
|
col = row.column(align=True)
|
|
|
|
col.label(text="Point Context Menu", icon='GP_SELECT_POINTS')
|
|
col.separator()
|
|
|
|
# Additive Operators
|
|
col.operator("gpencil.stroke_subdivide", text="Subdivide").only_selected = True
|
|
|
|
col.separator()
|
|
|
|
col.operator("gpencil.extrude_move", text="Extrude")
|
|
|
|
col.separator()
|
|
|
|
# Deform Operators
|
|
col.operator("gpencil.stroke_smooth", text="Smooth").only_selected = True
|
|
col.operator("transform.bend", text="Bend")
|
|
col.operator("transform.shear", text="Shear")
|
|
col.operator("transform.tosphere", text="To Sphere")
|
|
col.operator("transform.transform", text="Shrink/Fatten").mode = 'GPENCIL_SHRINKFATTEN'
|
|
col.operator("gpencil.stroke_start_set", text="Set Start Point")
|
|
|
|
col.separator()
|
|
|
|
col.menu("VIEW3D_MT_mirror", text="Mirror")
|
|
col.menu("GPENCIL_MT_snap", text="Snap")
|
|
|
|
col.separator()
|
|
|
|
# Duplicate operators
|
|
col.operator("gpencil.duplicate_move", text="Duplicate")
|
|
col.operator("gpencil.copy", text="Copy", icon='COPYDOWN')
|
|
col.operator("gpencil.paste", text="Paste", icon='PASTEDOWN').type = 'ACTIVE'
|
|
col.operator("gpencil.paste", text="Paste by Layer").type = 'LAYER'
|
|
|
|
col.separator()
|
|
|
|
# Removal Operators
|
|
col.operator("gpencil.stroke_merge", text="Merge")
|
|
col.operator("gpencil.stroke_merge_by_distance").use_unselected = False
|
|
col.operator("gpencil.stroke_split", text="Split")
|
|
col.operator("gpencil.stroke_separate", text="Separate").mode = 'POINT'
|
|
|
|
col.separator()
|
|
|
|
col.operator("gpencil.delete", text="Delete").type = 'POINTS'
|
|
col.operator("gpencil.dissolve", text="Dissolve").type = 'POINTS'
|
|
col.operator("gpencil.dissolve", text="Dissolve Between").type = 'BETWEEN'
|
|
col.operator("gpencil.dissolve", text="Dissolve Unselected").type = 'UNSELECT'
|
|
|
|
if is_stroke_mode:
|
|
|
|
col = row.column(align=True)
|
|
col.label(text="Stroke Context Menu", icon='GP_SELECT_STROKES')
|
|
col.separator()
|
|
|
|
# Main Strokes Operators
|
|
col.operator("gpencil.stroke_subdivide", text="Subdivide").only_selected = False
|
|
col.menu("VIEW3D_MT_gpencil_simplify")
|
|
col.operator("gpencil.stroke_trim", text="Trim")
|
|
|
|
col.separator()
|
|
|
|
col.operator("gpencil.stroke_smooth", text="Smooth").only_selected = False
|
|
col.operator("transform.transform", text="Shrink/Fatten").mode = 'GPENCIL_SHRINKFATTEN'
|
|
|
|
col.separator()
|
|
|
|
# Layer and Materials operators
|
|
col.menu("GPENCIL_MT_move_to_layer")
|
|
col.menu("VIEW3D_MT_assign_material")
|
|
col.operator("gpencil.set_active_material", text="Set as Active Material")
|
|
col.operator_menu_enum("gpencil.stroke_arrange", "direction", text="Arrange")
|
|
|
|
col.separator()
|
|
|
|
col.menu("VIEW3D_MT_mirror", text="Mirror")
|
|
col.menu("VIEW3D_MT_snap", text="Snap")
|
|
|
|
col.separator()
|
|
|
|
# Duplicate operators
|
|
col.operator("gpencil.duplicate_move", text="Duplicate")
|
|
col.operator("gpencil.copy", text="Copy", icon='COPYDOWN')
|
|
col.operator("gpencil.paste", text="Paste", icon='PASTEDOWN').type = 'ACTIVE'
|
|
col.operator("gpencil.paste", text="Paste by Layer").type = 'LAYER'
|
|
|
|
col.separator()
|
|
|
|
# Removal Operators
|
|
col.operator("gpencil.stroke_merge_by_distance").use_unselected = True
|
|
col.operator_menu_enum("gpencil.stroke_join", "type", text="Join")
|
|
col.operator("gpencil.stroke_split", text="Split")
|
|
col.operator("gpencil.stroke_separate", text="Separate").mode = 'STROKE'
|
|
|
|
col.separator()
|
|
|
|
col.operator("gpencil.delete", text="Delete").type = 'STROKES'
|
|
|
|
col.separator()
|
|
|
|
col.operator("gpencil.reproject", text="Reproject")
|
|
|
|
|
|
def draw_gpencil_layer_active(context, layout):
|
|
gpl = context.active_gpencil_layer
|
|
if gpl:
|
|
layout.label(text="Active Layer")
|
|
row = layout.row(align=True)
|
|
row.operator_context = 'EXEC_REGION_WIN'
|
|
row.operator_menu_enum("gpencil.layer_change", "layer", text="", icon='GREASEPENCIL')
|
|
row.prop(gpl, "info", text="")
|
|
row.operator("gpencil.layer_remove", text="", icon='X')
|
|
|
|
|
|
def draw_gpencil_material_active(context, layout):
|
|
ob = context.active_object
|
|
if ob and len(ob.material_slots) > 0 and ob.active_material_index >= 0:
|
|
ma = ob.material_slots[ob.active_material_index].material
|
|
if ma:
|
|
layout.label(text="Active Material")
|
|
row = layout.row(align=True)
|
|
row.operator_context = 'EXEC_REGION_WIN'
|
|
row.operator_menu_enum("gpencil.material_set", "slot", text="", icon='MATERIAL')
|
|
row.prop(ma, "name", text="")
|
|
|
|
|
|
class VIEW3D_PT_gpencil_sculpt_automasking(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Auto-masking"
|
|
bl_ui_units_x = 10
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
tool_settings = context.scene.tool_settings
|
|
layout.label(text="Auto-masking")
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(tool_settings.gpencil_sculpt, "use_automasking_stroke", text="Stroke")
|
|
col.prop(tool_settings.gpencil_sculpt, "use_automasking_layer_stroke", text="Layer")
|
|
col.prop(tool_settings.gpencil_sculpt, "use_automasking_material_stroke", text="Material")
|
|
col.separator()
|
|
col.prop(tool_settings.gpencil_sculpt, "use_automasking_layer_active", text="Active Layer")
|
|
col.prop(tool_settings.gpencil_sculpt, "use_automasking_material_active", text="Active Material")
|
|
|
|
|
|
class VIEW3D_PT_gpencil_sculpt_context_menu(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Sculpt Context Menu"
|
|
bl_ui_units_x = 12
|
|
|
|
def draw(self, context):
|
|
ts = context.tool_settings
|
|
settings = ts.gpencil_sculpt_paint
|
|
brush = settings.brush
|
|
|
|
layout = self.layout
|
|
|
|
layout.prop(brush, "size", slider=True)
|
|
layout.prop(brush, "strength")
|
|
|
|
# Layers
|
|
draw_gpencil_layer_active(context, layout)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_weight_context_menu(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Weight Paint Context Menu"
|
|
bl_ui_units_x = 12
|
|
|
|
def draw(self, context):
|
|
ts = context.tool_settings
|
|
settings = ts.gpencil_weight_paint
|
|
brush = settings.brush
|
|
|
|
layout = self.layout
|
|
|
|
layout.prop(brush, "size", slider=True)
|
|
layout.prop(brush, "strength")
|
|
layout.prop(brush, "weight")
|
|
|
|
# Layers
|
|
draw_gpencil_layer_active(context, layout)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_draw_context_menu(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Draw Context Menu"
|
|
bl_ui_units_x = 12
|
|
|
|
def draw(self, context):
|
|
ts = context.tool_settings
|
|
settings = ts.gpencil_paint
|
|
brush = settings.brush
|
|
gp_settings = brush.gpencil_settings
|
|
|
|
layout = self.layout
|
|
is_pin_vertex = gp_settings.brush_draw_mode == 'VERTEXCOLOR'
|
|
is_vertex = settings.color_mode == 'VERTEXCOLOR' or brush.gpencil_tool == 'TINT' or is_pin_vertex
|
|
|
|
if brush.gpencil_tool not in {'ERASE', 'CUTTER', 'EYEDROPPER'} and is_vertex:
|
|
split = layout.split(factor=0.1)
|
|
split.prop(brush, "color", text="")
|
|
split.template_color_picker(brush, "color", value_slider=True)
|
|
|
|
col = layout.column()
|
|
col.separator()
|
|
col.prop_menu_enum(gp_settings, "vertex_mode", text="Mode")
|
|
col.separator()
|
|
|
|
if brush.gpencil_tool not in {'FILL', 'CUTTER'}:
|
|
layout.prop(brush, "size", slider=True)
|
|
if brush.gpencil_tool not in {'ERASE', 'FILL', 'CUTTER'}:
|
|
layout.prop(gp_settings, "pen_strength")
|
|
|
|
# Layers
|
|
draw_gpencil_layer_active(context, layout)
|
|
# Material
|
|
if not is_vertex:
|
|
draw_gpencil_material_active(context, layout)
|
|
|
|
|
|
class VIEW3D_PT_gpencil_vertex_context_menu(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Vertex Paint Context Menu"
|
|
bl_ui_units_x = 12
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
ts = context.tool_settings
|
|
settings = ts.gpencil_vertex_paint
|
|
brush = settings.brush
|
|
gp_settings = brush.gpencil_settings
|
|
|
|
col = layout.column()
|
|
|
|
if brush.gpencil_vertex_tool in {'DRAW', 'REPLACE'}:
|
|
split = layout.split(factor=0.1)
|
|
split.prop(brush, "color", text="")
|
|
split.template_color_picker(brush, "color", value_slider=True)
|
|
|
|
col = layout.column()
|
|
col.separator()
|
|
col.prop_menu_enum(gp_settings, "vertex_mode", text="Mode")
|
|
col.separator()
|
|
|
|
row = col.row(align=True)
|
|
row.prop(brush, "size", text="Radius")
|
|
row.prop(gp_settings, "use_pressure", text="", icon='STYLUS_PRESSURE')
|
|
|
|
if brush.gpencil_vertex_tool in {'DRAW', 'BLUR', 'SMEAR'}:
|
|
row = layout.row(align=True)
|
|
row.prop(gp_settings, "pen_strength", slider=True)
|
|
row.prop(gp_settings, "use_strength_pressure", text="", icon='STYLUS_PRESSURE')
|
|
|
|
# Layers
|
|
draw_gpencil_layer_active(context, layout)
|
|
|
|
|
|
class VIEW3D_PT_paint_vertex_context_menu(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Vertex Paint Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
brush = context.tool_settings.vertex_paint.brush
|
|
capabilities = brush.vertex_paint_capabilities
|
|
|
|
if capabilities.has_color:
|
|
split = layout.split(factor=0.1)
|
|
UnifiedPaintPanel.prop_unified_color(split, context, brush, "color", text="")
|
|
UnifiedPaintPanel.prop_unified_color_picker(split, context, brush, "color", value_slider=True)
|
|
layout.prop(brush, "blend", text="")
|
|
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"size",
|
|
unified_name="use_unified_size",
|
|
pressure_name="use_pressure_size",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
unified_name="use_unified_strength",
|
|
pressure_name="use_pressure_strength",
|
|
slider=True,)
|
|
|
|
|
|
class VIEW3D_PT_paint_texture_context_menu(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Texture Paint Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
brush = context.tool_settings.image_paint.brush
|
|
capabilities = brush.image_paint_capabilities
|
|
|
|
if capabilities.has_color:
|
|
split = layout.split(factor=0.1)
|
|
UnifiedPaintPanel.prop_unified_color(split, context, brush, "color", text="")
|
|
UnifiedPaintPanel.prop_unified_color_picker(split, context, brush, "color", value_slider=True)
|
|
layout.prop(brush, "blend", text="")
|
|
|
|
if capabilities.has_radius:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"size",
|
|
unified_name="use_unified_size",
|
|
pressure_name="use_pressure_size",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
unified_name="use_unified_strength",
|
|
pressure_name="use_pressure_strength",
|
|
slider=True,)
|
|
|
|
|
|
class VIEW3D_PT_paint_weight_context_menu(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Weights Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
brush = context.tool_settings.weight_paint.brush
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"weight",
|
|
unified_name="use_unified_weight",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"size",
|
|
unified_name="use_unified_size",
|
|
pressure_name="use_pressure_size",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
unified_name="use_unified_strength",
|
|
pressure_name="use_pressure_strength",
|
|
slider=True,)
|
|
|
|
|
|
class VIEW3D_PT_sculpt_automasking(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Auto-Masking"
|
|
bl_ui_units_x = 10
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
tool_settings = context.tool_settings
|
|
sculpt = tool_settings.sculpt
|
|
layout.label(text="Auto-Masking")
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(sculpt, "use_automasking_topology", text="Topology")
|
|
col.prop(sculpt, "use_automasking_face_sets", text="Face Sets")
|
|
|
|
col.separator()
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(sculpt, "use_automasking_boundary_edges", text="Mesh Boundary")
|
|
col.prop(sculpt, "use_automasking_boundary_face_sets", text="Face Sets Boundary")
|
|
|
|
if sculpt.use_automasking_boundary_edges or sculpt.use_automasking_boundary_face_sets:
|
|
col.prop(sculpt.brush, "automasking_boundary_edges_propagation_steps")
|
|
|
|
col.separator()
|
|
|
|
col = layout.column(align=True)
|
|
row = col.row()
|
|
row.prop(sculpt, "use_automasking_cavity", text="Cavity")
|
|
|
|
is_cavity_active = sculpt.use_automasking_cavity or sculpt.use_automasking_cavity_inverted
|
|
|
|
if is_cavity_active:
|
|
props = row.operator("sculpt.mask_from_cavity", text="Create Mask")
|
|
props.settings_source = "SCENE"
|
|
|
|
col.prop(sculpt, "use_automasking_cavity_inverted", text="Cavity (inverted)")
|
|
|
|
if is_cavity_active:
|
|
col = layout.column(align=True)
|
|
col.prop(sculpt, "automasking_cavity_factor", text="Factor")
|
|
col.prop(sculpt, "automasking_cavity_blur_steps", text="Blur")
|
|
|
|
col = layout.column()
|
|
col.prop(sculpt, "use_automasking_custom_cavity_curve", text="Custom Curve")
|
|
|
|
if sculpt.use_automasking_custom_cavity_curve:
|
|
col.template_curve_mapping(sculpt, "automasking_cavity_curve")
|
|
|
|
col.separator()
|
|
|
|
col = layout.column(align=True)
|
|
col.prop(sculpt, "use_automasking_view_normal", text="View Normal")
|
|
|
|
if sculpt.use_automasking_view_normal:
|
|
col.prop(sculpt, "use_automasking_view_occlusion", text="Occlusion")
|
|
subcol = col.column(align=True)
|
|
subcol.active = not sculpt.use_automasking_view_occlusion
|
|
subcol.prop(sculpt, "automasking_view_normal_limit", text="Limit")
|
|
subcol.prop(sculpt, "automasking_view_normal_falloff", text="Falloff")
|
|
|
|
col = layout.column()
|
|
col.prop(sculpt, "use_automasking_start_normal", text="Area Normal")
|
|
|
|
if sculpt.use_automasking_start_normal:
|
|
col = layout.column(align=True)
|
|
col.prop(sculpt, "automasking_start_normal_limit", text="Limit")
|
|
col.prop(sculpt, "automasking_start_normal_falloff", text="Falloff")
|
|
|
|
|
|
class VIEW3D_PT_sculpt_context_menu(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Sculpt Context Menu"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
brush = context.tool_settings.sculpt.brush
|
|
capabilities = brush.sculpt_capabilities
|
|
|
|
channels = []
|
|
colorch = None
|
|
keys = {}
|
|
|
|
# maintain compatibility with old text overrides
|
|
textmap = {"plane_trim": "Distance"}
|
|
|
|
for ch in brush.channels:
|
|
if ch.show_in_context_menu:
|
|
if ch.idname == "color":
|
|
colorch = ch
|
|
else:
|
|
key = ch.ui_order
|
|
|
|
if ch.idname == "blend":
|
|
key = -2
|
|
elif ch.idname == "secondary_color":
|
|
key = -1
|
|
|
|
keys[ch.idname] = key
|
|
channels.append(ch)
|
|
|
|
channels.sort(key=lambda ch: keys[ch.idname])
|
|
|
|
if colorch:
|
|
split = layout.split(factor=0.1)
|
|
UnifiedPaintPanel.prop_unified_color(split, context, brush, "color", text="", show_mappings=False)
|
|
UnifiedPaintPanel.prop_unified_color_picker(split, context, brush, "color", value_slider=True)
|
|
|
|
for ch in channels:
|
|
if ch.idname in textmap:
|
|
UnifiedPaintPanel.channel_unified(layout, context, brush, ch.idname, ui_editing=False, slider=True, show_mappings=False, text=textmap[ch.idname])
|
|
else:
|
|
UnifiedPaintPanel.channel_unified(layout, context, brush, ch.idname, ui_editing=False, slider=True, show_mappings=False)
|
|
|
|
return
|
|
layout.label(text="-----")
|
|
|
|
if capabilities.has_color:
|
|
split = layout.split(factor=0.1)
|
|
UnifiedPaintPanel.prop_unified_color(split, context, brush, "color", text="")
|
|
UnifiedPaintPanel.prop_unified_color_picker(split, context, brush, "color", value_slider=True)
|
|
layout.prop(brush, "blend", text="")
|
|
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
size,
|
|
unified_name="use_unified_size",
|
|
pressure_name="use_pressure_size",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"strength",
|
|
unified_name="use_unified_strength",
|
|
pressure_name="use_pressure_strength",
|
|
slider=True,)
|
|
|
|
if capabilities.has_auto_smooth:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"auto_smooth_factor",
|
|
slider=True,)
|
|
|
|
if capabilities.has_normal_weight:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"normal_weight",
|
|
slider=True,)
|
|
|
|
if capabilities.has_pinch_factor:
|
|
text = "Pinch"
|
|
if brush.sculpt_tool in {'BLOB', 'SNAKE_HOOK'}:
|
|
text = "Magnify"
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"crease_pinch_factor",
|
|
text=text,
|
|
slider=True,)
|
|
|
|
if capabilities.has_rake_factor:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"rake_factor",
|
|
slider=True,)
|
|
|
|
if capabilities.has_plane_offset:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"plane_offset",
|
|
slider=True,)
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"plane_trim",
|
|
slider=True,
|
|
text="Distance")
|
|
|
|
if capabilities.has_height:
|
|
UnifiedPaintPanel.prop_unified(layout,
|
|
context,
|
|
brush,
|
|
"height",
|
|
slider=True,
|
|
text="Height")
|
|
|
|
|
|
class TOPBAR_PT_gpencil_materials(GreasePencilMaterialsPanel, Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Materials"
|
|
bl_ui_units_x = 14
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
ob = context.object
|
|
return ob and ob.type == 'GPENCIL'
|
|
|
|
|
|
class TOPBAR_PT_gpencil_vertexcolor(GreasePencilVertexcolorPanel, Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_label = "Color Attribute"
|
|
bl_ui_units_x = 10
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
ob = context.object
|
|
return ob and ob.type == 'GPENCIL'
|
|
|
|
|
|
class VIEW3D_PT_curves_sculpt_add_shape(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Curves Sculpt Add Curve Options"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.use_property_split = True
|
|
layout.use_property_decorate = False # No animation.
|
|
|
|
settings = UnifiedPaintPanel.paint_settings(context)
|
|
brush = settings.brush
|
|
|
|
col = layout.column(heading="Interpolate", align=True)
|
|
col.prop(brush.curves_sculpt_settings, "interpolate_length", text="Length")
|
|
col.prop(brush.curves_sculpt_settings, "interpolate_shape", text="Shape")
|
|
col.prop(brush.curves_sculpt_settings, "interpolate_point_count", text="Point Count")
|
|
|
|
col = layout.column()
|
|
col.active = not brush.curves_sculpt_settings.interpolate_length
|
|
col.prop(brush.curves_sculpt_settings, "curve_length", text="Length")
|
|
|
|
col = layout.column()
|
|
col.active = not brush.curves_sculpt_settings.interpolate_point_count
|
|
col.prop(brush.curves_sculpt_settings, "points_per_curve", text="Points")
|
|
|
|
|
|
class VIEW3D_PT_curves_sculpt_grow_shrink_scaling(Panel):
|
|
# Only for popover, these are dummy values.
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'WINDOW'
|
|
bl_label = "Curves Grow/Shrink Scaling"
|
|
bl_ui_units_x = 12
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.use_property_split = True
|
|
layout.use_property_decorate = False # No animation.
|
|
|
|
settings = UnifiedPaintPanel.paint_settings(context)
|
|
brush = settings.brush
|
|
|
|
layout.prop(brush.curves_sculpt_settings, "scale_uniform")
|
|
layout.prop(brush.curves_sculpt_settings, "minimum_length")
|
|
|
|
|
|
class VIEW3D_PT_viewport_debug(Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'HEADER'
|
|
bl_parent_id = 'VIEW3D_PT_overlay'
|
|
bl_label = "Viewport Debug"
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
prefs = context.preferences
|
|
return prefs.experimental.use_viewport_debug
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
view = context.space_data
|
|
overlay = view.overlay
|
|
|
|
layout.prop(overlay, "use_debug_freeze_view_culling")
|
|
|
|
|
|
classes = (
|
|
VIEW3D_HT_header,
|
|
VIEW3D_HT_tool_header,
|
|
VIEW3D_MT_editor_menus,
|
|
VIEW3D_MT_transform,
|
|
VIEW3D_MT_transform_object,
|
|
VIEW3D_MT_transform_armature,
|
|
VIEW3D_MT_mirror,
|
|
VIEW3D_MT_snap,
|
|
VIEW3D_MT_uv_map,
|
|
VIEW3D_MT_view,
|
|
VIEW3D_MT_view_local,
|
|
VIEW3D_MT_view_cameras,
|
|
VIEW3D_MT_view_navigation,
|
|
VIEW3D_MT_view_align,
|
|
VIEW3D_MT_view_align_selected,
|
|
VIEW3D_MT_view_viewpoint,
|
|
VIEW3D_MT_view_regions,
|
|
VIEW3D_MT_select_object,
|
|
VIEW3D_MT_select_object_more_less,
|
|
VIEW3D_MT_select_pose,
|
|
VIEW3D_MT_select_pose_more_less,
|
|
VIEW3D_MT_select_particle,
|
|
VIEW3D_MT_edit_mesh,
|
|
VIEW3D_MT_edit_mesh_select_similar,
|
|
VIEW3D_MT_edit_mesh_select_by_trait,
|
|
VIEW3D_MT_edit_mesh_select_more_less,
|
|
VIEW3D_MT_select_edit_mesh,
|
|
VIEW3D_MT_select_edit_curve,
|
|
VIEW3D_MT_select_edit_surface,
|
|
VIEW3D_MT_select_edit_text,
|
|
VIEW3D_MT_select_edit_metaball,
|
|
VIEW3D_MT_edit_lattice_context_menu,
|
|
VIEW3D_MT_select_edit_lattice,
|
|
VIEW3D_MT_select_edit_armature,
|
|
VIEW3D_MT_select_gpencil,
|
|
VIEW3D_MT_select_paint_mask,
|
|
VIEW3D_MT_select_paint_mask_vertex,
|
|
VIEW3D_MT_select_edit_curves,
|
|
VIEW3D_MT_select_sculpt_curves,
|
|
VIEW3D_MT_mesh_add,
|
|
VIEW3D_MT_curve_add,
|
|
VIEW3D_MT_surface_add,
|
|
VIEW3D_MT_edit_metaball_context_menu,
|
|
VIEW3D_MT_metaball_add,
|
|
TOPBAR_MT_edit_curve_add,
|
|
TOPBAR_MT_edit_armature_add,
|
|
VIEW3D_MT_armature_add,
|
|
VIEW3D_MT_light_add,
|
|
VIEW3D_MT_lightprobe_add,
|
|
VIEW3D_MT_camera_add,
|
|
VIEW3D_MT_volume_add,
|
|
VIEW3D_MT_add,
|
|
VIEW3D_MT_image_add,
|
|
VIEW3D_MT_object,
|
|
VIEW3D_MT_object_animation,
|
|
VIEW3D_MT_object_asset,
|
|
VIEW3D_MT_object_rigid_body,
|
|
VIEW3D_MT_object_clear,
|
|
VIEW3D_MT_object_context_menu,
|
|
VIEW3D_MT_object_convert,
|
|
VIEW3D_MT_object_shading,
|
|
VIEW3D_MT_object_apply,
|
|
VIEW3D_MT_object_relations,
|
|
VIEW3D_MT_object_liboverride,
|
|
VIEW3D_MT_object_parent,
|
|
VIEW3D_MT_object_track,
|
|
VIEW3D_MT_object_collection,
|
|
VIEW3D_MT_object_constraints,
|
|
VIEW3D_MT_object_quick_effects,
|
|
VIEW3D_MT_object_showhide,
|
|
VIEW3D_MT_object_cleanup,
|
|
VIEW3D_MT_make_single_user,
|
|
VIEW3D_MT_make_links,
|
|
VIEW3D_MT_brush_paint_modes,
|
|
VIEW3D_MT_paint_vertex,
|
|
VIEW3D_MT_hook,
|
|
VIEW3D_MT_vertex_group,
|
|
VIEW3D_MT_gpencil_vertex_group,
|
|
VIEW3D_MT_paint_weight,
|
|
VIEW3D_MT_paint_weight_lock,
|
|
VIEW3D_MT_sculpt,
|
|
VIEW3D_MT_sculpt_set_pivot,
|
|
VIEW3D_MT_mask,
|
|
VIEW3D_MT_face_sets,
|
|
VIEW3D_MT_face_sets_init,
|
|
VIEW3D_MT_random_mask,
|
|
VIEW3D_MT_particle,
|
|
VIEW3D_MT_particle_context_menu,
|
|
VIEW3D_MT_particle_showhide,
|
|
VIEW3D_MT_pose,
|
|
VIEW3D_MT_pose_transform,
|
|
VIEW3D_MT_pose_slide,
|
|
VIEW3D_MT_pose_propagate,
|
|
VIEW3D_MT_pose_motion,
|
|
VIEW3D_MT_pose_group,
|
|
VIEW3D_MT_pose_ik,
|
|
VIEW3D_MT_pose_constraints,
|
|
VIEW3D_MT_pose_names,
|
|
VIEW3D_MT_pose_showhide,
|
|
VIEW3D_MT_pose_apply,
|
|
VIEW3D_MT_pose_context_menu,
|
|
VIEW3D_MT_bone_options_toggle,
|
|
VIEW3D_MT_bone_options_enable,
|
|
VIEW3D_MT_bone_options_disable,
|
|
VIEW3D_MT_edit_mesh_context_menu,
|
|
VIEW3D_MT_edit_mesh_select_mode,
|
|
VIEW3D_MT_edit_mesh_select_linked,
|
|
VIEW3D_MT_edit_mesh_select_loops,
|
|
VIEW3D_MT_edit_mesh_extrude,
|
|
VIEW3D_MT_edit_mesh_vertices,
|
|
VIEW3D_MT_edit_mesh_edges,
|
|
VIEW3D_MT_edit_mesh_faces,
|
|
VIEW3D_MT_edit_mesh_faces_data,
|
|
VIEW3D_MT_edit_mesh_normals,
|
|
VIEW3D_MT_edit_mesh_normals_select_strength,
|
|
VIEW3D_MT_edit_mesh_normals_set_strength,
|
|
VIEW3D_MT_edit_mesh_normals_average,
|
|
VIEW3D_MT_edit_mesh_shading,
|
|
VIEW3D_MT_edit_mesh_weights,
|
|
VIEW3D_MT_edit_mesh_clean,
|
|
VIEW3D_MT_edit_mesh_delete,
|
|
VIEW3D_MT_edit_mesh_merge,
|
|
VIEW3D_MT_edit_mesh_split,
|
|
VIEW3D_MT_edit_mesh_showhide,
|
|
VIEW3D_MT_paint_gpencil,
|
|
VIEW3D_MT_draw_gpencil,
|
|
VIEW3D_MT_assign_material,
|
|
VIEW3D_MT_edit_gpencil,
|
|
VIEW3D_MT_edit_gpencil_stroke,
|
|
VIEW3D_MT_edit_gpencil_point,
|
|
VIEW3D_MT_edit_gpencil_delete,
|
|
VIEW3D_MT_edit_gpencil_showhide,
|
|
VIEW3D_MT_weight_gpencil,
|
|
VIEW3D_MT_gpencil_animation,
|
|
VIEW3D_MT_gpencil_simplify,
|
|
VIEW3D_MT_gpencil_autoweights,
|
|
VIEW3D_MT_gpencil_edit_context_menu,
|
|
VIEW3D_MT_edit_curve,
|
|
VIEW3D_MT_edit_curve_ctrlpoints,
|
|
VIEW3D_MT_edit_curve_segments,
|
|
VIEW3D_MT_edit_curve_clean,
|
|
VIEW3D_MT_edit_curve_context_menu,
|
|
VIEW3D_MT_edit_curve_delete,
|
|
VIEW3D_MT_edit_curve_showhide,
|
|
VIEW3D_MT_edit_surface,
|
|
VIEW3D_MT_edit_font,
|
|
VIEW3D_MT_edit_font_chars,
|
|
VIEW3D_MT_edit_font_kerning,
|
|
VIEW3D_MT_edit_font_delete,
|
|
VIEW3D_MT_edit_font_context_menu,
|
|
VIEW3D_MT_edit_meta,
|
|
VIEW3D_MT_edit_meta_showhide,
|
|
VIEW3D_MT_edit_lattice,
|
|
VIEW3D_MT_edit_armature,
|
|
VIEW3D_MT_armature_context_menu,
|
|
VIEW3D_MT_edit_armature_parent,
|
|
VIEW3D_MT_edit_armature_roll,
|
|
VIEW3D_MT_edit_armature_names,
|
|
VIEW3D_MT_edit_armature_delete,
|
|
VIEW3D_MT_edit_gpencil_transform,
|
|
VIEW3D_MT_edit_curves,
|
|
VIEW3D_MT_object_mode_pie,
|
|
VIEW3D_MT_view_pie,
|
|
VIEW3D_MT_transform_gizmo_pie,
|
|
VIEW3D_MT_shading_pie,
|
|
VIEW3D_MT_shading_ex_pie,
|
|
VIEW3D_MT_pivot_pie,
|
|
VIEW3D_MT_snap_pie,
|
|
VIEW3D_MT_orientations_pie,
|
|
VIEW3D_MT_proportional_editing_falloff_pie,
|
|
VIEW3D_MT_sculpt_mask_edit_pie,
|
|
VIEW3D_MT_sculpt_automasking_pie,
|
|
VIEW3D_MT_sculpt_gpencil_automasking_pie,
|
|
VIEW3D_MT_wpaint_vgroup_lock_pie,
|
|
VIEW3D_MT_sculpt_face_sets_edit_pie,
|
|
VIEW3D_MT_sculpt_curves,
|
|
VIEW3D_PT_active_tool,
|
|
VIEW3D_PT_active_tool_duplicate,
|
|
VIEW3D_PT_view3d_properties,
|
|
VIEW3D_PT_view3d_lock,
|
|
VIEW3D_PT_view3d_cursor,
|
|
VIEW3D_PT_collections,
|
|
VIEW3D_PT_object_type_visibility,
|
|
VIEW3D_PT_grease_pencil,
|
|
VIEW3D_PT_annotation_onion,
|
|
VIEW3D_PT_gpencil_multi_frame,
|
|
VIEW3D_PT_gpencil_curve_edit,
|
|
VIEW3D_PT_gpencil_sculpt_automasking,
|
|
VIEW3D_PT_quad_view,
|
|
VIEW3D_PT_view3d_stereo,
|
|
VIEW3D_PT_shading,
|
|
VIEW3D_PT_shading_lighting,
|
|
VIEW3D_PT_shading_color,
|
|
VIEW3D_PT_shading_options,
|
|
VIEW3D_PT_shading_options_shadow,
|
|
VIEW3D_PT_shading_options_ssao,
|
|
VIEW3D_PT_shading_render_pass,
|
|
VIEW3D_PT_shading_compositor,
|
|
VIEW3D_PT_gizmo_display,
|
|
VIEW3D_PT_overlay,
|
|
VIEW3D_PT_overlay_guides,
|
|
VIEW3D_PT_overlay_object,
|
|
VIEW3D_PT_overlay_geometry,
|
|
VIEW3D_PT_overlay_motion_tracking,
|
|
VIEW3D_PT_overlay_edit_mesh,
|
|
VIEW3D_PT_overlay_edit_mesh_shading,
|
|
VIEW3D_PT_overlay_edit_mesh_measurement,
|
|
VIEW3D_PT_overlay_edit_mesh_normals,
|
|
VIEW3D_PT_overlay_edit_mesh_freestyle,
|
|
VIEW3D_PT_overlay_edit_curve,
|
|
VIEW3D_PT_overlay_texture_paint,
|
|
VIEW3D_PT_overlay_vertex_paint,
|
|
VIEW3D_PT_overlay_weight_paint,
|
|
VIEW3D_PT_overlay_bones,
|
|
VIEW3D_PT_overlay_sculpt,
|
|
VIEW3D_PT_overlay_sculpt_curves,
|
|
VIEW3D_PT_snapping,
|
|
VIEW3D_PT_proportional_edit,
|
|
VIEW3D_PT_gpencil_origin,
|
|
VIEW3D_PT_gpencil_lock,
|
|
VIEW3D_PT_gpencil_guide,
|
|
VIEW3D_PT_transform_orientations,
|
|
VIEW3D_PT_overlay_gpencil_options,
|
|
VIEW3D_PT_context_properties,
|
|
VIEW3D_PT_paint_vertex_context_menu,
|
|
VIEW3D_PT_paint_texture_context_menu,
|
|
VIEW3D_PT_paint_weight_context_menu,
|
|
VIEW3D_PT_gpencil_vertex_context_menu,
|
|
VIEW3D_PT_gpencil_sculpt_context_menu,
|
|
VIEW3D_PT_gpencil_weight_context_menu,
|
|
VIEW3D_PT_gpencil_draw_context_menu,
|
|
VIEW3D_PT_sculpt_automasking,
|
|
VIEW3D_PT_sculpt_context_menu,
|
|
TOPBAR_PT_gpencil_materials,
|
|
TOPBAR_PT_gpencil_vertexcolor,
|
|
TOPBAR_PT_annotation_layers,
|
|
VIEW3D_PT_curves_sculpt_add_shape,
|
|
VIEW3D_PT_curves_sculpt_grow_shrink_scaling,
|
|
VIEW3D_PT_viewport_debug,
|
|
)
|
|
|
|
|
|
if __name__ == "__main__": # only for live edit.
|
|
from bpy.utils import register_class
|
|
for cls in classes:
|
|
register_class(cls)
|