C++ csArray类代码示例

void pawsSummaryWindow::SetVerify( csArray<psCharVerificationMesg::Attribute> stats,
                                   csArray<psCharVerificationMesg::Attribute> skills )
{
    statsList->Clear();
    skillsList->Clear();
    
    for ( size_t x = 0; x < skills.GetSize(); x++ )
    {       
        if (skills[x].value)
        {
            pawsListBoxRow* row = skillsList->NewRow();
            pawsTextBox* name = (pawsTextBox*)row->GetColumn(0);
            name->SetText( skills[x].name );

            pawsTextBox* val = (pawsTextBox*)row->GetColumn(1);
            val->FormatText( "%d", skills[x].value );
        }
    }
    
    for ( size_t x = 0; x < stats.GetSize(); x++ )
    {       
        if (stats[x].value)
        {
            pawsListBoxRow* row = statsList->NewRow();
            pawsTextBox* name = (pawsTextBox*)row->GetColumn(0);
            name->SetText( stats[x].name );
                       
            pawsTextBox* val = (pawsTextBox*)row->GetColumn(1);
            val->FormatText( "%d", stats[x].value );
        }
    }
     
    serverStatus->SetText(PawsManager::GetSingleton().Translate("Verification complete"));     
}

bool PawsManager::LoadChildWidgets( const char* widgetFile, csArray<pawsWidget *> &loadedWidgets )
{
    bool errors=false;
    loadedWidgets.DeleteAll();
    csString fullPath = localization->FindLocalizedFile(widgetFile);

    csRef<iDocumentNode> topNode = ParseWidgetFile( fullPath );
    if (!topNode) return false;
    csRef<iDocumentNodeIterator> iter = topNode->GetNodes();

    while ( iter->HasNext() )
    {
        csRef<iDocumentNode> node = iter->Next();

        if ( node->GetType() != CS_NODE_ELEMENT )
            continue;

        // This is a widget so read it's factory to create it.
        pawsWidget * widget = LoadWidget(node);
        if (widget)
            loadedWidgets.Push(widget);
        else
            errors = true;
    }
    return (!errors);
}

void csBSPTree::Build (csTriangle* triangles, csPlane3* planes,
	size_t num_triangles, const csVector3* vertices,
	const csArray<int>& triidx)
{
  CS_ASSERT (triidx.GetSize () > 0);
  if (triidx.GetSize () == 1)
  {
    splitters.Push (triidx[0]);
    return;
  }

  size_t idx = FindBestSplitter (triangles, planes, num_triangles, vertices,
  	triidx);
  CS_ASSERT (idx != (size_t)-1);
  splitters.Push (triidx[idx]);

  csArray<int> left;
  csArray<int> right;
  size_t i;
  split_plane = planes[triidx[idx]];
  for (i = 0 ; i < triidx.GetSize () ; i++)
    if (i != idx)
    {
      int idxi = triidx[i];
      csTriangle& trj = triangles[idxi];
      int cla = ClassifyPlane (split_plane, vertices[trj.a]);
      int clb = ClassifyPlane (split_plane, vertices[trj.b]);
      int clc = ClassifyPlane (split_plane, vertices[trj.c]);
      if ((cla == -clb && cla != 0) ||
	  (cla == -clc && cla != 0) ||
	  (clb == -clc && clb != 0))
      {
	// There is a split.
	left.Push (idxi);
	right.Push (idxi);
      }
      else
      {
	if (cla == -1 || clb == -1 || clc == -1)
	  left.Push (idxi);
	else if (cla == 1 || clb == 1 || clc == 1)
	  right.Push (idxi);
        else
	  splitters.Push (idxi);
      }
    }
  if (left.GetSize () > 0)
  {
    child1 = TreeNodes()->Alloc ();
    child1->Build (triangles, planes, num_triangles, vertices, left);
  }
  if (right.GetSize () > 0)
  {
    child2 = TreeNodes()->Alloc ();
    child2->Build (triangles, planes, num_triangles, vertices, right);
  }
}

void psNetMsgProfiles::AddEnoughRecords(csArray<psOperProfile*> & arr, int neededIndex, const char * desc)
{
    while (neededIndex >= (int)arr.GetSize())
    {
        csStringFast<100> fullDesc = GetMsgTypeName((int)arr.GetSize()) + "-" + csStringFast<100>(desc);
        psOperProfile * newProf = new psOperProfile(fullDesc);
        arr.Push(newProf);
        profs.Push(newProf);
    }
}

int GMEventManager::GetAllGMEventsForPlayer (PID playerID,
                                             csArray<int>& completedEvents,
                                             int& runningEventAsGM,
                                             csArray<int>& completedEventsAsGM)
{
    int runningEvent = -1, id, index=0;
    GMEvent* gmEvent;

    completedEvents.DeleteAll();
    completedEventsAsGM.DeleteAll();

    if ((gmEvent = GetGMEventByGM(playerID, RUNNING, index)))
    {
        runningEventAsGM = gmEvent->id;
    }
    else
    {
        runningEventAsGM = -1;
    }

    index = 0;
    do
    {
        gmEvent = GetGMEventByGM(playerID, COMPLETED, index);
        if (gmEvent)
        {
            id = gmEvent->id;
            completedEventsAsGM.Push(id);
        }
    }
    while (gmEvent);

    index = 0;
    gmEvent = GetGMEventByPlayer(playerID, RUNNING, index);
    if (gmEvent)
        runningEvent = gmEvent->id;

    index = 0;
    do
    {
        gmEvent = GetGMEventByPlayer(playerID, COMPLETED, index);
        if (gmEvent)
        {
            id = gmEvent->id;
            completedEvents.Push(id);
        }
    }
    while (gmEvent);

    return (runningEvent);
}

void csPixelShaderParser::WriteProgram (
	const csArray<csPSProgramInstruction>& instrs, 
	csString& str) const
{
  for(size_t i = 0; i < instrs.GetSize (); i++)
  {
    const csPSProgramInstruction& instr = instrs.Get (i);

    csString line;
    GetInstructionLine (instr, line);
    str << line;
    str << '\n';
  }
}

  void csFurStrand::SetUV( const csArray<csGuideFur> &guideFurs,
    const csArray<csGuideFurLOD> &guideFursLOD )
  {
    csVector2 strandUV(0);

    for ( size_t j = 0 ; j < GUIDE_HAIRS_COUNT ; j ++ )
      if (guideHairsRef[j].index < guideFurs.GetSize() )
        strandUV += guideHairsRef[j].distance * 
          guideFurs.Get(guideHairsRef[j].index).uv;
      else
        strandUV += guideHairsRef[j].distance * 
          guideFursLOD.Get(guideHairsRef[j].index - guideFurs.GetSize()).uv;

    uv = strandUV;
  }

bool csTerrainObjectLoader::ParseMaterialPalette (iDocumentNode *node,
       iLoaderContext *ldr_context, csArray<iMaterialWrapper*>& palette)
{
  csRef<iDocumentNodeIterator> it = node->GetNodes ();
  while (it->HasNext ())
  {
    csRef<iDocumentNode> child = it->Next ();
    if (child->GetType () != CS_NODE_ELEMENT) continue;
    const char *value = child->GetValue ();
    csStringID id = xmltokens.Request (value);
    switch (id)
    {
      case XMLTOKEN_MATERIAL:
      {
        const char* matname = child->GetContentsValue ();
        csRef<iMaterialWrapper> mat = ldr_context->FindMaterial (matname);
        if (!mat)
        {
          synldr->ReportError (
            "crystalspace.terrain.object.loader.materialpalette",
            child, "Couldn't find material '%s'!", matname);
          return false;
        }
        palette.Push (mat);
        break;
      }
      default:
        synldr->ReportError (
          "crystalspace.terrain.object.loader.materialpalette",
          child, "Unknown token in materials list!");
    }
  }
  return true;
}

  void csFurStrand::Update( const csArray<csGuideFur> &guideFurs,
    const csArray<csGuideFurLOD> &guideFursLOD, float controlPointsLOD)
  {
    for ( size_t i = 0 ; i < GetControlPointsCount(controlPointsLOD); i++ )
    {
      controlPoints[i] = csVector3(0);

      for ( size_t j = 0 ; j < GUIDE_HAIRS_COUNT ; j ++ )
        if ( guideHairsRef[j].index < guideFurs.GetSize() )
          controlPoints[i] += guideHairsRef[j].distance * 
            (guideFurs.Get(guideHairsRef[j].index).controlPoints[i]);
        else
          controlPoints[i] += guideHairsRef[j].distance * (guideFursLOD.Get
            (guideHairsRef[j].index - guideFurs.GetSize()).controlPoints[i]);
    }
  }

bool csBox3::ProjectOutline (const csVector3& origin,
                             int axis, float where, csArray<csVector2>& poly) const
{
    int idx = CalculatePointSegment (origin);
    const Outline &ol = outlines[idx];
    int num_array = MIN (ol.num, 6);

    int i;
    for (i = 0 ; i < num_array ; i++)
    {
        csVector3 isect;
        if (!csIntersect3::SegmentAxisPlane (origin, GetCorner (ol.vertices[i]),
                                             axis, where, isect))
            return false;
        csVector2 v;
        switch (axis)
        {
        case CS_AXIS_X:
            v.x = isect.y;
            v.y = isect.z;
            break;
        case CS_AXIS_Y:
            v.x = isect.x;
            v.y = isect.z;
            break;
        case CS_AXIS_Z:
            v.x = isect.x;
            v.y = isect.y;
            break;
        }
        poly.Push (v);
    }
    return true;
}

size_t csBSPTree::FindBestSplitter (csTriangle* triangles, csPlane3* planes,
	size_t /*num_triangles*/, const csVector3* vertices,
	const csArray<int>& triidx)
{
  size_t i, j;
  float mincost = 1000000.0;
  size_t minidx = (size_t)-1;
  for (i = 0 ; i < triidx.GetSize () ; i++)
  {
    int cnt_splits = 0;
    int cnt_left = 0;
    int cnt_right = 0;
    csPlane3& pl = planes[triidx[i]];
    for (j = 0 ; j < triidx.GetSize () ; j++)
      if (i != j)
      {
        csTriangle& trj = triangles[triidx[j]];
	int cla = ClassifyPlane (pl, vertices[trj.a]);
	int clb = ClassifyPlane (pl, vertices[trj.b]);
	int clc = ClassifyPlane (pl, vertices[trj.c]);
	if ((cla == -clb && cla != 0) ||
	    (cla == -clc && cla != 0) ||
	    (clb == -clc && clb != 0))
	{
	  // There is a split.
	  cnt_splits++;
	}
	else
	{
	  if (cla == -1 || clb == -1 || clc == -1)
	    cnt_left++;
	  else if (cla == 1 || clb == 1 || clc == 1)
	    cnt_right++;
	}
      }
    float split = float (cnt_splits) / float (triidx.GetSize ());
    float balance = float (ABS (cnt_left-cnt_right)) / float (triidx.GetSize ());
    float cost = 10.0 * split + balance;
    if (cost < mincost)
    {
      minidx = i;
      mincost = cost;
    }
  }
  return minidx;
}

bool LootRandomizer::GetModifiers(uint32_t itemID,
                                  csArray<psGMSpawnMods::ItemModifier>& mods)
{
    csHash<LootModifier*, uint32_t>::GlobalIterator it =
        LootModifiersById.GetIterator();
    while(it.HasNext())
    {
        LootModifier* lootModifier = it.Next();
        if(!lootModifier->IsAllowed(itemID))
        {
            continue;
        }

        psGMSpawnMods::ItemModifier mod;
        mod.name = lootModifier->name;
        mod.id = lootModifier->id;
        mod.type = lootModifier->mod_id;
        mods.Push(mod);
    }

    return mods.GetSize() != 0;
}

  void csFurStrand::Generate( size_t controlPointsCount,
    const csArray<csGuideFur> &guideFurs, 
    const csArray<csGuideFurLOD> &guideFursLOD )
  {
    // Allocate control points
    this -> controlPointsCount = controlPointsCount;

    controlPoints = new csVector3[ controlPointsCount ];

    for ( size_t i = 0 ; i < controlPointsCount ; i ++ )
    {
      controlPoints[i] = csVector3(0);

      for ( size_t j = 0 ; j < GUIDE_HAIRS_COUNT ; j ++ )
        if ( guideHairsRef[j].index < guideFurs.GetSize() )
          controlPoints[i] += guideHairsRef[j].distance *
            guideFurs.Get(guideHairsRef[j].index).controlPoints[i];
        else
          controlPoints[i] += guideHairsRef[j].distance *
            guideFursLOD.Get(guideHairsRef[j].index - 
            guideFurs.GetSize()).controlPoints[i];
    }
  }

int CharCreationManager::CalculateCPLife(csArray<uint32_t> &events)
{
    int cpCost = 0;
    for(size_t li = 0; li < events.GetSize(); li++)
    {
        CharCreationManager::LifeEventChoiceServer* event;
        event = psserver->charCreationManager->FindLifeEvent(events[li]);

        if(event)
        {
            cpCost+=event->cpCost;
        }
    }

    return cpCost;
}

void NetManager::Multicast (MsgEntry* me, const csArray<PublishDestination>& multi, int except, float range)
{
    for (size_t i=0; i<multi.GetSize(); i++)
    {
        if (multi[i].client==except)  // skip the exception client to avoid circularity
            continue;

        Client *c = clients.Find(multi[i].client);
        if (c && c->IsReady() )
        {
            if (range == 0 || multi[i].dist < range)
            {
                me->clientnum = multi[i].client;
                SendMessage(me);      // This copies the mem block, so we can reuse.
            }
        }
    }
}