/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*********************************************************************************************** 
 ***                            Confidential - Westwood Studios                              *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Commando                                                     * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/Combat/radar.cpp                             $* 
 *                                                                                             * 
 *                      $Author:: Byon_g                                                      $* 
 *                                                                                             * 
 *                     $Modtime:: 1/23/02 5:48p                                               $* 
 *                                                                                             * 
 *                    $Revision:: 68                                                          $* 
 *                                                                                             * 
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "radar.h"
#include "assets.h"
#include "soldier.h"
#include "gameobjmanager.h"
#include "debug.h"
#include "combat.h"
#include "render2d.h"
#include "texture.h"
#include "playertype.h"
#include "globalsettings.h"
#include "objectives.h"
#include "globalsettings.h"
#include "wwprofile.h"
#include "wwaudio.h"
#include "render2dsentence.h"
#include "stylemgr.h"
#include "translatedb.h"
#include "string_ids.h"


DynamicVectorClass<RadarMarkerClass>	RadarManager::Markers;
Render2DClass						*	RadarManager::Renderer;
unsigned long							RadarManager::BlipColors[ NUM_BLIP_COLOR_TYPES ];
const PhysicalGameObj				*	RadarManager::BracketObj = NULL;
RectClass								RadarManager::BlipUV[ NUM_BLIP_TYPES ];
bool										RadarManager::IsHidden = false;
float										RadarManager::HiddenTimer = 0.0f;
RadarModeEnum							RadarManager::RadarMode = RADAR_ALL;
Render2DSentenceClass *				RadarManager::CompassRenderers[8];
int										RadarManager::CurrentCompassRendererIndex;

static		Matrix3D					RadarTM;
#if 0
static		float						RadarSweep					= 0;
static		float						RadarSweepMove;
#endif

DynamicVectorClass<Render2DClass *>		Blips;

const char * RadarManager::Get_Blip_Shape_Type_Name( int index )
{
	static const char * names[ NUM_BLIP_SHAPE_TYPES ] = {
		"None",
		"Human",
		"Vehicle",
		"Stationary",
		"Objective",
	};

	return names[index];
}

/*
**
*/
static	const RectClass &	Scale_UV( const RectClass & uv, float texture_size )
{
	static RectClass new_uv;
	new_uv = uv;
	new_uv.Scale( 1/texture_size );
	return new_uv;
}


void	RadarManager::Set_Hidden( bool onoff )	
{ 
	if ( IsHidden != onoff ) {

		int sound_id = 0;
		if ( onoff ) {
			sound_id = HUDGlobalSettingsDef::Get_Instance()->RadarOnSoundID;
		} else { 
			sound_id = HUDGlobalSettingsDef::Get_Instance()->RadarOffSoundID;
		}

		if (sound_id != 0) {
			WWAudioClass::Get_Instance ()->Create_Instant_Sound (sound_id, Matrix3D (1));
		}

		IsHidden = onoff; 
	}
}

/*
**
*/

#define		RADAR_TEXTURE		"HUD_MAIN.TGA"

extern Vector2 INFO_UV_SCALE;
extern Vector2 RADAR_RINGS_UV_UL;
extern Vector2 RADAR_RINGS_UV_LR;
extern Vector2 RADAR_RINGS_L_OFFSET;
extern Vector2 RADAR_RINGS_R_OFFSET;
extern Vector2 RADAR_STAR_UV_UL;
extern Vector2 RADAR_STAR_UV_LR;
extern Vector2 RADAR_SQUARE_UV_UL;
extern Vector2 RADAR_SQUARE_UV_LR;
extern Vector2 RADAR_TRIANGLE_UV_UL;
extern Vector2 RADAR_TRIANGLE_UV_LR;
extern Vector2 RADAR_CIRCLE_UV_UL;
extern Vector2 RADAR_CIRCLE_UV_LR;
extern Vector2 RADAR_BRACKET_UV_UL;
extern Vector2 RADAR_BRACKET_UV_LR;
extern Vector2 RADAR_SWEEP_UV_UL;
extern Vector2 RADAR_SWEEP_UV_LR;


void 	RadarManager::Init()
{
	int i;

	BracketObj = NULL;

	Renderer = new Render2DClass();
	Renderer->Set_Texture( RADAR_TEXTURE );
	Renderer->Set_Coordinate_Range( Render2DClass::Get_Screen_Resolution() ); 

	// Init Colors
	for ( i = 0; i < NUM_BLIP_COLOR_TYPES; i++ ) {
		BlipColors[ i ] = 0xFFFFFFFF;
	}
	if ( HUDGlobalSettingsDef::Get_Instance() != NULL ) {
		BlipColors[ BLIP_COLOR_TYPE_NOD ] =						HUDGlobalSettingsDef::Get_Instance()->Get_Nod_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_GDI ] =						HUDGlobalSettingsDef::Get_Instance()->Get_GDI_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_NEUTRAL ] =					HUDGlobalSettingsDef::Get_Instance()->Get_Neutral_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_MUTANT ] =					HUDGlobalSettingsDef::Get_Instance()->Get_Mutant_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_RENEGADE ] =				HUDGlobalSettingsDef::Get_Instance()->Get_Renegade_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_PRIMARY_OBJECTIVE ] =		HUDGlobalSettingsDef::Get_Instance()->Get_Primary_Objective_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_SECONDARY_OBJECTIVE ] =		HUDGlobalSettingsDef::Get_Instance()->Get_Secondary_Objective_Color().Convert_To_ARGB(); 
		BlipColors[ BLIP_COLOR_TYPE_TERTIARY_OBJECTIVE ] =		HUDGlobalSettingsDef::Get_Instance()->Get_Tertiary_Objective_Color().Convert_To_ARGB(); 
	}

#if 0
	const HUDGlobalSettingsDef * settings = HUDGlobalSettingsDef::Get_Instance();
	float radar_texture_size = settings->RadarTextureSize;

	BlipUV[ BLIP_SHAPE_TYPE_NONE ] =			RectClass( 0,0,0,0 );
	BlipUV[ BLIP_SHAPE_TYPE_HUMAN ] =		Scale_UV( settings->RadarHumanBlipUV, radar_texture_size );
	BlipUV[ BLIP_SHAPE_TYPE_VEHICLE ] =		Scale_UV( settings->RadarVehicleBlipUV, radar_texture_size );
	BlipUV[ BLIP_SHAPE_TYPE_STATIONARY ] =	Scale_UV( settings->RadarStationaryBlipUV, radar_texture_size );
	BlipUV[ BLIP_SHAPE_TYPE_OBJECTIVE ] =	Scale_UV( settings->RadarObjectiveBlipUV, radar_texture_size );
	BlipUV[ BLIP_BRACKET ] =					Scale_UV( settings->RadarBlipBracketUV, radar_texture_size );
	BlipUV[ BLIP_SWEEP ] =						Scale_UV( settings->RadarSweepUV, radar_texture_size );
#else
	BlipUV[ BLIP_SHAPE_TYPE_NONE ] =		RectClass( 0,0,0,0 );
	BlipUV[ BLIP_SHAPE_TYPE_HUMAN ] =		RectClass( RADAR_CIRCLE_UV_UL, RADAR_CIRCLE_UV_LR );
	BlipUV[ BLIP_SHAPE_TYPE_VEHICLE ] =		RectClass( RADAR_TRIANGLE_UV_UL, RADAR_TRIANGLE_UV_LR );
	BlipUV[ BLIP_SHAPE_TYPE_STATIONARY ] =	RectClass( RADAR_SQUARE_UV_UL, RADAR_SQUARE_UV_LR );
	BlipUV[ BLIP_SHAPE_TYPE_OBJECTIVE ] =	RectClass( RADAR_STAR_UV_UL, RADAR_STAR_UV_LR );
	BlipUV[ BLIP_BRACKET ] =				RectClass( RADAR_BRACKET_UV_UL, RADAR_BRACKET_UV_LR );
	BlipUV[ BLIP_SWEEP ] =					RectClass( RADAR_SWEEP_UV_UL, RADAR_SWEEP_UV_LR );
	BlipUV[ BLIP_SHAPE_TYPE_HUMAN ].Scale( INFO_UV_SCALE );
	BlipUV[ BLIP_SHAPE_TYPE_VEHICLE ].Scale( INFO_UV_SCALE );
	BlipUV[ BLIP_SHAPE_TYPE_STATIONARY ].Scale( INFO_UV_SCALE );
	BlipUV[ BLIP_SHAPE_TYPE_OBJECTIVE ].Scale( INFO_UV_SCALE );
	BlipUV[ BLIP_BRACKET ].Scale( INFO_UV_SCALE );
	BlipUV[ BLIP_SWEEP ].Scale( INFO_UV_SCALE );
#endif

	// Clear radar renderer pointers, these are initialized on demand
	for (i=0;i<8;++i) {
		CompassRenderers[i] = NULL;
	}

	// Don't reset the markers here, Some may have already been added when loading the level (Created)

	HiddenTimer = 0;
}

/*
**
*/
void 	RadarManager::Shutdown()
{
	if ( Renderer ) {
		delete Renderer;
		Renderer = NULL;
	}

	while ( Blips.Count() > 0 ) {
		int index = Blips.Count() - 1;
		delete Blips[ index ];
		Blips.Delete( index );
	}

	for (int i=0;i<8;++i) {
		delete CompassRenderers[i];
		CompassRenderers[i] = NULL;
	}


	Markers.Delete_All();

	IsHidden = false;		// Do this here rather than init, because init is called after load
}

/*
**
*/
enum	{
	CHUNKID_MANAGER_VARIABLES			=	630001357,
	CHUNKID_MARKER_ENTRY,

	MICROCHUNKID_IS_HIDDEN			=	1,
	MICROCHUNKID_HIDDEN_TIMER,
};

/*
**
*/
bool	RadarManager::Save( ChunkSaveClass &csave )
{
	csave.Begin_Chunk( CHUNKID_MANAGER_VARIABLES );
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_IS_HIDDEN,	IsHidden );
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_HIDDEN_TIMER,	HiddenTimer );
	csave.End_Chunk();

	for ( int i = 0; i < Markers.Count(); i++ ) {
		csave.Begin_Chunk( CHUNKID_MARKER_ENTRY );
			Markers[i].Save( csave );
		csave.End_Chunk();
	}

	return true;
}

bool	RadarManager::Load( ChunkLoadClass &cload )
{
	WWASSERT( Markers.Count() == 0 );

	while (cload.Open_Chunk()) {
		switch(cload.Cur_Chunk_ID()) {

			case CHUNKID_MANAGER_VARIABLES:
				while (cload.Open_Micro_Chunk()) {
					switch(cload.Cur_Micro_Chunk_ID()) {
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_IS_HIDDEN,	IsHidden );
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_HIDDEN_TIMER,	HiddenTimer );
						default:
							Debug_Say(("Unhandled Chunk:%d File:%s Line:%d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
							break;
					}
					cload.Close_Micro_Chunk();
				}
				break;

			case CHUNKID_MARKER_ENTRY:
			{
				RadarMarkerClass marker;
				marker.Load( cload );
				Add_Marker( marker );
				break;
			}

			default:
				Debug_Say(("Unhandled Chunk:%d File:%s Line:%d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
				break;

		}
		cload.Close_Chunk();
	}
	return true;
}

/*
**
*/
#define	RADAR_RADIUS			84
#define	BLIP_SIZE				4
#define	RADAR_FADE_STOP			(RADAR_RADIUS * 0.60f)
#define	RADAR_FADE_START		(RADAR_RADIUS * 0.50f)
#define	RADAR_CENTER_TWEAK	Vector2( 1, 2 )

Vector2	OldRadarCenter(0.0f,0.0f);
Vector2	RadarCenter(0.0f,0.0f);
float	RadarIntensity;
long	RadarColor;

float	RadarManager::Add_Blip( const Vector3 & pos, int shape_type, int color_type, float intensity, bool bracket, bool altitude_fade ) 
{
	if ( shape_type != BLIP_SHAPE_TYPE_NONE ) {

		Vector3	screen = RadarTM * pos;
		screen *= RADAR_RADIUS;
		screen *= 0.01f;	//			screen *= ZoomFactor;
		screen.Z = 0;

		float dist = screen.Length();

		if ( shape_type == BLIP_SHAPE_TYPE_OBJECTIVE ) {
			if ( dist >= RADAR_FADE_STOP ) {
				screen.Normalize();
				screen *= RADAR_FADE_STOP;
				dist = RADAR_FADE_STOP;
			}
		}

		if ( dist <= RADAR_FADE_STOP ) 
		{
#if 0
			// Find blip bearing
			float bearing = WWMath::Atan2( screen.Y, screen.X );
			// find the bering relative to sweep
			bearing = WWMath::Wrap( bearing - RadarSweep, -DEG_TO_RADF( 360 ), 0 );
			if ( bearing > -RadarSweepMove*2 ) {
				intensity = 1.0;		// Ping
			}
#else
			intensity = 1.0;		// Always Ping
#endif

			float alpha = 1.0f - ((dist - RADAR_FADE_START) / (RADAR_FADE_STOP - RADAR_FADE_START) );
			alpha = WWMath::Clamp( alpha, 0, 1 );
			if ( shape_type == BLIP_SHAPE_TYPE_OBJECTIVE ) {
				alpha = 1;
			}
			float color_alpha = alpha * intensity;
			if ( altitude_fade ) {
				color_alpha *= 0.66f;
			}


			unsigned int color = BlipColors[ color_type ];
			color &= 0x00FFFFFF;
			color |= (unsigned int)(RadarIntensity * color_alpha * 255) << 24;
			if ( Renderer ) {
				RectClass	blip( -BLIP_SIZE, -BLIP_SIZE, BLIP_SIZE, BLIP_SIZE );
				if ( altitude_fade ) {
					blip.Scale_Relative_Center( 0.66f );
				}
   				blip += Vector2( -screen.X, screen.Y );
   				blip += RadarCenter + RADAR_CENTER_TWEAK;
				RectClass uv = BlipUV[ shape_type ];
				Renderer->Add_Quad( blip, uv, color );

				if ( bracket ) {
					color = 0x0000FF00;	// Make Green
					color |= (unsigned int)(RadarIntensity * alpha * 255) << 24;
					RectClass uv = BlipUV[ BLIP_BRACKET ];
					Renderer->Add_Quad( blip, uv, color );
				}
			}
		}
	}

	return intensity;
}

#define	COMPASS_OFFSET			Vector2( 2, -73 )
#define	RADAR_Z_RANGE			3

void	RadarManager::Update( const Matrix3D & player_tm, const Vector2 & center )
{
	WWPROFILE( "Radar Update" );

	OldRadarCenter=RadarCenter;
	RadarCenter = center;

	RadarTM = player_tm;
	RadarTM.Pre_Rotate_Z( DEG_TO_RAD( -90 ) );

#if 0
	RadarSweepMove = TimeManager::Get_Frame_Seconds() * 2;
	RadarSweep -= RadarSweepMove;
	if ( RadarSweep < 0 ) {
		RadarSweep += DEG_TO_RAD( 360 );
	}
#endif

	HiddenTimer += TimeManager::Get_Frame_Seconds() * (IsHidden ? 1 : -1);
	HiddenTimer = WWMath::Clamp( HiddenTimer, 0, 1 );

	RadarIntensity = 1-HiddenTimer;
	RadarColor = ((int)((1-HiddenTimer) * 255) << 24) | 0x00FFFFFF;

	Renderer->Reset();

	if ( RadarIntensity == 0 ) {
		return;
	}

	// Radar Rings
	RectClass uv;
	RectClass draw;
	uv.Set( RADAR_RINGS_UV_UL, RADAR_RINGS_UV_LR );
	draw = uv;
	draw.Right = draw.Left + uv.Height();
	draw.Bottom = draw.Top + uv.Width();
	uv.Scale( INFO_UV_SCALE );
	draw += center + RADAR_RINGS_L_OFFSET - draw.Upper_Left();
	Renderer->Add_Quad( draw.Lower_Left(), draw.Lower_Right(), draw.Upper_Left(), draw.Upper_Right(), uv, RadarColor );
	draw += center + RADAR_RINGS_R_OFFSET - draw.Upper_Left();
	Renderer->Add_Quad_Backfaced( draw.Lower_Right(), draw.Lower_Left(), draw.Upper_Right(), draw.Upper_Left(), uv, RadarColor );

#if 0
{WWPROFILE( "Sweep" );
	// Draw sweep Line
	Vector2 edge = Vector2( -WWMath::Cos( RadarSweep ), WWMath::Sin( RadarSweep ) ) * RADAR_FADE_STOP + center;
	float width = 20;
	Vector2	corner_offset = center - edge;  	// get line relative to edge
	float temp = corner_offset.X;					// Rotate 90
	corner_offset.X = corner_offset.Y;
	corner_offset.Y = -temp;
	corner_offset.Normalize();						// scale to length width/2
	corner_offset *= width;
	RectClass uv = BlipUV[ BLIP_SWEEP ];
	Renderer->Add_Tri( edge - corner_offset, center, edge,  
		uv.Lower_Left(),	uv.Upper_Right(), uv.Upper_Left(),	0xFF00FF00 & RadarColor );
}
#endif

#if 0
{WWPROFILE( "Compass" );
	// Draw the compass
	const HUDGlobalSettingsDef * settings = HUDGlobalSettingsDef::Get_Instance();
	float radar_texture_size = settings->RadarTextureSize;
	float	bering = WWMath::Wrap( (player_tm.Get_Z_Rotation() / DEG_TO_RAD( 360.0f )) + 0.25f, 0, 1 );
	int frame = (int)((bering * 8.0f) + 0.5f);
	RectClass compass( Vector2( 0, 0 ), settings->RadarCompassSize );
//	compass += Render2DClass::Get_Screen_Resolution().Lower_Left() + settings->RadarCompassOffset;
	compass += center + COMPASS_OFFSET;
	RectClass compass_uv = Scale_UV( settings->RadarCompassBaseUV, radar_texture_size );
	compass_uv += (settings->RadarCompassUVOffset/radar_texture_size) * (frame & 7);
	Renderer->Add_Quad( compass, compass_uv, RadarColor );
}

#else
	float	bering = WWMath::Wrap( (player_tm.Get_Z_Rotation() / DEG_TO_RAD( 360.0f )) + 0.25f, 0, 1 );
	CurrentCompassRendererIndex = (int)((bering * 8.0f) + 0.5f);
	CurrentCompassRendererIndex&=7;

	int dir[8] = { IDS_HUD_COMPASS_N, IDS_HUD_COMPASS_NE, IDS_HUD_COMPASS_E, IDS_HUD_COMPASS_SE, 
						IDS_HUD_COMPASS_S, IDS_HUD_COMPASS_SW, IDS_HUD_COMPASS_W, IDS_HUD_COMPASS_NW };

	// If the renderer object for this particular radar direction hasn't been created, create it now...
	if (!CompassRenderers[CurrentCompassRendererIndex]) {
		CompassRenderers[CurrentCompassRendererIndex]=new Render2DSentenceClass();
		FontCharsClass *font = StyleMgrClass::Peek_Font( StyleMgrClass::FONT_INGAME_TXT );
		CompassRenderers[CurrentCompassRendererIndex]->Set_Font( font );
		CompassRenderers[CurrentCompassRendererIndex]->Reset();
		CompassRenderers[CurrentCompassRendererIndex]->Build_Sentence(TRANSLATE(dir[CurrentCompassRendererIndex]));
		Vector2 text_size=CompassRenderers[CurrentCompassRendererIndex]->Get_Text_Extents(TRANSLATE(dir[CurrentCompassRendererIndex]));

		Vector2 pos = center + COMPASS_OFFSET - (text_size * 0.5f);
		pos.X = (int)pos.X;
		pos.Y = (int)pos.Y;
		CompassRenderers[CurrentCompassRendererIndex]->Set_Location( pos );

		CompassRenderers[CurrentCompassRendererIndex]->Draw_Sentence();
	}
	else {
		// If the radar center has moved (which should never happen unless the screen size changes)
		if (RadarCenter!=OldRadarCenter) {	
			CompassRenderers[CurrentCompassRendererIndex]->Reset();
			CompassRenderers[CurrentCompassRendererIndex]->Build_Sentence( TRANSLATE(dir[CurrentCompassRendererIndex]));
			Vector2 text_size=CompassRenderers[CurrentCompassRendererIndex]->Get_Text_Extents(TRANSLATE(dir[CurrentCompassRendererIndex]));
			Vector2 pos = center + COMPASS_OFFSET - (text_size * 0.5f);
			pos.X = (int)pos.X;
			pos.Y = (int)pos.Y;
			CompassRenderers[CurrentCompassRendererIndex]->Set_Location( pos );
			CompassRenderers[CurrentCompassRendererIndex]->Draw_Sentence();
		}
	}

#endif


	// Now build the blips
	float star_z = 0;
	if ( COMBAT_STAR ) {
		Vector3 p;
		COMBAT_STAR->Get_Position( &p );
		star_z = p.Z;
	}

{WWPROFILE( "Blips" );
	// for all physicalgameobjs
	SLNode<BaseGameObj> *objnode;
	for (	objnode = GameObjManager::Get_Game_Obj_List()->Head(); objnode; objnode = objnode->Next()) {
		PhysicalGameObj *obj = objnode->Data()->As_PhysicalGameObj();
		if ( obj ) {
			if ( obj == COMBAT_STAR ) continue;	// Don't draw the star
			if ( obj->Peek_Physical_Object() == NULL ) continue;

			// Don't draw dead soldiers
			if (	obj->As_SoldierGameObj() && 
					obj->Get_Defense_Object() && 
					obj->Get_Defense_Object()->Get_Health() <= 0.0f ) {
				continue;
			}

			//
			// TSS: Filter blips based on RadarMode
			//
			if (COMBAT_STAR != NULL && RadarMode != RADAR_ALL) {
				if (RadarMode == RADAR_NOBODY) {
					continue;
				} else {
					WWASSERT(RadarMode == RADAR_TEAMMATES);
					int other_pt = obj->Get_Player_Type();
					int my_pt = COMBAT_STAR->Get_Player_Type();
					if (my_pt != other_pt || 
					   (my_pt != PLAYERTYPE_NOD && my_pt != PLAYERTYPE_GDI)) {
						continue;
					}
				}
			}

			//
			// gth: don't show radar blips for enemy stealthed units
			//
			SmartGameObj * smart_obj = obj->As_SmartGameObj();
			if ((smart_obj != NULL) && (smart_obj->Is_Stealthed())) {

				int obj_pt = smart_obj->Get_Player_Type();
				int my_pt = COMBAT_STAR->Get_Player_Type();
				if (my_pt != obj_pt) {
					continue;
				}
			}


			Vector3 objpos;
			obj->Get_Position( &objpos );

			bool altitude_fade = false;
			float z_diff = star_z - objpos.Z;
			if ( WWMath::Fabs( z_diff ) > RADAR_Z_RANGE) {
				altitude_fade = true;
			}

//			if ( (WWMath::Fabs( z_diff ) < RADAR_Z_RANGE) || (obj->Get_Radar_Blip_Shape_Type() == BLIP_SHAPE_TYPE_OBJECTIVE) ) {
				float intensity = obj->Get_Radar_Blip_Intensity();
				bool bracket = obj == BracketObj;
				intensity = Add_Blip( objpos, obj->Get_Radar_Blip_Shape_Type(), obj->Get_Radar_Blip_Color_Type(), intensity, bracket, altitude_fade );
	#if 0
				intensity -= RadarSweepMove / DEG_TO_RAD( 360 ) * 0.666f;				// Drop Blip intensity
	#endif
				obj->Set_Radar_Blip_Intensity( WWMath::Clamp( intensity, 0, 1 ) );
//			}
		}
	}
}

	int i;

{WWPROFILE( "Objectives" );
	// for all objectives with a position
	int count = ObjectiveManager::Get_Objective_Count();
	for ( int i = 0; i < count; i++ ) {
		Objective * objective = ObjectiveManager::Get_Objective( i );
		if ( objective->DrawBlip && objective->Status == ObjectiveManager::STATUS_IS_PENDING ) {
			float intensity = objective->BlipIntensity;
			intensity = Add_Blip( objective->Position, BLIP_SHAPE_TYPE_OBJECTIVE, objective->Radar_Blip_Color_Type(), intensity, false );
#if 0
			intensity -= RadarSweepMove / DEG_TO_RAD( 360 ) * 0.666f;				// Drop Blip intensity
#endif
			objective->BlipIntensity = WWMath::Clamp( intensity, 0, 1 );
		}
	}
}

{WWPROFILE( "Markers" );
	// for all markers
	for ( i = 0; i < Markers.Count(); i++ ) {
		float intensity = Markers[i].Intensity;
		intensity = Add_Blip( Markers[i].Position, Markers[i].Type, Markers[i].Color, intensity, false );
#if 0
		intensity -= RadarSweepMove / DEG_TO_RAD( 360 ) * 0.666f;				// Drop Blip intensity
#endif
		Markers[i].Intensity = WWMath::Clamp( intensity, 0, 1 );
	}
}

}

/*
**
*/
void	RadarManager::Render( void )
{
	if ( (HiddenTimer < 1) && Renderer ) {
		Renderer->Render();

		if ( CompassRenderers[CurrentCompassRendererIndex] != NULL ) {
			CompassRenderers[CurrentCompassRendererIndex]->Render();
		}
	}
}

/*
**
*/
void	RadarManager::Clear_Marker( int id )
{
	for ( int i = 0; i < Markers.Count(); i++ ) {
		if ( Markers[i].ID == id ) {
			Markers.Delete( i );
			i--;
		}
	}
}

void	RadarManager::Change_Marker_Color( int id, int color )
{
	for ( int i = 0; i < Markers.Count(); i++ ) {
		if ( Markers[i].ID == id ) {
			Markers[i].Color = color;
		}
	}
}

/*
**
*/
RadarMarkerClass::RadarMarkerClass( void ) :
	ID( 0 ),
	Type( 0 ),
	Color( 0 ),
	Position( 0,0,0 ),
	Intensity( 0 )
{
}


enum	{
	CHUNKID_VARIABLES						=	630001403,
	XXXCHUNKID_GAME_OBJ_REF,

	MICROCHUNKID_ID						=	1,
	MICROCHUNKID_POSITION,
	XXXMICROCHUNKID_COLOR,
	XXXMICROCHUNKID_FLASH,
	XXXMICROCHUNKID_OBJECT_BASED,
	MICROCHUNKID_TYPE,
	MICROCHUNKID_COLOR,
};

bool	RadarMarkerClass::Save( ChunkSaveClass & csave )
{
	csave.Begin_Chunk( CHUNKID_VARIABLES );
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_ID, ID );
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_POSITION, Position );                    
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_TYPE, Type );                  
		WRITE_MICRO_CHUNK( csave, 	MICROCHUNKID_COLOR, Color );                  
	csave.End_Chunk();

	return true;
}

bool	RadarMarkerClass::Load( ChunkLoadClass &cload )
{
	while (cload.Open_Chunk()) {
		switch(cload.Cur_Chunk_ID()) {

			case CHUNKID_VARIABLES:
				while (cload.Open_Micro_Chunk()) {
					switch(cload.Cur_Micro_Chunk_ID()) {
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_ID, ID );
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_POSITION, Position );                    
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_TYPE, Type );                  
						READ_MICRO_CHUNK( cload, 	MICROCHUNKID_COLOR, Color );                  

						default:
							Debug_Say(("Unhandled Chunk:%d File:%s Line:%d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
							break;
					}
					cload.Close_Micro_Chunk();
				}
				break;

			default:
				Debug_Say(("Unhandled Chunk:%d File:%s Line:%d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
				break;

		}
		cload.Close_Chunk();
	}
	return true;
}