/// <summary>
/// Called when this transform's parent changes.
/// </summary>
/// <param name="newParent">The new parent. May be null.</param>
private void SetParent(Transform newParent)
{
var oldParent = _parent;
if (oldParent != null)
{
oldParent._children.Remove(this);
oldParent.TransformChanged -= OnParentTransformChanged;
oldParent.PositionManuallyChanged -= OnParentPositionChanged;
oldParent.RotationManuallyChanged -= OnParentRotationChanged;
}
_parent = newParent;
if (newParent != null)
{
newParent._children.Add(this);
newParent.TransformChanged += OnParentTransformChanged;
newParent.PositionManuallyChanged += OnParentPositionChanged;
newParent.RotationManuallyChanged += OnParentRotationChanged;
}
ParentChanged?.Invoke(this, oldParent, _parent);
TransformChanged?.Invoke(this);
OnPositionChanged();
}
public void SetTransformInternal(float zoom, float xTranslation, float yTranslation)
{
bool transformChanged = false;
if (_zoom != zoom)
{
_zoom = zoom;
transformChanged = true;
}
if (_translation.X != xTranslation || _translation.Y != xTranslation)
{
_translation = new PointF(xTranslation, yTranslation);
transformChanged = true;
}
if (transformChanged)
{
UpdateMatrices();
TransformChanged.Raise(this, EventArgs.Empty);
if (AdaptedControl != null)
{
AdaptedControl.Invalidate();
}
}
}
private void Update()
{
if (lastPos != transform.position || lastRot != transform.rotation || lastScale != transform.localScale)
{
DoCacheTransformData();
TransformChanged?.Invoke();
}
}
/// <summary>
/// Translates the handles position over the Y axis
/// </summary>
public void TranslateY(float pTranslation)
{
Vector3 pos = transform.position;
pos.y += pTranslation;
transform.position = pos;
TransformChanged?.Invoke(this, new TransformChangedEventArgs(new Vector3(0, pTranslation, 0)));
}
public void UnityEvent_OnTransformChanged()
{
if (TransformChanged == null)
{
return;
}
TransformChanged.Invoke(transform);
}
/// <summary>
/// Used for updating the transform of a weapon
/// </summary>
/// <param name="slot">The weapon slot being manipulated</param>
/// <param name="vec">The new transform vector</param>
/// <param name="tc">Whether position or rotation are being updated</param>
public void UpdateWeaponTransform(int slot, Vector3 vec, TransformChanged tc)
{
if (tc == TransformChanged.position)
{
Stats_Weapons.Positions[slot] = vec;
}
else
{
Stats_Weapons.Rotations[slot] = vec;
}
}
/// <summary>
/// Sets the transform.
/// </summary>
/// <param name="newScale">The new scale.</param>
/// <param name="newOffset">The new offset.</param>
protected void SetTransform(double newScale, double newOffset)
{
// ReSharper disable CompareOfFloatsByEqualityOperator
if (newScale == Scale && newOffset == Offset)
{
return;
}
// ReSharper restore CompareOfFloatsByEqualityOperator
Scale = newScale;
Offset = newOffset;
TransformChanged?.Invoke(this, new EventArgs());
}
/// <summary>
/// Sets the transform to scale and translate. The scale is applied first, so that subscribers
/// to the TransformChanged event can change the translation constraint.</summary>
/// <param name="xScale">X scale</param>
/// <param name="yScale">Y scale</param>
/// <param name="xTranslation">X translation</param>
/// <param name="yTranslation">Y translation</param>
public void SetTransform(float xScale, float yScale, float xTranslation, float yTranslation)
{
if (m_settingTransform)
{
return;
}
try
{
m_settingTransform = true;
bool transformChanged = false;
float[] m = m_transform.Elements;
PointF scale = EnforceConstraints ? this.ConstrainScale(new PointF(xScale, yScale)) : new PointF(xScale, yScale);
if (m[0] != scale.X || m[3] != scale.Y)
{
m_transform = new Matrix(scale.X, 0, 0, scale.Y, m_transform.OffsetX, m_transform.OffsetY);
OnTransformChanged(EventArgs.Empty);
TransformChanged.Raise(this, EventArgs.Empty);
transformChanged = true;
}
PointF translation = EnforceConstraints ? this.ConstrainTranslation(new PointF(xTranslation, yTranslation)) : new PointF(xTranslation, yTranslation);
if (m[4] != translation.X || m[5] != translation.Y)
{
m_transform = new Matrix(scale.X, 0, 0, scale.Y, translation.X, translation.Y);
OnTransformChanged(EventArgs.Empty);
TransformChanged.Raise(this, EventArgs.Empty);
transformChanged = true;
}
if (transformChanged)
{
var d2dCtrl = AdaptedControl as D2dAdaptableControl;
if (d2dCtrl != null)
{
d2dCtrl.DrawD2d();
}
else if (AdaptedControl != null)
{
AdaptedControl.Invalidate();
}
}
}
finally
{
m_settingTransform = false;
}
}
private void OnPositionChanged()
{
PositionChanged?.Invoke(Position);
TransformChanged?.Invoke(this);
}
private void OnParentTransformChanged(Transform obj)
{
TransformChanged?.Invoke(this);
}
private void OnScalechanged()
{
ScaleChanged?.Invoke(Scale);
TransformChanged?.Invoke(this);
}
private void OnRotationChanged()
{
RotationChanged?.Invoke(Rotation);
TransformChanged?.Invoke(this);
}
private void UpdateTransitionedTransform(TransitionSpeed transitionSpeed)
{
_diagramSpaceToScreenSpaceTransform = CreateTransformToScreenSpace();
Transform = new TransitionedTransform(_diagramSpaceToScreenSpaceTransform, transitionSpeed);
TransformChanged?.Invoke(Transform);
}
private void RaiseTransformChanged()
{
TransformChanged?.Invoke(this, EventArgs.Empty);
}
