Local client load speed enhancement

A few people asked for this to be posted as a resource, so here it is. I've checked this code out on local and dedicated servers, in demos and out, and it all seems to work. There may be a few issues here and there, but I haven't seen any yet. As always, use the code at your own risk. I'm not supporting it in any way. If you have problems implementing it or want questions answered or whatever, too bad.

Essentially these changes amount to little more than short-circuiting both datablock transmission and the transmission of scopealways objects so as to avoid the chokepoint imposed by networking packet sizes and the like. This will greatly decrease the amount of time required for transmitting datablocks and static objects (such as the terrain and so on) to a local client.

Implementing this resource consists of a few modifications to the codebase, but it's all pretty straightforward. Kudos go out to all the people who've contributed to it.

First, around line 1230 of game/gameConnection.cc, replace the transmitDataBlocks console method with:

ConsoleMethod( GameConnection, transmitDataBlocks, void, 3, 3, "(int sequence)")
{
    // Set the datablock sequence.
    object->setDataBlockSequence(dAtoi(argv[2]));

    // Store a pointer to the datablock group.
    SimDataBlockGroup* pGroup = Sim::getDataBlockGroup();

    // Determine the size of the datablock group.
    const U32 iCount = pGroup->size();

    // If this is the local client...
    if (GameConnection::getLocalClientConnection() == object)
    {
        // Set up a pointer to the datablock.
        SimDataBlock* pDataBlock = 0;

        // Iterate through all the datablocks...
        for (U32 i = 0; i < iCount; i++)
        {
            // Get a pointer to the datablock in question...
            pDataBlock = (SimDataBlock*)(*pGroup)[i];

            // Set the client's new modified key.
            object->setMaxDataBlockModifiedKey(pDataBlock->getModifiedKey());

            // Set up a buffer for the datablock send.
            U8 iBuffer[4096];
            BitStream mStream(iBuffer, 4096);

            // Pack the datablock stream.
            pDataBlock->packData(&mStream);

            // Set the stream position back to zero.
            mStream.setPosition(0);

            // Unpack the datablock stream.
            pDataBlock->unpackData(&mStream);

            // Call the console function to set the number of blocks to be sent.
            Con::executef(3, "onDataBlockObjectReceived", Con::getIntArg(i), Con::getIntArg(iCount));

            // Preload the datablock on the dummy client.
            pDataBlock->preload(false, NetConnection::getErrorBuffer());
        }

        // Get the last datablock (if any)...
        if (pDataBlock)
        {
            // Ensure the datablock modified key is set.
            object->setDataBlockModifiedKey(object->getMaxDataBlockModifiedKey());

            // Ensure that the client knows that the datablock send is done...
            object->sendConnectionMessage(GameConnection::DataBlocksDone, object->getDataBlockSequence());
        }
    } 
    else
    {
        // Otherwise, store the current datablock modified key.
        const S32 iKey = object->getDataBlockModifiedKey();

        // Iterate through the datablock group...
        U32 i = 0;
        for (; i < iCount; i++)
        {
            // If the datablock's modified key has already been set, break out of the loop...
            if (((SimDataBlock*)(*pGroup)[i])->getModifiedKey() > iKey)
            {
                break;
            }
        }

        // If this is the last datablock in the group...
        if (i == iCount)
        {
            // Ensure that the client knows that the datablock send is done...
            object->sendConnectionMessage(GameConnection::DataBlocksDone, object->getDataBlockSequence());

            // Then exit out since nothing else needs to be done.
            return;
        }

        // Set the maximum datablock modified key value.
        object->setMaxDataBlockModifiedKey(iKey);

        // Get the minimum number of datablocks...
        const U32 iMax = getMin(i + DataBlockQueueCount, iCount);

        // Iterate through the remaining datablocks...
        for (;i < iMax; i++)
        {
            // Get a pointer to the datablock in question...
            SimDataBlock* pDataBlock = (SimDataBlock*)(*pGroup)[i];

            // Post the datablock event to the client.
            object->postNetEvent(new SimDataBlockEvent(pDataBlock, i, iCount, object->getDataBlockSequence()));
        }
    }
}

In the same file, at line 1146 or thereabouts, find the following:

// object failed to load, let's see if it had any missing files

         if(!ResourceManager->getMissingFileList(mMissingFileList))

... and replace it with ...

// object failed to load, let's see if it had any missing files

         if(isLocalConnection() || !ResourceManager->getMissingFileList(mMissingFileList))

Then in sim/netGhost.cc, around line 958, find this code in NetConnection::loadNextGhostAlwaysObject:

// object failed to load, let's see if it had any missing files
         if(!ResourceManager->getMissingFileList(mMissingFileList))

... and replace it with ...

// object failed to load, let's see if it had any missing files
         if(isLocalConnection() || !ResourceManager->getMissingFileList(mMissingFileList))

In the same file around line 828 in the NetConnection::activateGhosting method, remove the following code:

sendConnectionMessage(GhostAlwaysStarting, mGhostingSequence, ghostAlwaysSet->size());
   for(j = mGhostZeroUpdateIndex - 1; j >= 0; j--)
   {
      AssertFatal((mGhostArray[j]->flags & GhostInfo::ScopeAlways) != 0, "Non-scope always in the scope always list.")

      // we may end up resending state here, but at least initial state
      // will not be resent.
      mGhostArray[j]->updateMask = 0;
      ghostPushToZero(mGhostArray[j]);
      mGhostArray[j]->flags &= ~GhostInfo::NotYetGhosted;
      mGhostArray[j]->flags |= GhostInfo::ScopedEvent;

      postNetEvent(new GhostAlwaysObjectEvent(mGhostArray[j]->obj, mGhostArray[j]->index));
   }
   sendConnectionMessage(GhostAlwaysDone, mGhostingSequence);

... and replace it with:

// Send the initial ghosting connection message.
    sendConnectionMessage(GhostAlwaysStarting, mGhostingSequence, ghostAlwaysSet->size());

    // If this is the connection to the local client...
    if (getLocalClientConnection() == this)
    {
        // Get a pointer to the local client.
        NetConnection* pClient = NetConnection::getConnectionToServer();

        // Iterate through the scope always objects...
        for (j = mGhostZeroUpdateIndex - 1; j >= 0; j--)
        {
            AssertFatal((mGhostArray[j]->flags & GhostInfo::ScopeAlways) != 0, "NetConnection::activateGhosting:  Non-scope always in the scope always list.")

            // Clear the ghost update mask and flags appropriately.
            mGhostArray[j]->updateMask = 0;
            ghostPushToZero(mGhostArray[j]);
            mGhostArray[j]->flags &= ~GhostInfo::NotYetGhosted;
            mGhostArray[j]->flags |= GhostInfo::ScopedEvent;

            // Set up a pointer to the new object.
            NetObject* pObject = 0;

            // If there's a valid ghost object...
            if (mGhostArray[j]->obj)
            {
                // Set up a buffer for the object send.
                U8 iBuffer[4096];
                BitStream mStream(iBuffer, 4096);

                // Pack the server object's update.
                mGhostArray[j]->obj->packUpdate(this, 0xFFFFFFFF, &mStream);

                // Set the stream position back to zero.
                mStream.setPosition(0);

                // Create a new object instance for the client.
                pObject = (NetObject*)ConsoleObject::create(pClient->getNetClassGroup(), NetClassTypeObject, mGhostArray[j]->obj->getClassId(getNetClassGroup()));

                // Set the client object networking flags.
                pObject->mNetFlags = NetObject::IsGhost;
                pObject->mNetIndex = mGhostArray[j]->index;

                // Unpack the client object's update.
                pObject->unpackUpdate(pClient, &mStream);
            }
            else
            {
                // Otherwise, create a new dummy netobject.
                pObject = new NetObject;
            }

            // Execute the appropriate console callback.
            Con::executef(1, "onGhostAlwaysObjectReceived");

            // Set the ghost always object for the client.
            pClient->setGhostAlwaysObject(pObject, mGhostArray[j]->index);
        }
    }
    else
    {
        // Iterate through the scope always objects...
        for (j = mGhostZeroUpdateIndex - 1; j >= 0; j--)
        {
            AssertFatal((mGhostArray[j]->flags & GhostInfo::ScopeAlways) != 0, "NetConnection::activateGhosting:  Non-scope always in the scope always list.")

            // Clear the ghost update mask and flags appropriately.
            mGhostArray[j]->updateMask = 0;
            ghostPushToZero(mGhostArray[j]);
            mGhostArray[j]->flags &= ~GhostInfo::NotYetGhosted;
            mGhostArray[j]->flags |= GhostInfo::ScopedEvent;

            // Post a network event to ghost the scope always object.
            postNetEvent(new GhostAlwaysObjectEvent(mGhostArray[j]->obj, mGhostArray[j]->index));
        }
    }

    // Send the ghosting always done message.
    sendConnectionMessage(GhostAlwaysDone, mGhostingSequence);