Call for Advanced Camera new features/changes/fixes

void setOrbitChangeZoom(F32 zoom);

void addYaw(F32 yawAdjust);
   void addPitch(F32 pitchAdjust);
   void addZoom(F32 zoomAdjust);

   void setYaw(F32 yaw);
   void setPitch(F32 pitch);
   void setZoom(F32 zoom);

   void updateMovementValues(F32 dt);

Parent::advanceTime(dt);

updateMovementValues(dt);

mathWrite(*bstream, mCurrentOrbitMinMaxDeclination);

bstream->write(mYawAdjust);
   bstream->write(mPitchAdjust);
   bstream->write(mZoomAdjust);

   mYawAdjust   = 0.0f;
   mPitchAdjust = 0.0f;
   mZoomAdjust  = 0.0f;

mathRead(*bstream, &mCurrentOrbitMinMaxDeclination);

bstream->read(&mYawAdjust);
   bstream->read(&mPitchAdjust);
   bstream->read(&mZoomAdjust);

   mYaw   += mYawAdjust;
   mPitch += mPitchAdjust;
   mZoom  += mZoomAdjust;

void AdvancedCamera::updateMovementValues(F32 dt)
{
	
	//Determinate the directions being rotated
	F32 mCamRotateLeft  = getMin(mYaw, 0.0f);
	F32 mCamRotateRight = getMax(mYaw, 0.0f);
	F32 mCamRotateUp    = getMin(mPitch, 0.0f);
	F32 mCamRotateDown  = getMax(mPitch, 0.0f);
	F32 mCamZoomIn      = getMin(mZoom, 0.0f);
	F32 mCamZoomOut     = getMax(mZoom, 0.0f);
	
	if (mCamRotateUp) // top
	{
		F32 newDeclinationAngle;
		// we want to process in degrees during testing for understandability
		// since we use declination, moving the camera "up" is a decrease in angle
		// convert to degrees for now, then apply Change
		newDeclinationAngle = ( mDeclination * 180 / M_PI_F ) + mPitch;
		if (newDeclinationAngle >= mCurrentOrbitMinMaxDeclination.x )	
		{
			mDeclination = newDeclinationAngle * M_PI_F / 180; // converted to radians
		}
		else
		{
			mDeclination = mCurrentOrbitMinMaxDeclination.x * M_PI_F/180;  //set to our MinDeclination define
		}
	}
	if (mCamRotateDown) // bottom
	{
		F32 newDeclinationAngle;
		// we want to process in degrees during testing for understandability
		// since we use declination, moving the camera "down" is an increase in angle
		// convert to degrees for now, then apply Change
		newDeclinationAngle = ( mDeclination * 180 / M_PI_F ) + mPitch;
		if ( newDeclinationAngle <= mCurrentOrbitMinMaxDeclination.y )	
		{
			mDeclination = newDeclinationAngle * M_PI_F / 180; // converted to radians
		}
		else
		{
			mDeclination = mCurrentOrbitMinMaxDeclination.y * M_PI_F/180;  //set to our MinDeclination define
		}			
	}
	if (mCamRotateRight) // right
	{
		F32 newAzimuthAngle;
		// we want to process in degrees during testing for understandability
		// since we use azimuth, moving the camera "right" is an increase in azimuth
		// convert to degrees for now, then apply change
		newAzimuthAngle = (mAzimuth * 180/ M_PI_F) + mYaw;
		if ( newAzimuthAngle < 360 )	// wrap using 360 clock math if needed
		{
			mAzimuth = newAzimuthAngle * M_2PI_F / 360; // converted to radians
		}
		else  // wrap
		{
			mAzimuth = ( newAzimuthAngle - 360 ) *M_2PI_F/360;
		}
	}
	if (mCamRotateLeft) // left
	{
		F32 newAzimuthAngle;
		// we want to process in degrees during testing for understandability
		// since we use azimuth, moving the camera "left" is a decrease in azimuth
		// convert to degrees for now, then apply change
		newAzimuthAngle = (mAzimuth * 180/ M_PI_F) + mYaw;
		if ( newAzimuthAngle > 0 )	// wrap using 360 clock math if needed
		{
			mAzimuth = newAzimuthAngle * M_2PI_F / 360; // converted to radians
		}
		else  // wrap
		{
			mAzimuth = ( newAzimuthAngle + 360 ) *M_2PI_F/360;
		}
	}
	if (mCamZoomIn) // zoom in
	{
		F32 newZoom = mZoomDistance;
		newZoom += mZoom;
		if ( newZoom <= mCurrentOrbitMinMaxZoom.x )
		{
			mZoomDistance = mCurrentOrbitMinMaxZoom.x;
		}
		else
		{
			mZoomDistance = newZoom;
		}	  	
	}
	if (mCamZoomOut) // zoom out
	{
		F32 newZoom = mZoomDistance;
		newZoom += mZoom;
		if ( newZoom >= mCurrentOrbitMinMaxZoom.y )
		{
			mZoomDistance = mCurrentOrbitMinMaxZoom.y;
		}
		else
		{
			mZoomDistance = newZoom;
		}	  	
	}
	
	//Calculate the time-based damping
	F32 subDamp;
	subDamp = mPow(mDamping, dt*10.0f);
	
	//Apply damping
	mYaw   *= subDamp;
	mPitch *= subDamp;
	mZoom  *= subDamp;
   
}

void AdvancedCamera::addYaw(F32 yawAdjust) {
	mYawAdjust = yawAdjust;
}
void AdvancedCamera::addPitch(F32 pitchAdjust) {
	mPitchAdjust = pitchAdjust;
}
void AdvancedCamera::addZoom(F32 zoomAdjust) {
	mZoomAdjust = zoomAdjust;
}

void AdvancedCamera::setYaw(F32 yaw) {
	mYaw = yaw;
}
void AdvancedCamera::setPitch(F32 pitch) {
	mPitch = pitch;
}
void AdvancedCamera::setZoom(F32 zoom) {
	mZoom = zoom;
}

ConsoleMethod( AdvancedCamera, addYaw, void, 3, 3, "(F32 yawAdjust)"
              "Increment the yaw speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 yawAdjust;
   dSscanf( argv[2], "%f", &yawAdjust );
   camObj->addYaw(yawAdjust);
}
ConsoleMethod( AdvancedCamera, addPitch, void, 3, 3, "(F32 pitchAdjust)"
              "Increment the pitch speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 pitchAdjust;
   dSscanf( argv[2], "%f", &pitchAdjust );
   camObj->addPitch(pitchAdjust);
}
ConsoleMethod( AdvancedCamera, addZoom, void, 3, 3, "(F32 zoomAdjust)"
              "Increment the zoom speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 zoomAdjust;
   dSscanf( argv[2], "%f", &zoomAdjust );
   camObj->addZoom(zoomAdjust);
}

ConsoleMethod( AdvancedCamera, setYaw, void, 3, 3, "(F32 yaw)"
              "Set the yaw speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 yaw;
   dSscanf( argv[2], "%f", &yaw );
   camObj->setYaw(yaw);
}
ConsoleMethod( AdvancedCamera, setPitch, void, 3, 3, "(F32 pitch)"
              "Set the pitch speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 pitch;
   dSscanf( argv[2], "%f", &pitch );
   camObj->setPitch(pitch);
}
ConsoleMethod( AdvancedCamera, setZoom, void, 3, 3, "(F32 zoom)"
              "Set the zoom speed for orbit mode.\n\n") {
   AdvancedCamera *camObj = (AdvancedCamera *) object;

   F32 zoom;
   dSscanf( argv[2], "%f", &zoom );
   camObj->setZoom(zoom);
}

//------------------------------------------------------------------------------
// Advanced Camera Movement
//------------------------------------------------------------------------------

function rotateCameraHorizontal(%val)
{
     localClientConnection.advCamera.addYaw(getMouseAdjustAmount(%val)*(-10.0));
}

function rotateCameraVertical(%val)
{
     localClientConnection.advCamera.addPitch(getMouseAdjustAmount(%val)*(-5.0));
}

moveMap.bind( mouse, xaxis, rotateCameraHorizontal);
moveMap.bind( mouse, yaxis, rotateCameraVertical );