Liquid wave depth - does this actually work? (Code spew)

//------------------------------------------------------------------------------
//  Public Functions
//
public:
            fluid               ( void );
           ~fluid               ();


[B]	//
	// KGB: Check the surface Z at point XY.
	//
	F32		surfaceAtXY			( f32 X, f32 Y )	const;
	F32		m_ServerSeconds; // KGB - Server time sync.
[/B]
    //
    // Render (in FluidRender.cc):
    //
    void    Render              ( bool& EyeSubmerged );

f32 TLMap[] = { 0.0f,  Q2, 0.0f, 0.0f };

    // Several attributes in the fluid vary over time.  Get a definitive time
    // reading now to be used throughout this render pass.
    [B]m_Seconds = m_ServerSeconds; // KGB: Use server time instead of computing it[/B]
         
    // Based on the view frustrum, accumulate the list of triangles that
    // comprise the fluid surface for this render pass.
    RunQuadTree( EyeSubmerged );

fluid::fluid( void )
{
    m_Instances     +=  1;

    [B]m_ServerSeconds    = 0.0f;   // KGB: Networking sync[/B]

    // Fill out fields with a stable, if useless, state.
    m_SquareX0        =  0;
    m_SquareY0        =  0;

//==============================================================================
// KGB: This returns the wave-adjusted surface Z position for a given XY
// returns 0 if there is no water (so if the water Z is actually 0.0, it gets a minor
// goose to make sure the routine doesn't completely fail).

F32 fluid::surfaceAtXY( f32 X, f32 Y ) const
{
   F32 surfaceZ = 0.0f;   
   if (IsFluidAtXY(X, Y)){       
       // this uses the formula from the runQuadTree() routine that calculates a
       // point matrix for rendering - here we only need to calculate one point.       
       //
       surfaceZ = m_SurfaceZ + (SINE( (X * 0.05f) + m_ServerSeconds ) +
                                     SINE( (Y * 0.05f) + m_ServerSeconds)) * m_WaveFactor;
      // Failure trap
      if (surfaceZ == 0.0f) surfaceZ = 0.001f; // what are the odds?
   }
   return(surfaceZ);

}
//==============================================================================

// MM: Depth-map Resolution.
   enum WaterAttributes
   {
      eDepthMapResolution   = 512,
   };
[B]	
// ** KGB: Section added for water sync
	enum States {
		updateFluidMask = BIT(1),
		updateTimeMask = BIT(2),
	};

	F32  getWaterSurface       ( const Point3F &pos, bool worldSpace = true ) const;

protected:
    // These three methods are the interface for ITickable
    virtual void interpolateTick( F32 delta );
    virtual void processTick();
    virtual void advanceTime( F32 timeDelta );
private:	
     F32 mStartSeconds;          // Time the object was created (server or Ghost)
     S32 mClientSyncTicks;       // How often to sync client time (in ticks)
     F32 mAllowedClientVariance; // Amount client needs to out of sync to resync

     F32 sElapsedSeconds;        // Elapsed time on the server	

     F32 cBaseSeconds;		 // Amount to adjust local time count
     F32 cElapsedSeconds;        // Elapsed time on the client (unadjusted)
// ** KGB end **
[/B]
    fluid               mFluid;
    bool                mTile;
    TextureHandle       mSurfaceTexture;

WaterBlock::WaterBlock()
{
   mNetFlags.set(Ghostable | ScopeAlways);
   mTypeMask = WaterObjectType;
[B]
   // **KGB: Waterblock sync vars
   mStartSeconds = SECONDS;      // Start time of actual object (server or ghost)
   mClientSyncTicks = 100;       // How often to sync client time (in ticks)
   mAllowedClientVariance = .05; // how far out of syc the client needs to be to mess with the
                                 // base rate (resync causes a jitter)    

   sElapsedSeconds = 0.0f;    // Time elapsed on the server

   cBaseSeconds = 0.0f;       // Difference between client start and server start
   cElapsedSeconds = 0.0f;    // Client-side elapsed time counter (mostly redundant with fluid)
   // **KGB end
[/B]
   mObjBox.min.set( 0, 0, 0 );
   mObjBox.max.set( 1, 1, 1 );

addField( "specularColor",    TypeColorF,    Offset( mSpecColor,        WaterBlock ) );
   addField( "specularPower",    TypeF32,       Offset( mSpecPower,        WaterBlock ) );
   endGroup("Misc");
[B]
   // **KGB: Water sync network control params
   addGroup("Sync");
   addField( "syncTicks",        TypeS32,      Offset( mClientSyncTicks,   WaterBlock));
   addField( "allowedVariance",  TypeF32,      Offset(mAllowedClientVariance,WaterBlock));
   endGroup("Sync");
[/B]

U32 WaterBlock::packUpdate( NetConnection* c, U32 mask, BitStream* stream )
{
   U32 retMask = Parent::packUpdate( c, mask, stream );
[B]
   stream->write(sElapsedSeconds);  // KGB - always send this

   if(stream->writeFlag(mask & updateFluidMask))
   {	
[/B]
      stream->writeFlag(mTile);

      stream->writeAffineTransform( mObjToWorld );
    .
    .
    .
[B]
   } // <---- We are adding an if block ... make sure to close it at the end of the statements
[/B]
} <--- And the one to close the function!

void WaterBlock::unpackUpdate( NetConnection* c, BitStream* stream )
{
   Parent::unpackUpdate( c, stream );

   U32 LiquidType;
[B]
   // ***KGB: Water Sync Code      
   stream->read(&sElapsedSeconds);                             // These are the seconds that the server thinks has elapsed
   F32 ckB = mFabs(mFluid.m_ServerSeconds - sElapsedSeconds);   // The difference between client and server

   // Only set the base seconds once unless we are out of sync.  Setting it hard
   // like this can cause a bit of a jump - it could be made better with interpolation.
   //
   if ( cBaseSeconds == 0 || ckB > mAllowedClientVariance ){      
      cBaseSeconds = sElapsedSeconds - (SECONDS - mStartSeconds);;
   }   

   // Check if the rest of the waterBlock needs updating
   if(stream->readFlag())  
   {
[/B]
      mTile = stream->readFlag();

      stream->readAffineTransform( &mObjToWorld );
    .
    . 
    .
    .
      resetWorldBox();
[B]
   } // <---- We are adding an if block ... make sure to close it at the end of the statements
[/B]
} <--- And the one to close the function!

// *****************************************************************************
// KGB - These functions implement the iTickable interface to allow the server to
// sync the wave functions with clients.  A time counter on the server is used to
// calculate values in the fluid.  The server sends the client this elapsed time.
// The client compares this to it's own local waterblock counter to calculate the
// difference between the two.  Since the server always starts before the client,
// adding this differental to the local counter results in a rather close sync
// between server and client.
// 
// The server continues to send out a sync occasionally.  The client will only
// recalculate the differental if it falls outside the defined threshold.  If it
// is too far out of sync the client will adjust the differental (which can cause
// a rendering jump) to keep the rendering and physics in sync.  Some minor
// interpolation when adjusting differental would be the final piece to this.
//
// NOTE: This is currently used to extract surface Z (wave depth) but all
// time-based effects applied to the waterblock should be accessable.  Generally
// they seem to be computed in the runQuadTree function and the formulas can be
// used to compute a single point value (for current time) if taken out of that loop.
// -----------------------------------------------------------------------------

void WaterBlock::interpolateTick( F32 delta ){
  // This page intentionally left blank.
}

// processTick is used to make sure the clients are on the same page
// with the server every so often - but not every tick!
// ------------------------------------------------------------------------------
static S32 ctr=0;
void WaterBlock::processTick(){      
   if( isServerObject() ) {
      if(ctr < mClientSyncTicks)
         ctr++;
      else {
         setMaskBits(updateTimeMask);  
         ctr=0;
      }
   }
}

// Advance time takes over from the fluid's render function in keeping track of time.
// The server keeps local time rolled into the local fluid object for physics and clocking.
// The client keeps track of the ghosted water block's timing syncronized with the server
// and uses this for rendering.
// ------------------------------------------------------------------------------
void WaterBlock::advanceTime( F32 timeDelta ){
   if (isServerObject()){      
      sElapsedSeconds = SECONDS - mStartSeconds;   // This is the # of elapsed seconds since the waterblock started
      mFluid.m_ServerSeconds = sElapsedSeconds;     // This is the reference fluid block
   } else {
      cElapsedSeconds = SECONDS - mStartSeconds;   // Actual time elapsed on client      
      mFluid.m_ServerSeconds = cElapsedSeconds + cBaseSeconds;   // Time adjusted for server offset
   }
}


// Find an actual surface level of the water with the waves included.
//  Not much to explain here - the work goes on in fluidSupport.cc.
// ------------------------------------------------------------------------------
F32 WaterBlock::getWaterSurface(const Point3F &pos, bool worldSpace) const
{
   
   Point3F Pos = pos;   

   if( worldSpace )
   {      
      Pos.x += F32(mTerrainHalfSize);
      Pos.y += F32(mTerrainHalfSize);
   }
   F32 surface = mFluid.surfaceAtXY(Pos.x, Pos.y);
   return( surface  );
}


// *****************************************************************************

// KGB: 
// This is based on the player::pointInWater function.  It gets a list of all water blocks,
// and checks each to see if the object is in the water.  If so, it sets up the various 
// water-related variables like the old waterFind()/updateContainer()  functions.
// 
bool ShapeBase::checkInLiquid()
{
   SimpleQueryList sql;
   if (isServerObject())
      gServerSceneGraph->getWaterObjectList(sql);
   else
      gClientSceneGraph->getWaterObjectList(sql);

   for (U32 i = 0; i < sql.mList.size(); i++)
   {
      WaterBlock* pBlock = dynamic_cast<WaterBlock*>(sql.mList[i]);      
      if (pBlock)
      {
         Point3F pos = getPosition();         

         F32 wS = pBlock->getWaterSurface(pos);
         if (wS > 0.0f) {
            // There is some water here - let's see if we are in it            

            const Box3F& sbox = getWorldBox();   // Object box 
            if (wS < sbox.max.z)                 // If surface is lower than the object top
               mWaterCoverage = mClampF((wS - sbox.min.z) / (sbox.max.z - sbox.min.z),0.0f,1.0f);
            else
               // Otherwise, we're over our head
               mWaterCoverage = 1.0f;

            if (mWaterCoverage >= 0.1f) {
               // If we are deep enough - calculate the density and viscocity
               F32 viscosity = pBlock->getViscosity();
               F32 density = pBlock->getDensity();

               mDrag = mDataBlock->drag * viscosity * mWaterCoverage;
               mBuoyancy = (density / mDataBlock->density) * mWaterCoverage;
            }
            // Look up the liquid's particulars for the object's pleasure.
            mLiquidType = pBlock->getLiquidType();
            mLiquidHeight = pBlock->getSurfaceHeight();
            return true;
         }       
      }
   }
   return false;
}

Quote:Implementing this with shapebase adds functionality to many game objects (vehicle, player, item, staticShape, etc.) making the mWatercoverage variable represent the coverage including wave height.