A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using System;
2using UnityEditor.U2D.Common;
3using UnityEditor.U2D.Layout;
4using UnityEngine;
5using UnityEditor.ShortcutManagement;
6using UnityEngine.UIElements;
7
8namespace UnityEditor.U2D.Animation
9{
10 internal partial class SkinningModule
11 {
12 private LayoutOverlay m_LayoutOverlay;
13 private PoseToolbar m_PoseToolbar;
14 private BoneToolbar m_BoneToolbar;
15 private MeshToolbar m_MeshToolbar;
16 private WeightToolbar m_WeightToolbar;
17 private RigToolbar m_RigToolbar;
18
19 private InternalEditorBridge.ShortcutContext m_ShortcutContext;
20
21 private static SkinningModule GetModuleFromContext(ShortcutArguments args)
22 {
23 var sc = args.context as InternalEditorBridge.ShortcutContext;
24 if (sc == null)
25 return null;
26
27 return sc.context as SkinningModule;
28 }
29
30 [Shortcut(ShortcutIds.toggleToolText, typeof(InternalEditorBridge.ShortcutContext), KeyCode.BackQuote, ShortcutModifiers.Shift)]
31 private static void CollapseToolbar(ShortcutArguments args)
32 {
33 var sm = GetModuleFromContext(args);
34 if (sm != null)
35 {
36 SkinningModuleSettings.compactToolBar = !SkinningModuleSettings.compactToolBar;
37 }
38 }
39
40 [Shortcut(ShortcutIds.restoreBindPose, typeof(InternalEditorBridge.ShortcutContext), KeyCode.Alpha1, ShortcutModifiers.Shift)]
41 private static void DisablePoseModeKey(ShortcutArguments args)
42 {
43 var sm = GetModuleFromContext(args);
44 if (sm != null && !sm.spriteEditor.editingDisabled)
45 {
46 var effectiveSkeleton = sm.skinningCache.GetEffectiveSkeleton(sm.skinningCache.selectedSprite);
47 if (effectiveSkeleton != null && effectiveSkeleton.isPosePreview)
48 {
49 using (sm.skinningCache.UndoScope(TextContent.restorePose))
50 {
51 sm.skinningCache.RestoreBindPose();
52 sm.skinningCache.events.shortcut.Invoke("#1");
53 }
54 }
55 }
56 }
57
58 [Shortcut(ShortcutIds.toggleCharacterMode, typeof(InternalEditorBridge.ShortcutContext), KeyCode.Alpha2, ShortcutModifiers.Shift)]
59 private static void ToggleCharacterModeKey(ShortcutArguments args)
60 {
61 var sm = GetModuleFromContext(args);
62 if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.hasCharacter)
63 {
64 var tool = sm.skinningCache.GetTool(Tools.SwitchMode);
65
66 using (sm.skinningCache.UndoScope(TextContent.setMode))
67 {
68 if (tool.isActive)
69 tool.Deactivate();
70 else
71 tool.Activate();
72 }
73
74 sm.skinningCache.events.shortcut.Invoke("#2");
75 }
76 }
77
78 [Shortcut(ShortcutIds.previewPose, typeof(InternalEditorBridge.ShortcutContext), KeyCode.Q, ShortcutModifiers.Shift)]
79 private static void EditPoseKey(ShortcutArguments args)
80 {
81 var sm = GetModuleFromContext(args);
82 if (sm != null && !sm.spriteEditor.editingDisabled)
83 {
84 sm.SetSkeletonTool(Tools.EditPose);
85 sm.skinningCache.events.shortcut.Invoke("#q");
86 }
87 }
88
89 [Shortcut(ShortcutIds.characterPivot, typeof(InternalEditorBridge.ShortcutContext), KeyCode.T, ShortcutModifiers.Shift)]
90 private static void EditCharacterPivotKey(ShortcutArguments args)
91 {
92 var sm = GetModuleFromContext(args);
93 if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.mode == SkinningMode.Character)
94 {
95 sm.SetSkeletonTool(Tools.CharacterPivotTool);
96 sm.skinningCache.events.shortcut.Invoke("#t");
97 }
98 }
99
100 [Shortcut(ShortcutIds.editBone, typeof(InternalEditorBridge.ShortcutContext), KeyCode.W, ShortcutModifiers.Shift)]
101 private static void EditJointsKey(ShortcutArguments args)
102 {
103 var sm = GetModuleFromContext(args);
104 if (sm != null && !sm.spriteEditor.editingDisabled)
105 {
106 sm.SetSkeletonTool(Tools.EditJoints);
107 sm.skinningCache.events.shortcut.Invoke("#w");
108 }
109 }
110
111 [Shortcut(ShortcutIds.createBone, typeof(InternalEditorBridge.ShortcutContext), KeyCode.E, ShortcutModifiers.Shift)]
112 private static void CreateBoneKey(ShortcutArguments args)
113 {
114 var sm = GetModuleFromContext(args);
115 if (sm != null && !sm.spriteEditor.editingDisabled)
116 {
117 sm.SetSkeletonTool(Tools.CreateBone);
118 sm.skinningCache.events.shortcut.Invoke("#e");
119 }
120 }
121
122 [Shortcut(ShortcutIds.splitBone, typeof(InternalEditorBridge.ShortcutContext), KeyCode.R, ShortcutModifiers.Shift)]
123 private static void SplitBoneKey(ShortcutArguments args)
124 {
125 var sm = GetModuleFromContext(args);
126 if (sm != null && !sm.spriteEditor.editingDisabled)
127 {
128 sm.SetSkeletonTool(Tools.SplitBone);
129 sm.skinningCache.events.shortcut.Invoke("#r");
130 }
131 }
132
133 [Shortcut(ShortcutIds.autoGeometry, typeof(InternalEditorBridge.ShortcutContext), KeyCode.A, ShortcutModifiers.Shift)]
134 private static void GenerateGeometryKey(ShortcutArguments args)
135 {
136 var sm = GetModuleFromContext(args);
137 if (sm != null && !sm.spriteEditor.editingDisabled)
138 {
139 sm.SetMeshTool(Tools.GenerateGeometry);
140 sm.skinningCache.events.shortcut.Invoke("#a");
141 }
142 }
143
144 [Shortcut(ShortcutIds.editGeometry, typeof(InternalEditorBridge.ShortcutContext), KeyCode.S, ShortcutModifiers.Shift)]
145 private static void MeshSelectionKey(ShortcutArguments args)
146 {
147 var sm = GetModuleFromContext(args);
148 if (sm != null && !sm.spriteEditor.editingDisabled)
149 {
150 sm.SetMeshTool(Tools.EditGeometry);
151 sm.skinningCache.events.shortcut.Invoke("#s");
152 }
153 }
154
155 [Shortcut(ShortcutIds.createVertex, typeof(InternalEditorBridge.ShortcutContext), KeyCode.J, ShortcutModifiers.Shift)]
156 private static void CreateVertex(ShortcutArguments args)
157 {
158 var sm = GetModuleFromContext(args);
159 if (sm != null && !sm.spriteEditor.editingDisabled)
160 {
161 sm.SetMeshTool(Tools.CreateVertex);
162 sm.skinningCache.events.shortcut.Invoke("#d");
163 }
164 }
165
166 [Shortcut(ShortcutIds.createEdge, typeof(InternalEditorBridge.ShortcutContext), KeyCode.G, ShortcutModifiers.Shift)]
167 private static void CreateEdgeKey(ShortcutArguments args)
168 {
169 var sm = GetModuleFromContext(args);
170 if (sm != null && !sm.spriteEditor.editingDisabled)
171 {
172 sm.SetMeshTool(Tools.CreateEdge);
173 sm.skinningCache.events.shortcut.Invoke("#g");
174 }
175 }
176
177 [Shortcut(ShortcutIds.splitEdge, typeof(InternalEditorBridge.ShortcutContext), KeyCode.H, ShortcutModifiers.Shift)]
178 private static void SplitEdge(ShortcutArguments args)
179 {
180 var sm = GetModuleFromContext(args);
181 if (sm != null && !sm.spriteEditor.editingDisabled)
182 {
183 sm.SetMeshTool(Tools.SplitEdge);
184 sm.skinningCache.events.shortcut.Invoke("#h");
185 }
186 }
187
188 [Shortcut(ShortcutIds.autoWeights, typeof(InternalEditorBridge.ShortcutContext), KeyCode.Z, ShortcutModifiers.Shift)]
189 private static void GenerateWeightsKey(ShortcutArguments args)
190 {
191 var sm = GetModuleFromContext(args);
192 if (sm != null && !sm.spriteEditor.editingDisabled)
193 {
194 sm.SetWeightTool(Tools.GenerateWeights);
195 sm.skinningCache.events.shortcut.Invoke("#z");
196 }
197 }
198
199 [Shortcut(ShortcutIds.weightSlider, typeof(InternalEditorBridge.ShortcutContext), KeyCode.X, ShortcutModifiers.Shift)]
200 private static void WeightSliderKey(ShortcutArguments args)
201 {
202 var sm = GetModuleFromContext(args);
203 if (sm != null && !sm.spriteEditor.editingDisabled)
204 {
205 sm.SetWeightTool(Tools.WeightSlider);
206 sm.skinningCache.events.shortcut.Invoke("#x");
207 }
208 }
209
210 [Shortcut(ShortcutIds.weightBrush, typeof(InternalEditorBridge.ShortcutContext), KeyCode.N, ShortcutModifiers.Shift)]
211 private static void WeightBrushKey(ShortcutArguments args)
212 {
213 var sm = GetModuleFromContext(args);
214 if (sm != null && !sm.spriteEditor.editingDisabled)
215 {
216 sm.SetWeightTool(Tools.WeightBrush);
217 sm.skinningCache.events.shortcut.Invoke("#c");
218 }
219 }
220
221 [Shortcut(ShortcutIds.boneInfluence, typeof(InternalEditorBridge.ShortcutContext), KeyCode.V, ShortcutModifiers.Shift)]
222 private static void BoneInfluenceKey(ShortcutArguments args)
223 {
224 var sm = GetModuleFromContext(args);
225 if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.mode == SkinningMode.Character)
226 {
227 sm.SetWeightTool(Tools.BoneInfluence);
228 sm.skinningCache.events.shortcut.Invoke("#v");
229 }
230 }
231
232 [Shortcut(ShortcutIds.spriteInfluence, typeof(InternalEditorBridge.ShortcutContext), KeyCode.M, ShortcutModifiers.Shift)]
233 private static void SpriteInfluenceKey(ShortcutArguments args)
234 {
235 var sm = GetModuleFromContext(args);
236 if (sm != null && !sm.spriteEditor.editingDisabled && sm.skinningCache.mode == SkinningMode.Character)
237 {
238 sm.SetWeightTool(Tools.SpriteInfluence);
239 sm.skinningCache.events.shortcut.Invoke("#m");
240 }
241 }
242
243 [Shortcut(ShortcutIds.pastePanelWeights, typeof(InternalEditorBridge.ShortcutContext), KeyCode.B, ShortcutModifiers.Shift)]
244 private static void PastePanelKey(ShortcutArguments args)
245 {
246 var sm = GetModuleFromContext(args);
247 if (sm != null && !sm.spriteEditor.editingDisabled)
248 {
249 sm.TogglePasteTool();
250 sm.skinningCache.events.shortcut.Invoke("#b");
251 }
252 }
253
254 [Shortcut(ShortcutIds.visibilityPanel, typeof(InternalEditorBridge.ShortcutContext), KeyCode.P, ShortcutModifiers.Shift)]
255 private static void VisibilityPanelKey(ShortcutArguments args)
256 {
257 var sm = GetModuleFromContext(args);
258 if (sm != null && !sm.spriteEditor.editingDisabled)
259 {
260 sm.m_HorizontalToggleTools.ToggleVisibilityTool(sm.currentTool);
261 sm.skinningCache.events.shortcut.Invoke("#p");
262 }
263 }
264
265 private void AddMainUI(VisualElement mainView)
266 {
267 var visualTree = ResourceLoader.Load<VisualTreeAsset>("LayoutOverlay/LayoutOverlay.uxml");
268 VisualElement clone = visualTree.CloneTree();
269 m_LayoutOverlay = clone.Q<LayoutOverlay>("LayoutOverlay");
270
271 mainView.Add(m_LayoutOverlay);
272 m_LayoutOverlay.hasScrollbar = true;
273 m_LayoutOverlay.verticalToolbar.verticalScrollerVisibility = ScrollerVisibility.Hidden;
274 m_LayoutOverlay.StretchToParentSize();
275
276 CreatePoseToolbar();
277 CreateBoneToolbar();
278 CreateMeshToolbar();
279 CreateWeightToolbar();
280 CreateRigToolbar();
281
282 m_ShortcutContext = new InternalEditorBridge.ShortcutContext()
283 {
284 isActive = isFocused,
285 context = this
286 };
287 InternalEditorBridge.RegisterShortcutContext(m_ShortcutContext);
288 InternalEditorBridge.AddEditorApplicationProjectLoadedCallback(OnProjectLoaded);
289 }
290
291 private void OnProjectLoaded()
292 {
293 if (m_ShortcutContext != null)
294 InternalEditorBridge.RegisterShortcutContext(m_ShortcutContext);
295 }
296
297 private void DoViewGUI()
298 {
299 if (spriteEditor.editingDisabled == m_BoneToolbar.enabledSelf)
300 {
301 m_BoneToolbar.SetEnabled(!spriteEditor.editingDisabled);
302 m_MeshToolbar.SetEnabled(!spriteEditor.editingDisabled);
303 m_WeightToolbar.SetEnabled(!spriteEditor.editingDisabled);
304 }
305
306 if (spriteEditor.editingDisabled == m_LayoutOverlay.rightOverlay.enabledSelf)
307 {
308 m_LayoutOverlay.rightOverlay.SetEnabled(!spriteEditor.editingDisabled);
309 m_LayoutOverlay.rightOverlay.visible = !spriteEditor.editingDisabled;
310 }
311
312 m_PoseToolbar.UpdateResetButtonState();
313 m_RigToolbar.UpdatePasteButtonEnabledState();
314 }
315
316 private bool isFocused()
317 {
318 return spriteEditor != null && (EditorWindow.focusedWindow == spriteEditor as EditorWindow);
319 }
320
321 private void CreatePoseToolbar()
322 {
323 m_PoseToolbar = PoseToolbar.GenerateFromUXML();
324 m_PoseToolbar.Setup(skinningCache);
325 m_LayoutOverlay.verticalToolbar.AddToContainer(m_PoseToolbar);
326
327 m_PoseToolbar.SetMeshTool += SetMeshTool;
328 m_PoseToolbar.SetSkeletonTool += SetSkeletonTool;
329 m_PoseToolbar.ActivateEditPoseTool += ActivateEditPoseTool;
330 m_PoseToolbar.SetEnabled(!spriteEditor.editingDisabled);
331 }
332
333 private void CreateBoneToolbar()
334 {
335 m_BoneToolbar = BoneToolbar.GenerateFromUXML();
336 m_BoneToolbar.Setup(skinningCache);
337 m_LayoutOverlay.verticalToolbar.AddToContainer(m_BoneToolbar);
338
339 m_BoneToolbar.SetSkeletonTool += SetSkeletonTool;
340 m_BoneToolbar.SetEnabled(!spriteEditor.editingDisabled);
341 }
342
343 private void CreateMeshToolbar()
344 {
345 m_MeshToolbar = MeshToolbar.GenerateFromUXML();
346 m_MeshToolbar.skinningCache = skinningCache;
347 m_LayoutOverlay.verticalToolbar.AddToContainer(m_MeshToolbar);
348
349 m_MeshToolbar.SetMeshTool += SetMeshTool;
350 m_MeshToolbar.SetEnabled(!spriteEditor.editingDisabled);
351 }
352
353 private void CreateWeightToolbar()
354 {
355 m_WeightToolbar = WeightToolbar.GenerateFromUXML();
356 m_WeightToolbar.skinningCache = skinningCache;
357 m_LayoutOverlay.verticalToolbar.AddToContainer(m_WeightToolbar);
358 m_WeightToolbar.SetWeightTool += SetWeightTool;
359 m_WeightToolbar.SetEnabled(!spriteEditor.editingDisabled);
360 }
361
362 private void CreateRigToolbar()
363 {
364 m_RigToolbar = RigToolbar.GenerateFromUXML();
365 m_RigToolbar.skinningCache = skinningCache;
366 m_LayoutOverlay.verticalToolbar.AddToContainer(m_RigToolbar);
367
368 m_RigToolbar.ActivateCopyTool += ActivateCopyTool;
369 m_RigToolbar.TogglePasteTool += TogglePasteTool;
370 m_RigToolbar.SetEnabled(!spriteEditor.editingDisabled);
371 }
372
373 private void ActivateEditPoseTool()
374 {
375 var tool = skinningCache.GetTool(Tools.EditPose);
376 if (currentTool == tool)
377 return;
378
379 using (skinningCache.UndoScope(TextContent.setTool))
380 {
381 ActivateTool(tool);
382 }
383 }
384
385 private void SetSkeletonTool(Tools toolType)
386 {
387 var tool = skinningCache.GetTool(toolType) as SkeletonToolWrapper;
388
389 if (currentTool == tool)
390 return;
391
392 using (skinningCache.UndoScope(TextContent.setTool))
393 {
394 ActivateTool(tool);
395
396 if (tool.editBindPose)
397 skinningCache.RestoreBindPose();
398 }
399 }
400
401 private void SetMeshTool(Tools toolType)
402 {
403 var tool = skinningCache.GetTool(toolType);
404
405 if (currentTool == tool)
406 return;
407
408 using (skinningCache.UndoScope(TextContent.setTool))
409 {
410 ActivateTool(tool);
411 skinningCache.RestoreBindPose();
412 UnselectBones();
413 }
414 }
415
416 private void SetWeightTool(Tools toolType)
417 {
418 var tool = skinningCache.GetTool(toolType);
419
420 if (currentTool == tool)
421 return;
422
423 using (skinningCache.UndoScope(TextContent.setTool))
424 {
425 ActivateTool(tool);
426 }
427 }
428
429 private void ActivateCopyTool()
430 {
431 var tool = skinningCache.GetTool(Tools.CopyPaste) as CopyTool;
432 tool.OnCopyActivated();
433 }
434
435 private void TogglePasteTool()
436 {
437 var tool = skinningCache.GetTool(Tools.CopyPaste) as CopyTool;
438 if (!tool.isActive)
439 ActivateTool(tool);
440 else if (previousTool != null)
441 ActivateTool(previousTool);
442 }
443
444 private void StorePreviousTool()
445 {
446 if (currentTool is CopyTool || currentTool is VisibilityTool)
447 return;
448
449 previousTool = currentTool;
450 }
451
452 private void ActivateTool(BaseTool tool)
453 {
454 StorePreviousTool();
455
456 m_ModuleToolGroup.ActivateTool(tool);
457 UpdateToggleState();
458 skinningCache.events.toolChanged.Invoke(tool);
459 }
460
461 private void UnselectBones()
462 {
463 skinningCache.skeletonSelection.Clear();
464 skinningCache.events.boneSelectionChanged.Invoke();
465 }
466
467 private void UpdateToggleState()
468 {
469 Debug.Assert(m_PoseToolbar != null);
470 Debug.Assert(m_BoneToolbar != null);
471 Debug.Assert(m_MeshToolbar != null);
472 Debug.Assert(m_WeightToolbar != null);
473
474 m_PoseToolbar.UpdateToggleState();
475 m_BoneToolbar.UpdateToggleState();
476 m_MeshToolbar.UpdateToggleState();
477 m_WeightToolbar.UpdateToggleState();
478 m_RigToolbar.UpdatePasteButtonCheckedState();
479 }
480
481 private void RemoveMainUI(VisualElement mainView)
482 {
483 InternalEditorBridge.RemoveEditorApplicationProjectLoadedCallback(OnProjectLoaded);
484 InternalEditorBridge.UnregisterShortcutContext(m_ShortcutContext);
485 }
486 }
487}