C++ TLeafList类代码示例

void RenderServer::PreviousCamera()
{
    TLeafList cameras;
    mActiveScene->GetChildrenOfClass("Camera", cameras, true);
    for (TLeafList::iterator iter = cameras.begin(); iter != cameras.end(); ++iter)
        if (*iter == mCamera)
        {
            mCamera = iter != cameras.begin() ? static_pointer_cast<Camera>(*(--iter)) : static_pointer_cast<Camera>(cameras.back());
            break;
        }
}

void
MaterialServer::ExportMaterial(boost::shared_ptr<Material> material)
{
    TLeafList exporters;
    ListChildrenSupportingClass<MaterialExporter>(exporters);

    for (TLeafList::const_iterator bi = exporters.begin(); bi != exporters.end(); ++bi)
    {
        boost::shared_ptr<MaterialExporter> mb = static_pointer_cast<MaterialExporter>(*bi);
        mb->RegisterMaterial(material);
    }
}

void RenderServer::NextCamera()
{
    TLeafList cameras;
    mActiveScene->GetChildrenOfClass("Camera", cameras, true);
    for (TLeafList::iterator iter = cameras.begin(); iter != cameras.end(); ++iter)
        if (*iter == mCamera)
        {
            ++iter;
            mCamera = iter != cameras.end() ? shared_static_cast<Camera>(*iter) : shared_static_cast<Camera>(cameras.front());
            break;
        }
}

void Leaf::GetChildren(const std::string &name, TLeafList &baseList, bool /*recursive*/)
{
    if (name.compare("..") == 0)
    {
        baseList.push_back(GetParent().lock());
    }

    if (name.compare(".") == 0)
    {
        baseList.push_back(static_pointer_cast<Leaf>(GetSelf().lock()));
    }
}

void
MaterialServer::ExportAllMaterial()
{
    GetLog()->Debug() << "(MaterialServer) ExportAllMaterial\n";
    TLeafList materials;
    ListChildrenSupportingClass<Material>(materials);

    for (TLeafList::const_iterator mi = materials.begin(); mi != materials.end(); ++mi)
    {
        boost::shared_ptr<Material> m = static_pointer_cast<Material>(*mi);
        ExportMaterial(m);
    }
    GetLog()->Debug() << "(MaterialServer) ExportAllMaterial done\n";
}

void SparkMonitor::DescribeScene(stringstream& ss, boost::shared_ptr<BaseNode> node)
{
    bool closeParen = DescribeNode(ss, node);

    TLeafList baseNodes = node->GetBaseNodeChildren();
    for (TLeafList::iterator i = baseNodes.begin(); i!= baseNodes.end(); ++i)
        {
            boost::shared_ptr<BaseNode> baseNode = dynamic_pointer_cast<BaseNode>(*i);
            DescribeScene(ss,baseNode);
        }
        
    if (closeParen)
        {
            ss << ")";
        }
}

void
RenderControl::RenderCustom()
{
    // get list of registered CustomMonitor objects
    TLeafList customList;
    ListChildrenSupportingClass<CustomRender>(customList);

    for (
         TLeafList::iterator iter = customList.begin();
         iter != customList.end();
         ++iter
         )
    {
        shared_static_cast<CustomRender>((*iter))->Render();
    }
}

void SparkMonitor::ParseMonitorMessage(const std::string& data)
{
    // pass the received string on to all installed CommandParsers
    TLeafList items;
    ListChildrenSupportingClass<MonitorCmdParser>(items);

    for (
         TLeafList::iterator iter = items.begin();
         iter != items.end();
         ++iter
         )
        {
            static_pointer_cast<MonitorCmdParser>(*iter)
                ->ParseMonitorMessage(data);
        }
}

void
RestrictedVisionPerceptor::SetupLines(TLineList& visibleLines)
{
  TLeafList lineList;
  mActiveScene->GetChildrenOfClass("Line", lineList, true);

  // determine position relative to the local reference frame
  const Matrix& mat = mTransformParent->GetWorldTransform();

  // get the transformation matrix describing the current orientation
  Vector3f myPos = mat.Pos();
  if (mAddNoise)
  {
    myPos -= mError;
  }


  for (TLeafList::iterator i = lineList.begin(); i != lineList.end(); ++i)
  {
    LineData ld;

    ld.mLine = static_pointer_cast<Line > (*i);

    if (ld.mLine.get() == 0)
    {
      GetLog()->Error() << "Error: (RestrictedVisionPerceptor) skipped line: "
        << (*i)->GetName() << "\n";
      continue; // this should never happen
    }

    boost::shared_ptr<Transform> j = ld.mLine->GetTransformParent();

    if (j.get() == 0)
    {
      GetLog()->Error() << "Error: (RestrictedVisionPerceptor) skipped line (2): "
        << (*i)->GetName() << "\n";
      continue; // this should never happen
    }

    const salt::Matrix& t = j->GetWorldTransform();
    ld.mBeginPoint.mRelPos =   mat.InverseRotate( t * ld.mLine->BeginPoint() - myPos );
    ld.mEndPoint.mRelPos = mat.InverseRotate( t * ld.mLine->EndPoint() - myPos );

    visibleLines.push_back(ld);
  }
}

void SparkMonitorLogFileServer::ParseCustomPredicates(sexp_t* sexp)
{
    // ( (name param1 param2 ...) (name param1 param2 ...) ... )
    if (sexp == 0)
        {
            return;
        }

    // get list of registered CustomMonitor objects
    TLeafList customList;
    ListChildrenSupportingClass<CustomMonitor>(customList);
    customList.push_back(GetCore()->Get("/sys/server/simulation/SparkMonitorClient/SoccerMonitor"));

    if (customList.empty())
        {
            return;
        }

    // parse predicates
    PredicateList pList;

    sexp = sexp->list;
    while (sexp != 0)
        {
            if (sexp->ty == SEXP_LIST)
                {
                    sexp_t* sPred = sexp->list;
                    ParseCustomPredicates(sPred,pList);
                }

            sexp = sexp->next;
        }

    // pass predicates to all registered CustomMonitor objects
    for (
         TLeafList::iterator iter = customList.begin();
         iter != customList.end();
         ++iter
         )
        {
            static_pointer_cast<CustomMonitor>((*iter))
                ->ParseCustomPredicates(pList);
        }
}

void SparkMonitorClient::ParseCustomPredicates(sexp_t* sexp)
{
    // ( (name param1 param2 ...) (name param1 param2 ...) ... )
    if (sexp == 0)
        {
            return;
        }

    // get list of registered CustomMonitor objects
    TLeafList customList;
    ListChildrenSupportingClass<CustomMonitor>(customList);

    if (customList.empty())
        {
            return;
        }

    // parse predicates
    PredicateList pList;

    sexp = sexp->list;
    while (sexp != 0)
        {
            if (sexp->ty == SEXP_LIST)
                {
                    sexp_t* sPred = sexp->list;
                    ParseCustomPredicates(sPred,pList);
                }

            sexp = sexp->next;
        }

    // pass predicates to all registered CustomMonitor objects
    for (
         TLeafList::iterator iter = customList.begin();
         iter != customList.end();
         ++iter
         )
        {
            shared_static_cast<CustomMonitor>((*iter))
                ->ParseCustomPredicates(pList);
        }
}

void Space::DestroySpaceObjects()
{
    boost::shared_ptr<Scene> scene = GetScene(); 

    if (scene.get() == 0)
        {
            return;
        }

    TLeafList objects;
    const bool recursive = true;
    scene->ListChildrenSupportingClass<PhysicsObject>(objects, recursive);

    bool globalSpace = IsGlobalSpace();
    shared_ptr<Space> self = shared_static_cast<Space>(GetSelf().lock());

    for (
         TLeafList::iterator iter = objects.begin();
         iter != objects.end();
         ++iter
         )
        {
            shared_ptr<PhysicsObject> object = shared_static_cast<PhysicsObject>(*iter);
            if (object == self)
            {
                continue;
            }

            // destroy objects registered to this space; the top level
            // space object also destroy any other ODE object
            const long parentSpace = object->GetParentSpaceID();
            if (
                (
                 (globalSpace) &&
                 (parentSpace == 0)
                 ) ||
                (parentSpace == mSpaceID)
                )
                {
                    object->DestroyPhysicsObject();
                }
        }
}

void
AgentAspect::UpdateEffectorMap()
{
    // build list of effectors, searching recursively
    TLeafList effectors;
    ListChildrenSupportingClass<Effector>(effectors,true);

    // build the effector map
    mEffectorMap.clear();

    for (
         TLeafList::iterator iter = effectors.begin();
         iter != effectors.end();
         ++iter
         )
        {
            boost::shared_ptr<Effector> effector = static_pointer_cast<Effector>(*iter);
            mEffectorMap[effector->GetPredicate()] = effector;
        }
}

void
GeometryServer::RegisterMesh(boost::shared_ptr<TriMesh> mesh)
{
    if (mesh.get() == 0)
    {
        GetLog()->Debug()
            << "(GeometryServer) RegisterMesh called with NULL mesh\n";
        return;
    }

    std::string name = mesh->GetName();
    if (name.empty())
    {
        GetLog()->Error()
            << "(GeometryServer) Cannot register a mesh without a name\n";
        return;
    }

    TMeshMap::const_iterator iter = mMeshMap.find(name);
    if (iter != mMeshMap.end())
    {
        GetLog()->Debug() << "(GeometryServer) replacing mesh " << name << "\n";
    }

    mMeshMap[name] = mesh;
    GetLog()->Debug() << "(GeometryServer) mesh " << name << " registered\n";

    TLeafList exporters;
    ListChildrenSupportingClass<MeshExporter>(exporters);

    for (TLeafList::const_iterator bi = exporters.begin(); bi != exporters.end(); ++bi)
    {
        GetLog()->Debug() << "(GeometryServer) additionally registered mesh "
                           << name << " via MeshExporter '" << (*bi)->GetName() << "'\n";
        boost::shared_ptr<MeshExporter> mb = static_pointer_cast<MeshExporter>(*bi);
        mb->RegisterMesh(mesh);
    }
}

shared_ptr<PredicateList>
AgentAspect::QueryPerceptors()
{
    mPerceptorCycle++;
    // build list of perceptors, searching recursively
    TLeafList perceptors;
    ListChildrenSupportingClass<Perceptor>(perceptors,true);

    shared_ptr<PredicateList> predList(new PredicateList());

    // query the perceptors for new data
    for (
         TLeafList::iterator iter = perceptors.begin();
         iter != perceptors.end();
         ++iter
         )
        {
            shared_ptr<Perceptor> pct = shared_static_cast<Perceptor>(*iter);
            if ( mPerceptorCycle % pct->GetInterval() == 0 )
                pct->Percept(predList);
        }

    return predList;
}