archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
dbf96e62529cd7978b1035d2a26422e01b51b83b
blender-archive/release/scripts/startup/bl_ui/properties_data_modifier.py
Hans Goudey 9b099c8612 UI: Drag and Drop Modifiers, Layout Updates 
This patch implements the list panel system D7490 for modifiers.
It also moves modifier drawing to a callback in ModifierTypeInfo
in line with the extensible architecture refactoring goal T75724.

This adds a PanelRegister callback and utilities for registering
panels and subpanels. It also adds the callbacks for expansion saving
and drag and drop reordering described in D7490.

These utilities, callbacks, and other common UI elements shared
between modifiers live in MOD_ui_common.c.

Because modifier buttons are now in panels, we can make use of
subpanels for organization. The UI layouts also use the single
column layout style consistently used elsewhere in Blender.
Additionally, the mode-setting buttons are aligned and ordered
consistently with the outliner.

However, the large number of UI changes in this patch may mean
that additional polishing is required in master.

Thanks to William Reynish (@billreynish) who did a fair amount of the
layout work and to Julian Eisel (@Severin) for consistent help.

Differential Revision: https://developer.blender.org/D7498
2020-06-05 10:41:03 -04:00

552 lines
16 KiB
Python
Raw Blame History

# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
import bpy
from bpy.types import Panel
from bpy.app.translations import pgettext_iface as iface_
class ModifierButtonsPanel:
bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW'
bl_context = "modifier"
bl_options = {'HIDE_HEADER'}
class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
bl_label = "Modifiers"
@classmethod
def poll(cls, context):
ob = context.object
return ob and ob.type != 'GPENCIL'
def draw(self, context):
layout = self.layout
layout.operator_menu_enum("object.modifier_add", "type")
layout.template_modifiers()
class DATA_PT_gpencil_modifiers(ModifierButtonsPanel, Panel):
bl_label = "Modifiers"
def check_conflicts(self, layout, ob):
for md in ob.grease_pencil_modifiers:
if md.type == 'GP_TIME':
row = layout.row()
row.label(text="Build and Time Offset modifier not compatible", icon='ERROR')
break
@classmethod
def poll(cls, context):
ob = context.object
return ob and ob.type == 'GPENCIL'
def draw(self, context):
layout = self.layout
ob = context.object
layout.operator_menu_enum("object.gpencil_modifier_add", "type")
for md in ob.grease_pencil_modifiers:
box = layout.template_greasepencil_modifier(md)
if box:
# match enum type to our functions, avoids a lookup table.
getattr(self, md.type)(box, ob, md)
# the mt.type enum is (ab)used for a lookup on function names
# ...to avoid lengthy if statements
# so each type must have a function here.
def gpencil_masking(self, layout, ob, md, use_vertex, use_curve=False):
gpd = ob.data
layout.separator()
layout.label(text="Influence Filters:")
split = layout.split(factor=0.25)
col1 = split.column()
col1.label(text="Layer:")
col1.label(text="Material:")
if use_vertex:
col1.label(text="Vertex Group:")
col2 = split.column()
split = col2.split(factor=0.6)
row = split.row(align=True)
row.prop_search(md, "layer", gpd, "layers", text="", icon='GREASEPENCIL')
row.prop(md, "invert_layers", text="", icon='ARROW_LEFTRIGHT')
row = split.row(align=True)
row.prop(md, "layer_pass", text="Pass")
row.prop(md, "invert_layer_pass", text="", icon='ARROW_LEFTRIGHT')
split = col2.split(factor=0.6)
row = split.row(align=True)
valid = md.material in (slot.material for slot in ob.material_slots) or md.material is None
if valid:
icon = 'SHADING_TEXTURE'
else:
icon = 'ERROR'
row.alert = not valid
row.prop_search(md, "material", gpd, "materials", text="", icon=icon)
row.prop(md, "invert_materials", text="", icon='ARROW_LEFTRIGHT')
row = split.row(align=True)
row.prop(md, "pass_index", text="Pass")
row.prop(md, "invert_material_pass", text="", icon='ARROW_LEFTRIGHT')
if use_vertex:
row = col2.row(align=True)
row.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
row.prop(md, "invert_vertex", text="", icon='ARROW_LEFTRIGHT')
if use_curve:
col = layout.column()
col.separator()
col.prop(md, "use_custom_curve")
if md.use_custom_curve:
col.template_curve_mapping(md, "curve")
def GP_NOISE(self, layout, ob, md):
split = layout.split()
col = split.column()
row = col.row(align=True)
row.prop(md, "factor", text="Position")
row = col.row(align=True)
row.prop(md, "factor_strength", text="Strength")
row = col.row(align=True)
row.prop(md, "factor_thickness", text="Thickness")
row = col.row(align=True)
row.prop(md, "factor_uvs", text="UV")
col.separator()
row = col.row(align=True)
row.prop(md, "random", text="", icon='TIME', toggle=True)
subrow = row.row(align=True)
subrow.enabled = md.random
subrow.prop(md, "step")
subrow.prop(md, "seed")
col.separator()
col.prop(md, "noise_scale")
self.gpencil_masking(layout, ob, md, True, True)
def GP_SMOOTH(self, layout, ob, md):
col = layout.column()
col.prop(md, "factor")
col.prop(md, "step", text="Repeat")
col.label(text="Affect:")
row = col.row(align=True)
row.prop(md, "use_edit_position", text="Position", toggle=True)
row.prop(md, "use_edit_strength", text="Strength", toggle=True)
row.prop(md, "use_edit_thickness", text="Thickness", toggle=True)
row.prop(md, "use_edit_uv", text="UV", toggle=True)
self.gpencil_masking(layout, ob, md, True, True)
def GP_SUBDIV(self, layout, ob, md):
layout.row().prop(md, "subdivision_type", expand=True)
split = layout.split()
col = split.column()
row = col.row(align=True)
row.prop(md, "level", text="Subdivisions")
self.gpencil_masking(layout, ob, md, False)
def GP_SIMPLIFY(self, layout, ob, md):
gpd = ob.data
row = layout.row()
row.prop(md, "mode")
split = layout.split()
col = split.column()
col.label(text="Settings:")
if md.mode == 'FIXED':
col.prop(md, "step")
elif md.mode == 'ADAPTIVE':
col.prop(md, "factor")
elif md.mode == 'SAMPLE':
col.prop(md, "length")
elif md.mode == 'MERGE':
col.prop(md, "distance")
self.gpencil_masking(layout, ob, md, False)
def GP_THICK(self, layout, ob, md):
col = layout.column()
col.prop(md, "normalize_thickness")
if md.normalize_thickness:
col.prop(md, "thickness")
else:
col.prop(md, "thickness_factor")
self.gpencil_masking(layout, ob, md, True, True)
def GP_TEXTURE(self, layout, ob, md):
col = layout.column()
col.prop(md, "mode")
if md.mode in {'STROKE', 'STROKE_AND_FILL'}:
col.label(text="Stroke Texture:")
col.prop(md, "fit_method")
col.prop(md, "uv_offset")
col.prop(md, "uv_scale")
if md.mode == 'STROKE_AND_FILL':
col.separator()
if md.mode in {'FILL', 'STROKE_AND_FILL'}:
col.label(text="Fill Texture:")
col.prop(md, "fill_rotation", text="Rotation")
col.prop(md, "fill_offset", text="Location")
col.prop(md, "fill_scale", text="Scale")
self.gpencil_masking(layout, ob, md, True)
def GP_TINT(self, layout, ob, md):
layout.row().prop(md, "tint_type", expand=True)
if md.tint_type == 'UNIFORM':
col = layout.column()
col.prop(md, "color")
col.separator()
col.prop(md, "factor")
if md.tint_type == 'GRADIENT':
col = layout.column()
col.label(text="Colors:")
col.template_color_ramp(md, "colors")
col.separator()
col.label(text="Object:")
col.prop(md, "object", text="")
col.separator()
row = col.row(align=True)
row.prop(md, "radius")
row.prop(md, "factor")
col.separator()
col.prop(md, "vertex_mode")
self.gpencil_masking(layout, ob, md, True, True)
def GP_TIME(self, layout, ob, md):
gpd = ob.data
row = layout.row()
row.prop(md, "mode", text="Mode")
row = layout.row()
if md.mode == 'FIX':
txt = "Frame"
else:
txt = "Frame Offset"
row.prop(md, "offset", text=txt)
row = layout.row()
row.enabled = md.mode != 'FIX'
row.prop(md, "frame_scale")
row = layout.row()
row.separator()
row = layout.row()
row.enabled = md.mode != 'FIX'
row.prop(md, "use_custom_frame_range")
row = layout.row(align=True)
row.enabled = md.mode != 'FIX' and md.use_custom_frame_range is True
row.prop(md, "frame_start")
row.prop(md, "frame_end")
row = layout.row()
row.enabled = md.mode != 'FIX'
row.prop(md, "use_keep_loop")
row = layout.row()
row.label(text="Layer:")
row = layout.row(align=True)
row.prop_search(md, "layer", gpd, "layers", text="", icon='GREASEPENCIL')
row.prop(md, "invert_layers", text="", icon='ARROW_LEFTRIGHT')
row = layout.row(align=True)
row.prop(md, "layer_pass", text="Pass")
row.prop(md, "invert_layer_pass", text="", icon='ARROW_LEFTRIGHT')
def GP_COLOR(self, layout, ob, md):
split = layout.split()
col = split.column()
col.label(text="Color:")
col.prop(md, "hue", text="H", slider=True)
col.prop(md, "saturation", text="S", slider=True)
col.prop(md, "value", text="V", slider=True)
row = layout.row()
row.prop(md, "modify_color")
self.gpencil_masking(layout, ob, md, False, True)
def GP_OPACITY(self, layout, ob, md):
split = layout.split()
col = split.column()
col.prop(md, "modify_color")
if md.modify_color == 'HARDNESS':
col.prop(md, "hardness")
show = False
else:
col.prop(md, "normalize_opacity")
if md.normalize_opacity is True:
text="Strength"
else:
text="Opacity Factor"
col.prop(md, "factor", text=text)
show = True
self.gpencil_masking(layout, ob, md, show, show)
def GP_ARRAY(self, layout, ob, md):
col = layout.column()
col.prop(md, "count")
split = layout.split()
col = split.column()
col.prop(md, "use_constant_offset", text="Constant Offset")
subcol = col.column()
subcol.enabled = md.use_constant_offset
subcol.prop(md, "constant_offset", text="")
col.prop(md, "use_object_offset")
subcol = col.column()
subcol.enabled = md.use_object_offset
subcol.prop(md, "offset_object", text="")
col = split.column()
col.prop(md, "use_relative_offset", text="Relative Offset")
subcol = col.column()
subcol.enabled = md.use_relative_offset
subcol.prop(md, "relative_offset", text="")
split = layout.split()
col = split.column()
col.label(text="Random Offset:")
col.prop(md, "random_offset", text="")
col = split.column()
col.label(text="Random Rotation:")
col.prop(md, "random_rotation", text="")
col = split.column()
col.label(text="Random Scale:")
col.prop(md, "random_scale", text="")
col = layout.column()
col.prop(md, "seed")
col.separator()
col.prop(md, "replace_material", text="Material Override")
self.gpencil_masking(layout, ob, md, False)
def GP_BUILD(self, layout, ob, md):
gpd = ob.data
split = layout.split()
col = split.column()
self.check_conflicts(col, ob)
col.prop(md, "mode")
if md.mode == 'CONCURRENT':
col.prop(md, "concurrent_time_alignment")
col.separator()
col.prop(md, "transition")
sub = col.column(align=True)
sub.prop(md, "start_delay")
sub.prop(md, "length")
col = layout.column(align=True)
col.prop(md, "use_restrict_frame_range")
sub = col.column(align=True)
sub.active = md.use_restrict_frame_range
sub.prop(md, "frame_start", text="Start")
sub.prop(md, "frame_end", text="End")
col.prop(md, "use_percentage")
sub = col.column(align=True)
sub.active = md.use_percentage
sub.prop(md, "percentage_factor")
layout.label(text="Influence Filters:")
split = layout.split(factor=0.25)
col1 = split.column()
col1.label(text="Layer:")
col2 = split.column()
split = col2.split(factor=0.6)
row = split.row(align=True)
row.prop_search(md, "layer", gpd, "layers", text="", icon='GREASEPENCIL')
row.prop(md, "invert_layers", text="", icon='ARROW_LEFTRIGHT')
row = split.row(align=True)
row.prop(md, "layer_pass", text="Pass")
row.prop(md, "invert_layer_pass", text="", icon='ARROW_LEFTRIGHT')
def GP_LATTICE(self, layout, ob, md):
split = layout.split()
col = split.column()
col.label(text="Object:")
col.prop(md, "object", text="")
layout.prop(md, "strength", slider=True)
self.gpencil_masking(layout, ob, md, True)
def GP_MIRROR(self, layout, ob, md):
row = layout.row(align=True)
row.prop(md, "x_axis")
row.prop(md, "y_axis")
row.prop(md, "z_axis")
layout.label(text="Mirror Object:")
layout.prop(md, "object", text="")
self.gpencil_masking(layout, ob, md, False)
def GP_HOOK(self, layout, ob, md):
split = layout.split()
col = split.column()
col.label(text="Object:")
col.prop(md, "object", text="")
if md.object and md.object.type == 'ARMATURE':
col.label(text="Bone:")
col.prop_search(md, "subtarget", md.object.data, "bones", text="")
use_falloff = (md.falloff_type != 'NONE')
layout.separator()
row = layout.row(align=True)
if use_falloff:
row.prop(md, "falloff_radius")
row.prop(md, "strength", slider=True)
layout.prop(md, "falloff_type")
col = layout.column()
if use_falloff:
if md.falloff_type == 'CURVE':
col.template_curve_mapping(md, "falloff_curve")
split = layout.split()
col = split.column()
col.prop(md, "use_falloff_uniform")
self.gpencil_masking(layout, ob, md, True)
def GP_OFFSET(self, layout, ob, md):
split = layout.split()
split.column().prop(md, "location")
split.column().prop(md, "rotation")
split.column().prop(md, "scale")
self.gpencil_masking(layout, ob, md, True)
def GP_ARMATURE(self, layout, ob, md):
split = layout.split()
col = split.column()
col.label(text="Object:")
col.prop(md, "object", text="")
# col.prop(md, "use_deform_preserve_volume")
col = split.column()
col.label(text="Bind To:")
col.prop(md, "use_vertex_groups", text="Vertex Groups")
col.prop(md, "use_bone_envelopes", text="Bone Envelopes")
layout.separator()
row = layout.row(align=True)
row.label(text="Vertex Group:")
row = layout.row(align=True)
row.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
sub = row.row(align=True)
sub.active = bool(md.vertex_group)
sub.prop(md, "invert_vertex_group", text="", icon='ARROW_LEFTRIGHT')
def GP_MULTIPLY(self, layout, ob, md):
col = layout.column()
col.prop(md, "duplicates")
subcol = col.column()
subcol.enabled = md.duplicates > 0
subcol.prop(md, "distance")
subcol.prop(md, "offset", slider=True)
subcol.separator()
subcol.prop(md, "use_fade")
if md.use_fade:
subcol.prop(md, "fading_center")
subcol.prop(md, "fading_thickness", slider=True)
subcol.prop(md, "fading_opacity", slider=True)
self.gpencil_masking(layout, ob, md, False)
classes = (
DATA_PT_modifiers,
DATA_PT_gpencil_modifiers,
)
if __name__ == "__main__": # only for live edit.
from bpy.utils import register_class
for cls in classes:
register_class(cls)
View Git Blame Copy Permalink