public Background(CCSize size, CCColor4B color) { Color = new CCColor3B(color); Opacity = color.A; AnchorPoint = CCPoint.AnchorMiddle; ContentSize = size; }
/* * TL TR * 0----1 0,1,2,3 = index offsets for vertex indices * | /| * | / | * | / | * |/ | * 2----3 * BL BR */ void GenerateGradient(CCSize textureSizeInPixels) { var gradientNode = new CCDrawNode(); var gradientAlpha = new CCColor4B(0, 0, 0,(byte)(0.7f * 255f)); CCV3F_C4B[] vertices = new CCV3F_C4B[6]; // Left triangle TL - 0 vertices[0].Vertices = new CCVertex3F(0, textureSizeInPixels.Height, 0); vertices[0].Colors = CCColor4B.Transparent; // Left triangle BL - 2 vertices[1].Vertices = new CCVertex3F(0, 0, 0); vertices[1].Colors = gradientAlpha; // Left triangle TR - 1 vertices[2].Vertices = new CCVertex3F(textureSizeInPixels.Width, textureSizeInPixels.Height, 0); vertices[2].Colors = CCColor4B.Transparent; // Right triangle BL - 2 vertices[3].Vertices = new CCVertex3F(0, 0, 0); vertices[3].Colors = gradientAlpha; // Right triangle BR - 3 vertices[4].Vertices = new CCVertex3F(textureSizeInPixels.Width, 0, 0); vertices[4].Colors = gradientAlpha; // Right triangle TR - 1 vertices[5].Vertices = new CCVertex3F(textureSizeInPixels.Width, textureSizeInPixels.Height, 0); vertices[5].Colors = CCColor4B.Transparent; gradientNode.DrawTriangleList(vertices); gradientNode.Visit(); }
public AlignmentPanel(CCSize size, CCColor4B color) { Color = new CCColor3B(color); Opacity = color.A; //AnchorPoint = CCPoint.AnchorMiddle; ContentSize = size; }
public SpriteWithColor(CCColor4B bgColor, CCSize textureSizeInPixels) : base () { // 1: Create new CCRenderTexture CCRenderTexture rt = new CCRenderTexture(textureSizeInPixels, textureSizeInPixels); // 2: Call CCRenderTexture:begin rt.BeginWithClear(bgColor); // 3: Draw into the texture // You'll add this later GenerateGradient(textureSizeInPixels); var noise = new CCSprite("images/Noise.png"); noise.AnchorPoint = CCPoint.AnchorLowerLeft; noise.Position = CCPoint.Zero; noise.BlendFunc = new CCBlendFunc(CCOGLES.GL_DST_COLOR, CCOGLES.GL_ZERO); noise.Texture.SamplerState = Microsoft.Xna.Framework.Graphics.SamplerState.LinearWrap; // To get the linear wrap to work correctly we have to set the TextureRectInPixels as well as ContentSize noise.TextureRectInPixels = new CCRect(0, 0, textureSizeInPixels.Width, textureSizeInPixels.Height); noise.ContentSize = noise.TextureRectInPixels.Size; noise.Visit(); // 4: Call CCRenderTexture:end rt.End(); this.Texture = rt.Texture; }
internal static CCTexture2D CreateNativeLabel(string text, CCSize dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, string fontName, float fontSize, CCColor4B textColor) { if (string.IsNullOrEmpty(text)) { return new CCTexture2D(); } var font = CreateFont (fontName, fontSize); if (dimensions.Equals(CCSize.Zero)) { CreateBitmap(1, 1); var ms = _graphics.MeasureString(text, font); dimensions.Width = ms.Width; dimensions.Height = ms.Height; } CreateBitmap((int)dimensions.Width, (int)dimensions.Height); var stringFormat = new StringFormat(); switch (hAlignment) { case CCTextAlignment.Left: stringFormat.Alignment = StringAlignment.Near; break; case CCTextAlignment.Center: stringFormat.Alignment = StringAlignment.Center; break; case CCTextAlignment.Right: stringFormat.Alignment = StringAlignment.Far; break; } switch (vAlignment) { case CCVerticalTextAlignment.Top: stringFormat.LineAlignment = StringAlignment.Near; break; case CCVerticalTextAlignment.Center: stringFormat.LineAlignment = StringAlignment.Center; break; case CCVerticalTextAlignment.Bottom: stringFormat.LineAlignment = StringAlignment.Far; break; } _graphics.DrawString(text, font, _brush, new RectangleF(0, 0, dimensions.Width, dimensions.Height), stringFormat); _graphics.Flush(); var texture = new CCTexture2D(SaveToStream(), CCSurfaceFormat.Bgra4444); return texture; }
public static CCV3F_C4B ToVectorC4B(this b2Vec2 vec, CCColor4B color, int PTMRatio) { var v3f_c4b = new CCV3F_C4B(); v3f_c4b.Vertices.X = vec.x * PTMRatio; v3f_c4b.Vertices.Y = vec.y * PTMRatio; v3f_c4b.Colors = color; return v3f_c4b; }
public override void DrawSolidPolygon(Box2D.Common.b2Vec2[] vertices, int vertexCount, Box2D.Common.b2Color color) { CCPoint[] verticesToPoint = new CCPoint[vertexCount]; CCColor4B Color = new CCColor4B (color.r, color.g, color.b, 255); for (int i = 0; i < vertexCount; i++) { verticesToPoint [i] = new CCPoint (vertices [i].x * 50f, vertices [i].y * 50f); } DrawNode.DrawPolygon (verticesToPoint, vertexCount, Color, 3f, Color); }
public Ball(float x, float y, float r, CCColor4B c) { this.x = x; this.y = y; this.r = r; this.color = c; location = new CCPoint (x , y); circle = new CCDrawNode (); drawCircle (); }
/* * TL TR * 0----1 0,1,2,3 = index offsets for vertex indices * | /| * | / | * | / | * |/ | * 2----3 * BL BR */ void GenerateStripes (CCSize textureSizeInPixels, CCColor4B c2, int numberOfStripes) { var gradientNode = new CCDrawNode(); // Layer 1: Stripes CCV3F_C4B[] vertices = new CCV3F_C4B[numberOfStripes*6]; var textureWidth = textureSizeInPixels.Width; var textureHeight = textureSizeInPixels.Height; int nVertices = 0; float x1 = -textureHeight; float x2; float y1 = textureHeight; float y2 = 0; float dx = textureWidth / numberOfStripes * 2; float stripeWidth = dx/2; for (int i=0; i<numberOfStripes; i++) { x2 = x1 + textureHeight; // Left triangle TL - 0 vertices[nVertices].Vertices = new CCVertex3F(x1, y1, 0); vertices[nVertices++].Colors = c2; // Left triangle BL - 2 vertices[nVertices].Vertices = new CCVertex3F(x1+stripeWidth, y1, 0); vertices[nVertices++].Colors = c2; // Left triangle TR - 1 vertices[nVertices].Vertices = new CCVertex3F(x2, y2, 0); vertices[nVertices++].Colors = c2; // Right triangle BL - 2 vertices[nVertices].Vertices = vertices[nVertices-2].Vertices; vertices[nVertices++].Colors = c2; // Right triangle BR - 3 vertices[nVertices].Vertices = vertices[nVertices-2].Vertices; vertices[nVertices++].Colors = c2; // Right triangle TR - 1 vertices[nVertices].Vertices = new CCVertex3F(x2+stripeWidth, y2, 0); vertices[nVertices++].Colors = c2; x1 += dx; } gradientNode.DrawTriangleList(vertices); gradientNode.Visit(); }
private void CreateBitmap(int width, int height) { // if (_bitmap == null || (_bitmap.Width < width || _bitmap.Height < height)) // { _bitmap = CCLabelUtilities.CreateBitmap (width, height); //} //if (_brush == null) //{ _brush = CCColor4B.White; //} }
public static void DrawPoint(CCPoint p, float size, CCColor4B color) { var verts = new CCPoint[4]; float hs = size / 2.0f; verts[0] = p + new CCPoint(-hs, -hs); verts[1] = p + new CCPoint(hs, -hs); verts[2] = p + new CCPoint(hs, hs); verts[3] = p + new CCPoint(-hs, hs); DrawPoly(verts, 4, false, true, color); }
private void RefreshColor() { BackgroundNode.Cleanup(); CCColor4B CurrColor = new CCColor4B(); if (Status == ButtonStatus.Pressed) { CurrColor = ClickedColor; } else { CurrColor = NormalColor; } BackgroundNode.DrawRect(new CCRect(0, 0, ContentSize.Width, ContentSize.Height), CurrColor); }
public void DrawCircle(CCPoint center, float radius, int segments, CCColor4B color) { var cl = color; float theta = MathHelper.Pi * 2.0f / segments; float tangetial_factor = (float)Math.Tan(theta); //calculate the tangential factor float radial_factor = (float)Math.Cos(theta); //calculate the radial factor float x = radius; //we start at angle = 0 float y = 0; var vert1 = new CCV3F_C4B(CCVertex3F.Zero, cl); float tx = 0; float ty = 0; for (int i = 0; i < segments; i++) { vert1.Vertices.X = x + center.X; vert1.Vertices.Y = y + center.Y; AddLineVertex(vert1); // output vertex //calculate the tangential vector //remember, the radial vector is (x, y) //to get the tangential vector we flip those coordinates and negate one of them tx = -y; ty = x; //add the tangential vector x += tx * tangetial_factor; y += ty * tangetial_factor; //correct using the radial factor x *= radial_factor; y *= radial_factor; vert1.Vertices.X = x + center.X; vert1.Vertices.Y = y + center.Y; AddLineVertex(vert1); // output vertex } dirty = true; }
protected void Draw() { CCColor4B color = new CCColor4B(1.0f, 1.0f, 1.0f, 1.0f); switch (_lineType) { case lineTypes.LINE_NONE: break; case lineTypes.LINE_TEMP: drawNode.DrawLine(_tip, _pivot, color); drawNode.DrawCircle(_pivot, 10, 10, color); break; case lineTypes.LINE_DASHED: drawNode.DrawCircle(_pivot, 10, 10, color); int segments = (int)(_lineLength / (_dash + _dashSpace)); float t = 0.0f; float x_; float y_; for (int i = 0; i < segments + 1; i++) { x_ = _pivot.X + t * (_tip.X - _pivot.X); y_ = _pivot.Y + t * (_tip.Y - _pivot.Y); drawNode.DrawCircle(new CCPoint(x_, y_), 4, 6, color); t += (float)1 / segments; } break; } //draw energy bar color = new CCColor4B(0.0f, 0.0f, 0.0f, 1.0f); drawNode.DrawLine( new CCPoint(_energyLineX, _screenSize.Height * 0.1f), new CCPoint(_energyLineX, _screenSize.Height * 0.9f), color); color = new CCColor4B(1.0f, 0.5f, 0.0f, 1.0f); drawNode.DrawLine( new CCPoint(_energyLineX, _screenSize.Height * 0.1f), new CCPoint(_energyLineX, _screenSize.Height * 0.1f + _energy * _energyHeight), color); }
public StripeWithColor(CCColor4B c1, CCColor4B c2, CCSize textureSizeInPixels, int nStripes) : base () { // 1: Create new CCRenderTexture CCRenderTexture rt = new CCRenderTexture(textureSizeInPixels, textureSizeInPixels); // 2: Call CCRenderTexture:begin rt.BeginWithClear(c1); // 3: Draw into the texture // You'll add this later GenerateStripes(textureSizeInPixels, c2, nStripes); var noise = new CCSprite("images/Noise.png"); noise.AnchorPoint = CCPoint.AnchorLowerLeft; noise.BlendFunc = new CCBlendFunc(CCOGLES.GL_DST_COLOR, CCOGLES.GL_ZERO); noise.Visit(); // 4: Call CCRenderTexture:end rt.End(); this.Texture = rt.Texture; }
public void Clear(CCColor4B color, float depth) { Clear(color, depth, 0); }
// Used for drawing line caps public void DrawSolidArc(CCPoint pos, float radius, float startAngle, float sweepAngle, CCColor4B color) { var cl = color.ToColor(); int segments = (int)(10 * (float)Math.Sqrt(radius)); //<- Let's try to guess at # segments for a reasonable smoothness float theta = sweepAngle / (segments - 1); // MathHelper.Pi * 2.0f / segments; float tangetial_factor = (float)Math.Tan(theta); //calculate the tangential factor float radial_factor = (float)Math.Cos(theta); //calculate the radial factor float x = radius * (float)Math.Cos(startAngle); //we now start at the start angle float y = radius * (float)Math.Sin(startAngle); var verticeCenter = new VertexPositionColor(new Vector3(pos.X, pos.Y, 0), cl); var vert1 = new VertexPositionColor(Vector3.Zero, cl); float tx = 0; float ty = 0; for (int i = 0; i < segments - 1; i++) { triangleVertices.Add(verticeCenter); vert1.Position.X = x + pos.X; vert1.Position.Y = y + pos.Y; triangleVertices.Add(vert1); // output vertex //calculate the tangential vector //remember, the radial vector is (x, y) //to get the tangential vector we flip those coordinates and negate one of them tx = -y; ty = x; //add the tangential vector x += tx * tangetial_factor; y += ty * tangetial_factor; //correct using the radial factor x *= radial_factor; y *= radial_factor; vert1.Position.X = x + pos.X; vert1.Position.Y = y + pos.Y; triangleVertices.Add(vert1); // output vertex } dirty = true; }
public CCV3F_C4B(CCPoint position, CCColor4B color) { this.Vertices = CCVertex3F.Zero; this.Vertices.X = position.X; this.Vertices.Y = position.Y; Colors = color; }
public CCV2F_C4B_T2F() { Vertices = new CCVertex2F(); Colors = new CCColor4B(); TexCoords = new CCTex2F(); }
public CCColor4F(CCColor4B color4B) : this(color4B.R / 255.0f, color4B.G / 255.0f, color4B.B / 255.0f, color4B.A / 255.0f) { }
public bool Equals(CCColor4B other) { return this == other; }
public static void DrawPoints(CCPoint[] points, int numberOfPoints, float size, CCColor4B color) { for (int i = 0; i < numberOfPoints; i++) { DrawPoint(points[i], size, color); } }
internal static void NativeDrawString(CGBitmapContext bitmapContext, string s, CTFont font, CCColor4B brush, RectangleF layoutRectangle) { if (font == null) { throw new ArgumentNullException("font"); } if (s == null || s.Length == 0) { return; } bitmapContext.ConcatCTM(bitmapContext.GetCTM().Invert()); // This is not needed here since the color is set in the attributed string. //bitmapContext.SetFillColor(brush.R/255f, brush.G/255f, brush.B/255f, brush.A/255f); // I think we only Fill the text with no Stroke surrounding //bitmapContext.SetTextDrawingMode(CGTextDrawingMode.Fill); var attributedString = buildAttributedString(s, font, brush); // Work out the geometry RectangleF insetBounds = layoutRectangle; PointF textPosition = new PointF(insetBounds.X, insetBounds.Y); float boundsWidth = insetBounds.Width; // Calculate the lines int start = 0; int length = attributedString.Length; var typesetter = new CTTypesetter(attributedString); float baselineOffset = 0; // First we need to calculate the offset for Vertical Alignment if we // are using anything but Top if (vertical != CCVerticalTextAlignment.Top) { while (start < length) { int count = typesetter.SuggestLineBreak(start, boundsWidth); var line = typesetter.GetLine(new NSRange(start, count)); // Create and initialize some values from the bounds. float ascent; float descent; float leading; line.GetTypographicBounds(out ascent, out descent, out leading); baselineOffset += (float)Math.Ceiling(ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior line.Dispose(); start += count; } } start = 0; 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(new NSRange(start, count)); // Create and initialize some values from the bounds. float ascent; float descent; float leading; line.GetTypographicBounds(out ascent, out descent, out leading); // Calculate the string format if need be var penFlushness = 0.0f; if (horizontal == CCTextAlignment.Right) { penFlushness = (float)line.GetPenOffsetForFlush(1.0f, boundsWidth); } else if (horizontal == CCTextAlignment.Center) { penFlushness = (float)line.GetPenOffsetForFlush(0.5f, boundsWidth); } // initialize our Text Matrix or we could get trash in here var textMatrix = CGAffineTransform.MakeIdentity(); if (vertical == CCVerticalTextAlignment.Top) { textMatrix.Translate(penFlushness, insetBounds.Height - textPosition.Y - (float)Math.Floor(ascent - 1)); } if (vertical == CCVerticalTextAlignment.Center) { textMatrix.Translate(penFlushness, ((insetBounds.Height / 2) + (baselineOffset / 2)) - textPosition.Y - (float)Math.Floor(ascent - 1)); } if (vertical == CCVerticalTextAlignment.Bottom) { textMatrix.Translate(penFlushness, baselineOffset - textPosition.Y - (float)Math.Floor(ascent - 1)); } // Set our matrix bitmapContext.TextMatrix = textMatrix; // and draw the line line.Draw(bitmapContext); // Move the index beyond the line break. start += count; textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior line.Dispose(); } }
public void BeginWithClear(CCColor4B clearColor, float depth = 1.0f, int stencil = 0) { ClearColor = clearColor; Begin(); }
void UpdateQuad(ref CCV3F_C4B_T2F_Quad quad, ref CCParticleBase particle) { CCPoint newPosition; if (PositionType == CCPositionType.Free || PositionType == CCPositionType.Relative) { newPosition.X = particle.Position.X - (currentPosition.X - particle.StartPosition.X); newPosition.Y = particle.Position.Y - (currentPosition.Y - particle.StartPosition.Y); } else { newPosition = particle.Position; } // translate newPos to correct position, since matrix transform isn't performed in batchnode // don't update the particle with the new position information, it will interfere with the radius and tangential calculations if (BatchNode != null) { newPosition.X += Position.X; newPosition.Y += Position.Y; } CCColor4B color = new CCColor4B(); if (OpacityModifyRGB) { color.R = (byte)(particle.Color.R * particle.Color.A * 255); color.G = (byte)(particle.Color.G * particle.Color.A * 255); color.B = (byte)(particle.Color.B * particle.Color.A * 255); color.A = (byte)(particle.Color.A * 255); } else { color.R = (byte)(particle.Color.R * 255); color.G = (byte)(particle.Color.G * 255); color.B = (byte)(particle.Color.B * 255); color.A = (byte)(particle.Color.A * 255); } quad.BottomLeft.Colors = color; quad.BottomRight.Colors = color; quad.TopLeft.Colors = color; quad.TopRight.Colors = color; // vertices float size_2 = particle.Size / 2; if (particle.Rotation != 0.0) { float x1 = -size_2; float y1 = -size_2; float x2 = size_2; float y2 = size_2; float x = newPosition.X; float y = newPosition.Y; float r = -CCMathHelper.ToRadians(particle.Rotation); float cr = CCMathHelper.Cos(r); float sr = CCMathHelper.Sin(r); float ax = x1 * cr - y1 * sr + x; float ay = x1 * sr + y1 * cr + y; float bx = x2 * cr - y1 * sr + x; float by = x2 * sr + y1 * cr + y; float cx = x2 * cr - y2 * sr + x; float cy = x2 * sr + y2 * cr + y; float dx = x1 * cr - y2 * sr + x; float dy = x1 * sr + y2 * cr + y; // bottom-left quad.BottomLeft.Vertices.X = ax; quad.BottomLeft.Vertices.Y = ay; // bottom-right vertex: quad.BottomRight.Vertices.X = bx; quad.BottomRight.Vertices.Y = by; // top-left vertex: quad.TopLeft.Vertices.X = dx; quad.TopLeft.Vertices.Y = dy; // top-right vertex: quad.TopRight.Vertices.X = cx; quad.TopRight.Vertices.Y = cy; } else { // bottom-left vertex: quad.BottomLeft.Vertices.X = newPosition.X - size_2; quad.BottomLeft.Vertices.Y = newPosition.Y - size_2; // bottom-right vertex: quad.BottomRight.Vertices.X = newPosition.X + size_2; quad.BottomRight.Vertices.Y = newPosition.Y - size_2; // top-left vertex: quad.TopLeft.Vertices.X = newPosition.X - size_2; quad.TopLeft.Vertices.Y = newPosition.Y + size_2; // top-right vertex: quad.TopRight.Vertices.X = newPosition.X + size_2; quad.TopRight.Vertices.Y = newPosition.Y + size_2; } }
public void Clear(CCColor4B color) { Clear(color, 1.0f); }
public static void DrawPoints(CCPoint[] points, float size, CCColor4B color) { DrawPoints(points, points.Length, size, color); }
public void DrawPolygon(CCPoint[] verts, int count, CCColor4B fillColor, float borderWidth, CCColor4B borderColor) { DrawPolygon(verts, count, new CCColor4F(fillColor), borderWidth, new CCColor4F(borderColor)); }
protected override void Draw() { base.Draw(); CCColor4B color = new CCColor4B(1.0f, 1.0f, 1.0f, 1.0f); CCDrawingPrimitives.Begin(); switch (_lineType) { case lineTypes.LINE_NONE: break; case lineTypes.LINE_TEMP: //CCDrawingPrimitives.Begin(); CCDrawingPrimitives.DrawLine(_tip, _pivot, color); CCDrawingPrimitives.DrawCircle(_pivot, 10, CCMathHelper.ToRadians(360), 10, false, color); //CCDrawingPrimitives.End(); break; case lineTypes.LINE_DASHED: //CCDrawingPrimitives.Begin(); CCDrawingPrimitives.DrawCircle(_pivot, 10, (float)Math.PI, 10, false, color); //CCDrawingPrimitives.End(); int segments = (int)(_lineLength / (_dash + _dashSpace)); float t = 0.0f; float x_; float y_; for (int i = 0; i < segments + 1; i++) { x_ = _pivot.X + t * (_tip.X - _pivot.X); y_ = _pivot.Y + t * (_tip.Y - _pivot.Y); //CCDrawingPrimitives.Begin(); CCDrawingPrimitives.DrawCircle(new CCPoint(x_, y_), 4, (float)Math.PI, 6, false, color); //CCDrawingPrimitives.End(); t += (float)1 / segments; } break; } //draw energy bar color = new CCColor4B(0.0f, 0.0f, 0.0f, 1.0f); CCDrawingPrimitives.DrawLine( new CCPoint(_energyLineX, _screenSize.Height * 0.1f), new CCPoint(_energyLineX, _screenSize.Height * 0.9f), color); color = new CCColor4B(1.0f, 0.5f, 0.0f, 1.0f); CCDrawingPrimitives.DrawLine( new CCPoint(_energyLineX, _screenSize.Height * 0.1f), new CCPoint(_energyLineX, _screenSize.Height * 0.1f + _energy * _energyHeight), color); CCDrawingPrimitives.End(); }
public CCLayerColor(CCColor4B color) : this(CCSize.Zero, color) { }
public static CCColor4B Lerp(CCColor4B value1, CCColor4B value2, float amount) { CCColor4B color = new CCColor4B(); color.A = (byte)(value1.A + ((value2.A - value1.A) * amount)); color.R = (byte)(value1.R + ((value2.R - value1.R) * amount)); color.G = (byte)(value1.G + ((value2.G - value1.G) * amount)); color.B = (byte)(value1.B + ((value2.B - value1.B) * amount)); return color; }
public CCLayerColor(CCSize visibleBoundsDimensions, CCColor4B color) : this(new CCCamera(visibleBoundsDimensions), color) { }
public CCPointSprite() { Position = new CCVertex2F(); Color = new CCColor4B(); Size = 0.0f; }
public void DrawRect(CCRect rect, CCColor4B fillColor) { DrawRect(rect, fillColor, 0, CCColor4B.Transparent); }
public CCV3F_C4B(CCVertex3F position, CCColor4B color) { this.Vertices = position; Colors = color; }
public void DrawCircle(CCPoint center, float radius, float angle, int segments, CCColor4B color) { float increment = MathHelper.Pi * 2.0f / segments; double theta = 0.0; CCPoint v1; List <CCPoint> verts = new List <CCPoint>(); for (int i = 0; i < segments; i++) { v1 = center + new CCPoint((float)Math.Cos(theta), (float)Math.Sin(theta)) * radius; verts.Add(v1); theta += increment; } CCColor4F cf = new CCColor4F(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f); DrawPolygon(verts.ToArray(), verts.Count, cf, 0, new CCColor4F(0f, 0f, 0f, 0f)); }
public CCColor3B(CCColor4B color4B): this(color4B.R, color4B.G, color4B.B) { }
/// <summary> /// draws a cubic bezier path /// @since v0.8 /// </summary> public static void DrawCubicBezier(CCPoint origin, CCPoint control1, CCPoint control2, CCPoint destination, int segments, CCColor4B color) { float t = 0; float increment = 1.0f / segments; var vertices = new CCPoint[segments]; vertices[0] = origin; for (int i = 1; i < segments; ++i, t+= increment) { vertices[i].X = CCSplineMath.CubicBezier(origin.X, control1.X, control2.X, destination.X, t); vertices[i].Y = CCSplineMath.CubicBezier(origin.Y, control1.Y, control2.Y, destination.Y, t); } vertices[segments - 1] = destination; DrawPoly(vertices, color); }
/// <summary> /// creates a CCLayer with color, width and height in Points /// </summary> public CCLayerColor (CCCamera camera, CCColor4B color) : base(camera) { DisplayedColor = RealColor = new CCColor3B(color.R, color.G, color.B); DisplayedOpacity = RealOpacity = color.A; BlendFunc = CCBlendFunc.NonPremultiplied; UpdateColor(); }
public void Clear(CCColor4B color, float depth, int stencil) { Clear(ClearOptions.Target | ClearOptions.Stencil | ClearOptions.DepthBuffer, color.ToColor(), depth, stencil); }
public CCLayerColor(CCSize visibleBoundsDimensions, CCColor4B color) : this(new CCCamera(visibleBoundsDimensions), color) { }
public CCLayerColor(CCColor4B color) : this(null, color) { }