Java PPickPath.popTransform方法代码示例

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Return true if this node or any pickable descendants are picked. If a
 * pick occurs the pickPath is modified so that this node is always returned
 * as the picked node, event if it was a descendant node that initially
 * reported the pick.
 * 
 * @param pickPath the pick path to add the nodes to if they are picked
 * @return true if this node or one of its descendants was picked
 */
public boolean fullPick(final PPickPath pickPath) {
    if (super.fullPick(pickPath)) {
        PNode picked = pickPath.getPickedNode();

        // this code won't work with internal cameras, because it doesn't
        // pop the cameras view transform.
        while (picked != this) {
            pickPath.popTransform(picked.getTransformReference(false));
            pickPath.popNode(picked);
            picked = pickPath.getPickedNode();
        }

        return true;
    }
    return false;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Try to pick this node and all of its descendants if they are visible in
 * the clipping region.
 * 
 * @param pickPath the pick path to add the node to if its picked
 * @return true if this node or one of its descendants was picked.
 */
public boolean fullPick(final PPickPath pickPath) {
    if (getPickable() && fullIntersects(pickPath.getPickBounds())) {
        pickPath.pushNode(this);
        pickPath.pushTransform(getTransformReference(false));

        if (pick(pickPath)) {
            return true;
        }

        if (getChildrenPickable() && getPathReference().intersects(pickPath.getPickBounds())) {
            final int count = getChildrenCount();
            for (int i = count - 1; i >= 0; i--) {
                final PNode each = getChild(i);
                if (each.fullPick(pickPath)) {
                    return true;
                }
            }
        }

        if (pickAfterChildren(pickPath)) {
            return true;
        }

        pickPath.popTransform(getTransformReference(false));
        pickPath.popNode(this);
    }

    return false;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Traverse the pick path determining which parent nodes are occluded by
 * their children nodes. Note that this is only detecting a subset of
 * occlusions (parent, child), others such as overlapping siblings or
 * cousins are not detected.
 * 
 * @param node node from which to detect occlusions
 * @param pickPath Pick Path to traverse
 */
public void detectOcclusions(final PNode node, final PPickPath pickPath) {
    if (!node.fullIntersects(pickPath.getPickBounds())) {
        return;
    }

    pickPath.pushTransform(node.getTransformReference(false));

    final int count = node.getChildrenCount();
    for (int i = count - 1; i >= 0; i--) {
        final PNode each = node.getChild(i);
        if (node.getOccluded()) {
            // if n has been occluded by a previous descendant then
            // this child must also be occluded
            each.setOccluded(true);
        }
        else {
            // see if child each occludes n
            detectOcclusions(each, pickPath);
        }
    }

    if (nodeOccludesParents(node, pickPath)) {
        final PNode parent = node.getParent();
        while (parent != null && !parent.getOccluded()) {
            parent.setOccluded(true);
        }
    }

    pickPath.popTransform(node.getTransformReference(false));
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * <p>
 * After the direct children of this camera have been given a chance to be
 * picked all of the layers in the list of layers viewed by this camera are
 * given a chance to be picked.
 * </p>
 * 
 * @return true if any of the layers in the list of layers viewed by this
 *    camera were picked
 */
protected boolean pickAfterChildren(final PPickPath pickPath) {
    if (intersects(pickPath.getPickBounds())) {
        pickPath.pushTransform(viewTransform);

        if (pickCameraView(pickPath)) {
            return true;
        }

        pickPath.popTransform(viewTransform);
        return true;
    }
    return false;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Try to pick this node and all of its descendants. Most subclasses should
 * not need to override this method. Instead they should override
 * <code>pick</code> or <code>pickAfterChildren</code>.
 * 
 * @param pickPath the pick path to add the node to if its picked
 * @return true if this node or one of its descendants was picked.
 */
public boolean fullPick(final PPickPath pickPath) {
    if (getVisible() && (getPickable() || getChildrenPickable()) && fullIntersects(pickPath.getPickBounds())) {
        pickPath.pushNode(this);
        pickPath.pushTransform(transform);

        final boolean thisPickable = getPickable() && pickPath.acceptsNode(this);

        if (thisPickable && pick(pickPath)) {
            return true;
        }

        if (getChildrenPickable()) {
            final int count = getChildrenCount();
            for (int i = count - 1; i >= 0; i--) {
                final PNode each = (PNode) children.get(i);
                if (each.fullPick(pickPath)) {
                    return true;
                }
            }
        }

        if (thisPickable && pickAfterChildren(pickPath)) {
            return true;
        }

        pickPath.popTransform(transform);
        pickPath.popNode(this);
    }

    return false;
}