waterblock.cc

五行MMORPG引擎系统V1.0

   { WaterBlock::eRiverWater,    "RiverWater"    },
   { WaterBlock::eStagnantWater, "StagnantWater" },
   { WaterBlock::eLava,          "Lava"          },
   { WaterBlock::eHotLava,       "HotLava"       },
   { WaterBlock::eCrustyLava,    "CrustyLava"    },
   { WaterBlock::eQuicksand,     "Quicksand"     }
};
static EnumTable gLiquidTypeTable( 8, gLiquidTypeEnums );

//------------------------------------------------------------------------------

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

   addGroup( "Debugging" );
   addField( "UseDepthMask",     TypeBool,      Offset( mUseDepthMap,      WaterBlock ) );
   endGroup( "Debugging" );

   addGroup("Media");
   addField( "surfaceTexture",   TypeFilename,  Offset( mSurfaceName,      WaterBlock ) );
   addField( "ShoreTexture",     TypeFilename,  Offset( mShoreName,        WaterBlock ) );
   addField( "envMapOverTexture",TypeFilename,  Offset( mEnvMapOverName,   WaterBlock ) );
   addField( "envMapUnderTexture",TypeFilename, Offset( mEnvMapUnderName,  WaterBlock ) );
   addField( "submergeTexture",  TypeFilename,  Offset( mSubmergeName,     WaterBlock ), WC_NUM_SUBMERGE_TEX );
   addField( "specularMaskTex",  TypeFilename,  Offset( mSpecMaskName,     WaterBlock ) );
   endGroup("Media");

   addGroup("Fluid");
   addField( "liquidType",       TypeEnum,      Offset( mLiquidType,       WaterBlock ), 1, &gLiquidTypeTable );
   addField( "density",          TypeF32,       Offset( mDensity,          WaterBlock ) );
   addField( "viscosity",        TypeF32,       Offset( mViscosity,        WaterBlock ) );
   endGroup("Fluid");

   addGroup("Surface");
   addField( "waveMagnitude",    TypeF32,       Offset( mWaveMagnitude,    WaterBlock ) );
   addField( "surfaceOpacity",   TypeF32,       Offset( mSurfaceOpacity,   WaterBlock ) );
   addField( "envMapIntensity",  TypeF32,       Offset( mEnvMapIntensity,  WaterBlock ) );
   addField( "TessSurface",      TypeF32,       Offset( mTessellationSurface,   WaterBlock ) );
   addField( "TessShore",        TypeF32,       Offset( mTessellationShore,WaterBlock ) );
   addField( "SurfaceParallax",  TypeF32,       Offset( mSurfaceParallax,  WaterBlock ) );
   endGroup("Surface");

   addGroup("Movement");
   addField( "FlowAngle",        TypeF32,       Offset( mFlowAngle,        WaterBlock ) );
   addField( "FlowRate",         TypeF32,       Offset( mFlowRate,         WaterBlock ) );
   addField( "DistortGridScale", TypeF32,       Offset( mDistortGridScale, WaterBlock ) );
   addField( "DistortMag",       TypeF32,       Offset( mDistortMagnitude, WaterBlock ) );
   addField( "DistortTime",      TypeF32,       Offset( mDistortTime,      WaterBlock ) );
   endGroup("Movement");

   addGroup("Depth Fx");
   addField( "ShoreDepth",       TypeF32,       Offset( mShoreDepth,       WaterBlock ) );
   addField( "DepthGradient",    TypeF32,       Offset( mDepthGradient,    WaterBlock ) );
   addField( "MinAlpha",         TypeF32,       Offset( mMinAlpha,         WaterBlock ) );
   addField( "MaxAlpha",         TypeF32,       Offset( mMaxAlpha,         WaterBlock ) );
   endGroup("Depth Fx");

   addGroup("Misc");
   addField( "tile",             TypeBool,      Offset(mTile,              WaterBlock));
   addField( "audioEnvironment", TypeAudioEnvironmentPtr, Offset( mAudioEnvironment, WaterBlock ) );
   addField( "removeWetEdges",   TypeBool,      Offset( mRemoveWetEdges,   WaterBlock ) );
   addField( "specularColor",    TypeColorF,    Offset( mSpecColor,        WaterBlock ) );
   addField( "specularPower",    TypeF32,       Offset( mSpecPower,        WaterBlock ) );
   endGroup("Misc");
}

//==============================================================================

void WaterBlock::toggleWireFrame()
{
      mFluid.m_ShowWire = !(mFluid.m_ShowWire);
      if( mFluid.m_ShowWire )
         Con::printf( "WaterBlock wire frame ENABLED" );
      else
         Con::printf( "WaterBlock wire frame DISABLED" );
}

ConsoleMethod( WaterBlock, toggleWireFrame, void, 2, 2, "()")
{
   object->toggleWireFrame();
}

//==============================================================================

U32 WaterBlock::packUpdate( NetConnection* c, U32 mask, BitStream* stream )
{
   U32 retMask = Parent::packUpdate( c, mask, stream );

   // No masking in here now.
   // There's not too much data, and it doesn't change during normal game play.

   stream->writeFlag(mTile);

   stream->writeAffineTransform( mObjToWorld );
   mathWrite( *stream, mObjScale );

   stream->writeString(mSurfaceName);
   stream->writeString(mSpecMaskName);
   stream->writeString(mEnvMapOverName);
   stream->writeString(mEnvMapUnderName);
   stream->writeString(mShoreName);

   for( int i=0; i<WC_NUM_SUBMERGE_TEX; i++ )
   {
      stream->writeString( mSubmergeName[i] );
   }

   stream->write( (S32)mLiquidType );
   stream->write( mDensity         );
   stream->write( mViscosity       );
   stream->write( mWaveMagnitude   );
   stream->write( mSurfaceOpacity  );
   stream->write( mEnvMapIntensity );
   stream->write( mRemoveWetEdges  );

   // audio environment:
   if(stream->writeFlag(mAudioEnvironment))
      stream->writeRangedU32(mAudioEnvironment->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);

   // MM: Write Depth-Map Controls.
   stream->write( mUseDepthMap );
   stream->write( mShoreDepth );
   stream->write( mMinAlpha );
   stream->write( mMaxAlpha );
   stream->write( mDepthGradient );
   stream->write( mTessellationSurface );
   stream->write( mTessellationShore );
   stream->write( mSurfaceParallax );
   stream->write( mFlowAngle );
   stream->write( mFlowRate );
   stream->write( mDistortGridScale );
   stream->write( mDistortMagnitude );
   stream->write( mDistortTime );


   stream->write( mSpecColor );
   stream->write( mSpecPower );

   stream->writeFlag(mEditorApplied);
   mEditorApplied = false;

   return( retMask );
}

//==============================================================================

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

   U32 LiquidType;

   // No masking in here now.
   // There's not too much data, and it doesn't change during normal game play.

   mTile = stream->readFlag();

   stream->readAffineTransform( &mObjToWorld );
   mathRead( *stream, &mObjScale );

   mSurfaceName      = stream->readSTString();
   mSpecMaskName     = stream->readSTString();
   mEnvMapOverName   = stream->readSTString();
   mEnvMapUnderName  = stream->readSTString();
   mShoreName        = stream->readSTString();

   for( int i=0; i<WC_NUM_SUBMERGE_TEX; i++ )
   {
      mSubmergeName[i] = stream->readSTString();
   }

    mSurfaceTexture     = TextureHandle( mSurfaceName,      MeshTexture );
    mSpecMaskTex        = TextureHandle( mSpecMaskName,     MeshTexture );
    mEnvMapOverTexture  = TextureHandle( mEnvMapOverName,   MeshTexture );
    mEnvMapUnderTexture = TextureHandle( mEnvMapUnderName,  MeshTexture );
    mShoreTexture       = TextureHandle( mShoreName,        MeshTexture );

    mFluid.SetTextures( mSurfaceTexture,
                        mEnvMapOverTexture,
                        mEnvMapUnderTexture,
                        mShoreTexture,
                        mDepthTexture,
                        mShoreDepthTexture,
                        mSpecMaskTex);

    for( int i=0; i<WC_NUM_SUBMERGE_TEX; i++ )
    {
       if( mSubmergeName[i] && mSubmergeName[i][0] )
       {
          mLocalSubmergeTexture[i] = TextureHandle( mSubmergeName[i], MeshTexture );
          mSubmergeTexture[i] = mLocalSubmergeTexture[i];
       }
    }

   stream->read( &LiquidType       );
   stream->read( &mDensity         );
   stream->read( &mViscosity       );
   stream->read( &mWaveMagnitude   );
   stream->read( &mSurfaceOpacity  );
   stream->read( &mEnvMapIntensity );
   stream->read( &mRemoveWetEdges  );

   // audio environment:
   if(stream->readFlag())
   {
      U32 profileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
      mAudioEnvironment = dynamic_cast<AudioEnvironment*>(Sim::findObject(profileId));
   }
   else
      mAudioEnvironment = 0;

   mLiquidType = (EWaterType)LiquidType;

   stream->read( &mUseDepthMap );
   stream->read( &mShoreDepth );
   stream->read( &mMinAlpha );
   stream->read( &mMaxAlpha );
   stream->read( &mDepthGradient );
   stream->read( &mTessellationSurface );
   stream->read( &mTessellationShore );
   stream->read( &mSurfaceParallax );
   stream->read( &mFlowAngle );
   stream->read( &mFlowRate );
   stream->read( &mDistortGridScale );
   stream->read( &mDistortMagnitude );
   stream->read( &mDistortTime );
   stream->read( &mSpecColor );
   stream->read( &mSpecPower );

   if (stream->readFlag())
      CalculateDepthMaps();

   // Keep this *after* depth-map reads.
   UpdateFluidRegion();

   if( !isProperlyAdded() )
      return;

   resetWorldBox();
}

//==============================================================================
// This method can take a point in world space, or water block space. The default
// assumes pos is in world space, and therefore must transform it to waterblock
// space.

bool WaterBlock::isPointSubmerged(const Point3F &pos, bool worldSpace) const
{
   return( isPointSubmergedSimple( pos, worldSpace ) );
}

//==============================================================================

bool WaterBlock::isPointSubmergedSimple(const Point3F &pos, bool worldSpace) const
{
   Point3F Pos = pos;

   if( Pos.z > mSurfaceZ )
      return( false );

   if( worldSpace )
   {
      Pos.x += 1024.0f;
      Pos.y += 1024.0f;
   }

   return( mFluid.IsFluidAtXY( Pos.x, Pos.y ) );
}

//==============================================================================

bool WaterBlock::castRay( const Point3F& start, const Point3F& end, RayInfo* info )
{
   F32 t, x, y, X, Y;
   Point3F Pos;

   //
   // Looks like the incoming points are in parametric object space.  Great.
   //

   // The water surface is 1.0.  Bail if the ray does not cross the surface.

   if( (start.z > 1.0f) && (end.z > 1.0f) )        return( false );
   if( (start.z < 1.0f) && (end.z < 1.0f) )        return( false );

   // The ray crosses the surface plane.  Find out where.

   t = (start.z - 1.0f) / (start.z - end.z);
   x = start.x + (end.x - start.x) * t;
   y = start.y + (end.y - start.y) * t;

   Pos = mObjToWorld.getPosition();

   X = (x * mObjScale.x) + Pos.x + 1024.0f;
   Y = (y * mObjScale.y) + Pos.y + 1024.0f;

   if( mFluid.IsFluidAtXY( X, Y ) )
   {
      info->t = t;
      info->point.x  = x;
      info->point.y  = y;
      info->point.z  = 1.0f;
      info->normal.x = 0.0f;
      info->normal.y = 0.0f;
      info->normal.z = 1.0f;
      info->object   = this;
      info->material = 0;
      return( true );
   }

   // Hmm.  Guess we missed!
   return( false );
}

//==============================================================================

bool WaterBlock::isWater( U32 liquidType )
{
   EWaterType wType = EWaterType( liquidType );
   return( wType == eWater      ||
           wType == eOceanWater ||
           wType == eRiverWater ||
           wType == eStagnantWater );
}

//==============================================================================

bool WaterBlock::isLava( U32 liquidType )
{
   EWaterType wType = EWaterType( liquidType );
   return( wType == eLava    ||
           wType == eHotLava ||
           wType == eCrustyLava );
}

//==============================================================================

bool WaterBlock::isQuicksand( U32 liquidType )
{
   EWaterType wType = EWaterType( liquidType );
   return( wType == eQuicksand );
}

//==============================================================================