AblativeAbsolute/rimworld-animation-studio
1
0
Fork 0
mirror of https://gitgud.io/AbstractConcept/rimworld-animation-studio.git synced 2024-08-15 00:43:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Initial commit

Browse source
This commit is contained in:
AbstractConcept 2022-09-13 00:36:34 -05:00
commit 3c7cc0c973
8391 changed files with 704313 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

13
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/IMeshPreviewBehaviour.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using UnityEngine;
namespace UnityEditor.U2D.Animation
{
internal interface IMeshPreviewBehaviour
{
float GetWeightMapOpacity(SpriteCache sprite);
bool DrawWireframe(SpriteCache sprite);
bool Overlay(SpriteCache sprite);
bool OverlayWireframe(SpriteCache sprite);
}
}

11
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/IMeshPreviewBehaviour.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: aeeab8c4e75a1e8419b0eed0716d850a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

73
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/MeshPreviewBehaviour.cs Normal file
View file

@ -0,0 +1,73 @@
using System;
using UnityEngine;
namespace UnityEditor.U2D.Animation
{
internal class DefaultPreviewBehaviour : IMeshPreviewBehaviour
{
public float GetWeightMapOpacity(SpriteCache sprite)
{
return 0f;
}
public bool DrawWireframe(SpriteCache sprite)
{
return false;
}
public bool Overlay(SpriteCache sprite)
{
return false;
}
public bool OverlayWireframe(SpriteCache sprite)
{
return sprite.IsVisible() && sprite.skinningCache.selectedSprite == sprite;
}
}
internal class MeshPreviewBehaviour : IMeshPreviewBehaviour
{
public bool showWeightMap { get; set; }
public bool drawWireframe { get; set; }
public bool overlaySelected { get; set; }
public float GetWeightMapOpacity(SpriteCache sprite)
{
var skinningCache = sprite.skinningCache;
if (showWeightMap)
{
if (skinningCache.selectedSprite == sprite || skinningCache.selectedSprite == null)
return VisibilityToolSettings.meshOpacity;
}
return 0f;
}
public bool DrawWireframe(SpriteCache sprite)
{
var skinningCache = sprite.skinningCache;
if (drawWireframe)
return skinningCache.selectedSprite == null;
return false;
}
public bool Overlay(SpriteCache sprite)
{
var skinningCache = sprite.skinningCache;
if (overlaySelected && skinningCache.selectedSprite == sprite)
return true;
return false;
}
public bool OverlayWireframe(SpriteCache sprite)
{
return sprite.IsVisible() && sprite.skinningCache.selectedSprite == sprite;
}
}
}

11
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/MeshPreviewBehaviour.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8f503e223cd1e624d9aae16f915047f3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

331
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/MeshPreviewTool.cs Normal file
View file

@ -0,0 +1,331 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace UnityEditor.U2D.Animation
{
internal class MeshPreviewTool : BaseTool
{
[SerializeField]
private Material m_Material;
private List<SpriteCache> m_Sprites;
private IMeshPreviewBehaviour m_DefaultPreviewBehaviour = new DefaultPreviewBehaviour();
public IMeshPreviewBehaviour previewBehaviourOverride { get; set; }
public override IMeshPreviewBehaviour previewBehaviour
{
get
{
if (previewBehaviourOverride != null)
return previewBehaviourOverride;
return m_DefaultPreviewBehaviour;
}
}
internal override void OnCreate()
{
m_Material = new Material(Shader.Find("Hidden/SkinningModule-GUITextureClip"));
m_Material.hideFlags = HideFlags.DontSave;
}
internal override void OnDestroy()
{
base.OnDestroy();
Debug.Assert(m_Material != null);
DestroyImmediate(m_Material);
}
protected override void OnActivate()
{
m_Sprites = new List<SpriteCache>(skinningCache.GetSprites());
DirtyMeshesAll();
skinningCache.events.meshChanged.AddListener(MeshChanged);
skinningCache.events.characterPartChanged.AddListener(CharacterPartChanged);
skinningCache.events.skeletonPreviewPoseChanged.AddListener(SkeletonChanged);
skinningCache.events.skeletonBindPoseChanged.AddListener(SkeletonChanged);
skinningCache.events.skinningModeChanged.AddListener(SkinningModuleModeChanged);
}
protected override void OnDeactivate()
{
skinningCache.events.meshChanged.RemoveListener(MeshChanged);
skinningCache.events.skeletonPreviewPoseChanged.RemoveListener(SkeletonChanged);
skinningCache.events.skeletonBindPoseChanged.RemoveListener(SkeletonChanged);
skinningCache.events.skinningModeChanged.RemoveListener(SkinningModuleModeChanged);
}
protected override void OnGUI()
{
Prepare();
if (Event.current.type == EventType.Repaint)
{
//DrawDefaultSpriteMeshes();
DrawSpriteMeshes();
}
}
public void DrawOverlay()
{
if (Event.current.type != EventType.Repaint)
return;
if (skinningCache.mode == SkinningMode.SpriteSheet)
{
foreach (var sprite in m_Sprites)
{
if (previewBehaviour.Overlay(sprite))
DrawSpriteMesh(sprite);
}
}
else
{
var character = skinningCache.character;
Debug.Assert(character != null);
var parts = character.parts;
foreach (var part in parts)
{
if (part.isVisible && previewBehaviour.Overlay(part.sprite))
DrawSpriteMesh(part.sprite);
}
}
}
public void OverlayWireframe()
{
if (Event.current.type != EventType.Repaint)
return;
foreach (var sprite in m_Sprites)
if (previewBehaviour.OverlayWireframe(sprite))
DrawWireframe(sprite);
}
private void CharacterPartChanged(CharacterPartCache characterPart)
{
var meshPreview = characterPart.sprite.GetMeshPreview();
Debug.Assert(meshPreview != null);
meshPreview.SetSkinningDirty();
}
private void MeshChanged(MeshCache mesh)
{
var meshPreview = mesh.sprite.GetMeshPreview();
Debug.Assert(meshPreview != null);
meshPreview.SetMeshDirty();
}
private void SkeletonChanged(SkeletonCache skeleton)
{
DirtySkinningAll();
}
private void SkinningModuleModeChanged(SkinningMode mode)
{
DirtyMeshesAll();
}
private void DirtyMeshesAll()
{
foreach (var sprite in m_Sprites)
{
var meshPreview = sprite.GetMeshPreview();
if (meshPreview != null)
meshPreview.SetMeshDirty();
}
}
private void DirtySkinningAll()
{
foreach (var sprite in m_Sprites)
{
var meshPreview = sprite.GetMeshPreview();
Debug.Assert(meshPreview != null);
meshPreview.SetSkinningDirty();
}
}
private void Prepare()
{
foreach (var sprite in m_Sprites)
{
var meshPreview = sprite.GetMeshPreview();
Debug.Assert(meshPreview != null);
meshPreview.enableSkinning = true;
meshPreview.Prepare();
}
}
private void DrawDefaultSpriteMeshes()
{
Debug.Assert(Event.current.type == EventType.Repaint);
if (skinningCache.mode == SkinningMode.SpriteSheet)
{
foreach (var sprite in m_Sprites)
DrawDefaultSpriteMesh(sprite);
}
else
{
var character = skinningCache.character;
Debug.Assert(character != null);
var parts = character.parts;
foreach (var part in parts)
{
if (part.isVisible)
DrawDefaultSpriteMesh(part.sprite);
}
}
}
private void DrawDefaultSpriteMesh(SpriteCache sprite)
{
Debug.Assert(m_Material != null);
var meshPreview = sprite.GetMeshPreview();
var meshCache = sprite.GetMesh();
var skeleton = skinningCache.GetEffectiveSkeleton(sprite);
Debug.Assert(meshPreview != null);
if (meshPreview.canSkin == false || skeleton.isPosePreview == false)
{
m_Material.mainTexture = meshCache.textureDataProvider.texture;
m_Material.SetFloat("_Opacity", 1f);
m_Material.SetFloat("_VertexColorBlend", 0f);
m_Material.color = new Color(1f, 1f, 1f, 1f);
DrawingUtility.DrawMesh(meshPreview.defaultMesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
}
}
private void DrawSpriteMeshes()
{
Debug.Assert(Event.current.type == EventType.Repaint);
if (skinningCache.mode == SkinningMode.SpriteSheet)
{
foreach (var sprite in m_Sprites)
{
if (previewBehaviour.Overlay(sprite))
continue;
DrawSpriteMesh(sprite);
}
}
else
{
var character = skinningCache.character;
Debug.Assert(character != null);
var parts = character.parts;
var selected = skinningCache.selectedSprite;
var selectedVisible = false;
foreach (var part in parts)
{
if (previewBehaviour.Overlay(part.sprite))
continue;
if (part.sprite == selected)
selectedVisible = part.isVisible;
else if (part.isVisible)
DrawSpriteMesh(part.sprite);
}
if (selectedVisible && selected != null)
DrawSpriteMesh(selected);
}
}
private void DrawSpriteMesh(SpriteCache sprite)
{
var weightMapOpacity = previewBehaviour.GetWeightMapOpacity(sprite);
DrawSpriteMesh(sprite, weightMapOpacity);
if (previewBehaviour.DrawWireframe(sprite))
DrawWireframe(sprite);
}
private void DrawSpriteMesh(SpriteCache sprite, float weightMapOpacity)
{
Debug.Assert(m_Material != null);
var meshPreview = sprite.GetMeshPreview();
var meshCache = sprite.GetMesh();
Debug.Assert(meshPreview != null);
if (meshPreview.mesh == null || meshPreview.mesh.vertexCount == 0)
{
DrawDefaultSpriteMesh(sprite);
}
else
{
m_Material.mainTexture = meshCache.textureDataProvider.texture;
m_Material.SetFloat("_Opacity", 1f);
m_Material.SetFloat("_VertexColorBlend", weightMapOpacity);
m_Material.color = Color.white;
DrawingUtility.DrawMesh(meshPreview.mesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
}
}
private void DrawSelectedSpriteWeightMap()
{
var selectedSprite = skinningCache.selectedSprite;
if (selectedSprite != null)
{
var opacity = GetWeightOpacityFromCurrentTool();
if (opacity > 0f)
DrawSpriteMesh(selectedSprite, opacity);
}
}
private float GetWeightOpacityFromCurrentTool()
{
return IsWeightTool() ? VisibilityToolSettings.meshOpacity : 0f;
}
private bool IsWeightTool()
{
var currentTool = skinningCache.selectedTool;
if (currentTool == skinningCache.GetTool(Tools.WeightSlider) ||
currentTool == skinningCache.GetTool(Tools.WeightBrush) ||
currentTool == skinningCache.GetTool(Tools.BoneInfluence) ||
currentTool == skinningCache.GetTool(Tools.GenerateWeights))
return true;
return false;
}
private void DrawWireframe(SpriteCache sprite)
{
Debug.Assert(Event.current.type == EventType.Repaint);
Debug.Assert(sprite != null);
var meshPreview = sprite.GetMeshPreview();
Debug.Assert(meshPreview != null);
m_Material.mainTexture = null;
m_Material.SetFloat("_Opacity", 0.35f);
m_Material.SetFloat("_VertexColorBlend", 0f);
m_Material.color = Color.white;
GL.wireframe = true;
DrawingUtility.DrawMesh(meshPreview.mesh, m_Material, sprite.GetLocalToWorldMatrixFromMode());
GL.wireframe = false;
}
}
}

11
Library/PackageCache/com.unity.2d.animation@3.2.6/Editor/SkinningModule/MeshPreviewTool/MeshPreviewTool.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 90e762d3b06944889a5d95fc12a8db68
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: