Mini map fog of war

if(projectPoint(unit->getPosition(), &screenPos))
{
 /*
 S32 team = unit->getTeam();					The original block of code that's removed now
 buff[17] = '0' + team; 
 const char* pref = Con::getVariable(buff);
 ColorF teamColor;
 dSscanf(pref, "%f %f %f", &teamColor.red, &teamColor.green, &teamColor.blue);
 glColor3f(teamColor.red, teamColor.green, teamColor.blue);
 glVertex2f(offset.x + screenPos.x, offset.y + screenPos.y);
 */

 [b]if(localTeam == unit->getTeam()){         // Only give us map vision for our team[/b]

								// Get the XY of the upper left corner that the 
								// unit can see
 drawChunkPoint.set(offset.x + screenPos.x - vision, offset.y + screenPos.y - vision);

								// Get the rect of the map to render. Since it's flipped
								// on the Y axis before rendering we need to "come in"
								// from the opposite side
 mapRect.set(screenPos.x - vision, mTextureSize - screenPos.y - vision, vision * 2, vision * 2);

								// Drop the rect from the map at point drawChunk with
								// the clipping rectangle mapRect and then flip it
 dglDrawBitmapSR(mRenderTexture, drawChunkPoint, mapRect, GFlip_Y);

								// Save the info we'll need to render the blip later
 [b]}//if[/b]

 unitIter->point.set(offset.x + screenPos.x, offset.y + screenPos.y);
 unitIter->team = unit->getTeam();
 unitIter++;
}

glPointSize(2.0f);
glColor3f(0.0, 0.0, 1.0);
glBegin(GL_POINTS);
static char buff[18];
dSprintf(buff, 18, "$Server::TeamInfo0");
unitIter = unitList;						// Reset the iterator

for(int i = 0; i < listSize; i++){
 buff[17] = char(48) + unitIter->team;             // forum font doesn't seem to like single quotes...char(48) == '0'
 const char* pref = Con::getVariable(buff);
 ColorF teamColor;
 dSscanf(pref, "%f %f %f", &teamColor.red, &teamColor.green, &teamColor.blue);
 glColor3f(teamColor.red, teamColor.green, teamColor.blue);
 
 glVertex2f(unitIter->point.x, unitIter->point.y);

 unitIter++;
}//for
glEnd();


delete []unitList;						// Cleanup!

// texture = texture to render
// in_rAt & dstRect = destination rectangle
// in_rSubRegion & srcRect = source rectangle
// complexity = number of sides to the circle
// in_flip = orientation : hard coded to flip how we need for the rts
void dglDrawBitmapCircularSR(TextureObject* texture, const Point2I& in_rAt, 
					       const RectI& in_rSubRegion, int complexity = 10, const U32 in_flip = GFlip_None);
void dglDrawBitmapCircularSR(TextureObject* texture, const RectI& dstRect,
						 const RectI& srcRect, int complexity = 10, const U32 in_flip = GFlip_None);

const F32 PI_OVER_180 = 0.01744;		// Close enough for government work

// Calls overloaded dgldrawbitmapcircularsr telling it not to stretch the image
void dglDrawBitmapCircularSR(TextureObject* texture, const Point2I& in_rAt, 
						 const RectI& srcRect, int complexity, const U32 in_flip){
			

   RectI stretch(in_rAt.x, in_rAt.y, srcRect.len_x(), srcRect.len_y());
   dglDrawBitmapCircularSR(texture, stretch, srcRect, complexity, in_flip);
}

void dglDrawBitmapCircularSR(TextureObject* texture, const RectI& dstRect,
						 const RectI& srcRect, int complexity, const U32 in_flip){

 // Make sure we're given valid info
 AssertFatal(texture != NULL, "GSurface::drawBitmapStretchSR: NULL Handle");
 if(!dstRect.isValidRect()) return;
   
 AssertFatal(srcRect.isValidRect() == true, "GSurface::drawBitmapCircularSR: routines assume normal rects");

 // Some open GL setup
 glDisable(GL_LIGHTING);
 glEnable(GL_TEXTURE_2D);
 glBindTexture(GL_TEXTURE_2D, texture->texGLName);
 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 glEnable(GL_BLEND);
 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

 // Initialize variables for the source and destination locations
 F32 dstCenterX = F32((dstRect.extent.x / 2) + dstRect.point.x);
 F32 dstCenterY = F32((dstRect.extent.y / 2) + dstRect.point.y);
 F32 srcCenterX = F32((srcRect.extent.x / 2) + srcRect.point.x) / F32(texture->texWidth);
 F32 srcCenterY = F32((srcRect.extent.y / 2) + srcRect.point.y) / F32(texture->texHeight);
 F32 dstRadius = F32(dstRect.extent.x);
 F32 srcRadius = F32(srcRect.extent.x) / F32(texture->texWidth);

 F32 i;    // used in loop counting 
 
 if(complexity < 6) complexity = 6;   // Make sure requested sides is reasonable
 else if(complexity > 36) complexity = 36;

 F32 stepBy = F32(360 / complexity); // Cuts out two more divisions pre iteration

 glColor4ub(sg_bitmapModulation.red, sg_bitmapModulation.green,
	        sg_bitmapModulation.blue, sg_bitmapModulation.alpha);

 glBegin(GL_TRIANGLE_FAN);

 glTexCoord2f(srcCenterX, srcCenterY); // Center vertex to the circle
 glVertex2f(dstCenterX, dstCenterY);

                                // Loop through building the circle. We 
                                // need to texture going the opposite
                                // direction to compensate for the map
                                // hud being rendered flipped on the
                                // Y axis
 for(F32 n = 0, i = 360; n <= 360; n += stepBy, i -= stepBy){
  glTexCoord2f(srcCenterX + srcRadius * cos(i * PI_OVER_180), srcCenterY + srcRadius * sin(i * PI_OVER_180));
  glVertex2f(dstCenterX + dstRadius * cos(n * PI_OVER_180), dstCenterY + dstRadius * sin(n * PI_OVER_180));
 }//for

 glEnd();

 glDisable(GL_BLEND);
 glDisable(GL_TEXTURE_2D);
}//dglDrawBitmapCircularSR

dglDrawBitmapCircularSR(mRenderTexture, drawChunkPoint, mapRect, 9, GFlip_Y);