Exemplo n.º 1
0
  private void updateTransform() {
    Matrix3 temp = worldTransform;

    float originX = getOriginX();
    float originY = getOriginY();
    float rotation = getRotation();
    float scaleX = getScaleX();
    float scaleY = getScaleY();

    if (originX != 0 || originY != 0) localTransform.setToTranslation(originX, originY);
    else localTransform.idt();
    if (rotation != 0) localTransform.mul(temp.setToRotation(rotation));
    if (scaleX != 1 || scaleY != 1) localTransform.mul(temp.setToScaling(scaleX, scaleY));
    if (originX != 0 || originY != 0) localTransform.mul(temp.setToTranslation(-originX, -originY));
    localTransform.trn(getX(), getY());

    // Find the first parent that transforms.
    Group parentGroup = getParent();
    while (parentGroup != null) {
      if (parentGroup.transform) break;
      parentGroup = parentGroup.getParent();
    }

    if (parentGroup != null) {
      worldTransform.set(parentGroup.worldTransform);
      worldTransform.mul(localTransform);
    } else {
      worldTransform.set(localTransform);
    }

    batchTransform.set(worldTransform);
  }
Exemplo n.º 2
0
  /**
   * Sets this actor as the event {@link Event#setTarget(Actor) target} and propagates the event to
   * this actor and ancestor actors as necessary. If this actor is not in the stage, the stage must
   * be set before calling this method.
   *
   * <p>Events are fired in 2 phases. The first phase notifies listeners on each actor starting at
   * the root and propagating downward to (and including) this actor. The second phase notifes
   * listeners on each actor starting at this actor and, if {@link Event#getBubbles()} is true,
   * propagating upward to the root. If the event is {@link Event#stop() stopped} at any time, it
   * will not propagate to the next actor.
   *
   * @return true of the event was {@link Event#cancel() cancelled}.
   */
  public boolean fire(Event event) {
    if (event.getStage() == null) event.setStage(getStage());
    event.setTarget(this);

    // Collect ancestors so event propagation is unaffected by hierarchy changes.
    Array<Group> ancestors = Pools.obtain(Array.class);
    Group parent = getParent();
    while (parent != null) {
      ancestors.add(parent);
      parent = parent.getParent();
    }

    try {
      // Notify all parent capture listeners, starting at the root. Ancestors may stop an event
      // before children receive it.
      for (int i = ancestors.size - 1; i >= 0; i--) {
        Group currentTarget = ancestors.get(i);
        currentTarget.notify(event, true);
        if (event.isStopped()) return event.isCancelled();
      }

      // Notify the target capture listeners.
      notify(event, true);
      if (event.isStopped()) return event.isCancelled();

      // Notify the target listeners.
      notify(event, false);
      if (!event.getBubbles()) return event.isCancelled();
      if (event.isStopped()) return event.isCancelled();

      // Notify all parent listeners, starting at the target. Children may stop an event before
      // ancestors receive it.
      for (int i = 0, n = ancestors.size; i < n; i++) {
        ancestors.get(i).notify(event, false);
        if (event.isStopped()) return event.isCancelled();
      }

      return event.isCancelled();
    } finally {
      ancestors.clear();
      Pools.free(ancestors);
    }
  }
Exemplo n.º 3
0
  @Override
  public void act(float delta) {

    // coordinate fix
    // TODO to STAGE COORDS for relativ coords

    float relativeX = getX();
    float relativeY = getY();
    float relativeRotation = 0;

    Group currParent = this.getParent();
    while (currParent != null) {
      relativeX += currParent.getX();
      relativeY += currParent.getY();
      relativeRotation += currParent.getRotation();
      currParent = currParent.getParent();
    }

    if (lightObject != null) {

      float yy = 0;
      float xx = 0;

      if (relativeRotation != 0) {
        xx =
            getX() * MathUtils.cosDeg(relativeRotation)
                - getY() * MathUtils.sinDeg(relativeRotation);
        yy =
            getY() * MathUtils.cosDeg(relativeRotation)
                + getX() * MathUtils.sinDeg(relativeRotation);
        yy = getY() - yy;
        xx = getX() - xx;
      }
      lightObject.setPosition(relativeX - xx, relativeY - yy);
    }
    if (dataVO.type == LightType.CONE) {
      lightObject.setDirection(direction + relativeRotation);
    }
    // debugImg.setX(relativeX);
    // debugImg.setY(relativeY);
    super.act(delta);
  }