public override void StartWithTarget(CCNode target) { base.StartWithTarget(target); float r, zenith, azimuth; SphericalRadius(out r, out zenith, out azimuth); if (float.IsNaN(m_fRadius)) { m_fRadius = r; } if (float.IsNaN(m_fAngleZ)) { m_fAngleZ = CCMacros.CCRadiansToDegrees(zenith); } if (float.IsNaN(m_fAngleX)) { m_fAngleX = CCMacros.CCRadiansToDegrees(azimuth); } m_fRadZ = CCMacros.CCDegreesToRadians(m_fAngleZ); m_fRadX = CCMacros.CCDegreesToRadians(m_fAngleX); }
private void updateTexture() { CCTexture2D tex; // Dump the old one if (Texture != null) { Texture.Dispose(); } // let system compute label's width or height when its value is 0 // refer to cocos2d-x issue #1430 tex = new CCTexture2D(); tex.InitWithString(m_pString, CCMacros.CCSizePointsToPixels(m_tDimensions), m_hAlignment, m_vAlignment, m_pFontName, m_fFontSize * CCMacros.CCContentScaleFactor()); Texture = tex; CCRect rect = CCRect.Zero; rect.Size = m_pobTexture.ContentSize; SetTextureRect(rect); }
/* optimization methos */ private CCSprite AppendTileForGID(uint gid, CCPoint pos) { CCRect rect = m_pTileSet.RectForGID(gid); rect = CCMacros.CCRectanglePixelsToPoints(rect); var z = (int)(pos.X + pos.Y * m_tLayerSize.Width); CCSprite tile = ReusedTileWithRect(rect); SetupTileSprite(tile, pos, gid); // optimization: // The difference between appendTileForGID and insertTileforGID is that append is faster, since // it appends the tile at the end of the texture atlas int indexForZ = m_pAtlasIndexArray.Count; // don't add it using the "standard" way. AddQuadFromSprite(tile, indexForZ); // append should be after addQuadFromSprite since it modifies the quantity values m_pAtlasIndexArray.Insert(indexForZ, z); return(tile); }
private void UpdateAtlasValueAt(CCGridSize pos, Color value, int index) { int x = pos.X; int y = pos.Y; float row = (float)(value.R % m_uItemsPerRow); float col = (float)(value.R / m_uItemsPerRow); float textureWide = (m_pTextureAtlas.Texture.PixelsWide); float textureHigh = (m_pTextureAtlas.Texture.PixelsHigh); float itemWidthInPixels = m_uItemWidth * CCMacros.CCContentScaleFactor(); float itemHeightInPixels = m_uItemHeight * CCMacros.CCContentScaleFactor(); #if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL float left = (2 * row * itemWidthInPixels + 1) / (2 * textureWide); float right = left + (itemWidthInPixels * 2 - 2) / (2 * textureWide); float top = (2 * col * itemHeightInPixels + 1) / (2 * textureHigh); float bottom = top + (itemHeightInPixels * 2 - 2) / (2 * textureHigh); #else float left = (row * itemWidthInPixels) / textureWide; float right = left + itemWidthInPixels / textureWide; float top = (col * itemHeightInPixels) / textureHigh; float bottom = top + itemHeightInPixels / textureHigh; #endif CCV3F_C4B_T2F_Quad quad; quad.TopLeft.TexCoords.U = left; quad.TopLeft.TexCoords.V = top; quad.TopRight.TexCoords.U = right; quad.TopRight.TexCoords.V = top; quad.BottomLeft.TexCoords.U = left; quad.BottomLeft.TexCoords.V = bottom; quad.BottomRight.TexCoords.U = right; quad.BottomRight.TexCoords.V = bottom; quad.BottomLeft.Vertices.X = (x * m_uItemWidth); quad.BottomLeft.Vertices.Y = (y * m_uItemHeight); quad.BottomLeft.Vertices.Z = 0.0f; quad.BottomRight.Vertices.X = (x * m_uItemWidth + m_uItemWidth); quad.BottomRight.Vertices.Y = (y * m_uItemHeight); quad.BottomRight.Vertices.Z = 0.0f; quad.TopLeft.Vertices.X = (x * m_uItemWidth); quad.TopLeft.Vertices.Y = (y * m_uItemHeight + m_uItemHeight); quad.TopLeft.Vertices.Z = 0.0f; quad.TopRight.Vertices.X = (x * m_uItemWidth + m_uItemWidth); quad.TopRight.Vertices.Y = (y * m_uItemHeight + m_uItemHeight); quad.TopRight.Vertices.Z = 0.0f; var color = new CCColor4B(m_tColor.R, m_tColor.G, m_tColor.B, m_cOpacity); quad.TopRight.Colors = color; quad.TopLeft.Colors = color; quad.BottomRight.Colors = color; quad.BottomLeft.Colors = color; m_pTextureAtlas.UpdateQuad(ref quad, index); }
protected virtual bool InitWithWidthAndHeight(int w, int h, SurfaceFormat colorFormat, DepthFormat depthFormat, RenderTargetUsage usage) { m_Width = (int)Math.Ceiling(w * CCMacros.CCContentScaleFactor()); m_Height = (int)Math.Ceiling(h * CCMacros.CCContentScaleFactor()); m_ColorFormat = colorFormat; m_DepthFormat = depthFormat; m_Usage = usage; MakeTexture(); return(true); }
/// <summary> /// Creates the full set of bolt segments between the start and end points. Based upon the /// algorithm found at http://gamedevelopment.tutsplus.com/tutorials/how-to-generate-shockingly-good-2d-lightning-effects--gamedev-2681 /// by Michael Hoffman. /// </summary> /// <param name="source"></param> /// <param name="dest"></param> /// <returns></returns> protected virtual List <CCPoint> CreateBolt(CCPoint source, CCPoint dest) { var results = new List <CCPoint>(); List <float> seglength = new List <float>(); CCPoint tangent = dest - source; CCPoint normal = CCPoint.Normalize(new CCPoint(tangent.Y, -tangent.X)); float length = tangent.Length; List <float> positions = new List <float>(); positions.Add(0); for (int i = 0; i < length / 4; i++) { positions.Add(CCMacros.CCRandomBetween0And1()); } positions.Sort(); CCPoint prevPoint = source; float prevDisplacement = 0; for (int i = 1; i < positions.Count; i++) { float pos = positions[i]; // used to prevent sharp angles by ensuring very close positions also have small perpendicular variation. float scale = (length * m_Jaggedness) * (pos - positions[i - 1]); // defines an envelope. Points near the middle of the bolt can be farther from the central line. float envelope = pos > 0.95f ? 20f * (1f - pos) : 1f; float displacement = -m_Sway + 2f * m_Sway * CCMacros.CCRandomBetween0And1(); displacement -= (displacement - prevDisplacement) * (1 - scale); displacement *= envelope; CCPoint point = source + tangent * pos + normal * displacement; // Core segment results.Add(prevPoint); results.Add(point); // Length of this segment float ll = (point - prevPoint).Length; seglength.Add(ll); _TrackLength += ll; // Continue to the next segment. prevPoint = point; prevDisplacement = displacement; } results.Add(prevPoint); results.Add(dest); _SegmentLengths = seglength.ToArray(); return(results); }
private void Init(float radius, float deltaRadius, float angleZ, float deltaAngleZ, float angleX, float deltaAngleX) { m_fRadius = radius; m_fDeltaRadius = deltaRadius; m_fAngleZ = angleZ; m_fDeltaAngleZ = deltaAngleZ; m_fAngleX = angleX; m_fDeltaAngleX = deltaAngleX; m_fRadDeltaZ = CCMacros.CCDegreesToRadians(deltaAngleZ); m_fRadDeltaX = CCMacros.CCDegreesToRadians(deltaAngleX); }
public void Set2DProjection() { CCSize size = m_pTexture.ContentSizeInPixels; CCDrawManager.SetViewPort(0, 0, (int)(size.Width * CCMacros.CCContentScaleFactor()), (int)(size.Height * CCMacros.CCContentScaleFactor()) ); /* * CCDrawManager.ProjectionMatrix = Matrix.Identity; * * Matrix orthoMatrix = Matrix.CreateOrthographicOffCenter( * 0, size.width * ccMacros.CC_CONTENT_SCALE_FACTOR(), * 0, size.height * ccMacros.CC_CONTENT_SCALE_FACTOR(), * -1, 1 * ); * * CCDrawManager.MultMatrix(ref orthoMatrix); */ CCDrawManager.ViewMatrix = Matrix.Identity; CCDrawManager.ProjectionMatrix = Matrix.Identity; Matrix projection = Matrix.CreateOrthographicOffCenter(0, size.Width, 0, size.Height, -1024.0f, 1024.0f); Matrix halfPixelOffset = Matrix.CreateTranslation(-0.5f, -0.5f, 0); CCDrawManager.WorldMatrix = (halfPixelOffset * projection); /* * CCDirector *director = CCDirector::sharedDirector(); * * CCSize size = director->getWinSizeInPixels(); * * glViewport(0, 0, (GLsizei)(size.width * CC_CONTENT_SCALE_FACTOR()), (GLsizei)(size.height * CC_CONTENT_SCALE_FACTOR()) ); * kmGLMatrixMode(KM_GL_PROJECTION); * kmGLLoadIdentity(); * * kmMat4 orthoMatrix; * kmMat4OrthographicProjection(&orthoMatrix, 0, size.width * CC_CONTENT_SCALE_FACTOR(), 0, size.height * CC_CONTENT_SCALE_FACTOR(), -1, 1); * kmGLMultMatrix( &orthoMatrix ); * * kmGLMatrixMode(KM_GL_MODELVIEW); * kmGLLoadIdentity(); * * * ccSetProjectionMatrixDirty(); */ }
/** initializes a CCTMXLayer with a tileset info, a layer info and a map info */ public bool InitWithTilesetInfo(CCTMXTilesetInfo tilesetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo) { // XXX: is 35% a good estimate ? CCSize size = layerInfo.LayerSize; float totalNumberOfTiles = size.Width * size.Height; float capacity = totalNumberOfTiles * 0.35f + 1; // 35 percent is occupied ? CCTexture2D texture = null; if (tilesetInfo != null) { texture = CCTextureCache.SharedTextureCache.AddImage(tilesetInfo.m_sSourceImage); } if (base.InitWithTexture(texture, (int)capacity)) { // layerInfo m_sLayerName = layerInfo.Name; m_tLayerSize = size; m_pTiles = layerInfo.Tiles; m_uMinGID = layerInfo.MinGID; m_uMaxGID = layerInfo.MaxGID; m_cOpacity = layerInfo.Opacity; Properties = new Dictionary <string, string>(layerInfo.Properties); m_fContentScaleFactor = CCDirector.SharedDirector.ContentScaleFactor; // tilesetInfo m_pTileSet = tilesetInfo; // mapInfo m_tMapTileSize = mapInfo.TileSize; m_uLayerOrientation = (CCTMXOrientation)mapInfo.Orientation; // offset (after layer orientation is set); CCPoint offset = CalculateLayerOffset(layerInfo.Offset); Position = CCMacros.CCPointPixelsToPoints(offset); m_pAtlasIndexArray = new List <int>((int)totalNumberOfTiles); ContentSize = CCMacros.CCSizePixelsToPoints(new CCSize(m_tLayerSize.Width * m_tMapTileSize.Width, m_tLayerSize.Height * m_tMapTileSize.Height)); m_bUseAutomaticVertexZ = false; m_nVertexZvalue = 0; return(true); } return(false); }
protected virtual bool InitWithTexture(CCTexture2D pobTexture, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize) { m_pobTexture = pobTexture; m_obRectInPixels = rect; m_obRect = CCMacros.CCRectanglePixelsToPoints(rect); m_obOffsetInPixels = offset; m_obOffset = CCMacros.CCPointPixelsToPoints(m_obOffsetInPixels); m_obOriginalSizeInPixels = originalSize; m_obOriginalSize = CCMacros.CCSizePixelsToPoints(m_obOriginalSizeInPixels); m_bRotated = rotated; return(true); }
protected virtual bool InitWithTextureFilename(String filename, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize) { m_pobTexture = null; m_strTextureFilename = filename; m_obRectInPixels = rect; m_obRect = CCMacros.CCRectanglePixelsToPoints(rect); m_obOffsetInPixels = offset; m_obOffset = CCMacros.CCPointPixelsToPoints(m_obOffsetInPixels); m_obOriginalSizeInPixels = originalSize; m_obOriginalSize = CCMacros.CCSizePixelsToPoints(m_obOriginalSizeInPixels); m_bRotated = rotated; return(true); }
public bool InitWithString(string theString, string fntFile) { string data = CCFileUtils.GetFileData(fntFile); PlistDocument doc = new PlistDocument(data); var dict = doc.Root as PlistDictionary; Debug.Assert(dict["version"].AsInt == 1, "Unsupported version. Upgrade cocos2d version"); string textureFilename = dict["textureFilename"].AsString; int width = (int)Math.Ceiling(dict["itemWidth"].AsInt / CCMacros.CCContentScaleFactor()); int height = (int)Math.Ceiling(dict["itemHeight"].AsInt / CCMacros.CCContentScaleFactor()); var startChar = (char)dict["firstChar"].AsInt; return(InitWithString(theString, textureFilename, width, height, startChar)); }
private void updateTexture() { CCTexture2D tex; // Dump the old one if (Texture != null) { CCTexture2D tmp = Texture; Texture = null; tmp.Dispose(); } // let system compute label's width or height when its value is 0 // refer to cocos2d-x issue #1430 tex = new CCTexture2D(); var result = tex.InitWithString(m_pString, m_tDimensions.PointsToPixels(), m_hAlignment, m_vAlignment, m_pFontName, m_fFontSize * CCMacros.CCContentScaleFactor()); //#if MACOS || IPHONE || IOS // // There was a problem loading the text for some reason or another if result is not true // // For MonoMac and IOS Applications we will try to create a Native Label automatically // // If the font is not found then a default font will be selected by the device and used. // if (!result && !string.IsNullOrEmpty(m_pString)) // { // tex = CCLabelUtilities.CreateLabelTexture (m_pString, // CCMacros.CCSizePointsToPixels (m_tDimensions), // m_hAlignment, // m_vAlignment, // m_pFontName, // m_fFontSize * CCMacros.CCContentScaleFactor (), // new CCColor4B(Microsoft.Xna.Framework.Color.White) ); // } //#endif if (result) { Texture = tex; CCRect rect = CCRect.Zero; rect.Size = m_pobTexture.ContentSize; SetTextureRect(rect); } }
/** sets the tile gid (gid = tile global id) at a given tile coordinate. * The Tile GID can be obtained by using the method "tileGIDAt" or by using the TMX editor . Tileset Mgr +1. * If a tile is already placed at that position, then it will be removed. * * Use withFlags if the tile flags need to be changed as well */ public void SetTileGID(uint gid, CCPoint pos, uint flags) { Debug.Assert(pos.X < m_tLayerSize.Width && pos.Y < m_tLayerSize.Height && pos.X >= 0 && pos.Y >= 0, "TMXLayer: invalid position"); Debug.Assert(m_pTiles != null && m_pAtlasIndexArray != null, "TMXLayer: the tiles map has been released"); Debug.Assert(gid == 0 || gid >= m_pTileSet.m_uFirstGid, "TMXLayer: invalid gid"); uint currentFlags; uint currentGID = TileGIDAt(pos, out currentFlags); if (currentGID != gid || currentFlags != flags) { uint gidAndFlags = gid | flags; // setting gid=0 is equal to remove the tile if (gid == 0) { RemoveTileAt(pos); } // empty tile. create a new one else if (currentGID == 0) { InsertTileForGID(gidAndFlags, pos); } // modifying an existing tile with a non-empty tile else { var z = (int)(pos.X + pos.Y * m_tLayerSize.Width); var sprite = (CCSprite)GetChildByTag(z); if (sprite != null) { CCRect rect = m_pTileSet.RectForGID(gid); rect = CCMacros.CCRectanglePixelsToPoints(rect); sprite.SetTextureRect(rect, false, rect.Size); if (flags != 0) { SetupTileSprite(sprite, sprite.Position, gidAndFlags); } m_pTiles[z] = gidAndFlags; } else { UpdateTileForGID(gidAndFlags, pos); } } } }
public void Set2DProjection() { CCSize size = m_pTexture.ContentSizeInPixels; CCDrawManager.SetViewPort(0, 0, (int)(size.Width * CCMacros.CCContentScaleFactor()), (int)(size.Height * CCMacros.CCContentScaleFactor()) ); CCDrawManager.ViewMatrix = Matrix.Identity; CCDrawManager.ProjectionMatrix = Matrix.Identity; Matrix projection = Matrix.CreateOrthographicOffCenter(0, size.Width, 0, size.Height, -1024.0f, 1024.0f); Matrix halfPixelOffset = Matrix.CreateTranslation(-0.5f, -0.5f, 0); CCDrawManager.WorldMatrix = (halfPixelOffset * projection); }
public AtlasFastBitmap() { // Upper Label for (int i = 0; i < 100; i++) { //char str[6] = {0}; string str; //sprintf(str, "-%d-", i); str = string.Format("-{0,d}-", i); CCLabelBMFont label = new CCLabelBMFont(str, "fonts/bitmapFontTest.fnt"); AddChild(label); CCSize s = CCDirector.SharedDirector.WinSize; CCPoint p = new CCPoint(CCMacros.CCRandomBetween0And1() * s.Width, CCMacros.CCRandomBetween0And1() * s.Height); label.Position = p; label.AnchorPoint = new CCPoint(0.5f, 0.5f); } }
/** returns the position in points of a given tile coordinate */ public CCPoint PositionAt(CCPoint pos) { CCPoint ret = CCPoint.Zero; switch (m_uLayerOrientation) { case CCTMXOrientation.Ortho: ret = PositionForOrthoAt(pos); break; case CCTMXOrientation.Iso: ret = PositionForIsoAt(pos); break; case CCTMXOrientation.Hex: ret = PositionForHexAt(pos); break; } ret = CCMacros.CCPointPixelsToPoints(ret); return(ret); }
protected virtual bool InitWithWidthAndHeight(int w, int h, SurfaceFormat colorFormat, DepthFormat depthFormat, RenderTargetUsage usage) { w = (w * CCMacros.CCContentScaleFactor()); h = (h * CCMacros.CCContentScaleFactor()); m_pTexture = new CCTexture2D(); m_pTexture.SetAliasTexParameters(); m_pRenderTarget2D = CCDrawManager.CreateRenderTarget(w, h, colorFormat, depthFormat, usage); m_pTexture.InitWithTexture(m_pRenderTarget2D); m_bFirstUsage = true; m_pSprite = new CCSprite(m_pTexture); //m_pSprite.scaleY = -1; m_pSprite.BlendFunc = new CCBlendFunc(CCMacros.CCDefaultSourceBlending, CCMacros.CCDefaultDestinationBlending); // OGLES.GL_ONE, OGLES.GL_ONE_MINUS_SRC_ALPHA); AddChild(m_pSprite); return(true); }
protected virtual bool InitWithWidthAndHeight(int w, int h, SurfaceFormat colorFormat, DepthFormat depthFormat, RenderTargetUsage usage) { w = (int)Math.Ceiling(w * CCMacros.CCContentScaleFactor()); h = (int)Math.Ceiling(h * CCMacros.CCContentScaleFactor()); m_pTexture = new CCTexture2D(); m_pTexture.IsAntialiased = false; m_pRenderTarget2D = CCDrawManager.CreateRenderTarget(w, h, colorFormat, depthFormat, usage); m_pTexture.InitWithTexture(m_pRenderTarget2D, colorFormat, true, false); m_bFirstUsage = true; m_pSprite = new CCSprite(m_pTexture); //m_pSprite.scaleY = -1; m_pSprite.BlendFunc = CCBlendFunc.AlphaBlend; AddChild(m_pSprite); return(true); }
/** returns the tile (CCSprite) at a given a tile coordinate. * The returned CCSprite will be already added to the CCTMXLayer. Don't add it again. * The CCSprite can be treated like any other CCSprite: rotated, scaled, translated, opacity, color, etc. * You can remove either by calling: * - layer.removeChild(sprite, cleanup); * - or layer.removeTileAt(ccp(x,y)); */ public CCSprite TileAt(CCPoint pos) { Debug.Assert(pos.X < m_tLayerSize.Width && pos.Y < m_tLayerSize.Height && pos.X >= 0 && pos.Y >= 0, "TMXLayer: invalid position"); Debug.Assert(m_pTiles != null && m_pAtlasIndexArray != null, "TMXLayer: the tiles map has been released"); CCSprite tile = null; uint gid = TileGIDAt(pos); // if GID == 0, then no tile is present if (gid != 0) { var z = (int)(pos.X + pos.Y * m_tLayerSize.Width); tile = (CCSprite)GetChildByTag(z); // tile not created yet. create it if (tile == null) { CCRect rect = m_pTileSet.RectForGID(gid); rect = CCMacros.CCRectanglePixelsToPoints(rect); tile = new CCSprite(Texture, rect); // // do the init AFTER the batch node is set so that the tile is set to // draw in batch mode instead of self draw mode. // tile.BatchNode = this; tile.Position = PositionAt(pos); tile.VertexZ = VertexZForPos(pos); tile.AnchorPoint = CCPoint.Zero; tile.Opacity = m_cOpacity; // tile.InitWithTexture(Texture, rect); // tile.BatchNode = this; int indexForZ = AtlasIndexForExistantZ(z); AddSpriteWithoutQuad(tile, indexForZ, z); } } return(tile); }
private CCSprite InsertTileForGID(uint gid, CCPoint pos) { CCRect rect = m_pTileSet.RectForGID(gid); rect = CCMacros.CCRectanglePixelsToPoints(rect); var z = (int)(pos.X + pos.Y * m_tLayerSize.Width); CCSprite tile = ReusedTileWithRect(rect); SetupTileSprite(tile, pos, gid); // get atlas index int indexForZ = AtlasIndexForNewZ(z); // Optimization: add the quad without adding a child AddQuadFromSprite(tile, indexForZ); // insert it into the local atlasindex array m_pAtlasIndexArray.Insert(indexForZ, z); // update possible children if (m_pChildren != null && m_pChildren.count > 0) { CCNode[] elements = m_pChildren.Elements; int count = m_pChildren.count; for (int i = 0; i < count; i++) { var sprite = (CCSprite)elements[i]; int ai = sprite.AtlasIndex; if (ai >= indexForZ) { sprite.AtlasIndex = ai + 1; } } } m_pTiles[z] = gid; return(tile); }
protected void UpdateSliderPosition(CCPoint location) { // Clamp the position of the icon within the circle CCRect backgroundBox = _background.BoundingBox; // Get the center point of the background image float centerX = _startPos.X + backgroundBox.Size.Width * 0.5f; float centerY = _startPos.Y + backgroundBox.Size.Height * 0.5f; // Work out the distance difference between the location and center float dx = location.X - centerX; float dy = location.Y - centerY; // Update angle by using the direction of the location var angle = (float)Math.Atan2(dy, dx); float angleDeg = CCMacros.CCRadiansToDegrees(angle) + 180.0f; // use the position / slider width to determin the percentage the dragger is at Hue = angleDeg; // send Control callback SendActionsForControlEvents(CCControlEvent.ValueChanged); }
public virtual CCAffineTransform NodeToParentTransform() { if (m_bIsTransformDirty) { // Translate values float x = m_tPosition.X; float y = m_tPosition.Y; if (m_bIgnoreAnchorPointForPosition) { x += m_tAnchorPointInPoints.X; y += m_tAnchorPointInPoints.Y; } // Rotation values float c = 1, s = 0; if (m_fRotation != 0.0f) { float radians = -CCMacros.CCDegreesToRadians(m_fRotation); c = (float)Math.Cos(radians); s = (float)Math.Sin(radians); } bool needsSkewMatrix = (m_fSkewX != 0f || m_fSkewY != 0f); // optimization: // inline anchor point calculation if skew is not needed if (!needsSkewMatrix && !m_tAnchorPointInPoints.Equals(CCPoint.Zero)) { x += c * -m_tAnchorPointInPoints.X * m_fScaleX + -s * -m_tAnchorPointInPoints.Y * m_fScaleY; y += s * -m_tAnchorPointInPoints.X * m_fScaleX + c * -m_tAnchorPointInPoints.Y * m_fScaleY; } // Build Transform Matrix //m_tTransform = new CCAffineTransform( // c * m_fScaleX, s * m_fScaleX, // -s * m_fScaleY, c * m_fScaleY, // x, y); // Build Transform Matrix m_tTransform.a = c * m_fScaleX; m_tTransform.b = s * m_fScaleX; m_tTransform.c = -s * m_fScaleY; m_tTransform.d = c * m_fScaleY; m_tTransform.tx = x; m_tTransform.ty = y; // XXX: Try to inline skew // If skew is needed, apply skew and then anchor point if (needsSkewMatrix) { var skewMatrix = new CCAffineTransform( 1.0f, (float)Math.Tan(CCMacros.CCDegreesToRadians(m_fSkewY)), (float)Math.Tan(CCMacros.CCDegreesToRadians(m_fSkewX)), 1.0f, 0.0f, 0.0f); m_tTransform = CCAffineTransform.Concat(skewMatrix, m_tTransform); // adjust anchor point if (!m_tAnchorPointInPoints.Equals(CCPoint.Zero)) { m_tTransform = CCAffineTransform.Translate(m_tTransform, -m_tAnchorPointInPoints.X, -m_tAnchorPointInPoints.Y); } } m_bIsTransformDirty = false; } return(m_tTransform); }
public virtual CCAffineTransform NodeToParentTransform() { if (m_bTransformDirty) { // Translate values float x = m_obPosition.X; float y = m_obPosition.Y; if (m_bIgnoreAnchorPointForPosition) { x += m_obAnchorPointInPoints.X; y += m_obAnchorPointInPoints.Y; } // Rotation values // Change rotation code to handle X and Y // If we skew with the exact same value for both x and y then we're simply just rotating float cx = 1, sx = 0, cy = 1, sy = 0; if (m_fRotationX != 0 || m_fRotationY != 0) { float radiansX = -CCMacros.CCDegreesToRadians(m_fRotationX); float radiansY = -CCMacros.CCDegreesToRadians(m_fRotationY); cx = (float)Math.Cos(radiansX); sx = (float)Math.Sin(radiansX); cy = (float)Math.Cos(radiansY); sy = (float)Math.Sin(radiansY); } bool needsSkewMatrix = (m_fSkewX != 0f || m_fSkewY != 0f); // optimization: // inline anchor point calculation if skew is not needed if (!needsSkewMatrix && !m_obAnchorPointInPoints.Equals(CCPoint.Zero)) { x += cy * -m_obAnchorPointInPoints.X * m_fScaleX + -sx * -m_obAnchorPointInPoints.Y * m_fScaleY; y += sy * -m_obAnchorPointInPoints.X * m_fScaleX + cx * -m_obAnchorPointInPoints.Y * m_fScaleY; } // Build Transform Matrix // Adjusted transform calculation for rotational skew m_sTransform.a = cy * m_fScaleX; m_sTransform.b = sy * m_fScaleX; m_sTransform.c = -sx * m_fScaleY; m_sTransform.d = cx * m_fScaleY; m_sTransform.tx = x; m_sTransform.ty = y; // XXX: Try to inline skew // If skew is needed, apply skew and then anchor point if (needsSkewMatrix) { var skewMatrix = new CCAffineTransform( 1.0f, (float)Math.Tan(CCMacros.CCDegreesToRadians(m_fSkewY)), (float)Math.Tan(CCMacros.CCDegreesToRadians(m_fSkewX)), 1.0f, 0.0f, 0.0f); m_sTransform = CCAffineTransform.Concat(skewMatrix, m_sTransform); // adjust anchor point if (!m_obAnchorPointInPoints.Equals(CCPoint.Zero)) { m_sTransform = CCAffineTransform.Translate(m_sTransform, -m_obAnchorPointInPoints.X, -m_obAnchorPointInPoints.Y); } } if (m_bAdditionalTransformDirty) { m_sTransform.Concat(ref m_sAdditionalTransform); m_bAdditionalTransformDirty = false; } m_bTransformDirty = false; } return(m_sTransform); }
protected virtual bool InitWithTexture(CCTexture2D pobTexture, CCRect rect) { CCRect rectInPixels = CCMacros.CCRectanglePointsToPixels(rect); return(InitWithTexture(pobTexture, rectInPixels, false, new CCPoint(0, 0), rectInPixels.Size)); }
private void SetTextureCoords(CCRect rect) { rect = CCMacros.CCRectanglePointsToPixels(rect); CCTexture2D tex = m_pobBatchNode != null ? m_pobTextureAtlas.Texture : m_pobTexture; if (tex == null) { return; } float atlasWidth = tex.PixelsWide; float atlasHeight = tex.PixelsHigh; float left, right, top, bottom; if (m_bRectRotated) { #if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL left = (2 * rect.origin.x + 1) / (2 * atlasWidth); right = left + (rect.size.height * 2 - 2) / (2 * atlasWidth); top = (2 * rect.origin.y + 1) / (2 * atlasHeight); bottom = top + (rect.size.width * 2 - 2) / (2 * atlasHeight); #else left = rect.Origin.X / atlasWidth; right = (rect.Origin.X + rect.Size.Height) / atlasWidth; top = rect.Origin.Y / atlasHeight; bottom = (rect.Origin.Y + rect.Size.Width) / atlasHeight; #endif // CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL if (m_bFlipX) { CCMacros.CCSwap(ref top, ref bottom); } if (m_bFlipY) { CCMacros.CCSwap(ref left, ref right); } m_sQuad.BottomLeft.TexCoords.U = left; m_sQuad.BottomLeft.TexCoords.V = top; m_sQuad.BottomRight.TexCoords.U = left; m_sQuad.BottomRight.TexCoords.V = bottom; m_sQuad.TopLeft.TexCoords.U = right; m_sQuad.TopLeft.TexCoords.V = top; m_sQuad.TopRight.TexCoords.U = right; m_sQuad.TopRight.TexCoords.V = bottom; } else { #if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL left = (2 * rect.origin.x + 1) / (2 * atlasWidth); right = left + (rect.size.width * 2 - 2) / (2 * atlasWidth); top = (2 * rect.origin.y + 1) / (2 * atlasHeight); bottom = top + (rect.size.height * 2 - 2) / (2 * atlasHeight); #else left = rect.Origin.X / atlasWidth; right = (rect.Origin.X + rect.Size.Width) / atlasWidth; top = rect.Origin.Y / atlasHeight; bottom = (rect.Origin.Y + rect.Size.Height) / atlasHeight; #endif // ! CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL if (m_bFlipX) { CCMacros.CCSwap(ref left, ref right); } if (m_bFlipY) { CCMacros.CCSwap(ref top, ref bottom); } m_sQuad.BottomLeft.TexCoords.U = left; m_sQuad.BottomLeft.TexCoords.V = bottom; m_sQuad.BottomRight.TexCoords.U = right; m_sQuad.BottomRight.TexCoords.V = bottom; m_sQuad.TopLeft.TexCoords.U = left; m_sQuad.TopLeft.TexCoords.V = top; m_sQuad.TopRight.TexCoords.U = right; m_sQuad.TopRight.TexCoords.V = top; } }
public override void UpdateAtlasValues() { int n = m_sString.Length; CCTexture2D texture = m_pTextureAtlas.Texture; float textureWide = texture.PixelsWide; float textureHigh = texture.PixelsHigh; float itemWidthInPixels = m_uItemWidth * CCMacros.CCContentScaleFactor(); float itemHeightInPixels = m_uItemHeight * CCMacros.CCContentScaleFactor(); if (m_bIgnoreContentScaleFactor) { itemWidthInPixels = m_uItemWidth; itemHeightInPixels = m_uItemHeight; } for (int i = 0; i < n; i++) { var a = (char)(m_sString[i] - m_cMapStartChar); float row = (a % m_uItemsPerRow); float col = (a / m_uItemsPerRow); #if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL // Issue #938. Don't use texStepX & texStepY float left = (2 * row * itemWidthInPixels + 1) / (2 * textureWide); float right = left + (itemWidthInPixels * 2 - 2) / (2 * textureWide); float top = (2 * col * itemHeightInPixels + 1) / (2 * textureHigh); float bottom = top + (itemHeightInPixels * 2 - 2) / (2 * textureHigh); #else float left = row * itemWidthInPixels / textureWide; float right = left + itemWidthInPixels / textureWide; float top = col * itemHeightInPixels / textureHigh; float bottom = top + itemHeightInPixels / textureHigh; #endif // ! CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL CCV3F_C4B_T2F_Quad quad; quad.TopLeft.TexCoords.U = left; quad.TopLeft.TexCoords.V = top; quad.TopRight.TexCoords.U = right; quad.TopRight.TexCoords.V = top; quad.BottomLeft.TexCoords.U = left; quad.BottomLeft.TexCoords.V = bottom; quad.BottomRight.TexCoords.U = right; quad.BottomRight.TexCoords.V = bottom; quad.BottomLeft.Vertices.X = i * m_uItemWidth; quad.BottomLeft.Vertices.Y = 0.0f; quad.BottomLeft.Vertices.Z = 0.0f; quad.BottomRight.Vertices.X = i * m_uItemWidth + m_uItemWidth; quad.BottomRight.Vertices.Y = 0.0f; quad.BottomRight.Vertices.Z = 0.0f; quad.TopLeft.Vertices.X = i * m_uItemWidth; quad.TopLeft.Vertices.Y = m_uItemHeight; quad.TopLeft.Vertices.Z = 0.0f; quad.TopRight.Vertices.X = i * m_uItemWidth + m_uItemWidth; quad.TopRight.Vertices.Y = m_uItemHeight; quad.TopRight.Vertices.Z = 0.0f; quad.TopLeft.Colors = quad.TopRight.Colors = quad.BottomLeft.Colors = quad.BottomRight.Colors = new CCColor4B(_displayedColor.R, _displayedColor.G, _displayedColor.B, _displayedOpacity); m_pTextureAtlas.UpdateQuad(ref quad, i); } }
// pointRect should be in Texture coordinates, not pixel coordinates private void InitTexCoordsWithRect(CCRect pointRect) { // convert to Tex coords var rect = new CCRect( pointRect.Origin.X * CCMacros.CCContentScaleFactor(), pointRect.Origin.Y * CCMacros.CCContentScaleFactor(), pointRect.Size.Width * CCMacros.CCContentScaleFactor(), pointRect.Size.Height * CCMacros.CCContentScaleFactor()); float wide = pointRect.Size.Width; float high = pointRect.Size.Height; if (m_pTexture != null) { wide = m_pTexture.PixelsWide; high = m_pTexture.PixelsHigh; } #if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL float left = (rect.origin.x * 2 + 1) / (wide * 2); float bottom = (rect.origin.y * 2 + 1) / (high * 2); float right = left + (rect.size.width * 2 - 2) / (wide * 2); float top = bottom + (rect.size.height * 2 - 2) / (high * 2); #else float left = rect.Origin.X / wide; float bottom = rect.Origin.Y / high; float right = left + rect.Size.Width / wide; float top = bottom + rect.Size.Height / high; #endif // ! CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL // Important. Texture in cocos2d are inverted, so the Y component should be inverted float tmp = top; top = bottom; bottom = tmp; CCV3F_C4B_T2F_Quad[] quads; int start, end; if (m_pBatchNode != null) { quads = m_pBatchNode.TextureAtlas.m_pQuads.Elements; m_pBatchNode.TextureAtlas.Dirty = true; start = m_uAtlasIndex; end = m_uAtlasIndex + m_uTotalParticles; } else { quads = m_pQuads.Elements; start = 0; end = m_uTotalParticles; } for (int i = start; i < end; i++) { // bottom-left vertex: quads[i].BottomLeft.TexCoords.U = left; quads[i].BottomLeft.TexCoords.V = bottom; // bottom-right vertex: quads[i].BottomRight.TexCoords.U = right; quads[i].BottomRight.TexCoords.V = bottom; // top-left vertex: quads[i].TopLeft.TexCoords.U = left; quads[i].TopLeft.TexCoords.V = top; // top-right vertex: quads[i].TopRight.TexCoords.U = right; quads[i].TopRight.TexCoords.V = top; } }
public void DrawCircle(CCPoint center, float radius, CCColor4B color) { DrawCircle(center, radius, CCMacros.CCDegreesToRadians(360f), 360, color); }
public static void SetDesignResolutionSize(float width, float height, ResolutionPolicy resolutionPolicy) { Debug.Assert(resolutionPolicy != ResolutionPolicy.UnKnown, "should set resolutionPolicy"); if (width == 0.0f || height == 0.0f) { return; } m_obDesignResolutionSize.Width = width; m_obDesignResolutionSize.Height = height; m_fScaleX = m_obScreenSize.Width / m_obDesignResolutionSize.Width; m_fScaleY = m_obScreenSize.Height / m_obDesignResolutionSize.Height; if (resolutionPolicy == ResolutionPolicy.NoBorder) { m_fScaleX = m_fScaleY = Math.Max(m_fScaleX, m_fScaleY); } if (resolutionPolicy == ResolutionPolicy.ShowAll) { m_fScaleX = m_fScaleY = Math.Min(m_fScaleX, m_fScaleY); } // calculate the rect of viewport float viewPortW = m_obDesignResolutionSize.Width * m_fScaleX; float viewPortH = m_obDesignResolutionSize.Height * m_fScaleY; m_obViewPortRect = new CCRect((m_obScreenSize.Width - viewPortW) / 2, (m_obScreenSize.Height - viewPortH) / 2, viewPortW, viewPortH); m_eResolutionPolicy = resolutionPolicy; // reset director's member variables to fit visible rect CCDirector.SharedDirector.m_obWinSizeInPoints = Size; CCDirector.SharedDirector.m_obWinSizeInPixels = new CCSize(m_obDesignResolutionSize.Width * CCMacros.CCContentScaleFactor(), m_obDesignResolutionSize.Height * CCMacros.CCContentScaleFactor()); CCDirector.SharedDirector.CreateStatsLabel(); CCDirector.SharedDirector.SetGlDefaultValues(); }