自学教程：C++ FixMul函数代码示例

//cycle the flashing light for when mine destroyedvoid FlashFrame (void){	static fixang flash_ang = 0;if (!(gameData.reactor.bDestroyed || gameStates.gameplay.seismic.nMagnitude)) {	gameStates.render.nFlashScale = I2X (1);	return;	}if (gameStates.app.bEndLevelSequence)	return;if (paletteManager.BlueEffect () > 10)		//whiting out	return;//	flash_ang += FixMul(FLASH_CYCLE_RATE, gameData.time.xFrame);if (gameStates.gameplay.seismic.nMagnitude) {	fix xAddedFlash = abs(gameStates.gameplay.seismic.nMagnitude);	if (xAddedFlash < I2X (1))		xAddedFlash *= 16;	flash_ang += (fixang) FixMul (gameStates.render.nFlashRate, FixMul(gameData.time.xFrame, xAddedFlash+I2X (1)));	FixFastSinCos (flash_ang, &gameStates.render.nFlashScale, NULL);	gameStates.render.nFlashScale = (gameStates.render.nFlashScale + I2X (3))/4;	//	gets in range 0.5 to 1.0	}else {	flash_ang += (fixang) FixMul (gameStates.render.nFlashRate, gameData.time.xFrame);	FixFastSinCos (flash_ang, &gameStates.render.nFlashScale, NULL);	gameStates.render.nFlashScale = (gameStates.render.nFlashScale + I2X (1))/2;	if (gameStates.app.nDifficultyLevel == 0)		gameStates.render.nFlashScale = (gameStates.render.nFlashScale+I2X (3))/4;	}}

void SeismicDisturbanceFrame (void){if (gameStates.gameplay.seismic.nShakeFrequency) {	if (((gameStates.gameplay.seismic.nStartTime < gameData.time.xGame) && 		  (gameStates.gameplay.seismic.nEndTime > gameData.time.xGame)) || StartSeismicDisturbance()) {		fix	deltaTime = gameData.time.xGame - gameStates.gameplay.seismic.nStartTime;		int	fc, rx, rz;		fix	h;		fc = abs(deltaTime - (gameStates.gameplay.seismic.nEndTime - gameStates.gameplay.seismic.nStartTime) / 2);		fc /= F1_0 / 16;		if (fc > 16)			fc = 16;		else if (fc == 0)			fc = 1;		gameStates.gameplay.seismic.nVolume += fc;		h = 3 * F1_0 / 16 + (F1_0 * (16 - fc)) / 32;		rx = FixMul(d_rand() - 16384, h);		rz = FixMul(d_rand() - 16384, h);		gameData.objs.console->mType.physInfo.rotVel.p.x += rx;		gameData.objs.console->mType.physInfo.rotVel.p.z += rz;		//	Shake the buddy!		if (gameData.escort.nObjNum != -1) {			gameData.objs.objects[gameData.escort.nObjNum].mType.physInfo.rotVel.p.x += rx*4;			gameData.objs.objects[gameData.escort.nObjNum].mType.physInfo.rotVel.p.z += rz*4;			}		//	Shake a guided missile!		gameStates.gameplay.seismic.nMagnitude += rx;		}	}}

//------------------------------------------------------------------------------//performs aspect scaling on global view matrixvoid ScaleMatrix (int bOglScale){	viewInfo.view [1] = viewInfo.view [0];		//so we can use unscaled if we want	viewInfo.viewf [1] = viewInfo.viewf [0];		//so we can use unscaled if we wantviewInfo.scale = viewInfo.windowScale;if (viewInfo.zoom <= f1_0) 		//xZoom in by scaling z	viewInfo.scale[Z] = FixMul (viewInfo.scale[Z], viewInfo.zoom);else {			//xZoom out by scaling x&y	fix s = FixDiv (f1_0, viewInfo.zoom);	viewInfo.scale[X] = FixMul (viewInfo.scale[X], s);	viewInfo.scale[Y] = FixMul (viewInfo.scale[Y], s);	}viewInfo.scalef = viewInfo.scale.ToFloat();//viewInfo.scale[X] = viewInfo.scale[Y] = viewInfo.scale[Z] = F1_0;//now scale matrix elementsif (bOglScale) {	//glScalef (X2F (viewInfo.scale[X]), X2F (viewInfo.scale[Y]), -X2F (viewInfo.scale[Z]));	glScalef (1, 1, -1);	}else {	//VmVecScale (&viewInfo.view [0].rVec, viewInfo.scale[X]);	//VmVecScale (&viewInfo.view [0].uVec, viewInfo.scale[Y]);	//viewInfo.scale[X] = viewInfo.scale[Y] = viewInfo.scale[Z] = F1_0;	viewInfo.view [0][FVEC] *= (-viewInfo.scale[Z]);	glScalef (1, 1, 1);	}viewInfo.viewf[0] = viewInfo.view[0].ToFloat();}

fix ComputeHeadlightLightOnObject (tObject *objP){	int	i;	fix	light;	//	Let's just illuminate players and robots for speed reasons, ok?	if ((objP->nType != OBJ_ROBOT) && (objP->nType	!= OBJ_PLAYER))		return 0;	light = 0;	for (i = 0; i < nHeadLights; i++) {		fix			dot, dist;		vmsVector	vecToObj;		tObject		*lightObjP;		lightObjP = Headlights [i];		VmVecSub (&vecToObj, &objP->position.vPos, &lightObjP->position.vPos);		dist = VmVecNormalize (&vecToObj);		if (dist > 0) {			dot = VmVecDot (&lightObjP->position.mOrient.fVec, &vecToObj);			if (dot < F1_0/2)				light += FixDiv (HEADLIGHT_SCALE, FixMul (HEADLIGHT_SCALE, dist));	//	Do the normal thing, but darken around headlight.			else				light += FixMul (FixMul (dot, dot), HEADLIGHT_SCALE)/8;		}	}	return light;}

//------------------------------------------------------------------------------//performs aspect scaling on global view matrixvoid ScaleMatrix (int bOglScale){	viewInfo.view [1] = viewInfo.view [0];		//so we can use unscaled if we want	viewInfo.viewf [1] = viewInfo.viewf [0];		//so we can use unscaled if we wantviewInfo.scale = viewInfo.windowScale;if (viewInfo.zoom <= f1_0) 		//xZoom in by scaling z	viewInfo.scale.p.z = FixMul (viewInfo.scale.p.z, viewInfo.zoom);else {			//xZoom out by scaling x&y	fix s = FixDiv (f1_0, viewInfo.zoom);	viewInfo.scale.p.x = FixMul (viewInfo.scale.p.x, s);	viewInfo.scale.p.y = FixMul (viewInfo.scale.p.y, s);	}//viewInfo.scale.p.x = viewInfo.scale.p.y = viewInfo.scale.p.z = F1_0;//now scale matrix elementsif (bOglScale)	//glScalef (f2fl (viewInfo.scale.p.x), f2fl (viewInfo.scale.p.y), -f2fl (viewInfo.scale.p.z));	glScalef (1, 1, -1);else {	//VmVecScale (&viewInfo.view [0].rVec, viewInfo.scale.p.x);	//VmVecScale (&viewInfo.view [0].uVec, viewInfo.scale.p.y);	//viewInfo.scale.p.x = viewInfo.scale.p.y = viewInfo.scale.p.z = F1_0;	VmVecScale (&viewInfo.view [0].fVec, -viewInfo.scale.p.z);	glScalef (1, 1, 1);	}VmsMatToFloat (viewInfo.viewf, viewInfo.view);}

void WiggleObject (CObject *objP){	fix		xWiggle;	int		nParent;	CObject	*pParent;if (gameStates.render.nShadowPass == 2)	return;if (gameOpts->app.bEpilepticFriendly)	return;if (!gameStates.app.bNostalgia && (!EGI_FLAG (nDrag, 0, 0, 0) || !EGI_FLAG (bWiggle, 1, 0, 1)))	return;nParent = gameData.objs.parentObjs [objP->Index ()];pParent = (nParent < 0) ? NULL : OBJECTS + nParent;FixFastSinCos (fix (gameData.time.xGame / gameStates.gameplay.slowmo [1].fSpeed), &xWiggle, NULL);if (gameData.time.xFrame < I2X (1))// Only scale wiggle if getting at least 1 FPS, to avoid causing the opposite problem.	xWiggle = FixMul (xWiggle * 20, gameData.time.xFrame); //make wiggle fps-independent (based on pre-scaled amount of wiggle at 20 FPS)if (SPECTATOR (objP))	OBJPOS (objP)->vPos += (OBJPOS (objP)->mOrient.UVec () * FixMul (xWiggle, gameData.pig.ship.player->wiggle)) * (I2X (1) / 20);else if ((objP->info.nType == OBJ_PLAYER) || !pParent)	objP->mType.physInfo.velocity += objP->info.position.mOrient.UVec () * FixMul (xWiggle, gameData.pig.ship.player->wiggle);else {	objP->mType.physInfo.velocity += pParent->info.position.mOrient.UVec () * FixMul (xWiggle, gameData.pig.ship.player->wiggle);	objP->info.position.vPos += objP->mType.physInfo.velocity * gameData.time.xFrame;	}}

void CShrapnel::Move (void){	fix			xSpeed = FixDiv (m_info.xSpeed, I2X (25) / 1000);	CFixVector	vOffs;	time_t		nTicks;if ((nTicks = gameStates.app.nSDLTicks - m_info.tUpdate) < 25)	return;xSpeed = (fix) (xSpeed / gameStates.gameplay.slowmo [0].fSpeed);for (; nTicks >= 25; nTicks -= 25) {	if (--(m_info.nTurn))		vOffs = m_info.vOffs;	else {		m_info.nTurn = ((m_info.xTTL > I2X (1) / 2) ? 2 : 4) + d_rand () % 4;		vOffs = m_info.vDir;		vOffs [X] = FixMul (vOffs [X], 2 * d_rand ());		vOffs [Y] = FixMul (vOffs [Y], 2 * d_rand ());		vOffs [Z] = FixMul (vOffs [Z], 2 * d_rand ());		CFixVector::Normalize (vOffs);		m_info.vOffs = vOffs;		}	vOffs *= xSpeed;	m_info.vPos += vOffs;	}if (m_info.nSmoke >= 0)	particleManager.SetPos (m_info.nSmoke, &m_info.vPos, NULL, -1);m_info.tUpdate = gameStates.app.nSDLTicks - nTicks;}

static void MixSoundSlot (struct sound_slot *sl, Uint8 *sldata, Uint8 *stream, int len){    Uint8 *streamend = stream + len;    Uint8 *slend = sldata - sl->position + sl->length;    Uint8 *sp = stream, s;    signed char v;    fix vl, vr;    int x;    if ((x = sl->pan) & 0x8000) {        vl = 0x20000 - x * 2;        vr = 0x10000;    }    else {        vl = 0x10000;        vr = x * 2;    }    vl = FixMul (vl, (x = sl->volume));    vr = FixMul (vr, x);    while (sp < streamend) {        if (sldata == slend) {            if (!sl->looped) {                sl->playing = 0;                break;            }            sldata = sl->samples;        }        v = *(sldata++) - 0x80;        s = *sp;        *(sp++) = mix8 [s + FixMul (v, vl) + 0x80];        s = *sp;        *(sp++) = mix8 [s + FixMul (v, vr) + 0x80];    }    sl->position = (int) (sldata - sl->samples);}

int Blend (int i1, int i2) {	Fixed	smallFix, bigFix, tempFix;	smallFix = ONE * i1;	bigFix = ONE * i2;	tempFix = FixMul (fract, bigFix) +FixMul (ONE-fract, smallFix);	return (FixRound (tempFix));}

//	------------------------------------------------------------------------------------------//	Move all sub-gameData.objs.objects in an tObject towards their goals.//	Current orientation of tObject is at:	polyObjInfo.animAngles//	Goal orientation of tObject is at:		aiInfo.goalAngles//	Delta orientation of tObject is at:		aiInfo.deltaAnglesvoid AIFrameAnimation (tObject *objP){	int	nObject = OBJ_IDX (objP);	int	joint;	int	nJoints = gameData.models.polyModels [objP->rType.polyObjInfo.nModel].nModels;	for (joint=1; joint<nJoints; joint++) {		fix			delta_to_goal;		fix			scaled_delta_angle;		vmsAngVec	*curangp = &objP->rType.polyObjInfo.animAngles [joint];		vmsAngVec	*goalangp = &gameData.ai.localInfo [nObject].goalAngles [joint];		vmsAngVec	*deltaangp = &gameData.ai.localInfo [nObject].deltaAngles [joint];		Assert (nObject >= 0);		delta_to_goal = goalangp->p - curangp->p;		if (delta_to_goal > 32767)			delta_to_goal = delta_to_goal - 65536;		else if (delta_to_goal < -32767)			delta_to_goal = 65536 + delta_to_goal;		if (delta_to_goal) {			scaled_delta_angle = FixMul (deltaangp->p, gameData.time.xFrame) * DELTA_ANG_SCALE;			curangp->p += (fixang) scaled_delta_angle;			if (abs (delta_to_goal) < abs (scaled_delta_angle))				curangp->p = goalangp->p;		}		delta_to_goal = goalangp->b - curangp->b;		if (delta_to_goal > 32767)			delta_to_goal = delta_to_goal - 65536;		else if (delta_to_goal < -32767)			delta_to_goal = 65536 + delta_to_goal;		if (delta_to_goal) {			scaled_delta_angle = FixMul (deltaangp->b, gameData.time.xFrame) * DELTA_ANG_SCALE;			curangp->b += (fixang) scaled_delta_angle;			if (abs (delta_to_goal) < abs (scaled_delta_angle))				curangp->b = goalangp->b;		}		delta_to_goal = goalangp->h - curangp->h;		if (delta_to_goal > 32767)			delta_to_goal = delta_to_goal - 65536;		else if (delta_to_goal < -32767)			delta_to_goal = 65536 + delta_to_goal;		if (delta_to_goal) {			scaled_delta_angle = FixMul (deltaangp->h, gameData.time.xFrame) * DELTA_ANG_SCALE;			curangp->h += (fixang) scaled_delta_angle;			if (abs (delta_to_goal) < abs (scaled_delta_angle))				curangp->h = goalangp->h;		}	}}

fix OmegaEnergy (fix xDeltaCharge){	fix xEnergyUsed;if (xDeltaCharge < 0)	return -1;xEnergyUsed = FixMul (OMEGA_ENERGY_RATE, xDeltaCharge);if (gameStates.app.nDifficultyLevel < 2)	xEnergyUsed = FixMul (xEnergyUsed, i2f (gameStates.app.nDifficultyLevel + 2) / 4);return xEnergyUsed;}

void CObject::RandomBump (fix xScale, fix xForce, bool bSound){	fix angle;angle = (d_rand () - I2X (1) / 4);mType.physInfo.rotVel [X] += FixMul (angle, xScale);angle = (d_rand () - I2X (1) / 4);mType.physInfo.rotVel [Z] += FixMul (angle, xScale);CFixVector vRand = CFixVector::Random ();Bump (vRand, xForce);if (bSound)	audio.CreateObjectSound (SOUND_PLAYER_HIT_WALL, SOUNDCLASS_GENERIC, Index ());}

bool G3DrawBitMap(vms_vector *pos,fix width,fix height,grs_bitmap *bm, int orientation){	vms_vector pv,v1;	int i;	r_bitmapc++;	v1.z=0;glActiveTextureARB(GL_TEXTURE0_ARB);glEnable(GL_TEXTURE_2D);OglBindBmTex(bm);OglTexWrap(bm->glTexture,GL_CLAMP);glBegin(GL_QUADS);glColor3d(1.0,1.0,1.0);width = FixMul(width,viewInfo.scale.x);height = FixMul(height,viewInfo.scale.y);for (i = 0; i < 4; i++) {	VmVecSub(&v1,pos,&viewInfo.position);	VmVecRotate(&pv,&v1,&viewInfo.view);	switch (i) {		case 0:			glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0, 0.0);			pv.x+=-width;			pv.y+=height;			break;		case 1:			glMultiTexCoord2fARB(GL_TEXTURE0_ARB, bm->glTexture->u, 0.0);			pv.x+=width;			pv.y+=height;			break;		case 2:			glMultiTexCoord2fARB(GL_TEXTURE0_ARB, bm->glTexture->u, bm->glTexture->v);			pv.x+=width;			pv.y+=-height;			break;		case 3:			glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0.0, bm->glTexture->v);			pv.x+=-width;			pv.y+=-height;			break;		}	glVertex3d (f2glf(pv.x), f2glf(pv.y), -f2glf(pv.z));	}glEnd();//These next lines are important for later leave these here - Lehm 4/26/05//glActiveTextureARB(GL_TEXTURE0_ARB);//glBindTexture(GL_TEXTURE_2D,0);//glDisable(GL_TEXTURE_2D);return 0;} 

//changed on 980905 by adb to cleanup, add pan support and optimize mixerstatic void _CDECL_ AudioMixCallback(void *userdata, Uint8 *stream, int len){    Uint8 *streamend = stream + len;    struct sound_slot *sl;    if (!gameStates.sound.digi.bInitialized)        return;    memset(stream, 0x80, len); // fix "static" sound bug on Mac OS X    for (sl = SoundSlots; sl < SoundSlots + MAX_SOUND_SLOTS; sl++) {        if (sl->playing && sl->samples && sl->length) {#if 0            MixSoundSlot (sl, sl->samples + sl->position, stream, len);#else            Uint8 *sldata = sl->samples + sl->position, *slend = sl->samples + sl->length;            Uint8 *sp = stream, s;            signed char v;            fix vl, vr;            int x;            if ((x = sl->pan) & 0x8000) {                vl = 0x20000 - x * 2;                vr = 0x10000;            }            else {                vl = 0x10000;                vr = x * 2;            }            vl = FixMul (vl, (x = sl->volume));            vr = FixMul (vr, x);            while (sp < streamend) {                if (sldata == slend) {                    if (!sl->looped) {                        sl->playing = 0;                        break;                    }                    sldata = sl->samples;                }                v = *(sldata++) - 0x80;                s = *sp;                *(sp++) = mix8 [s + FixMul (v, vl) + 0x80];                s = *sp;                *(sp++) = mix8 [s + FixMul (v, vr) + 0x80];            }            sl->position = (int) (sldata - sl->samples);#endif        }    }}

//------------------------------------------------------------------------------//process a continuously-spinning CObjectvoid CObject::Spin (void){	CAngleVector rotangs;	CFixMatrix rotmat, new_pm;Assert (info.movementType == MT_SPINNING);rotangs = CAngleVector::Create((fixang) FixMul (mType.spinRate [X], gameData.time.xFrame),										 (fixang) FixMul (mType.spinRate [Y], gameData.time.xFrame),										 (fixang) FixMul (mType.spinRate [Z], gameData.time.xFrame));rotmat = CFixMatrix::Create (rotangs);new_pm = info.position.mOrient * rotmat;info.position.mOrient = new_pm;info.position.mOrient.CheckAndFix();}

//------------------------------------------------------------------------------//compute the corners of a rod.  fills in vertbuf.int CalcRodCorners (g3sPoint *btmPoint, fix xBtmWidth, g3sPoint *topPoint, fix xTopWidth){	vmsVector	vDelta, vTop, vTemp, vRodNorm;	ubyte			andCodes;	int			i;//compute vector from one point to other, do cross product with vector//from eye to get perpendicularvDelta = btmPoint->p3_vec - topPoint->p3_vec;//unscale for aspect#if RESCALE_RODvDelta.p.x = FixDiv (vDelta.p.x, viewInfo.scale.p.x);vDelta.p.y = FixDiv (vDelta.p.y, viewInfo.scale.p.y);#endif//calc Perp vector//do lots of normalizing to prevent overflowing.  When this code works,//it should be optimizedvmsVector::Normalize(vDelta);vTop = topPoint->p3_vec;vmsVector::Normalize(vTop);vRodNorm = vmsVector::Cross(vDelta, vTop);vmsVector::Normalize(vRodNorm);//scale for aspect#if RESCALE_RODvRodNorm.p.x = FixMul (vRodNorm.p.x, viewInfo.scale.p.x);vRodNorm.p.y = FixMul (vRodNorm.p.y, viewInfo.scale.p.y);#endif//now we have the usable edge.  generate four points//vTop pointsvTemp = vRodNorm * xTopWidth;vTemp[Z] = 0;rodPoints [0].p3_vec = topPoint->p3_vec + vTemp;rodPoints [1].p3_vec = topPoint->p3_vec - vTemp;vTemp = vRodNorm * xBtmWidth;vTemp[Z] = 0;rodPoints [2].p3_vec = btmPoint->p3_vec - vTemp;rodPoints [3].p3_vec = btmPoint->p3_vec + vTemp;//now code the four pointsfor (i = 0, andCodes = 0xff; i < 4; i++)	andCodes &= G3EncodePoint (rodPoints + i);if (andCodes)	return 1;		//1 means off screen//clear flags for new points (not projected)for (i = 0; i < 4; i++) {	rodPoints [i].p3_flags = 0;	rodPoints [i].p3_index = -1;	}return 0;}

void CreateSmallFireballOnObject (CObject *objP, fix size_scale, int bSound){	fix			size;	CFixVector	vPos, vRand;	short			nSegment;vPos = objP->info.position.vPos;vRand = CFixVector::Random();vRand *= (objP->info.xSize / 2);vPos += vRand;size = FixMul (size_scale, I2X (1) / 2 + d_rand () * 4 / 2);nSegment = FindSegByPos (vPos, objP->info.nSegment, 1, 0);if (nSegment != -1) {	CObject *explObjP = /*Object*/CreateExplosion (nSegment, vPos, size, VCLIP_SMALL_EXPLOSION);	if (!explObjP)		return;	AttachObject (objP, explObjP);	if (bSound || (d_rand () < 8192)) {		fix vol = I2X (1) / 2;		if (objP->info.nType == OBJ_ROBOT)			vol *= 2;		audio.CreateObjectSound (SOUND_EXPLODING_WALL, SOUNDCLASS_EXPLOSION, objP->Index (), 0, vol);		}	}}

//	------------------------------------------------------------------------------------------//	Move all sub-OBJECTS in an CObject towards their goals.//	Current orientation of CObject is at:	polyObjInfo.animAngles//	Goal orientation of CObject is at:		aiInfo.goalAngles//	Delta orientation of CObject is at:		aiInfo.deltaAnglesvoid AIFrameAnimation (CObject *objP){	int	nObject = objP->Index ();	int	nJoint;	int	nJoints = gameData.models.polyModels [0][objP->rType.polyObjInfo.nModel].ModelCount ();for (nJoint = 1; nJoint < nJoints; nJoint++) {	fix				deltaToGoal;	fix				scaledDeltaAngle;	CAngleVector*	curAngP = &objP->rType.polyObjInfo.animAngles [nJoint];	CAngleVector*	goalAngP = &gameData.ai.localInfo [nObject].goalAngles [nJoint];	CAngleVector*	deltaAngP = &gameData.ai.localInfo [nObject].deltaAngles [nJoint];	Assert (nObject >= 0);	for (int nAngle = 0; nAngle < 3; nAngle++) {		deltaToGoal = (*goalAngP)[nAngle] - (*curAngP)[nAngle];		if (deltaToGoal > 32767)			deltaToGoal -= 65536;		else if (deltaToGoal < -32767)			deltaToGoal += deltaToGoal;		if (deltaToGoal) {			scaledDeltaAngle = FixMul ((*deltaAngP)[nAngle], gameData.time.xFrame) * DELTA_ANG_SCALE;			(*curAngP)[nAngle] += (fixang) scaledDeltaAngle;			if (abs (deltaToGoal) < abs (scaledDeltaAngle))				(*curAngP)[nAngle] = (*goalAngP)[nAngle];			}		}	}}

void CHUD::DrawAfterburnerBar (void){if (cockpit->Hide ())	return;		int h, y;if (!(LOCALPLAYER.flags & PLAYER_FLAGS_AFTERBURNER))	return;		//don't draw if don't haveh = FixMul (gameData.physics.xAfterburnerCharge, 100);if (!gameOpts->render.cockpit.bTextGauges) {	y = CCanvas::Current ()->Height () - (int) ((((gameData.app.nGameMode & GM_MULTI) ? 8 : 3) * m_info.nLineSpacing - 1) * m_info.yGaugeScale);	CCanvas::Current ()->SetColorRGB (255, 0, 0, 255);	glLineWidth (1);	OglDrawEmptyRect (6, y, 6 + (int) (100 * m_info.xGaugeScale), y + (int) (9 * m_info.yGaugeScale));	CCanvas::Current ()->SetColorRGB (224, 0, 0, 128);	OglDrawFilledRect (6, y, 6 + (int) (h * m_info.xGaugeScale), y + (int) (9 * m_info.yGaugeScale));	}if (gameData.demo.nState == ND_STATE_RECORDING) {	if (gameData.physics.xAfterburnerCharge != m_history [gameStates.render.vr.nCurrentPage].afterburner) {		NDRecordPlayerAfterburner (m_history [gameStates.render.vr.nCurrentPage].afterburner, gameData.physics.xAfterburnerCharge);		m_history [gameStates.render.vr.nCurrentPage].afterburner = gameData.physics.xAfterburnerCharge;	 	}	}}

int OptimizePath (tPointSeg *pointSegP, int nSegs){	int			i, j;	CFixVector	temp1, temp2;	fix			dot, mag1, mag2 = 0;for (i = 1; i < nSegs - 1; i += 2) {	if (i == 1) {		temp1 = pointSegP [i].point - pointSegP [i-1].point;		mag1 = temp1.Mag();		}	else {		temp1 = temp2;		mag1 = mag2;		}	temp2 = pointSegP [i + 1].point - pointSegP [i].point;	mag2 = temp1.Mag();	dot = CFixVector::Dot (temp1, temp2);	if (dot * 9/8 > FixMul (mag1, mag2))		pointSegP [i].nSegment = -1;	}//	Now, scan for points with nSegment == -1for (i = j = 0; i < nSegs; i++)	if (pointSegP [i].nSegment != -1)		pointSegP [j++] = pointSegP [i];return j;}

//	-----------------------------------------------------------------------------//see if a point is inside a face by projecting into 2dbool PointIsInQuad (CFixVector vRef, CFixVector* vertP, CFixVector vNormal){	CFixVector	t, v0, v1;	int 			i, j, iEdge, biggest;	fix			check_i, check_j;	vec2d 		vEdge, vCheck;//now do 2d check to see if vRef is in side//project polygon onto plane by finding largest component of Normalt [X] = labs (vNormal [0]);t [Y] = labs (vNormal [1]);t [Z] = labs (vNormal [2]);if (t [X] > t [Y]) {	if (t [X] > t [Z])		biggest = 0;	else		biggest = 2;	}else {	if (t [Y] > t [Z])		biggest = 1;	else		biggest = 2;	}if (vNormal [biggest] > 0) {	i = ijTable [biggest][0];	j = ijTable [biggest][1];	}else {	i = ijTable [biggest][1];	j = ijTable [biggest][0];	}//now do the 2d problem in the i, j planecheck_i = vRef [i];check_j = vRef [j];for (iEdge = 0; iEdge < 4; iEdge) {	v0 = vertP [iEdge++];	v1 = vertP [iEdge % 4];	vEdge.i = v1 [i] - v0 [i];	vEdge.j = v1 [j] - v0 [j];	vCheck.i = check_i - v0 [i];	vCheck.j = check_j - v0 [j];	if (FixMul (vCheck.i, vEdge.j) - FixMul (vCheck.j, vEdge.i) < 0)		return false;	}return true;}

//------------------------------------------------------------------------------//compute the corners of a rod.  fills in vertbuf.int CalcRodCorners (g3sPoint *bot_point, fix bot_width, g3sPoint *top_point, fix top_width){	vmsVector	delta_vec, top, tempv, rod_norm;	ubyte			codes_and;	int			i;//compute vector from one point to other, do cross product with vector//from eye to get perpendiclarVmVecSub (&delta_vec, &bot_point->p3_vec, &top_point->p3_vec);//unscale for aspectdelta_vec.x = FixDiv (delta_vec.x, viewInfo.scale.x);delta_vec.y = FixDiv (delta_vec.y, viewInfo.scale.y);//calc perp vector//do lots of normalizing to prevent overflowing.  When this code works, //it should be optimizedVmVecNormalize (&delta_vec);VmVecCopyNormalize (&top, &top_point->p3_vec);VmVecCross (&rod_norm, &delta_vec, &top);VmVecNormalize (&rod_norm);//scale for aspectrod_norm.x = FixMul (rod_norm.x, viewInfo.scale.x);rod_norm.y = FixMul (rod_norm.y, viewInfo.scale.y);//now we have the usable edge.  generate four points//top pointsVmVecCopyScale (&tempv, &rod_norm, top_width);tempv.z = 0;VmVecAdd (&rodPoints [0].p3_vec, &top_point->p3_vec, &tempv);VmVecSub (&rodPoints [1].p3_vec, &top_point->p3_vec, &tempv);VmVecCopyScale (&tempv, &rod_norm, bot_width);tempv.z = 0;VmVecSub (&rodPoints [2].p3_vec, &bot_point->p3_vec, &tempv);VmVecAdd (&rodPoints [3].p3_vec, &bot_point->p3_vec, &tempv);//now code the four pointsfor (i = 0, codes_and = 0xff; i < 4; i++)	codes_and &= G3EncodePoint (rodPoints + i);if (codes_and)	return 1;		//1 means off screen//clear flags for new points (not projected)for (i = 0; i < 4; i++) {	rodPoints [i].p3Flags = 0;	rodPoints [i].p3_index = -1;	}return 0;}

void SetObjectTurnRoll (tObject *objP){//if (!gameStates.app.bD1Mission) 	{	fixang desired_bank = -FixMul (objP->mType.physInfo.rotVel.y, TURNROLL_SCALE);	if (objP->mType.physInfo.turnRoll != desired_bank) {		fixang delta_ang, max_roll;		max_roll = FixMul (ROLL_RATE, gameData.time.xFrame);		delta_ang = desired_bank - objP->mType.physInfo.turnRoll;		if (labs (delta_ang) < max_roll)			max_roll = delta_ang;		else			if (delta_ang < 0)				max_roll = -max_roll;		objP->mType.physInfo.turnRoll += max_roll;		}	}}

bool FontPlatformData::applyState(FS_STATE* font, float scale) const{    ASSERT(font);    ASSERT(m_name);    if (FS_set_font(font, m_name) != SUCCESS)        return false;    if (FS_set_cmap(font, 3, 10) != SUCCESS) // First try Windows Unicode with surrogates...        if (FS_set_cmap(font, 3, 1) != SUCCESS) // try normal Windows Unicode            if (FS_set_cmap(font, 1, 0) != SUCCESS)                return false;    if (m_syntheticBold) {        if (FS_set_bold_pct(font, floatToITypeFixed(0.06)) != SUCCESS) // 6% pseudo bold            return false;    } else {        if (FS_set_bold_pct(font, 0) != SUCCESS)            return false;    }    FS_FIXED skew = 0;    if (m_syntheticOblique)        skew = 13930; // 12 degrees    FS_FIXED fixedScale = std::min(FixMul(floatToITypeFixed(scale), floatToITypeFixed(m_size)), MAXITYPEFONTSCALE);    if (FS_set_scale(font, fixedScale, FixMul(fixedScale, skew), 0, fixedScale) != SUCCESS)        return false;    if (FS_set_flags(font, FLAGS_CMAP_OFF) != SUCCESS)        return false;    if (FS_set_flags(font, FLAGS_HINTS_OFF) != SUCCESS)        return false;    if (FS_set_flags(font, FLAGS_DEFAULT_CSM_OFF) != SUCCESS)        return false;    if (m_orientation == Vertical) {        if (FS_set_flags(font, (m_textOrientation == TextOrientationVerticalRight) ? FLAGS_VERTICAL_ROTATE_LEFT_ON : FLAGS_VERTICAL_ON) != SUCCESS)            return false;    }    return true;}

void CAudioChannel::Mix (ubyte* stream, int len){if (m_info.bPlaying && m_info.sample.Buffer () && m_info.nLength) {#if 0	MixSoundchannelPot (channelP, m_info.sample + m_info.nPosition, stream, len);#else	ubyte* streamEnd = stream + len;	ubyte* channelData = reinterpret_cast<ubyte*> (m_info.sample.Buffer () + m_info.nPosition);	ubyte* channelEnd = reinterpret_cast<ubyte*> (m_info.sample.Buffer () + m_info.nLength);	ubyte* streamPos = stream, s;	signed char v;	fix vl, vr;	int x;	if ((x = m_info.nPan) & 0x8000) {		vl = 0x20000 - x * 2;		vr = 0x10000;		}	else {		vl = 0x10000;		vr = x * 2;		}	x = m_info.nVolume;	vl = FixMul (vl, x);	vr = FixMul (vr, x);	while (streamPos < streamEnd) {		if (channelData == channelEnd) {			if (!m_info.bLooped) {				m_info.bPlaying = 0;				break;				}			channelData = m_info.sample.Buffer ();			}		v = *(channelData++) - 0x80;		s = *streamPos;		*streamPos++ = mix8 [s + FixMul (v, vl) + 0x80];		s = *streamPos;		*streamPos++ = mix8 [s + FixMul (v, vr) + 0x80];		}	m_info.nPosition = int (channelData - m_info.sample.Buffer ());#endif	}}

//	If a smega missile been detonated, rock the mine!//	This should be called every frame.//	Maybe this should affect all robots, being called when they get their physics done.void RockTheMineFrame (void){	int	i;for (i = 0; i < MAX_ESHAKER_DETONATES; i++) {	if (eshakerDetonateTimes [i] != 0) {		fix	deltaTime = gameData.time.xGame - eshakerDetonateTimes [i];		if (!gameStates.gameplay.seismic.bSound) {			DigiPlaySampleLooping ((short) gameStates.gameplay.seismic.nSound, F1_0, -1, -1);			gameStates.gameplay.seismic.bSound = 1;			gameStates.gameplay.seismic.nNextSoundTime = gameData.time.xGame + d_rand()/2;			}		if (deltaTime < ESHAKER_SHAKE_TIME) {			//	Control center destroyed, rock the tPlayer's ship.			int	fc, rx, rz;			fix	h;			// -- fc = abs(deltaTime - ESHAKER_SHAKE_TIME/2);			//	Changed 10/23/95 to make decreasing for super mega missile.			fc = (ESHAKER_SHAKE_TIME - deltaTime) / (ESHAKER_SHAKE_TIME / 16);			if (fc > 16)				fc = 16;			else if (fc == 0)				fc = 1;			gameStates.gameplay.seismic.nVolume += fc;			h = 3 * F1_0 / 16 + (F1_0 * (16 - fc)) / 32;			rx = FixMul(d_rand() - 16384, h);			rz = FixMul(d_rand() - 16384, h);			gameData.objs.console->mType.physInfo.rotVel.p.x += rx;			gameData.objs.console->mType.physInfo.rotVel.p.z += rz;			//	Shake the buddy!			if (gameData.escort.nObjNum != -1) {				gameData.objs.objects[gameData.escort.nObjNum].mType.physInfo.rotVel.p.x += rx*4;				gameData.objs.objects[gameData.escort.nObjNum].mType.physInfo.rotVel.p.z += rz*4;				}			//	Shake a guided missile!			gameStates.gameplay.seismic.nMagnitude += rx;			} 		else			eshakerDetonateTimes [i] = 0;		}	}//	Hook in the rumble sound effect here.}

const CFixMatrix CFixMatrix::Inverse (void) {	fix xDet = Det ();	CFixMatrix m;m.m_data.mat [RVEC][X] = FixDiv (FixMul (m_data.mat [UVEC][Y], m_data.mat [FVEC][Z]) - FixMul (m_data.mat [UVEC][Z], m_data.mat [FVEC][Y]), xDet);m.m_data.mat [RVEC][Y] = FixDiv (FixMul (m_data.mat [RVEC][Z], m_data.mat [FVEC][Y]) - FixMul (m_data.mat [RVEC][Y], m_data.mat [FVEC][Z]), xDet);m.m_data.mat [RVEC][Z] = FixDiv (FixMul (m_data.mat [RVEC][Y], m_data.mat [UVEC][Z]) - FixMul (m_data.mat [RVEC][Z], m_data.mat [UVEC][Y]), xDet);m.m_data.mat [UVEC][X] = FixDiv (FixMul (m_data.mat [UVEC][Z], m_data.mat [FVEC][X]) - FixMul (m_data.mat [UVEC][X], m_data.mat [FVEC][Z]), xDet);m.m_data.mat [UVEC][Y] = FixDiv (FixMul (m_data.mat [RVEC][X], m_data.mat [FVEC][Z]) - FixMul (m_data.mat [RVEC][Z], m_data.mat [FVEC][X]), xDet);m.m_data.mat [UVEC][Z] = FixDiv (FixMul (m_data.mat [RVEC][Z], m_data.mat [UVEC][X]) - FixMul (m_data.mat [RVEC][X], m_data.mat [UVEC][Z]), xDet);m.m_data.mat [FVEC][X] = FixDiv (FixMul (m_data.mat [UVEC][X], m_data.mat [FVEC][Y]) - FixMul (m_data.mat [UVEC][Y], m_data.mat [FVEC][X]), xDet);m.m_data.mat [FVEC][Y] = FixDiv (FixMul (m_data.mat [RVEC][Y], m_data.mat [FVEC][X]) - FixMul (m_data.mat [RVEC][X], m_data.mat [FVEC][Y]), xDet);m.m_data.mat [FVEC][Z] = FixDiv (FixMul (m_data.mat [RVEC][X], m_data.mat [UVEC][Y]) - FixMul (m_data.mat [RVEC][Y], m_data.mat [UVEC][X]), xDet);return m;}

//------------------------------------------------------------------------------//do special cloaked renderint DrawCloakedObject (CObject *objP, fix light, fix *glow, fix xCloakStartTime, fix xCloakEndTime){	tObjTransformation	*posP = OBJPOS (objP);	tCloakInfo	ci;	int			bOk = 0;if (gameStates.render.bQueryCoronas)	return 1;GetCloakInfo (objP, xCloakStartTime, xCloakEndTime, &ci);if (ci.bFading < 0) {	fix xNewLight, xSaveGlow;	tBitmapIndex * altTextures = NULL;	if (objP->rType.polyObjInfo.nAltTextures > 0)		altTextures = mpTextureIndex [objP->rType.polyObjInfo.nAltTextures - 1];	xNewLight = FixMul (light, ci.xLightScale);	xSaveGlow = glow [0];	glow [0] = FixMul (glow [0], ci.xLightScale);	gameData.models.nLightScale = ci.xLightScale;	bOk = DrawPolyModel (objP, &posP->vPos, &posP->mOrient,								reinterpret_cast<CAngleVector*> (&objP->rType.polyObjInfo.animAngles),								objP->rType.polyObjInfo.nModel, objP->rType.polyObjInfo.nSubObjFlags,								xNewLight, glow, altTextures, NULL);	gameData.models.nLightScale = 0;	glow [0] = xSaveGlow;	}else {	gameStates.render.bCloaked = 1;	gameStates.render.grAlpha = GrAlpha (ci.nFadeValue);	CCanvas::Current ()->SetColorRGB (0, 0, 0, 255);	//set to black (matters for s3)	fpDrawTexPolyMulti = G3DrawTexPolyFlat;	bOk = DrawPolyModel (objP, &posP->vPos, &posP->mOrient,								reinterpret_cast<CAngleVector*> (&objP->rType.polyObjInfo.animAngles),								objP->rType.polyObjInfo.nModel, objP->rType.polyObjInfo.nSubObjFlags,								light, glow, NULL, NULL);	fpDrawTexPolyMulti = G3DrawTexPolyMulti;	gameStates.render.grAlpha = 1.0f;	gameStates.render.bCloaked = 0;	}return bOk;}

void NetworkHandlePingReturn (ubyte nPlayer){if ((nPlayer >= gameData.multiplayer.nPlayers) || !pingStats [nPlayer].launchTime) {#if 1				 console.printf (CON_DBG, "Got invalid PING RETURN from %s!/n", gameData.multiplayer.players [nPlayer].callsign);#endif   return;	}xPingReturnTime = TimerGetFixedSeconds ();pingStats [nPlayer].ping = X2I (FixMul (xPingReturnTime - pingStats [nPlayer].launchTime, I2X (1000)));if (!gameStates.render.cockpit.bShowPingStats)	HUDInitMessage ("Ping time for %s is %d ms!", gameData.multiplayer.players [nPlayer].callsign, pingStats [nPlayer].ping);pingStats [nPlayer].launchTime = 0;pingStats [nPlayer].received++;}

void Mix_VolPan (int channel, int vol, int pan){#if USE_SDL_MIXER    if (gameOpts->sound.bUseSDLMixer && (channel >= 0)) {        if (vol) {            vol = (FixMul (vol, gameStates.sound.digi.nVolume) + (SOUND_MAX_VOLUME / MIX_MAX_VOLUME) / 2) / (SOUND_MAX_VOLUME / MIX_MAX_VOLUME);            if (!vol)                vol = 1;            Mix_Volume (channel, vol);            pan /= (32767 / 127);            Mix_SetPanning (channel, (ubyte) pan, (ubyte) (254 - pan));        }    }#endif}