audioemitter.cc

五行MMORPG引擎系统V1.0

      return(false);

   setLastState(state, stateKey);
   if(gEditingMission && state->isObjectRendered(this))
   {
      SceneRenderImage * image = new SceneRenderImage;
      image->obj = this;
      state->insertRenderImage(image);
   }
   return(false);
}

void AudioEmitter::render3DVisualFeedBack(void)
{
    const float RADINC  = 30.f;
    const float SWPINC  = 10.f;
    const float FULLPNT = 6.f;

    float OldPointSize  = 1.f;
    float OldLineWidth  = 1.f;
    float OldColor[4]   = {1.f,1.f,1.f,1.f};

    float fPointIncrement = (mDescription.mMaxDistance/10.f);

    //
    // Startup Ops
    //
    glGetFloatv(GL_POINT_SIZE,      &OldPointSize);
    glGetFloatv(GL_LINE_WIDTH,      &OldLineWidth);
    glGetFloatv(GL_CURRENT_COLOR,   &OldColor[0]);
    glPushMatrix();
    glRotatef(mAnimRotAngle+=1.f,0.f,1.f,0.f);
    if(mAnimRotAngle >= 360.f) mAnimRotAngle = 0.f;
    //
    // RenderOps
    //
    // 0. INNER CONE
    {
        glPointSize(FULLPNT);

        // Radial Sweep - Sweeps about radius of current angular sweep angle
        for(float fRadAngle=0.f; fRadAngle < 360.f; fRadAngle += RADINC) {

            bool  bDone         = false;
            float fCurAngle     = mDescription.mConeInsideAngle/2;
            float fStopAngle    = 0;

            // Angular Sweep - Sweeps from outer angle of INNER CONE to 0 DEG
            while(!bDone)
            {
                glPushMatrix();
                glRotatef(fRadAngle, 0.f, 1.f, 0.f);
                glRotatef(fCurAngle, 1.f, 0.f, 0.f);

                glBegin(GL_POINTS);
                glColor4f(1.f,0.0f,0.0f,1.f);

                for(float fY=0.f;
                fY <= mDescription.mMaxDistance;
                fY += fPointIncrement) {
                    if(fY > mDescription.mReferenceDistance) {
                        glColor4f(1.f - (1.f - (mDescription.mReferenceDistance/fY)), 0.f,0.f,1.f);
                    }
                    glVertex3f(0.f, fY, 0.f);
                }

                glEnd();

                glPopMatrix();

                if(fStopAngle == fCurAngle) bDone = true;

                fCurAngle -= SWPINC;
                if(fStopAngle > fCurAngle) fCurAngle = fStopAngle;
            }
        }
    }
    // Outer Cone and Outside volume only get rendered if mConeOutsideVolume > 0
    if(mDescription.mConeOutsideVolume) {
        // 1. OUTER CONE
        {
            glPointSize(FULLPNT-1);

            // Radial Sweep - Sweeps about radius of current angular sweep angle
            for(float fRadAngle=0.f; fRadAngle < 360.f; fRadAngle += RADINC) {

                bool  bDone         = false;
                float fCurAngle     = mDescription.mConeOutsideAngle/2;
                float fStopAngle    = mDescription.mConeInsideAngle/2;

                // Angular Sweep - Sweeps from outer angle of INNER CONE to 0 DEG
                while(!bDone)
                {

                    glPushMatrix();
                    glRotatef(fRadAngle, 0.f, 1.f, 0.f);
                    glRotatef(fCurAngle, 1.f, 0.f, 0.f);

                    glBegin(GL_POINTS);
                    glColor4f(1.f,
                        0.0f,
                        1.0f,
                        1.f);

                    for(float fY=0.f;
                    fY <= mDescription.mMaxDistance;
                    fY += fPointIncrement) {
                        glVertex3f(0.f, fY, 0.f);
                    }

                    glEnd();

                    glPopMatrix();

                    if(fStopAngle == fCurAngle) bDone = true;

                    fCurAngle -= SWPINC*2.f;
                    if(fStopAngle > fCurAngle) fCurAngle = fStopAngle;
                }
            }

        }
        // 1. OUTSIDE VOLUME
        {
            glPointSize(FULLPNT-2);

            // Radial Sweep - Sweeps about radius of current angular sweep angle
            for(float fRadAngle=0.f; fRadAngle < 360.f; fRadAngle += RADINC) {

                bool  bDone         = false;
                float fCurAngle     = 180;
                float fStopAngle    = mDescription.mConeOutsideAngle/2;

                // Angular Sweep - Sweeps from outer angle of INNER CONE to 0 DEG
                while(!bDone)
                {

                    glPushMatrix();
                    glRotatef(fRadAngle, 0.f, 1.f, 0.f);
                    glRotatef(fCurAngle, 1.f, 0.f, 0.f);

                    glBegin(GL_POINTS);
                    glColor4f(0.f, 0.0f, 1.0f,1.f);

                    for(float fY=0.f;
                    fY <= mDescription.mMaxDistance;
                    fY += fPointIncrement) {
                        glVertex3f(0.f, fY, 0.f);
                    }

                    glEnd();

                    glPopMatrix();

                    if(fStopAngle == fCurAngle) bDone = true;

                    fCurAngle -= SWPINC*2.f;
                    if(fStopAngle > fCurAngle) fCurAngle = fStopAngle;
                }
            }

        }
    }
    //
    // Cleanup Ops
    //
    glPopMatrix();
    glColor4f(OldColor[0],OldColor[1],OldColor[2],OldColor[3]);
    glLineWidth(OldLineWidth);
    glPointSize(OldPointSize);
}

void AudioEmitter::renderObject(SceneState*, SceneRenderImage*)
{
   glPushMatrix();
   dglMultMatrix(&mObjToWorld);
   glScalef(mObjScale.x, mObjScale.y, mObjScale.z);

   glDisable(GL_CULL_FACE);
   Point3F size(1.f, 1.f, 1.f);


   // draw the cube
   // Check to see if it is playing (green == playing; black == off)
   glColor4f(0.f,0.f,0.f,1.f);
   U32 source = alxFindSource(mAudioHandle);
   if(source != -1)
   {

       ALint state = AL_STOPPED;
       alGetSourcei(source, AL_SOURCE_STATE, &state);
       if(state == AL_PLAYING)
       {
           Point3F listener;
           alGetListener3f(AL_POSITION, &listener.x, &listener.y, &listener.z);

           Point3F pos;
           alGetSourcefv(source, AL_POSITION, (F32*)pos);

           F32 dist = 0.f;
           alGetSourcef(source, AL_MAX_DISTANCE, &dist);

           pos -= listener;
           dist -= pos.len();

           if (dist > 0.f)
           {
               glColor4f(0.2f,1.f,0.2f,1.f);
           }
       }
   }

   for(int i = 0; i < 6; i++)
   {
       glBegin(GL_QUADS);
       for(int vert = 0; vert < 4; vert++)
       {
           int idx = cubeFaces[i][vert];
           glVertex3f(cubePoints[idx].x * size.x, cubePoints[idx].y * size.y, cubePoints[idx].z * size.z);
       }
       glEnd();
   }

   // Only render 3D visuals if in 3D Audio Mode
   if(mDescription.mIs3D && ( mEnableVisualFeedback || isSelected() ) ) render3DVisualFeedBack();

   glPopMatrix();
}

//------------------------------------------------------------------------------
namespace {
   static AudioProfile * saveAudioProfile;
   static AudioDescription * saveAudioDescription;
   static StringTableEntry saveFilename;
   static bool saveUseProfileDescription;
   static Audio::Description saveDescription;
   static Point3F savePos;
   static bool saveOutsideAmbient;
}

void AudioEmitter::inspectPreApply()
{
#ifndef TGE_RPGCLIENT2 /// TGE_RPGIsClientObject
   if(isClientObject())
      return;
#endif

   Parent::inspectPreApply();

   mObjToWorld.getColumn(3, &savePos);
   saveAudioProfile = mAudioProfile;
   saveAudioDescription = mAudioDescription;
   saveFilename = mFilename;
   saveUseProfileDescription = mUseProfileDescription;
   saveDescription = mDescription;
   saveOutsideAmbient = mOutsideAmbient;
}

void AudioEmitter::inspectPostApply()
{
#ifndef TGE_RPGCLIENT2 /// TGE_RPGIsClientObject
   if(isClientObject())
      return;
#endif

   Parent::inspectPostApply();

   Point3F pos;
   mObjToWorld.getColumn(3, &pos);

   // set some dirty flags
   mDirty.clear();
   mDirty.set((savePos != pos) ? Transform : 0);
   mDirty.set((saveAudioProfile != mAudioProfile) ? Profile : 0);
   mDirty.set((saveAudioDescription != mAudioDescription) ? Description : 0);
   mDirty.set((saveFilename != mFilename) ? Filename : 0);
   mDirty.set((saveUseProfileDescription != mUseProfileDescription) ? UseProfileDescription : 0);
   mDirty.set((saveDescription.mVolume != mDescription.mVolume) ? Volume : 0);
   mDirty.set((saveDescription.mIsLooping != mDescription.mIsLooping) ? IsLooping : 0);
   mDirty.set((saveDescription.mIs3D != mDescription.mIs3D) ? Is3D : 0);
   mDirty.set((saveDescription.mReferenceDistance != mDescription.mReferenceDistance) ? ReferenceDistance : 0);
   mDirty.set((saveDescription.mMaxDistance != mDescription.mMaxDistance) ? MaxDistance : 0);
   mDirty.set((saveDescription.mConeInsideAngle != mDescription.mConeInsideAngle) ? ConeInsideAngle : 0);
   mDirty.set((saveDescription.mConeOutsideAngle != mDescription.mConeOutsideAngle) ? ConeOutsideAngle : 0);
   mDirty.set((saveDescription.mConeOutsideVolume != mDescription.mConeOutsideVolume) ? ConeOutsideVolume : 0);
   mDirty.set((saveDescription.mConeVector != mDescription.mConeVector) ? ConeVector : 0);
   mDirty.set((saveDescription.mLoopCount != mDescription.mLoopCount) ? LoopCount : 0);
   mDirty.set((saveDescription.mMinLoopGap != mDescription.mMinLoopGap) ? MinLoopGap : 0);
   mDirty.set((saveDescription.mMaxLoopGap != mDescription.mMaxLoopGap) ? MaxLoopGap : 0);
   mDirty.set((saveDescription.mType != mDescription.mType) ? AudioType : 0);
   mDirty.set((saveOutsideAmbient != mOutsideAmbient) ? OutsideAmbient : 0);

   if(mDirty)
      setMaskBits(DirtyUpdateMask);
}

void AudioEmitter::packData(NetConnection *, U32 mask, BitStream * stream)
{
   // initial update
   if(stream->writeFlag(mask & InitialUpdateMask))
   {
      mask |= TransformUpdateMask;
      mDirty = AllDirtyMask;

      // see if can remove some items from initial update: description checked below
      if(!mAudioProfile)
         mDirty.clear(Profile);
      if(!mAudioDescription)
         mDirty.clear(Description);
      if(!mFilename || !mFilename[0])
         mDirty.clear(Filename);
      if(!mUseProfileDescription)
         mDirty.clear(UseProfileDescription);
      if(mOutsideAmbient)
         mDirty.clear(OutsideAmbient);
   }

   // transform
   if(stream->writeFlag(mask & TransformUpdateMask))
      stream->writeAffineTransform(mObjToWorld);

   // profile
   if(stream->writeFlag(mDirty.test(Profile)))
      if(stream->writeFlag(mAudioProfile))
         stream->writeRangedU32(mAudioProfile->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);

   // description
   if(stream->writeFlag(mDirty.test(Description)))
      if(stream->writeFlag(mAudioDescription))
         stream->writeRangedU32(mAudioDescription->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);

   // filename
   if(stream->writeFlag(mDirty.test(Filename)))
      stream->writeString(mFilename);

   // useprofiledescription
   if(stream->writeFlag(mDirty.test(UseProfileDescription)))
   {
      if(mUseProfileDescription)
      {
         if(!mAudioProfile)
            mUseProfileDescription = false;
         else
            mDirty.clear(UseProfileDescriptionMask);
      }

      if(!mUseProfileDescription)
         mDirty.set(UseProfileDescriptionMask);

      stream->writeFlag(mUseProfileDescription);
   }

   if(mAudioDescription && !mUseProfileDescription)
      mDirty.clear(UseProfileDescriptionMask);

   // check initial update against the default description
   if((mask & InitialUpdateMask) && !mUseProfileDescription)
   {
      if(mDescription.mVolume == smDefaultDescription.mVolume) mDirty.clear(Volume);