audioemitter.cc

五行MMORPG引擎系统V1.0

      AssertFatal(smDefaultDescription.mIsLooping, "Doh!");
      if(mDescription.mIsLooping != smDefaultDescription.mIsLooping)
         mDirty.clear(LoopingMask);
      else
      {
         mDirty.clear(IsLooping);
         if(mDescription.mLoopCount == smDefaultDescription.mLoopCount) mDirty.clear(LoopCount);
         if(mDescription.mMinLoopGap == smDefaultDescription.mMinLoopGap) mDirty.clear(MinLoopGap);
         if(mDescription.mMaxLoopGap == smDefaultDescription.mMaxLoopGap) mDirty.clear(MaxLoopGap);
      }
      AssertFatal(smDefaultDescription.mIs3D, "Doh!");
      if(mDescription.mIs3D != smDefaultDescription.mIs3D)
         mDirty.clear(Is3DMask);
      else
      {
         mDirty.clear(Is3D);
         if(mDescription.mReferenceDistance == smDefaultDescription.mReferenceDistance) mDirty.clear(ReferenceDistance);
         if(mDescription.mMaxDistance == smDefaultDescription.mMaxDistance) mDirty.clear(MaxDistance);
         if(mDescription.mConeInsideAngle == smDefaultDescription.mConeInsideAngle) mDirty.clear(ConeInsideAngle);
         if(mDescription.mConeOutsideAngle == smDefaultDescription.mConeOutsideAngle) mDirty.clear(ConeOutsideAngle);
         if(mDescription.mConeOutsideVolume == smDefaultDescription.mConeOutsideVolume) mDirty.clear(ConeOutsideVolume);
         if(mDescription.mConeVector == smDefaultDescription.mConeVector)  mDirty.clear(ConeVector);
      }
      if(mDescription.mType == smDefaultDescription.mType) mDirty.clear(AudioType);
   }

   // volume
   if(stream->writeFlag(mDirty.test(Volume)))
      stream->write(mDescription.mVolume);

   // islooping
   if(stream->writeFlag(mDirty.test(IsLooping)))
   {
      mDescription.mIsLooping ? mDirty.set(LoopingMask) : mDirty.clear(LoopingMask);
      stream->writeFlag(mDescription.mIsLooping);
   }

   // is3d
   if(stream->writeFlag(mDirty.test(Is3D)))
   {
      mDescription.mIs3D ? mDirty.set(Is3DMask) : mDirty.clear(Is3DMask);
      stream->writeFlag(mDescription.mIs3D);
   }

   // ReferenceDistance
   if(stream->writeFlag(mDirty.test(ReferenceDistance)))
      stream->write(mDescription.mReferenceDistance);

   // maxdistance
   if(stream->writeFlag(mDirty.test(MaxDistance)))
      stream->write(mDescription.mMaxDistance);

   // coneinsideangle
   if(stream->writeFlag(mDirty.test(ConeInsideAngle)))
      stream->write(mDescription.mConeInsideAngle);

   // coneoutsideangle
   if(stream->writeFlag(mDirty.test(ConeOutsideAngle)))
      stream->write(mDescription.mConeOutsideAngle);

   // coneoutsidevolume
   if(stream->writeFlag(mDirty.test(ConeOutsideVolume)))
      stream->write(mDescription.mConeOutsideVolume);

   // conevector
   if(stream->writeFlag(mDirty.test(ConeVector)))
   {
      stream->write(mDescription.mConeVector.x);
      stream->write(mDescription.mConeVector.y);
      stream->write(mDescription.mConeVector.z);
   }

   // loopcount
   if(stream->writeFlag(mDirty.test(LoopCount)))
      stream->write(mDescription.mLoopCount);

   // minloopgap
   if(stream->writeFlag(mDirty.test(MinLoopGap)))
      stream->write(mDescription.mMinLoopGap);

   // maxloopgap
   if(stream->writeFlag(mDirty.test(MaxLoopGap)))
      stream->write(mDescription.mMaxLoopGap);

   // audiotype
   if(stream->writeFlag(mDirty.test(AudioType)))
      stream->write(mDescription.mType);

   // outside ambient
   if(stream->writeFlag(mDirty.test(OutsideAmbient)))
      stream->writeFlag(mOutsideAmbient);

   stream->write(mEnableVisualFeedback);

   mDirty.clear();
}

//------------------------------------------------------------------------------
U32 AudioEmitter::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
{
   U32 retMask = Parent::packUpdate(con, mask, stream);
   packData(con, mask, stream);
   return(retMask);
}

bool AudioEmitter::readDirtyFlag(BitStream * stream, U32 mask)
{
   bool flag = stream->readFlag();
   if(flag)
      mDirty.set(mask);
   return(flag);
}

void AudioEmitter::unpackData(NetConnection *, BitStream * stream)
{
   // initial update?
   bool initialUpdate = stream->readFlag();

   // transform
   if(readDirtyFlag(stream, Transform))
   {
      MatrixF mat;
      stream->readAffineTransform(&mat);
      Parent::setTransform(mat);
   }

   // profile
   if(readDirtyFlag(stream, Profile))
      if(stream->readFlag())
         mAudioProfileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
      else
         mAudioProfileId = 0;

   // description
   if(readDirtyFlag(stream, Description))
      if(stream->readFlag())
         mAudioDescriptionId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
      else
         mAudioDescriptionId = 0;

   // filename
   if(readDirtyFlag(stream, Filename))
      mFilename = stream->readSTString();

   // useprofiledescription
   if(readDirtyFlag(stream, UseProfileDescription))
      mUseProfileDescription = stream->readFlag();

   // volume
   if(readDirtyFlag(stream, Volume))
      stream->read(&mDescription.mVolume);

   // islooping
   if(readDirtyFlag(stream, IsLooping))
      mDescription.mIsLooping = stream->readFlag();

   // is3d
   if(readDirtyFlag(stream, Is3D))
      mDescription.mIs3D = stream->readFlag();

   // ReferenceDistance
   if(readDirtyFlag(stream, ReferenceDistance))
      stream->read(&mDescription.mReferenceDistance);

   // maxdistance
   if(readDirtyFlag(stream, MaxDistance))
      stream->read(&mDescription.mMaxDistance);

   // coneinsideangle
   if(readDirtyFlag(stream, ConeInsideAngle))
      stream->read(&mDescription.mConeInsideAngle);

   // coneoutsideangle
   if(readDirtyFlag(stream, ConeOutsideAngle))
      stream->read(&mDescription.mConeOutsideAngle);

   // coneoutsidevolume
   if(readDirtyFlag(stream, ConeOutsideVolume))
      stream->read(&mDescription.mConeOutsideVolume);

   // conevector
   if(readDirtyFlag(stream, ConeVector))
   {
      stream->read(&mDescription.mConeVector.x);
      stream->read(&mDescription.mConeVector.y);
      stream->read(&mDescription.mConeVector.z);
   }

   // loopcount
   if(readDirtyFlag(stream, LoopCount))
      stream->read(&mDescription.mLoopCount);

   // minloopgap
   if(readDirtyFlag(stream, MinLoopGap))
   {
      stream->read(&mDescription.mMinLoopGap);
      if(mDescription.mMinLoopGap < 0)
         mDescription.mMinLoopGap = 0;
   }

   // maxloopgap
   if(readDirtyFlag(stream, MaxLoopGap))
   {
      stream->read(&mDescription.mMaxLoopGap);
      if(mDescription.mMaxLoopGap < 0)
         mDescription.mMaxLoopGap = 0;
   }

   // audiotype
   if(readDirtyFlag(stream, AudioType))
   {
      stream->read(&mDescription.mType);
      if(mDescription.mType >= Audio::NumAudioTypes)
         mDescription.mType = 0;
   }

   // outside ambient
   if(readDirtyFlag(stream, OutsideAmbient))
      mOutsideAmbient = stream->readFlag();

   stream->read(&mEnableVisualFeedback);

   // update the emitter now?
   if(!initialUpdate)
      update();
}

void AudioEmitter::unpackUpdate(NetConnection * con, BitStream * stream)
{
   Parent::unpackUpdate(con, stream);
   unpackData(con, stream);
}

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

   addGroup("Profile");
   addField("profile",              TypeAudioProfilePtr, Offset(mAudioProfile, AudioEmitter));
   addField("useProfileDescription",  TypeBool,          Offset(mUseProfileDescription, AudioEmitter));
   endGroup("Profile");

   addGroup("Media");
   addField("description",          TypeAudioDescriptionPtr,   Offset(mAudioDescription, AudioEmitter));
   addField("fileName",             TypeFilename,              Offset(mFilename, AudioEmitter));
   addField("type",                 TypeS32,                   Offset(mDescription.mType, AudioEmitter));
   endGroup("Media");

   addGroup("Sound");
   addField("volume",               TypeF32,    Offset(mDescription.mVolume, AudioEmitter));
   addField("outsideAmbient",       TypeBool,   Offset(mOutsideAmbient, AudioEmitter));
   addField("ReferenceDistance",    TypeF32,    Offset(mDescription.mReferenceDistance, AudioEmitter));
   addField("maxDistance",          TypeF32,    Offset(mDescription.mMaxDistance, AudioEmitter));
   endGroup("Sound");

   addGroup("Looping");
   addField("isLooping",            TypeBool,   Offset(mDescription.mIsLooping, AudioEmitter));
   addField("loopCount",            TypeS32,    Offset(mDescription.mLoopCount, AudioEmitter));
   addField("minLoopGap",           TypeS32,    Offset(mDescription.mMinLoopGap, AudioEmitter));
   addField("maxLoopGap",           TypeS32,    Offset(mDescription.mMaxLoopGap, AudioEmitter));
   endGroup("Looping");

   addGroup("Advanced");
   addField("enableVisualFeedback", TypeBool,   Offset(mEnableVisualFeedback, AudioEmitter));
   addField("is3D",                 TypeBool,   Offset(mDescription.mIs3D, AudioEmitter));
   addField("coneInsideAngle",      TypeS32,    Offset(mDescription.mConeInsideAngle, AudioEmitter));
   addField("coneOutsideAngle",     TypeS32,    Offset(mDescription.mConeOutsideAngle, AudioEmitter));
   addField("coneOutsideVolume",    TypeF32,    Offset(mDescription.mConeOutsideVolume, AudioEmitter));
   addField("coneVector",           TypePoint3F, Offset(mDescription.mConeVector, AudioEmitter));
   endGroup("Advanced");

   // create the static description
   smDefaultDescription.mVolume = 1.0f;
   smDefaultDescription.mIsLooping = true;
   smDefaultDescription.mIs3D = true;
   smDefaultDescription.mReferenceDistance = 1.0f;
   smDefaultDescription.mMaxDistance = 100.0f;
   smDefaultDescription.mConeInsideAngle = 360;
   smDefaultDescription.mConeOutsideAngle = 360;
   smDefaultDescription.mConeOutsideVolume = 1.0f;
   smDefaultDescription.mConeVector.set(0, 0, 1);
   smDefaultDescription.mLoopCount = -1;
   smDefaultDescription.mMinLoopGap = 0;
   smDefaultDescription.mMaxLoopGap = 0;
   smDefaultDescription.mType = 0;
}

////--------------------------------------------------------------------------
//IMPLEMENT_CO_NETOBJECT_V1(ClientAudioEmitter);
//
//ClientAudioEmitter::ClientAudioEmitter()
//{
//   mNetFlags = 0;
//   mEventCount = 0;
//}
//
//bool ClientAudioEmitter::onAdd()
//{
//   if(!SceneObject::onAdd())
//      return(false);
//
//   // create and send events to all clients
//   bool postedEvent = false;
//   for(NetConnection * conn = NetConnection::getConnectionList(); conn; conn = conn->getNext())
//   {
//      if(!conn->isConnectionToServer())
//      {
//         postedEvent = true;
//         conn->postNetEvent(new AudioEmitterToEvent(this));
//      }
//   }
//
//   return(postedEvent);
//}
//
//void ClientAudioEmitter::initPersistFields()
//{
//   Parent::initPersistFields();
//}
//
////--------------------------------------------------------------------------
//IMPLEMENT_CO_NETEVENT_V1(AudioEmitterToEvent);
//
//AudioEmitterToEvent::AudioEmitterToEvent(ClientAudioEmitter * emitter)
//{
//   mEmitter = emitter;
//   if(bool(mEmitter))
//      mEmitter->mEventCount++;
//}
//
//void AudioEmitterToEvent::notifyDelivered(NetConnection *, bool)
//{
//   if(bool(mEmitter) && mEmitter->mEventCount && (--mEmitter->mEventCount == 0))
//   {
//      mEmitter->deleteObject();
//      mEmitter = 0;
//   }
//}
//
//void AudioEmitterToEvent::write(NetConnection * conn, BitStream * bstream)
//{
//   if(bool(mEmitter))
//      mEmitter->packData(conn, AudioEmitter::InitialUpdateMask, bstream);
//}
//
//void AudioEmitterToEvent::pack(NetConnection * conn, BitStream * bstream)
//{
//   if(bool(mEmitter))
//      mEmitter->packData(conn, AudioEmitter::InitialUpdateMask, bstream);
//}
//
//void AudioEmitterToEvent::unpack(NetConnection * conn, BitStream * bstream)
//{
//   // clients are responsible for deleting these audioemitters!
//   AudioEmitter * emitter = new AudioEmitter(true);
//   emitter->mOwnedByClient = true;
//   emitter->unpackData(conn, bstream);
//   emitter->registerOb