Control Terrain Repeating through World Editor

Download Code File

This MPG Video shows how this works in the world editor. Essentially it adds a new property that you can toggle to control whether or not the terrain is repeated endlessely when rendered. The change takes place immediately after hitting APPLY so you don't have to reload the mission. When the terrain is set to NOT repeat endlessley, then there will be water covering the rest of the world endlessly. I guess I could have fixed that as well, but I didin't look into it. Seemed to me that you need "something" else out there if you don't repeat the terrain.

Applying this is pretty simple, and there are two ways you can do it. Via a patch or by hand.

Applying the patch
Note: The patch was built from a HEAD checkout 4/17/04

Applying the patch should be realtivly easy if your version of Torque is close to or the same as the one I used to build the patch. You can find instructions on applying patches [url=http://www.garagegames.com/docs/torque.sdk/gstarted/patches.html]here[/url. That page deals with both making and applying patches, so just ignore the parts that cover making them.

Applying the code by hand
Applying the code by hand is pretty easy, as there are only 3 files you have to touch. All code added for this is commented cleaerly. The code below will contain some of the original code before and after the changed/added code for context. This was applied to a HEAD version from about the end of March so there may be slight differences.

1) torque/engine/terrain/terrData.h
We need a variable to control our repeating option, so we add a new member variable to the TerrainBlock class.

U32   mTextureCallbackKey;
   void  processTextureEvent(const U32 eventCode);

   S32 mMPMIndex[10];

   S32 mVertexBuffer;
// JWV BEGIN added for control over terrain repeating
   bool mRepeatTerrain;
// JWV END added for control over terrain repeating
  private:
   Resource<TerrainFile> mFile;
   GridSquare *gridMap[BlockShift+1];
   GridChunk *mChunkMap;
   U32   mCRC;
   
  public:

2) torque/engine/terrain/terrData.cc
Now that we have the new variable, we need to add the code to set that variable, as well as the code to properly transmit it over the network. There are 4 places where we add code in this file.

First, we just need to initialize a default value (We default to repeating the terrain) in the constructor.

mCRC = 0;
   flagMap = 0;
	mVertexBuffer = -1;
// JWV BEGIN added for control over epeating terrain
   mRepeatTerrain = true;
// JWV BEGIN added for control over epeating terrain
}

Next, we need to add our new variable to the initPersistantFields() method. This is what allows it to be controled via the editor.

void TerrainBlock::initPersistFields()
{
   Parent::initPersistFields();

   addGroup("Media");	// MM: Added Group Header.
   addField("detailTexture",     TypeFilename,  Offset(mDetailTextureName, TerrainBlock));
   addField("terrainFile",       TypeFilename,  Offset(mTerrFileName, TerrainBlock));
//CW - bump mapping stuff
	addField("bumpTexture",			TypeFilename,	Offset(mBumpTextureName, TerrainBlock));
//CW - end bump mapping stuff
   endGroup("Media");	// MM: Added Group Footer.

   addGroup("Misc");	// MM: Added Group Header.
   addField("squareSize",        TypeS32,       Offset(squareSize, TerrainBlock));
   addField("emptySquares",      TypeS32Vector, Offset(mEmptySquareRuns, TerrainBlock));
//CW - bump mapping stuff
	addField("bumpScale",			TypeF32,			Offset(mBumpScale, TerrainBlock));
	addField("bumpOffset",			TypeF32,			Offset(mBumpOffset, TerrainBlock));
	addField("zeroBumpScale",		TypeS32,			Offset(mZeroBumpScale, TerrainBlock));
//CW - end bump mapping stuff
// JWV BEGIN added for control of repeating terrain
   addField("repeatTerrain",     TypeBool,      Offset(mRepeatTerrain, TerrainBlock));
// JWV END added for control of repeating terrain
   endGroup("Misc");	// MM: Added Group Footer.

   removeField("position");
}

The TerrainBlock now knows about the new variable and it can be set, however we also need to add in the networking for this new variable. IF we don't then it will never get properly "ghosted". To do this we add in code to write the variable over the network and to read it from the network. This is done in packUpdate() and unpackUpdate()

First we'll take care of packUpdate(). This is where we write the variable to the network.

U32 TerrainBlock::packUpdate(NetConnection *, U32 mask, BitStream *stream)
{
   if(stream->writeFlag(mask & InitMask))
   {
      stream->write(mCRC);
      stream->writeString(mTerrFileName);
      stream->writeString(mDetailTextureName);
//CW - bump mapping stuff
		stream->writeString(mBumpTextureName);
		//don't have negative bump scale and don't have one too small
		if (mBumpScale <= 0)
		{
			Con::errorf("Bump scale cannot be less than or equal to 0.  Setting to 0.0001.");
			mBumpScale = 0.0001;
		}
		stream->write(mBumpScale);
		stream->write(mBumpOffset);
		stream->write(mZeroBumpScale);
//CW - end bump mapping stuff
      stream->write(squareSize);
// JWV BEGIN added for control over terrain repeating
      stream->write(mRepeatTerrain);
// JWV END added for control over terrain repeating

      // write out the empty rle vector
      stream->write(mEmptySquareRuns.size());
      for(U32 i = 0; i < mEmptySquareRuns.size(); i++)   
         stream->write(mEmptySquareRuns[i]);
   }
   else // normal update

And lastly, we add code to read our variable from the network in unpackUpdate()

void TerrainBlock::unpackUpdate(NetConnection *, BitStream *stream)
{
   if(stream->readFlag())  // init
   {
      stream->read(&mCRC);
      mTerrFileName = stream->readSTString();
      mDetailTextureName = stream->readSTString();
//CW - bump mapping stuff
		mBumpTextureName = stream->readSTString();
		stream->read(&mBumpScale);
		stream->read(&mBumpOffset);
		stream->read(&mZeroBumpScale);
//CW - end bump mapping stuff
      stream->read(&squareSize);
// JWV BEGIN added for control over terrain repeating
      stream->read(&mRepeatTerrain);
// JWV END added for control over terrain repeating
      
      // read in the empty rle
      U32 size;   
      stream->read(&size);
      mEmptySquareRuns.setSize(size);
      for(U32 i = 0; i < size; i++)
         stream->read(&mEmptySquareRuns[i]);
   }
   else // normal update

Now what we've got is a new variable in the TerrainBlock that can be altered through the world editor and is properly "ghosted" over the network interface. The last step is to actually use this new variable to control the rendering of our terrain.

3) torque/engine/terrain/terrRender.cc
What we want to do here is alter the renderBlock() method to control if we should render the whole thing, or just the main block.

mDynamicTextureCount = 0;
   mTextureSpaceUsed = 0;
   mUnusedTextureCount = 0;
   mStaticTextureCount = 0;
   mLevelZeroCount = 0;
   mFullMipCount = 0;
   mStaticTSU = 0;
   
   F32 worldToScreenScale   = dglProjectRadius(1,1);
   F32 zeroDetailDistance   = (mSquareSize * worldToScreenScale) / (1 << 6) - (mSquareSize >> 1);
	F32 zeroBumpDistance		 = (mSquareSize * worldToScreenScale) / (1 << mCurrentBlock->mZeroBumpScale) - (mSquareSize >> 1);
   
   F32 blockSize = mSquareSize * TerrainBlock::BlockSquareWidth;
// JWV BEGIN change to terrain rendering so as to not endlessley repeat the terrain
/* OLD CODE
   S32 xStart = (S32)mFloor( (mCamPos.x - mFarDistance) / blockSize );
   S32 xEnd   = (S32)mCeil ( (mCamPos.x + mFarDistance) / blockSize );
   S32 yStart = (S32)mFloor( (mCamPos.y - mFarDistance) / blockSize );
   S32 yEnd   = (S32)mCeil ( (mCamPos.y + mFarDistance) / blockSize );
   S32 xExt   = (S32)(xEnd - xStart);
   S32 yExt   = (S32)(yEnd - yStart);*/
   S32 xStart;
   S32 xEnd;
   S32 yStart;
   S32 yEnd;
   S32 xExt;
   S32 yExt;
   if (block->mRepeatTerrain)
   {
      xStart = (S32)mFloor( (mCamPos.x - mFarDistance) / blockSize );
      xEnd   = (S32)mCeil ( (mCamPos.x + mFarDistance) / blockSize );
      yStart = (S32)mFloor( (mCamPos.y - mFarDistance) / blockSize );
      yEnd   = (S32)mCeil ( (mCamPos.y + mFarDistance) / blockSize );
      xExt   = (S32)(xEnd - xStart);
      yExt   = (S32)(yEnd - yStart);
   }
   else
   {
      xStart = 0;
      xEnd = 1;
      yStart = 0;
      yEnd   = 1;
      xExt   = (S32)(xEnd - xStart);
      yExt   = (S32)(yEnd - yStart);
   }
// JWV END change to terrain rendering so as to not endlessley repeat the terrain
   
#if 0
   {
      SquareStackNode2 *st = (SquareStackNode2 *) 
         FrameAllocator::alloc(sizeof(SquareStackNode2) * 
                               (xExt * yExt + TerrainBlock::BlockShift*4) );
      for(S32 y = 0; y < yExt; y++)

That's all the changes. Re-compile Torque and you should be all set to go.

How to Control Terrain Repeating
The video linked at the top of this resource shows exactly how to control this in the world editor, but for those who don't want to download the video, or can't, here are the baiscs.
1) Open the World Editor.
2) Go to the Mission Inspector.
3) Select the terrain block.
4) Expand the "Misc" group.
5) The field "repeatTerrain" controls the repeating. Select (repat) or unselect (dont' repeat) the field and then click APPLY.
6) Save the mission.