public Object Clone()
{
PMatrix r = new PMatrix();
r.Multiply(this);
return(r);
}
/// <summary>
/// Pushes the given matrix onto the matrix stack.
/// </summary>
/// <param name="aMatrix">The matrix to push.</param>
public virtual void PushMatrix(PMatrix aMatrix) {
matrixStack.Push(new PTuple(PickedNode, aMatrix));
if (aMatrix != null) {
RectangleF newPickBounds = aMatrix.InverseTransform(PickBounds);
pickBoundsStack.Push(newPickBounds);
}
}
/// <summary>
/// Pops a matrix from the transform stack.
/// </summary>
/// <param name="matrix">The matrix to pop.</param>
/// <remarks>This method also pops a clip from the local clip stack.</remarks>
public virtual void PopTransform(PMatrix matrix)
{
if (matrix == null)
{
return;
}
graphics.Matrix = (PMatrix)transformStack.Pop();
localClipStack.Pop();
}
public override bool Equals(object obj)
{
PMatrix otherMatrix = (PMatrix)obj;
return(offsetX == otherMatrix.offsetX &&
offsetY == otherMatrix.offsetY &&
//scale == otherMatrix.scale);
scaleX == otherMatrix.scaleX &&
scaleY == otherMatrix.scaleY);
}
public void Multiply(PMatrix aTransform)
{
ScaleBy(aTransform.scaleX, aTransform.scaleY);
offsetX = aTransform.scaleX * offsetX + aTransform.OffsetX;
offsetY = aTransform.scaleY * offsetY + aTransform.OffsetY;
//ScaleBy(aTransform.scale);
//offsetX = aTransform.scale * offsetX + aTransform.OffsetX;
//offsetY = aTransform.scale * offsetY + aTransform.OffsetY;
}
/// <summary>
/// Pushes the given matrix onto the transform stack.
/// </summary>
/// <param name="matrix">The matrix to push.</param>
/// <remarks>
/// This method also applies the matrix to the graphics context and the current local clip.
/// The new local clip is then pushed onto the local clip stack.
/// </remarks>
public virtual void PushTransform(PMatrix matrix)
{
if (matrix == null)
{
return;
}
RectangleF newLocalClip = matrix.InverseTransform(LocalClip);
transformStack.Push(graphics.Matrix);
localClipStack.Push(newLocalClip);
graphics.MultiplyTransform(matrix);
}
/// <summary>
/// Returns the product of the matrices from the top-most ancestor node (the last node
/// in the list) to the given node.
/// </summary>
/// <param name="nodeOnPath">
/// The bottom-most node in the path for which the matrix product will be computed.
/// </param>
/// <returns>
/// The product of the matrices from the top-most node to the given node.
/// </returns>
public virtual PMatrix GetPathTransformTo(PNode nodeOnPath) {
PMatrix aMatrix = new PMatrix();
object[] matrices = matrixStack.ToArray();
int count = matrices.Length;
for (int i = count - 1; i >= 0; i--) {
PTuple each = (PTuple) matrices[i];
if (each.matrix != null) aMatrix.Multiply(each.matrix);
if (nodeOnPath == each.node) {
return aMatrix;
}
}
return aMatrix;
}
/// <summary>
/// Animate this node's matrix from its current values when the activity
/// starts to the new values specified in the given matrix.
/// </summary>
/// <param name="destMatrix">The final matrix value.</param>
/// <param name="duration">The amount of time that the animation should take.</param>
/// <returns>The newly scheduled activity</returns>
/// <remarks>
/// If this node descends from the root then the activity will be scheduled,
/// else the returned activity should be scheduled manually. If two different
/// transform activities are scheduled for the same node at the same time,
/// they will both be applied to the node, but the last one scheduled will be
/// applied last on each frame, so it will appear to have replaced the
/// original. Generally you will not want to do that.
/// </remarks>
public virtual PTransformActivity AnimateToMatrix(PMatrix destMatrix, long duration)
{
PTransformActivity.Target t = new PNodeTransformTarget(this);
PTransformActivity ta = new PTransformActivity(duration, PUtil.DEFAULT_ACTIVITY_STEP_RATE, t, destMatrix);
AddActivity(ta);
return ta;
}
public Object Clone()
{
PMatrix r = new PMatrix();
r.Multiply(this);
return r;
}
/// <summary>
/// Animate the camera's view matrix from its current value when the activity
/// starts to the new destination matrix value.
/// </summary>
/// <param name="aCamera">The camera whose view matrix will be animated.</param>
/// <param name="aMatrix">The final matrix value.</param>
/// <param name="duration">
/// The amount of time that the animation should take.
/// </param>
/// <returns>
/// The newly scheduled activity, if the duration is greater than 0; else null.
/// </returns>
protected virtual PActivity AnimateCameraViewMatrixTo(PCamera aCamera, PMatrix aMatrix, int duration)
{
bool wasOldAnimation = false;
// first stop any old animations.
if (navigationActivity != null) {
navigationActivity.Terminate();
wasOldAnimation = true;
}
if (duration == 0) {
aCamera.ViewMatrix = aMatrix;
return null;
}
PMatrix source = aCamera.ViewMatrixReference;
//if (!source.MatrixReference.Equals(aMatrix.MatrixReference)) {
if (!source.Equals(aMatrix)) {
navigationActivity = aCamera.AnimateViewToMatrix(aMatrix, duration);
((PTransformActivity)navigationActivity).SlowInSlowOut = !wasOldAnimation;
return navigationActivity;
}
return null;
}
/// <summary>
/// Overridden. See <see cref="PInterpolatingActivity.OnActivityStarted">
/// PInterpolatingActivity.OnActivityStarted</see>.
/// </summary>
protected override void OnActivityStarted()
{
//if (FirstLoop) source = target.GetMatrix().MatrixReference.Elements;
if (FirstLoop) source = (PMatrix)target.Matrix.Clone(); //.MatrixReference.Elements;
base.OnActivityStarted();
}
public void Multiply(PMatrix aTransform)
{
ScaleBy(aTransform.scaleX, aTransform.scaleY);
offsetX = aTransform.scaleX * offsetX + aTransform.OffsetX;
offsetY = aTransform.scaleY * offsetY + aTransform.OffsetY;
//ScaleBy(aTransform.scale);
//offsetX = aTransform.scale * offsetX + aTransform.OffsetX;
//offsetY = aTransform.scale * offsetY + aTransform.OffsetY;
}
/// <summary>
/// Constructs a new PTransformActivity that animate between the source and destination
/// matrices in the order specified by the mode, looping the given number of iterations.
/// </summary>
/// <param name="duration">The length of one loop of the activity.</param>
/// <param name="stepInterval">
/// The minimum number of milliseconds that this activity should delay between steps.
/// </param>
/// <param name="loopCount">
/// The number of times the activity should reschedule itself.
/// </param>
/// <param name="mode">
/// Defines how the activity interpolates between states.
/// </param>
/// <param name="aTarget">
/// The object that the activity will be applied to and where the source
/// state will be taken from.
/// </param>
/// <param name="aDestination">The destination matrix.</param>
public PTransformActivity(long duration, long stepInterval, int loopCount, ActivityMode mode, Target aTarget, PMatrix aDestination)
: base(duration, stepInterval, loopCount, mode)
{
//source = new float[6];
//destination = new float[6];
target = aTarget;
//if (aDestination != null) {
// destination = aDestination.MatrixReference.Elements;
//}
source = new PMatrix();
destination = new PMatrix();
destination.Multiply(aDestination);
}
/// <summary>
/// Gets a string representation of the elements of a matrix.
/// </summary>
/// <param name="elements">The elements of a matrix.</param>
/// <returns>A string representation of the elements of a matrix.</returns>
protected static String GetElementString(PMatrix elements)
{
return (elements.OffsetX + " " + elements.OffsetY + " " + elements.Scale);
/*
StringBuilder result = new StringBuilder();
int length = elements.Length;
for (int i = 0; i < elements.Length; i++) {
result.Append(elements[i].ToString());
if (i < length-1) result.Append(", ");
}
return result.ToString();
*/
}
public Graphics2D(Graphics graphics)
{
this.graphics = graphics;
matrix = new PMatrix();
}
/// <summary>
/// Constructs a new PTransformActivity that will animate from the source matrix
/// to the destination matrix.
/// </summary>
/// <param name="duration">The length of one loop of the activity.</param>
/// <param name="stepInterval">
/// The minimum number of milliseconds that this activity should delay between
/// steps.
/// </param>
/// <param name="aTarget">
/// The object that the activity will be applied to and where the source
/// state will be taken from.
/// </param>
/// <param name="aDestination">The destination matrix.</param>
public PTransformActivity(long duration, long stepInterval, Target aTarget, PMatrix aDestination)
: this(duration, stepInterval, 1, ActivityMode.SourceToDestination, aTarget, aDestination)
{
}
/// <summary>
/// Constructs a new camera with no layers and a default white color.
/// </summary>
public PCamera()
: base()
{
viewMatrix = new PMatrix();
layers = new PLayerList();
viewConstraint = CameraViewConstraint.None;
Brush = new SolidBrush(Color.White);
}
/// <summary>
/// Pops a matrix from the transform stack.
/// </summary>
/// <param name="matrix">The matrix to pop.</param>
/// <remarks>This method also pops a clip from the local clip stack.</remarks>
public virtual void PopTransform(PMatrix matrix)
{
if (matrix == null) return;
graphics.Matrix = (PMatrix) transformStack.Pop();
localClipStack.Pop();
}
/// <summary>
/// Constructs a new PNode.
/// </summary>
/// <Remarks>
/// By default a node's brush is null, and bounds are empty. These values
/// must be set for the node to show up on the screen once it's added to
/// a scene graph.
/// </Remarks>
public PNode()
{
bounds = RectangleF.Empty;
fullBoundsCache = RectangleF.Empty;
//transparency = 1.0f;
pickable = true;
childrenPickable = true;
matrix = new PMatrix();
handlers = new EventHandlerList();
Visible = true;
}
/// <summary>
/// Pops a matrix from the matrix stack.
/// </summary>
/// <param name="aMatrix">The matrix to pop.</param>
public virtual void PopMatrix(PMatrix aMatrix) {
matrixStack.Pop();
if (aMatrix != null) {
pickBoundsStack.Pop();
}
}
/// <summary>
/// Pushes the given matrix onto the transform stack.
/// </summary>
/// <param name="matrix">The matrix to push.</param>
/// <remarks>
/// This method also applies the matrix to the graphics context and the current local clip.
/// The new local clip is then pushed onto the local clip stack.
/// </remarks>
public virtual void PushTransform(PMatrix matrix)
{
if (matrix == null) return;
RectangleF newLocalClip = matrix.InverseTransform(LocalClip);
transformStack.Push(graphics.Matrix);
localClipStack.Push(newLocalClip);
graphics.MultiplyTransform(matrix);
}
public virtual void MultiplyTransform(PMatrix matrix)
{
TranslateTransform(matrix.OffsetX, matrix.OffsetY);
ScaleTransform(matrix.Scale);
}
public Graphics2D(Graphics graphics)
{
this.graphics = graphics;
matrix = new PMatrix();
}
/// <summary>
/// Transform this node's matrix by the given matrix.
/// </summary>
/// <param name="matrix">The transform to apply.</param>
public virtual void TransformBy(PMatrix matrix)
{
this.matrix.Multiply(matrix);
InvalidatePaint();
InvalidateFullBounds();
FirePropertyChangedEvent(transformEventKey, null, matrix);
}
/// <summary>
/// Creates a new PTuple that associates the given node witht he given matrix.
/// </summary>
/// <param name="n">The node to associate with the matrix.</param>
/// <param name="m">The matrix to associate with the node.</param>
public PTuple(PNode n, PMatrix m) {
node = n;
matrix = m;
}
/// <summary>
/// Animate the camera's view matrix from its current value when the activity starts
/// to the new destination matrix value.
/// </summary>
/// <param name="destination">The final matrix value.</param>
/// <param name="duration">The amount of time that the animation should take.</param>
/// <returns>
/// The newly scheduled activity, if the duration is greater than 0; else null.
/// </returns>
public virtual PTransformActivity AnimateViewToMatrix(PMatrix destination, long duration)
{
if (duration == 0) {
ViewMatrix = destination;
return null;
}
PTransformActivity ta = new PTransformActivity(duration, PUtil.DEFAULT_ACTIVITY_STEP_RATE, new PCameraTransformTarget(this), destination);
PRoot r = Root;
if (r != null) {
r.AddActivity(ta);
}
return ta;
}
public virtual void MultiplyTransform(PMatrix matrix)
{
TranslateTransform(matrix.OffsetX, matrix.OffsetY);
ScaleTransform(matrix.Scale);
}
