internal static void SerializeData(CCSize pt, StreamWriter sw) { sw.WriteLine("{0} {1}", pt.Width, pt.Height); }
protected void InitCCLabelBMFont(string theString, string fntFile, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, CCPoint imageOffset, CCTexture2D texture) { Debug.Assert(FontConfiguration == null, "re-init is no longer supported"); Debug.Assert((theString == null && fntFile == null) || (theString != null && fntFile != null), "Invalid params for CCLabelBMFont"); if (!String.IsNullOrEmpty(fntFile)) { CCBMFontConfiguration newConf = FNTConfigLoadFile(fntFile); if (newConf == null) { CCLog.Log("CCLabelBMFont: Impossible to create font. Please check file: '{0}'", fntFile); return; } FontConfiguration = newConf; fntConfigFile = fntFile; if (texture == null) { try { texture = CCTextureCache.SharedTextureCache.AddImage(FontConfiguration.AtlasName); } catch (Exception) { // Try the 'images' ref location just in case. try { texture = CCTextureCache.SharedTextureCache.AddImage(System.IO.Path.Combine("images", FontConfiguration .AtlasName)); } catch (Exception) { // Lastly, try <font_path>/images/<font_name> string dir = System.IO.Path.GetDirectoryName(FontConfiguration.AtlasName); string fname = System.IO.Path.GetFileName(FontConfiguration.AtlasName); string newName = System.IO.Path.Combine(System.IO.Path.Combine(dir, "images"), fname); texture = CCTextureCache.SharedTextureCache.AddImage(newName); } } } } else { texture = new CCTexture2D(); } if (String.IsNullOrEmpty(theString)) { theString = String.Empty; } TextureAtlas = new CCTextureAtlas(texture, theString.Length); this.labelDimensions = dimensions; horzAlignment = hAlignment; vertAlignment = vAlignment; IsOpacityCascaded = true; ContentSize = CCSize.Zero; IsColorModifiedByOpacity = TextureAtlas.Texture.HasPremultipliedAlpha; AnchorPoint = CCPoint.AnchorMiddle; ImageOffset = imageOffset; SetString(theString, true); }
public CCLabelTtf(string text, string fontName, float fontSize, CCSize dimensions, CCTextAlignment hAlignment) : this(text, fontName, fontSize, dimensions, hAlignment, CCVerticalTextAlignment.Top) { }
public CCTLLine() { glyphRun = new List <LetterInfo>(); bounds = CCSize.Zero; }
internal CCTexture2D CreateTextSprite(string text, CCFontDefinition textDefinition) { if (string.IsNullOrEmpty(text)) { return(new CCTexture2D()); } int imageWidth; int imageHeight; var textDef = textDefinition; var contentScaleFactorWidth = CCLabel.DefaultTexelToContentSizeRatios.Width; var contentScaleFactorHeight = CCLabel.DefaultTexelToContentSizeRatios.Height; textDef.FontSize *= (int)contentScaleFactorWidth; textDef.Dimensions.Width *= contentScaleFactorWidth; textDef.Dimensions.Height *= contentScaleFactorHeight; bool hasPremultipliedAlpha; var font = CreateFont(textDef.FontName, textDef.FontSize); var _currentFontSizeEm = textDef.FontSize; var _currentDIP = ConvertPointSizeToDIP(_currentFontSizeEm); var fontColor = textDef.FontFillColor; var fontAlpha = textDef.FontAlpha; var foregroundColor = new Color4(fontColor.R / 255.0f, fontColor.G / 255.0f, fontColor.B / 255.0f, fontAlpha / 255.0f); // alignment var horizontalAlignment = textDef.Alignment; var verticleAlignement = textDef.LineAlignment; var textAlign = (CCTextAlignment.Right == horizontalAlignment) ? TextAlignment.Trailing : (CCTextAlignment.Center == horizontalAlignment) ? TextAlignment.Center : TextAlignment.Leading; var paragraphAlign = (CCVerticalTextAlignment.Bottom == vertAlignment) ? ParagraphAlignment.Far : (CCVerticalTextAlignment.Center == vertAlignment) ? ParagraphAlignment.Center : ParagraphAlignment.Near; // LineBreak var lineBreak = (CCLabelLineBreak.Character == textDef.LineBreak) ? WordWrapping.Wrap : (CCLabelLineBreak.Word == textDef.LineBreak) ? WordWrapping.Wrap : WordWrapping.NoWrap; // LineBreak // TODO: Find a way to specify the type of line breaking if possible. var dimensions = new CCSize(textDef.Dimensions.Width, textDef.Dimensions.Height); var layoutAvailable = true; if (dimensions.Width <= 0) { dimensions.Width = 8388608; layoutAvailable = false; } if (dimensions.Height <= 0) { dimensions.Height = 8388608; layoutAvailable = false; } var fontName = font.FontFamily.FamilyNames.GetString(0); var textFormat = new TextFormat(FactoryDWrite, fontName, _currentFontCollection, FontWeight.Regular, FontStyle.Normal, FontStretch.Normal, _currentDIP); textFormat.TextAlignment = textAlign; textFormat.ParagraphAlignment = paragraphAlign; var textLayout = new TextLayout(FactoryDWrite, text, textFormat, dimensions.Width, dimensions.Height); var boundingRect = new RectangleF(); // Loop through all the lines so we can find our drawing offsets var textMetrics = textLayout.Metrics; var lineCount = textMetrics.LineCount; // early out if something went wrong somewhere and nothing is to be drawn if (lineCount == 0) { return(new CCTexture2D()); } // Fill out the bounding rect width and height so we can calculate the yOffset later if needed boundingRect.X = 0; boundingRect.Y = 0; boundingRect.Width = textMetrics.Width; boundingRect.Height = textMetrics.Height; if (!layoutAvailable) { if (dimensions.Width == 8388608) { dimensions.Width = boundingRect.Width; } if (dimensions.Height == 8388608) { dimensions.Height = boundingRect.Height; } } imageWidth = (int)dimensions.Width; imageHeight = (int)dimensions.Height; // Recreate our layout based on calculated dimensions so that we can draw the text correctly // in our image when Alignment is not Left. if (textAlign != TextAlignment.Leading) { textLayout.MaxWidth = dimensions.Width; textLayout.MaxHeight = dimensions.Height; } // Line alignment var yOffset = (CCVerticalTextAlignment.Bottom == verticleAlignement || boundingRect.Bottom >= dimensions.Height) ? dimensions.Height - boundingRect.Bottom // align to bottom : (CCVerticalTextAlignment.Top == verticleAlignement) ? 0 // align to top : (imageHeight - boundingRect.Bottom) * 0.5f; // align to center SharpDX.WIC.Bitmap sharpBitmap = null; WicRenderTarget sharpRenderTarget = null; SolidColorBrush solidBrush = null; try { // Select our pixel format var pixelFormat = SharpDX.WIC.PixelFormat.Format32bppPRGBA; // create our backing bitmap sharpBitmap = new SharpDX.WIC.Bitmap(FactoryImaging, imageWidth, imageHeight, pixelFormat, BitmapCreateCacheOption.CacheOnLoad); // Create the render target that we will draw to sharpRenderTarget = new WicRenderTarget(Factory2D, sharpBitmap, new RenderTargetProperties()); // Create our brush to actually draw with solidBrush = new SolidColorBrush(sharpRenderTarget, foregroundColor); // Begin the drawing sharpRenderTarget.BeginDraw(); if (textDefinition.isShouldAntialias) { sharpRenderTarget.AntialiasMode = AntialiasMode.Aliased; } // Clear it sharpRenderTarget.Clear(TransparentColor); // Draw the text to the bitmap sharpRenderTarget.DrawTextLayout(new Vector2(boundingRect.X, yOffset), textLayout, solidBrush); // End our drawing which will commit the rendertarget to the bitmap sharpRenderTarget.EndDraw(); // Debugging purposes //var s = "Label4"; //SaveToFile(@"C:\Xamarin\" + s + ".png", _bitmap, _renderTarget); // The following code creates a .png stream in memory of our Bitmap and uses it to create our Textue2D Texture2D tex = null; using (var memStream = new MemoryStream()) { using (var encoder = new PngBitmapEncoder(FactoryImaging, memStream)) using (var frameEncoder = new BitmapFrameEncode(encoder)) { frameEncoder.Initialize(); frameEncoder.WriteSource(sharpBitmap); frameEncoder.Commit(); encoder.Commit(); } // Create the Texture2D from the png stream tex = Texture2D.FromStream(CCDrawManager.SharedDrawManager.XnaGraphicsDevice, memStream); } // Return our new CCTexture2D created from the Texture2D which will have our text drawn on it. return(new CCTexture2D(tex)); } catch (Exception exc) { CCLog.Log("CCLabel-Windows: Unable to create the backing image of our text. Message: {0}", exc.StackTrace); } finally { if (sharpBitmap != null) { sharpBitmap.Dispose(); sharpBitmap = null; } if (sharpRenderTarget != null) { sharpRenderTarget.Dispose(); sharpRenderTarget = null; } if (solidBrush != null) { solidBrush.Dispose(); solidBrush = null; } if (textFormat != null) { textFormat.Dispose(); textFormat = null; } if (textLayout != null) { textLayout.Dispose(); textLayout = null; } } // If we have reached here then something has gone wrong. return(new CCTexture2D()); }
public CCLayer(CCSize visibleBoundsDimensions, CCClipMode clipMode = CCClipMode.None) : this(visibleBoundsDimensions, DefaultCameraProjection, clipMode) { }
public CCSprite(CCSize contentSize, CCSpriteFrame spriteFrame) { ContentSize = contentSize; InitWithSpriteFrame(spriteFrame); }
/// <summary> /// Initializes a new instance of the <see cref="CocosSharp.CCLabel"/> class. /// </summary> /// <param name="str">Initial text of the label.</param> /// <param name="fntFile">Font definition file to use.</param> /// <param name="size">Font point size.</param> /// <param name="dimensions">Dimensions that the label should use to layout it's text.</param> /// <param name="labelFormat">Label format <see cref="CocosSharp.CCLabelFormat"/>.</param> public CCLabel(string str, string fntFile, float size, CCSize dimensions, CCLabelFormat labelFormat) : this(str, fntFile, size, dimensions, labelFormat, CCPoint.Zero, null) { }
/// <summary> /// Initializes a new instance of the <see cref="CocosSharp.CCLabel"/> class. /// </summary> /// <param name="str">Initial text of the label.</param> /// <param name="fntFile">Font definition file to use.</param> /// <param name="dimensions">Dimensions that the label should use to layout it's text.</param> /// <param name="labelFormat">Label format <see cref="CocosSharp.CCLabelFormat"/>.</param> /// <param name="imageOffset">Image offset.</param> /// <param name="texture">Texture atlas to be used.</param> public CCLabel(string str, string fntFile, CCSize dimensions, CCLabelFormat labelFormat, CCPoint imageOffset, CCTexture2D texture) { this.labelFormat = labelFormat; // First we try loading BitMapFont InitBMFont(str, fntFile, dimensions, labelFormat.Alignment, labelFormat.LineAlignment, imageOffset, texture); }
/// <summary> /// Initializes a new instance of the <see cref="CocosSharp.CCLabel"/> class. /// </summary> /// <param name="str">Initial text of the label.</param> /// <param name="fntFile">Font definition file to use.</param> /// <param name="dimensions">Dimensions that the label should use to layout it's text.</param> /// <param name="hAlignment">Horizontal alignment of the text.</param> public CCLabel(string str, string fntFile, CCSize dimensions, CCTextAlignment hAlignment) : this(str, fntFile, dimensions, new CCLabelFormat() { Alignment = hAlignment }, CCPoint.Zero, null) { }
/// <summary> /// Initializes a new instance of the <see cref="CocosSharp.CCLabel"/> class. /// </summary> /// <param name="str">Initial text of the label.</param> /// <param name="fntFile">Font definition file to use.</param> /// <param name="dimensions">Dimensions that the label should use to layout it's text.</param> /// <param name="hAlignment">Horizontal alignment of the text.</param> /// <param name="vAlignement">Vertical alignement of the text.</param> public CCLabel(string str, string fntFile, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignement) : this(str, fntFile, dimensions, hAlignment, vAlignement, CCPoint.Zero, null) { }
/// <summary> /// Initializes a new instance of the <see cref="CocosSharp.CCLabel"/> class. /// </summary> /// <param name="str">Initial text of the label.</param> /// <param name="fntFile">Font definition file to use.</param> /// <param name="dimensions">Dimensions that the label should use to layout it's text.</param> public CCLabel(string str, string fntFile, CCSize dimensions) : this(str, fntFile, dimensions, new CCLabelFormat(), CCPoint.Zero, null) { }
public override void NeedsLayout() { if (!parentInited) { return; } // Hide the background and the label if (titleLabel != null) { titleLabel.Visible = false; } if (_backgroundSprite != null) { _backgroundSprite.Visible = false; } // Update anchor of all labels LabelAnchorPoint = labelAnchorPoint; // Update the label to match with the current state currentTitle = GetTitleForState(State); currentTitleColor = GetTitleColorForState(State); TitleLabel = GetTitleLabelForState(State); var label = (ICCTextContainer)titleLabel; if (label != null && !String.IsNullOrEmpty(currentTitle)) { label.Text = (currentTitle); } var rgbaLabel = titleLabel; if (rgbaLabel != null) { rgbaLabel.Color = currentTitleColor; } if (titleLabel != null) { titleLabel.Position = new CCPoint(ContentSize.Width / 2, ContentSize.Height / 2); } // Update the background sprite BackgroundSprite = GetBackgroundSpriteForState(State); if (_backgroundSprite != null) { _backgroundSprite.Position = new CCPoint(ContentSize.Width / 2, ContentSize.Height / 2); } // Get the title label size CCSize titleLabelSize = CCSize.Zero; if (titleLabel != null) { titleLabelSize = titleLabel.BoundingBox.Size; } // Adjust the background image if necessary if (isAdjustBackgroundImage) { // Add the margins if (_backgroundSprite != null) { _backgroundSprite.ContentSize = new CCSize(titleLabelSize.Width + _marginH * 2, titleLabelSize.Height + _marginV * 2); } } else { //TODO: should this also have margins if one of the preferred sizes is relaxed? if (_backgroundSprite != null && _backgroundSprite is CCScale9Sprite) { CCSize preferredSize = ((CCScale9Sprite)_backgroundSprite).PreferredSize; if (preferredSize.Width <= 0) { preferredSize.Width = titleLabelSize.Width; } if (preferredSize.Height <= 0) { preferredSize.Height = titleLabelSize.Height; } _backgroundSprite.ContentSize = preferredSize; } } // Set the content size CCRect rectTitle = CCRect.Zero; if (titleLabel != null) { rectTitle = titleLabel.BoundingBox; } CCRect rectBackground = CCRect.Zero; if (_backgroundSprite != null) { rectBackground = _backgroundSprite.BoundingBox; } CCRect maxRect = CCControlUtils.CCRectUnion(rectTitle, rectBackground); ContentSize = new CCSize(maxRect.Size.Width, maxRect.Size.Height); if (titleLabel != null) { titleLabel.Position = new CCPoint(ContentSize.Width / 2, ContentSize.Height / 2); // Make visible label titleLabel.Visible = true; } if (_backgroundSprite != null) { _backgroundSprite.Position = new CCPoint(ContentSize.Width / 2, ContentSize.Height / 2); // Make visible the background _backgroundSprite.Visible = true; } }
void LayoutLabel() { if (FontAtlas == null || string.IsNullOrEmpty(Text)) { ContentSize = CCSize.Zero; return; } TextureAtlas.RemoveAllQuads(); Descendants.Clear(); lettersInfo.Clear(); FontAtlas.PrepareLetterDefinitions(Text); var start = 0; var typesetter = new CCTLTextLayout(this); var length = Text.Length; var insetBounds = labelDimensions; var layoutAvailable = true; if (insetBounds == CCSize.Zero) { insetBounds = new CCSize(8388608, 8388608); layoutAvailable = false; } var boundsWidth = insetBounds.Width; var contentScaleFactorWidth = CCLabel.DefaultTexelToContentSizeRatios.Width; var contentScaleFactorHeight = CCLabel.DefaultTexelToContentSizeRatios.Height; List <CCTLLine> lineList = new List <CCTLLine>(); while (start < length)// && textPosition.Y < insetBounds.Bottom) { // Now we ask the typesetter to break off a line for us. // This also will take into account line feeds embedded in the text. // Example: "This is text \n with a line feed embedded inside it" int count = typesetter.SuggestLineBreak(start, boundsWidth); var line = typesetter.GetLine(start, start + count); lineList.Add(line); start += count; } // Calculate our vertical starting position var totalHeight = lineList.Count * LineHeight; var nextFontPositionY = totalHeight; if (Dimensions.Height > 0) { var labelHeightPixel = Dimensions.Height * contentScaleFactorHeight; if (totalHeight > labelHeightPixel) { int numLines = (int)(labelHeightPixel / LineHeight); totalHeight = numLines * LineHeight; } switch (VerticalAlignment) { case CCVerticalTextAlignment.Top: nextFontPositionY = labelHeightPixel; break; case CCVerticalTextAlignment.Center: nextFontPositionY = (labelHeightPixel + totalHeight) * 0.5f; break; case CCVerticalTextAlignment.Bottom: nextFontPositionY = totalHeight; break; default: break; } } var lineGlyphIndex = 0; float longestLine = (labelDimensions.Width > 0) ? labelDimensions.Width : 0; // Used for calculating overlapping on last line character var lastCharWidth = 0.0f; int lastCharAdvance = 0; // Define our horizontal justification var flushFactor = (float)HorizontalAlignment / (float)CCTextAlignment.Right; // We now loop through all of our line's glyph runs foreach (var line in lineList) { var gliphRun = line.GlyphRun; var lineWidth = line.Bounds.Width * contentScaleFactorWidth; var flush = line.PenOffsetForFlush(flushFactor, boundsWidth); foreach (var glyph in gliphRun) { var letterPosition = glyph.Position; var letterDef = glyph.Definition; lastCharWidth = letterDef.Width * contentScaleFactorWidth; letterPosition.X += flush; letterPosition.Y = (nextFontPositionY - letterDef.YOffset) / contentScaleFactorHeight; //recordLetterInfo(letterPosition, glyph.def, lineGlyphIndex++); var tmpInfo = new LetterInfo(); tmpInfo.Definition = letterDef; tmpInfo.Position = letterPosition; tmpInfo.ContentSize.Width = letterDef.Width; tmpInfo.ContentSize.Height = letterDef.Height; if (lineGlyphIndex >= lettersInfo.Count) { lettersInfo.Add(tmpInfo); } else { lettersInfo[lineGlyphIndex] = tmpInfo; } lineGlyphIndex++; lastCharAdvance = (int)glyph.Definition.XAdvance; } // calculate our longest line which is used for calculating our ContentSize if (lineWidth > longestLine) { longestLine = lineWidth; } nextFontPositionY -= LineHeight; } CCSize tmpSize; // If the last character processed has an xAdvance which is less that the width of the characters image, then we need // to adjust the width of the string to take this into account, or the character will overlap the end of the bounding // box if (lastCharAdvance < lastCharWidth) { tmpSize.Width = longestLine - lastCharAdvance + lastCharWidth; } else { tmpSize.Width = longestLine; } tmpSize.Height = totalHeight; if (Dimensions.Height > 0) { tmpSize.Height = Dimensions.Height * contentScaleFactorHeight; } ContentSize = tmpSize / CCLabel.DefaultTexelToContentSizeRatios; lineList.Clear(); CCRect uvRect; CCSprite letterSprite; for (int c = 0; c < Children.Count; c++) { letterSprite = (CCSprite)Children[c]; int tag = letterSprite.Tag; if (tag >= length) { RemoveChild(letterSprite, true); } else if (tag >= 0) { if (letterSprite != null) { uvRect = lettersInfo[tag].Definition.Subrect; letterSprite.TextureRectInPixels = uvRect; letterSprite.ContentSize = uvRect.Size; } } } UpdateQuads(); UpdateColor(); }
void LoadAppleDictionary(PlistDictionary dict, CCTexture2D texture) { var version = dict.ContainsKey("version") ? dict ["version"].AsInt : 0; if (version != 1) { throw (new NotSupportedException("Binary PList version " + version + " is not supported.")); } var images = dict.ContainsKey("images") ? dict ["images"].AsArray : null; foreach (var imageEntry in images) { // we only support one image for now var imageDict = imageEntry.AsDictionary; var path = imageDict ["path"].AsString; path = Path.Combine(plistFilePath, CCFileUtils.RemoveExtension(path)); if (!CCTextureCache.SharedTextureCache.Contains(path)) { texture = CCTextureCache.SharedTextureCache.AddImage(path); } else { texture = CCTextureCache.SharedTextureCache[path]; } // size not used right now //var size = CCSize.Parse(imageDict ["size"].AsString); var subImages = imageDict ["subimages"].AsArray; foreach (var subImage in subImages) { CCSpriteFrame spriteFrame = null; var subImageDict = subImage.AsDictionary; var name = subImageDict ["name"].AsString; var alias = subImageDict ["alias"].AsString; var isFullyOpaque = true; if (subImageDict.ContainsKey("isFullyOpaque")) { isFullyOpaque = subImageDict ["isFullyOpaque"].AsBool; } var textureRect = CCRect.Parse(subImageDict ["textureRect"].AsString); var spriteOffset = CCPoint.Parse(subImageDict ["spriteOffset"].AsString); // We are going to override the sprite offset for now to be 0,0 // It seems the offset is calculated off of the original size but if // we pass this offset it throws our center position calculations off. spriteOffset = CCPoint.Zero; var textureRotated = false; if (subImageDict.ContainsKey("textureRotated")) { textureRotated = subImageDict ["textureRotated"].AsBool; } var spriteSourceSize = CCSize.Parse(subImageDict ["spriteSourceSize"].AsString); var frameRect = textureRect; if (textureRotated) { frameRect = new CCRect(textureRect.Origin.X, textureRect.Origin.Y, textureRect.Size.Height, textureRect.Size.Width); } #if DEBUG CCLog.Log("texture {0} rect {1} rotated {2} offset {3}, sourcesize {4}", name, textureRect, textureRotated, spriteOffset, spriteSourceSize); #endif frameRect.Origin += spriteOffset; // create frame spriteFrame = new CCSpriteFrame( spriteSourceSize, texture, frameRect, textureRotated ); spriteFrame.TextureFilename = name; spriteFrames [name] = spriteFrame; } } AutoCreateAliasList(); }
protected void InitBMFont(string theString, string fntFile, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, CCPoint imageOffset, CCTexture2D texture) { Debug.Assert(FontConfiguration == null, "re-init is no longer supported"); Debug.Assert((theString == null && fntFile == null) || (theString != null && fntFile != null), "Invalid params for CCLabelBMFont"); if (!String.IsNullOrEmpty(fntFile)) { try { FontAtlas = CCFontAtlasCache.GetFontAtlasFNT(fntFile, imageOffset); } catch {} if (FontAtlas == null) { CCLog.Log("Bitmap Font CCLabel: Impossible to create font. Please check file: '{0}'", fntFile); return; } } AnchorPoint = CCPoint.AnchorMiddle; FontConfiguration = CCBMFontConfiguration.FontConfigurationWithFile(fntFile); LabelType = CCLabelType.BitMapFont; if (String.IsNullOrEmpty(theString)) { theString = String.Empty; } // Initialize the TextureAtlas along with children. var capacity = theString.Length; BlendFunc = CCBlendFunc.AlphaBlend; if (capacity == 0) { capacity = defaultSpriteBatchCapacity; } UpdateBlendFunc(); // no lazy alloc in this node Children = new CCRawList <CCNode>(capacity); Descendants = new CCRawList <CCSprite>(capacity); this.labelDimensions = dimensions; horzAlignment = hAlignment; vertAlignment = vAlignment; IsOpacityCascaded = true; // We use base here so we do not trigger an update internally. base.ContentSize = CCSize.Zero; IsColorModifiedByOpacity = TextureAtlas.Texture.HasPremultipliedAlpha; AnchorPoint = CCPoint.AnchorMiddle; ImageOffset = imageOffset; Text = theString; }
void LoadCocos2DDictionary(PlistDictionary dict, CCTexture2D texture) { PlistDictionary metadataDict = null; if (dict.ContainsKey("metadata")) { metadataDict = dict["metadata"].AsDictionary; } PlistDictionary framesDict = null; if (dict.ContainsKey("frames")) { framesDict = dict["frames"].AsDictionary; } // get the format int format = 0; if (metadataDict != null) { format = metadataDict["format"].AsInt; } // check the format if (format < 0 || format > 3) { throw (new NotSupportedException("PList format " + format + " is not supported.")); } foreach (var pair in framesDict) { PlistDictionary frameDict = pair.Value.AsDictionary; CCSpriteFrame spriteFrame = null; if (format == 0) { float x = 0f, y = 0f, w = 0f, h = 0f; x = frameDict["x"].AsFloat; y = frameDict["y"].AsFloat; w = frameDict["width"].AsFloat; h = frameDict["height"].AsFloat; float ox = 0f, oy = 0f; ox = frameDict["offsetX"].AsFloat; oy = frameDict["offsetY"].AsFloat; int ow = 0, oh = 0; ow = frameDict["originalWidth"].AsInt; oh = frameDict["originalHeight"].AsInt; // check ow/oh if (ow == 0 || oh == 0) { CCLog.Log( "cocos2d: WARNING: originalWidth/Height not found on the CCSpriteFrame. AnchorPoint won't work as expected. Regenerate the .plist or check the 'format' metatag"); } // abs ow/oh ow = Math.Abs(ow); oh = Math.Abs(oh); // create frame spriteFrame = new CCSpriteFrame( new CCSize(ow, oh), texture, new CCRect(x + ox, y + oy, w, h), false ); } else if (format == 1 || format == 2) { var frame = CCRect.Parse(frameDict["frame"].AsString); bool rotated = false; // rotation if (format == 2) { if (frameDict.ContainsKey("rotated")) { rotated = frameDict["rotated"].AsBool; } } var offset = CCPoint.Parse(frameDict["offset"].AsString); var sourceSize = CCSize.Parse(frameDict["sourceSize"].AsString); frame.Origin += offset; // create frame spriteFrame = new CCSpriteFrame(sourceSize, texture, frame, rotated); } else if (format == 3) { var spriteSize = CCSize.Parse(frameDict["spriteSize"].AsString); var spriteOffset = CCPoint.Parse(frameDict["spriteOffset"].AsString); var spriteSourceSize = CCSize.Parse(frameDict["spriteSourceSize"].AsString); var textureRect = CCRect.Parse(frameDict["textureRect"].AsString); bool textureRotated = false; if (frameDict.ContainsKey("textureRotated")) { textureRotated = frameDict["textureRotated"].AsBool; } // get aliases var aliases = frameDict["aliases"].AsArray; for (int i = 0; i < aliases.Count; i++) { string oneAlias = aliases[i].AsString; if (spriteFramesAliases.ContainsKey(oneAlias)) { if (spriteFramesAliases[oneAlias] != null) { CCLog.Log("CocosSharp: WARNING: an alias with name {0} already exists", oneAlias); } } if (!spriteFramesAliases.ContainsKey(oneAlias)) { spriteFramesAliases.Add(oneAlias, pair.Key); } } // create frame spriteFrame = new CCSpriteFrame( spriteSourceSize, texture, new CCRect(textureRect.Origin.X + spriteOffset.X, textureRect.Origin.Y + spriteOffset.Y, spriteSize.Width, spriteSize.Height), textureRotated ); } spriteFrame.TextureFilename = pair.Key; spriteFrames[pair.Key] = spriteFrame; } AutoCreateAliasList(); }
protected void InitSpriteFont(string theString, string fntFile, float fontSize, CCSize dimensions, CCLabelFormat labelFormat, CCPoint imageOffset, CCTexture2D texture) { Debug.Assert((theString == null && fntFile == null) || (theString != null && fntFile != null), "Invalid params for CCLabel SpriteFont"); if (!String.IsNullOrEmpty(fntFile)) { try { FontAtlas = CCFontAtlasCache.GetFontAtlasSpriteFont(fntFile, fontSize, imageOffset); Scale = FontAtlas.Font.FontScale; } catch {} if (FontAtlas == null) { CCLog.Log("SpriteFont CCLabel: Impossible to create font. Please check file: '{0}'", fntFile); return; } } AnchorPoint = CCPoint.AnchorMiddle; LabelType = CCLabelType.SpriteFont; if (String.IsNullOrEmpty(theString)) { theString = String.Empty; } // Initialize the TextureAtlas along with children. var capacity = theString.Length; BlendFunc = CCBlendFunc.AlphaBlend; if (capacity == 0) { capacity = defaultSpriteBatchCapacity; } UpdateBlendFunc(); // no lazy alloc in this node Children = new CCRawList <CCNode>(capacity); Descendants = new CCRawList <CCSprite>(capacity); this.labelDimensions = dimensions; horzAlignment = labelFormat.Alignment; vertAlignment = labelFormat.LineAlignment; IsOpacityCascaded = true; ContentSize = CCSize.Zero; IsColorModifiedByOpacity = TextureAtlas.Texture.HasPremultipliedAlpha; AnchorPoint = CCPoint.AnchorMiddle; ImageOffset = imageOffset; Text = theString; }
public CCLayer(CCSize visibleBoundsDimensions, CCCameraProjection cameraProjection, CCClipMode clipMode = CCClipMode.None) : this(new CCCamera(cameraProjection, visibleBoundsDimensions), clipMode) { }
public static CCPhysicsBody CreateBox(CCSize size, float radius) { return(CreateBox(size, CCPhysicsMaterial.PHYSICSSHAPE_MATERIAL_DEFAULT, radius)); }
public CCTransitionSceneContainerNode(CCScene scene, CCSize contentSize) : base(contentSize) { InnerScene = scene; }
public static CCPhysicsBody CreateEdgeBox(CCSize size, float border, CCPoint offset) { return(CreateEdgeBox(size, CCPhysicsMaterial.PHYSICSSHAPE_MATERIAL_DEFAULT, border, offset)); }
public bool UpdateWithBatchNode(CCSpriteBatchNode batchnode, CCRect rect, bool rotated, CCRect capInsets) { var opacity = Opacity; var color = Color; // Release old sprites RemoveAllChildren(true); scale9Image = batchnode; scale9Image.RemoveAllChildren(true); this.capInsets = capInsets; spriteFrameRotated = rotated; // If there is no given rect if (rect.Equals(CCRect.Zero)) { // Get the texture size as original CCSize textureSize = scale9Image.TextureAtlas.Texture.ContentSizeInPixels; rect = new CCRect(0, 0, textureSize.Width, textureSize.Height); } // Set the given rect's size as original size spriteRect = rect; originalSize = rect.Size; preferredSize = originalSize; capInsetsInternal = capInsets; float h = rect.Size.Height; float w = rect.Size.Width; // If there is no specified center region if (capInsetsInternal.Equals(CCRect.Zero)) { capInsetsInternal = new CCRect(w / 3, h / 3, w / 3, h / 3); } float left_w = capInsetsInternal.Origin.X; float center_w = capInsetsInternal.Size.Width; float right_w = rect.Size.Width - (left_w + center_w); float top_h = capInsetsInternal.Origin.Y; float center_h = capInsetsInternal.Size.Height; float bottom_h = rect.Size.Height - (top_h + center_h); // calculate rects // ... top row float x = 0.0f; float y = 0.0f; // top left CCRect lefttopbounds = new CCRect(x, y, left_w, top_h); // top center x += left_w; CCRect centertopbounds = new CCRect(x, y, center_w, top_h); // top right x += center_w; CCRect righttopbounds = new CCRect(x, y, right_w, top_h); // ... center row x = 0.0f; y = 0.0f; y += top_h; // center left CCRect leftcenterbounds = new CCRect(x, y, left_w, center_h); // center center x += left_w; CCRect centerbounds = new CCRect(x, y, center_w, center_h); // center right x += center_w; CCRect rightcenterbounds = new CCRect(x, y, right_w, center_h); // ... bottom row x = 0.0f; y = 0.0f; y += top_h; y += center_h; // bottom left CCRect leftbottombounds = new CCRect(x, y, left_w, bottom_h); // bottom center x += left_w; CCRect centerbottombounds = new CCRect(x, y, center_w, bottom_h); // bottom right x += center_w; CCRect rightbottombounds = new CCRect(x, y, right_w, bottom_h); if (!rotated) { CCAffineTransform t = CCAffineTransform.Identity; t = CCAffineTransform.Translate(t, rect.Origin.X, rect.Origin.Y); centerbounds = CCAffineTransform.Transform(centerbounds, t); rightbottombounds = CCAffineTransform.Transform(rightbottombounds, t); leftbottombounds = CCAffineTransform.Transform(leftbottombounds, t); righttopbounds = CCAffineTransform.Transform(righttopbounds, t); lefttopbounds = CCAffineTransform.Transform(lefttopbounds, t); rightcenterbounds = CCAffineTransform.Transform(rightcenterbounds, t); leftcenterbounds = CCAffineTransform.Transform(leftcenterbounds, t); centerbottombounds = CCAffineTransform.Transform(centerbottombounds, t); centertopbounds = CCAffineTransform.Transform(centertopbounds, t); // Centre centre = new CCSprite(scale9Image.Texture, centerbounds); scale9Image.AddChild(centre, 0, (int)Positions.Centre); // Top top = new CCSprite(scale9Image.Texture, centertopbounds); scale9Image.AddChild(top, 1, (int)Positions.Top); // Bottom bottom = new CCSprite(scale9Image.Texture, centerbottombounds); scale9Image.AddChild(bottom, 1, (int)Positions.Bottom); // Left left = new CCSprite(scale9Image.Texture, leftcenterbounds); scale9Image.AddChild(left, 1, (int)Positions.Left); // Right right = new CCSprite(scale9Image.Texture, rightcenterbounds); scale9Image.AddChild(right, 1, (int)Positions.Right); // Top left topLeft = new CCSprite(scale9Image.Texture, lefttopbounds); scale9Image.AddChild(topLeft, 2, (int)Positions.TopLeft); // Top right topRight = new CCSprite(scale9Image.Texture, righttopbounds); scale9Image.AddChild(topRight, 2, (int)Positions.TopRight); // Bottom left bottomLeft = new CCSprite(scale9Image.Texture, leftbottombounds); scale9Image.AddChild(bottomLeft, 2, (int)Positions.BottomLeft); // Bottom right bottomRight = new CCSprite(scale9Image.Texture, rightbottombounds); scale9Image.AddChild(bottomRight, 2, (int)Positions.BottomRight); } else { // set up transformation of coordinates // to handle the case where the sprite is stored rotated // in the spritesheet // CCLog("rotated"); CCAffineTransform t = CCAffineTransform.Identity; CCRect rotatedcenterbounds = centerbounds; CCRect rotatedrightbottombounds = rightbottombounds; CCRect rotatedleftbottombounds = leftbottombounds; CCRect rotatedrighttopbounds = righttopbounds; CCRect rotatedlefttopbounds = lefttopbounds; CCRect rotatedrightcenterbounds = rightcenterbounds; CCRect rotatedleftcenterbounds = leftcenterbounds; CCRect rotatedcenterbottombounds = centerbottombounds; CCRect rotatedcentertopbounds = centertopbounds; t = CCAffineTransform.Translate(t, rect.Size.Height + rect.Origin.X, rect.Origin.Y); t = CCAffineTransform.Rotate(t, 1.57079633f); centerbounds = CCAffineTransform.Transform(centerbounds, t); rightbottombounds = CCAffineTransform.Transform(rightbottombounds, t); leftbottombounds = CCAffineTransform.Transform(leftbottombounds, t); righttopbounds = CCAffineTransform.Transform(righttopbounds, t); lefttopbounds = CCAffineTransform.Transform(lefttopbounds, t); rightcenterbounds = CCAffineTransform.Transform(rightcenterbounds, t); leftcenterbounds = CCAffineTransform.Transform(leftcenterbounds, t); centerbottombounds = CCAffineTransform.Transform(centerbottombounds, t); centertopbounds = CCAffineTransform.Transform(centertopbounds, t); rotatedcenterbounds.Origin = centerbounds.Origin; rotatedrightbottombounds.Origin = rightbottombounds.Origin; rotatedleftbottombounds.Origin = leftbottombounds.Origin; rotatedrighttopbounds.Origin = righttopbounds.Origin; rotatedlefttopbounds.Origin = lefttopbounds.Origin; rotatedrightcenterbounds.Origin = rightcenterbounds.Origin; rotatedleftcenterbounds.Origin = leftcenterbounds.Origin; rotatedcenterbottombounds.Origin = centerbottombounds.Origin; rotatedcentertopbounds.Origin = centertopbounds.Origin; // Centre centre = new CCSprite(scale9Image.Texture, rotatedcenterbounds, true); //centre.InitWithTexture(scale9Image.Texture, rotatedcenterbounds, true); scale9Image.AddChild(centre, 0, (int)Positions.Centre); // Top top = new CCSprite(scale9Image.Texture, rotatedcentertopbounds, true); //top.InitWithTexture(scale9Image.Texture, rotatedcentertopbounds, true); scale9Image.AddChild(top, 1, (int)Positions.Top); // Bottom bottom = new CCSprite(scale9Image.Texture, rotatedcenterbottombounds, true); //bottom.InitWithTexture(scale9Image.Texture, rotatedcenterbottombounds, true); scale9Image.AddChild(bottom, 1, (int)Positions.Bottom); // Left left = new CCSprite(scale9Image.Texture, rotatedleftcenterbounds, true); //left.InitWithTexture(scale9Image.Texture, rotatedleftcenterbounds, true); scale9Image.AddChild(left, 1, (int)Positions.Left); // Right right = new CCSprite(scale9Image.Texture, rotatedrightcenterbounds, true); //right.InitWithTexture(scale9Image.Texture, rotatedrightcenterbounds, true); scale9Image.AddChild(right, 1, (int)Positions.Right); // Top left topLeft = new CCSprite(scale9Image.Texture, rotatedlefttopbounds, true); //topLeft.InitWithTexture(scale9Image.Texture, rotatedlefttopbounds, true); scale9Image.AddChild(topLeft, 2, (int)Positions.TopLeft); // Top right topRight = new CCSprite(scale9Image.Texture, rotatedrighttopbounds, true); //topRight.InitWithTexture(scale9Image.Texture, rotatedrighttopbounds, true); scale9Image.AddChild(topRight, 2, (int)Positions.TopRight); // Bottom left bottomLeft = new CCSprite(scale9Image.Texture, rotatedleftbottombounds, true); //bottomLeft.InitWithTexture(scale9Image.Texture, rotatedleftbottombounds, true); scale9Image.AddChild(bottomLeft, 2, (int)Positions.BottomLeft); // Bottom right bottomRight = new CCSprite(scale9Image.Texture, rotatedrightbottombounds, true); //bottomRight.InitWithTexture(scale9Image.Texture, rotatedrightbottombounds, true); scale9Image.AddChild(bottomRight, 2, (int)Positions.BottomRight); } ContentSize = rect.Size; AddChild(scale9Image); if (spritesGenerated) { // Restore color and opacity Opacity = opacity; Color = color; } spritesGenerated = true; return(true); }
public void AlignItemsInColumns(params uint[] numOfItemsPerRow) { alignmentState.Alignment = Alignment.Column; alignmentState.NumberOfItemsPer = numOfItemsPerRow; float height = -DefaultPadding; int row = 0; int rowHeight = 0; int columnsOccupied = 0; uint rowColumns; if (menuItems != null && menuItems.Count > 0) { foreach (CCMenuItem item in menuItems) { if (item.Visible) { Debug.Assert(row < numOfItemsPerRow.Length); rowColumns = numOfItemsPerRow[row]; // can not have zero columns on a row Debug.Assert(rowColumns > 0, ""); float tmp = item.ContentSize.Height; rowHeight = (int)((rowHeight >= tmp || float.IsNaN(tmp)) ? rowHeight : tmp); ++columnsOccupied; if (columnsOccupied >= rowColumns) { height += rowHeight + (int)DefaultPadding; columnsOccupied = 0; rowHeight = 0; ++row; } } } // check if too many rows/columns for available menu items Debug.Assert(columnsOccupied == 0, ""); CCSize menuSize = ContentSize; row = 0; rowHeight = 0; rowColumns = 0; float w = 0.0f; float x = 0.0f; float y = (height / 2f); foreach (CCMenuItem item in menuItems) { if (item.Visible) { if (rowColumns == 0) { rowColumns = numOfItemsPerRow[row]; if (rowColumns == 0) { throw (new ArgumentException("Can not have a zero column size for a row.")); } w = (menuSize.Width - 2 * DefaultPadding) / rowColumns; // 1 + rowColumns x = w / 2f; // center of column } float tmp = item.ContentSize.Height * item.ScaleY; rowHeight = (int)((rowHeight >= tmp || float.IsNaN(tmp)) ? rowHeight : tmp); item.Position = new CCPoint(DefaultPadding + x - (menuSize.Width - 2 * DefaultPadding) / 2, y - item.ContentSize.Height * item.ScaleY / 2); x += w; ++columnsOccupied; if (columnsOccupied >= rowColumns) { y -= rowHeight + DefaultPadding; columnsOccupied = 0; rowColumns = 0; rowHeight = 0; ++row; } } } } }
public CCLabelBMFont(string str, string fntFile, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, CCPoint imageOffset, CCTexture2D texture) { InitCCLabelBMFont(str, fntFile, dimensions, hAlignment, vAlignment, imageOffset, texture); }
public void AlignItemsInRows(params uint[] numOfItemsPerColumn) { alignmentState.Alignment = Alignment.Row; alignmentState.NumberOfItemsPer = numOfItemsPerColumn; List <float> columnWidths = new List <float>(); List <float> columnHeights = new List <float>(); float width = -DefaultPadding * 2.0f; float columnHeight = -DefaultPadding; int column = 0; int columnWidth = 0; int rowsOccupied = 0; uint columnRows; if (menuItems != null && menuItems.Count > 0) { foreach (CCMenuItem item in menuItems) { if (item.Visible) { // check if too many menu items for the amount of rows/columns Debug.Assert(column < numOfItemsPerColumn.Length, ""); columnRows = numOfItemsPerColumn[column]; // can't have zero rows on a column Debug.Assert(columnRows > 0, ""); float tmp = item.ContentSize.Width * item.ScaleX; columnWidth = (int)((columnWidth >= tmp || float.IsNaN(tmp)) ? columnWidth : tmp); columnHeight += (int)(item.ContentSize.Height * item.ScaleY + DefaultPadding); ++rowsOccupied; if (rowsOccupied >= columnRows) { columnWidths.Add(columnWidth); columnHeights.Add(columnHeight); width += columnWidth + DefaultPadding * 2.0f; rowsOccupied = 0; columnWidth = 0; columnHeight = -DefaultPadding; ++column; } } } // check if too many rows/columns for available menu items. Debug.Assert(rowsOccupied == 0, ""); CCSize menuSize = ContentSize; column = 0; columnWidth = 0; columnRows = 0; float x = (-width / 2f); float y = 0.0f; foreach (CCMenuItem item in menuItems) { if (item.Visible) { if (columnRows == 0) { columnRows = numOfItemsPerColumn[column]; y = columnHeights [column]; } // columnWidth = fmaxf(columnWidth, [item contentSize].width); float tmp = item.ContentSize.Width * item.ScaleX; columnWidth = (int)((columnWidth >= tmp || float.IsNaN(tmp)) ? columnWidth : tmp); item.Position = new CCPoint(x + columnWidths [column] / 2, y - menuSize.Height / 2); y -= item.ContentSize.Height * item.ScaleY + 10; ++rowsOccupied; if (rowsOccupied >= columnRows) { x += columnWidth + 5; rowsOccupied = 0; columnRows = 0; columnWidth = 0; ++column; } } } } }
public void CreateFontChars() { int nextFontPositionX = 0; int nextFontPositionY = 0; char prev = (char)255; int kerningAmount = 0; CCSize tmpSize = CCSize.Zero; int longestLine = 0; int totalHeight = 0; int quantityOfLines = 1; if (String.IsNullOrEmpty(labelText)) { return; } int stringLen = labelText.Length; var charSet = FontConfiguration.CharacterSet; if (charSet.Count == 0) { throw (new InvalidOperationException( "Can not compute the size of the font because the character set is empty.")); } for (int i = 0; i < stringLen - 1; ++i) { if (labelText[i] == '\n') { quantityOfLines++; } } LineHeight = FontConfiguration.CommonHeight; totalHeight = LineHeight * quantityOfLines; nextFontPositionY = 0 - (LineHeight - LineHeight * quantityOfLines); CCBMFontConfiguration.CCBMGlyphDef fontDef = null; CCRect fontCharTextureRect; CCSize fontCharContentSize; for (int i = 0; i < stringLen; i++) { char c = labelText[i]; if (c == '\n') { nextFontPositionX = 0; nextFontPositionY -= LineHeight; continue; } if (charSet.IndexOf(c) == -1) { CCLog.Log("CocosSharp: CCLabelBMFont: Attempted to use character not defined in this bitmap: {0}", (int)c); continue; } kerningAmount = this.KerningAmountForFirst(prev, c); // unichar is a short, and an int is needed on HASH_FIND_INT if (!FontConfiguration.Glyphs.TryGetValue(c, out fontDef)) { CCLog.Log("CocosSharp: CCLabelBMFont: character not found {0}", (int)c); continue; } fontCharTextureRect = fontDef.Subrect; fontCharTextureRect.Origin.X += ImageOffset.X; fontCharTextureRect.Origin.Y += ImageOffset.Y; fontCharContentSize = fontCharTextureRect.Size / DefaultTexelToContentSizeRatios; CCSprite fontChar; //bool hasSprite = true; fontChar = (CCSprite)(this[i]); if (fontChar != null) { // Reusing previous Sprite fontChar.Visible = true; // updating previous sprite fontChar.IsTextureRectRotated = false; fontChar.ContentSize = fontCharContentSize; fontChar.TextureRectInPixels = fontCharTextureRect; } else { // New Sprite ? Set correct color, opacity, etc... //if( false ) //{ // /* WIP: Doesn't support many features yet. // But this code is super fast. It doesn't create any sprite. // Ideal for big labels. // */ // fontChar = m_pReusedChar; // fontChar.BatchNode = null; // hasSprite = false; //} //else { fontChar = new CCSprite(TextureAtlas.Texture, fontCharTextureRect); fontChar.ContentSize = fontCharContentSize; AddChild(fontChar, i, i); } // Apply label properties fontChar.IsColorModifiedByOpacity = IsColorModifiedByOpacity; // Color MUST be set before opacity, since opacity might change color if OpacityModifyRGB is on fontChar.UpdateDisplayedColor(DisplayedColor); fontChar.UpdateDisplayedOpacity(DisplayedOpacity); } // See issue 1343. cast( signed short + unsigned integer ) == unsigned integer (sign is lost!) int yOffset = FontConfiguration.CommonHeight - fontDef.YOffset; var fontPos = new CCPoint( (float)nextFontPositionX + fontDef.XOffset + fontDef.Subrect.Size.Width * 0.5f + kerningAmount, (float)nextFontPositionY + yOffset - fontCharTextureRect.Size.Height * 0.5f); fontChar.Position = fontPos; // update kerning nextFontPositionX += fontDef.XAdvance + kerningAmount; prev = c; if (longestLine < nextFontPositionX) { longestLine = nextFontPositionX; } } // If the last character processed has an xAdvance which is less that the width of the characters image, then we need // to adjust the width of the string to take this into account, or the character will overlap the end of the bounding // box if (fontDef != null && fontDef.XAdvance < fontDef.Subrect.Size.Width) { tmpSize.Width = longestLine + fontDef.Subrect.Size.Width - fontDef.XAdvance; } else { tmpSize.Width = longestLine; } tmpSize.Height = totalHeight; var tmpDimensions = labelDimensions; labelDimensions = new CCSize( labelDimensions.Width > 0 ? labelDimensions.Width : tmpSize.Width, labelDimensions.Height > 0 ? labelDimensions.Height : tmpSize.Height ); ContentSize = labelDimensions; labelDimensions = tmpDimensions; }
public void SetDesignResolutionSize(float width, float height, CCSceneResolutionPolicy resolutionPolicy) { designResolutionSize = new CCSize(width, height); DesignResolutionPolicy = resolutionPolicy; }
public CCLabelTtf(string text, string fontName, float fontSize, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment) { InitCCLabelTTF(text, fontName, fontSize, dimensions, hAlignment, vAlignment); }
internal void AddSpriteFrames(PlistDictionary pobDictionary, CCTexture2D pobTexture) { /* * Supported Zwoptex Formats: * * ZWTCoordinatesFormatOptionXMLLegacy = 0, // Flash Version * ZWTCoordinatesFormatOptionXML1_0 = 1, // Desktop Version 0.0 - 0.4b * ZWTCoordinatesFormatOptionXML1_1 = 2, // Desktop Version 1.0.0 - 1.0.1 * ZWTCoordinatesFormatOptionXML1_2 = 3, // Desktop Version 1.0.2+ */ PlistDictionary metadataDict = null; if (pobDictionary.ContainsKey("metadata")) { metadataDict = pobDictionary["metadata"].AsDictionary; } PlistDictionary framesDict = null; if (pobDictionary.ContainsKey("frames")) { framesDict = pobDictionary["frames"].AsDictionary; } int format = 0; // get the format if (metadataDict != null) { format = metadataDict["format"].AsInt; } // check the format if (format < 0 || format > 3) { throw (new NotSupportedException("PList format " + format + " is not supported.")); } foreach (var pair in framesDict) { PlistDictionary frameDict = pair.Value.AsDictionary; CCSpriteFrame spriteFrame = null; if (format == 0) { float x = 0f, y = 0f, w = 0f, h = 0f; x = frameDict["x"].AsFloat; y = frameDict["y"].AsFloat; w = frameDict["width"].AsFloat; h = frameDict["height"].AsFloat; float ox = 0f, oy = 0f; ox = frameDict["offsetX"].AsFloat; oy = frameDict["offsetY"].AsFloat; int ow = 0, oh = 0; ow = frameDict["originalWidth"].AsInt; oh = frameDict["originalHeight"].AsInt; // check ow/oh if (ow == 0 || oh == 0) { CCLog.Log( "cocos2d: WARNING: originalWidth/Height not found on the CCSpriteFrame. AnchorPoint won't work as expected. Regenerate the .plist or check the 'format' metatag"); } // abs ow/oh ow = Math.Abs(ow); oh = Math.Abs(oh); // create frame spriteFrame = new CCSpriteFrame( new CCSize(ow, oh), pobTexture, new CCRect(x, y, w, h), new CCSize(ow, oh), false, new CCPoint(ox, oy) ); } else if (format == 1 || format == 2) { CCRect frame = CCRect.Parse(frameDict["frame"].AsString); bool rotated = false; // rotation if (format == 2) { if (frameDict.ContainsKey("rotated")) { rotated = frameDict["rotated"].AsBool; } } CCPoint offset = CCPoint.Parse(frameDict["offset"].AsString); CCSize sourceSize = CCSize.Parse(frameDict["sourceSize"].AsString); // create frame spriteFrame = new CCSpriteFrame( sourceSize, pobTexture, frame, sourceSize, rotated, offset ); } else if (format == 3) { // get values CCSize spriteSize = CCSize.Parse(frameDict["spriteSize"].AsString); CCPoint spriteOffset = CCPoint.Parse(frameDict["spriteOffset"].AsString); CCSize spriteSourceSize = CCSize.Parse(frameDict["spriteSourceSize"].AsString); CCRect textureRect = CCRect.Parse(frameDict["textureRect"].AsString); bool textureRotated = false; if (frameDict.ContainsKey("textureRotated")) { textureRotated = frameDict["textureRotated"].AsBool; } // get aliases PlistArray aliases = frameDict["aliases"].AsArray; string frameKey = pair.Key; foreach (PlistObjectBase item2 in aliases) { string oneAlias = item2.AsString; if (spriteFramesAliases.ContainsKey(oneAlias)) { if (spriteFramesAliases[oneAlias] != null) { CCLog.Log("CocosSharp: WARNING: an alias with name {0} already exists", oneAlias); } } if (!spriteFramesAliases.ContainsKey(oneAlias)) { spriteFramesAliases.Add(oneAlias, frameKey); } } // create frame spriteFrame = new CCSpriteFrame( spriteSourceSize, pobTexture, new CCRect(textureRect.Origin.X, textureRect.Origin.Y, spriteSize.Width, spriteSize.Height), spriteSourceSize, textureRotated, spriteOffset ); } // add sprite frame string key = pair.Key; if (!AllowFrameOverwrite && spriteFrames.ContainsKey(key)) { CCLog.Log("Frame named " + key + " already exists in the animation cache. Not overwriting existing record."); } else if (AllowFrameOverwrite || !spriteFrames.ContainsKey(key)) { spriteFrames[key] = spriteFrame; } } }