void GameTacMap::drawSensor(const Stuff::Vector3D& pos, float radius, int32_t color)
{
if (color == 0)
return;
gos_VERTEX sqare[4];
if (radius > 1)
radius += land->metersPerCell * 6.f; // a little fudge
radius *= ((float)(right - left)) / (land->metersPerCell * land->realVerticesMapSide * 3.f);
for (size_t i = 0; i < 4; ++i)
{
sqare[i].z = 0;
sqare[i].rhw = .5;
sqare[i].argb = color;
sqare[i].frgb = 0;
}
worldToTacMap((Stuff::Vector3D&)pos, sqare[0]);
sqare[1].x = sqare[0].x;
sqare[1].y = sqare[0].y + 1;
sqare[2].x = sqare[0].x + 1;
sqare[2].y = sqare[0].y;
sqare[3].x = sqare[0].x + 1;
sqare[3].y = sqare[0].y + 1;
// need to draw that round thing
Stuff::Vector2DOf<int32_t> center;
Stuff::Vector2DOf<int32_t> radii;
center.x = float2long(sqare[1].x);
center.y = float2long(sqare[1].y);
radii.x = 2.0f * float2long(radius + .5);
radii.y = 2.0f * float2long(radius + .5);
EllipseElement circle(center, radii, color, 0);
RECT rect = {left, top, right, bottom};
circle.setClip(rect);
circle.draw();
}
//---------------------------------------------------------------------------
void Clouds::update (void)
{
renderClouds = false;
scrollU += frameLength * SCROLL_U_FACTOR;
scrollV += frameLength * SCROLL_V_FACTOR;
if (scrollU > 1.0f)
scrollU -= 1.0f;
if (scrollV > 1.0f)
scrollV -= 1.0f;
if (scrollU < -1.0f)
scrollU += 1.0f;
if (scrollV < -1.0f)
scrollV += 1.0f;
//---------------------------------------------------------------------
// If projectionAngle is less then some magic number, draw the clouds.
// Otherwise, do not do anything!
if (eye->active && eye->usePerspective && (eye->getProjectionAngle() < MAX_CLOUDS_ANGLE))
{
//renderClouds = true;
//-------------------------------------------------------
// Create the cloud grid based on camera CENTER position.
Stuff::Vector3D centerPosition(eye->getPosition());
//-------------------------------------------------------
// Create a topLeft vertex
float tLeftX = centerPosition.x + MAX_CLOUDS_SIZE;
float tLeftY = centerPosition.y + MAX_CLOUDS_SIZE;
//-------------------------------------------------------
// Create the grid.
long cloudInc = float2long(MAX_CLOUDS_SIZE * 2.0f / gridSize);
float uvInc = MAX_UV_REPEAT / float(gridSize);
for (long y=0;y<gridSize;y++)
{
for (long x=0;x<gridSize;x++)
{
cloudVertices[x + (y*gridSize)].vx = tLeftX - (cloudInc * x);
cloudVertices[x + (y*gridSize)].vy = tLeftY - (cloudInc * y);
cloudVertices[x + (y*gridSize)].pu = CLOUD_START_U + (uvInc * x);
cloudVertices[x + (y*gridSize)].pv = CLOUD_START_V + (uvInc * y);
}
}
//-------------------------------------------------------
// Transform Grid
long gridTotal = gridSize * gridSize;
for (long i=0;i<gridTotal;i++)
{
//----------------------------------------------------------------------------------------
// Figure out if we are in front of camera or not. Should be faster then actual project!
// Should weed out VAST overwhelming majority of vertices!
bool onScreen = true;
//-----------------------------------------------------------------
// Find angle between lookVector of Camera and vector from camPos
// to Target. If angle is less then halfFOV, object is visible.
//-------------------------------------------------------------------
// Then figure out if FarClipped. Should weed out a boatload more!
float hazeFactor = 0.0f;
Stuff::Point3D Distance;
Stuff::Point3D vPosition;
Stuff::Point3D eyePosition(eye->getPosition());
vPosition.x = cloudVertices[i].vx;;
vPosition.y = cloudVertices[i].vy;
vPosition.z = centerPosition.z;
Distance.Subtract(eyePosition,vPosition);
float eyeDistance = Distance.GetApproximateLength();
if (eyeDistance > Camera::MaxClipDistance)
{
hazeFactor = 1.0f;
//onScreen = false;
}
else if (eyeDistance > Camera::MinHazeDistance)
{
hazeFactor = (eyeDistance - Camera::MinHazeDistance) * Camera::DistanceFactor;
}
else
{
hazeFactor = 0.0f;
}
//------------------------------------------------------------
// Calculate the HazeDWORD here
if (hazeFactor != 0.0f)
{
float fogFactor = 1.0 - hazeFactor;
DWORD distFog = float2long(fogFactor * 255.0f);
cloudVertices[i].fogRGB = (distFog<<24) + (0xffffff);
}
else
{
cloudVertices[i].fogRGB = 0xffffffff;
}
if (onScreen)
{
Stuff::Vector3D Distance;
Stuff::Point3D objPosition;
Stuff::Point3D eyePosition(eye->getCameraOrigin());
objPosition.x = -cloudVertices[i].vx;
objPosition.y = CLOUD_ALTITUDE;
objPosition.z = cloudVertices[i].vy;
Distance.Subtract(objPosition,eyePosition);
Distance.Normalize(Distance);
float cosine = Distance * eye->getLookVector();
if (cosine > eye->cosHalfFOV)
onScreen = true;
else
onScreen = false;
}
else
{
hazeFactor = 1.0f;
}
Stuff::Vector3D vertex3D(cloudVertices[i].vx,cloudVertices[i].vy,(CLOUD_ALTITUDE+eye->getCameraOrigin().y));
Stuff::Vector4D screenPos;
bool inView = eye->projectZ(vertex3D,screenPos);
cloudVertices[i].px = screenPos.x;
cloudVertices[i].py = screenPos.y;
cloudVertices[i].pz = screenPos.z;
cloudVertices[i].pw = screenPos.w;
//------------------------------------------------------------
// Fix clip. Vertices can all be off screen and triangle
// still needs to be drawn!
cloudVertices[i].clipInfo = onScreen && inView;
//------------------------------------------------------------
// Still need to scrollUVs here!
cloudVertices[i].pu += scrollU;
cloudVertices[i].pv += scrollV;
}
for (y=0;y<(gridSize-1);y++)
{
for (long x=0;x<(gridSize-1);x++)
{
CloudVertexPtr cloudVertex0 = &(cloudVertices[x + (y *gridSize)]);
CloudVertexPtr cloudVertex1 = &(cloudVertices[(x+1) + (y *gridSize)]);
CloudVertexPtr cloudVertex2 = &(cloudVertices[(x+1) + ((y+1)*gridSize)]);
CloudVertexPtr cloudVertex3 = &(cloudVertices[x + ((y+1)*gridSize)]);
bool clipCheck = (cloudVertex0->clipInfo || cloudVertex1->clipInfo || cloudVertex2->clipInfo);
if (clipCheck && ((cloudVertex0->pz < 1.0f) && (cloudVertex0->pz > 0.0f) &&
(cloudVertex1->pz < 1.0f) && (cloudVertex1->pz > 0.0f) &&
(cloudVertex2->pz < 1.0f) && (cloudVertex2->pz > 0.0f)))
{
mcTextureManager->addTriangle(mcTextureNodeIndex,MC2_DRAWALPHA);
}
clipCheck = (cloudVertex0->clipInfo || cloudVertex2->clipInfo || cloudVertex3->clipInfo);
if (clipCheck && ((cloudVertex0->pz < 1.0f) && (cloudVertex0->pz > 0.0f) &&
(cloudVertex2->pz < 1.0f) && (cloudVertex2->pz > 0.0f) &&
(cloudVertex3->pz < 1.0f) && (cloudVertex3->pz > 0.0f)))
{
mcTextureManager->addTriangle(mcTextureNodeIndex,MC2_DRAWALPHA);
}
}
}
}
}
//---------------------------------------------------------------------
void CraterManager::render (void)
{
if (!useNonWeaponEffects)
return;
//-----------------------------------------------------
// Run through all craters in list and render anything
// which not clipped or an invalid_crater
CraterDataPtr currCrater = craterList;
for (long i=0;i<(long)maxCraters;i++,currCrater++)
{
if (currCrater->craterShapeId != -1)
{
long handleOffset = 1;
float uvAdd = 0.125;
if (currCrater->craterShapeId >= MAX_FOOTPRINTS)
{
handleOffset = 0;
uvAdd = 0.50;
}
bool onScreen1 = eye->projectZ(currCrater->position[0],currCrater->screenPos[0]);
bool onScreen2 = eye->projectZ(currCrater->position[1],currCrater->screenPos[1]);
bool onScreen3 = eye->projectZ(currCrater->position[2],currCrater->screenPos[2]);
bool onScreen4 = eye->projectZ(currCrater->position[3],currCrater->screenPos[3]);
//--------------------------------------------------
// First, if we are using perspective, figure out
// if object too far from camera. Far Clip Plane.
float hazeFactor = 0.0f;
if (eye->usePerspective)
{
Stuff::Point3D Distance;
Stuff::Point3D objPosition;
Stuff::Point3D eyePosition(eye->getCameraOrigin());
objPosition.x = -currCrater->position[0].x;
objPosition.y = currCrater->position[0].z;
objPosition.z = currCrater->position[0].y;
Distance.Subtract(objPosition,eyePosition);
float eyeDistance = Distance.GetApproximateLength();
if (eyeDistance > Camera::MaxClipDistance)
{
onScreen1 = false;
onScreen2 = false;
onScreen3 = false;
onScreen4 = false;
}
else if (eyeDistance > Camera::MinHazeDistance)
{
hazeFactor = (eyeDistance - Camera::MinHazeDistance) * Camera::DistanceFactor;
}
else
{
hazeFactor = 0.0f;
}
}
//----------------
// Check clipping
if (onScreen1 || onScreen2 || onScreen3 || onScreen4)
{
DWORD lightRGB = 0xffffffff;
DWORD specR = 0, specB = 0, specG = 0;
unsigned char lightr = 0xff,lightg = 0xff,lightb = 0xff;
lightr = eye->ambientRed;
lightg = eye->ambientGreen;
lightb = eye->ambientBlue;
lightRGB = lightb + (lightr<<16) + (lightg << 8) + (0xff << 24);
if (Terrain::terrainTextures2)
{
if (TerrainQuad::rainLightLevel < 1.0f)
{
lightr = (float)lightr * TerrainQuad::rainLightLevel;
lightb = (float)lightb * TerrainQuad::rainLightLevel;
lightg = (float)lightg * TerrainQuad::rainLightLevel;
}
if (TerrainQuad::lighteningLevel > 0x0)
{
specR = specG = specB = TerrainQuad::lighteningLevel;
}
lightRGB = lightb + (lightr<<16) + (lightg << 8) + (0xff << 24);
}
DWORD fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB;
if (useFog)
{
DWORD fogValue = 0xff;
float fogStart = eye->fogStart;
float fogFull = eye->fogFull;
if (currCrater->position[0].z < fogStart)
{
float fogFactor = fogStart - currCrater->position[0].z;
if (fogFactor < 0.0)
fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB;
else
{
fogFactor /= (fogStart - fogFull);
if (fogFactor <= 1.0)
{
fogFactor *= fogFactor;
fogFactor = 1.0 - fogFactor;
fogFactor *= 256.0;
}
else
{
fogFactor = 256.0;
}
unsigned char fogResult = fogFactor;
fogValue = fogFactor;
fogRGB = (fogResult << 24) + (specR<<16) + (specG<<8) + specB;
}
}
else
{
fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB;
}
if (hazeFactor != 0.0f)
{
float fogFactor = 1.0 - hazeFactor;
DWORD distFog = float2long(fogFactor * 255.0f);
if (distFog < fogValue)
fogValue = distFog;
fogRGB = (fogValue << 24) + (specR << 16) + (specG << 8) + (specB);
}
}
if (drawOldWay)
{
//------------------------------------
// Replace with Polygon Quad Elements
gos_VERTEX gVertex[4];
gVertex[0].x = currCrater->screenPos[0].x;
gVertex[0].y = currCrater->screenPos[0].y;
gVertex[0].z = currCrater->screenPos[0].z;
gVertex[0].rhw = currCrater->screenPos[0].w;
gVertex[0].u = craterUVTable[(currCrater->craterShapeId*2)];
gVertex[0].v = craterUVTable[(currCrater->craterShapeId*2)+1];
gVertex[0].argb = lightRGB;
gVertex[0].frgb = fogRGB;
gVertex[1].x = currCrater->screenPos[1].x;
gVertex[1].y = currCrater->screenPos[1].y;
gVertex[1].z = currCrater->screenPos[1].z;
gVertex[1].rhw = currCrater->screenPos[1].w;
gVertex[1].u = gVertex[0].u + uvAdd;
gVertex[1].v = gVertex[0].v;
gVertex[1].argb = lightRGB;
gVertex[1].frgb = fogRGB;
gVertex[2].x = currCrater->screenPos[2].x;
gVertex[2].y = currCrater->screenPos[2].y;
gVertex[2].z = currCrater->screenPos[2].z;
gVertex[2].rhw = currCrater->screenPos[2].w;
gVertex[2].u = gVertex[1].u;
gVertex[2].v = gVertex[0].v + uvAdd;
gVertex[2].argb = lightRGB;
gVertex[2].frgb = fogRGB;
gVertex[3].x = currCrater->screenPos[3].x;
gVertex[3].y = currCrater->screenPos[3].y;
gVertex[3].z = currCrater->screenPos[3].z;
gVertex[3].rhw = currCrater->screenPos[3].w;
gVertex[3].u = gVertex[0].u;
gVertex[3].v = gVertex[2].v;
gVertex[3].argb = lightRGB;
gVertex[3].frgb = fogRGB;
TexturedPolygonQuadElement element;
element.init(gVertex,craterTextureHandles[handleOffset],false,false);
//-----------------------------------------------------
// FOG time. Set Render state to FOG on!
if (useFog)
{
DWORD fogColor = eye->fogColor;
gos_SetRenderState( gos_State_Fog, (int)&fogColor);
}
else
{
gos_SetRenderState( gos_State_Fog, 0);
}
element.draw();
gos_SetRenderState( gos_State_Fog, 0); //ALWAYS SHUT FOG OFF WHEN DONE!
}
else
{
//------------------------------------
gos_VERTEX gVertex[3];
gos_VERTEX sVertex[3];
gVertex[0].x = sVertex[0].x = currCrater->screenPos[0].x;
gVertex[0].y = sVertex[0].y = currCrater->screenPos[0].y;
gVertex[0].z = sVertex[0].z = currCrater->screenPos[0].z;
gVertex[0].rhw = sVertex[0].rhw = currCrater->screenPos[0].w;
gVertex[0].u = sVertex[0].u = craterUVTable[(currCrater->craterShapeId*2)];
gVertex[0].v = sVertex[0].v = craterUVTable[(currCrater->craterShapeId*2)+1];
gVertex[0].argb = sVertex[0].argb = lightRGB;
gVertex[0].frgb = sVertex[0].frgb = fogRGB;
gVertex[1].x = currCrater->screenPos[1].x;
gVertex[1].y = currCrater->screenPos[1].y;
gVertex[1].z = currCrater->screenPos[1].z;
gVertex[1].rhw = currCrater->screenPos[1].w;
gVertex[1].u = gVertex[0].u + uvAdd;
gVertex[1].v = gVertex[0].v;
gVertex[1].argb = lightRGB;
gVertex[1].frgb = fogRGB;
gVertex[2].x = sVertex[1].x = currCrater->screenPos[2].x;
gVertex[2].y = sVertex[1].y = currCrater->screenPos[2].y;
gVertex[2].z = sVertex[1].z = currCrater->screenPos[2].z;
gVertex[2].rhw = sVertex[1].rhw = currCrater->screenPos[2].w;
gVertex[2].u = sVertex[1].u = gVertex[1].u;
gVertex[2].v = sVertex[1].v = gVertex[0].v + uvAdd;
gVertex[2].argb = sVertex[1].argb = lightRGB;
gVertex[2].frgb = sVertex[1].frgb = fogRGB;
sVertex[2].x = currCrater->screenPos[3].x;
sVertex[2].y = currCrater->screenPos[3].y;
sVertex[2].z = currCrater->screenPos[3].z;
sVertex[2].rhw = currCrater->screenPos[3].w;
sVertex[2].u = gVertex[0].u;
sVertex[2].v = gVertex[2].v;
sVertex[2].argb = lightRGB;
sVertex[2].frgb = fogRGB;
if (currCrater->craterShapeId > TURKINA_FOOTPRINT) //We are standard crater.
{
mcTextureManager->addVertices(craterTextureIndices[handleOffset],gVertex,MC2_ISCRATERS | MC2_DRAWALPHA | MC2_ISTERRAIN);
mcTextureManager->addVertices(craterTextureIndices[handleOffset],sVertex,MC2_ISCRATERS | MC2_DRAWALPHA | MC2_ISTERRAIN);
}
else //We are a footprint
{
mcTextureManager->addVertices(craterTextureIndices[handleOffset],gVertex,MC2_ISCRATERS | MC2_DRAWALPHA);
mcTextureManager->addVertices(craterTextureIndices[handleOffset],sVertex,MC2_ISCRATERS | MC2_DRAWALPHA);
}
}
}
}
}
}
