shapeimage.cc

五行MMORPG引擎系统V1.0

   addField("mountPoint", TypeS32, Offset(mountPoint,ShapeBaseImageData));
   addField("offset", TypeMatrixPosition, Offset(mountOffset,ShapeBaseImageData));
   addField("rotation", TypeMatrixRotation, Offset(mountOffset,ShapeBaseImageData));
   addField("eyeOffset", TypeMatrixPosition, Offset(eyeOffset,ShapeBaseImageData));
   addField("eyeRotation", TypeMatrixRotation, Offset(eyeOffset,ShapeBaseImageData));
   addField("correctMuzzleVector", TypeBool,  Offset(correctMuzzleVector, ShapeBaseImageData));
   addField("firstPerson", TypeBool, Offset(firstPerson, ShapeBaseImageData));
   addField("mass", TypeF32, Offset(mass, ShapeBaseImageData));

   addField("usesEnergy", TypeBool, Offset(usesEnergy,ShapeBaseImageData));
   addField("minEnergy", TypeF32, Offset(minEnergy,ShapeBaseImageData));
   addField("accuFire", TypeBool, Offset(accuFire, ShapeBaseImageData));

   addField("lightType",   TypeEnum,   Offset(lightType,          ShapeBaseImageData), 1, &gImageLightTypeTable);
   addField("lightColor",  TypeColorF, Offset(lightColor,         ShapeBaseImageData));
   addField("lightTime",   TypeS32,    Offset(lightTime,          ShapeBaseImageData));
   addField("lightRadius", TypeF32,    Offset(lightRadius,        ShapeBaseImageData));

   addField("casing",            TypeDebrisDataPtr,  Offset(casing,              ShapeBaseImageData));
   addField("shellExitDir",      TypePoint3F,        Offset(shellExitDir,        ShapeBaseImageData));
   addField("shellExitVariance", TypeF32,            Offset(shellExitVariance,   ShapeBaseImageData));
   addField("shellVelocity",     TypeF32,            Offset(shellVelocity,       ShapeBaseImageData));

   // State arrays
   addField("stateName", TypeCaseString, Offset(stateName, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnLoaded", TypeString, Offset(stateTransitionLoaded, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnNotLoaded", TypeString, Offset(stateTransitionNotLoaded, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnAmmo", TypeString, Offset(stateTransitionAmmo, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnNoAmmo", TypeString, Offset(stateTransitionNoAmmo, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnTarget", TypeString, Offset(stateTransitionTarget, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnNoTarget", TypeString, Offset(stateTransitionNoTarget, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnWet", TypeString, Offset(stateTransitionWet, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnNotWet", TypeString, Offset(stateTransitionNotWet, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnTriggerUp", TypeString, Offset(stateTransitionTriggerUp, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnTriggerDown", TypeString, Offset(stateTransitionTriggerDown, ShapeBaseImageData), MaxStates);
   addField("stateTransitionOnTimeout", TypeString, Offset(stateTransitionTimeout, ShapeBaseImageData), MaxStates);
   addField("stateTimeoutValue", TypeF32, Offset(stateTimeoutValue, ShapeBaseImageData), MaxStates);
   addField("stateWaitForTimeout", TypeBool, Offset(stateWaitForTimeout, ShapeBaseImageData), MaxStates);
   addField("stateFire", TypeBool, Offset(stateFire, ShapeBaseImageData), MaxStates);
   addField("stateEjectShell", TypeBool, Offset(stateEjectShell, ShapeBaseImageData), MaxStates);
   addField("stateEnergyDrain", TypeF32, Offset(stateEnergyDrain, ShapeBaseImageData), MaxStates);
   addField("stateAllowImageChange", TypeBool, Offset(stateAllowImageChange, ShapeBaseImageData), MaxStates);
   addField("stateDirection", TypeBool, Offset(stateDirection, ShapeBaseImageData), MaxStates);
   addField("stateLoadedFlag", TypeEnum, Offset(stateLoaded, ShapeBaseImageData), MaxStates, &EnumLoadedState);
   addField("stateSpinThread", TypeEnum, Offset(stateSpin, ShapeBaseImageData), MaxStates, &EnumSpinState);
   addField("stateRecoil", TypeEnum, Offset(stateRecoil, ShapeBaseImageData), MaxStates, &EnumRecoilState);
   addField("stateSequence", TypeString, Offset(stateSequence, ShapeBaseImageData), MaxStates);
   addField("stateSequenceRandomFlash", TypeBool, Offset(stateSequenceRandomFlash, ShapeBaseImageData), MaxStates);
   addField("stateSound", TypeAudioProfilePtr, Offset(stateSound, ShapeBaseImageData), MaxStates);
   addField("stateScript", TypeCaseString, Offset(stateScript, ShapeBaseImageData), MaxStates);
   addField("stateEmitter", TypeParticleEmitterDataPtr, Offset(stateEmitter, ShapeBaseImageData), MaxStates);
   addField("stateEmitterTime", TypeF32, Offset(stateEmitterTime, ShapeBaseImageData), MaxStates);
   addField("stateEmitterNode", TypeString, Offset(stateEmitterNode, ShapeBaseImageData), MaxStates);
   addField("stateIgnoreLoadedForReady", TypeBool, Offset(stateIgnoreLoadedForReady, ShapeBaseImageData), MaxStates);
   addField("computeCRC", TypeBool, Offset(computeCRC, ShapeBaseImageData));
}

void ShapeBaseImageData::packData(BitStream* stream)
{
   Parent::packData(stream);

   if(stream->writeFlag(computeCRC))
      stream->write(mCRC);

   stream->writeFlag(emap);

   stream->writeString(shapeName);
   stream->write(mountPoint);
   if (!stream->writeFlag(mountOffset.isIdentity()))
      stream->writeAffineTransform(mountOffset);
   if (!stream->writeFlag(eyeOffset.isIdentity()))
      stream->writeAffineTransform(eyeOffset);

   stream->writeFlag(correctMuzzleVector);
   stream->writeFlag(firstPerson);
   stream->write(mass);
   stream->writeFlag(usesEnergy);
   stream->write(minEnergy);
   stream->writeFlag(hasFlash);
   // Client doesn't need accuFire

   // Write the projectile datablock
   if (stream->writeFlag(projectile))
      stream->writeRangedU32(packed? SimObjectId(projectile):
                             projectile->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);

   stream->writeFlag(cloakable);
   stream->writeRangedU32(lightType, 0, NumLightTypes-1);
   if(lightType != NoLight)
   {
      stream->write(lightRadius);
      stream->write(lightTime);
      stream->writeFloat(lightColor.red, 7);
      stream->writeFloat(lightColor.green, 7);
      stream->writeFloat(lightColor.blue, 7);
      stream->writeFloat(lightColor.alpha, 7);
   }

   mathWrite( *stream, shellExitDir );
   stream->write(shellExitVariance);
   stream->write(shellVelocity);

   if( stream->writeFlag( casing ) )
   {
      stream->writeRangedU32(packed? SimObjectId(casing):
         casing->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
   }

   for (U32 i = 0; i < MaxStates; i++)
      if (stream->writeFlag(state[i].name && state[i].name[0])) {
         StateData& s = state[i];
         // States info not needed on the client:
         //    s.allowImageChange
         //    s.scriptNames
         // Transitions are inc. one to account for -1 values
         stream->writeString(state[i].name);

         stream->writeInt(s.transition.loaded[0]+1,NumStateBits);
         stream->writeInt(s.transition.loaded[1]+1,NumStateBits);
         stream->writeInt(s.transition.ammo[0]+1,NumStateBits);
         stream->writeInt(s.transition.ammo[1]+1,NumStateBits);
         stream->writeInt(s.transition.target[0]+1,NumStateBits);
         stream->writeInt(s.transition.target[1]+1,NumStateBits);
         stream->writeInt(s.transition.wet[0]+1,NumStateBits);
         stream->writeInt(s.transition.wet[1]+1,NumStateBits);
         stream->writeInt(s.transition.trigger[0]+1,NumStateBits);
         stream->writeInt(s.transition.trigger[1]+1,NumStateBits);
         stream->writeInt(s.transition.timeout+1,NumStateBits);

         if(stream->writeFlag(s.timeoutValue != gDefaultStateData.timeoutValue))
            stream->write(s.timeoutValue);

         stream->writeFlag(s.waitForTimeout);
         stream->writeFlag(s.fire);
         stream->writeFlag(s.ejectShell);
         stream->writeFlag(s.scaleAnimation);
         stream->writeFlag(s.direction);
         if(stream->writeFlag(s.energyDrain != gDefaultStateData.energyDrain))
            stream->write(s.energyDrain);

         stream->writeInt(s.loaded,StateData::NumLoadedBits);
         stream->writeInt(s.spin,StateData::NumSpinBits);
         stream->writeInt(s.recoil,StateData::NumRecoilBits);
         if(stream->writeFlag(s.sequence != gDefaultStateData.sequence))
            stream->writeSignedInt(s.sequence, 16);

         if(stream->writeFlag(s.sequenceVis != gDefaultStateData.sequenceVis))
            stream->writeSignedInt(s.sequenceVis,16);
         stream->writeFlag(s.flashSequence);
         stream->writeFlag(s.ignoreLoadedForReady);

         if (stream->writeFlag(s.emitter)) {
            stream->writeRangedU32(packed? SimObjectId(s.emitter):
                                   s.emitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
            stream->write(s.emitterTime);
            stream->write(s.emitterNode);
         }

         if (stream->writeFlag(s.sound))
            stream->writeRangedU32(packed? SimObjectId(s.sound):
                                   s.sound->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
      }
}

void ShapeBaseImageData::unpackData(BitStream* stream)
{
   Parent::unpackData(stream);
   computeCRC = stream->readFlag();
   if(computeCRC)
      stream->read(&mCRC);

   emap = stream->readFlag();

   shapeName = stream->readSTString();
   stream->read(&mountPoint);
   if (stream->readFlag())
      mountOffset.identity();
   else
      stream->readAffineTransform(&mountOffset);
   if (stream->readFlag())
      eyeOffset.identity();
   else
      stream->readAffineTransform(&eyeOffset);

   correctMuzzleVector = stream->readFlag();
   firstPerson = stream->readFlag();
   stream->read(&mass);
   usesEnergy = stream->readFlag();
   stream->read(&minEnergy);
   hasFlash = stream->readFlag();

   projectile = (stream->readFlag() ?
                 (ProjectileData*)stream->readRangedU32(DataBlockObjectIdFirst,
                                                        DataBlockObjectIdLast) : 0);

   cloakable = stream->readFlag();
   lightType = stream->readRangedU32(0, NumLightTypes-1);
   if(lightType != NoLight)
   {
      stream->read(&lightRadius);
      stream->read(&lightTime);
      lightColor.red = stream->readFloat(7);
      lightColor.green = stream->readFloat(7);
      lightColor.blue = stream->readFloat(7);
      lightColor.alpha = stream->readFloat(7);
   }

   mathRead( *stream, &shellExitDir );
   stream->read(&shellExitVariance);
   stream->read(&shellVelocity);

   if(stream->readFlag())
   {
      casingID = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
   }

   for (U32 i = 0; i < MaxStates; i++) {
      if (stream->readFlag()) {
         StateData& s = state[i];
         // States info not needed on the client:
         //    s.allowImageChange
         //    s.scriptNames
         // Transitions are dec. one to restore -1 values
         s.name = stream->readSTString();

         s.transition.loaded[0] = stream->readInt(NumStateBits) - 1;
         s.transition.loaded[1] = stream->readInt(NumStateBits) - 1;
         s.transition.ammo[0] = stream->readInt(NumStateBits) - 1;
         s.transition.ammo[1] = stream->readInt(NumStateBits) - 1;
         s.transition.target[0] = stream->readInt(NumStateBits) - 1;
         s.transition.target[1] = stream->readInt(NumStateBits) - 1;
         s.transition.wet[0] = stream->readInt(NumStateBits) - 1;
         s.transition.wet[1] = stream->readInt(NumStateBits) - 1;
         s.transition.trigger[0] = stream->readInt(NumStateBits) - 1;
         s.transition.trigger[1] = stream->readInt(NumStateBits) - 1;
         s.transition.timeout = stream->readInt(NumStateBits) - 1;
         if(stream->readFlag())
            stream->read(&s.timeoutValue);
         else
            s.timeoutValue = gDefaultStateData.timeoutValue;

         s.waitForTimeout = stream->readFlag();
         s.fire = stream->readFlag();
         s.ejectShell = stream->readFlag();
         s.scaleAnimation = stream->readFlag();
         s.direction = stream->readFlag();
         if(stream->readFlag())
            stream->read(&s.energyDrain);
         else
            s.energyDrain = gDefaultStateData.energyDrain;

         s.loaded = (StateData::LoadedState)stream->readInt(StateData::NumLoadedBits);
         s.spin = (StateData::SpinState)stream->readInt(StateData::NumSpinBits);
         s.recoil = (StateData::RecoilState)stream->readInt(StateData::NumRecoilBits);
         if(stream->readFlag())
            s.sequence = stream->readSignedInt(16);
         else
            s.sequence = gDefaultStateData.sequence;

         if(stream->readFlag())
            s.sequenceVis = stream->readSignedInt(16);
         else
            s.sequenceVis = gDefaultStateData.sequenceVis;

         s.flashSequence = stream->readFlag();
         s.ignoreLoadedForReady = stream->readFlag();

         if (stream->readFlag()) {
            s.emitter = (ParticleEmitterData*) stream->readRangedU32(DataBlockObjectIdFirst,
                                                                     DataBlockObjectIdLast);
            stream->read(&s.emitterTime);
            stream->read(&s.emitterNode);
         }
         else
            s.emitter = 0;
         s.sound = stream->readFlag()? (AudioProfile*) stream->readRangedU32(DataBlockObjectIdFirst,
                                                                             DataBlockObjectIdLast): 0;
      }
   }
   statesLoaded = true;
}

void ShapeBase::MountedImage::registerImageLights(LightManager * lightManager, bool lightingScene, const Point3F &objectPosition, U32 startTime)
{
   if(lightingScene)
      return;

   F32 intensity;

   F32 delta = Sim::getCurrentTime() - startTime;

   switch(dataBlock->lightType)
   {
      case ShapeBaseImageData::ConstantLight:
         intensity = 1.f;
         break;

      case ShapeBaseImageData::PulsingLight:
      {
         intensity = 0.5f + 0.5f * mSin(M_PI * delta / F32(dataBlock->lightTime));
         intensity = 0.15f + intensity * 0.85f;
         break;
      }

      case ShapeBaseImageData::WeaponFireLight:
      {
         if (delta > dataBlock->lightTime)
           return;
         intensity = 1.0 - F32(delta) / F32(dataBlock->lightTime);
         break;
      }

      default:
         intensity = 1.0f;
         return;
   }

   mLight.mColor  = dataBlock->lightColor * intensity;
   mLight.mColor.clamp();
   mLight.mType = LightInfo::Point;
   mLight.mRadius = dataBlock->lightRadius;

	//get the light source position
	Point3F mountOffset;
   dataBlock->mountTransform.getColumn(3, &mountOffset);
	mLight.mPos = objectPosition + mountOffset;

   lightManager->addLight(&mLight);
}

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

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

ShapeBase::MountedImage::MountedImage()
{
   shapeInstance = 0;
   state = 0;
   dataBlock = 0;
   nextImage = InvalidImagePtr;
   animSound = 0;
   delayTime = 0;
   ammo = false;
   target = false;
   triggerDown = false;
   loaded = false;
   fireCount = 0;
   wet = false;
}

ShapeBase::MountedImage::~MountedImage()
{
   delete shapeInstance;

   // stop sound
   if(animLoopingSound && (animSound != NULL_AUDIOHANDLE))
      alxStop(animSound);

   for (S32 i = 0; i < MaxImageEmitters; i++)
      if (bool(emitter[i].emitter))
         emitter[i].emitter->deleteWhenEmpty();
}


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

//----------------------------------------------------------------------------
// Any item with an item image is selectable

bool ShapeBase::mountImage(ShapeBaseImageData* imageData,U32 imageSlot,bool loaded,StringHandle &skinNameHandle)
{
   MountedImage& image = mMountedImageList[imageSlot];
   if (image.dataBlock) {
      if ((image.dataBlock == imageData) && (image.skinNameHandle == skinNameHandle)) {
         // Image already loaded
         image.nextImage = InvalidImagePtr;
         return true;
      }
   }