autour_de_minuit
/
rig_picker
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: autour_de_minuit:master
Branches Tags
autour_de_minuit:master
autour_de_minuit:Gizmo
autour_de_minuit:blender3.6
..
compare: autour_de_minuit:blender3.6
Branches Tags
autour_de_minuit:master
autour_de_minuit:Gizmo
autour_de_minuit:blender3.6

No commits in common. "master" and "blender3.6" have entirely different histories.
master ... blender3.6

19 changed files with 866 additions and 1526 deletions
Show Stats Expand all files Collapse all files

7
README.md
View File

@ -2,8 +2,6 @@
> Blender addon for picking rig contollers > Blender addon for picking rig contollers
Rig_picker is an OpenGl tool for having a 2d interface for the 3d animators allowing them to pick a controller easily. Rig_picker is an OpenGl tool for having a 2d interface for the 3d animators allowing them to pick a controller easily.
The addon is drawing 2d shapes inside a dedicated Node Editor Area using the gpu module.
You can use multiple pickers for one rig, each picker shapes are in there own collection.
Video of the previous version : https://vimeo.com/241970235 Video of the previous version : https://vimeo.com/241970235
@ -25,12 +23,7 @@ Video of the previous version : https://vimeo.com/241970235
<!-- INSTALLATION --> <!-- INSTALLATION -->
## Installation ## Installation
For external user, you can clone the repository using:
```sh
git clone https://git.autourdeminuit.com/autour_de_minuit/rig_picker.git
```
For Internal user:
1. Create your own local directory in 1. Create your own local directory in
```sh ```sh
/home/<USER>/dev /home/<USER>/dev

2
__init__.py
View File

@ -15,7 +15,7 @@ import importlib
modules = ( modules = (
'.operators', '.operators',
'.properties', '.properties',
'.ui', '.panels',
'.area', '.area',
'.gizmo', '.gizmo',
'.draw_handlers' '.draw_handlers'

102
area.py
View File

@ -1,6 +1,5 @@
import bpy import bpy
from bpy.types import NodeTree, NODE_PT_tools_active, NODE_HT_header, Menu from bpy.types import NodeTree, NODE_PT_tools_active, NODE_HT_header
from .constants import PICKERS
# Derived from the NodeTree base type, similar to Menu, Operator, Panel, etc. # Derived from the NodeTree base type, similar to Menu, Operator, Panel, etc.
@ -14,78 +13,17 @@ class RigPickerTree(NodeTree):
bl_icon = 'OUTLINER_DATA_ARMATURE' bl_icon = 'OUTLINER_DATA_ARMATURE'
class RP_MT_picker(Menu):
"""Picker"""
bl_label = "Picker"
def draw(self, context):
layout = self.layout
scn = context.scene
layout.operator('rigpicker.reload_picker', icon='FILE_REFRESH')
row = layout.row(align=True)
# Has at least one picker collection in the scene
if not [c.rig_picker.enabled for c in scn.collection.children_recursive]:
row.enabled = False
row.prop(scn.rig_picker, 'use_pick_bone', text='Auto Bone Assign')
class RP_MT_animation(Menu):
"""Picker"""
bl_label = "Animation"
def draw(self, context):
layout = self.layout
layout.operator("rigpicker.toogle_bone_layer", icon="MOUSE_LMB_DRAG")
row = layout.row()
op = row.operator("node.context_menu_picker", icon="MOUSE_RMB")
if not context.active_pose_bone:
row.enabled = False
layout.separator()
op = layout.operator("rigpicker.call_operator", text='Select All')
op.operator = "pose.select_all"
op.arguments = '{"action": "SELECT"}'
op = layout.operator("rigpicker.call_operator", text='Select All')
op.operator = "pose.select_all"
op.arguments = '{"action": "DESELECT"}'
op = layout.operator("rigpicker.call_operator", text='Frame Selected')
op.operator = "view3d.view_selected"
op.view_3d = True
layout.separator()
layout.operator("rigpicker.call_operator", text='Insert Keyframe').operator="animtoolbox.insert_keyframe"
layout.operator("anim.keyframe_delete_v3d", text='Delete Keyframe')
layout.separator()
op = layout.operator("rigpicker.call_operator", text='Move')
op.operator="transform.translate"
op.invoke = True
op.view_3d = True
layout.operator("node.picker_transform", text='Rotate').mode='ROTATE'
layout.operator("node.picker_transform", text='Scale').mode='SCALE'
layout.separator()
layout.operator("rigpicker.call_operator", text='Reset Bone').operator="animtoolbox.reset_bone"
layout.operator("rigpicker.call_operator", text='Clear Location').operator='pose.loc_clear'
layout.operator("rigpicker.call_operator", text='Clear Rotation').operator='pose.rot_clear'
layout.operator("rigpicker.call_operator", text='Clear Scale').operator='pose.scale_clear'
def draw_header(self, context): def draw_header(self, context):
if not context.space_data.tree_type == 'RigPickerTree': if context.space_data.tree_type == 'RigPickerTree':
self._draw(context)
return
scn = context.scene
layout = self.layout layout = self.layout
layout.template_header() layout.template_header()
#layout.separator_spacer()
if not context.space_data.node_tree: if not context.space_data.node_tree:
ntree = bpy.data.node_groups.get('.rig_picker') ntree = bpy.data.node_groups.get('.rig_picker')
@ -94,36 +32,17 @@ def draw_header(self, context):
context.space_data.node_tree = ntree context.space_data.node_tree = ntree
row = layout.row(align=True) #layout.template_ID(context.space_data, "node_tree", new="node.new_node_tree")
row.menu("RP_MT_picker") #layout.separator_spacer()
row.menu("RP_MT_animation")
ob = context.object layout.operator('rigpicker.reload_picker', icon='FILE_REFRESH', text='')
if not ob or not ob.type == 'ARMATURE':
return
picker_group = PICKERS.get(ob) #layout.prop('rigpicker.reload_picker', icon='FILE_REFRESH', text='')
if not picker_group:
return
if scn.rig_picker.use_pick_bone:
layout.alert = True
layout.label(text='Auto Bone Assign')
layout.prop(scn.rig_picker, 'use_pick_bone', icon='PANEL_CLOSE', text='', emboss=False)
layout.separator_spacer() layout.separator_spacer()
row = layout.row()
row.enabled = False
row.label(text=ob.name)
layout.separator_spacer()
row = layout.row(align=True)
for i, picker in enumerate(picker_group.pickers):
row.operator('rigpicker.fit_picker', text=f'{i+1}').index=i
row.operator('rigpicker.fit_picker', text='', icon='FULLSCREEN_ENTER').index = -1
else:
self._draw(context)
def tools_from_context(context, mode=None): def tools_from_context(context, mode=None):
sp = context.space_data sp = context.space_data
@ -149,13 +68,10 @@ def poll(cls, context):
classes = ( classes = (
RigPickerTree, RigPickerTree,
RP_MT_picker,
RP_MT_animation
) )
def register(): def register():
# Remove the tools inside the picker space
bpy.types.WM_OT_tool_set_by_id._execute = bpy.types.WM_OT_tool_set_by_id.execute #tool_set_by_id bpy.types.WM_OT_tool_set_by_id._execute = bpy.types.WM_OT_tool_set_by_id.execute #tool_set_by_id
bpy.types.WM_OT_tool_set_by_id.execute = tool_set_by_id bpy.types.WM_OT_tool_set_by_id.execute = tool_set_by_id

27
constants.py
View File

@ -1,29 +1,2 @@
import gpu
from pathlib import Path
class LazyDict(dict):
def __getitem__(self, k):
v = super().__getitem__(k)
if callable(v):
v = v()
super().__setitem__(k, v)
return v
def get(self, k, default=None):
if k in self:
return self.__getitem__(k)
return default
PICKERS = {} PICKERS = {}
MODULE_DIR = Path(__file__).parent
SHADER_DIR = MODULE_DIR / 'shaders'
SHADERS = LazyDict()
vertex_shader = Path(SHADER_DIR, "dash_shader.vert").read_text(encoding='utf-8')
fragment_shader = Path(SHADER_DIR, "dash_shader.frag").read_text(encoding='utf-8')
SHADERS['dashed_line'] = lambda : gpu.types.GPUShader(vertex_shader, fragment_shader)

19
core/addon_utils.py
View File

@ -1,21 +1,6 @@
import bpy import bpy
from .bl_utils import get_mat, get_collection_parents from .bl_utils import get_mat
def get_picker_collection(ob=None):
"""Return the picker collection of an object"""
if not ob:
ob = bpy.context.object
for col in ob.users_collection:
if col.rig_picker.enabled:
return col
if picker_col := next((c for c in get_collection_parents(col) if c.rig_picker.enabled), None):
return picker_col
def is_shape(ob): def is_shape(ob):
scn = bpy.context.scene scn = bpy.context.scene
@ -30,7 +15,6 @@ def is_shape(ob):
return False return False
def get_object_color(ob): def get_object_color(ob):
if not ob.data.materials: if not ob.data.materials:
return return
@ -45,7 +29,6 @@ def get_object_color(ob):
return emit_node.inputs['Color'].default_value return emit_node.inputs['Color'].default_value
def get_operator_from_id(idname): def get_operator_from_id(idname):
if not '.' in idname: if not '.' in idname:
return return

84
core/bl_utils.py
View File

@ -2,34 +2,6 @@
import bpy import bpy
def get_collection_parents(col, root=None, cols=None):
"""Return all direct collection parents
Args:
col (bpy.types.Collection): collection to get parents from
root (bpy.types.Collection, optional): collection to search in (recursive) instead of the scene collection.
Defaults to None.
cols (_type_, optional): for recursivity, store the parent collections.
Defaults to None.
Returns:
list[bpy.types.Collection]: a list of direct parents
"""
if cols is None:
cols = []
if root is None:
root = bpy.context.scene.collection
for sub in root.children:
if sub == col:
cols.append(root)
if len(sub.children):
cols = get_collection_parents(col, root=sub, cols=cols)
return cols
def get_view_3d_override(): def get_view_3d_override():
windows = bpy.context.window_manager.windows windows = bpy.context.window_manager.windows
areas = [a for w in windows for a in w.screen.areas if a.type == 'VIEW_3D'] areas = [a for w in windows for a in w.screen.areas if a.type == 'VIEW_3D']
@ -59,34 +31,40 @@ def link_mat_to_object(ob):
sl.link = 'OBJECT' sl.link = 'OBJECT'
sl.material = m sl.material = m
def eval_attr(ob, name): def find_mirror(name):
resolved = ob mirror = None
for o in name.split("."): prop= False
resolved = getattr(resolved, o)
return resolved
def flip_name(name): if name:
if not name:
return if name.startswith('[')and name.endswith(']'):
prop = True
name= name[:-2][2:]
match={
'R': 'L',
'r': 'l',
'L': 'R',
'l': 'r',
}
separator=['.','_']
if name.startswith(tuple(match.keys())):
if name[1] in separator:
mirror = match[name[0]]+name[1:]
if name.endswith(tuple(match.keys())):
if name[-2] in separator:
mirror = name[:-1]+match[name[-1]]
if mirror and prop == True:
mirror='["%s"]'%mirror
return mirror
if name.startswith('[') and name.endswith(']'): #It's a custom property
flipped_name = bpy.utils.flip_name(name[:-2][2:])
return f'["{flipped_name}"]'
else: else:
return bpy.utils.flip_name(name) return None
def split_path(path) :
try :
bone_name = path.split('["')[1].split('"]')[0]
except Exception:
bone_name = None
try :
prop_name = path.split('["')[2].split('"]')[0]
except Exception:
prop_name = None
return bone_name, prop_name
def hide_layers(args): def hide_layers(args):
""" """ """ """

18
core/geometry_utils.py
View File

@ -21,25 +21,15 @@ def bound_box_center(ob):
return (sum(x) / len(points), sum(y) / len(points),sum(z) / len(points)) return (sum(x) / len(points), sum(y) / len(points),sum(z) / len(points))
def bounding_rect(points):
x_points = sorted(p[0] for p in points)
y_points = sorted(p[1] for p in points)
return [ def intersect_rectangles(bound, border): # returns None if rectangles don't intersect
Vector((x_points[0], y_points[-1])), dx = min(border[1][0],bound[1][0]) - max(border[0][0],bound[0][0])
Vector((x_points[-1], y_points[-1])), dy = min(border[0][1],bound[0][1]) - max(border[2][1],bound[2][1])
Vector((x_points[-1], y_points[0])),
Vector((x_points[0], y_points[0])),
]
def intersect_rects(rect, border): # returns None if rectangles don't intersect
dx = min(border[1][0],rect[1][0]) - max(border[0][0],rect[0][0])
dy = min(border[0][1],rect[0][1]) - max(border[2][1],rect[2][1])
if (dx>=0) and (dy>=0): if (dx>=0) and (dy>=0):
return dx*dy return dx*dy
def point_inside_rect(point, rect): def point_inside_rectangle(point, rect):
return rect[0][0]< point[0]< rect[1][0] and rect[2][1]< point[1]< rect[0][1] return rect[0][0]< point[0]< rect[1][0] and rect[2][1]< point[1]< rect[0][1]
def point_over_shape(point,verts,loops,outside_point=(-1,-1)): def point_over_shape(point,verts,loops,outside_point=(-1,-1)):

569
core/picker.py
View File

@ -3,12 +3,10 @@ import bpy
import gpu import gpu
from gpu_extras.batch import batch_for_shader from gpu_extras.batch import batch_for_shader
import blf import blf
from mathutils import bvhtree, Vector, Color from mathutils import bvhtree, Vector
from mathutils.geometry import (intersect_point_quad_2d, intersect_point_tri_2d, from mathutils.geometry import intersect_point_quad_2d, intersect_point_tri_2d, intersect_tri_tri_2d
intersect_tri_tri_2d)
from ..constants import PICKERS from ..constants import PICKERS
from .addon_utils import get_operator_from_id from .addon_utils import get_operator_from_id
from .geometry_utils import bounding_rect
from pathlib import Path from pathlib import Path
import re import re
@ -18,6 +16,7 @@ import os
import threading import threading
class Shape: class Shape:
def __init__(self, picker, points, polygons=None, edges=None, tooltip='', color=None, source_name=''): def __init__(self, picker, points, polygons=None, edges=None, tooltip='', color=None, source_name=''):
@ -29,37 +28,47 @@ class Shape:
self.hover = False self.hover = False
self.press = False self.press = False
self.shader = gpu.shader.from_builtin('UNIFORM_COLOR')
self.shader.bind()
#self.hover_shader = gpu.shader.from_builtin('UNIFORM_COLOR') self.shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
#self.hover_shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
#self.hover_shader.uniform_float("color", [1, 1, 1, 0.1]) #self.hover_shader.uniform_float("color", [1, 1, 1, 0.1])
self.hover_color = [1, 1, 1, 0.1]
self.color = color
self.hover_color = self.brighten_color(self.color)
self.tooltip = tooltip self.tooltip = tooltip
self.color = color
self.points = points self.points = points
self.polygons = polygons or [] self.polygons = polygons or []
self.edges = edges or [] self.edges = edges or []
#print(points, self.polygons)
self.p_batch = batch_for_shader(self.shader, 'TRIS', {"pos": self.points}, indices=self.polygons) self.p_batch = batch_for_shader(self.shader, 'TRIS', {"pos": self.points}, indices=self.polygons)
self.e_batch = batch_for_shader(self.shader, 'LINES', {"pos": self.points}, indices=self.edges) self.e_batch = batch_for_shader(self.shader, 'LINES', {"pos": self.points}, indices=self.edges)
self.rect = bounding_rect(points) #if polygons:
# self.batch = batch_for_shader(self.shader, 'TRIS', {"pos": points}, indices=polygons)
#else:
#pts = []
#for loop in self.edges:
# pts += [self.points[i] for i in loop]
# self.batch = batch_for_shader(self.shader, 'LINES', {"pos": points}, indices=indices)
points_x = [v[0] for v in points]
points_y = [v[1] for v in points]
self.bound = [
(min(points_x), max(points_y)),
(max(points_x), max(points_y)),
(max(points_x), min(points_y)),
(min(points_x), min(points_y))
]
@property @property
def color(self): def color(self):
return self._color return self._color
def brighten_color(self, color):
brighten_color = Color(color[:3])
brighten_color.v += 0.05
brighten_color.v *= 1.1
brighten_color.v = max(brighten_color.v, 0.15)
return [*brighten_color, color[3]]
@color.setter @color.setter
def color(self, color=None): def color(self, color=None):
if not color: if not color:
@ -79,17 +88,16 @@ class Shape:
def draw(self): def draw(self):
#self.shader.bind() self.shader.bind()
self.shader.uniform_float("color", self.color) self.shader.uniform_float("color", self.color)
if self.polygons: if self.polygons:
self.p_batch.draw(self.shader) self.p_batch.draw(self.shader)
if self.edges: if self.edges:
self.e_batch.draw(self.shader) self.e_batch.draw(self.shader)
def move_event(self, location): def move_event(self, location):
if not intersect_point_quad_2d(location, *self.rect): if not intersect_point_quad_2d(location, *self.bound):
self.hover = False self.hover = False
return False return False
@ -116,9 +124,33 @@ class BoneShape(Shape):
self.type = 'bone' self.type = 'bone'
self.bone = bone self.bone = bone
self.active_color = [1, 1, 1, 0.1] self.active_color = [1, 1, 1, 0.1]
self.select_color = self.brighten_color(self.hover_color) #self.contour_shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
self.bone_colors = self.get_bone_colors() #self.contour_batches = []
#self.line_batch =
#for loop in edges:
# loop_points = [points[i] for i in loop]
# batch = batch_for_shader(self.shader, 'LINE_LOOP', {"pos": loop_points})
# #self.contour_batches.append(batch)
theme = bpy.context.preferences.themes['Default']
self.bone_colors = {
'select': [*theme.view_3d.bone_pose, 1],
'normal': [0.05, 0.05, 0.05, 1],
'active': [*theme.view_3d.bone_pose_active, 1],
'hide': [0.85, 0.85, 0.85, 0.2],
}
if bone and bone.bone_group:
normal_color = bone.bone_group.colors.normal.copy()
normal_color.s *= 0.75
self.bone_colors['normal'] = [*normal_color, 1]
self.bone_colors['select'] = [*bone.bone_group.colors.select, 1]
self.bone_colors['active'] = [*bone.bone_group.colors.active, 1]
self.bone_colors['hide'] = [*normal_color, 0.1]
#self.color = [i for i in self.color]
@property @property
def select(self): def select(self):
@ -140,14 +172,20 @@ class BoneShape(Shape):
return False return False
#return self.bone not in (bpy.context.visible_pose_bones or []) #return self.bone not in (bpy.context.visible_pose_bones or [])
bl = [i for i, l in enumerate(self.bone.bone.layers) if l]
return self.bone.bone.hide or not any(l.is_visible for l in self.bone.bone.collections) rl = [i for i, l in enumerate(self.rig.data.layers) if l]
return self.bone.bone.hide or not len(set(bl).intersection(rl))
@property @property
def bone_color(self): def bone_color(self):
if not self.bone: if not self.bone:
return [0, 0, 0, 1] return [0, 0, 0, 1]
bone = self.bone.bone
bl = bone.layers
rl = self.rig.data.layers
if self.select and self.active: if self.select and self.active:
return self.bone_colors['active'] return self.bone_colors['active']
elif self.select: elif self.select:
@ -157,110 +195,58 @@ class BoneShape(Shape):
else: else:
return self.bone_colors['normal'] return self.bone_colors['normal']
def get_bone_colors(self):
theme = bpy.context.preferences.themes['Default']
bone_colors = {
'select': [*theme.view_3d.bone_pose, 1],
'normal': [0.05, 0.05, 0.05, 1],
'active': [*theme.view_3d.bone_pose_active, 1],
'hide': [0.85, 0.85, 0.85, 0.2],
}
if not self.bone:
return bone_colors
if self.bone.color.palette == 'CUSTOM':
bone_color = self.bone
elif self.bone.color.palette == 'DEFAULT':
bone_color = self.bone.bone
normal_color = bone_color.color.custom.normal.copy()
normal_color.s *= 0.75
bone_colors['normal'] = [*normal_color, 1]
bone_colors['select'] = [*bone_color.color.custom.select, 1]
bone_colors['active'] = [*bone_color.color.custom.active, 1]
bone_colors['hide'] = [*normal_color, 0.1]
return bone_colors
def draw_hided(self):
gpu.state.blend_set('ALPHA')
gpu.state.line_width_set(1.0)
line_color = (1, 1, 1, 0.1)
color = Color(self.color[:3])
if self.hover:
color.v += 0.05
color.v *= 1.1
line_color = (1, 1, 1, 0.3)
self.shader.uniform_float("color", (*color[:3], 0.5))
self.p_batch.draw(self.shader)
self.shader.uniform_float("color", line_color)
self.e_batch.draw(self.shader)
gpu.state.blend_set('NONE')
def draw_zero_scaled(self):
gpu.state.blend_set('ALPHA')
gpu.state.line_width_set(1.0)
line_color = (*self.bone_colors['normal'][:3], 0.2)
color = Color(self.color[:3])
if self.hover or self.select:
color.v += 0.05
color.v *= 1.1
line_color = (*self.bone_color[:3], 0.66)
self.shader.uniform_float("color", (*color[:3], 0.5))
self.p_batch.draw(self.shader)
self.shader.uniform_float("color", line_color)
self.e_batch.draw(self.shader)
gpu.state.blend_set('NONE')
def draw(self): def draw(self):
gpu.state.blend_set('ALPHA') gpu.state.blend_set('ALPHA')
gpu.state.line_width_set(1.0)
if self.hide: if self.hide:
return self.draw_hided() self.shader.uniform_float("color", (*self.color[:3], 0.4))
self.p_batch.draw(self.shader)
#elif self.select:
# self.shader.uniform_float("color", self.bone_color)
# self.p_batch.draw(self.shader)
else:
super().draw()
elif self.bone and self.bone.custom_shape_scale_xyz.length < 0.00001: # Overlay the fill slightly with the bone color
return self.draw_zero_scaled() #self.shader.uniform_float("color", (*self.bone_color[:3], 0.1))
#self.p_batch.draw(self.shader)
# Draw Fill
color = self.color
if self.select: if self.select:
color = self.select_color
elif self.hover:
color = self.hover_color color = self.hover_color
if self.select or self.hover:
color = self.hover_color
if self.select and self.hover:
color = self.active_color
self.shader.uniform_float("color", color) self.shader.uniform_float("color", color)
self.p_batch.draw(self.shader) self.p_batch.draw(self.shader)
# Draw Outline #Overlay the fill slightly with the bone color
gpu.state.blend_set('NONE') self.shader.uniform_float("color", (*self.bone_colors['normal'][:3], 0.1))
self.p_batch.draw(self.shader)
#self.contour_shader.bind()
#print(self.bone_color)
if self.select or self.active: if self.select or self.active:
gpu.state.line_width_set(2.0) gpu.state.line_width_set(2.0)
#if not self.hide:
self.shader.uniform_float("color", self.bone_color) self.shader.uniform_float("color", self.bone_color)
#for b in self.contour_batches:
self.e_batch.draw(self.shader) self.e_batch.draw(self.shader)
gpu.state.line_width_set(1.0) gpu.state.line_width_set(1.0)
gpu.state.blend_set('NONE')
def assign_bone_event(self): def assign_bone_event(self):
#print('assign_bone_event', self) #print('assign_bone_event', self)
scn = bpy.context.scene scn = bpy.context.scene
rig = self.picker.rig rig = scn.rig_picker.rig
source_object = scn.objects.get(self.source_name) source_object = scn.objects.get(self.source_name)
if not source_object: if not source_object:
print(f'Source object {self.source_name} not found') print(f'Source object {self.source_name} not found')
@ -271,9 +257,6 @@ class BoneShape(Shape):
print('You need to have an active bone') print('You need to have an active bone')
return return
#print(active_bone, source_object)
#print(rig)
source_object.name = rig.data.bones.active.name
source_object.rig_picker.name = rig.data.bones.active.name source_object.rig_picker.name = rig.data.bones.active.name
def release_event(self, mode='SET'): def release_event(self, mode='SET'):
@ -294,6 +277,11 @@ class BoneShape(Shape):
def border_select(self, border, mode='SET'): def border_select(self, border, mode='SET'):
'''
if ( not any(intersect_point_quad_2d(b, *self.bound) for b in border) and
not any(intersect_point_quad_2d(b, *border) for b in self.bound) ):
return
'''
if not self.bone: if not self.bone:
return return
@ -301,16 +289,16 @@ class BoneShape(Shape):
self.bone.bone.select = False self.bone.bone.select = False
return return
rect_tri1 = self.rect[0], self.rect[1], self.rect[2] bound_tri1 = self.bound[0], self.bound[1], self.bound[2]
rect_tri2 = self.rect[2], self.rect[3], self.rect[0] bound_tri2 = self.bound[2], self.bound[3], self.bound[0]
border_tri1 = border[0], border[1], border[2] border_tri1 = border[0], border[1], border[2]
border_tri2 = border[2], border[3], border[0] border_tri2 = border[2], border[3], border[0]
if (not intersect_tri_tri_2d(*border_tri1, *rect_tri1) and if (not intersect_tri_tri_2d(*border_tri1, *bound_tri1) and
not intersect_tri_tri_2d(*border_tri1, *rect_tri2) and not intersect_tri_tri_2d(*border_tri1, *bound_tri2) and
not intersect_tri_tri_2d(*border_tri2, *rect_tri1) and not intersect_tri_tri_2d(*border_tri2, *bound_tri1) and
not intersect_tri_tri_2d(*border_tri2, *rect_tri2)): not intersect_tri_tri_2d(*border_tri2, *bound_tri2)):
return return
select = True select = True
@ -397,94 +385,121 @@ class OperatorShape(Shape):
class Picker: class Picker:
def __init__(self, parent, rig, shapes): def __init__(self, rig, shapes):
self.parent = parent
self.region = bpy.context.region self.region = bpy.context.region
self.rig = rig self.rig = rig
self.translation = Vector((0, 0))
self.shapes = [] self.shapes = []
self.box_select = None self.box_select = None
self.hover_shape = None self.hover_shape = None
self.shader = gpu.shader.from_builtin('UNIFORM_COLOR') self.shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
self.tooltip_shape = None
self.tooltip_mouse = None
self.tooltip = ''
self.timer = None
self.mouse = None self.mouse = None
for shape_data in shapes: for s in shapes:
if not shape_data['points']: if not s['points']:
continue continue
if shape_data['type'] in ('CANVAS', 'DISPLAY'): if s['type'] in ('CANVAS', 'DISPLAY'):
shape = Shape( shape = Shape(
self, self,
points=shape_data['points'], points=s['points'],
polygons=shape_data['polygons'], polygons=s['polygons'],
edges=shape_data['edges'], edges=s['edges'],
color=shape_data['color'] color=s['color']
) )
elif shape_data['type'] == 'BONE': elif s['type'] == 'BONE':
bone = rig.pose.bones.get(shape_data['bone']) bone = rig.pose.bones.get(s['bone'])
#if not bone: #if not bone:
# print(f'Bone {shape_data["bone"]} not exist') # print(f'Bone {s["bone"]} not exist')
# continue # continue
shape = BoneShape( shape = BoneShape(
self, self,
source_name=shape_data['source_name'], source_name=s['source_name'],
points=shape_data['points'], points=s['points'],
polygons=shape_data['polygons'], polygons=s['polygons'],
edges=shape_data['edges'], edges=s['edges'],
bone=bone, bone=bone,
color=shape_data['color'] color=s['color']
) )
elif shape_data['type'] == 'OPERATOR': elif s['type'] == 'OPERATOR':
shape = OperatorShape( shape = OperatorShape(
self, self,
source_name=shape_data['source_name'], source_name=s['source_name'],
points=shape_data['points'], points=s['points'],
polygons=shape_data['polygons'], polygons=s['polygons'],
operator=shape_data['operator'], operator=s['operator'],
color=shape_data['color'], color=s['color'],
tooltip=shape_data['tooltip'], tooltip=s['tooltip'],
) )
self.shapes.append(shape) self.shapes.append(shape)
self.rect = bounding_rect([p for s in self.shapes for p in s.points])
def assign_bone_event(self): def assign_bone_event(self):
for shape in self.shapes: for s in self.shapes:
if shape.type == 'bone' and shape.hover: if s.type=='bone' and s.hover:
shape.assign_bone_event() s.assign_bone_event()
bpy.ops.rigpicker.save_picker(index=self.index) bpy.ops.rigpicker.save_picker()
def press_event(self, mode='SET'): def press_event(self, mode='SET'):
for shape in self.shapes: for s in self.shapes:
#print(s) if s.hover:
if shape.hover: s.press_event(mode)
shape.press_event(mode)
else: else:
shape.press = False s.press = False
def release_event(self, mode='SET'): def release_event(self, mode='SET'):
if mode == 'SET':
for b in self.rig.pose.bones:
b.bone.select = False
#bpy.ops.pose.select_all(action='DESELECT') #bpy.ops.pose.select_all(action='DESELECT')
#print('PICKER release event', mode) #print('PICKER release event', mode)
#print(f'type={event.type}, value={event.value}, ctrl={event.ctrl}, shift={event.shift}, alt={event.alt}') #print(f'type={event.type}, value={event.value}, ctrl={event.ctrl}, shift={event.shift}, alt={event.alt}')
for shape in self.shapes: for s in self.shapes:
if shape.hover: if s.hover:
shape.release_event(mode) s.release_event(mode)
shape.press = False s.press = False
#bpy.context.area.tag_redraw() #bpy.context.area.tag_redraw()
def tooltip_event(self):
#print('Tooltip Event', self)
#print(self.hover_shape, self.hover_shape.type)
if self.hover_shape and self.hover_shape.type != 'display':
if self.hover_shape.type == 'bone':
self.tooltip = self.hover_shape.bone.name
else:
self.tooltip = self.hover_shape.tooltip
self.tooltip_shape = self.hover_shape
else:
self.tooltip = ''
self.tooltip_shape = None
self.tooltip_mouse = self.mouse
self.timer.cancel()
#print(self.tooltip)
self.region.tag_redraw()
''' '''
picker.tooltip_event(event='SHOW') picker.tooltip_event(event='SHOW')
region.tag_redraw() region.tag_redraw()
@ -511,27 +526,27 @@ class Picker:
''' '''
def border_select(self, border, mode): def border_select(self, border, mode):
border = [Vector(b) - Vector(self.translation) for b in border] border = [bpy.context.region.view2d.region_to_view(*b) for b in border]
for shape in self.shapes: if mode == 'SET':
shape.press = False for b in self.rig.pose.bones:
shape.hover = False b.bone.select = False
if shape.type != 'bone':
continue
shape.border_select(border, mode) for s in (s for s in self.shapes if s.type=='bone'):
s.border_select(border, mode)
def move_event(self, location): def move_event(self, location):
self.mouse = Vector(location) - Vector(self.translation) self.mouse = location
location = self.region.view2d.region_to_view(*location)
self.hover_shape = None self.hover_shape = None
for shape in reversed(self.shapes): for shape in reversed(self.shapes):
if self.hover_shape: if self.hover_shape:
shape.hover = False shape.hover = False
elif shape.move_event(self.mouse): elif shape.move_event(location):
self.hover_shape = shape self.hover_shape = shape
#if point_inside_rect(self.end, rect): #if point_inside_rectangle(self.end, bound):
# over = point_over_shape(self.end,points, edges) # over = point_over_shape(self.end,points, edges)
#if bpy.app.timers.is_registered(self.tooltip_event): #if bpy.app.timers.is_registered(self.tooltip_event):
@ -539,221 +554,57 @@ class Picker:
# bpy.app.timers.unregister(self.tooltip_event) # bpy.app.timers.unregister(self.tooltip_event)
#except: #except:
# pass # pass
#bpy.app.timers.register(self.tooltip_event, first_interval=1)
def draw(self):
with gpu.matrix.push_pop():
gpu.matrix.translate(self.translation)
for shape in self.shapes:
shape.draw()
def under_mouse(self, location):
location = Vector(location) - Vector(self.translation)
return intersect_point_quad_2d(location, *self.rect)
@property
def center(self):
relative_center = (self.rect[1] + self.rect[3]) * 0.5
return relative_center + self.translation
@property
def index(self):
return self.parent.pickers.index(self)
class PickerGroup:
def __init__(self, rig, pickers):
#self.view_location = Vector((0, 0))
self.region = bpy.context.region
self.rig = rig
self.pickers = []
self.mouse = Vector((0, 0))
self.location = Vector((0, 0))
self.hover_shape = None
self.tooltip_shape = None
self.tooltip_mouse = Vector((0, 0))
self.tooltip = ''
self.timer = None
for picker in pickers:
self.add_picker(picker)
def add_picker(self, picker):
self.pickers.append(Picker(self, self.rig, picker))
def draw(self):
y = 0
for picker in self.pickers:
height = picker.rect[1][1] - picker.rect[-1][1]
picker.translation = Vector((0, -y-height*0.5))
picker.draw()
y += height + 50
#break #TODO for now only draw first picker
def move_event(self, mouse):
self.mouse = mouse
self.location = self.region.view2d.region_to_view(*mouse)
# Try to detect view pan to remove tooltip
# view_location = self.region.view2d.region_to_view(0, 0)
# if view_location != self.view_location:
# self.view_location = view_location
# self.tooltip = ''
# if self.timer:
# self.timer.cancel()
# return
hover_shape = None
for picker in self.pickers:
if not picker.under_mouse(self.location):
continue
picker.move_event(self.location)
if picker.hover_shape:
hover_shape = picker.hover_shape
self.hover_shape = hover_shape
if self.tooltip_shape is not self.hover_shape: if self.tooltip_shape is not self.hover_shape:
self.tooltip = '' self.tooltip = ''
if self.timer: if self.timer:
self.timer.cancel() self.timer.cancel()
self.timer = threading.Timer(0.4, self.tooltip_event) self.timer = threading.Timer(0.5, self.tooltip_event)
self.timer.start() self.timer.start()
def press_event(self, mode='SET'):
#self.clear_tooltip()
for picker in self.pickers: #bpy.app.timers.register(self.tooltip_event, first_interval=1)
if picker.under_mouse(self.location):
picker.press_event(mode)
else:
for shape in picker.shapes:
shape.press = False
def release_event(self, mode='SET'): def draw(self):
if mode == 'SET': for s in self.shapes:
for bone in self.rig.data.bones: s.draw()
bone.select = False '''
if self.box_select:
for picker in self.pickers: self.box_shader.uniform_float("color", self.box_select_color)
if picker.under_mouse(self.location): batch = batch_for_shader(self.shader, 'LINE_LOOP', {"pos": []})
picker.release_event(mode)
else:
for shape in picker.shapes:
shape.press = False
def assign_bone_event(self):
for picker in self.pickers:
if picker.under_mouse(self.location):
picker.assign_bone_event()
def border_select(self, border, mode):
border = [self.region.view2d.region_to_view(*b) for b in border]
if mode == 'SET':
for bone in self.rig.data.bones:
bone.select = False
for picker in self.pickers:
picker.border_select(border, mode)
def clear_tooltip(self):
self.tooltip = ''
self.tooltip_shape = None
self.timer.cancel()
self.region.tag_redraw()
def tooltip_event(self):
#print('Tooltip Event', self)
#print(self.hover_shape, self.hover_shape.type)
if self.hover_shape and self.hover_shape.type != 'display':
if self.hover_shape.type == 'bone' and self.hover_shape.bone:
self.tooltip = self.hover_shape.bone.name
else:
self.tooltip = self.hover_shape.tooltip
self.tooltip_shape = self.hover_shape
else:
return self.clear_tooltip()
self.tooltip_mouse = self.mouse for b in self.contour_batches:
b.draw(self.contour_shader)
self.timer.cancel() self.batch.draw(self.shader)
#print(self.tooltip)
self.region.tag_redraw()
@property
def rect(self):
return bounding_rect([co - Vector(p.translation) for p in self.pickers for co in p.rect])
@property
def center(self):
center = sum(self.rect, Vector((0, 0))) / len(self.rect)
center[1] = -center[1]
return center
def load_picker_data(rig): gpu.state.blend_set('NONE')
if 'pickers' in rig.data.rig_picker: '''
picker_datas = [[s.to_dict() for s in p] for p in rig.data.rig_picker['pickers']]
else:
picker_datas = []
for picker in rig.data.rig_picker.sources: def get_picker_path(rig, start=None):
picker_path = Path(bpy.path.abspath(picker.source, library=rig.data.library)) picker_path = rig.data.get('rig_picker', {}).get('source')
if not picker_path:
if not picker_path.exists():
print(f'Picker path not exists: {picker_path.resolve()}')
continue
print('Load picker from', picker_path.resolve())
picker_data = json.loads(picker_path.read_text(encoding='utf-8'))
picker_datas.append(picker_data)
PICKERS[rig] = PickerGroup(rig, picker_datas)
def get_picker_path(rig, source, start=None):
picker_path = bpy.path.abspath(source, library=rig.data.library, start=start)
return Path(os.path.abspath(picker_path))
def pack_picker(rig, start=None):
if not 'rig_picker' in rig.data:
return return
pickers = [] picker_path = bpy.path.abspath(picker_path, library=rig.data.library, start=start)
for picker_source in rig.data['rig_picker'].get('sources', []):
picker_path = get_picker_path(rig, picker_source['source'], start)
if not picker_path.exists():
print(f'{picker_path} not exists')
continue
picker_data = json.loads(picker_path.read_text(encoding='utf-8'))
pickers.append(picker_data)
rig.data['rig_picker']['pickers'] = pickers return Path(os.path.abspath(picker_path))
def pack_picker(rig, start=None):
picker_path = get_picker_path(rig, start=start)
if picker_path and picker_path.exists():
if 'rig_picker' not in rig.data.keys():
rig.data['rig_picker'] = {}
rig.data['rig_picker']['picker'] = json.loads(picker_path.read_text())
def unpack_picker(rig): def unpack_picker(rig):
if 'rig_picker' not in rig.data.keys(): if 'rig_picker' not in rig.data.keys():
return return
if 'pickers' in rig.data['rig_picker'].keys(): if 'picker' in rig.data['rig_picker'].keys():
del rig.data['rig_picker']['pickers'] del rig.data['rig_picker']['picker']

120
core/shape.py
View File

@ -20,7 +20,7 @@ def border_over_shape(border,verts,loops):
return True return True
for point in verts: for point in verts:
if point_inside_rect(point,border): if point_inside_rectangle(point,border):
return True return True
for point in border: for point in border:
@ -29,7 +29,7 @@ def border_over_shape(border,verts,loops):
def border_loop(vert, loop): def border_loop(vert, loop):
border_edge =[e for e in vert.link_edges if e.is_rectary] border_edge =[e for e in vert.link_edges if e.is_boundary]
if border_edge: if border_edge:
for edge in border_edge: for edge in border_edge:
@ -61,50 +61,67 @@ def contour_loops(bm, vert_index=0, loops=None, vert_indices=None):
return loops return loops
def get_picker_datas(objects, canvas, rig):
def get_shape_data(ob, matrix=None, depsgraph=None): picker_datas = []
if not matrix:
matrix = Matrix()
if not depsgraph:
depsgraph = bpy.context.evaluated_depsgraph_get()
gamma = 1 / 2.2 gamma = 1 / 2.2
eval_ob = ob.evaluated_get(depsgraph)
mesh = eval_ob.to_mesh() if canvas.type =='CURVE':
canvas_points = canvas.data.splines[0].points
else:
canvas_points = canvas.data.vertices
canvas_coords = [canvas.matrix_world@Vector((p.co)) for p in canvas_points]
canvas_x = [p[0] for p in canvas_coords]
canvas_y = [p[1] for p in canvas_coords]
canvas_center = sum(canvas_coords, Vector()) / len(canvas_coords)
canvas_scale_fac = 4096 / (max(canvas_y) - min(canvas_y))# Reference height for the canvas
objects.append(canvas)
dg = bpy.context.evaluated_depsgraph_get()
#sorted by their z axes
for ob in sorted(objects, key=lambda x: bound_box_center(x)[2]):
print('Storing shape', ob.name)
mesh = bpy.data.meshes.new_from_object(ob.evaluated_get(dg))
bm = bmesh.new() bm = bmesh.new()
bm.from_mesh(mesh) bm.from_mesh(mesh)
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.002) bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.002)
bmesh.ops.dissolve_limit(bm, angle_limit=0.001745, verts=bm.verts, edges=bm.edges) bmesh.ops.dissolve_limit(bm, angle_limit=0.001745, verts=bm.verts, edges=bm.edges)
bmesh.ops.connect_verts_concave(bm, faces=bm.faces) bmesh.ops.connect_verts_concave(bm, faces=bm.faces)
bmesh.ops.triangulate(bm, faces=bm.faces) bmesh.ops.triangulate(bm, faces=bm.faces)
#bm_loops = contour_loops(bm)
#loops = [[l.index for l in loop] for loop in bm_loops]
loops = []
edges = [[v.index for v in e.verts] for e in bm.edges if len(e.link_faces)<=1] edges = [[v.index for v in e.verts] for e in bm.edges if len(e.link_faces)<=1]
bm.to_mesh(mesh) bm.to_mesh(mesh)
mesh.update() mesh.update()
bm.clear() bm.clear()
points = [] points = []
#edges = []
polygons = [] polygons = []
depths = []
for vert in mesh.vertices: for p in mesh.vertices:
co = matrix @ (ob.matrix_world @ Vector(vert.co)) point = ob.matrix_world@Vector((p.co))
points.append([round(co[0], 1), round(co[1], 1)]) point = (point - canvas_center) * canvas_scale_fac
points.append([round(point[0]), round(point[1])])
depths += [co[2]] for f in mesh.polygons:
polygons.append([v for v in f.vertices])
if depths: #for e in mesh.edges:
depth = max(depths) #
else: # edges.append([v for v in e.vertices])
print(f'{ob.name} has no vertices')
depth = 0
for face in mesh.polygons:
polygons.append([v for v in face.vertices])
color = get_object_color(ob) color = get_object_color(ob)
if color: if color:
@ -115,65 +132,28 @@ def get_shape_data(ob, matrix=None, depsgraph=None):
shape = { shape = {
'source_name': ob.name, 'source_name': ob.name,
'tooltip': ob.rig_picker.name, 'tooltip': ob.rig_picker.name,
'depth': depth,
'points': points, 'points': points,
'polygons': polygons, 'polygons': polygons,
'edges': edges, 'edges': edges,
'loops': loops,
'color': color, 'color': color,
'type': ob.rig_picker.shape_type 'type': 'CANVAS' if ob == canvas else ob.rig_picker.shape_type
} }
if shape['type'] =='OPERATOR': if shape['type'] =='OPERATOR':
shape['operator'] = ob.rig_picker.operator shape['operator'] = ob.rig_picker.operator
#if ob.rig_picker.arguments:
#shape['arguments'] = ob.rig_picker.arguments
#if ob.rig_picker.shortcut:
shape['shortcut'] = ob.rig_picker.shortcut shape['shortcut'] = ob.rig_picker.shortcut
elif shape['type'] =='BONE': elif shape['type'] =='BONE':
shape['bone'] = ob.rig_picker.name shape['bone'] = ob.rig_picker.name
eval_ob.to_mesh_clear() picker_datas.append(shape)
return shape
def get_picker_data(collection):
picker_data = []
depsgraph = bpy.context.evaluated_depsgraph_get()
canvas = collection.rig_picker.canvas
if canvas.type == 'CURVE':
canvas_points = canvas.data.splines[0].points
else:
canvas_points = canvas.data.vertices
canvas_coords = [canvas.matrix_world@Vector((p.co)) for p in canvas_points]
height = abs(max(canvas_coords).y - min(canvas_coords).y)
width = abs(max(canvas_coords).x - min(canvas_coords).x)
center = sum(canvas_coords, Vector()) / len(canvas_coords)
scale = 2048 / max(height, width)# Reference height for the canvas
matrix = Matrix.Translation(-center)
matrix = Matrix.Scale(scale, 4) @ matrix
#sorted by their z axes
for ob in collection.all_objects:
if ob.instance_collection:
for shape in ob.instance_collection.all_objects:
picker_data.append(get_shape_data(shape, matrix=matrix@ob.matrix_world, depsgraph=depsgraph))
elif ob.type in ('MESH', 'CURVE', 'FONT'):
picker_data.append(get_shape_data(ob, matrix=matrix, depsgraph=depsgraph))
else:
#print(f'{ob.name} of type {ob.type} not supported')
continue
picker_data.sort(key=lambda x : x['depth'])
#print(picker_datas) #print(picker_datas)
return picker_data return picker_datas
#rig.data.rig_picker['shapes'] = picker_datas #rig.data.rig_picker['shapes'] = picker_datas

90
draw_handlers.py
View File

@ -1,63 +1,39 @@
import bpy import bpy
import gpu
from gpu_extras.batch import batch_for_shader
import blf import blf
from pathlib import Path from pathlib import Path
from .constants import PICKERS from .constants import PICKERS
from .core.picker import Picker, PickerGroup, load_picker_data from .core.picker import Picker
import json import json
def draw_rect_2d(position, width, height, color):
"""
Draw a 2d rectangele.
:arg position: Position of the lower left corner.
:type position: 2D Vector
:arg width: Width of the rect.
:type width: float
:arg height: Height of the rect.
:type height: float
"""
coords = ((0, 0), (1, 0), (1, 1), (0, 1))
shader = gpu.shader.from_builtin('UNIFORM_COLOR')
batch = batch_for_shader(
shader, 'TRI_FAN',
{"pos": coords},
)
with gpu.matrix.push_pop():
gpu.matrix.translate(position)
gpu.matrix.scale((width, height))
shader.uniform_float("color", color)
batch.draw(shader)
def draw_callback_view(): def draw_callback_view():
space_data = bpy.context.space_data sp = bpy.context.space_data
if not space_data or not space_data.tree_type == 'RigPickerTree': if not sp or not sp.tree_type == 'RigPickerTree':
return return
# Use the pin to know if this is the first time this picker window in created to hide the n panel
if not space_data.pin:
space_data.pin = True
space_data.show_region_ui = False
ob = bpy.context.object ob = bpy.context.object
if not ob or ob.type !='ARMATURE' or not ob.data.rig_picker.sources: if not ob or ob.type !='ARMATURE' or not ob.data.rig_picker.source:
return return
if ob not in PICKERS: if ob not in PICKERS:
load_picker_data(ob) if 'picker' in ob.data.rig_picker:
picker_datas = [s.to_dict() for s in ob.data.rig_picker['picker']]
else:
picker_path = Path(bpy.path.abspath(ob.data.rig_picker.source, library=ob.data.library))
picker_group = PICKERS[ob] if not picker_path.exists():
picker_group.draw() print(f'Picker path not exists: {picker_path.resolve()}')
return
print('Load picker from', picker_path.resolve())
picker_datas = json.loads(picker_path.read_text())
#shapes = [s.to_dict() for s in ob.data.rig_picker['shapes']]
PICKERS[ob] = Picker(ob, shapes=picker_datas)
picker = PICKERS.get(ob)
picker.draw()
def draw_callback_px(): def draw_callback_px():
sp = bpy.context.space_data sp = bpy.context.space_data
@ -66,37 +42,24 @@ def draw_callback_px():
ob = bpy.context.object ob = bpy.context.object
picker_group = PICKERS.get(ob) picker = PICKERS.get(ob)
if not picker_group or not picker_group.tooltip: if not picker or not picker.tooltip:
return return
region = bpy.context.region text = picker.tooltip
text = picker_group.tooltip
ui_scale = bpy.context.preferences.system.ui_scale
#print('Draw text', text) #print('Draw text', text)
font_id = 0 font_id = 0
blf.size(font_id, int(13 * ui_scale))
margins = [12, 5]
text_size = blf.dimensions(font_id, text)
text_pos = (region.width - text_size[0]-margins[0], margins[1])
bg_pos = (text_pos[0] - margins[0], text_pos[1] - margins[1]-1)
bg_size = (text_size[0] + 2*margins[0], text_size[1] + 2*margins[1])
gpu.state.blend_set('ALPHA')
draw_rect_2d(bg_pos, *bg_size, (0.1, 0.1, 0.1, 0.66))
gpu.state.blend_set('NONE')
#blf.dimensions(font_id, text) #blf.dimensions(font_id, text)
blf.enable(font_id, blf.SHADOW) blf.enable(font_id, blf.SHADOW)
#gpu.state.blend_set('ALPHA')
# BLF drawing routine # BLF drawing routine
blf.position(font_id, round(text_pos[0]), round(text_pos[1]), 0) blf.position(font_id, picker.tooltip_mouse[0]-5, picker.tooltip_mouse[1]+5, 0)
blf.color(font_id, 0.85, 0.85, 0.85, 1) blf.size(font_id, 14)
blf.color(font_id, 1, 1, 1, 1)
blf.shadow(font_id , 5, 0.0, 0.0, 0.0, 1) blf.shadow(font_id , 5, 0.0, 0.0, 0.0, 1)
blf.shadow_offset(font_id, 2, -2) blf.shadow_offset(font_id, 2, -2)
@ -104,6 +67,7 @@ def draw_callback_px():
blf.draw(font_id, text) blf.draw(font_id, text)
blf.disable(font_id, blf.SHADOW) blf.disable(font_id, blf.SHADOW)
#gpu.state.blend_set('NONE')
handle_view = None handle_view = None
handle_pixel = None handle_pixel = None

2
gizmo.py
View File

@ -68,8 +68,6 @@ class RP_GT_gizmo(Gizmo):
context.region.tag_redraw() context.region.tag_redraw()
#print(location)
return -1 return -1

780
operators/picker.py
View File

File diff suppressed because it is too large Load Diff

148
operators/shape.py
View File

@ -1,18 +1,13 @@
import json
from os.path import abspath
from pathlib import Path
import bpy import bpy
from bpy.types import Operator from ..core.shape import get_picker_datas
from bpy.props import IntProperty from ..core.addon_utils import is_shape
from mathutils import Matrix from ..core.bl_utils import link_mat_to_object, find_mirror
from pathlib import Path
from ..core.shape import get_picker_data import json
from ..core.addon_utils import is_shape, get_picker_collection
from ..core.bl_utils import link_mat_to_object, flip_name
class RP_OT_create_shape(Operator): class RP_OT_create_shape(bpy.types.Operator):
bl_label = 'Create UI shape' bl_label = 'Create UI shape'
bl_idname = 'rigpicker.create_shape' bl_idname = 'rigpicker.create_shape'
#bl_options = {'REGISTER', 'UNDO'} #bl_options = {'REGISTER', 'UNDO'}
@ -57,7 +52,7 @@ class RP_OT_create_shape(Operator):
return {'FINISHED'} return {'FINISHED'}
class RP_OT_name_from_bone(Operator): class RP_OT_name_from_bone(bpy.types.Operator):
bl_label = 'Name Shape from selected bones' bl_label = 'Name Shape from selected bones'
bl_idname = 'rigpicker.name_from_bone' bl_idname = 'rigpicker.name_from_bone'
#bl_options = {'REGISTER', 'UNDO'} #bl_options = {'REGISTER', 'UNDO'}
@ -74,67 +69,67 @@ class RP_OT_name_from_bone(Operator):
return {'FINISHED'} return {'FINISHED'}
class RP_OT_mirror_shape(Operator): class RP_OT_mirror_shape(bpy.types.Operator):
bl_label = 'Mirror UI shape' bl_label = 'Mirror UI shape'
bl_idname = 'rigpicker.mirror_shape' bl_idname = 'rigpicker.mirror_shape'
#bl_options = g #bl_options = {'REGISTER', 'UNDO'}
@classmethod
def poll(cls, context):
return (context.object and context.object.type in ('MESH', 'CURVE', 'TEXT'))
def execute(self,context): def execute(self,context):
scn = context.scene scn = context.scene
ob = context.object
collection = get_picker_collection(ob)
objects = context.selected_objects
# Remove mirror object: for ob in bpy.context.selected_objects:
for ob in list(collection.all_objects):
if ob in objects:
continue
for mod in ob.modifiers: name = find_mirror(ob.name)
if (mod.type == 'NODES' and mod.node_group.name == 'Symmetrize' and link_mat_to_object(ob)
mod.get('Socket_2') in objects):
bpy.data.objects.remove(ob) if not name:
name = ob.name + '_flip'
if collection.rig_picker.symmetry: old_shape = bpy.data.objects.get(name)
x_axis = collection.rig_picker.symmetry.matrix_world.to_translation()[0] old_mat = None
if old_shape:
old_mat = next((sl.material for sl in old_shape.material_slots if sl.material), None)
bpy.data.objects.remove(old_shape)
mirror_ob = ob.copy()
mirror_ob.data = ob.data
mirror_ob.name = name
if old_mat:
#mirror_ob.data.materials.clear()
#mirror_ob.data.materials.append(None)
#mirror_ob.material_slots[0].link = 'OBJECT'
mirror_ob.material_slots[0].material = old_mat
#mirror_ob = bpy.data.objects.new(name,ob.data.copy())
for c in ob.users_collection:
c.objects.link(mirror_ob)
if scn.rig_picker.symmetry:
symmetry_loc = scn.rig_picker.symmetry.matrix_world.to_translation()[0]
else: else:
x_axis = 0 symmetry_loc = 0
for ob in objects: #print(symmetry_loc)
flipped_name = flip_name(ob.name) mirror_ob.matrix_world = ob.matrix_world
if flipped_name == ob.name:
suffix = '.L'
flipped_suffix = '.R'
# Determine side of the object
if ob.matrix_world.to_translation()[0] < x_axis:
suffix, flipped_suffix = flipped_suffix, suffix
flipped_name = f'{ob.name}{flipped_suffix}' #if mirror_ob.location[0] < symmetry_loc:
ob.name = f'{ob.name}{suffix}' mirror_ob.location.x = symmetry_loc + (symmetry_loc - ob.location.x)
#else:
# mirror_ob.location[0]= symmetry_loc+ (symmetry_loc- ob.location[0])
flipped_object = ob.copy() mirror_ob.rotation_euler.y = -ob.rotation_euler.y
flipped_object.name = flipped_name mirror_ob.rotation_euler.z = -ob.rotation_euler.z
flipped_object.parent = None
flipped_object.matrix_world = Matrix()
for mod in list(flipped_object.modifiers):
flipped_object.modifiers.remove(mod)
# Add symmetrize modifier mirror_ob.scale.x = -ob.scale.x
mod = flipped_object.modifiers.new(name='Symmetrize', type='NODES')
mod.node_group = bpy.data.node_groups['Symmetrize']
mod['Socket_2'] = ob
mod['Socket_3'] = collection.rig_picker.symmetry
for col in ob.users_collection: for key, value in ob.items():
col.objects.link(flipped_object) if key not in ['_RNA_UI','cycles']:
mirror_ob[key] = value
if ob.rig_picker.shape_type == 'BONE': if ob.rig_picker.shape_type == 'BONE':
flipped_object.rig_picker.name = flip_name(ob.rig_picker.name) mirror_ob.rig_picker.name = find_mirror(ob.rig_picker.name)
elif ob.rig_picker.shape_type == 'FUNCTION': elif ob.rig_picker.shape_type == 'FUNCTION':
args = {} args = {}
@ -142,18 +137,18 @@ class RP_OT_mirror_shape(Operator):
if type(value) == list: if type(value) == list:
mirrored_value = [] mirrored_value = []
for item in value: for item in value:
mirrored_value.append(flip_name(item)) mirrored_value.append(find_mirror(item))
elif type(value) == str: elif type(value) == str:
mirrored_value = flip_name(value) mirrored_value = find_mirror(value)
args[key] = mirrored_value args[key] = mirrored_value
flipped_object.rig_picker.arguments = str(args) mirror_ob.rig_picker.arguments = str(args)
return {'FINISHED'} return {'FINISHED'}
class RP_OT_select_shape_type(Operator): class RP_OT_select_shape_type(bpy.types.Operator):
bl_label = 'Select Shape by Type' bl_label = 'Select Shape by Type'
bl_idname = 'rigpicker.select_shape_type' bl_idname = 'rigpicker.select_shape_type'
#bl_options = {'REGISTER', 'UNDO'} #bl_options = {'REGISTER', 'UNDO'}
@ -182,46 +177,33 @@ class RP_OT_select_shape_type(Operator):
return wm.invoke_props_dialog(self, width=150) return wm.invoke_props_dialog(self, width=150)
class RP_OT_save_picker(Operator): class RP_OT_save_picker(bpy.types.Operator):
bl_label = 'Store UI Data' bl_label = 'Store UI Data'
bl_idname = 'rigpicker.save_picker' bl_idname = 'rigpicker.save_picker'
index : IntProperty(default=-1)
def execute(self, context): def execute(self, context):
scn = context.scene scn = context.scene
ob = context.object canvas = scn.rig_picker.canvas
rig = scn.rig_picker.rig
shapes = [o for o in scn.objects if o != canvas and is_shape(o)]
if self.index == -1: if not rig:
collection = get_picker_collection(ob) self.report({'ERROR'}, 'Choose a Rig')
else:
source = context.active_object.data.rig_picker.sources[self.index].source
source = Path(bpy.path.abspath(source, library=ob.data.library)).resolve()
collection = next((c for c in set(scn.collection.children_recursive) if c.rig_picker.enabled
and Path(bpy.path.abspath(c.rig_picker.destination)).resolve() == source), None)
if not collection:
self.report({"ERROR"}, 'No Picker found')
return {'CANCELLED'} return {'CANCELLED'}
canvas = collection.rig_picker.canvas
#rig = collection.rig_picker.rig
shapes = [o for o in collection.all_objects if o != canvas and o.type in ('MESH', 'CURVE', 'FONT')]
if not canvas: if not canvas:
self.report({'ERROR'}, 'Choose a Canvas') self.report({'ERROR'}, 'Choose a Canvas')
return {'CANCELLED'} return {'CANCELLED'}
picker_data = get_picker_data(collection) data = get_picker_datas(shapes, canvas, rig)
picker_path = Path(bpy.path.abspath(collection.rig_picker.destination)) picker_path = Path(bpy.path.abspath(scn.rig_picker.destination))
picker_path.write_text(json.dumps(data))
print(f'Save Picker to {picker_path}')
picker_path.write_text(json.dumps(picker_data))
bpy.ops.rigpicker.reload_picker() bpy.ops.rigpicker.reload_picker()
return {'FINISHED'} return {'FINISHED'}
classes = ( classes = (

117
panels.py Normal file
View File

@ -0,0 +1,117 @@
import bpy
#import collections
#import inspect
from .core.addon_utils import get_operator_from_id
from .core.bl_utils import get_mat
import re
class RP_PT_picker_maker_panel(bpy.types.Panel):
bl_label = 'Rig Picker'
bl_category = 'Rigging'
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
@classmethod
def poll(cls, context):
return context.object
def draw(self, context):
ob = context.object
scn = context.scene
layout = self.layout
col = layout.column(align=False)
col.prop_search(scn.rig_picker, 'rig', scn, 'objects', text='Rig ')
col.prop_search(scn.rig_picker, 'canvas', scn, 'objects', text='Canvas ')
col.prop_search(scn.rig_picker, 'symmetry', scn, 'objects', text='Symmetry ')
if ob.type == 'ARMATURE':
row = layout.row(align=True)
is_packed = ('picker' in ob.data.rig_picker.keys())
sub_row = row.row(align=True)
sub_row.prop(ob.data.rig_picker, 'source', text='Picker')
sub_row.enabled = not is_packed
row.operator('rigpicker.pack_picker', icon='PACKAGE' if is_packed else 'UGLYPACKAGE', text='')
col = layout.column(align=True)
row = col.row(align=True)
row.operator('rigpicker.create_shape', icon='MESH_DATA', text='Create shape')
row.operator('rigpicker.mirror_shape', icon='ARROW_LEFTRIGHT', text='Mirror shape')
col.operator('rigpicker.name_from_bone', icon='SORTALPHA' , text='Name from bones')
col.prop(scn.rig_picker, 'use_pick_bone', icon='EYEDROPPER', text='Auto bone assign')
if ob.type !='ARMATURE':
box = layout.box()
col = box.column(align=False)
material_row = col.row(align=True)
material_row.operator('rigpicker.remove_mat', icon='REMOVE', text='')
material_row.operator('rigpicker.add_mat', icon='ADD', text='')
mat = False
if ob.type in ('MESH', 'CURVE', 'FONT') and ob.data.materials:
mat = get_mat(ob)
if mat and mat.node_tree:
emission_nodes = [n for n in mat.node_tree.nodes if n.type =='EMISSION']
if emission_nodes:
material_row.prop(emission_nodes[0].inputs[0], 'default_value', text='')
mat = True
if not mat:
material_row.label(text='No Material')
material_row.operator('rigpicker.eyedropper_mat', icon='EYEDROPPER', text='')
shape_type_row = col.row(align=True)
shape_type_row.prop(ob.rig_picker,'shape_type',expand = True)
shape_type_row.operator('rigpicker.select_shape_type', text='', icon='RESTRICT_SELECT_OFF')
if ob.rig_picker.shape_type == 'OPERATOR':
op_row = col.row(align=True)
op_row.prop(ob.rig_picker, 'operator', text='')
op_row.operator('rigpicker.operator_selector', text='', icon='COLLAPSEMENU')
if ob.rig_picker.operator:
col.prop(ob.rig_picker, 'name', text='Tooltip')
col.prop(ob.rig_picker,'shortcut', text='Shortcut')
else:
col.prop(ob.rig_picker, 'name', text='Tooltip')
'''
if ob.rig_picker.operator:
op = get_operator_from_id(ob.rig_picker.idname)
if op:
doc = re.findall(r'\(([^\)]+)\)', op.__doc__)[0]
else:
doc = 'Operator not found'
col.prop(ob.rig_picker,'name', text='Tooltip')
if op:
col.prop(ob.rig_picker,'shortcut', text='Shortcut')
col.prop(ob.rig_picker,'arguments', text='')
col.label(text=doc)
else:
col.label(text=doc)
'''
if ob.rig_picker.shape_type == 'BONE':
if scn.rig_picker.rig:
col.prop_search(ob.rig_picker, 'name', scn.rig_picker.rig.pose, 'bones', text='Bone')
#layout.separator()
layout.prop(scn.rig_picker, 'destination', text='Filepath')
layout.operator('rigpicker.save_picker', icon='PASTEDOWN', text='Save Picker')
classes = (
RP_PT_picker_maker_panel,
)
register, unregister = bpy.utils.register_classes_factory(classes)

13
properties.py
View File

@ -1,7 +1,5 @@
import bpy import bpy
from bpy.props import (EnumProperty, StringProperty, PointerProperty, BoolProperty, from bpy.props import EnumProperty, StringProperty, PointerProperty, BoolProperty
CollectionProperty, IntProperty)
import inspect import inspect
''' '''
@ -24,15 +22,9 @@ def bones_item(self,context):
items.append((bone.name,bone.name,'')) items.append((bone.name,bone.name,''))
return items return items
class RP_PG_picker_source(bpy.types.PropertyGroup):
source : StringProperty(subtype='FILE_PATH')
class RP_PG_armature_ui_settings(bpy.types.PropertyGroup): class RP_PG_armature_ui_settings(bpy.types.PropertyGroup):
name: StringProperty() name: StringProperty()
source: StringProperty(subtype='FILE_PATH') source: StringProperty(subtype='FILE_PATH')
sources: CollectionProperty(type=RP_PG_picker_source)
class RP_PG_object_ui_settings(bpy.types.PropertyGroup): class RP_PG_object_ui_settings(bpy.types.PropertyGroup):
@ -45,7 +37,6 @@ class RP_PG_object_ui_settings(bpy.types.PropertyGroup):
class RP_PG_scene_ui_settings(bpy.types.PropertyGroup): class RP_PG_scene_ui_settings(bpy.types.PropertyGroup):
enabled : BoolProperty(default=False)
rig: PointerProperty(type=bpy.types.Object) rig: PointerProperty(type=bpy.types.Object)
canvas: PointerProperty(type=bpy.types.Object) canvas: PointerProperty(type=bpy.types.Object)
symmetry: PointerProperty(type=bpy.types.Object) symmetry: PointerProperty(type=bpy.types.Object)
@ -76,7 +67,6 @@ class RP_OT_operator_selector(bpy.types.Operator):
classes = ( classes = (
RP_PG_picker_source,
RP_PG_object_ui_settings, RP_PG_object_ui_settings,
RP_PG_scene_ui_settings, RP_PG_scene_ui_settings,
RP_PG_armature_ui_settings, RP_PG_armature_ui_settings,
@ -90,7 +80,6 @@ def register():
bpy.types.Armature.rig_picker = bpy.props.PointerProperty(type=RP_PG_armature_ui_settings) bpy.types.Armature.rig_picker = bpy.props.PointerProperty(type=RP_PG_armature_ui_settings)
bpy.types.Object.rig_picker = bpy.props.PointerProperty(type=RP_PG_object_ui_settings) bpy.types.Object.rig_picker = bpy.props.PointerProperty(type=RP_PG_object_ui_settings)
bpy.types.Scene.rig_picker = bpy.props.PointerProperty(type=RP_PG_scene_ui_settings) bpy.types.Scene.rig_picker = bpy.props.PointerProperty(type=RP_PG_scene_ui_settings)
bpy.types.Collection.rig_picker = bpy.props.PointerProperty(type=RP_PG_scene_ui_settings)
def unregister(): def unregister():
del bpy.types.Scene.rig_picker del bpy.types.Scene.rig_picker

BIN
resources/KohinoorZerone-Zero.otf
View File

Binary file not shown.

19
shaders/dash_shader.frag
View File

@ -1,19 +0,0 @@
flat in vec2 startPos;
in vec2 vertPos;
out vec4 fragColor;
uniform vec4 color;
uniform float dashSize;
uniform float gapSize;
void main()
{
vec2 dir = (vertPos.xy - startPos.xy);
float dist = length(dir);
if (fract(dist / (dashSize + gapSize)) > dashSize/(dashSize + gapSize))
discard;
fragColor = color;
}

15
shaders/dash_shader.vert
View File

@ -1,15 +0,0 @@
layout (location = 0) in vec2 pos;
flat out vec2 startPos;
out vec2 vertPos;
uniform mat4 viewMatrix;
void main()
{
vec4 outPos = viewMatrix * vec4(pos.x, pos.y, 0.0, 1.0);
gl_Position = outPos;
vertPos = pos.xy / outPos.w;
startPos = vertPos;
}

144
ui.py
View File

@ -1,144 +0,0 @@
import bpy
from bpy.types import UIList
#import collections
#import inspect
from .core.addon_utils import get_operator_from_id, get_picker_collection
from .core.bl_utils import get_mat
import re
# class RP_UL_picker_source(UIList):
# def draw_item(self, context, layout, data, item, _icon, _active_data, _active_propname, _index):
# ob = context.object
# row = layout.row(align=True)
# is_packed = ('picker' in ob.data.rig_picker.keys())
# sub_row = row.row(align=True)
# sub_row.prop(item, 'source', text='')
# sub_row.enabled = not is_packed
# #row.operator('rigpicker.pack_picker', icon='PACKAGE' if is_packed else 'UGLYPACKAGE', text='')
class RP_PT_picker_maker_panel(bpy.types.Panel):
bl_label = 'Rig Picker'
bl_category = 'Rigging'
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
@classmethod
def poll(cls, context):
return context.object
def draw_header_preset(self, context):
self.layout.operator('rigpicker.add_picker_collection', text="", icon='ADD', emboss=False)
def draw(self, context):
ob = context.object
scn = context.scene
collection = get_picker_collection(ob)
layout = self.layout
col = layout.column(align=False)
if collection:
col.prop_search(collection.rig_picker, 'rig', scn, 'objects', text='Rig ')
col.prop_search(collection.rig_picker, 'canvas', scn, 'objects', text='Canvas ')
col.prop_search(collection.rig_picker, 'symmetry', scn, 'objects', text='Symmetry ')
if ob.type == 'ARMATURE':
box = col.box()
box.enabled = not ob.data.library
col = box.column(align=False)
row = col.row(align=True)
row.separator(factor=0.5)
row.label(text="Sources")
is_packed = ('pickers' in ob.data.rig_picker.keys())
row.operator('rigpicker.pack_picker', icon='PACKAGE' if is_packed else 'UGLYPACKAGE', text='', emboss=False)
row.operator("rigpicker.add_picker_source", icon ='ADD', text="", emboss=False)
for i, item in enumerate(ob.data.rig_picker.sources):
row = col.row(align=True)
row.enabled = not is_packed
row.prop(item, 'source', text='')
row.operator("rigpicker.remove_picker_source", icon ='PANEL_CLOSE', text="", emboss=False).index=i
if collection:
#layout.separator()
layout.prop(collection.rig_picker, 'destination', text='Filepath')
layout.operator('rigpicker.save_picker', icon='PASTEDOWN', text='Save Picker')
class RP_PT_shape(bpy.types.Panel):
bl_label = 'Shape'
bl_category = 'Rigging'
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_parent_id = "RP_PT_picker_maker_panel"
def draw(self, context):
ob = context.object
scn = context.scene
collection = get_picker_collection(ob)
layout = self.layout
col = layout.column(align=False)
if collection:
#if context.collection and context.collection.rig_picker.enabled:
col = layout.column(align=True)
row = col.row(align=True)
row.operator('rigpicker.create_shape', icon='MESH_DATA', text='Create Shape')
row.operator('rigpicker.mirror_shape', icon='MOD_MIRROR', text='Mirror Shape')
col.operator('rigpicker.name_from_bone', icon='SORTALPHA' , text='Name From Bones')
col.prop(scn.rig_picker, 'use_pick_bone', icon='EYEDROPPER', text='Auto Bone Assign')
if ob.type != 'ARMATURE':
box = layout.box()
col = box.column(align=False)
material_row = col.row(align=True)
material_row.operator('rigpicker.remove_mat', icon='REMOVE', text='')
material_row.operator('rigpicker.add_mat', icon='ADD', text='')
mat = False
if ob.type in ('MESH', 'CURVE', 'FONT') and ob.data.materials:
mat = get_mat(ob)
if mat and mat.node_tree:
emission_nodes = [n for n in mat.node_tree.nodes if n.type =='EMISSION']
if emission_nodes:
material_row.prop(emission_nodes[0].inputs[0], 'default_value', text='')
mat = True
if not mat:
material_row.label(text='No Material')
material_row.operator('rigpicker.eyedropper_mat', icon='EYEDROPPER', text='')
shape_type_row = col.row(align=True)
shape_type_row.prop(ob.rig_picker,'shape_type',expand = True)
shape_type_row.operator('rigpicker.select_shape_type', text='', icon='RESTRICT_SELECT_OFF')
if ob.rig_picker.shape_type == 'OPERATOR':
op_row = col.row(align=True)
op_row.prop(ob.rig_picker, 'operator', text='')
op_row.operator('rigpicker.operator_selector', text='', icon='COLLAPSEMENU')
if ob.rig_picker.operator:
col.prop(ob.rig_picker, 'name', text='Tooltip')
col.prop(ob.rig_picker,'shortcut', text='Shortcut')
else:
col.prop(ob.rig_picker, 'name', text='Tooltip')
elif ob.rig_picker.shape_type == 'BONE':
if collection and collection.rig_picker.rig:
col.prop_search(ob.rig_picker, 'name', collection.rig_picker.rig.pose, 'bones', text='Bone')
classes = (
#RP_UL_picker_source,
RP_PT_picker_maker_panel,
RP_PT_shape
)
register, unregister = bpy.utils.register_classes_factory(classes)