//page file
private void parseImageFileName(string line, string fntFile)
{
// //////////////////////////////////////////////////////////////////////////
//// line to parse:
//// page id=0 file="bitmapFontTest.png"
////////////////////////////////////////////////////////////////////////////
// page ID. Sanity check
int index = line.IndexOf('=') + 1;
int index2 = line.IndexOf(' ', index);
string value = line.Substring(index, index2 - index);
try
{
int ivalue = int.Parse(value);
}
catch (Exception)
{
throw (new ContentLoadException("Invalid page ID for FNT descriptor. Line=" + line + ", value=" + value + ", indices=" + index + "," + index2));
}
// Debug.Assert(Convert.ToInt32(value) == 0, "LabelBMFont file could not be found");
// file
index = line.IndexOf('"') + 1;
index2 = line.IndexOf('"', index);
value = line.Substring(index, index2 - index);
m_sAtlasName = CCFileUtils.FullPathFromRelativeFile(value, fntFile);
}
/// <summary>
///
/// </summary>
/// <param name="pszPlist"></param>
/// <returns>The scope parameter derived from the pszPlist parameter.</returns>
public string AddSpriteFramesWithFile(string pszPlist)
{
string pszPath = CCFileUtils.FullPathFromRelativePath(pszPlist);
//Dictionary<string, Object> dict = CCFileUtils.dictionaryWithContentsOfFile(pszPath);
PlistDictionary dict = CCApplication.SharedApplication.Content.Load <PlistDocument>(pszPlist).Root.AsDictionary;
string texturePath = "";
PlistDictionary metadataDict = dict.ContainsKey("metadata") ? dict["metadata"].AsDictionary : null;
string framePrefix = string.Empty;
if (metadataDict != null)
{
// try to read texture file name from meta data
if (metadataDict.ContainsKey("textureFileName"))
{
texturePath = metadataDict["textureFileName"].AsString;
framePrefix = ExtractPrefix(texturePath);
}
}
if (!string.IsNullOrEmpty(texturePath))
{
// build texture path relative to plist file
texturePath = CCFileUtils.FullPathFromRelativeFile(texturePath, pszPath);
}
else
{
// build texture path by replacing file extension
texturePath = pszPath;
// remove .xxx
texturePath = CCFileUtils.RemoveExtension(texturePath);
CCLog.Log("cocos2d: CCSpriteFrameCache: Trying to use file {0} as texture", texturePath);
}
CCTexture2D pTexture = CCTextureCache.SharedTextureCache.AddImage(texturePath);
if (pTexture != null)
{
AddSpriteFramesWithDictionary(dict, pTexture, framePrefix);
}
else
{
CCLog.Log("cocos2d: CCSpriteFrameCache: Couldn't load texture");
}
return(framePrefix);
}
public void AddSpriteFramesWithFile(string pszPlist)
{
PlistDocument document = CCContentManager.SharedContentManager.Load <PlistDocument>(pszPlist);
PlistDictionary dict = document.Root.AsDictionary;
string texturePath = "";
PlistDictionary metadataDict = dict.ContainsKey("metadata") ? dict["metadata"].AsDictionary : null;
if (metadataDict != null)
{
// try to read texture file name from meta data
if (metadataDict.ContainsKey("textureFileName"))
{
texturePath = metadataDict["textureFileName"].AsString;
}
}
if (!string.IsNullOrEmpty(texturePath))
{
// build texture path relative to plist file
texturePath = CCFileUtils.FullPathFromRelativeFile(texturePath, pszPlist);
}
else
{
// build texture path by replacing file extension
texturePath = pszPlist;
// remove .xxx
texturePath = CCFileUtils.RemoveExtension(texturePath);
// append .png
texturePath = texturePath + ".png";
CCLog.Log("cocos2d: CCSpriteFrameCache: Trying to use file {0} as texture", texturePath);
}
CCTexture2D pTexture = CCTextureCache.SharedTextureCache.AddImage(texturePath);
if (pTexture != null)
{
AddSpriteFramesWithDictionary(dict, pTexture);
}
else
{
CCLog.Log("cocos2d: CCSpriteFrameCache: Couldn't load texture");
}
}
public bool InitWithDictionary(PlistDictionary dictionary)
{
bool bRet = false;
do
{
int maxParticles = dictionary["maxParticles"].AsInt;
// self, not super
if (InitWithTotalParticles(maxParticles))
{
// angle
m_fAngle = dictionary["angle"].AsFloat;
m_fAngleVar = dictionary["angleVariance"].AsFloat;
// duration
m_fDuration = dictionary["duration"].AsFloat;
// blend function
m_tBlendFunc.Source = dictionary["blendFuncSource"].AsInt;
m_tBlendFunc.Destination = dictionary["blendFuncDestination"].AsInt;
// color
m_tStartColor.R = dictionary["startColorRed"].AsFloat;
m_tStartColor.G = dictionary["startColorGreen"].AsFloat;
m_tStartColor.B = dictionary["startColorBlue"].AsFloat;
m_tStartColor.A = dictionary["startColorAlpha"].AsFloat;
m_tStartColorVar.R = dictionary["startColorVarianceRed"].AsFloat;
m_tStartColorVar.G = dictionary["startColorVarianceGreen"].AsFloat;
m_tStartColorVar.B = dictionary["startColorVarianceBlue"].AsFloat;
m_tStartColorVar.A = dictionary["startColorVarianceAlpha"].AsFloat;
m_tEndColor.R = dictionary["finishColorRed"].AsFloat;
m_tEndColor.G = dictionary["finishColorGreen"].AsFloat;
m_tEndColor.B = dictionary["finishColorBlue"].AsFloat;
m_tEndColor.A = dictionary["finishColorAlpha"].AsFloat;
m_tEndColorVar.R = dictionary["finishColorVarianceRed"].AsFloat;
m_tEndColorVar.G = dictionary["finishColorVarianceGreen"].AsFloat;
m_tEndColorVar.B = dictionary["finishColorVarianceBlue"].AsFloat;
m_tEndColorVar.A = dictionary["finishColorVarianceAlpha"].AsFloat;
// particle size
m_fStartSize = dictionary["startParticleSize"].AsFloat;
m_fStartSizeVar = dictionary["startParticleSizeVariance"].AsFloat;
m_fEndSize = dictionary["finishParticleSize"].AsFloat;
m_fEndSizeVar = dictionary["finishParticleSizeVariance"].AsFloat;
// position
float x = dictionary["sourcePositionx"].AsFloat;
float y = dictionary["sourcePositiony"].AsFloat;
Position = new CCPoint(x, y);
m_tPosVar.X = dictionary["sourcePositionVariancex"].AsFloat;
m_tPosVar.Y = dictionary["sourcePositionVariancey"].AsFloat;
// Spinning
m_fStartSpin = dictionary["rotationStart"].AsFloat;
m_fStartSpinVar = dictionary["rotationStartVariance"].AsFloat;
m_fEndSpin = dictionary["rotationEnd"].AsFloat;
m_fEndSpinVar = dictionary["rotationEndVariance"].AsFloat;
m_nEmitterMode = (CCEmitterMode)dictionary["emitterType"].AsInt;
// Mode A: Gravity + tangential accel + radial accel
if (m_nEmitterMode == CCEmitterMode.kCCParticleModeGravity)
{
// gravity
modeA.gravity.X = dictionary["gravityx"].AsFloat;
modeA.gravity.Y = dictionary["gravityy"].AsFloat;
// speed
modeA.speed = dictionary["speed"].AsFloat;
modeA.speedVar = dictionary["speedVariance"].AsFloat;
// radial acceleration
modeA.radialAccel = dictionary["radialAcceleration"].AsFloat;
modeA.radialAccelVar = dictionary["radialAccelVariance"].AsFloat;
// tangential acceleration
modeA.tangentialAccel = dictionary["tangentialAcceleration"].AsFloat;
modeA.tangentialAccelVar = dictionary["tangentialAccelVariance"].AsFloat;
}
// or Mode B: radius movement
else if (m_nEmitterMode == CCEmitterMode.kCCParticleModeRadius)
{
modeB.startRadius = dictionary["maxRadius"].AsFloat;
modeB.startRadiusVar = dictionary["maxRadiusVariance"].AsFloat;
modeB.endRadius = dictionary["minRadius"].AsFloat;
modeB.endRadiusVar = 0.0f;
modeB.rotatePerSecond = dictionary["rotatePerSecond"].AsFloat;
modeB.rotatePerSecondVar = dictionary["rotatePerSecondVariance"].AsFloat;
}
else
{
Debug.Assert(false, "Invalid emitterType in config file");
break;
}
// life span
m_fLife = dictionary["particleLifespan"].AsFloat;
m_fLifeVar = dictionary["particleLifespanVariance"].AsFloat;
// emission Rate
m_fEmissionRate = m_uTotalParticles / m_fLife;
//don't get the internal texture if a batchNode is used
if (m_pBatchNode == null)
{
// Set a compatible default for the alpha transfer
m_bOpacityModifyRGB = false;
// texture
// Try to get the texture from the cache
string textureName = dictionary["textureFileName"].AsString;
string fullpath = CCFileUtils.FullPathFromRelativeFile(textureName, m_sPlistFile);
CCTexture2D tex = null;
if (!string.IsNullOrEmpty(textureName))
{
// set not pop-up message box when load image failed
bool bNotify = CCFileUtils.IsPopupNotify;
CCFileUtils.IsPopupNotify = false;
try
{
tex = CCTextureCache.SharedTextureCache.AddImage(fullpath);
}
catch (Exception)
{
tex = null;
}
// reset the value of UIImage notify
CCFileUtils.IsPopupNotify = bNotify;
}
if (tex != null)
{
Texture = tex;
}
else
{
string textureData = dictionary["textureImageData"].AsString;
Debug.Assert(textureData != null && textureData.Length > 0, string.Format("CCParticleSystem: textureData does not exist : {0}", textureName));
int dataLen = textureData.Length;
if (dataLen != 0)
{
var dataBytes = Convert.FromBase64String(textureData);
Debug.Assert(dataBytes != null, string.Format("CCParticleSystem: error decoding textureImageData : {0}", textureName));
var imageBytes = Inflate(dataBytes);
Debug.Assert(imageBytes != null, string.Format("CCParticleSystem: error init image with Data for texture : {0}", textureName));
using (var imageStream = new MemoryStream(imageBytes))
{
try
{
Texture = CCTextureCache.SharedTextureCache.AddImage(imageStream, textureName);
}
catch (Exception ex)
{
CCLog.Log(ex.ToString());
throw (new NotSupportedException("Embedded textureImageData is a format that this platform does not understand. Use PNG, GIF, or JPEG for your particle systems."));
}
}
}
}
Debug.Assert(Texture != null, string.Format("CCParticleSystem: error loading the texture : {0}", textureName));
}
bRet = true;
}
} while (false);
return(bRet);
}
public void StartElement(object ctx, string name, string[] atts)
{
CCTMXMapInfo pTMXMapInfo = this;
string elementName = name;
var attributeDict = new Dictionary <string, string>();
if (atts != null && atts[0] != null)
{
for (int i = 0; i + 1 < atts.Length; i += 2)
{
string key = atts[i];
string value = atts[i + 1];
attributeDict.Add(key, value);
}
}
if (elementName == "map")
{
string version = attributeDict["version"];
if (version != "1.0")
{
CCLog.Log("cocos2d: TMXFormat: Unsupported TMX version: {0}", version);
}
string orientationStr = attributeDict["orientation"];
if (orientationStr == "orthogonal")
{
pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Ortho);
}
else if (orientationStr == "isometric")
{
pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Iso);
}
else if (orientationStr == "hexagonal")
{
pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Hex);
}
else
{
CCLog.Log("cocos2d: TMXFomat: Unsupported orientation: {0}", pTMXMapInfo.Orientation);
}
CCSize sMapSize;
sMapSize.Width = CCUtils.CCParseFloat(attributeDict["width"]);
sMapSize.Height = CCUtils.CCParseFloat(attributeDict["height"]);
pTMXMapInfo.MapSize = sMapSize;
CCSize sTileSize;
sTileSize.Width = CCUtils.CCParseFloat(attributeDict["tilewidth"]);
sTileSize.Height = CCUtils.CCParseFloat(attributeDict["tileheight"]);
pTMXMapInfo.TileSize = sTileSize;
// The parent element is now "map"
pTMXMapInfo.ParentElement = (int)CCTMXProperty.Map;
}
else if (elementName == "tileset")
{
// If this is an external tileset then start parsing that
if (attributeDict.Keys.Contains("source"))
{
string externalTilesetFilename = attributeDict["source"];
externalTilesetFilename = CCFileUtils.FullPathFromRelativeFile(externalTilesetFilename, pTMXMapInfo.TMXFileName);
m_uCurrentFirstGID = uint.Parse(attributeDict["firstgid"]);
pTMXMapInfo.ParseXmlFile(externalTilesetFilename);
}
else
{
var tileset = new CCTMXTilesetInfo();
tileset.m_sName = attributeDict["name"];
if (m_uCurrentFirstGID == 0)
{
tileset.m_uFirstGid = uint.Parse(attributeDict["firstgid"]);
}
else
{
tileset.m_uFirstGid = m_uCurrentFirstGID;
m_uCurrentFirstGID = 0;
}
if (attributeDict.Keys.Contains("spacing"))
{
tileset.m_uSpacing = int.Parse(attributeDict["spacing"]);
}
if (attributeDict.Keys.Contains("margin"))
{
tileset.m_uMargin = int.Parse(attributeDict["margin"]);
}
CCSize s;
s.Width = CCUtils.CCParseFloat(attributeDict["tilewidth"]);
s.Height = CCUtils.CCParseFloat(attributeDict["tileheight"]);
tileset.m_tTileSize = s;
pTMXMapInfo.Tilesets.Add(tileset);
}
}
else if (elementName == "tile")
{
CCTMXTilesetInfo info = pTMXMapInfo.Tilesets.LastOrDefault();
var dict = new Dictionary <string, string>();
pTMXMapInfo.ParentGID = (info.m_uFirstGid + uint.Parse(attributeDict["id"]));
pTMXMapInfo.TileProperties.Add(pTMXMapInfo.ParentGID, dict);
pTMXMapInfo.ParentElement = (int)CCTMXProperty.Tile;
}
else if (elementName == "layer")
{
var layer = new CCTMXLayerInfo();
layer.Name = attributeDict["name"];
CCSize s;
s.Width = CCUtils.CCParseFloat(attributeDict["width"]);
s.Height = CCUtils.CCParseFloat(attributeDict["height"]);
layer.LayerSize = s;
layer.Tiles = new uint[(int)s.Width * (int)s.Height];
if (attributeDict.Keys.Contains("visible"))
{
string visible = attributeDict["visible"];
layer.Visible = !(visible == "0");
}
else
{
layer.Visible = true;
}
if (attributeDict.Keys.Contains("opacity"))
{
string opacity = attributeDict["opacity"];
layer.Opacity = (byte)(255 * CCUtils.CCParseFloat(opacity));
}
else
{
layer.Opacity = 255;
}
float x = attributeDict.Keys.Contains("x") ? CCUtils.CCParseFloat(attributeDict["x"]) : 0;
float y = attributeDict.Keys.Contains("y") ? CCUtils.CCParseFloat(attributeDict["y"]) : 0;
layer.Offset = new CCPoint(x, y);
pTMXMapInfo.Layers.Add(layer);
// The parent element is now "layer"
pTMXMapInfo.ParentElement = (int)CCTMXProperty.Layer;
}
else if (elementName == "objectgroup")
{
var objectGroup = new CCTMXObjectGroup();
objectGroup.GroupName = attributeDict["name"];
CCPoint positionOffset = CCPoint.Zero;
if (attributeDict.ContainsKey("x"))
{
positionOffset.X = CCUtils.CCParseFloat(attributeDict["x"]) * pTMXMapInfo.TileSize.Width;
}
if (attributeDict.ContainsKey("y"))
{
positionOffset.Y = CCUtils.CCParseFloat(attributeDict["y"]) * pTMXMapInfo.TileSize.Height;
}
objectGroup.PositionOffset = positionOffset;
pTMXMapInfo.ObjectGroups.Add(objectGroup);
// The parent element is now "objectgroup"
pTMXMapInfo.ParentElement = (int)CCTMXProperty.ObjectGroup;
}
else if (elementName == "image")
{
CCTMXTilesetInfo tileset = pTMXMapInfo.Tilesets.LastOrDefault();
// build full path
string imagename = attributeDict["source"];
tileset.m_sSourceImage = CCFileUtils.FullPathFromRelativeFile(imagename, pTMXMapInfo.TMXFileName);
}
else if (elementName == "data")
{
string encoding = attributeDict.ContainsKey("encoding") ? attributeDict["encoding"] : "";
string compression = attributeDict.ContainsKey("compression") ? attributeDict["compression"] : "";
if (encoding == "base64")
{
int layerAttribs = pTMXMapInfo.LayerAttribs;
pTMXMapInfo.LayerAttribs = layerAttribs | (int)CCTMXLayerAttrib.Base64;
pTMXMapInfo.StoringCharacters = true;
if (compression == "gzip")
{
layerAttribs = pTMXMapInfo.LayerAttribs;
pTMXMapInfo.LayerAttribs = layerAttribs | (int)CCTMXLayerAttrib.Gzip;
}
else if (compression == "zlib")
{
layerAttribs = pTMXMapInfo.LayerAttribs;
pTMXMapInfo.LayerAttribs = layerAttribs | (int)CCTMXLayerAttrib.Zlib;
}
Debug.Assert(compression == "" || compression == "gzip" || compression == "zlib", "TMX: unsupported compression method");
}
Debug.Assert(pTMXMapInfo.LayerAttribs != (int)CCTMXLayerAttrib.None,
"TMX tile map: Only base64 and/or gzip/zlib maps are supported");
}
else if (elementName == "object")
{
CCTMXObjectGroup objectGroup = pTMXMapInfo.ObjectGroups.LastOrDefault();
// The value for "type" was blank or not a valid class name
// Create an instance of TMXObjectInfo to store the object and its properties
var dict = new Dictionary <string, string>();
var pArray = new[] { "name", "type", "width", "height", "gid" };
for (int i = 0; i < pArray.Length; i++)
{
string key = pArray[i];
if (attributeDict.ContainsKey(key))
{
dict.Add(key, attributeDict[key]);
}
}
// But X and Y since they need special treatment
// X
int x = int.Parse(attributeDict["x"]) + (int)objectGroup.PositionOffset.X;
dict.Add("x", x.ToString());
int y = int.Parse(attributeDict["y"]) + (int)objectGroup.PositionOffset.Y;
// Correct y position. (Tiled uses Flipped, cocos2d uses Standard)
y = (int)(pTMXMapInfo.MapSize.Height * pTMXMapInfo.TileSize.Height) - y -
(attributeDict.ContainsKey("height") ? int.Parse(attributeDict["height"]) : 0);
dict.Add("y", y.ToString());
// Add the object to the objectGroup
objectGroup.Objects.Add(dict);
// The parent element is now "object"
pTMXMapInfo.ParentElement = (int)CCTMXProperty.Object;
}
else if (elementName == "property")
{
if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.None)
{
CCLog.Log("TMX tile map: Parent element is unsupported. Cannot add property named '{0}' with value '{1}'",
attributeDict["name"], attributeDict["value"]);
}
else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Map)
{
// The parent element is the map
string value = attributeDict["value"];
string key = attributeDict["name"];
pTMXMapInfo.Properties.Add(key, value);
}
else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Layer)
{
// The parent element is the last layer
CCTMXLayerInfo layer = pTMXMapInfo.Layers.LastOrDefault();
string value = attributeDict["value"];
string key = attributeDict["name"];
// Add the property to the layer
layer.Properties.Add(key, value);
}
else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.ObjectGroup)
{
// The parent element is the last object group
CCTMXObjectGroup objectGroup = pTMXMapInfo.ObjectGroups.LastOrDefault();
string value = attributeDict["value"];
string key = attributeDict["name"];
objectGroup.Properties.Add(key, value);
}
else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Object)
{
// The parent element is the last object
CCTMXObjectGroup objectGroup = pTMXMapInfo.ObjectGroups.LastOrDefault();
Dictionary <string, string> dict = objectGroup.Objects.LastOrDefault();
string propertyName = attributeDict["name"];
string propertyValue = attributeDict["value"];
dict.Add(propertyName, propertyValue);
}
else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Tile)
{
Dictionary <string, string> dict = pTMXMapInfo.TileProperties[pTMXMapInfo.ParentGID];
string propertyName = attributeDict["name"];
string propertyValue = attributeDict["value"];
dict.Add(propertyName, propertyValue);
}
}
else if (elementName == "polygon")
{
// find parent object's dict and add polygon-points to it
CCTMXObjectGroup objectGroup = m_pObjectGroups.LastOrDefault();
var dict = objectGroup.Objects.LastOrDefault();
// get points value string
var value = attributeDict["points"];
if (!String.IsNullOrEmpty(value))
{
var pPointsArray = new List <CCPoint>();
var pointPairs = value.Split(' ');
foreach (var pontPair in pointPairs)
{
//TODO: Parse points
//CCPoint point;
//point.X = x + objectGroup.PositionOffset.X;
//point.Y = y + objectGroup.PositionOffset.Y;
//pPointsArray.Add(point);
}
//dict.Add("points", pPointsArray);
}
}
else if (elementName == "polyline")
{
// find parent object's dict and add polyline-points to it
// CCTMXObjectGroup* objectGroup = (CCTMXObjectGroup*)m_pObjectGroups->lastObject();
// CCDictionary* dict = (CCDictionary*)objectGroup->getObjects()->lastObject();
// TODO: dict->setObject:[attributeDict objectForKey:@"points"] forKey:@"polylinePoints"];
}
}
public void InitWithFile(string fileName)
{
PlistDocument document = CCContentManager.SharedContentManager.Load <PlistDocument>(fileName);
var dict = document.Root.AsDictionary;
var texturePath = string.Empty;
plistFilePath = string.Empty;
plistType = GetPlistType(dict);
if (plistType == PlistType.SpriteKit)
{
var images = dict.ContainsKey("images") ? dict ["images"].AsArray : null;
var imageDict = images [0].AsDictionary;
if (imageDict != null)
{
// try to read texture file name from meta data
if (imageDict.ContainsKey("path"))
{
texturePath = imageDict ["path"].AsString;
}
}
}
else
{
var metadataDict = dict.ContainsKey("metadata") ? dict ["metadata"].AsDictionary : null;
if (metadataDict != null)
{
// try to read texture file name from meta data
if (metadataDict.ContainsKey("textureFileName"))
{
texturePath = metadataDict ["textureFileName"].AsString;
}
}
}
if (!string.IsNullOrEmpty(texturePath))
{
// build texture path relative to plist file
texturePath = CCFileUtils.FullPathFromRelativeFile(texturePath, fileName);
}
else
{
// build texture path by replacing file extension
texturePath = fileName;
// remove .xxx
texturePath = CCFileUtils.RemoveExtension(texturePath);
CCLog.Log("cocos2d: CCSpriteFrameCache: Trying to use file {0} as texture", texturePath);
}
plistFilePath = Path.GetDirectoryName(texturePath);
CCTexture2D pTexture = CCTextureCache.SharedTextureCache.AddImage(texturePath);
if (pTexture != null)
{
InitWithDictionary(dict, pTexture);
}
else
{
CCLog.Log("CCSpriteSheet: Couldn't load texture");
}
}
/// <summary>
///
/// </summary>
/// <param name="pszPlist"></param>
/// <returns>The scope parameter derived from the pszPlist parameter.</returns>
public string AddSpriteFramesWithFile(string pszPlist)
{
string path = CCFileUtils.FullPathFromRelativePath(pszPlist);
//Dictionary<string, Object> dict = CCFileUtils.dictionaryWithContentsOfFile(pszPath);
PlistDocument document = null;
try
{
document = CCApplication.SharedApplication.Content.Load <PlistDocument>(path);
}
catch (System.Exception)
{
string xml = CCContent.LoadContentFile(path);
if (xml != null)
{
document = new PlistDocument(xml);
}
}
if (document == null)
{
throw (new Microsoft.Xna.Framework.Content.ContentLoadException("Failed to load the particle definition file from " + path));
}
PlistDictionary dict = document.Root.AsDictionary;
string texturePath = "";
PlistDictionary metadataDict = dict.ContainsKey("metadata") ? dict["metadata"].AsDictionary : null;
string framePrefix = string.Empty;
if (metadataDict != null)
{
// try to read texture file name from meta data
if (metadataDict.ContainsKey("textureFileName"))
{
texturePath = metadataDict["textureFileName"].AsString;
framePrefix = ExtractPrefix(texturePath);
}
}
if (!string.IsNullOrEmpty(texturePath))
{
// build texture path relative to plist file
texturePath = CCFileUtils.FullPathFromRelativeFile(texturePath, path);
}
else
{
// build texture path by replacing file extension
texturePath = path;
// remove .xxx
texturePath = CCFileUtils.RemoveExtension(texturePath);
CCLog.Log("cocos2d: CCSpriteFrameCache: Trying to use file {0} as texture", texturePath);
}
CCTexture2D pTexture = CCTextureCache.SharedTextureCache.AddImage(texturePath);
if (pTexture != null)
{
AddSpriteFramesWithDictionary(dict, pTexture, framePrefix);
}
else
{
CCLog.Log("cocos2d: CCSpriteFrameCache: Couldn't load texture");
}
return(framePrefix);
}