public void Create(ISpriteEditor spriteEditor, ISkinningCachePersistentState state)
{
Clear();
var dataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
var boneProvider = spriteEditor.GetDataProvider <ISpriteBoneDataProvider>();
var meshProvider = spriteEditor.GetDataProvider <ISpriteMeshDataProvider>();
var spriteRects = dataProvider.GetSpriteRects();
var textureProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_State = state;
m_State.lastTexture = textureProvider.texture;
for (var i = 0; i < spriteRects.Length; i++)
{
var spriteRect = spriteRects[i];
var sprite = CreateSpriteCache(spriteRect);
CreateSkeletonCache(sprite, boneProvider);
CreateMeshCache(sprite, meshProvider, textureProvider);
CreateMeshPreviewCache(sprite);
}
CreateCharacter(spriteEditor);
CreateSpriteLibrary(spriteEditor);
}
public void TestSetup()
{
m_BoneDataProvider = Substitute.For <ISpriteBoneDataProvider>();
m_SpriteEditor = Substitute.For <ISpriteEditor>();
m_SR1 = new SpriteRect();
m_SR2 = new SpriteRect();
m_SR1.spriteID = new GUID()
{
};
List <SpriteBone> bones1 = new List <SpriteBone>();
bones1.Add(new SpriteBone()
{
name = "root1", parentId = -1, rotation = Quaternion.identity
});
m_BoneDataProvider.GetBones(m_SR1.spriteID).Returns(bones1);
List <SpriteBone> bones2 = new List <SpriteBone>();
bones2.Add(new SpriteBone()
{
name = "root2", parentId = -1, rotation = Quaternion.identity
});
m_BoneDataProvider.GetBones(m_SR2.spriteID).Returns(bones2);
m_SpriteEditor.GetDataProvider <ISpriteBoneDataProvider>().Returns(m_BoneDataProvider);
m_Module = new BoneSpriteEditorModule();
var prop = m_Module.GetType().GetProperty("spriteEditor");
prop.SetValue(m_Module, m_SpriteEditor, null);
}
protected SpriteFrameModuleBase(string name, ISpriteEditor sw, IEventSystem es, IUndoSystem us, IAssetDatabase ad)
{
spriteEditor = sw;
eventSystem = es;
undoSystem = us;
assetDatabase = ad;
m_ModuleName = name;
}
protected SpriteFrameModuleBase(string name, ISpriteEditor sw, IEventSystem es, IUndoSystem us, IAssetDatabase ad)
{
this.spriteEditor = sw;
this.eventSystem = es;
this.undoSystem = us;
this.assetDatabase = ad;
this.moduleName = name;
}
void CreateSpriteLibrary(ISpriteEditor spriteEditor)
{
var dataProvider = spriteEditor.GetDataProvider <ISpriteLibDataProvider>();
if (dataProvider != null)
{
m_SpriteCategoryList = CreateCache <SpriteCategoryListCacheObject>();
m_SpriteCategoryList.CopyFrom(dataProvider.GetSpriteCategoryList());
}
}
public SpriteOutlineRenderer(ISpriteEditor spriteEditor, SkinningEvents eventSystem)
{
m_BitMaskMaterial = new Material(Shader.Find("com.unity3d.animation/SpriteBitmask"));
m_BitMaskMaterial.hideFlags = HideFlags.HideAndDontSave;
m_OutlineMaterial = new Material(Shader.Find("com.unity3d.animation/SpriteOutline"));
m_OutlineMaterial.hideFlags = HideFlags.HideAndDontSave;
m_SpriteEditor = spriteEditor;
m_EventSystem = eventSystem;
m_EventSystem.meshPreviewChanged.AddListener(OnMeshPreviewChanged);
m_EventSystem.selectedSpriteChanged.AddListener(OnSelectionChanged);
CheckDataProviderChanged();
}
public SpriteOutlineModule(ISpriteEditor sem, IEventSystem es, IUndoSystem us, IAssetDatabase ad, IGUIUtility gu, IShapeEditorFactory sef, ITexture2D outlineTexture)
{
this.spriteEditorWindow = sem;
this.undoSystem = us;
this.eventSystem = es;
this.assetDatabase = ad;
this.guiUtility = gu;
this.shapeEditorFactory = sef;
this.m_OutlineTexture = outlineTexture;
this.m_ShapeSelectionUI = new ShapeEditorRectSelectionTool(gu);
this.m_ShapeSelectionUI.RectSelect += new Action <Rect, ShapeEditor.SelectionType>(this.RectSelect);
this.m_ShapeSelectionUI.ClearSelection += new Action(this.ClearSelection);
}
public SpriteOutlineModule(ISpriteEditor sem, IEventSystem es, IUndoSystem us, IAssetDatabase ad, IGUIUtility gu, IShapeEditorFactory sef, ITexture2D outlineTexture)
{
spriteEditorWindow = sem;
undoSystem = us;
eventSystem = es;
assetDatabase = ad;
guiUtility = gu;
shapeEditorFactory = sef;
m_OutlineTexture = outlineTexture;
m_ShapeSelectionUI = new ShapeEditorRectSelectionTool(gu);
m_ShapeSelectionUI.RectSelect += RectSelect;
m_ShapeSelectionUI.ClearSelection += ClearSelection;
}
private void CreateCharacter(ISpriteEditor spriteEditor)
{
var characterProvider = spriteEditor.GetDataProvider <ICharacterDataProvider>();
if (characterProvider != null)
{
var characterData = characterProvider.GetCharacterData();
var characterParts = new List <CharacterPartCache>();
m_Character = CreateCache <CharacterCache>();
var skeleton = CreateCache <SkeletonCache>();
skeleton.SetBones(CreateBoneCacheFromSpriteBones(characterData.bones, 1.0f));
skeleton.position = Vector3.zero;
var bones = skeleton.bones;
foreach (var p in characterData.parts)
{
var spriteBones = p.bones != null?p.bones.ToList() : new List <int>();
var characterPartBones = spriteBones.ConvertAll(i => bones[i]).ToArray();
var characterPart = CreateCache <CharacterPartCache>();
var positionInt = p.spritePosition.position;
characterPart.position = new Vector2(positionInt.x, positionInt.y);
characterPart.sprite = GetSprite(p.spriteId);
characterPart.bones = characterPartBones;
var mesh = characterPart.sprite.GetMesh();
if (mesh != null)
{
mesh.SetCompatibleBoneSet(characterPartBones);
}
characterParts.Add(characterPart);
m_CharacterPartMap.Add(characterPart.sprite, characterPart);
}
m_Character.parts = characterParts.ToArray();
m_Character.skeleton = skeleton;
m_Character.dimension = characterData.dimension;
CreateSpriteSheetSkeletons();
}
}
private Texture GenerateOutlineTexture(ISpriteEditor spriteEditor, SpriteCache spriteCache, RenderTexture reuseRT)
{
if (spriteCache != null && spriteCache.textureRect.width != 0 && spriteCache.textureRect.height != 0)
{
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::GenerateOutlineTexture");
var mesh = GetMesh(spriteCache);
var b = mesh.bounds;
if (reuseRT == null)
{
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::CreateRTNew");
reuseRT = new RenderTexture((int)b.size.x, (int)b.size.y, 24, RenderTextureFormat.ARGBHalf);
UnityEngine.Profiling.Profiler.EndSample();
}
else if (reuseRT.width != (int)b.size.x || reuseRT.height != (int)b.size.y)
{
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::CreateRTReuse");
Object.DestroyImmediate(reuseRT);
reuseRT = new RenderTexture((int)b.size.x, (int)b.size.y, 24, RenderTextureFormat.ARGBHalf);
UnityEngine.Profiling.Profiler.EndSample();
}
m_BitMaskMaterial.mainTexture = spriteEditor.GetDataProvider <ITextureDataProvider>().texture;
var oldRT = RenderTexture.active;
Graphics.SetRenderTarget(reuseRT);
m_BitMaskMaterial.SetPass(0);
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::DrawMesh");
GL.Clear(false, true, new Color(0, 0, 0, 0));
GL.PushMatrix();
GL.LoadOrtho();
var h = b.size.y * 0.5f;
var w = h * (b.size.x / b.size.y);
GL.LoadProjectionMatrix(Matrix4x4.Ortho(-w, w, -h, h, -1, 1));
GL.Begin(GL.QUADS);
GL.Color(Color.white);
Graphics.DrawMeshNow(mesh, Matrix4x4.Translate(-b.center));
GL.End();
GL.PopMatrix();
Graphics.SetRenderTarget(oldRT);
UnityEngine.Profiling.Profiler.EndSample();
UnityEngine.Profiling.Profiler.EndSample();
return(reuseRT);
}
return(null);
}
public void CreateToolCache(ISpriteEditor spriteEditor, LayoutOverlay layoutOverlay)
{
var spriteEditorDataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
var skeletonTool = CreateCache <SkeletonTool>();
var meshTool = CreateCache <MeshTool>();
skeletonTool.Initialize(layoutOverlay);
meshTool.Initialize(layoutOverlay);
m_ToolMap.Add(Tools.EditPose, CreateSkeletonTool <SkeletonToolWrapper>(skeletonTool, SkeletonMode.EditPose, false, layoutOverlay));
m_ToolMap.Add(Tools.EditJoints, CreateSkeletonTool <SkeletonToolWrapper>(skeletonTool, SkeletonMode.EditJoints, true, layoutOverlay));
m_ToolMap.Add(Tools.CreateBone, CreateSkeletonTool <SkeletonToolWrapper>(skeletonTool, SkeletonMode.CreateBone, true, layoutOverlay));
m_ToolMap.Add(Tools.SplitBone, CreateSkeletonTool <SkeletonToolWrapper>(skeletonTool, SkeletonMode.SplitBone, true, layoutOverlay));
m_ToolMap.Add(Tools.ReparentBone, CreateSkeletonTool <BoneReparentTool>(skeletonTool, SkeletonMode.EditPose, false, layoutOverlay));
m_ToolMap.Add(Tools.EditGeometry, CreateMeshTool <MeshToolWrapper>(skeletonTool, meshTool, SpriteMeshViewMode.EditGeometry, SkeletonMode.Disabled, layoutOverlay));
m_ToolMap.Add(Tools.CreateVertex, CreateMeshTool <MeshToolWrapper>(skeletonTool, meshTool, SpriteMeshViewMode.CreateVertex, SkeletonMode.Disabled, layoutOverlay));
m_ToolMap.Add(Tools.CreateEdge, CreateMeshTool <MeshToolWrapper>(skeletonTool, meshTool, SpriteMeshViewMode.CreateEdge, SkeletonMode.Disabled, layoutOverlay));
m_ToolMap.Add(Tools.SplitEdge, CreateMeshTool <MeshToolWrapper>(skeletonTool, meshTool, SpriteMeshViewMode.SplitEdge, SkeletonMode.Disabled, layoutOverlay));
m_ToolMap.Add(Tools.GenerateGeometry, CreateMeshTool <GenerateGeometryTool>(skeletonTool, meshTool, SpriteMeshViewMode.EditGeometry, SkeletonMode.EditPose, layoutOverlay));
var copyTool = CreateTool <CopyTool>();
copyTool.Initialize(layoutOverlay);
copyTool.pixelsPerUnit = spriteEditorDataProvider.pixelsPerUnit;
copyTool.skeletonTool = skeletonTool;
copyTool.meshTool = meshTool;
m_ToolMap.Add(Tools.CopyPaste, copyTool);
CreateWeightTools(skeletonTool, meshTool, layoutOverlay);
m_SelectionTool = CreateTool <SelectionTool>();
m_SelectionTool.spriteEditor = spriteEditor;
m_SelectionTool.Initialize(layoutOverlay);
m_SelectionTool.Activate();
var visibilityTool = CreateTool <VisibilityTool>();
visibilityTool.Initialize(layoutOverlay);
visibilityTool.skeletonTool = skeletonTool;
m_ToolMap.Add(Tools.Visibility, visibilityTool);
var switchModeTool = CreateTool <SwitchModeTool>();
m_ToolMap.Add(Tools.SwitchMode, switchModeTool);
}
internal void RenderSpriteOutline(ISpriteEditor spriteEditor, SpriteCache sprite)
{
if (spriteEditor == null || sprite == null)
{
return;
}
if (Event.current.type == EventType.Repaint)
{
if (SelectionOutlineSettings.selectedSpriteOutlineSize < 0.01f || SelectionOutlineSettings.outlineColor.a < 0.01f)
{
return;
}
var mesh = GetMesh(sprite);
if (mesh == null)
{
return;
}
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::RenderSpriteOutline");
var vertices = mesh.vertices;
var edges = sprite.GetMesh().edges;
var multMatrix = Handles.matrix * sprite.GetLocalToWorldMatrixFromMode();
var texture = spriteEditor.GetDataProvider <ITextureDataProvider>().texture;
var outlineSize = SelectionOutlineSettings.selectedSpriteOutlineSize;
var outlineColor = SelectionOutlineSettings.outlineColor;
var adjustForGamma = PlayerSettings.colorSpace == ColorSpace.Linear ? 1.0f : 0.0f;
if (edges != null && edges.Count > 0 && vertices.Length > 0)
{
var finalOutlineSize = outlineSize / spriteEditor.zoomLevel;
DrawEdgeOutline(edges, vertices, multMatrix, finalOutlineSize, outlineColor, adjustForGamma);
}
else // Fallback: Draw using the Sobel filter.
{
var finalOutlineSize = Mathf.Max(texture.width, texture.height) * outlineSize / k_ReferenceTextureSize;
DrawMeshOutline(mesh, sprite, multMatrix, finalOutlineSize, outlineColor, adjustForGamma);
}
UnityEngine.Profiling.Profiler.EndSample();
}
}
public static void ResetSpriteEditorView(ISpriteEditor spriteEditor)
{
if (spriteEditor != null)
{
Type t = spriteEditor.GetType();
var zoom = t.GetField("m_Zoom", BindingFlags.Instance | BindingFlags.NonPublic);
if (zoom != null)
{
zoom.SetValue(spriteEditor, -1);
}
var scrollPosition = t.GetField("m_ScrollPosition", BindingFlags.Instance | BindingFlags.NonPublic);
if (scrollPosition != null)
{
scrollPosition.SetValue(spriteEditor, new Vector2());
}
}
}
void CreateSpriteLibrary(ISpriteEditor spriteEditor)
{
var dataProvider = spriteEditor.GetDataProvider <ISpriteLibDataProvider>();
if (dataProvider != null && hasCharacter)
{
m_SpriteCategoryList = CreateCache <SpriteCategoryListCacheObject>();
var categoryList = dataProvider.GetSpriteCategoryList();
var spriteIds = m_Character.parts.Select(p => p.sprite.id);
foreach (var category in categoryList.categories)
{
category.labels.RemoveAll(label => !spriteIds.Contains(label.spriteId));
}
m_SpriteCategoryList.CopyFrom(categoryList);
}
}
public void Create(ISpriteEditor spriteEditor)
{
Clear();
var dataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
var boneProvider = spriteEditor.GetDataProvider <ISpriteBoneDataProvider>();
var meshProvider = spriteEditor.GetDataProvider <ISpriteMeshDataProvider>();
var spriteRects = dataProvider.GetSpriteRects();
var textureProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
for (var i = 0; i < spriteRects.Length; i++)
{
var spriteRect = spriteRects[i];
var sprite = CreateSpriteCache(spriteRect);
CreateSkeletonCache(sprite, boneProvider);
CreateMeshCache(sprite, meshProvider, textureProvider);
CreateMeshPreviewCache(sprite);
}
CreateCharacter(spriteEditor);
}
internal void RenderSpriteOutline(ISpriteEditor spriteEditor, SpriteCache sprite)
{
if (sprite == null)
{
return;
}
if (Event.current.type == EventType.Repaint)
{
UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::RenderSpriteOutline");
m_OutlineMaterial.SetColor("_OutlineColor", SelectionOutlineSettings.outlineColor);
m_OutlineMaterial.SetFloat("_AdjustLinearForGamma", PlayerSettings.colorSpace == ColorSpace.Linear ? 1.0f : 0.0f);
var texture = spriteEditor.GetDataProvider <ITextureDataProvider>().texture;
float outlineSize = Mathf.Max(texture.width, texture.height) * SelectionOutlineSettings.selectedSpriteOutlineSize / 1024.0f;
m_OutlineMaterial.SetFloat("_OutlineSize", outlineSize);
var mesh = GetMesh(sprite);
m_OutlineMaterial.SetPass(0);
GL.PushMatrix();
GL.MultMatrix(Handles.matrix * sprite.GetLocalToWorldMatrixFromMode());
Rect r = new Rect(mesh.bounds.min.x, mesh.bounds.min.y, mesh.bounds.size.x, mesh.bounds.size.y);
GL.Begin(GL.QUADS);
GL.Color(Color.white);
GL.TexCoord(new Vector3(0, 0, 0));
GL.Vertex3(r.xMin, r.yMin, 0);
GL.TexCoord(new Vector3(1, 0, 0));
GL.Vertex3(r.xMax, r.yMin, 0);
GL.TexCoord(new Vector3(1, 1, 0));
GL.Vertex3(r.xMax, r.yMax, 0);
GL.TexCoord(new Vector3(0, 1, 0));
GL.Vertex3(r.xMin, r.yMax, 0);
GL.End();
GL.PopMatrix();
UnityEngine.Profiling.Profiler.EndSample();
}
}
public SpritePhysicsShapeModule(ISpriteEditor sem, IEventSystem ege, IUndoSystem us, IAssetDatabase ad, IGUIUtility gu, IShapeEditorFactory sef, ITexture2D outlineTexture)
: base(sem, ege, us, ad, gu, sef, outlineTexture)
{
spriteEditorWindow = sem;
}
public BoneSpriteEditorModuleView(ISpriteEditor spriteEditor)
{
this.spriteEditor = spriteEditor;
}
public SpritePolygonModeModule(ISpriteEditor sw, IEventSystem es, IUndoSystem us, IAssetDatabase ad) :
base("Sprite Polygon Mode Editor", sw, es, us, ad)
{
}
