public static List<SpriteData> Parse(string path)
{
PListRoot root = PListRoot.Load(path);
PListDict dic = (PListDict)root.Root;
if (dic.ContainsKey("frames") && dic.ContainsKey("metadata"))
{
//second child content :the big picture information
PListDict metaDic = (PListDict)dic["metadata"];
PListString wh = (PListString)metaDic["size"];
int w = GetFirstInter(wh);
int h = GetSecondInter(wh);
//-------------------------------------------------------------
//first child content
PListDict framesDic = (PListDict)dic["frames"];
IEnumerable<string> keys = framesDic.Keys;
List<SpriteData> sdList = new List<SpriteData>();
foreach (string k in keys)
{
PListDict frameDic = (PListDict)framesDic[k];
PListString temp = (PListString)frameDic["frame"];
int x = GetFirstInter(temp);
int y = GetSecondInter(temp);
PListBool rotated = (PListBool)frameDic["rotated"];
bool needRotate = rotated.Value;
int width = !needRotate ? GetThirdInter(temp) : GetForthInter(temp);
int height = !needRotate ? GetForthInter(temp) : GetThirdInter(temp);
SpriteData sd = new SpriteData();
sd.name = k;
sd.x = x;
sd.y = h - height - y;
sd.width = width;
sd.height = height;
sd.rotated = rotated;
sdList.Add(sd);
}
return sdList;
}
else
{
Debug.LogError("Not a Valid plist file:" + path);
return null;
}
}
public BlockTile(SpriteData left, SpriteData right, SpriteData top, SpriteData bottom, SpriteData front, SpriteData back){
left_00 = left._00;
left_01 = left._01;
left_10 = left._10;
left_11 = left._11;
right_00 = right._00;
right_01 = right._01;
right_10 = right._10;
right_11 = right._11;
top_00 = top._00;
top_01 = top._01;
top_10 = top._10;
top_11 = top._11;
bottom_00 = bottom._00;
bottom_01 = bottom._01;
bottom_10 = bottom._10;
bottom_11 = bottom._11;
front_00 = front._00;
front_01 = front._01;
front_10 = front._10;
front_11 = front._11;
back_00 = back._00;
back_01 = back._01;
back_10 = back._10;
back_11 = back._11;
}
public static void defineSprite(string name, int x, int y, int width, int height, int frameW, int frameH, int offsetX, int offsetY, int sheetW, int sheetH, bool doubled)
{
if (sprites == null) sprites = new Dictionary<string, SpriteData>();
SpriteData data = new SpriteData(x, y, width, height, frameW, frameH, offsetX, offsetY, doubled);
sprites.Add(name, data);
RendererUniversal.sheetW = sheetW;
RendererUniversal.sheetH = sheetH;
if (name == "white") white = data;
}
public static void AtlasCreate()
{
string[] guids = Selection.assetGUIDs;
for (int i = 0; i < guids.Length; i++)
{
string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
Debug.Log(assetPath);
string dictPath = Application.dataPath.Replace("Assets", assetPath);
DirectoryInfo Dir = new DirectoryInfo(dictPath);
string resPath = UGUIConfig.SpriteDir + Dir.Name;
if (!Directory.Exists(resPath))
{
Directory.CreateDirectory(resPath);
}
FileInfo[] infos = Dir.GetFiles("*.png");
if(infos.Length > 0)
{
string dicPath = infos[0].ToString().Remove(0, infos[0].ToString().IndexOf("Assets")).Replace("\\", "/");
AtlasData atlasData = ScriptableObject.CreateInstance<AtlasData>();
atlasData.spDataList = new List<SpriteData>();
foreach (FileInfo f in infos) //查找文件
{
int index = f.ToString().IndexOf("Assets");
string modPath = f.ToString().Remove(0, index);
modPath = modPath.Replace("\\", "/");
TextureImporter texImport = AssetImporter.GetAtPath(modPath) as TextureImporter;
texImport.textureType = TextureImporterType.Sprite;
texImport.spritePackingTag = new DirectoryInfo(Path.GetDirectoryName(modPath)).Name;
texImport.mipmapEnabled = false;
AssetDatabase.ImportAsset(modPath);
Sprite sprite = AssetDatabase.LoadAssetAtPath(modPath, typeof(Sprite)) as Sprite;
SpriteData data = new SpriteData(sprite.name, sprite);
atlasData.spDataList.Add(data);
}
string prePath = resPath + "/" + new DirectoryInfo(Path.GetDirectoryName(dicPath)).Name + ".asset";
prePath = prePath.Substring(prePath.IndexOf("Assets"));
AssetDatabase.CreateAsset(atlasData, prePath);
AssetDatabase.Refresh();
}
else
{
Debug.LogError("文件夹下没有png文件!");
return;
}
}
}
/// <summary>
/// 將字典傳入，依json表設定資料
/// </summary>
public static void SetData(Dictionary<string, SpriteData> _dic)
{
string jsonStr = Resources.Load<TextAsset>("Json/Sprite").ToString();
JsonData jd = JsonMapper.ToObject(jsonStr);
JsonData items = jd["Sprite"];
for (int i = 0; i < items.Count; i++)
{
SpriteData data = new SpriteData(items[i]);
string id = data.Name;
if (_dic.ContainsKey(id))
{
Debug.LogWarning("Sprite表的ID重複");
break;
}
_dic.Add(id, data);
}
}
public void ShowFiefInterface(ScreenBase screenBase, Hero hero, Action refreshAction)
{
this._screenBase = screenBase;
SpriteData spriteData = UIResourceManager.SpriteData;
TwoDimensionEngineResourceContext resourceContext = UIResourceManager.ResourceContext;
ResourceDepot resourceDepot = UIResourceManager.UIResourceDepot;
spriteData.SpriteCategories["ui_encyclopedia"].Load(resourceContext, resourceDepot);
spriteData.SpriteCategories["ui_kingdom"].Load(resourceContext, resourceDepot);
_layer = new GauntletLayer(211);
_layer.InputRestrictions.SetInputRestrictions(true, InputUsageMask.All);
_layer.Input.RegisterHotKeyCategory(HotKeyManager.GetCategory("GenericCampaignPanelsGameKeyCategory"));
_layer.IsFocusLayer = true;
ScreenManager.TrySetFocus(_layer);
screenBase.AddLayer(_layer);
_vm = new GrantFiefVM(hero, () => this.OnFinalize(refreshAction));
_movie = _layer.LoadMovie("GrantFief", _vm);
}
private void applyPolygonData()
{
if (this.currentPolygonType == PolygonType.None)
{
return;
}
IShaderData shaderData;
switch (this.currentPolygonType)
{
case PolygonType.Sprite:
shaderData = new SpriteData(this.localTransform, this.textureId, this.color, this.clipArea);
break;
case PolygonType.Orbit:
shaderData = new OrbitData(this.minRadius, this.maxRadius, this.color, this.localTransform, this.sprite);
break;
case PolygonType.Sdf:
if (!this.smoothDist.HasValue)
{
throw new InvalidOperationException("Pixel size not defined");
}
shaderData = new SdfData(this.localTransform, this.textureId, this.color, this.smoothDist.Value, this.clipArea);
break;
default:
throw new NotImplementedException(this.currentPolygonType.ToString());
}
foreach (var layer in this.vertexData)
{
this.polygons.Add(new PolygonData(layer.Key, shaderData, layer.Value));
}
//clean up
this.vertexData = new Dictionary <float, List <float> >();
this.localTransform = Matrix4.Identity;
this.smoothDist = null;
}
// Cuts the sprite into its sub-sprites
public static List <SpriteMetaData> CutSprite(Texture2D sprite, List <SpriteData> cutting_data)
{
// Import image
string image_path = AssetDatabase.GetAssetPath(sprite);
TextureImporter importer = AssetImporter.GetAtPath(image_path) as TextureImporter;
importer.spriteImportMode = SpriteImportMode.Multiple;
// Prepare spritesheet
List <SpriteMetaData> sheet = new List <SpriteMetaData>();
int source_y = sprite.height;
// For each sub-sprite
for (int i = 0; i < cutting_data.Count; i++)
{
// Create new sprite metadata
SpriteMetaData s = new SpriteMetaData();
SpriteData sd = cutting_data[i];
s.name = sd.name;
s.pivot = new Vector2(sd.offsetX, sd.offsetY);
s.rect = new Rect(sd.x, source_y - sd.y - sd.height, sd.width, sd.height);
s.alignment = 0;
s.border = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
sheet.Add(s);
}
// Apply spritesheet
importer.spritesheet = sheet.ToArray();
// Apply import settings
AssetDatabase.StartAssetEditing();
AssetDatabase.ImportAsset(importer.assetPath);
AssetDatabase.StopAssetEditing();
// Return spritesheet
return(sheet);
}
public Mouse()
{
Transform
.Create(this);
Sprite
.Create(this)
.SetImage("rufzeichen", 2)
.SetFrame(1)
.SetRenderStage(RenderStage.PostBloom);
SpriteData
.Create(this)
.SetOffset(-20, -20);
MouseFollower
.Create(this);
InteractiveVisibility
.Create(this);
}
public FairyObject(Room room, Vector2 pos) : base(room, pos, new Vector2(0, 0), new Vector2(32, 32))
{
life = 3;
cooldown = 60;
moving = true;
Position -= new Vector2(0, 16);
facingRight = true;
Sprite = new SpriteData();
Sprite.Size = new Vector2(32, 32);
animationindex = -16;
goingUp = true;
Hitbox = new Rectangle(0, 0, 32, 48);
Sprite.Layer = Layer;
fairySprite = null;
AssetManager.RequestTexture("fairy", (frames) =>
{
fairySprite = frames;
Sprite.Change(fairySprite);
Sprite.Speed = 1f / 10;
});
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
this.spriteBatch = new SpriteBatch(GraphicsDevice);
this.spriteData = new SpriteData();
this.background = Content.Load <Texture2D>(@"Content\Background");
SpriteInitializer.InitializeSprites(this.spriteData, Content);
this.emoticon = new Emoticon("OnfireEmoticon");
this.sprite = spriteData.DuplicateSprite(this.emoticon.Name);
this.uiEmoticon = new UIEmoticon(this.sprite, this.emoticon);
this.uiEmoticon.Sprite.AnimationIndex = 3;
this.hero = new Hero("LightHero");
this.sprite = spriteData.DuplicateSprite(this.hero.Name);
this.uiHero = new UIHero(this.sprite, this.hero);
StartGame();
}
public static void Load()
{
var rd = UIResourceManager.UIResourceDepot;
var rc = UIResourceManager.ResourceContext;
var sd = UIResourceManager.SpriteData;
var spriteData = new SpriteData("entrepreneur-ui-1");
spriteData.Load(rd);
var texture = new TaleWorlds.TwoDimension.Texture((TaleWorlds.TwoDimension.ITexture)
new EngineTexture(
TaleWorlds.Engine.Texture.CreateTextureFromPath(
@"../../Modules/Entrepreneur/GUI/SpriteSheets/", "entrepreneur-ui-1.png")
)
);
sd.SpriteCategories.Add("entrepreneur-ui-1", spriteData.SpriteCategories["entrepreneur-ui-1"]);
sd.SpritePartNames.Add("FinancesIcon", spriteData.SpritePartNames["FinancesIcon"]);
sd.SpriteNames.Add("FinancesIcon", new SpriteGeneric("FinancesIcon", spriteData.SpritePartNames["FinancesIcon"]));
sd.SpritePartNames.Add("MapbarLeftFrame", spriteData.SpritePartNames["MapbarLeftFrame"]);
sd.SpriteNames.Add("MapbarLeftFrame", new SpriteGeneric("MapbarLeftFrame", spriteData.SpritePartNames["MapbarLeftFrame"]));
sd.SpritePartNames.Add("Entrepreneur.EmptyField", spriteData.SpritePartNames["Entrepreneur.EmptyField"]);
sd.SpriteNames.Add("Entrepreneur.EmptyField", new SpriteGeneric("Entrepreneur.EmptyField", spriteData.SpritePartNames["Entrepreneur.EmptyField"]));
sd.SpritePartNames.Add("Entrepreneur.WorkingField", spriteData.SpritePartNames["Entrepreneur.WorkingField"]);
sd.SpriteNames.Add("Entrepreneur.WorkingField", new SpriteGeneric("Entrepreneur.WorkingField", spriteData.SpritePartNames["Entrepreneur.WorkingField"]));
sd.SpritePartNames.Add("Entrepreneur.VillagePropertyIcon", spriteData.SpritePartNames["Entrepreneur.VillagePropertyIcon"]);
sd.SpriteNames.Add("Entrepreneur.VillagePropertyIcon", new SpriteGeneric("Entrepreneur.VillagePropertyIcon", spriteData.SpritePartNames["Entrepreneur.VillagePropertyIcon"]));
var bettertimeicons = sd.SpriteCategories["entrepreneur-ui-1"];
bettertimeicons.SpriteSheets.Add(texture);
bettertimeicons.Load((ITwoDimensionResourceContext)rc, rd);
UIResourceManager.BrushFactory.Initialize();
}
void loadSpriteSheet(FileInfo path)
{
string[] split = path.FullName.Split('.');
string pathXml = string.Join(".", split, 0, split.Length - 1) + ".xml";
string fileName = path.Name.Split('.')[0];
Debug.Log(string.Format("Loading \"{0}\" ({1})...", path, fileName));
byte[] imageData = File.ReadAllBytes(path.FullName);
Texture2D tex = new Texture2D(2, 2, TextureFormat.ARGB32, false);
if (tex.LoadImage(imageData))
{
tex.filterMode = FilterMode.Point;
}
else
{
Debug.LogError("Cannot load texture!");
}
Debug.Assert(tex != null, "Texture can't be null, invalid sheet map?");
if (File.Exists(pathXml))
{
XmlReaderSettings settings = new XmlReaderSettings();
XmlReader reader = XmlReader.Create(pathXml, settings);
loadSprites(reader, tex);
}
else
{
SpriteData data = new SpriteData(new Rect(Vector2.zero, defaultSize), defaultPivot);
data.name = fileName;
sprites[data.name] = new SpriteContainer {
sprite = Sprite.Create(tex, data.rect, data.pivot), layer = null
};
return;
}
}
public TileSet AddSpriteDataToTileSet(TileSet set, SpriteData data)
{
foreach (var part in data.Parts)
{
for (int i = 0; i < part.m_Frames; i++)
{
if (set.FindTileByName(part.m_Name) >= 0)
{
continue;
}
var index = set.GetLastUnusedTileId();
set.CreateTile(index);
set.TileSetTexture(index, part.m_FrameSprite[i]);
set.TileSetName(index, data.Name);
set.TileSetModulate(index, part.SelectedColour);
set.TileSetMaterial(index, this.TileSetMaterial);
}
}
return(set);
}
private Vector2 InitItem(Match match, EmojiItem item)
{
string keyContent = match.Groups[0].Value;
EmojiTypeKey type = EmojiTypeKey.S;
string id = "";
EmojiConfig.Instance.GetEmojiInfo(keyContent, ref type, ref id);
Vector2 defaultSize = Vector2.zero;
bool adpativeSize = false;
switch (type)
{
case EmojiTypeKey.V:
VideoData videoData = EmojiConfig.Instance.GetVideoData(id);
item.PlayVideo(videoData.VideoClip);
defaultSize = videoData.DefaultSize;
adpativeSize = videoData.AdaptiveSize;
break;
case EmojiTypeKey.S:
SpriteData spriteData = EmojiConfig.Instance.GetSpriteData(id);
item.SetSprite(spriteData.Sprite);
defaultSize = spriteData.DefaultSize;
adpativeSize = spriteData.AdaptiveSize;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (adpativeSize)
{
defaultSize = Vector2.one * fontSize;
}
item.SetSize(type, defaultSize);
return(defaultSize);
}
void SaveData(Texture2D tex, int xSize, int ySize, List <Color> colors, int[,] spriteGrid)
{
Texture2D snapshot = RenderData(xSize, ySize, spriteGrid, colors);
SpriteData asset = ScriptableObject.CreateInstance <SpriteData>();
UnityEditor.AssetDatabase.CreateAsset(asset, "Assets/Resources/Sprite Objects/" + tex.name + ".asset");
UnityEditor.AssetDatabase.SaveAssets();
UnityEditor.AssetDatabase.CreateAsset(snapshot, "Assets/Resources/Sprite Thumbnails/" + tex.name + "_img.asset");
UnityEditor.AssetDatabase.SaveAssets();
asset.xSize = xSize;
asset.ySize = ySize;
asset.thumb = snapshot;
asset.myName = tex.name;
asset.colors = new Color[colors.Count];
asset.colorCount = colors.Count;
int tileCount = 0;
for (int xx = 0; xx < xSize; xx++)
{
for (int yy = 0; yy < ySize; yy++)
{
if (spriteGrid [xx, yy] >= 0)
{
tileCount++;
}
}
}
asset.tileCount = tileCount;
for (int xx = 0; xx < colors.Count; xx++)
{
asset.colors [xx] = colors [xx];
}
asset.colorData = Globals.SaveArray(spriteGrid);
asset.difficulty = colors.Count * tileCount;
UnityEditor.AssetDatabase.Refresh();
UnityEditor.EditorUtility.SetDirty(asset);
UnityEditor.AssetDatabase.SaveAssets();
}
private Rect GetUvs(int x, int y, SpriteData data)
{
Rect result = new Rect(data.uv.x, data.uv.y, data.uv.width / 3f, data.uv.height / 3f);
if (x == this.m_width - 1)
{
result.x += 2f * result.width;
}
else if (x > 0)
{
result.x += result.width;
}
if (y == this.m_height - 1)
{
result.y += 2f * result.height;
}
else if (y > 0)
{
result.y += result.height;
}
return(result);
}
private static void CreateAtlasPrefab(string atlasName, string[] atlPath)
{
List <Sprite> splist = new List <Sprite>();
foreach (var path in atlPath)
{
splist.AddRange(AssetDatabase.LoadAllAssetsAtPath(path).OfType <Sprite>().ToArray());
}
if (splist.Count > 0)
{
GameObject go = new GameObject(atlasName);
SpriteData spdata = go.AddComponent <SpriteData>();
spdata.SetSP = splist.ToArray();
string path1 = AtlasPrefabPath + atlasName + ".prefab";
GameObject temp = PrefabUtility.CreatePrefab(path1, go);
#region 添加ab标记
//此处自动添加ab标记
//如果加载方式是Resources.load()等不需要ab标记的可以把此处注释掉
//AssetImporter importer = AssetImporter.GetAtPath(path1);
//if (importer == null || temp == null)
//{
// Debug.LogError("error: " + path1);
// return;
//}
//importer.assetBundleName = "ui-share.unity3d";
#endregion
GameObject.DestroyImmediate(go);
EditorUtility.SetDirty(temp);
AssetDatabase.SaveAssets();
}
Resources.UnloadUnusedAssets();
AssetDatabase.Refresh();
Debug.Log("****图集创建成功****");
}
public static void DrawImage(
this SKCanvas canvas,
SKImage image,
SKPaint paint,
SpriteData spriteData
)
{
var origin = spriteData.Origin;
var textureBounds = spriteData.TextureBounds;
canvas.DrawImage(
image,
textureBounds,
SKRect.Create(
-origin.X,
-origin.Y,
textureBounds.Width,
textureBounds.Height
),
paint
);
}
private Vector2 GetSize()
{
int length = this.text.Length;
float num = 0f;
float num2 = 0f;
float num3 = this.letterInterval * 0.026041666f;
for (int i = 0; i < length; i++)
{
char c = this.text[i];
SpriteFont.SpriteSymbol symbol = this.m_font.GetSymbol(c);
SpriteData spriteData = symbol.spriteData;
float num4 = symbol.spriteScaleX * (float)spriteData.width * 0.026041666f;
float num5 = symbol.spriteScaleY * (float)spriteData.height * 0.026041666f;
num2 += num4 + num3;
if (num5 > num)
{
num = num5;
}
}
return(new Vector2(num2, num));
}
public void LoadSprite(string path)
{
SpriteData sd = _mgr.TryGetSprite(path);
if (sd == null)
{
object obj = Resources.Load(path);
if (obj != null)
{
OnIconLoadSuccess(path, obj);
}
else
{
OnIconLoadFaild(path);
}
}
else
{
sd.usedTime = Time.time;
OnComplete(sd.sprite);
}
}
private static void UF_HandleToken(List <TextToken> tokens, List <SpriteData> listSpriteDatas, int fontSize)
{
listSpriteDatas.Clear();
for (int k = 0; k < tokens.Count; k++)
{
if (tokens [k].type == TextTokenType.QUAD)
{
int idxQuad = tokens[k].buffer.IndexOf("f=");
if (idxQuad < 0)
{
continue;
}
string spriteName = RichText.UF_ReadString(tokens[k].buffer, idxQuad + 2);;
if (string.IsNullOrEmpty(spriteName))
{
continue;
}
SpriteData spritedata = new SpriteData();
spritedata.name = spriteName;
spritedata.idx = tokens [k].index;
int idxSize = tokens[k].buffer.IndexOf("s=");
int idxOffset = tokens[k].buffer.IndexOf("o=");
if (idxSize > -1)
{
spritedata.size = RichText.UF_ReadInt(tokens [k].buffer, idxQuad + 2, 1);
}
else
{
spritedata.size = fontSize;
}
if (idxOffset > -1)
{
spritedata.offset = RichText.UF_ReadFloat(tokens[k].buffer, idxOffset + 2, 0);
}
listSpriteDatas.Add(spritedata);
}
}
}
public void SetAnimation(string name)
{
string upperName = name.ToUpper();
int newIndex = animationIndex;
for (int i = 0; i < animationList.Length; i++)
{
if (animationList[i].name.ToUpper().Equals(upperName))
{
newIndex = i;
}
}
if (newIndex != animationIndex)
{
//Debug.Log(transform.parent.parent.name + "/" + transform.parent.name + "/" + this.name + " > Set Animation to " + name);
// Update offset and scale and current animation rate
spriteIndex = 0;
animationIndex = newIndex;
SpriteDataList spriteAnim = animationList[animationIndex];
if (spriteAnim.fps <= 0)
{
rate = 10;
}
else
{
rate = 1 / spriteAnim.fps;
}
for (int i = 0; i < spriteAnim.spriteList.Length; i++)
{
SpriteData spriteInfo = spriteAnim.spriteList[i];
// Use texture size to determine sprite offsets (coords / texture size) and texture scale (sprite size / texture size)
spriteInfo.scale = new Vector2(spriteInfo.size.x / textureSize.x, spriteInfo.size.y / textureSize.y);
spriteInfo.offset = new Vector2(spriteInfo.coords.x / textureSize.x, 1 - (spriteInfo.coords.y + spriteInfo.size.y) / textureSize.y);
}
// Immediate update
nextUpdate = Time.time;
}
}
public void InitializeAnimations(RuntimeSpriteDatabase db)
{
this.m_timer = 0f;
this.m_frame = 0;
this.m_sprite = base.GetComponent <global::Sprite>();
this.m_meshFilter = base.GetComponent <MeshFilter>();
string id = this.m_sprite.Id;
foreach (Animation animation in this.m_animations)
{
float num = 0f;
foreach (FrameTiming frameTiming in animation.frames)
{
num += frameTiming.time;
frameTiming.endTime = num;
SpriteData data = db.Find(frameTiming.id);
this.m_sprite.SelectSprite(data, true);
frameTiming.mesh = this.m_sprite.GetComponent <MeshFilter>().sharedMesh;
}
}
this.m_sprite.SelectSprite(db.Find(id), true);
this.m_initialized = true;
}
public void RefreshEditorView()
{
if (!Application.isPlaying)
{
MeshFilter component = base.transform.GetComponent <MeshFilter>();
if (!component)
{
return;
}
if (base.GetComponent <Renderer>().sharedMaterial&& base.GetComponent <Renderer>().sharedMaterial.mainTexture)
{
if (this.m_spriteDatabase == null)
{
this.m_spriteDatabase = Resources.Load <GameObject>("GUISystem/SpriteDatabase").GetComponent <RuntimeSpriteDatabase>();
}
SpriteData spriteData = this.m_spriteDatabase.Find(this.m_id);
if (spriteData != null)
{
this.SelectSprite(spriteData, false);
}
}
}
}
public void RebuildIcons()
{
if (Singleton <RuntimeSpriteDatabase> .Instance != null)
{
Vector2 vector;
if (TextDialog.SpriteScale.GetCustomScale(this.customScales, this.itemSpriteID, out vector))
{
this.itemIcon.m_scaleX = vector.x;
this.itemIcon.m_scaleY = vector.y;
}
else
{
this.itemIcon.m_scaleX = this.defaultScale.x;
this.itemIcon.m_scaleY = this.defaultScale.y;
}
SpriteData spriteData = Singleton <RuntimeSpriteDatabase> .Instance.Find(this.itemSpriteID);
if (spriteData != null)
{
this.itemIcon.SelectSprite(spriteData, true);
}
}
}
//创建图集预设
public static void CreateAtlasPrefab(string atlasName, string[] atlPath)
{
List <Sprite> _texs = new List <Sprite>();
foreach (string path in atlPath)
{
_texs.AddRange(AssetDatabase.LoadAllAssetsAtPath(path).OfType <Sprite>().ToArray());
}
if (null != _texs)
{
GameObject _go = new GameObject();
_go.name = atlasName;
SpriteData _spData = _go.AddComponent <SpriteData>();
_spData.SetSP = _texs.ToArray();
string path1 = UISharePath + atlasName + ".prefab";
GameObject temp = PrefabUtility.CreatePrefab(path1, _go);
#region 添加ab标记
//此处自动添加ab标记
//如果加载方式是Resources.load()等不需要ab标记的可以把此处注释掉
AssetImporter importer = AssetImporter.GetAtPath(path1);
if (importer == null || temp == null)
{
Debug.LogError("error: " + path1);
return;
}
importer.assetBundleName = "ui-share.unity3d";
#endregion
GameObject.DestroyImmediate(_go);
EditorUtility.SetDirty(temp);
AssetDatabase.SaveAssets();
}
Resources.UnloadUnusedAssets();
AssetDatabase.Refresh();
}
private void GenerateSprite(UIVertexHelper vh, SpriteData sprite, Rect rect, Vector2 pivot, Color color)
{
var spriteSize = new Vector2(sprite.rect.width, sprite.rect.height);
// Covert sprite pivot into normalized space.
var spritePivot = sprite.pivot / spriteSize;
var rectPivot = pivot;
Rect r = rect;
if (preserveAspect & spriteSize.sqrMagnitude > 0.0f)
{
PreserveSpriteAspectRatio(ref r, spriteSize, pivot);
}
var drawingSize = new Vector2(r.width, r.height);
var spriteBoundSize = sprite.bounds.size;
// Calculate the drawing offset based on the difference between the two pivots.
var drawOffset = (rectPivot - spritePivot) * drawingSize;
var color32 = color;
vh.Clear();
Vector2[] vertices = sprite.vertices;
Vector2[] uvs = sprite.uvs;
for (int i = 0; i < vertices.Length; ++i)
{
vh.AddVert(new Vector3((vertices[i].x / spriteBoundSize.x) * drawingSize.x - drawOffset.x, (vertices[i].y / spriteBoundSize.y) * drawingSize.y - drawOffset.y), color32, new Vector2(uvs[i].x, uvs[i].y));
}
UInt16[] triangles = sprite.triangles;
for (int i = 0; i < triangles.Length; i += 3)
{
vh.AddTriangle(triangles[i + 0], triangles[i + 1], triangles[i + 2]);
}
}
private SpriteData <TType>[] CreateDataMap <TType>(SpriteData <TType>[] spriteDataMap) where TType : Enum
{
var flags = System.Enum.GetValues(typeof(TType));
if (spriteDataMap != null)
{
// サイズ同じなら何もしない
if (spriteDataMap.Length == flags.Length)
{
return(spriteDataMap);
}
}
var dataMap = new SpriteData <TType> [flags.Length];
int count = 0;
foreach (TType flag in flags)
{
var data = new SpriteData <TType>();
data.SetType(flag);
dataMap[count++] = data;
}
// サイズ変更により中身を差し替える
var length = Mathf.Min(spriteDataMap.Length, flags.Length);
for (int i = 0; i < length; ++i)
{
var sprite = spriteDataMap[i].Sprite;
dataMap[i].SetSprite(sprite);
}
return(dataMap);
}
public RyanBlooddrop(Vector2 position, byte frame, int ttl, string id, float z) : base(id)
{
Sprite
.Create(this)
.SetTexture(Game.Ego.Get <BloodDropEmitter>().Texture, 16, 1)
.SetFrame(16);
SpriteData
.Create(this)
.SetColor(Color.White);
HotspotSprite
.Create(this)
.SetPixelPerfect(true)
.SetCaption(Basement_Res.drop_of_blood);
Transform
.Create(this)
.SetZ(z)
.SetPosition(position - new Vector2(0, 55));
Interaction
.Create(this)
.SetPosition(position - new Vector2(0, 55))
.SetGetInteractionsFn(GetInteractions);
Scripts
.Create(this);
TimeToLive = Math.Min(500, ttl);
UpdateCount = 0;
TargetFrame = frame;
TargetPosition = position;
Visible = true;
}
public void Initialize(SpriteMenu menu, SpriteData data)
{
SpriteMenu = menu;
Sprite = data;
// Initialize sprite image
image.sprite = data.Sprite;
if (data.MaintainAspect)
{
float scale = Mathf.Min(data.Width / data.Sprite.bounds.size.x, data.Height / data.Sprite.bounds.size.y);
((RectTransform)transform).sizeDelta = scale * data.Sprite.bounds.size;
}
else
{
((RectTransform)transform).sizeDelta = new Vector2(data.Width, data.Height);
}
// Store defaults
baseSize = ((RectTransform)transform).sizeDelta;
baseOutlineDistance = outline.effectDistance;
// Set button response
button.onClick.AddListener(() => SpriteMenu.SelectSprite(this));
}
private void LoadByResources(int index, SpriteData data)
{
//if (data._obj.GetType() == typeof(DataManager)) { };
string url = string.Format(data._url, index);
ResourcesManager.Asset tAsset = new ResourcesManager.Asset(url, data._assetType, data._assetPath);
tAsset._isTexture2dReadable = data._isReadable;
ResourcesManager.LoadAsset(tAsset, (ResourcesManager.Asset asset) => {
if (false == data._isKeepLastAsset)
{
if (null != data._lastAsset)
{
ResourcesManager.Asset temp = data._lastAsset as ResourcesManager.Asset;
if (asset != temp)
{
temp._isCached = false;
temp.Dispose();
data._lastAsset = null;
}
}
}
asset._isCached = true;
data._lastAsset = asset;
if (data._objType == ObjType.Texture2D)
{
data._obj = asset._texture2d;
}
else
{
data._obj = asset.Sprite;
}
HandleUpdate(index, true, data);
}, (ResourcesManager.Asset asset) => {
HandleUpdate(index, false, data);
});
}
private void btnExport_Click(object sender, EventArgs e)
{
if (dlgSave.ShowDialog() == DialogResult.OK)
{
// Get the sprite indices
int bank = cboBank.SelectedIndex;
int chr = indexmap[cboChar.SelectedIndex];
int sprite = cboSprite.SelectedIndex;
// Get the bitmap
Bitmap bmp = SpriteData.GetSprite(bank, chr, sprite, cboPalNum.SelectedIndex, false);
// Get the palette
var palette = SpritePalettes.GetPalette(sprite);
// Create the target bitmap
Bitmap target = new Bitmap(Math.Max(128, bmp.Width), 32 + bmp.Height, PixelFormat.Format32bppArgb);
Graphics g = Graphics.FromImage(target);
// Draw the palette
for (int i = 0; i < 16; i++)
{
int x = (i & 7) << 4;
int y = ((i & 8) << 1);
g.FillRectangle(new SolidBrush(palette.Entries[0][i]), new Rectangle(x, y, 16, 16));
}
// Draw the sprite
g.DrawImage(bmp, new Point(0, 32));
// Save
target.Save(dlgSave.FileName);
g.Dispose();
}
}
private void RebuildBuffer()
{
var data = new SpriteData[m_instances.Count];
for (int i = 0; i < m_instances.Count; i++)
{
var instance = m_instances[i];
var sprite = instance.Sprite;
var matrix = Matrix4.Identity;
matrix *= Matrix4.Translate(instance.Position.X, instance.Position.Y, 0f);
matrix *= Matrix4.Scale(instance.Size.X, instance.Size.Y, 0f);
data[i] = new SpriteData()
{
//Color = new Vector4(1f, 1f, 1f, 1f),
Transform = matrix,
TextureOrigin = sprite.Coordinates.Position,
TextureTarget = sprite.Coordinates.Position + sprite.Coordinates.Size
};
}
m_bufferSprite.SetData(data, GL.STREAM_DRAW);
//m_bufferSprite.SetData(m_instances.Count, GL.STREAM_DRAW);
//using (var mapping = m_bufferSprite.Map(m_instances.Count))
//{
// unsafe
// {
// SpriteData* data = (SpriteData*)mapping.Address.ToPointer();
// for (int i = 0; i < m_instances.Count; i++)
// {
// var instance = m_instances[i];
// var sprite = instance.Sprite;
// var matrix = Matrix4.Identity;
// matrix *= Matrix4.Translate(instance.Position.X, instance.Position.Y, 0f);
// matrix *= Matrix4.Scale(instance.Size.X, instance.Size.Y, 0f);
// data[i] = new SpriteData()
// {
// //Color = new Vector4(1f, 1f, 1f, 1f),
// Transform = matrix,
// TextureOrigin = sprite.Coordinates.Position,
// TextureTarget = sprite.Coordinates.Position + sprite.Coordinates.Size
// };
// }
// }
//}
m_isDirty = false;
}
protected override Mesh GetMesh()
{
if (!Application.isPlaying)
return null;
sprites.Clear();
// first check if all children are ready
if (!ChildrenReady())
return null;
if (linked.Count>0)
{
linkedInitializing = false;
for (int i=0; i<linked.Count; i++)
if (!linked[i].hasMesh || linked[i].uv == null)
{
linkedInitializing = true;
return null;
}
sprites.AddRange(linked);
}
if (sprites.Count==0)
{
ResetRemovedSprites();
meshDirty = false;
return new Mesh();
}
submeshMaterials.Clear();
submeshTriangles.Clear();
submeshes.Clear();
gameObjects.Clear();
packedUvs.Clear();
texturesToPack.Clear();
#if UNITY_EDITOR
if (packTextures && Application.isEditor)
CheckTexturesReadWrite();
#endif
ResetRemovedSprites();
Material mat = null;
spriteData.Clear();
lookup.Clear();
List<GameObject> toDelete = new List<GameObject>();
if (Application.isPlaying)
{
Mesh mesh = new Mesh();
List<Vector3> vertices = new List<Vector3>();
List<Color> colors = new List<Color>();
List<int>triangles = new List<int>();
List<int> subTriangles = new List<int>();
List<Vector2> uv = new List<Vector2>();
int submeshCount = 0;
sprites.Sort(SpritesByDepth);
for (int c = 0; c < sprites.Count; c++)
{
OTSprite sprite = sprites[sprites.Count - 1 - c];
GameObject g = sprite.gameObject;
MeshFilter mf = g.GetComponent<MeshFilter>();
if (mf.mesh != null)
{
SpriteData data = new SpriteData();
string scId = sprite.materialReference;
if (sprite is OTFilledSprite)
scId += "|"+sprite.GetInstanceID();
if (sprite.spriteContainer != null)
scId += "|"+sprite.spriteContainer.GetInstanceID();
else
if (sprite.image != null)
scId += "|" + sprite.image.GetInstanceID();
if (checkTintedAlpha && (sprite.materialReference == "tint" || sprite.materialReference=="alpha"))
scId += "|" + sprite.tintColor + "|" + sprite.alpha;
if (scId != "-1")
{
data.subMesh = -1;
if (packTextures)
{
if (packedMaterial != null)
mat = new Material(packedMaterial);
if (mat == null)
{
mat = new Material(sprite.otRenderer.material);
}
if (!texturesToPack.Contains(sprite.otRenderer.material.mainTexture as Texture2D))
{
texturesToPack.Add(sprite.otRenderer.material.mainTexture as Texture2D);
data.textureIdx = texturesToPack.Count - 1;
}
else
data.textureIdx = texturesToPack.IndexOf(sprite.otRenderer.material.mainTexture as Texture2D);
}
else
{
if (!submeshTriangles.ContainsKey(scId))
{
subTriangles = new List<int>();
submeshTriangles.Add(scId, subTriangles);
mat = new Material(sprite.otRenderer.material);
if (sprite.spriteContainer != null)
mat.mainTexture = sprite.spriteContainer.GetTexture();
else
mat.mainTexture = sprite.image;
if (!(sprite is OTFilledSprite))
{
mat.mainTextureScale = Vector2.one;
mat.mainTextureOffset = Vector2.zero;
}
submeshMaterials.Add(mat);
submeshCount++;
submeshes.Add(scId);
}
else
subTriangles = submeshTriangles[scId];
data.subMesh = submeshes.IndexOf(scId);
}
}
#if UNITY_3_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5
data.active = sprite.gameObject.active;
if (deactivateSprites)
sprite.gameObject.active = false;
#else
data.active = sprite.gameObject.activeSelf;
if (deactivateSprites)
sprite.gameObject.SetActive(false);
#endif
data.index = spriteData.Count;
data.sprite = sprite;
data.mf = mf;
data.position = sprite.position;
data.rotation = sprite.rotation;
data.size = sprite.size;
data.depth = sprite.depth;
data.verticeIdx = vertices.Count;
data.triangleIdx = triangles.Count;
data.subTriangleIdx = subTriangles.Count;
data.uvIdx = uv.Count;
data.image = sprite.image;
data.container = sprite.spriteContainer;
data.frameIndex = sprite.frameIndex;
data.vertexCount = mf.mesh.vertexCount;
Vector3[] vts = GetVertices(data);
vertices.AddRange(vts);
int[] tri = GetTriangles(data);
colors.AddRange(GetColors(data));
triangles.AddRange(tri);
subTriangles.AddRange(tri);
data.triCount = tri.Length;
Vector2[] _uv = GetUV(data,vts.Length);
data.uvCount = _uv.Length;
uv.AddRange(_uv);
lookup.Add(data.sprite.GetInstanceID(), spriteData.Count);
spriteData.Add(data);
if (!deactivateSprites)
data.sprite._iMsg = "hide";
}
}
while (toDelete.Count > 0)
{
DestroyImmediate(toDelete[0]);
toDelete.RemoveAt(0);
}
mesh.vertices = vertices.ToArray();
mesh.colors = colors.ToArray();
mesh.triangles = triangles.ToArray();
if (!packTextures && submeshCount > 1)
{
mesh.uv = uv.ToArray();
mesh.subMeshCount = submeshCount;
for (int i = submeshCount - 1; i >= 0; i--)
mesh.SetTriangles(submeshTriangles[submeshes[i]].ToArray(), i);
otRenderer.materials = submeshMaterials.ToArray();
}
else
{
if (packTextures)
{
if (packedTexture == null)
packedTexture = new Texture2D(maxAtlasSize, maxAtlasSize);
packedUvs = new List<Rect>(packedTexture.PackTextures(texturesToPack.ToArray(), 0, maxAtlasSize, false));
for (int s = 0; s < spriteData.Count; s++)
{
SpriteData data = spriteData[s];
Rect uvBase = packedUvs[data.textureIdx];
for (int u = 0; u < data.uvCount; u++)
{
Vector2 v = uv[data.uvIdx + u];
uv[data.uvIdx + u] = new Vector2(uvBase.x + (uvBase.width * v.x), uvBase.y + (uvBase.height * v.y));
}
}
}
mesh.uv = uv.ToArray();
mesh.subMeshCount = 1;
otRenderer.materials = new Material[] { };
otRenderer.material = mat;
if (packTextures)
mat.mainTexture = packedTexture;
}
mesh.RecalculateBounds();
mesh.RecalculateNormals();
visible = true;
return mesh;
}
else
return null;
}
public static void generate3DMeshFrom2D(GameObject g, SpriteData sprite, float depth = 0.0625f) {
ExtrudeSprite extrudeSprite = g.AddComponent<ExtrudeSprite> () as ExtrudeSprite;
extrudeSprite.GenerateMesh (sprite.texture_2d, depth);
}
/* *** Private Methods *** */
/// <summary>
/// Read and parse atlas data from XML file.
/// </summary>
private void ImportAtlasData()
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(atlasDataFile.text);
XmlNode frames = xml.DocumentElement.SelectSingleNode("dict/key");
List<AtlasData> data = new List<AtlasData>();
if (frames != null && frames.InnerText == "frames") {
XmlNodeList subTextureNames = xml.DocumentElement.SelectNodes("dict/dict/key");
XmlNodeList subTextures = xml.DocumentElement.SelectNodes("dict/dict/dict");
try {
for (int si = 0; si < subTextures.Count; si++) {
_subTexture = subTextures[si];
AtlasData ad = new AtlasData();
bool rotated = _subTexture.GetBool("rotated");
Rect frame = _subTexture.GetRect("frame");
Rect colorRect = _subTexture.GetRect("sourceColorRect");
Vector2 sourceSize = _subTexture.GetVector2("sourceSize");
try {
ad.name = subTextureNames[si].InnerText.Split('.')[0];
} catch (System.Exception) {
ad.name = subTextureNames[si].InnerText;
}
ad.position = new Vector2(frame.xMin, frame.yMin);
ad.rotated = rotated;
ad.size = new Vector2(colorRect.width, colorRect.height);
ad.frameSize = sourceSize;
ad.offset = new Vector2(colorRect.xMin, colorRect.yMin);
data.Add(ad);
}
} catch (System.Exception ERR) {
Debug.LogError("Atlas Import error!");
Debug.LogError(ERR.Message);
}
}
InitVertices();
spriteData = new SpriteData[data.Count];
SpriteData sprite = null;
for (int i = 0; i < data.Count; i++) {
sprite = new SpriteData();
sprite.name = data[i].name;
sprite.size = data[i].size;
sprite.sheetPixelCoords = data[i].position;
sprite.texture = texture;
sprite.UpdateUVs();
spriteData[i] = sprite;
}
}
public void AddWeaponSprite(SpriteData sd)
{
Sprites.Add(sd);
}
public void AssignRootSprite( SpriteData spriteData )
{
CurrentAnimation = spriteData.Animations[spriteData.DefaultAnimationName];
CurrentFrame = 0;
CurrentAnimationDirection = spriteData.DefaultAnimationDirection;
FrameStartTime = TimeSpan.MinValue;
IsAnimating = false;
AnimationEndingAction = AnimationEndingAction.Stop;
mRootSpriteAnimation = spriteData;
mSpriteList = new List<SpriteItem>( 1 );
mSpriteTable = new Dictionary<string, SpriteItem>();
// Add the initial root sprite
mSpriteList.Add( new SpriteItem( spriteData,
CurrentAnimationDirection,
CurrentAnimationName,
CurrentFrame ) );
}
int[] GetTriangles(SpriteData data)
{
List<int> newTriangles = new List<int>();
newTriangles.AddRange(data.mf.mesh.triangles);
for (int t = 0; t < newTriangles.Count; t++)
newTriangles[t] += data.verticeIdx;
return newTriangles.ToArray();
}
Vector2[] GetUV(SpriteData data, int count)
{
Vector2[] meshUV = new Vector2[]{};
if (data.sprite.spriteContainer != null || data.sprite.image!=null)
{
// OTContainer.Frame frame = data.sprite.CurrentFrame();
if (data.sprite.uv != null)
meshUV = data.sprite.uv.Clone() as Vector2[];
}
else
{
meshUV = new Vector2[] { };
Array.Resize<Vector2>(ref meshUV, count);
}
return meshUV;
}
Vector3[] GetVertices(SpriteData data)
{
Matrix4x4 matrix = new Matrix4x4();
Vector3 scale = data.sprite.otTransform.lossyScale;
matrix.SetTRS( data.sprite.otTransform.position - otTransform.position, data.sprite.otTransform.rotation, scale);
Vector3[] newVertices = data.mf.mesh.vertices;
for (int v = 0; v < newVertices.Length; v++)
newVertices[v] = matrix.MultiplyPoint3x4(newVertices[v]);
return newVertices;
}
private unsafe void RenderBatch(Texture2D texture, SpriteData[] sprites, int offset, int count)
{
graphicsDevice.Textures[0] = texture;
float num = 1f / (float)texture.Width;
float num2 = 1f / (float)texture.Height;
while (count > 0)
{
SetDataOptions options = SetDataOptions.NoOverwrite;
int num3 = count;
if (num3 > 2048 - vertexBufferPosition)
{
num3 = 2048 - vertexBufferPosition;
if (num3 < 256)
{
vertexBufferPosition = 0;
options = SetDataOptions.Discard;
num3 = count;
if (num3 > 2048)
num3 = 2048;
}
}
fixed (SpriteData* ptr = &sprites[offset])
{
fixed (VertexPositionColorTexture* ptr2 = &vertices[0])
{
SpriteData* ptr3 = ptr;
VertexPositionColorTexture* ptr4 = ptr2;
for (int i = 0; i < num3; i++)
{
float num4 = ptr3->Origin.X / ptr3->Source.Z;
float num5 = ptr3->Origin.Y / ptr3->Source.W;
ptr4->Color = (*ptr3).Colors.TopLeftColor;
ptr4[1].Color = ptr3->Colors.TopRightColor;
ptr4[2].Color = ptr3->Colors.BottomRightColor;
ptr4[3].Color = ptr3->Colors.BottomLeftColor;
for (int j = 0; j < 4; j++)
{
float num6 = xCornerOffsets[j];
float num7 = yCornerOffsets[j];
float num8 = (num6 - num4) * ptr3->Destination.Z;
float num9 = (num7 - num5) * ptr3->Destination.W;
float x = ptr3->Destination.X + num8;
float y = ptr3->Destination.Y + num9;
if ((ptr3->Effects & SpriteEffects.FlipVertically) != SpriteEffects.None)
num6 = 1f - num6;
if ((ptr3->Effects & SpriteEffects.FlipHorizontally) != SpriteEffects.None)
num7 = 1f - num7;
ptr4->Position.X = x;
ptr4->Position.Y = y;
ptr4->Position.Z = 0f;
ptr4->TextureCoordinate.X = (ptr3->Source.X + num6 * ptr3->Source.Z) * num;
ptr4->TextureCoordinate.Y = (ptr3->Source.Y + num7 * ptr3->Source.W) * num2;
ptr4++;
}
ptr3++;
}
}
}
int offsetInBytes = vertexBufferPosition * sizeof(VertexPositionColorTexture) * 4;
vertexBuffer.SetData<VertexPositionColorTexture>(offsetInBytes, vertices, 0, num3 * 4, sizeof(VertexPositionColorTexture), options);
int minVertexIndex = vertexBufferPosition * 4;
int numVertices = num3 * 4;
int startIndex = vertexBufferPosition * 6;
int primitiveCount = num3 * 2;
graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, minVertexIndex, numVertices, startIndex, primitiveCount);
vertexBufferPosition += num3;
offset += num3;
count -= num3;
}
}
public void Initialize(DungeonEntity e, SpriteData sd, LinkedSpriteManager ls)
{
entity = e;
spriteData = sd;
lsManager = ls;
Texture texture = lsManager.material.mainTexture;
Vector2 textDim = new Vector2(texture.width, texture.height);
uvDim = new Vector2(spriteData.spriteDim.x / textDim.x, spriteData.spriteDim.y / textDim.y);
Vector2 uvCoord = Vector2.zero;
uvCoord.x = uvDim.x * 7;
uvCoord.y = 1 - (spriteData.spriteDim.y * (spriteData.spriteIndex + 1) / textDim.y);
sprite = lsManager.AddSprite(gameObject, spriteData.dim.x, spriteData.dim.y, uvCoord, uvDim, Vector3.up * 0.5f, true);
visible = true;
transform.localPosition = Vector3.up * sd.dim.y/2;
Vector2 pos;
UVAnimation walking_s = new UVAnimation();
pos = new Vector2(0, uvCoord.y);
walking_s.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_s.name = "walking_s";
walking_s.loopCycles = -1;
UVAnimation walking_nw = new UVAnimation();
pos = new Vector2(uvDim.x * 3, uvCoord.y);
walking_nw.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_nw.name = "walking_nw";
walking_nw.loopCycles = -1;
UVAnimation walking_sw = new UVAnimation();
pos = new Vector2(uvDim.x * 3, uvCoord.y);
walking_sw.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_sw.name = "walking_sw";
walking_sw.loopCycles = -1;
UVAnimation walking_ne = new UVAnimation();
pos = new Vector2(uvDim.x * 6, uvCoord.y);
walking_ne.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_ne.name = "walking_ne";
walking_ne.loopCycles = -1;
UVAnimation walking_se = new UVAnimation();
pos = new Vector2(uvDim.x * 6, uvCoord.y);
walking_se.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_se.name = "walking_se";
walking_se.loopCycles = -1;
UVAnimation walking_n = new UVAnimation();
pos = new Vector2(uvDim.x * 9, uvCoord.y);
walking_n.BuildUVAnim(pos, uvDim, 3, 1, 3, 10);
walking_n.name = "walking_n";
walking_n.loopCycles = -1;
sprite.AddAnimation(walking_n);
sprite.AddAnimation(walking_ne);
sprite.AddAnimation(walking_nw);
sprite.AddAnimation(walking_s);
sprite.AddAnimation(walking_se);
sprite.AddAnimation(walking_sw);
}
/******* PARSING DATA ************/
//add an atlas, and then take out it's elements and put them into m_Atlases
private void addAtlasData(FAtlas _atlas, string _atlasID)
{
int elementCount = _atlas.elements.Count;
for(int e = 0; e<elementCount; ++e)
{
FAtlasElement element = _atlas.elements[e];
element.atlas = _atlas;
element.atlasIndex = _atlas.index;
//remember the concention "ID-ANIMATION-#-DELAY"
string[] name = element.name.Split('-');
int length = name.Length;
string id = name[0];
string animation = length > 1 ? name[1] : "default";
int frameNum = length > 2 ? int.Parse(name[2]) : 1;
float delay = length > 3 ? 1.0f/float.Parse(name[3]) : 1.0f/60.0f;
Frame frame = new Frame();
frame.Num = frameNum;
frame.Element = element;
frame.Delay = delay;
if(!m_spriteData.ContainsKey(id)) {
SpriteData spriteData = new SpriteData();
spriteData.data = new Dictionary<string, List<Frame>>();
spriteData.data.Add(animation, new List<Frame>());
spriteData.data[animation].Add(frame);
spriteData.AtlasID = _atlasID;
m_spriteData[id] = spriteData;
}
else {
//it's a duplicate, so check for new animation name
SpriteData spriteData = m_spriteData[id];
//duplicate animName, add to list
if(!spriteData.data.ContainsKey(animation)) {
spriteData.data[animation] = new List<Frame>();
}
//add frame
spriteData.data[animation].Add(frame);
//then sort
spriteData.data[animation] = spriteData.data[animation].OrderBy(f=>f.Num).ToList();
}
}
}
public SpriteItem( SpriteData sprite,
Direction currentDirection,
string currentAnimation,
int currentFrame)
{
AnimationData animation = sprite.Animations[currentAnimation];
SourceSprite = sprite;
AtlasTexture = sprite.Texture;
AtlasSpriteRect = animation.GetSpriteRectFor( currentDirection, currentFrame );
OriginOffset = sprite.OriginOffset;
}
Color[] GetColors(SpriteData data)
{
Color[] co = new Color[] {};
co = data.sprite.colors;
if (!data.sprite.visible)
{
for (int i=0; i<co.Length; i++)
co[i] = Color.clear;
}
return co;
}
void Build(SpriteData data)
{
MeshFilter mf = GetComponent<MeshFilter>();
if (mf != null && mf.mesh != null && mf.mesh.vertexCount>0)
{
int vi = data.verticeIdx;
int vc = data.vertexCount;
int ep = vi + vc;
int ti = data.triangleIdx;
int sti = data.subTriangleIdx;
int tc = data.triCount;
int tep = ti + tc;
int step = sti + tc;
data.position = data.sprite.position;
data.rotation = data.sprite.rotation;
data.size = data.sprite.size;
data.depth = data.sprite.depth;
data.frameIndex = data.sprite.frameIndex;
Vector2[] meshUvs = mf.mesh.uv;
Color[] meshColors = mf.mesh.colors;
Vector3[] meshVs = mf.mesh.vertices;
int[] meshTri = mf.mesh.triangles;
List<int[]> subTris = new List<int[]>();
Material[] materials = otRenderer.materials;
for (int i=0; i<mf.mesh.subMeshCount; i++)
subTris.Add(mf.mesh.GetTriangles(i));
// temporary clear triangles and sub triangles;
// adjust vertices
Vector3[] spriteVs = GetVertices(data);
Vector3[] vs = new Vector3[meshVs.Length - vc + spriteVs.Length];
Array.Copy(meshVs, 0, vs, 0, vi);
Array.Copy(spriteVs, 0, vs, vi, spriteVs.Length);
Array.Copy(meshVs, ep, vs, vi + spriteVs.Length, meshVs.Length - ep);
int vDelta = spriteVs.Length - vc;
if (vDelta!=0)
mf.mesh.triangles = new int[] {};
mf.mesh.vertices = vs;
data.vertexCount = spriteVs.Length;
// adjust uv coordinates
Vector2[] spriteUvs = GetUV(data,spriteVs.Length);
data.uvCount = spriteUvs.Length;
Vector2[] us = new Vector2[vs.Length];
Array.Copy(meshUvs, 0, us, 0, vi);
Array.Copy(spriteUvs, 0, us, vi, spriteUvs.Length);
Array.Copy(meshUvs, ep, us, vi + spriteUvs.Length, meshUvs.Length - ep);
// check if vertexcount and triangles have changed
if (vDelta!=0)
{
// adjust triangles
int[] spriteTri = GetTriangles(data);
// re-index all vertex indices
for (int i=0; i<meshTri.Length; i++)
if (meshTri[i]>=data.verticeIdx+vc)
meshTri[i] += vDelta;
// re-index vertex indices of the submeshes
if (!packTextures)
for (int i=subTris.Count-1; i>=0; i--)
{
for (int ii=0; ii<subTris[i].Length; ii++)
if (subTris[i][ii]>=data.verticeIdx+vc)
subTris[i][ii] += vDelta;
}
// adjust vertex and uv index for this sprite in the batch
for (int s=0; s < spriteData.Count; s++)
{
if (spriteData[s].sprite!=null)
{
if (spriteData[s].sprite!=data.sprite && spriteData[s].verticeIdx>=data.verticeIdx)
{
SpriteData d = spriteData[s];
d.verticeIdx += vDelta;
d.uvIdx += vDelta;
spriteData[s] = d;
}
}
}
int tDelta = spriteTri.Length - data.triCount;
// adjust triangles
data.triCount = spriteTri.Length;
int[] tri = new int[meshTri.Length - tc + spriteTri.Length ];
Array.Copy(meshTri, 0, tri, 0, ti);
Array.Copy(spriteTri, 0, tri, ti, spriteTri.Length);
Array.Copy(meshTri, tep, tri, ti + spriteTri.Length, meshTri.Length - tep);
if (!packTextures)
{
int[] subMeshTri = subTris[data.subMesh];
int[] stri = new int[subMeshTri.Length - tc + spriteTri.Length ];
Array.Copy(subMeshTri, 0, stri, 0, sti);
Array.Copy(spriteTri, 0, stri, sti, spriteTri.Length);
Array.Copy(subMeshTri, step, stri, sti + spriteTri.Length, subMeshTri.Length - step);
subTris[data.subMesh] = stri;
// adjust submesh triangle index for this sprite in the batch
for (int s=0; s < spriteData.Count; s++)
if (spriteData[s].sprite!=null && spriteData[s].subMesh == data.subMesh && spriteData[s].sprite!=data.sprite && spriteData[s].subTriangleIdx>=data.subTriangleIdx)
{
SpriteData d = spriteData[s];
d.subTriangleIdx += tDelta;
spriteData[s] = d;
}
}
// adjust triangle index for this sprite in the batch
for (int s=0; s < spriteData.Count; s++)
if (spriteData[s].sprite!=null && spriteData[s].sprite!=data.sprite && spriteData[s].triangleIdx>data.triangleIdx)
{
SpriteData d = spriteData[s];
d.triangleIdx += tDelta;
spriteData[s] = d;
}
mf.mesh.triangles = tri;
}
// adjust colors
Color[] spriteColors = GetColors(data);
Color[] cs = new Color[meshColors.Length - vc + spriteColors.Length];
Array.Copy(meshColors, 0, cs, 0, vi);
Array.Copy(spriteColors, 0, cs, vi, spriteColors.Length);
Array.Copy(meshColors, ep, cs, vi + spriteColors.Length, meshColors.Length - ep);
mf.mesh.colors = cs;
spriteData[data.index] = data;
if (packTextures)
{
Rect uvBase = packedUvs[data.textureIdx];
for (int u = 0; u < data.uvCount; u++)
{
Vector2 v = us[data.uvIdx + u];
us[data.uvIdx + u] = new Vector2(uvBase.x + (uvBase.width * v.x), uvBase.y + (uvBase.height * v.y));
}
}
else
{
if (data.sprite is OTFilledSprite || (checkTintedAlpha && (data.sprite.materialReference == "tint" || data.sprite.materialReference == "alpha")))
{
materials[data.subMesh] = data.sprite.otRenderer.material;
if (vDelta == 0)
otRenderer.materials = materials;
}
if (vDelta!=0)
{
mf.mesh.subMeshCount = subTris.Count;
for (int i=subTris.Count-1; i>=0; i--)
mf.mesh.SetTriangles(subTris[i],i);
otRenderer.materials = materials;
}
}
mf.mesh.uv = us;
mf.mesh.RecalculateBounds();
mf.mesh.RecalculateNormals();
}
}
private void RebuildBuffer()
{
List<SpriteInstance> tempInstances = null;
lock (m_instances)
{
tempInstances = new List<SpriteInstance>(m_instances);
}
var length = tempInstances.Count;
if (length != 0)
{
var data = new SpriteData[length];
Parallel.For(0, length, i =>
{
var instance = tempInstances[i];
var sprite = instance.Sprite;
var matrix = Matrix4.Identity;
if (instance.RotateFromOrigin)
{
matrix *= Matrix4.Translate(instance.Position.X, instance.Position.Y, 0f);
matrix *= Matrix4.RotateZ(instance.Angle);
//matrix *= Matrix4.Translate(-instance.Size.X, -instance.Size.Y, 0f);
}
else
{
matrix *= Matrix4.Translate(instance.Position.X + instance.Size.X / 2, instance.Position.Y + instance.Size.Y / 2, 0f);
matrix *= Matrix4.RotateZ(instance.Angle);
matrix *= Matrix4.Translate(-instance.Size.X / 2, -instance.Size.Y / 2, 0f);
}
matrix *= Matrix4.Scale(instance.Size.X, instance.Size.Y, 0f);
data[i] = new SpriteData()
{
Color = instance.Color,
Transform = matrix,
TextureOrigin = sprite.Coordinates.Position,
TextureTarget = sprite.Coordinates.Position + sprite.Coordinates.Size
};
});
GL.BindVertexArray(m_vao);
m_bufferSprite.SetData(data, GL.STREAM_DRAW);
}
else
{
GL.BindVertexArray(m_vao);
m_bufferSprite.SetData(null, GL.STREAM_DRAW);
}
m_isDirty = false;
}
/// <summary>
/// Sets the pose.
/// </summary>
/// <param name='pose'>
/// Pose.
/// </param>
protected void SetPose(int pose)
{
data = new SpriteData(graphic, 0, pixelSize.y*pose, pixelSize.x, pixelSize.y, centerPivot.x, centerPivot.y);
}
public void AddSpriteData(SpriteData sd)
{
Sprites.Add(sd);
}
public void AddSprite( string name, SpriteData spriteData )
{
SpriteItem item = new SpriteItem( spriteData,
CurrentAnimationDirection,
CurrentAnimationName,
CurrentFrame );
mSpriteList.Add( item );
mSpriteTable.Add( name, item );
}
