CFixVector *get_dy_vec (int h)
{
CFixVector *dyp;
dyp = yCache + h;
if (!ycFlags [h]) {
CFixVector tv = mSurfaceOrient.UVec () * (h * TERRAIN_HEIGHT_SCALE);
transformation.RotateScaled (*dyp, tv);
ycFlags [h] = 1;
}
return dyp;
}
//------------------------------------------------------------------------------
//instance at specified point with specified orientation
//if matrix==NULL, don't modify matrix. This will be like doing an offset
void CTransformation::Begin (const CFixVector& vPos, CFixMatrix& mOrient)
{
CFixVector vOffs;
CFixMatrix mTrans, mRot;
//Assert (nInstanceDepth < MAX_INSTANCE_DEPTH);
if (!Push ())
return;
if (ogl.m_states.bUseTransform) {
CFixVector h;
if (m_save.ToS () > 1) {
glScalef (-1.0f, -1.0f, -1.0f);
Move (vPos);
glScalef (-1.0f, -1.0f, -1.0f);
Rotate (mOrient);
}
else {
glLoadIdentity ();
#if 0
glScalef (transformation.m_info.scalef [X], transformation.m_info.scalef [Y], -transformation.m_info.scalef [Z]);
#else
glScalef (1, 1, -1);
#endif
Rotate (m_info.viewf [2]);
h = m_info.pos - vPos;
Move (h);
Rotate (mOrient);
if (!gameData.models.vScale.IsZero ()) {
CFloatVector fScale;
fScale.Assign (gameData.models.vScale);
glScalef (fScale [X], fScale [Y], fScale [Z]);
}
}
}
//step 1: subtract object position from view position
vOffs = m_info.pos - vPos;
//step 2: rotate view vector through CObject matrix
m_info.pos = mOrient * vOffs;
//step 3: rotate CObject matrix through view_matrix (vm = ob * vm)
mTrans = mOrient.Transpose ();
for (int i = 0; i < 2; i++) {
mRot = mTrans * m_info.view [i];
m_info.view [i] = mRot;
m_info.viewf [i].Assign (m_info.view [i]);
}
m_info.posf [0].Assign (m_info.pos);
}
void CFile::WriteMatrix (const CFixMatrix& m)
{
WriteVector (m.RVec());
WriteVector (m.UVec());
WriteVector (m.FVec());
}
void CFile::ReadMatrix (CFixMatrix& m)
{
ReadVector (m.RVec());
ReadVector (m.UVec());
ReadVector (m.FVec());
}
void RenderTerrain (CFixVector *vOrgPoint, int org_2dx, int org_2dy)
{
CFixVector tv, delta_i, delta_j; //delta_y;
g3sPoint p, p2, pLast, p2Last, pLowSave, pHighSave;
int i, j, iLow, iHigh, jLow, jHigh, iViewer, jViewer;
#if 1
memset (&p, 0, sizeof (g3sPoint));
memset (&p2, 0, sizeof (g3sPoint));
memset (&pLast, 0, sizeof (g3sPoint));
memset (&p2Last, 0, sizeof (g3sPoint));
#endif
gameData.render.terrain.nMineTilesDrawn = 0; //clear flags
gameData.render.terrain.orgI = org_2dy;
gameData.render.terrain.orgJ = org_2dx;
iLow = 0;
iHigh = gameData.render.terrain.nGridW - 1;
jLow = 0;
jHigh = gameData.render.terrain.nGridH - 1;
memset (ycFlags, 0, sizeof (ycFlags));
gameStates.render.nInterpolationMethod = im;
tv = mSurfaceOrient.RVec () * TERRAIN_GRID_SCALE;
transformation.RotateScaled (delta_i, tv);
tv = mSurfaceOrient.FVec () * TERRAIN_GRID_SCALE;
transformation.RotateScaled (delta_j, tv);
gameData.render.terrain.vStartPoint = *vOrgPoint + mSurfaceOrient.RVec () *
(-(gameData.render.terrain.orgI - iLow) * TERRAIN_GRID_SCALE);
gameData.render.terrain.vStartPoint += mSurfaceOrient.FVec () *
(-(gameData.render.terrain.orgJ - jLow) * TERRAIN_GRID_SCALE);
tv = gameData.objs.viewerP->info.position.vPos - gameData.render.terrain.vStartPoint;
iViewer = CFixVector::Dot (tv, mSurfaceOrient.RVec ()) / TERRAIN_GRID_SCALE;
if (iViewer > iHigh)
iViewer = iHigh;
jViewer = CFixVector::Dot (tv, mSurfaceOrient.FVec ()) / TERRAIN_GRID_SCALE;
if (jViewer > jHigh)
jViewer = jHigh;
G3TransformAndEncodePoint (&pLast, gameData.render.terrain.vStartPoint);
pLowSave = pLast;
for (j = jLow; j <= jHigh; j++) {
G3AddDeltaVec (gameData.render.terrain.saveRow + j, &pLast, get_dy_vec (HEIGHT (iLow, j)));
if (j == jHigh)
pHighSave = pLast;
else
G3AddDeltaVec (&pLast, &pLast, &delta_j);
}
for (i = iLow; i < iViewer; i++) {
G3AddDeltaVec (&pLowSave, &pLowSave, &delta_i);
pLast = pLowSave;
G3AddDeltaVec (&p2Last, &pLast, get_dy_vec (HEIGHT (i + 1, jLow)));
for (j = jLow; j < jViewer; j++) {
G3AddDeltaVec (&p, &pLast, &delta_j);
G3AddDeltaVec (&p2, &p, get_dy_vec (HEIGHT (i + 1, j + 1)));
DrawTerrainCell (i, j, gameData.render.terrain.saveRow + j,
gameData.render.terrain.saveRow + j + 1, &p2, &p2Last);
pLast = p;
gameData.render.terrain.saveRow [j] = p2Last;
p2Last = p2;
}
delta_j = -delta_j; //don't have a delta sub...
G3AddDeltaVec (&pHighSave, &pHighSave, &delta_i);
pLast = pHighSave;
G3AddDeltaVec (&p2Last, &pLast, get_dy_vec (HEIGHT (i + 1, jHigh)));
for (j = jHigh - 1; j >= jViewer; j--) {
G3AddDeltaVec (&p, &pLast, &delta_j);
G3AddDeltaVec (&p2, &p, get_dy_vec (HEIGHT (i + 1, j)));
DrawTerrainCell (i, j, gameData.render.terrain.saveRow + j,
gameData.render.terrain.saveRow + j + 1, &p2Last, &p2);
pLast = p;
gameData.render.terrain.saveRow [j + 1] = p2Last;
p2Last = p2;
}
gameData.render.terrain.saveRow [j + 1] = p2Last;
delta_j = -delta_j; //restore sign of j
}
//now do i from other end
delta_i = -delta_i; //going the other way now...
gameData.render.terrain.vStartPoint += mSurfaceOrient.RVec () *
((iHigh-iLow)*TERRAIN_GRID_SCALE);
G3TransformAndEncodePoint (&pLast, gameData.render.terrain.vStartPoint);
pLowSave = pLast;
for (j = jLow; j <= jHigh; j++) {
G3AddDeltaVec (gameData.render.terrain.saveRow + j, &pLast, get_dy_vec (HEIGHT (iHigh, j)));
if (j == jHigh)
pHighSave = pLast;
else
G3AddDeltaVec (&pLast, &pLast, &delta_j);
}
for (i = iHigh - 1; i >= iViewer; i--) {
G3AddDeltaVec (&pLowSave, &pLowSave, &delta_i);
pLast = pLowSave;
G3AddDeltaVec (&p2Last, &pLast, get_dy_vec (HEIGHT (i, jLow)));
for (j = jLow; j < jViewer; j++) {
G3AddDeltaVec (&p, &pLast, &delta_j);
G3AddDeltaVec (&p2, &p, get_dy_vec (HEIGHT (i, j + 1)));
DrawTerrainCell (i, j, &p2Last, &p2,
gameData.render.terrain.saveRow + j + 1,
gameData.render.terrain.saveRow + j);
pLast = p;
gameData.render.terrain.saveRow [j] = p2Last;
p2Last = p2;
}
delta_j = -delta_j; //don't have a delta sub...
G3AddDeltaVec (&pHighSave, &pHighSave, &delta_i);
pLast = pHighSave;
G3AddDeltaVec (&p2Last, &pLast, get_dy_vec (HEIGHT (i, jHigh)));
for (j = jHigh - 1; j >= jViewer; j--) {
G3AddDeltaVec (&p, &pLast, &delta_j);
G3AddDeltaVec (&p2, &p, get_dy_vec (HEIGHT (i, j)));
DrawTerrainCell (i, j, &p2, &p2Last,
gameData.render.terrain.saveRow + j + 1,
gameData.render.terrain.saveRow + j);
pLast = p;
gameData.render.terrain.saveRow [j + 1] = p2Last;
p2Last = p2;
}
gameData.render.terrain.saveRow [j + 1] = p2Last;
delta_j = -delta_j; //restore sign of j
}
}
void CParticle::Setup (float fBrightness, char nFrame, char nRotFrame, tParticleVertex* pb, int nThread)
{
CFloatVector3 vCenter, uVec, rVec;
float fScale;
vCenter.Assign (m_vPos);
if ((m_nType <= SMOKE_PARTICLES) && m_bBlowUp) {
#if DBG
if (m_nFadeType == 3)
fScale = 1.0;
else if (m_decay > 0.9f)
fScale = (1.0f - pow (m_decay, 44.0f)) / float (pow (m_decay, 0.25f));
else
fScale = 1.0f / float (pow (m_decay, 0.25f));
#else
fScale = (m_nFadeType == 3)
? 1.0f
: (m_decay > 0.9f) // start from zero size by scaling with pow (m_decay, 44f) which is < 0.01 for m_decay == 0.9f
? (1.0f - pow (m_decay, 44.0f)) / float (pow (m_decay, 0.3333333f))
: 1.0f / float (pow (m_decay, 0.3333333f));
#endif
}
else {
fScale = m_decay;
}
pb [0].color =
pb [1].color =
pb [2].color =
pb [3].color = m_renderColor;
float hx = ParticleImageInfo (m_nType).xBorder;
pb [m_nOrient].texCoord.v.u =
pb [(m_nOrient + 3) % 4].texCoord.v.u = m_texCoord.v.u + hx;
pb [(m_nOrient + 1) % 4].texCoord.v.u =
pb [(m_nOrient + 2) % 4].texCoord.v.u = m_texCoord.v.u + m_deltaUV - hx;
float hy = ParticleImageInfo (m_nType).yBorder;
pb [m_nOrient].texCoord.v.v =
pb [(m_nOrient + 1) % 4].texCoord.v.v = m_texCoord.v.v + hy;
pb [(m_nOrient + 2) % 4].texCoord.v.v =
pb [(m_nOrient + 3) % 4].texCoord.v.v = m_texCoord.v.v + m_deltaUV - hy;
if ((m_nType == BUBBLE_PARTICLES) && gameOpts->render.particles.bWiggleBubbles)
vCenter [X] += (float) sin (nFrame / 4.0f * Pi) / (10 + rand () % 6);
if (m_bRotate && gameOpts->render.particles.bRotate) {
int i = (m_nOrient & 1) ? 63 - m_nRotFrame : m_nRotFrame;
CFixMatrix mOrient = gameData.objs.viewerP->info.position.mOrient * mRot [i];
uVec.Assign (mOrient.UVec ());
rVec.Assign (mOrient.RVec ());
}
else {
uVec.Assign (gameData.objs.viewerP->info.position.mOrient.UVec ());
rVec.Assign (gameData.objs.viewerP->info.position.mOrient.RVec ());
}
uVec *= m_nHeight * fScale;
rVec *= m_nWidth * fScale;
pb [0].vertex = vCenter - rVec - uVec;
pb [1].vertex = vCenter - rVec + uVec;
pb [2].vertex = vCenter + rVec + uVec;
pb [3].vertex = vCenter + rVec - uVec;
}
void SetRenderView (fix nEyeOffset, short *pnStartSeg, int bOglScale)
{
short nStartSeg;
gameData.render.mine.viewerEye = gameData.objs.viewerP->info.position.vPos;
if (nEyeOffset) {
gameData.render.mine.viewerEye += gameData.objs.viewerP->info.position.mOrient.RVec () * nEyeOffset;
}
externalView.SetPos (NULL);
if (gameStates.render.cameras.bActive) {
nStartSeg = gameData.objs.viewerP->info.nSegment;
G3SetViewMatrix (gameData.render.mine.viewerEye, gameData.objs.viewerP->info.position.mOrient, gameStates.render.xZoom, bOglScale);
}
else {
if (!pnStartSeg)
nStartSeg = gameStates.render.nStartSeg;
else {
nStartSeg = FindSegByPos (gameData.render.mine.viewerEye, gameData.objs.viewerP->info.nSegment, 1, 0);
if (!gameStates.render.nWindow && (gameData.objs.viewerP == gameData.objs.consoleP)) {
externalView.SetPoint (gameData.objs.viewerP);
if (nStartSeg == -1)
nStartSeg = gameData.objs.viewerP->info.nSegment;
}
}
if ((gameData.objs.viewerP == gameData.objs.consoleP) && transformation.m_info.bUsePlayerHeadAngles) {
CFixMatrix mHead, mView;
mHead = CFixMatrix::Create(transformation.m_info.playerHeadAngles);
mView = gameData.objs.viewerP->info.position.mOrient * mHead;
G3SetViewMatrix (gameData.render.mine.viewerEye, mView, gameStates.render.xZoom, bOglScale);
}
else if (gameStates.render.bRearView && (gameData.objs.viewerP == gameData.objs.consoleP)) {
#if 1
CFixMatrix mView;
mView = gameData.objs.viewerP->info.position.mOrient;
mView.FVec ().Neg ();
mView.RVec ().Neg ();
#else
CFixMatrix mHead, mView;
transformation.m_info.playerHeadAngles [PA] = 0;
transformation.m_info.playerHeadAngles [BA] = 0x7fff;
transformation.m_info.playerHeadAngles [HA] = 0x7fff;
VmAngles2Matrix (&mHead, &transformation.m_info.playerHeadAngles);
VmMatMul (&mView, &gameData.objs.viewerP->info.position.mOrient, &mHead);
#endif
G3SetViewMatrix (gameData.render.mine.viewerEye, mView, //gameStates.render.xZoom, bOglScale);
FixDiv (gameStates.render.xZoom, gameStates.zoom.nFactor), bOglScale);
}
else if ((gameData.objs.viewerP == gameData.objs.consoleP) && (!IsMultiGame || gameStates.app.bHaveExtraGameInfo [1])) {
gameStates.zoom.nMinFactor = I2X (gameStates.render.glAspect);
gameStates.zoom.nMaxFactor = gameStates.zoom.nMinFactor * 5;
HandleZoom ();
if ((gameData.objs.viewerP == gameData.objs.consoleP) &&
#if DBG
gameStates.render.bChaseCam) {
#else
gameStates.render.bChaseCam && (!IsMultiGame || IsCoopGame || EGI_FLAG (bEnableCheats, 0, 0, 0))) {
#endif
externalView.GetViewPoint ();
G3SetViewMatrix (gameData.render.mine.viewerEye,
externalView.GetPos () ? externalView.GetPos ()->mOrient : gameData.objs.viewerP->info.position.mOrient,
gameStates.render.xZoom, bOglScale);
}
else
G3SetViewMatrix (gameData.render.mine.viewerEye, gameData.objs.viewerP->info.position.mOrient,
FixDiv (gameStates.render.xZoom, gameStates.zoom.nFactor), bOglScale);
}
int FireWeaponDelayedWithSpread (
CObject *objP,
ubyte nLaserType,
int nGun,
fix xSpreadR,
fix xSpreadU,
fix xDelay,
int bMakeSound,
int bHarmless,
short nLightObj)
{
short nLaserSeg;
int nFate;
CFixVector vLaserPos, vLaserDir, *vGunPoints;
CHitQuery fq;
CHitData hitData;
int nObject;
CObject* laserP;
#if FULL_COCKPIT_OFFS
int bLaserOffs = ((gameStates.render.cockpit.nType == CM_FULL_COCKPIT) &&
(objP->Index () == LOCALPLAYER.nObject));
#else
int bLaserOffs = 0;
#endif
CFixMatrix m;
int bSpectate = SPECTATOR (objP);
tObjTransformation* posP = bSpectate ? &gameStates.app.playerPos : &objP->info.position;
#if DBG
if (nLaserType == SMARTMINE_BLOB_ID)
nLaserType = nLaserType;
#endif
CreateAwarenessEvent (objP, PA_WEAPON_WALL_COLLISION);
// Find the initial vPosition of the laser
if (!(vGunPoints = GetGunPoints (objP, nGun)))
return 0;
TransformGunPoint (objP, vGunPoints, nGun, xDelay, nLaserType, &vLaserPos, &m);
//--------------- Find vLaserPos and nLaserSeg ------------------
fq.p0 = &posP->vPos;
fq.startSeg = bSpectate ? gameStates.app.nPlayerSegment : objP->info.nSegment;
fq.p1 = &vLaserPos;
fq.radP0 =
fq.radP1 = 0x10;
fq.thisObjNum = objP->Index ();
fq.ignoreObjList = NULL;
fq.flags = FQ_CHECK_OBJS | FQ_IGNORE_POWERUPS;
fq.bCheckVisibility = false;
nFate = FindHitpoint (&fq, &hitData);
nLaserSeg = hitData.hit.nSegment;
if (nLaserSeg == -1) { //some sort of annoying error
return -1;
}
//SORT OF HACK... IF ABOVE WAS CORRECT THIS WOULDNT BE NECESSARY.
if (CFixVector::Dist (vLaserPos, posP->vPos) > 3 * objP->info.xSize / 2) {
return -1;
}
if (nFate == HIT_WALL) {
return -1;
}
#if 0
//as of 12/6/94, we don't care if the laser is stuck in an object. We
//just fire away normally
if (nFate == HIT_OBJECT) {
if (OBJECTS [hitData.hitObject].nType == OBJ_ROBOT)
OBJECTS [hitData.hitObject].Die ();
if (OBJECTS [hitData.hitObject].nType != OBJ_POWERUP)
return;
}
#endif
// Now, make laser spread out.
vLaserDir = m.FVec ();
if (xSpreadR || xSpreadU) {
vLaserDir += m.RVec () * xSpreadR;
vLaserDir += m.UVec () * xSpreadU;
}
if (bLaserOffs)
vLaserDir += m.UVec () * LASER_OFFS;
nObject = CreateNewWeapon (&vLaserDir, &vLaserPos, nLaserSeg, objP->Index (), nLaserType, bMakeSound);
// Omega cannon is a hack, not surprisingly. Don't want to do the rest of this stuff.
if (nLaserType == OMEGA_ID)
return -1;
if (nObject == -1)
return -1;
//TrackWeaponObject (nObject, int (objP->info.nId));
laserP = OBJECTS + nObject;
if ((nLaserType == GUIDEDMSL_ID) && gameData.multigame.bIsGuided)
gameData.objs.guidedMissile [objP->info.nId].objP = laserP;
gameData.multigame.bIsGuided = 0;
if (gameData.objs.bIsMissile [nLaserType] && (nLaserType != GUIDEDMSL_ID)) {
if (!gameData.objs.missileViewerP && (objP->info.nId == gameData.multiplayer.nLocalPlayer))
gameData.objs.missileViewerP = laserP;
}
// If this weapon is supposed to be silent, set that bit!
if (!bMakeSound)
laserP->info.nFlags |= OF_SILENT;
// If this weapon is supposed to be silent, set that bit!
if (bHarmless)
laserP->info.nFlags |= OF_HARMLESS;
// If the object firing the laser is the CPlayerData, then indicate the laser object so robots can dodge.
// New by MK on 6/8/95, don't let robots evade proximity bombs, thereby decreasing uselessness of bombs.
if ((objP == gameData.objs.consoleP) && !WeaponIsPlayerMine (laserP->info.nId))
gameStates.app.bPlayerFiredLaserThisFrame = nObject;
if (gameStates.app.cheats.bHomingWeapons || gameData.weapons.info [nLaserType].homingFlag) {
if (objP == gameData.objs.consoleP) {
laserP->cType.laserInfo.nHomingTarget = FindHomingObject (&vLaserPos, laserP);
gameData.multigame.laser.nTrack = laserP->cType.laserInfo.nHomingTarget;
}
else {// Some other CPlayerData shot the homing thing
Assert (IsMultiGame);
laserP->cType.laserInfo.nHomingTarget = gameData.multigame.laser.nTrack;
}
}
lightClusterManager.Add (nObject, nLightObj);
return nObject;
}
