C# UISpriteData类代码示例

 public void CopyBorderFrom(UISpriteData sd)
 {
     this.borderLeft = sd.borderLeft;
     this.borderRight = sd.borderRight;
     this.borderTop = sd.borderTop;
     this.borderBottom = sd.borderBottom;
 }

	protected void SetAtlasSprite(UISpriteData sprite){
		mSpriteSet = true;
		if (sprite != null) {
			mSprite = sprite;
			mSpriteName = mSprite.name;
		} else {
			mSpriteName = (mSprite!=null) ? mSprite.name : "";
			mSprite = sprite;
		}
	}

 public void CopyFrom(UISpriteData sd)
 {
     this.name = sd.name;
     this.x = sd.x;
     this.y = sd.y;
     this.width = sd.width;
     this.height = sd.height;
     this.borderLeft = sd.borderLeft;
     this.borderRight = sd.borderRight;
     this.borderTop = sd.borderTop;
     this.borderBottom = sd.borderBottom;
     this.paddingLeft = sd.paddingLeft;
     this.paddingRight = sd.paddingRight;
     this.paddingTop = sd.paddingTop;
     this.paddingBottom = sd.paddingBottom;
 }

    /// <summary>
    /// Add a new sprite to the atlas, given the texture it's coming from and the packed rect within the atlas.
    /// </summary>
    static UISpriteData AddSprite(List<UISpriteData> sprites, SpriteEntry se)
    {
        // See if this sprite already exists
        foreach (UISpriteData sp in sprites)
        {
            if (sp.name == se.name)
            {
                sp.CopyFrom(se);
                return sp;
            }
        }

        UISpriteData sprite = new UISpriteData();
        sprite.CopyFrom(se);
        sprites.Add(sprite);
        return sprite;
    }

	/// <summary>
	/// Copy all values of the specified sprite data.
	/// </summary>

	public void CopyFrom (UISpriteData sd)
	{
		name = sd.name;

		x = sd.x;
		y = sd.y;
		width = sd.width;
		height = sd.height;
		
		borderLeft = sd.borderLeft;
		borderRight = sd.borderRight;
		borderTop = sd.borderTop;
		borderBottom = sd.borderBottom;
		
		paddingLeft = sd.paddingLeft;
		paddingRight = sd.paddingRight;
		paddingTop = sd.paddingTop;
		paddingBottom = sd.paddingBottom;
	}

    // Use this for initialization
    void Start()
    {
        Texture2D textrue = AvatarAssetManager.s.getTexture("skin/cloth/1");
        Shader shader = Shader.Find("Unlit/Transparent Colored");
        Material mat = new Material(shader);
        mat.mainTexture = textrue;
        UISpriteData uiSpData = new UISpriteData();
        uiSpData.width = textrue.width;
        uiSpData.height = textrue.height;
        UIAtlas atlas = gameObject.AddComponent<UIAtlas>();
        atlas.spriteMaterial = mat;
        List<UISpriteData> list = new List<UISpriteData>();
        list.Add(uiSpData);
        atlas.spriteList = list;

        UISprite sp = gameObject.AddComponent<UISprite>();
        sp.atlas = atlas;
        sp.MakePixelPerfect();
    }

        public void SetUp()
        {
            GameObject go = new GameObject();
              atlas = go.AddComponent<UIAtlas>();
              sprite = go.AddComponent<UISprite>();
              sprite.atlas = atlas;
              sprite.spriteName = "testSprite";

              UISpriteData[] spriteDatas = new UISpriteData[] {
            new UISpriteData() {
              name = "available"
            },
            new UISpriteData() {
              name = "unused"
            }
              };

              sprite.spriteName = "available";
              atlas.spriteList.AddRange(spriteDatas);

              usages = new AtlasUsages(atlas);
        }

	public UISpriteData GetAltasSprite(){
		if (!mSpriteSet) {
			mSprite = null;
		}
		if (mSprite == null && Atlas != null) {
			if(!string.IsNullOrEmpty(mSpriteName)){
				UISpriteData sp = Atlas.GetSprite(mSpriteName);
				if(sp == null) return null;
				SetAtlasSprite(sp);
			}
			if(mSprite == null && Atlas.spriteList.Count > 0){
				UISpriteData sp = Atlas.spriteList[0];
				if(sp == null) return null;
				SetAtlasSprite(sp);
				if(mSprite == null){
					this.PRINT(Atlas.name+"seems to have a null sprite");
					return null;
				}
				mSpriteName = mSprite.name;
			}
		}
		return mSprite;
	}

	/// <summary>
	/// Extract the specified sprite from the atlas texture.
	/// </summary>

	static SpriteEntry ExtractSprite (UISpriteData es, Color32[] oldPixels, int oldWidth, int oldHeight)
	{
		int xmin = Mathf.Clamp(es.x, 0, oldWidth);
		int ymin = Mathf.Clamp(es.y, 0, oldHeight);
		int xmax = Mathf.Min(xmin + es.width, oldWidth - 1);
		int ymax = Mathf.Min(ymin + es.height, oldHeight - 1);
		int newWidth = Mathf.Clamp(es.width, 0, oldWidth);
		int newHeight = Mathf.Clamp(es.height, 0, oldHeight);

		if (newWidth == 0 || newHeight == 0) return null;

		Color32[] newPixels = new Color32[newWidth * newHeight];

		for (int y = 0; y < newHeight; ++y)
		{
			int cy = ymin + y;
			if (cy > ymax) cy = ymax;

			for (int x = 0; x < newWidth; ++x)
			{
				int cx = xmin + x;
				if (cx > xmax) cx = xmax;

				int newIndex = (newHeight - 1 - y) * newWidth + x;
				int oldIndex = (oldHeight - 1 - cy) * oldWidth + cx;

				newPixels[newIndex] = oldPixels[oldIndex];
			}
		}

		// Create a new sprite
		SpriteEntry sprite = new SpriteEntry();
		sprite.CopyFrom(es);
		sprite.SetRect(0, 0, newWidth, newHeight);
		sprite.temporaryTexture = true;
		sprite.tex = new Texture2D(newWidth, newHeight);
		sprite.tex.SetPixels32(newPixels);
		sprite.tex.Apply();
		return sprite;
	}

    /// <summary>
    /// Performs an upgrade from the legacy way of specifying data to the new one.
    /// </summary>
    bool Upgrade()
    {
        if (mSprites.Count == 0 && sprites.Count > 0)
        {
            Texture tex = material.mainTexture;
            int width = (tex != null) ? tex.width : 512;
            int height = (tex != null) ? tex.height : 512;

            for (int i = 0; i < sprites.Count; ++i)
            {
                Sprite old = sprites[i];
                Rect outer = old.outer;
                Rect inner = old.inner;

                if (mCoordinates == Coordinates.TexCoords)
                {
                    NGUIMath.ConvertToPixels(outer, width, height, true);
                    NGUIMath.ConvertToPixels(inner, width, height, true);
                }

                UISpriteData sd = new UISpriteData();
                sd.name = old.name;

                sd.x = Mathf.RoundToInt(outer.xMin);
                sd.y = Mathf.RoundToInt(outer.yMin);
                sd.width = Mathf.RoundToInt(outer.width);
                sd.height = Mathf.RoundToInt(outer.height);

                sd.paddingLeft = Mathf.RoundToInt(old.paddingLeft * outer.width);
                sd.paddingRight = Mathf.RoundToInt(old.paddingRight * outer.width);
                sd.paddingBottom = Mathf.RoundToInt(old.paddingBottom * outer.height);
                sd.paddingTop = Mathf.RoundToInt(old.paddingTop * outer.height);

                sd.borderLeft = Mathf.RoundToInt(inner.xMin - outer.xMin);
                sd.borderRight = Mathf.RoundToInt(outer.xMax - inner.xMax);
                sd.borderBottom = Mathf.RoundToInt(inner.yMin - outer.yMin);
                sd.borderTop = Mathf.RoundToInt(outer.yMax - inner.yMax);

                mSprites.Add(sd);
            }
            sprites.Clear();
        #if UNITY_EDITOR
            UnityEditor.EditorUtility.SetDirty(this);
            UnityEditor.AssetDatabase.SaveAssets();
        #endif
            return true;
        }
        return false;
    }

 public UISpriteData GetAtlasSprite()
 {
     if (!this.mSpriteSet)
     {
         this.mSprite = null;
     }
     if ((this.mSprite == null) && (this.mAtlas != null))
     {
         if (!string.IsNullOrEmpty(this.mSpriteName))
         {
             UISpriteData sprite = this.mAtlas.GetSprite(this.mSpriteName);
             if (sprite == null)
             {
                 return null;
             }
             this.SetAtlasSprite(sprite);
         }
         if ((this.mSprite == null) && (this.mAtlas.spriteList.Count > 0))
         {
             UISpriteData sp = this.mAtlas.spriteList[0];
             if (sp == null)
             {
                 return null;
             }
             this.SetAtlasSprite(sp);
             if (this.mSprite == null)
             {
                 Debug.LogError(this.mAtlas.name + " seems to have a null sprite!");
                 return null;
             }
             this.mSpriteName = this.mSprite.name;
         }
     }
     return this.mSprite;
 }

	/// <summary>
	/// Add a dark shadowy outline around the sprite, giving it some visual depth.
	/// </summary>

	void AddDepth (UISpriteData sprite)
	{
		List<UIAtlasMaker.SpriteEntry> sprites = new List<UIAtlasMaker.SpriteEntry>();
		UIAtlasMaker.ExtractSprites(mAtlas, sprites);
		UIAtlasMaker.SpriteEntry se = null;

		for (int i = 0; i < sprites.Count; ++i)
		{
			if (sprites[i].name == sprite.name)
			{
				se = sprites[i];
				break;
			}
		}

		if (se != null)
		{
			int w1 = se.tex.width;
			int h1 = se.tex.height;

			int w2 = w1 + 2;
			int h2 = h1 + 2;

			Color32[] c1 = se.tex.GetPixels32();
			Color32[] c2 = new Color32[w2 * h2];

			for (int y2 = 0; y2 < h2; ++y2)
			{
				int y1 = NGUIMath.ClampIndex(y2 - 1, h1);

				for (int x2 = 0; x2 < w2; ++x2)
				{
					int x1 = NGUIMath.ClampIndex(x2 - 1, w1);
					int i2 = x2 + y2 * w2;
					c2[i2] = c1[x1 + y1 * w1];

					if (x2 == 0 || x2 + 1 == w2 || y2 == 0 || y2 + 1 == h2)
						c2[i2].a = 0;
				}
			}

			for (int y2 = 0; y2 < h2; ++y2)
			{
				for (int x2 = 0; x2 < w2; ++x2)
				{
					int index = x2 + y2 * w2;
					Color32 uc = c2[index];
					if (uc.a == 255) continue;

					Color original = uc;
					float val = original.a * 4f;
					int count = 4;
					float div1 = 1f / 255f;
					float div2 = 2f / 255f;

					if (x2 != 0)
					{
						val += c2[x2 - 1 + y2 * w2].a * div2;
						count += 2;
					}

					if (x2 + 1 != w2)
					{
						val += c2[x2 + 1 + y2 * w2].a * div2;
						count += 2;
					}

					if (y2 != 0)
					{
						val += c2[x2 + (y2 - 1) * w2].a * div2;
						count += 2;
					}

					if (y2 + 1 != h2)
					{
						val += c2[x2 + (y2 + 1) * w2].a * div2;
						count += 2;
					}

					if (x2 != 0 && y2 != 0)
					{
						val += c2[x2 - 1 + (y2 - 1) * w2].a * div1;
						++count;
					}

					if (x2 != 0 && y2 + 1 != h2)
					{
						val += c2[x2 - 1 + (y2 + 1) * w2].a * div1;
						++count;
					}

					if (x2 + 1 != w2 && y2 != 0)
					{
						val += c2[x2 + 1 + (y2 - 1) * w2].a * div1;
						++count;
					}
//.........这里部分代码省略.........

public static int UISpriteData(IntPtr L)
{
UISpriteData ret = new UISpriteData(
);
LuaStatic.addGameObject2Lua(L,ret,"UISpriteData");
return 1;
}

	/// <summary>
	/// Parse the specified JSon file, loading sprite information for the specified atlas.
	/// </summary>

	static void LoadSpriteData (UIAtlas atlas, Hashtable decodedHash)
	{
		if (decodedHash == null || atlas == null) return;
		List<UISpriteData> oldSprites = atlas.spriteList;
		atlas.spriteList = new List<UISpriteData>();

		Hashtable frames = (Hashtable)decodedHash["frames"];

		foreach (System.Collections.DictionaryEntry item in frames)
		{
			UISpriteData newSprite = new UISpriteData();
			newSprite.name = item.Key.ToString();

			bool exists = false;

			// Check to see if this sprite exists
			foreach (UISpriteData oldSprite in oldSprites)
			{
				if (oldSprite.name.Equals(newSprite.name, StringComparison.OrdinalIgnoreCase))
				{
					exists = true;
					break;
				}
			}

			// Get rid of the extension if the sprite doesn't exist
			// The extension is kept for backwards compatibility so it's still possible to update older atlases.
			if (!exists)
			{
				newSprite.name = newSprite.name.Replace(".png", "");
				newSprite.name = newSprite.name.Replace(".tga", "");
			}

			// Extract the info we need from the TexturePacker json file, mainly uvRect and size
			Hashtable table = (Hashtable)item.Value;
			Hashtable frame = (Hashtable)table["frame"];

			int frameX = int.Parse(frame["x"].ToString());
			int frameY = int.Parse(frame["y"].ToString());
			int frameW = int.Parse(frame["w"].ToString());
			int frameH = int.Parse(frame["h"].ToString());

			// Read the rotation value
			//newSprite.rotated = (bool)table["rotated"];

			newSprite.x = frameX;
			newSprite.y = frameY;
			newSprite.width = frameW;
			newSprite.height = frameH;

			// Support for trimmed sprites
			Hashtable sourceSize = (Hashtable)table["sourceSize"];
			Hashtable spriteSize = (Hashtable)table["spriteSourceSize"];

			if (spriteSize != null && sourceSize != null)
			{
				// TODO: Account for rotated sprites
				if (frameW > 0)
				{
					int spriteX = int.Parse(spriteSize["x"].ToString());
					int spriteW = int.Parse(spriteSize["w"].ToString());
					int sourceW = int.Parse(sourceSize["w"].ToString());

					newSprite.paddingLeft = spriteX;
					newSprite.paddingRight = sourceW - (spriteX + spriteW);
				}

				if (frameH > 0)
				{
					int spriteY = int.Parse(spriteSize["y"].ToString());
					int spriteH = int.Parse(spriteSize["h"].ToString());
					int sourceH = int.Parse(sourceSize["h"].ToString());

					newSprite.paddingTop = spriteY;
					newSprite.paddingBottom = sourceH - (spriteY + spriteH);
				}
			}

			// If the sprite was present before, see if we can copy its inner rect
			foreach (UISpriteData oldSprite in oldSprites)
			{
				if (oldSprite.name.Equals(newSprite.name, StringComparison.OrdinalIgnoreCase))
				{
					newSprite.borderLeft = oldSprite.borderLeft;
					newSprite.borderRight = oldSprite.borderRight;
					newSprite.borderBottom = oldSprite.borderBottom;
					newSprite.borderTop = oldSprite.borderTop;
				}
			}

			// Add this new sprite
			atlas.spriteList.Add(newSprite);
		}

		// Sort imported sprites alphabetically
		atlas.spriteList.Sort(CompareSprites);
//.........这里部分代码省略.........

 protected void SetAtlasSprite(UISpriteData sp)
 {
     base.mChanged = true;
     this.mSpriteSet = true;
     if (sp != null)
     {
         this.mSprite = sp;
         this.mSpriteName = this.mSprite.name;
     }
     else
     {
         this.mSpriteName = (this.mSprite == null) ? string.Empty : this.mSprite.name;
         this.mSprite = sp;
     }
 }