path: root/src/demos/xtrans/XTBasicTransitionManager.java

package demos.xtrans;

import java.awt.*;
import java.awt.geom.*;
import java.util.*;
import gleem.linalg.*;

/** A basic transition manager supporting animated scrolling, rotating
    and fading of components. */

public class XTBasicTransitionManager implements XTTransitionManager {
  /** Indicates the style of the transition (either no motion,
      scrolling, or rotating). */
  public static class Style {
    private Style() {}
  }

  /** Indicates the component has no motion (scrolling or rotation) in
      its animation. */
  public static Style STYLE_NO_MOTION = new Style();

  /** Indicates the component is to be scrolled in to or out of
      place. */
  public static Style STYLE_SCROLL    = new Style();

  /** Indicates the component is to be rotated in to or out of
      place. */
  public static Style STYLE_ROTATE    = new Style();

  /** Indicates the direction of the transition if it contains any
      motion (either up, down, left, or right). */
  public static class Direction {
    private Direction() {}
  }

  /** Indicates the component's animation is from or toward the left,
      depending on whether the transition is an "in" or "out"
      transition. */
  public static Direction DIR_LEFT  = new Direction();

  /** Indicates the component's animation is from or toward the right,
      depending on whether the transition is an "in" or "out"
      transition. */
  public static Direction DIR_RIGHT = new Direction();

  /** Indicates the component's animation is in the upward
      direction. */
  public static Direction DIR_UP    = new Direction();

  /** Indicates the component's animation is in the downward
      direction. */
  public static Direction DIR_DOWN  = new Direction();

  private Style     nextTransitionStyle;
  private Direction nextTransitionDirection;
  private boolean   nextTransitionFade;

  private Random random;

  /** Sets the next transition to be used by this transition manager
      for either an "in" or an "out" transition. By default the
      transition manager selects random transitions from those
      available. */
  public void setNextTransition(Style style,
                                Direction direction,
                                boolean fade) {
    if (style == null) {
      throw new IllegalArgumentException("Must supply a style");
    }
    nextTransitionStyle     = style;
    nextTransitionDirection = direction;
    nextTransitionFade      = fade;
  }

  /** Creates an XTBasicTransition for the given component. By default
      this transition manager chooses a random transition from those
      available if one is not specified via {@link #setNextTransition
      setNextTransition}. */
  public XTTransition createTransitionForComponent(Component c,
                                                   boolean isAddition,
                                                   Rectangle   oglViewportOfDesktop,
                                                   Point       viewportOffsetFromOrigin,
                                                   Rectangle2D oglTexCoordsOnBackBuffer) {
    if (nextTransitionStyle == null) {
      chooseRandomTransition();
    }

    // Figure out the final positions of everything
    // Keep in mind that the Java2D origin is at the upper left and
    // the OpenGL origin is at the lower left
    Rectangle bounds = c.getBounds();
    int x = bounds.x;
    int y = bounds.y;
    int w = bounds.width;
    int h = bounds.height;
    float tx = (float) oglTexCoordsOnBackBuffer.getX();
    float ty = (float) oglTexCoordsOnBackBuffer.getY();
    float tw = (float) oglTexCoordsOnBackBuffer.getWidth();
    float th = (float) oglTexCoordsOnBackBuffer.getHeight();
    float vx = oglViewportOfDesktop.x;
    float vy = oglViewportOfDesktop.y;
    float vw = oglViewportOfDesktop.width;
    float vh = oglViewportOfDesktop.height;
    Quad3f verts = new Quad3f(new Vec3f(0,  0, 0),
                              new Vec3f(0, -h, 0),
                              new Vec3f(w, -h, 0),
                              new Vec3f(w,  0, 0));
    Quad2f texcoords = new Quad2f(new Vec2f(tx,      ty + th),
                                  new Vec2f(tx,      ty),
                                  new Vec2f(tx + tw, ty),
                                  new Vec2f(tx + tw, ty + th));

    XTBasicTransition trans = new XTBasicTransition();

    Vec3f translation = new Vec3f(x - viewportOffsetFromOrigin.x,
                                  vh - y - viewportOffsetFromOrigin.y,
                                  0);
    InterpolatedVec3f transInterp = new InterpolatedVec3f();
    transInterp.setStart(translation);
    transInterp.setEnd(translation);

    InterpolatedQuad3f quadInterp = new InterpolatedQuad3f();
    quadInterp.setStart(verts);
    quadInterp.setEnd(verts);

    InterpolatedQuad2f texInterp = new InterpolatedQuad2f();
    texInterp.setStart(texcoords);
    texInterp.setEnd(texcoords);

    trans.setTranslation(transInterp);
    trans.setVertices(quadInterp);
    trans.setTexCoords(texInterp);

    // Now decide how we are going to handle this transition
    Style     transitionStyle     = nextTransitionStyle;
    Direction transitionDirection = nextTransitionDirection;
    boolean   fade                = nextTransitionFade;
    nextTransitionStyle = null;
    nextTransitionDirection = null;
    nextTransitionFade = false;

    int[] vtIdxs = null;
    int[] ttIdxs = null;
    Vec3f rotAxis = null;
    Vec3f pivot = null;
    float startAngle = 0;
    float endAngle = 0;

    if (fade) {
      InterpolatedFloat alpha = new InterpolatedFloat();
      float start = (isAddition ? 0.0f : 1.0f);
      float end   = (isAddition ? 1.0f : 0.0f);
      alpha.setStart(start);
      alpha.setEnd(end);
      trans.setAlpha(alpha);
    }

    if (transitionDirection != null) {
      if (transitionStyle == STYLE_SCROLL) {
        if (transitionDirection == DIR_LEFT) {
          vtIdxs = new int[] { 3, 2, 2, 3 };
          ttIdxs = new int[] { 0, 1, 1, 0 };
        } else if (transitionDirection == DIR_RIGHT) {
          vtIdxs = new int[] { 0, 1, 1, 0 };
          ttIdxs = new int[] { 3, 2, 2, 3 };
        } else if (transitionDirection == DIR_UP) {
          vtIdxs = new int[] { 1, 1, 2, 2 };
          ttIdxs = new int[] { 0, 0, 3, 3 };
        } else {
          // DIR_DOWN
          vtIdxs = new int[] { 0, 0, 3, 3 };
          ttIdxs = new int[] { 1, 1, 2, 2 };
        }
      } else if (transitionStyle == STYLE_ROTATE) {
        if (transitionDirection == DIR_LEFT) {
          rotAxis = new Vec3f(0, 1, 0);
          pivot = new Vec3f();
          startAngle = -90;
          endAngle = 0;
        } else if (transitionDirection == DIR_RIGHT) {
          rotAxis = new Vec3f(0, 1, 0);
          pivot = new Vec3f(w, 0, 0);
          startAngle = 90;
          endAngle = 0;
        } else if (transitionDirection == DIR_UP) {
          rotAxis = new Vec3f(1, 0, 0);
          pivot = new Vec3f(0, -h, 0);
          startAngle = 90;
          endAngle = 0;
        } else {
          // DIR_DOWN
          rotAxis = new Vec3f(1, 0, 0);
          pivot = new Vec3f();
          startAngle = -90;
          endAngle = 0;
        }
      }
    }


    /*
    switch (transitionType) {
      case FADE:
      {
        InterpolatedFloat alpha = new InterpolatedFloat();
        float start = (isAddition ? 0.0f : 1.0f);
        float end   = (isAddition ? 1.0f : 0.0f);
        alpha.setStart(start);
        alpha.setEnd(end);
        trans.setAlpha(alpha);
        break;
      }
      case SCROLL_LEFT:
      {
        vtIdxs = new int[] { 3, 2, 2, 3 };
        ttIdxs = new int[] { 0, 1, 1, 0 };
        break;
      }
      case SCROLL_RIGHT:
      {
        vtIdxs = new int[] { 0, 1, 1, 0 };
        ttIdxs = new int[] { 3, 2, 2, 3 };
        break;
      }
      case SCROLL_UP:
      {
        vtIdxs = new int[] { 1, 1, 2, 2 };
        ttIdxs = new int[] { 0, 0, 3, 3 };
        break;
      }
      case SCROLL_DOWN:
      {
        vtIdxs = new int[] { 0, 0, 3, 3 };
        ttIdxs = new int[] { 1, 1, 2, 2 };
        break;
      }
      case ROTATE_LEFT:
      {
        rotAxis = new Vec3f(0, 1, 0);
        pivot = new Vec3f();
        startAngle = -90;
        endAngle = 0;
        break;
      }
      case ROTATE_RIGHT:
      {
        rotAxis = new Vec3f(0, 1, 0);
        //        pivot = translation.plus(new Vec3f(w, 0, 0));
        pivot = new Vec3f(w, 0, 0);
        startAngle = 90;
        endAngle = 0;
        break;
      }
      case ROTATE_UP:
      {
        rotAxis = new Vec3f(1, 0, 0);
        //        pivot = translation.plus(new Vec3f(0, -h, 0));
        pivot = new Vec3f(0, -h, 0);
        startAngle = 90;
        endAngle = 0;
        break;
      }
      case ROTATE_DOWN:
      {
        rotAxis = new Vec3f(1, 0, 0);
        pivot = new Vec3f();
        startAngle = -90;
        endAngle = 0;
        break;
      }
    }

    */

    if (vtIdxs != null) {
      if (isAddition) {
        quadInterp.setStart(new Quad3f(verts.getVec(vtIdxs[0]),
                                       verts.getVec(vtIdxs[1]),
                                       verts.getVec(vtIdxs[2]),
                                       verts.getVec(vtIdxs[3])));
        texInterp.setStart(new Quad2f(texcoords.getVec(ttIdxs[0]),
                                      texcoords.getVec(ttIdxs[1]),
                                      texcoords.getVec(ttIdxs[2]),
                                      texcoords.getVec(ttIdxs[3])));
      } else {
        // Note: swapping the vertex and texture indices happens to
        // have the correct effect
        int[] tmp = vtIdxs;
        vtIdxs = ttIdxs;
        ttIdxs = tmp;

        quadInterp.setEnd(new Quad3f(verts.getVec(vtIdxs[0]),
                                     verts.getVec(vtIdxs[1]),
                                     verts.getVec(vtIdxs[2]),
                                     verts.getVec(vtIdxs[3])));
        texInterp.setEnd(new Quad2f(texcoords.getVec(ttIdxs[0]),
                                    texcoords.getVec(ttIdxs[1]),
                                    texcoords.getVec(ttIdxs[2]),
                                    texcoords.getVec(ttIdxs[3])));
      }
    } else if (rotAxis != null) {
      if (!isAddition) {
        float tmp = endAngle;
        endAngle = -startAngle;
        startAngle = tmp;
      }

      trans.setPivotPoint(pivot);
      trans.setRotationAxis(rotAxis);
      InterpolatedFloat rotInterp = new InterpolatedFloat();
      rotInterp.setStart(startAngle);
      rotInterp.setEnd(endAngle);
      trans.setRotationAngle(rotInterp);
    }

    return trans;
  }

  /** Chooses a random transition from those available. */
  protected void chooseRandomTransition() {
    if (random == null) {
      random = new Random();
    }
    nextTransitionFade = random.nextBoolean();
    nextTransitionStyle = null;
    do {
      int style = random.nextInt(3);
      switch (style) {
        // Make no-motion transitions always use fades for effect
        // without biasing transitions toward no-motion transitions
        case 0:   if (nextTransitionFade) nextTransitionStyle = STYLE_NO_MOTION; break;
        case 1:   nextTransitionStyle = STYLE_SCROLL;                            break;
        default:  nextTransitionStyle = STYLE_ROTATE;                            break;
      }
    } while (nextTransitionStyle == null);
    int dir = random.nextInt(4);
    switch (dir) {
      case 0:   nextTransitionDirection = DIR_LEFT;  break;
      case 1:   nextTransitionDirection = DIR_RIGHT; break;
      case 2:   nextTransitionDirection = DIR_UP;    break;
      default:  nextTransitionDirection = DIR_DOWN;  break;
    }
  }
}