private void drawLine(Point p1, Point p2)
{
List <Point> controlPoints = BezierHelper.getControlPoints(0.4, p1, p2);
if (isHaveLastControlPoint == false)
{
lastControlPoint = p1;
isHaveLastControlPoint = true;
}
QuadraticBezierSegment bezierSegment = new QuadraticBezierSegment(p1, controlPoints[0], true);
lastControlPoint = controlPoints[1];
pathFigure.Segments.Add(bezierSegment);
LineSegment lineSegment = new LineSegment(controlPoints[1], true);
pathFigure.Segments.Add(lineSegment);
//if (isHaveLastControlPoint == false)
//{
// lastControlPoint = p1;
// isHaveLastControlPoint = true;
//}
//LineSegment lineSegment=new LineSegment(p2,true);
//pathFigure.Segments.Add(lineSegment);
// Graphics.FromHwnd(this)
lastControlPoint = controlPoints[1];
}
protected override void OnAnimate()
{
UIObject.Scale(
BezierHelper.Linear(EasingTime, StartScale, EndScale),
Anchor.GetValueOrDefault(UIObject.Anchor)
);
}
private void drawLine(Point p1, Point p2)
{
List <Point> controlPoints = BezierHelper.getControlPoints(0.4, p1, p2);
if (isHaveLastControlPoint == false)
{
lastControlPoint = p1;
isHaveLastControlPoint = true;
}
//先画bezier，再画直线
// QuadraticBezierSegment bezierSegment = new QuadraticBezierSegment(p1, controlPoints[0], true);
//
// lastControlPoint = controlPoints[1];
// pathFigure.Segments.Add(bezierSegment);
// LineSegment lineSegment = new LineSegment(controlPoints[1], true);
// pathFigure.Segments.Add(lineSegment);
StreamGeometry streamGeometry = new StreamGeometry();
using (StreamGeometryContext ctx = streamGeometry.Open())
{
ctx.BeginFigure(lastControlPoint, false, false);
ctx.QuadraticBezierTo(p1, controlPoints[0], true, true);
ctx.LineTo(controlPoints[1], true, true);
}
lastControlPoint = controlPoints[1];
geometryGroup.Children.Add(streamGeometry);
}
private void BtnQuadratciBezier_Click(object sender, RoutedEventArgs e)
{
this.inkCanvas.Strokes.Clear();
Point p1 = new Point()
{
X = 200, Y = 400
};
Point p2 = new Point()
{
X = 300, Y = 200
};
Point p3 = new Point()
{
X = 400, Y = 400
};
List <Point> points = BezierHelper.getQuadraticBezierPoints(p1, p2, p3, Convert.ToInt16(txtCount.Text));
StylusPointCollection stylusPointCollection = new StylusPointCollection();
for (int i = 0; i < points.Count; i++)
{
stylusPointCollection.Add(new StylusPoint(points[i].X, points[i].Y));
}
Stroke stroke = new Stroke(stylusPointCollection);
stroke.DrawingAttributes = new DrawingAttributes {
Width = 1, Height = 1, Color = Color.FromRgb(0, 0, 0)
};
this.inkCanvas.Strokes.Add(stroke);
}
public override void Animate()
{
transform.localScale = BezierHelper.Linear(
EasingTime,
Settings.From,
Settings.To);
}
void PaintLinkLine(Link link, RenderArgs e)
{
Rectangle rect1 = link.From.Bounds;
Rectangle rect2 = link.Target.Bounds;
// if bounds changed, rebuild layout info
if (rect1 != link.LayoutData.StartBounds || rect2 != link.LayoutData.EndBounds)
{
link.RefreshLayout();
}
// draw line
var layout = link.LayoutData;
Color color = link.Color.IsEmpty ? e.Chart.LinkLineColor : link.Color;
var pen = e.Graphics.Pen(color, link.LineWidth, link.LineStyle);
e.Graphics.DrawBezier(pen, layout.StartPoint, layout.ControlPoint1, layout.ControlPoint2, layout.EndPoint,
link.StartCap, link.EndCap);
//text
if (!string.IsNullOrEmpty(link.Text))
{
var pt = BezierHelper.GetPoint(layout.StartPoint, layout.ControlPoint1, layout.ControlPoint2, layout.EndPoint, 0.5f);
var size = Size.Ceiling(e.Graphics.MeasureString(link.Text, e.Font));
var rectText = new Rectangle(pt.X - size.Width / 2, pt.Y - size.Height / 2, size.Width, size.Height);
if (!e.Chart.BackColor.IsEmpty)
{
e.Graphics.FillRectangle(e.Graphics.SolidBrush(Color.FromArgb(180, e.Chart.BackColor)), rectText);
}
if (!e.Chart.ForeColor.IsEmpty)
{
var font2 = e.Font;
if (!string.IsNullOrEmpty(link.Hyperlink))
{
font2 = e.Graphics.Font(e.Font, e.Font.Style | FontStyle.Underline);
}
var sf = PaintHelper.SFCenter;
e.Graphics.DrawString(link.Text, font2, e.Graphics.SolidBrush(e.Chart.ForeColor), rectText, sf);
}
link.LayoutData.TextBounds = rectText;
}
else
{
link.LayoutData.TextBounds = Rectangle.Empty;
}
// remark-icon
if (e.ShowRemarkIcon && link.HaveRemark)
{
Image iconRemark = Properties.Resources.note_small;
Point pt = BezierHelper.GetPoint(layout.StartPoint, layout.ControlPoint1, layout.ControlPoint2, layout.EndPoint, 0.5f);
Rectangle rectRemark = new Rectangle(pt.X - iconRemark.Width / 2, pt.Y - iconRemark.Height / 2, iconRemark.Width, iconRemark.Height);
e.Graphics.DrawImage(iconRemark, rectRemark, 0, 0, iconRemark.Width, iconRemark.Height);
}
}
protected override void OnAnimate()
{
UIObject.Position(
position: BezierHelper.Linear(EasingTime, StartPos, EndPos),
anchor: Anchor.GetValueOrDefault(UIObject.Anchor),
relativeTo: RelativeTo
);
}
protected override void OnAnimate()
{
UIObject.Position(
position: BezierHelper.Quadratic(EasingTime, FirstPoint, SecondPoint, ThirdPoint),
anchor: Anchor.GetValueOrDefault(UIObject.Anchor),
relativeTo: RelativeTo
);
}
public override void Animate()
{
transform.Position(
BezierHelper.Quadratic(EasingTime,
Settings.FirstPoint,
Settings.SecondPoint,
Settings.ThirdPoint),
Settings.RelativeTo);
}
private void drawLine(float nCompress, Point p, Point lastTwoPoint, Point lastOnePoint)
{
startCount++;
if (!isStartedPoint)
{
startTime = (DateTime.Now.Ticks - dtFrom.Ticks) / 10000;
lastControlPoint = p;
stylusPointCollection = new StylusPointCollection();
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, 0.1f));
stroke = new Stroke(stylusPointCollection);
stroke.DrawingAttributes = new DrawingAttributes
{
Width = brushWidth, Height = brushWidth, Color = Color.FromRgb(0, 0, 0)
};
isStartedPoint = true;
isFirst = true;
ic.Strokes.Add(stroke);
isHaveLastControlPoint = false;
}
else
{
isFirst = false;
if (startCount < 3)
{
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, 0.1f));
}
else
{
var controlPoints = BezierHelper.getControlPoints(0.4, lastTwoPoint, lastOnePoint);
if (isHaveLastControlPoint && lastControlPoint.X != 0 && lastControlPoint.Y != 0)
{
var quadraticBezierPoints = BezierHelper.getQuadraticBezierPoints(lastControlPoint,
lastTwoPoint,
controlPoints[0], 6);
foreach (var item in quadraticBezierPoints)
{
stylusPointCollection.Add(new StylusPoint(item.X, item.Y, nCompress));
}
lastControlPoint = controlPoints[1];
}
else
{
isHaveLastControlPoint = true;
lastControlPoint = p;
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, nCompress));
}
}
Console.WriteLine("draw5：{0},{1},{2}", p.X, p.Y, nCompress);
}
points.Add(new MyPoint {
Point = p, Pressure = nCompress, IsFirst = isFirst, LastControlPoint = lastControlPoint
});
}
private void LateUpdate()
{
if (Bezier == null)
{
return;
}
transform.position = Bezier.transform.TransformPoint(BezierHelper.BezierValue(CurrentStepLength, Points));
float value = pathTool.FiringGap < 1 ? StepLengthFactor / StepLength : StepLengthFactor / StepLength + pathTool.CompensationFactor;
CurrentStepLength += value;
}
/// <summary>
/// Gets points on the path that are evenly spaced with given value.
/// </summary>
/// <param name="spacing">Distance between points.</param>
/// <param name="resolution">Time value.</param>
/// <returns>Array of points that are evenly spaced on the curve.</returns>
public Vector2[] CalculateEvenlySpacedPoints(float spacing, float resolution = 1)
{
var evenlySpacedPoints = new List <Vector2>
{
points[0]
};
Vector2 lastPoint = points[0];
float distanceSinceLastEvenPoint = 0;
for (int i = 0; i < SegmentsCount; i++)
{
Vector2[] pointsInSegment = GetPointsInSegment(i);
float controlNetLength = Vector2.Distance(pointsInSegment[0], pointsInSegment[1])
+ Vector2.Distance(pointsInSegment[1], pointsInSegment[2])
+ Vector2.Distance(pointsInSegment[2], pointsInSegment[3]);
float estimatedCurveLength = Vector2.Distance(pointsInSegment[0], pointsInSegment[3]) + (controlNetLength / 2);
int divisions = Mathf.CeilToInt((estimatedCurveLength * resolution) * 10);
float t = 0;
while (t <= 1)
{
t += 1.0f / divisions;
// Get point on the curve
Vector2 pointOnCurve = BezierHelper.EvaluateCubic(pointsInSegment[0], pointsInSegment[1], pointsInSegment[2], pointsInSegment[3], t);
distanceSinceLastEvenPoint += Vector2.Distance(lastPoint, pointOnCurve);
/*
* If distance between the last point and the new one is less than spacing, then just ignore that new point.
* Otherwise if the distance is equal to spacing, add that point to evenly spaced points.
* And if the distance is more than spacing, then move that point back so that the distance becomes equal to
* spacing and that point to evenly spaced points.
*/
while (distanceSinceLastEvenPoint >= spacing)
{
float overshootDistance = distanceSinceLastEvenPoint - spacing;
Vector2 newEvenlySpacedPoint = pointOnCurve + ((lastPoint - pointOnCurve).normalized * overshootDistance);
evenlySpacedPoints.Add(newEvenlySpacedPoint);
distanceSinceLastEvenPoint = overshootDistance;
lastPoint = newEvenlySpacedPoint;
}
lastPoint = pointOnCurve;
}
}
return(evenlySpacedPoints.ToArray());
}
private void drawLine2(bool isFrist, float nCompress, Point p, MyPoint lastTwoPoint, MyPoint lastOnePoint)
{
if (isFrist)
{
Console.WriteLine("isFirst:" + isFrist);
startTime = (DateTime.Now.Ticks - dtFrom.Ticks) / 10000;
lastControlPoint = p;
stylusPointCollection = new StylusPointCollection();
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, 0.1f));
stroke = new Stroke(stylusPointCollection);
stroke.DrawingAttributes = new DrawingAttributes
{
Width = brushWidth, Height = brushWidth, Color = Color.FromRgb(0, 0, 0)
};
ic.Strokes.Add(stroke);
isHaveLastControlPoint = false;
}
else
{
if ((lastTwoPoint.Point.X == 0 && lastTwoPoint.Point.Y == 0) || (lastOnePoint.Point.X == 0 && lastOnePoint.Point.Y == 0))
{
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, 0.1f));
}
else
{
var controlPoints = BezierHelper.getControlPoints(0.4, lastTwoPoint.Point, lastOnePoint.Point);
if (isHaveLastControlPoint && lastOnePoint.LastControlPoint.X != 0 && lastOnePoint.LastControlPoint.Y != 0)
{
Console.WriteLine("lastOnePoint.LastControlPoint:" + lastOnePoint.LastControlPoint);
var quadraticBezierPoints = BezierHelper.getQuadraticBezierPoints(lastOnePoint.LastControlPoint,
lastTwoPoint.Point,
controlPoints[0], 12);
foreach (var item in quadraticBezierPoints)
{
stylusPointCollection.Add(new StylusPoint(item.X, item.Y, nCompress));
}
lastControlPoint = controlPoints[1];
}
else
{
isHaveLastControlPoint = true;
stylusPointCollection.Add(new StylusPoint(p.X, p.Y, nCompress));
}
}
Console.WriteLine("draw5：{0},{1},{2}", p.X, p.Y, nCompress);
}
}
protected override void OnAnimate()
{
var rotation = BezierHelper.Linear(EasingTime, FromAngle, ToAngle);
if (RotateAround != null)
{
UIObject.RotationAround(RotateAround.Value, rotation, RelativeTo);
}
else
{
UIObject.Rotation(rotation, RelativeTo);
}
}
private void drawLine(Point p1, Point p2, Point p3)
{
List <Point> controlPoints = BezierHelper.getControlPoints(0.3, p1, p2, p3);
if (isHaveLastControlPoint == false)
{
lastControlPoint = p1;
isHaveLastControlPoint = true;
}
BezierSegment bezierSegment = new BezierSegment(lastControlPoint, controlPoints[0], p2, true);
lastControlPoint = controlPoints[1];
pathFigure.Segments.Add(bezierSegment);
}
// Update is called once per frame
void Update()
{
if (CurrentStepLength > MaxStepLength)
{
pathTool.PointList.Add(gameObject);
gameObject.SetActive(false);
return;
}
Bezier = GetComponentInParent <BezierCurve>();
Target = Bezier.transform.TransformPoint(BezierHelper.BezierValue(CurrentStepLength, Points));
AutoRotate(Target);
}
private void initViews()
{
PathGeometry pathGeometry = new PathGeometry();
pathFigure = new PathFigure();
pathGeometry.Figures.Add(pathFigure);
Point p1 = new Point(100, 300);
Point p2 = new Point(200, 200);
Point p3 = new Point(300, 300);
Point p4 = new Point(400, 300);
// List<Point> controlPoints = getControlPoints(0.3, p1, p2, p3);
pathFigure.StartPoint = p1;
// BezierSegment bezierSegment=new BezierSegment(p1,controlPoints[0],p2,true);
// pathFigure.Segments.Add(bezierSegment);
// Point lastControlPoint = controlPoints[1];
//
// controlPoints = getControlPoints(0.3, p2, p3, p4); ;
// bezierSegment = new BezierSegment(lastControlPoint, controlPoints[0], p3, true);
//
// pathFigure.Segments.Add(bezierSegment);
List <Point> controlPoints = BezierHelper.getControlPoints(0.4, p1, p2);
pathFigure.StartPoint = p1;
LineSegment lineSegment = new LineSegment(controlPoints[0], true);
pathFigure.Segments.Add(lineSegment);
controlPoints = BezierHelper.getControlPoints(0.4, p2, p3);
QuadraticBezierSegment bezierSegment = new QuadraticBezierSegment(p2, controlPoints[0], true);
pathFigure.Segments.Add(bezierSegment);
lineSegment = new LineSegment(controlPoints[1], true);
pathFigure.Segments.Add(lineSegment);
controlPoints = BezierHelper.getControlPoints(0.4, p3, p4);
bezierSegment = new QuadraticBezierSegment(p3, controlPoints[0], true);
pathFigure.Segments.Add(bezierSegment);
Path path = new Path();
path.Stroke = new SolidColorBrush(Color.FromRgb(0, 0, 0));
path.Data = pathGeometry;
canvas.Children.Add(path);
}
protected void InvalidateLink(Point[] points, int width, bool realTime)
{
if (points == null || points.Length != 4)
{
return;
}
var region = BezierHelper.GetBezierUpdateRegion(
View.PointToReal(points[0]),
View.PointToReal(points[1]),
View.PointToReal(points[2]),
View.PointToReal(points[3]),
width);
InvalidateChart(region, realTime);
}
public static Vector3d GetPoint(CubeArray <Vector3d> array, double u, double v, double w)
{
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
_coordBufferSurf.Value[x + y * 4] = BezierHelper.Bezier(array[x, y, 0], array[x, y, 1], array[x, y, 2], array[x, y, 3], w);
}
}
for (int x = 0; x < 4; x++)
{
_coordBufferCurv.Value[x] = BezierHelper.Bezier(_coordBufferSurf.Value[x + 4 * 0], _coordBufferSurf.Value[x + 4 * 1], _coordBufferSurf.Value[x + 4 * 2], _coordBufferSurf.Value[x + 4 * 3], v);
}
return(BezierHelper.Bezier(_coordBufferCurv.Value[0], _coordBufferCurv.Value[1], _coordBufferCurv.Value[2], _coordBufferCurv.Value[3], u));
}
public override void AfterUpdatePosition()
{
this._timeStamp += this._behaviors.owner.battle.deltaTime;
Vec3 lastPos = this._behaviors.owner.property.position;
this._behaviors.owner.property.Equal(Attr.Position,
BezierHelper.GetPointAtTime(this._timeStamp / this._duration, this._src,
this._midPoint, this._targetPoint));
this._behaviors.owner.property.Equal(Attr.Direction,
Vec3.Normalize(this._behaviors.owner.property.position - lastPos));
if (this._timeStamp >= this._duration)
{
this.complete = true;
}
}
void DragControlHandle(BezierPoint controlHandle, Point pt)
{
if (TempLayout != null && SelectedObject.Link != null)
{
Rectangle rect = TempLayout.MaxRectangle;
Link line = SelectedObject.Link;
var oldPoints = line.GetBezierPoints();
pt = View.PointToLogic(pt);
switch (controlHandle)
{
case BezierPoint.StartPoint:
TempLayout.StartPoint = pt;
TempLayout.ControlPoint1 = BezierHelper.GetControlPoint(TempLayout.StartPoint, TempLayout.CP1);
break;
case BezierPoint.EndPoint:
TempLayout.EndPoint = pt;
TempLayout.ControlPoint2 = BezierHelper.GetControlPoint(TempLayout.EndPoint, TempLayout.CP2);
break;
case BezierPoint.ControlPoint1:
TempLayout.ControlPoint1 = pt;
Shape sShape = Shape.GetShaper(line.From);
TempLayout.StartPoint = sShape.GetBorderPoint(line.From.Bounds, TempLayout.ControlPoint1);
break;
case BezierPoint.ControlPoint2:
TempLayout.ControlPoint2 = pt;
Shape dShape = Shape.GetShaper(line.Target);
TempLayout.EndPoint = dShape.GetBorderPoint(line.Target.Bounds, TempLayout.ControlPoint2);
break;
default:
break;
}
//rect = Rectangle.Union(rect, TempLayout.MaxRectangle);
//InvalidateChart(rect, true);
InvalidateLink(oldPoints, line.Width, true);
InvalidateLink(TempLayout.GetPoints(), line.Width, true);
}
DragingControlHandle = controlHandle;
}
protected void InvalidateLink(Link link, bool realTime)
{
if (link == null)
{
return;
}
var region = BezierHelper.GetBezierUpdateRegionWidthHandles(
View.PointToReal(link.LayoutData.StartPoint),
View.PointToReal(link.LayoutData.ControlPoint1),
View.PointToReal(link.LayoutData.ControlPoint2),
View.PointToReal(link.LayoutData.EndPoint),
link.Width);
if (region != null)
{
InvalidateChart(region, realTime);
}
}
public void destroyBlock()
{
float time = Random.Range(0.6f, 0.8f);
float delay = Random.Range(0.05f, 0.15f);
GameObject guiObject = BezierHelper.moveTo(gameObject, uiTarget, fakeBlock, time, delay);
guiObject.GetComponent <FakeBlockController>().Invoke("OnFinishAnimation", time + delay);
guiObject.GetComponent <UISprite>().spriteName = GetComponentInChildren <SpriteRenderer>().sprite.name;;
guiObject.GetComponent <UISprite>().MarkAsChanged();
uiTarget.GetComponent <ResourceManager>().Invoke("addBlock", time + delay);
Destroy(this.gameObject);
//TODO finish sound
// TODO allow for the particles To fade
}
public void Set(float arc, Vec3 targetPoint)
{
this._targetPoint = targetPoint;
Entity self = this._behaviors.owner;
this._src = self.property.position;
Vec3 distance = this._targetPoint - this._src;
float magnitude = distance.Magnitude();
this._midPoint = distance / 2f + this._src;
this._midPoint.y = magnitude * arc;
this._duration = magnitude * MathUtils.PI * arc / (self.maxSpeed * self.property.moveSpeedFactor);
this._timeStamp = 0f;
//用上一个模拟的流逝时间来估算朝向
Vec3 nextPos = BezierHelper.GetPointAtTime(self.battle.deltaTime / this._duration, this._src, this._midPoint, this._targetPoint);
self.property.Equal(Attr.Position, Vec3.Normalize(nextPos - self.property.position));
this.complete = false;
}
void giveReward()
{
Game.Instance.playerStuffManager.money += client.reward;
int coinsToSpawn = (client.reward / 5);
GameObject uiTarget = Game.Instance.playerStuffManager.moneyIcon;
for (int i = 0; i < coinsToSpawn; ++i)
{
// vizualize
float time = Random.Range(0.6f, 0.8f);
float delay = (0.02f * i);
GameObject guiObject = BezierHelper.moveTo(avatar.gameObject, uiTarget, floatingCoinPrefab, time, delay);
Destroy(guiObject, time + delay);
// play sound only once
if (i == 0)
{
uiTarget.GetComponent <PlayerCoinsController>().Invoke("OnFinishAnimation", time + delay);
}
}
}
BezierLayoutInfo GetLayoutInfo(BezierControlPoint controlPoint1, BezierControlPoint controlPoint2)
{
var layout = new BezierLayoutInfo();
layout.CP1 = controlPoint1;
layout.CP2 = controlPoint2;
Point cp1, cp2;
Rectangle rect1 = From.Bounds;
Rectangle rect2 = Target.Bounds;
Point pts = PaintHelper.CenterPoint(rect1);
Point ptd = PaintHelper.CenterPoint(rect2);
rect1.Inflate(2, 2);
rect2.Inflate(2, 2);
if (StartCap != LineAnchor.None)
{
rect1.Inflate(Layouter.LineAnchorSize, Layouter.LineAnchorSize);
}
if (EndCap != LineAnchor.None)
{
rect2.Inflate(Layouter.LineAnchorSize, Layouter.LineAnchorSize);
}
if (pts == ptd)
{
cp1 = pts;
cp2 = ptd;
layout.Bounds = Rectangle.Empty;
layout.Region = null;
}
else
{
cp1 = BezierHelper.GetControlPoint(pts, controlPoint1);
cp2 = BezierHelper.GetControlPoint(ptd, controlPoint2);
//Point[] controlPoints = GetControlPoints(pts, ptd);
Shape sShape = Shape.GetShaper(From);
pts = sShape.GetBorderPoint(rect1, cp1);
Shape dShape = Shape.GetShaper(Target);
ptd = sShape.GetBorderPoint(rect2, cp2);
GraphicsPath gp = new GraphicsPath();
gp.AddBezier(pts, cp1, cp2, ptd);
Pen penWiden = new Pen(Color.Black, LineWidth + 5);
gp.Widen(penWiden);
var rect = gp.GetBounds();
rect.Inflate(LineWidth, LineWidth);
layout.Bounds = rect;
layout.Region = new Region(gp);
}
Point ptCenter = BezierHelper.GetPoint(pts, cp1, cp2, ptd, 0.5f);
Rectangle textBounds = layout.TextBounds;
textBounds.X = ptCenter.X - layout.TextBounds.Width / 2;
textBounds.Y = ptCenter.Y - layout.TextBounds.Height / 2;
// cache layout info
layout.StartBounds = rect1;
layout.EndBounds = rect2;
layout.StartPoint = pts;
layout.EndPoint = ptd;
layout.ControlPoint1 = cp1;
layout.ControlPoint2 = cp2;
layout.TextBounds = textBounds;
return(layout);
}
private void SetPoints(List <Vector2> controlPoints)
{
approxPoints = BezierHelper.GetBezierApproximation(controlPoints.ToArray(), 64);
}
public Vector3 GetPoint(float t)
{
return(transform.TransformPoint(BezierHelper.BezierValue(t, Points)));
}
public override void Animate()
{
transform.Position(
BezierHelper.Linear(EasingTime, Settings.From, Settings.To),
Settings.RelativeTo);
}
