fxsunlight.cc

五行MMORPG引擎系统V1.0

ConsoleMethod(fxSunLight, setSizeKeys, void, 3, 3, "(keys)")
{
   object->setSizeKeys(argv[2]);
}

ConsoleMethod(fxSunLight, setAzimuthKeys, void, 3, 3, "(keys)")
{
   object->setAzimuthKeys(argv[2]);
}

ConsoleMethod(fxSunLight, setElevationKeys, void, 3, 3, "(keys)")
{
   object->setElevationKeys(argv[2]);
}

// ********************************************************************************
// Animation Times.
// ********************************************************************************

ConsoleMethod(fxSunLight, setColourTime, void, 3, 3, "(time)")
{
   object->setColourTime(dAtof(argv[2]));
}

ConsoleMethod(fxSunLight, setBrightnessTime, void, 3, 3, "(time)")
{
   object->setBrightnessTime(dAtof(argv[2]));
}

ConsoleMethod(fxSunLight, setRotationTime, void, 3, 3, "(time)")
{
   object->setRotationTime(dAtof(argv[2]));
}

ConsoleMethod(fxSunLight, setSizeTime, void, 3, 3, "(time)")
{
   object->setSizeTime(dAtof(argv[2]));
}

ConsoleMethod(fxSunLight, setAzimuthTime, void, 3, 3, "(time)")
{
   object->setAzimuthTime(dAtof(argv[2]));
}

ConsoleMethod(fxSunLight, setElevationTime, void, 3, 3, "(time)")
{
   object->setElevationTime(dAtof(argv[2]));
}

// ********************************************************************************
// Misc.
// ********************************************************************************

ConsoleMethod(fxSunLight, reset, void, 2, 2, "()")
{
   object->reset();
}

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

void fxSunLight::AnimateSun(F32 ElapsedTime)
{
   // ********************************************
   // Calculate Colour.
   // ********************************************

   // Animating Colour?
   if (mUseColour)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mColourElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mColourElapsedTime > mColourTime) { mColourElapsedTime -= mColourTime; };

      // Scale Time.
      F32 ScaledTime = mColourElapsedTime * mColourTimeScale;

      // Calculate Position From.
      PosFrom = (U32)(mFloor(ScaledTime));

      // Are we Lerping?
      if (mLerpColour)
      {
         // Yes, so calculate Position To.
         PosTo = (U32)(mCeil(ScaledTime));

         // Calculate Lerp Factor.
         LerpFactor = ScaledTime - PosFrom;
      }
      else
      {
         // No, so clamp Position.
         PosTo = PosFrom;

         // Clamp lerp factor.
         LerpFactor = 0.0f;
      }

      // Reset RGB Set Flag.
      bool RedSet = false;
      bool GreenSet = false;
      bool BlueSet = false;

      // ********************************************
      // Red<GREEN,BLUE> Keys.
      // ********************************************
      if (mRedKeysLength)
      {
         // Are we using single-channel colour keys?
         if (mSingleColourKeys)
         {
            // Yes, so calculate rgb from red keys.
				mAnimationColour.red	= GetLerpKey(mRedKeys, PosFrom, PosTo, mMinColour.red, mMaxColour.red, LerpFactor);
				mAnimationColour.green	= GetLerpKey(mRedKeys, PosFrom, PosTo, mMinColour.green, mMaxColour.green, LerpFactor);
				mAnimationColour.blue	= GetLerpKey(mRedKeys, PosFrom, PosTo, mMinColour.blue, mMaxColour.blue, LerpFactor);

            // Flag RGB Set.
            RedSet = GreenSet = BlueSet = true;
         }
         else
         {
            // No, so calculate Red only.
            mAnimationColour.red = GetLerpKey(mRedKeys, PosFrom, PosTo, mMinColour.red, mMaxColour.red, LerpFactor);

            // Flag Red Set.
            RedSet = true;
         }
      }

      // ********************************************
      // Green Keys.
      // ********************************************
      if (!mSingleColourKeys && mGreenKeysLength)
      {
         // Calculate Green.
         mAnimationColour.green = GetLerpKey(mGreenKeys, PosFrom, PosTo, mMinColour.green, mMaxColour.green, LerpFactor);

         // Flag Green Set.
         GreenSet = true;
      }

      // ********************************************
      // Blue Keys.
      // ********************************************
      if (!mSingleColourKeys && mBlueKeysLength)
      {
         // Calculate Blue.
         mAnimationColour.blue = GetLerpKey(mGreenKeys, PosFrom, PosTo, mMinColour.blue, mMaxColour.blue, LerpFactor);

         // Flag Blue Set.
         BlueSet = true;
      }

      // Set to static colour if we failed to set RGB correctly.
      if (!RedSet || !GreenSet || !BlueSet) mAnimationColour = mFlareColour;
   }
   else
   {
      // No, so set to static Colour.
      mAnimationColour = mFlareColour;
   }


   // ********************************************
   // Calculate Brightness.
   // ********************************************

   // Animating Brightness?
   if (mUseBrightness)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mBrightnessElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mBrightnessElapsedTime > mBrightnessTime) { mBrightnessElapsedTime -= mBrightnessTime; };

      // Scale Time.
      F32 ScaledTime = mBrightnessElapsedTime * mBrightnessTimeScale;

      // Calculate Position From.
      PosFrom = (U32)(mFloor(ScaledTime));

      // Are we Lerping?
      if (mLerpBrightness)
      {
         // Yes, so calculate Position To.
         PosTo = (U32)(mCeil(ScaledTime));

         // Calculate Lerp Factor.
         LerpFactor = ScaledTime - PosFrom;
      }
      else
      {
         // No, so clamp Position.
         PosTo = PosFrom;

         // Clamp lerp factor.
         LerpFactor = 0.0f;
      }

      // ********************************************
      // Brightness Keys.
      // ********************************************
      if (mBrightnessKeysLength)
      {
         // No, so calculate Brightness.
         mAnimationBrightness = GetLerpKey(mBrightnessKeys, PosFrom, PosTo, mMinBrightness, mMaxBrightness, LerpFactor);
      }
      else
      {
         // Set to static brightness if we failed to set Brightness correctly.
         mAnimationBrightness = mFlareBrightness;
      }
   }
   else
   {
      // No, so set to static Brightness.
      mAnimationBrightness = mFlareBrightness;
   }

   // Adjust Colour by Brightness.
   mAnimationColour *= ColorF( mAnimationBrightness, mAnimationBrightness, mAnimationBrightness );


   // ********************************************
   // Calculate Rotation.
   // ********************************************

   // Animating Rotation?
   if (mUseRotation)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mRotationElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mRotationElapsedTime > mRotationTime) { mRotationElapsedTime -= mRotationTime; };

      // Scale Time.
      F32 ScaledTime = mRotationElapsedTime * mRotationTimeScale;

      // Calculate Position From.
      PosFrom = (U32)(mFloor(ScaledTime));

      // Are we Lerping?
      if (mLerpRotation)
      {
         // Yes, so calculate Position To.
         PosTo = (U32)(mCeil(ScaledTime));

         // Calculate Lerp Factor.
         LerpFactor = ScaledTime - PosFrom;
      }
      else
      {
         // No, so clamp Position.
         PosTo = PosFrom;

         // Clamp lerp factor.
         LerpFactor = 0.0f;
      }

      // ********************************************
      // Rotation Keys.
      // ********************************************
      if (mRotationKeysLength)
      {
         // No, so calculate Rotation.
         mAnimationRotation = GetLerpKey(mRotationKeys, PosFrom, PosTo, mMinRotation, mMaxRotation, LerpFactor);
      }
      else
      {
         // Set to static Rotation if we failed to set Rotation correctly.
         mAnimationRotation = mMinRotation;
      }
   }
   else
   {
      // No, so set to static Rotation.
      mAnimationRotation = 0;
   }


   // ********************************************
   // Calculate Size.
   // ********************************************

   // Animating Size?
   if (mUseSize)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mSizeElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mSizeElapsedTime > mSizeTime) { mSizeElapsedTime -= mSizeTime; };

      // Scale Time.
      F32 ScaledTime = mSizeElapsedTime * mSizeTimeScale;

      // Calculate Position From.
      PosFrom = (U32)(mFloor(ScaledTime));

      // Are we Lerping?
      if (mLerpSize)
      {
         // Yes, so calculate Position To.
         PosTo = (U32)(mCeil(ScaledTime));

         // Calculate Lerp Factor.
         LerpFactor = ScaledTime - PosFrom;
      }
      else
      {
         // No, so clamp Position.
         PosTo = PosFrom;

         // Clamp lerp factor.
         LerpFactor = 0.0f;
      }

      // ********************************************
      // Size Keys.
      // ********************************************
      if (mSizeKeysLength)
      {
         // No, so calculate Size.
         mAnimationSize = GetLerpKey(mSizeKeys, PosFrom, PosTo, mMinSize, mMaxSize, LerpFactor);
      }
      else
      {
         // Set to static Size if we failed to set Size correctly.
         mAnimationSize = mMinSize;
      }
   }
   else
   {
      // No, so set to static Size.
      mAnimationSize = mFlareSize;
   }


   // ********************************************
   // Calculate Azimuth.
   // ********************************************

   // Animating Size?
   if (mUseAzimuth)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mAzimuthElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mAzimuthElapsedTime > mAzimuthTime) { mAzimuthElapsedTime -= mAzimuthTime; };

      // Scale Time.
      F32 ScaledTime = mAzimuthElapsedTime * mAzimuthTimeScale;

      // Calculate Position From.
      PosFrom = (U32)(mFloor(ScaledTime));

      // Are we Lerping?
      if (mLerpAzimuth)
      {
         // Yes, so calculate Position To.
         PosTo = (U32)(mCeil(ScaledTime));

         // Calculate Lerp Factor.
         LerpFactor = ScaledTime - PosFrom;
      }
      else
      {
         // No, so clamp Position.
         PosTo = PosFrom;

         // Clamp lerp factor.
         LerpFactor = 0.0f;
      }

      // ********************************************
      // Azimuth Keys.
      // ********************************************
      if (mAzimuthKeysLength)
      {
         // No, so calculate Size.
         mAnimationAzimuth = GetLerpKey(mAzimuthKeys, PosFrom, PosTo, mMinAzimuth, mMaxAzimuth, LerpFactor);
      }
      else
      {
         // Set to static Azimuth if we failed to set Size correctly.
         mAnimationAzimuth = mMinAzimuth;
      }
   }
   else
   {
      // No, so set to static Azimuth.
      mAnimationAzimuth = 0;
   }


   // ********************************************
   // Calculate Elevation.
   // ********************************************

   // Animating Size?
   if (mUseElevation)
   {
      U32 PosFrom;
      U32 PosTo;
		F32	LerpFactor;

      // Yes, so adjust time-base.
      mElevationElapsedTime += ElapsedTime;

      // Adjust to Bounds.
      while (mElevationElapsedTime > mElevationTime) { mElevationElapsedTime -= mElevationTime; };

      // Scale Time.
      F32 ScaledTime = mElevationElapsedTime * mElevationTimeScale;

      // Calculate Position From.