C++ CClientStreamElement类代码示例

void CClientStreamer::AddToSortedList ( list < CClientStreamElement* > * pList, CClientStreamElement * pElement )
{
    // Make sure it's exp distance is updated
    float fDistance = pElement->GetDistanceToBoundingBoxSquared ( m_vecPosition );
    pElement->SetExpDistance ( fDistance );

    // Don't add if already in the list
    if ( ListContains ( *pList, pElement ) )
        return;

    // Search through our list. Add it behind the first item further away than this
    CClientStreamElement * pTemp = NULL;
    list < CClientStreamElement* > :: iterator iter = pList->begin ();
    for ( ; iter != pList->end (); iter++ )
    {
        pTemp = *iter;

        // Is it further than the one we add?
        if ( pTemp->GetDistanceToBoundingBoxSquared ( m_vecPosition ) > fDistance )
        {
            // Add it before here
            pList->insert ( iter, pElement );
            return;
        }
    }

    // We have no elements in the list, add it at the beginning
    pList->push_back ( pElement );
}

void CClientStreamer::OnEnterSector ( CClientStreamSector * pSector )
{
    CClientStreamElement * pElement = NULL;
    if ( m_pSector )
    {                
        // Grab the unwanted sectors
        list < CClientStreamSector * > common, uncommon;
        pSector->CompareSurroundings ( m_pSector, &common, &uncommon, true );

        // Deactivate the unwanted sectors
        CClientStreamSector * pTempSector = NULL;
        list < CClientStreamSector * > ::iterator iter = uncommon.begin ();
        for ( ; iter != uncommon.end () ; iter++ )
        {
            pTempSector = *iter;
            // Make sure we dont unload our new sector
            if ( pTempSector != pSector )
            {            
                if ( pTempSector->IsActivated () )
                {
                    list < CClientStreamElement * > ::iterator iter = pTempSector->Begin ();
                    for ( ; iter != pTempSector->End () ; iter++ )
                    {
                        pElement = *iter;
                        if ( pElement->IsStreamedIn () )
                        {
                            // Add it to our streaming out list
                            m_ToStreamOut.push_back ( pElement );
                        }
                    }
                    pTempSector->RemoveElements ( &m_ActiveElements );
                    pTempSector->SetActivated ( false );
                }
            }
        }

        // Grab the wanted sectors
        m_pSector->CompareSurroundings ( pSector, &common, &uncommon, true );

        // Activate the unwanted sectors
        iter = uncommon.begin ();
        for ( ; iter != uncommon.end () ; iter++ )
        {
            pTempSector = *iter;
            if ( !pTempSector->IsActivated () )
            {
                pTempSector->AddElements ( &m_ActiveElements );
                pTempSector->SetActivated ( true );
            }
        }
    }
    m_pSector = pSector;
    SetExpDistances ( &m_ActiveElements );
    m_ActiveElements.sort ( CompareExpDistance );
}

void CClientStreamer::SetExpDistances ( list < CClientStreamElement * > * pList )
{
    // Run through our list setting distances to world center
    CClientStreamElement * pElement = NULL;
    list < CClientStreamElement* >:: iterator iter = pList->begin ();
    for ( ; iter != pList->end (); iter++ )
    {
        pElement = *iter;
        // Set its distance ^ 2
        pElement->SetExpDistance ( pElement->GetDistanceToBoundingBoxSquared ( m_vecPosition ) );
    }
}

void CClientStreamElement::UpdateStreamPosition ( const CVector & vecPosition )
{
    m_vecStreamPosition = vecPosition;    
    m_pStreamer->OnUpdateStreamPosition ( this );
    m_pManager->OnUpdateStreamPosition ( this );

	// Update attached elements stream position
	list < CClientEntity* >::iterator i = m_AttachedEntities.begin();
	for (; i != m_AttachedEntities.end(); i++)
	{
		CClientStreamElement* attachedElement = dynamic_cast< CClientStreamElement* > (*i);
		if ( attachedElement )
		{
			attachedElement->UpdateStreamPosition( vecPosition + attachedElement->m_vecAttachedPosition );
		}
	}
}

void CClientStreamElement::InternalStreamOut ( void )
{
    if ( m_bStreamedIn )
    {
        StreamOut ();
        m_bStreamedIn = false;

       	// Stream out attached elements
        list < CClientEntity* >::iterator i = m_AttachedEntities.begin();
        for (; i != m_AttachedEntities.end(); i++)
        {
            CClientStreamElement* attachedElement = dynamic_cast< CClientStreamElement* > (*i);
            if ( attachedElement )
            {
                attachedElement->InternalStreamOut();
            }
        }

        CLuaArguments Arguments;
        CallEvent ( "onClientElementStreamOut", Arguments, true );
    }
}

void CClientStreamer::SetDimension ( unsigned short usDimension )
{
    // Different dimension than before?
    if ( usDimension != m_usDimension )
    {
        // Set the new dimension
        m_usDimension = usDimension;

        // That means all of the currently streamed in elements will have to
        // go. Unstream all elements that are streamed in.
        CClientStreamElement * pElement = NULL;
        list < CClientStreamElement * > ::iterator iter = m_ActiveElements.begin ();
        for ( ; iter != m_ActiveElements.end () ; iter++ )
        {
            pElement = *iter;
            if ( pElement->IsStreamedIn () )
            {
                // Unstream it
                m_ToStreamOut.push_back ( pElement );
            }
        }
    }
}

void CClientStreamer::Restream ( bool bMovedFar )
{
    // Limit distance stream in/out rate
    // Vehicles might have to ignore this to reduce blocking loads elsewhere.
    int iMaxOut = 6;
    int iMaxIn = 6;
    if ( bMovedFar )
    {
        iMaxOut = 1000;
        iMaxIn = 1000;
    }

    // Do we have any elements waiting to be streamed out?
    while ( !m_ToStreamOut.empty () )
    {
        CClientStreamElement* pElement = m_ToStreamOut.front ();
        // Make sure we have no stream-references
        if ( pElement->GetTotalStreamReferences () == 0 )
        {
            // Stream out 1 of them per frame
            pElement->InternalStreamOut ();
            iMaxOut--;
        }
        m_ToStreamOut.remove ( pElement );

        if ( iMaxOut <= 0 )
            break;
    }

    static std::vector < CClientStreamElement* > ClosestStreamedOutList;
    static std::vector < CClientStreamElement* > FurthestStreamedInList;
    ClosestStreamedOutList.clear();
    FurthestStreamedInList.clear();

    bool bReachedLimit = ReachedLimit ();
    // Loop through our active elements list (they should be ordered closest to furthest)
    list < CClientStreamElement* > ::iterator iter = m_ActiveElements.begin ();
    for ( ; iter != m_ActiveElements.end (); iter++ )
    {
        CClientStreamElement* pElement = *iter;
        float fElementDistanceExp = pElement->GetExpDistance ();
        
        // Is this element streamed in?
        if ( pElement->IsStreamedIn () )
        {                
            if ( IS_VEHICLE ( pElement ) )
            {
                CClientVehicle* pVehicle = DynamicCast < CClientVehicle > ( pElement );
                if ( pVehicle )
                {
                    if ( pVehicle->GetOccupant ( ) && IS_PLAYER ( pVehicle->GetOccupant ( ) ) )
                    {
                        CClientPlayer* pPlayer = DynamicCast < CClientPlayer > ( pVehicle->GetOccupant ( ) );
                        if ( pPlayer->GetLastPuresyncType ( ) == PURESYNC_TYPE_LIGHTSYNC )
                        {
                            // if the last packet was ls he shouldn't be streamed in
                            m_ToStreamOut.push_back ( pElement );
                        }
                    }

                    // Is this a trailer?
                    if ( pVehicle->GetTowedByVehicle ( ) != NULL )
                    {
                        // Don't stream it out (this is handled by the towing vehicle)
                        continue;
                    }
                }
            }
            if ( IS_PLAYER ( pElement ) )
            {
                CClientPlayer* pPlayer = DynamicCast < CClientPlayer > ( pElement );
                if ( pPlayer->GetLastPuresyncType ( ) == PURESYNC_TYPE_LIGHTSYNC )
                {
                    // if the last packet was ls he isn't/shouldn't be streamed in
                    m_ToStreamOut.push_back ( pElement );
                }
            }
            // Too far away? Use the threshold so we won't flicker load it if it's on the border moving.
            if ( fElementDistanceExp > m_fMaxDistanceThreshold )
            {
                // Unstream it now?
                if ( iMaxOut > 0 )
                {
                    // Make sure we have no stream-references
                    if ( pElement->GetTotalStreamReferences () == 0 )
                    {
                        // Stream out now
                        pElement->InternalStreamOut ();
                        iMaxOut--;
                    }
                    m_ToStreamOut.remove ( pElement );
                }
                else
                {
                    // or later
                    m_ToStreamOut.push_back ( pElement );
                }
            }
            else
            {
//.........这里部分代码省略.........

//.........这里部分代码省略.........
            flags.bCheckDummies = true;
            flags.bSeeThroughStuff = true;
            flags.bIgnoreSomeObjectsForCamera = false;
            flags.bShootThroughStuff = true;
            g_pGame->GetWorld()->ProcessLineOfSight(&vecStart, &vecTarget, &pColPoint, &pEntity, flags);
            if (pColPoint)
                pColPoint->Destroy();

            // Un-ignore the local player
            pLocalPlayer->WorldIgnore(false);

            // Did we find an entity?
            if (pEntity)
            {
                // Grab the CClientEntity belonging to this game_sa entity
                CClientEntity* pClientEntity = reinterpret_cast<CClientEntity*>(pEntity->GetStoredPointer());
                if (pClientEntity)
                {
                    // Is it a vehicle? Is it a ped?
                    eClientEntityType EntityType = pClientEntity->GetType();
                    if (EntityType == CCLIENTVEHICLE)
                    {
                        CClientVehicle* pClientVehicle = static_cast<CClientVehicle*>(pClientEntity);

                        // Set the current time as the last draw time for all players inside
                        CClientPed* pPed;
                        int         i;
                        for (i = 0; i < 8; i++)
                        {
                            // Grab this seat's occupant and set its last nametag show time to now
                            pPed = pClientVehicle->GetOccupant(i);
                            if (pPed && pPed->GetType() == CCLIENTPLAYER)
                            {
                                static_cast<CClientPlayer*>(pPed)->SetLastNametagShow(ulCurrentTime);
                            }
                        }
                    }
                    else if (EntityType == CCLIENTPLAYER)
                    {
                        // Grab the player this entity is
                        CClientPlayer* pClientPlayer = static_cast<CClientPlayer*>(pClientEntity);
                        if (pClientPlayer)
                        {
                            // Set now as the last time we had the cursor above him
                            pClientPlayer->SetLastNametagShow(ulCurrentTime);
                        }
                    }
                }
            }

            // Grab the local player vehicle
            CClientVehicle* pLocalVehicle = pLocalPlayer->GetOccupiedVehicle();

            // Draw the nametags we need to
            CClientPlayer*                              pPlayer;
            CClientStreamElement*                       pElement;
            list<CClientStreamElement*>::const_iterator iter = m_pPlayerStreamer->ActiveElementsBegin();
            for (; iter != m_pPlayerStreamer->ActiveElementsEnd(); ++iter)
            {
                pElement = *iter;
                if (!pElement->IsStreamedIn())
                    continue;
                if (pElement->GetType() != CCLIENTPLAYER)
                    continue;
                pPlayer = static_cast<CClientPlayer*>(pElement);
                if (pPlayer->IsLocalPlayer())
                    continue;

                // Is he in the same vehicle as the local player?
                if (pLocalVehicle && pPlayer->GetOccupiedVehicle() == pLocalVehicle)
                {
                    pPlayer->SetLastNametagShow(ulCurrentTime);
                }

                // Can we show this player's nametag
                unsigned long ulLastNametagShow = pPlayer->GetLastNametagShow();
                if (ulLastNametagShow != 0 && ulCurrentTime <= ulLastNametagShow + NAMETAG_END_FADE_TIME)
                {
                    unsigned long ulLastNametagShow = pPlayer->GetLastNametagShow();
                    // Calculate the alpha modifier
                    float fAlphaTimeModifier;
                    if (ulCurrentTime < ulLastNametagShow + NAMETAG_BEGIN_FADE_TIME)
                    {
                        fAlphaTimeModifier = 1.0f;
                    }
                    else
                    {
                        fAlphaTimeModifier = 1.0f - (ulCurrentTime - ulLastNametagShow - NAMETAG_BEGIN_FADE_TIME) / 1000.0f;
                    }

                    // Calculate the alpha for the nametag
                    unsigned char ucAlpha = static_cast<unsigned char>(180.0f * fAlphaTimeModifier);

                    // Draw it
                    DrawTagForPlayer(pPlayer, ucAlpha);
                }
            }
        }
    }
}

void CNametags::DrawDefault()
{
    // Grab the resolution width and height
    static float fResWidth = static_cast<float>(g_pCore->GetGraphics()->GetViewportWidth());
    static float fResHeight = static_cast<float>(g_pCore->GetGraphics()->GetViewportHeight());

    // Got any players that are not local?
    if (m_pPlayerManager->Count() <= 1)
        return;

    list<CClientPlayer*> playerTags;

    // Grab the local player
    CClientPlayer* pLocalPlayer = m_pPlayerManager->GetLocalPlayer();
    if (!pLocalPlayer)
        return;

    CClientVehicle* pSniperTargetedVehicle = NULL;
    CClientPlayer*  pSniperTargetedPlayer = NULL;

    // Grab our current weapon slot. Use screen center if melee or none
    eWeaponSlot eSlot = pLocalPlayer->GetCurrentWeaponSlot();
    if (eSlot >= WEAPONSLOT_TYPE_HANDGUN && eSlot <= WEAPONSLOT_TYPE_RIFLE)
    {
        CVector vecOrigin, vecTarget;
        pLocalPlayer->GetShotData(&vecOrigin, &vecTarget);

        // Ignore the local player for this
        pLocalPlayer->WorldIgnore(true);

        // Do the raycast
        CColPoint*        pColPoint = NULL;
        CEntity*          pEntity = NULL;
        SLineOfSightFlags flags;
        flags.bCheckBuildings = true;
        flags.bCheckVehicles = true;
        flags.bCheckPeds = true;
        flags.bCheckObjects = true;
        flags.bCheckDummies = true;
        flags.bSeeThroughStuff = true;
        flags.bIgnoreSomeObjectsForCamera = false;
        flags.bShootThroughStuff = true;
        g_pGame->GetWorld()->ProcessLineOfSight(&vecOrigin, &vecTarget, &pColPoint, &pEntity, flags);
        if (pColPoint)
            pColPoint->Destroy();

        // Un-ignore the local player
        pLocalPlayer->WorldIgnore(false);

        // Did we find an entity?
        if (pEntity)
        {
            // Grab the CClientEntity belonging to this game_sa entity
            CClientEntity* pClientEntity = reinterpret_cast<CClientEntity*>(pEntity->GetStoredPointer());
            if (pClientEntity)
            {
                // Is it a vehicle? Is it a ped?
                eClientEntityType EntityType = pClientEntity->GetType();
                switch (EntityType)
                {
                    case CCLIENTVEHICLE:
                    {
                        pSniperTargetedVehicle = static_cast<CClientVehicle*>(pClientEntity);
                        break;
                    }
                    case CCLIENTPLAYER:
                    {
                        pSniperTargetedPlayer = static_cast<CClientPlayer*>(pClientEntity);
                        break;
                    }
                    default:
                        break;
                }
            }
        }
    }

    // Grab the local player vehicle
    CClientVehicle* pLocalVehicle = pLocalPlayer->GetOccupiedVehicle();
    CVehicle*       pLocalGameVehicle = NULL;
    if (pLocalVehicle)
        pLocalGameVehicle = pLocalVehicle->GetGameVehicle();

    CMatrix CameraMatrix;
    g_pGame->GetCamera()->GetMatrix(&CameraMatrix);

    // Remove collision from our local vehicle (if we have one)
    if (pLocalVehicle)
        pLocalVehicle->WorldIgnore(true);

    // Draw the nametags we need to
    CVector                                     vecPlayerPosition;
    CClientVehicle*                             pPlayerVehicle = NULL;
    float                                       fDistanceExp;
    bool                                        bCollision;
    CColPoint*                                  pColPoint = NULL;
    CEntity*                                    pGameEntity = NULL;
    CClientEntity*                              pEntity = NULL;
    CClientPlayer*                              pPlayer;
    CClientStreamElement*                       pElement;
//.........这里部分代码省略.........