C++ PODVector::Back方法代码示例

void UIBatch::AddOrMerge(const UIBatch& batch, PODVector<UIBatch>& batches)
{
    if (batch.vertexEnd_ == batch.vertexStart_)
        return;
    
    if (!batches.Empty() && batches.Back().Merge(batch))
        return;
    
    batches.Push(batch);
}

// ----------------------------------------------------------------------------
bool IKSolver::BuildTreeToEffector(IKEffector* effector)
{
    /*
     * NOTE: This function makes the assumption that the node the effector is
     * attached to is -- without a doubt -- in our subtree (by using
     * ComponentIsInOurSubtree() first). If this is not the case, the program
     * will abort.
     */

    /*
     * we need to build tree up to the node where this effector was added. Do
     * this by following the chain of parent nodes until we hit a node that
     * exists in the solver's subtree. Then iterate backwards again and add each
     * missing node to the solver's tree.
     */
    const Node* iterNode = effector->GetNode();
    ik_node_t* ikNode;
    PODVector<const Node*> missingNodes;
    while ((ikNode = ik_node_find_child(solver_->tree, iterNode->GetID())) == nullptr)
    {
        missingNodes.Push(iterNode);
        iterNode = iterNode->GetParent();

        // Assert the assumptions made (described in the beginning of this function)
        assert(iterNode != nullptr);
        assert (iterNode->HasComponent<IKSolver>() == false || iterNode == node_);
    }

    while (missingNodes.Size() > 0)
    {
        iterNode = missingNodes.Back();
        missingNodes.Pop();

        ik_node_t* ikChildNode = CreateIKNodeFromUrhoNode(iterNode);
        ik_node_add_child(ikNode, ikChildNode);

        ikNode = ikChildNode;
    }

    return true;
}

// ----------------------------------------------------------------------------
void IKSolver::BuildTreeToEffector(const Node* node)
{
    // Check if the component that was added is an IK effector. If not, then it
    // does not concern us.
    IKEffector* effector = static_cast<IKEffector*>(node->GetComponent<IKEffector>());
    if (effector == NULL || effector->GetType() != IKEffector::GetTypeStatic())
        return;

    // May need to build tree up to the node where this effector was added. Do
    // this by following the chain of parent nodes until we hit a node that
    // exists in the solver's tree. Then iterate backwards again and add each
    // missing node to the solver's tree.
    PODVector<const Node*> missingNodes;
    const Node* iterNode = node;
    ik_node_t* ikNode = ik_node_find_child(solver_->tree, node->GetID());
    while (ikNode == NULL)
    {
        missingNodes.Push(iterNode);
        iterNode = iterNode->GetParent();
        ikNode = ik_node_find_child(solver_->tree, iterNode->GetID());
    }
    while (missingNodes.Size() > 0)
    {
        iterNode = missingNodes.Back();
        missingNodes.Pop();
        ik_node_t* ikChildNode = CreateIKNode(iterNode);
        ik_node_add_child(ikNode, ikChildNode);
        ikNode = ikChildNode;
    }

    // The tip of the tree is the effector. The solver library has ownership of
    // the effector object, but our IKEffector object also needs to know about
    // it.
    ik_effector_t* ikEffector = ik_effector_create();
    ik_node_attach_effector(ikNode, ikEffector); // ownership of effector
    effector->SetIKEffector(ikEffector);           // "weak" reference to effector
    effector->SetIKSolver(this);
    effectorList_.Push(effector);

    MarkSolverTreeDirty();
}