#include <planet.h>

Inheritance diagram for GamePlanet:

Public Member Functions
virtual	~GamePlanet ()

virtual void	AddFog (const std::vector< AtmosphericFogMesh > &, bool optical_illusion)

Vector	AddSpaceElevator (const std::string &name, const std::string &faction, char direction)

void	AddAtmosphere (const std::string &texture, float radius, BLENDFUNC blendSrc, BLENDFUNC blendDst, bool inside_out)

void	AddRing (const std::string &texture, float iradius, float oradius, const QVector &r, const QVector &s, int slices, int numwrapx, int numwrapy, BLENDFUNC blendSrc, BLENDFUNC blendDst)

void	AddCity (const std::string &texture, float radius, int numwrapx, int numwrapy, BLENDFUNC blendSrc, BLENDFUNC blendDst, bool inside_out=false, bool reverse_normals=true)

void	DisableLights ()

void	EnableLights ()

virtual void	Draw (const Transformation &quat=identity_transformation, const Matrix &m=identity_matrix)
	Draws this unit with the transformation and matrix (should be equiv) separately. More...

void	DrawTerrain ()

virtual void	Kill (bool erasefromsave=false)

PlanetaryTransform *	setTerrain (ContinuousTerrain *, float ratiox, int numwraps, float scaleatmos)

ContinuousTerrain *	getTerrain (PlanetaryTransform *&t)

void	setAtmosphere (Atmosphere *)

Atmosphere *	getAtmosphere ()

void	reactToCollision (Unit *smaller, const QVector &biglocation, const Vector &bignormal, const QVector &smalllocation, const Vector &smallnormal, float dist)

Public Member Functions inherited from GameUnit< class Planet >
	GameUnit (int dummy)

	GameUnit (std::vector< Mesh * > &meshes, bool Subunit, int faction)

	GameUnit (const char filename, bool SubUnit, int faction, std::string customizedUnit=std::string(""), Flightgroup flightgroup=NULL, int fg_subnumber=0, std::string *netxml=NULL)

virtual	~GameUnit ()

int	nummesh () const

UnitImages< void > &	GetImageInformation ()

bool	RequestClearance (Unit *dockingunit)

void	UpgradeInterface (Unit *base)
	Loads a user interface for the user to upgrade his ship. More...

virtual void	Cloak (bool cloak)
	The name (type) of this unit shouldn't be public. More...

void	Split (int level)

void	FixGauges ()

void	UpdateHudMatrix (int whichcam)
	Sets the camera to be within this unit. More...

VSSprite *	getHudImage () const
	What's the HudImage of this unit. More...

virtual void	Draw (const Transformation &quat)

virtual void	Draw ()

virtual void	DrawNow (const Matrix &m, float lod=1000000000)

virtual void	DrawNow ()

void	addHalo (const char *filename, const QVector &loc, const Vector &size, const GFXColor &col, std::string halo_type, float halo_speed)
	Deprecated. More...

virtual void	applyTechniqueOverrides (const std::map< std::string, std::string > &overrides)

bool	TransferUnitToSystem (unsigned int whichJumpQueue, StarSystem *&previouslyActiveStarSystem, bool DoSightAndSound)

bool	Explode (bool draw, float timeit)
	Begin and continue explosion. More...

bool	queryFrustum (double frustum[6][4]) const

*bool	querySphereClickList (int, int, float err, Camera *activeCam)

virtual void	UpdatePhysics2 (const Transformation &trans, const Transformation &old_physical_state, const Vector &accel, float difficulty, const Matrix &transmat, const Vector &CumulativeVelocity, bool ResolveLast, UnitCollection *uc=NULL)
	returns true if jump possible even if not taken More...

void	Thrust (const Vector &amt, bool afterburn=false)
	Thrusts by ammt and clamps accordingly (afterburn or not) More...

Vector	ResolveForces (const Transformation &, const Matrix &)
	Resolves forces of given unit on a physics frame. More...

virtual void	ArmorDamageSound (const Vector &pnt)

virtual void	HullDamageSound (const Vector &pnt)

float	DealDamageToShield (const Vector &pnt, float &Damage)
	applies damage from the given pnt to the shield, and returns % damage applied and applies lighitn More...

bool	UpgradeSubUnits (const Unit *up, int subunitoffset, bool touchme, bool downgrade, int &numave, double &percentage)

double	Upgrade (const std::string &file, int mountoffset, int subunitoffset, bool force, bool loop_through_mounts)

Matrix	WarpMatrix (const Matrix &ctm) const
	Holds temporary values for inter-function XML communication Saves deprecated restr info. More...

Static Public Member Functions
static void	ProcessTerrains ()

Public Attributes
UnitCollection	satellites

Public Attributes inherited from GameUnit< class Planet >
double	sparkle_accum

std::auto_ptr< HaloSystem >	phalos

Protected Member Functions
	GamePlanet ()
	default constructor - only to be called by UnitFactory More...

	GamePlanet (QVector x, QVector y, float vely, const Vector &rotvel, float pos, float gravity, float radius, const std::string &filename, const std::string &technique, const std::string &unitname, BLENDFUNC blendsrc, BLENDFUNC blenddst, const std::vector< std::string > &dest, const QVector &orbitcent, Unit *parent, const GFXMaterial &ourmat, const std::vector< GFXLightLocal > &, int faction, string fullname, bool inside_out=false)
	constructor - only to be called by UnitFactory More...

Friends
class	UnitFactory

class	Planet::PlanetIterator

class	PlanetaryOrbit

Detailed Description

Definition at line 25 of file planet.h.

Constructor & Destructor Documentation

GamePlanet::GamePlanet ( )

protected

default constructor - only to be called by UnitFactory

Definition at line 30 of file planet.cpp.

                        :
     GameUnit< Planet > ( 0 )
 {
     atmosphere   = NULL;
     terrain      = NULL;
     radius       = 0.0;
     shine = NULL;
     inside       = false;
     Init();
     terraintrans = NULL;
     SetAI( new Order() );     //no behavior
 }

GamePlanet::GamePlanet	(	QVector	x,
		QVector	y,
		float	vely,
		const Vector &	rotvel,
		float	pos,
		float	gravity,
		float	radius,
		const std::string &	filename,
		const std::string &	technique,
		const std::string &	unitname,
		BLENDFUNC	blendsrc,
		BLENDFUNC	blenddst,
		const std::vector< std::string > &	dest,
		const QVector &	orbitcent,
		Unit *	parent,
		const GFXMaterial &	ourmat,
		const std::vector< GFXLightLocal > &	,
		int	faction,
		string	fullname,
		bool	inside_out = `false`
	)

protected

constructor - only to be called by UnitFactory

GamePlanet::~GamePlanet ( )

virtual

Definition at line 511 of file planet.cpp.

 {
     if (shine)
         delete shine;
     if (terrain)
         delete terrain;
     if (atmosphere)
         delete atmosphere;
 #ifdef FIX_TERRAIN
     if (terraintrans) {
         Matrix *tmp = new Matrix();
         *tmp = cumulative_transformation_matrix;
         terraintrans->SetTransformation( tmp );
         //FIXME
         //We're losing memory here...but alas alas... planets don't die that often
     }
 #endif
 }

Member Function Documentation

void GamePlanet::AddAtmosphere	(	const std::string &	texture,
		float	radius,
		BLENDFUNC	blendSrc,
		BLENDFUNC	blendDst,
		bool	inside_out
	)

Definition at line 177 of file planet.cpp.

References a, VegaConfig::getVariable(), XMLSupport::parse_int(), and vs_config.

 {
     if ( meshdata.empty() )
         meshdata.push_back( NULL );
     Mesh *shield = meshdata.back();
     meshdata.pop_back();
     static int stacks = XMLSupport::parse_int( vs_config->getVariable( "graphics", "planet_detail", "24" ) );
     meshdata.push_back( new SphereMesh( radius, stacks, stacks, texture.c_str(), string(), NULL, inside_out, blendSrc, blendDst ) );
     if ( meshdata.back() ) {
         //By klauss - this needs to be done for most atmospheres
         GFXMaterial a = {
             0, 0, 0, 0,
             1, 1, 1, 1,
             0, 0, 0, 0,
             0, 0, 0, 0,
             0
         };
         meshdata.back()->SetMaterial( a );
     }
     meshdata.push_back( shield );
 }

void GamePlanet::AddCity	(	const std::string &	texture,
		float	radius,
		int	numwrapx,
		int	numwrapy,
		BLENDFUNC	blendSrc,
		BLENDFUNC	blendDst,
		bool	inside_out = `false`,
		bool	reverse_normals = `true`
	)

Definition at line 141 of file planet.cpp.

References GFXMaterial::aa, GFXMaterial::ab, GFXMaterial::ag, GFXMaterial::ar, GFXMaterial::da, GFXMaterial::db, GFXMaterial::dg, GFXMaterial::dr, GFXMaterial::ea, GFXMaterial::eb, GFXMaterial::eg, GFXMaterial::er, VegaConfig::getVariable(), GFXFALSE, M_PI, ONE, XMLSupport::parse_float(), XMLSupport::parse_int(), GFXMaterial::power, GFXMaterial::sa, GFXMaterial::sb, GFXMaterial::sg, GFXMaterial::sr, and vs_config.

 {
     if ( meshdata.empty() )
         meshdata.push_back( NULL );
     Mesh *shield = meshdata.back();
     meshdata.pop_back();
     GFXMaterial  m;
     m.ar = m.ag = m.ab = m.aa = 0.0;
     static float materialweight    = XMLSupport::parse_float( vs_config->getVariable( "graphics", "city_light_strength", "10" ) );
     static float daymaterialweight =
         XMLSupport::parse_float( vs_config->getVariable( "graphics", "day_city_light_strength", "0" ) );
     m.dr    = m.dg = m.db = m.da = materialweight;
     m.sr    = m.sg = m.sb = m.sa = 0.0;
     m.er    = m.eg = m.eb = m.ea = daymaterialweight;
     m.power = 0.0;
     static int stacks = XMLSupport::parse_int( vs_config->getVariable( "graphics", "planet_detail", "24" ) );
     meshdata.push_back( new CityLights( radius, stacks, stacks, texture.c_str(), numwrapx, numwrapy, inside_out, ONE, ONE,
                                         false, 0, M_PI, 0.0, 2*M_PI, reverse_normals ) );
     meshdata.back()->setEnvMap( GFXFALSE );
     meshdata.back()->SetMaterial( m );
 
     meshdata.push_back( shield );
 }

void GamePlanet::AddFog	(	const std::vector< AtmosphericFogMesh > &	v,
		bool	optical_illusion
	)

virtual

Definition at line 117 of file planet.cpp.

References UnitFactory::createUnit(), Unit::GetHullPercent(), Unit::hull, i, MakeFogMesh(), and Unit::setFaceCamera().

 {
     if ( meshdata.empty() ) meshdata.push_back( NULL );
 #ifdef MESHONLY
     Mesh *shield = meshdata.back();
     meshdata.pop_back();
 #endif
     std::vector< Mesh* >fogs;
     for (unsigned int i = 0; i < v.size(); ++i) {
         Mesh *fog = MakeFogMesh( v[i], rSize() );
         fogs.push_back( fog );
     }
     Unit *fawg;
     if (opticalillusion)
         fawg = new AtmosphereHalo( this->rSize(), fogs, 0 );
     else
         fawg = UnitFactory::createUnit( fogs, true, 0 );
     fawg->setFaceCamera();
     getSubUnits().preinsert( fawg );
     fawg->hull /= fawg->GetHullPercent();
 #ifdef MESHONLY
     meshdata.push_back( shield );
 #endif
 }

void GamePlanet::AddRing	(	const std::string &	texture,
		float	iradius,
		float	oradius,
		const QVector &	r,
		const QVector &	s,
		int	slices,
		int	numwrapx,
		int	numwrapy,
		BLENDFUNC	blendSrc,
		BLENDFUNC	blendDst
	)

Definition at line 202 of file planet.cpp.

References VegaConfig::getVariable(), i, M_PI, XMLSupport::parse_int(), R, S, and vs_config.

 {
     if ( meshdata.empty() )
         meshdata.push_back( NULL );
     Mesh *shield = meshdata.back();
     meshdata.pop_back();
     static int stacks = XMLSupport::parse_int( vs_config->getVariable( "graphics", "planet_detail", "24" ) );
     if (slices > 0) {
         stacks = stacks;
         if (stacks < 3)
             stacks = 3;
         for (int i = 0; i < slices; i++)
             meshdata.push_back( new RingMesh( iradius, oradius, stacks, texture.c_str(), R, S, wrapx, wrapy, blendSrc, blendDst,
                                              false, i*(2*M_PI)/( (float) slices ), (i+1)*(2*M_PI)/( (float) slices ) ) );
     }
     meshdata.push_back( shield );
 }

Vector GamePlanet::AddSpaceElevator	(	const std::string &	name,
		const std::string &	faction,
		char	direction
	)

Definition at line 172 of file planet.cpp.

References Planet::AddSpaceElevator().

 {
     //direction is udrlfb//up down right left front ack
     return Planet::AddSpaceElevator( name, faction, direction );
 }

void GamePlanet::DisableLights ( )

Definition at line 506 of file planet.cpp.

References GFXDisableLight(), i, and StarSystemGent::lights.

 {
     for (unsigned int i = 0; i < lights.size(); i++)
         GFXDisableLight( lights[i] );
 }

void GamePlanet::Draw	(	const Transformation &	quat = `identity_transformation`,
		const Matrix &	m = `identity_matrix`
	)

virtual

Draws this unit with the transformation and matrix (should be equiv) separately.

somehow warp unit to reasonable place outisde of planet

Reimplemented from GameUnit< class Planet >.

Definition at line 362 of file planet.cpp.

References _Universe, Universe::AccessCamera(), c, Animation::Draw(), GameUnit< UnitType >::Draw(), Camera::GetPosition(), VegaConfig::getVariable(), GFXLoadIdentity(), GFXSetLight(), i, StarSystemGent::lights, MatrixToVectors(), MODEL, XMLSupport::parse_int(), POSITION, q, QVector, Animation::SetOrientation(), Animation::SetPosition(), Vector, and vs_config.

 {
     //Do lighting fx
     //if cam inside don't draw?
     //if(!inside) {
     GameUnit< Planet >::Draw( quat, m );
     //}
     QVector    t( _Universe->AccessCamera()->GetPosition()-Position() );
     static int counter = 0;
     if (counter++ > 100) {
         if (t.Magnitude() < corner_max.i) {
             inside = true;
         } else {
             inside = false;
             if (terrain) {
 #ifdef PLANETARYTRANSFORM
                 terrain->DisableUpdate();
 #endif
             }
         }
     }
     GFXLoadIdentity( MODEL );
     for (unsigned int i = 0; i < lights.size(); i++)
         GFXSetLight( lights[i], POSITION, GFXColor( cumulative_transformation.position.Cast() ) );
     if (inside && terrain)
         PlanetTerrainDrawQueue.push_back( new UnitContainer( this ) );
     if (shine) {
         Vector  p, q, r;
         QVector c;
         MatrixToVectors( cumulative_transformation_matrix, p, r, q, c );
         shine->SetOrientation( p, q, r );
         shine->SetPosition( c );
         static int num_shine_drawing =
             XMLSupport::parse_int( vs_config->getVariable( "graphics", "num_times_to_draw_shine", "2" ) );
         for (int i = 0; i < num_shine_drawing; ++i)
             shine->Draw();
     }
 }

void GamePlanet::DrawTerrain ( )

Definition at line 412 of file planet.cpp.

References _Universe, Universe::AccessCamera(), Universe::activeStarSystem(), blah, Camera::GetPlanetGFX(), Camera::GetPosition(), GFXLoadIdentity(), MODEL, Camera::UpdatePlanetGFX(), and Vector.

 {
     inside = true;
     if (terrain)
         terrain->EnableUpdate();
 #ifdef PLANETARYTRANSFORM
     TerrainUp = t;
     Normalize( TerrainUp );
     TerrainH  = TerrainUp.Cross( Vector( -TerrainUp.i+.25, TerrainUp.j-.24, -TerrainUp.k+.24 ) );
     Normalize( TerrainH );
 #endif
 
     GFXLoadIdentity( MODEL );
     if (inside && terrain) {
         _Universe->AccessCamera()->UpdatePlanetGFX();
         terrain->SetTransformation( *_Universe->AccessCamera()->GetPlanetGFX() );
         terrain->AdjustTerrain( _Universe->activeStarSystem() );
         terrain->Draw();
 #ifdef PLANETARYTRANSFORM
         terraintrans->GrabPerpendicularOrigin( _Universe->AccessCamera()->GetPosition(), tmp );
         terrain->SetTransformation( tmp );
         terrain->AdjustTerrain( _Universe->activeStarSystem() );
         terrain->Draw();
         if (atmosphere) {
             Vector tup( tmp[4], tmp[5], tmp[6] );
             Vector p    = ( _Universe->AccessCamera()->GetPosition() );
             Vector blah = p-Vector( tmp[12], tmp[13], tmp[14] );
             blah    = p-( blah.Dot( tup ) )*tup;
             tmp[12] = blah.i;
             tmp[13] = blah.j;
             tmp[14] = blah.k;
             atmosphere->SetMatricesAndDraw( _Universe->AccessCamera()->GetPosition(), tmp );
         }
 #endif
     }
 }

void GamePlanet::EnableLights ( )

Definition at line 501 of file planet.cpp.

References GFXEnableLight(), i, and StarSystemGent::lights.

 {
     for (unsigned int i = 0; i < lights.size(); i++)
         GFXEnableLight( lights[i] );
 }

Atmosphere* GamePlanet::getAtmosphere ( )

inline

Definition at line 95 of file planet.h.

     {
         return atmosphere;
     }

ContinuousTerrain* GamePlanet::getTerrain ( PlanetaryTransform *& t)

inline

Definition at line 89 of file planet.h.

     {
         t = terraintrans;
         return terrain;
     }

void GamePlanet::Kill ( bool erasefromsave = false)

virtual

Definition at line 550 of file planet.cpp.

References UnitCollection::clear(), UnitCollection::createIterator(), GFXDeleteLight(), i, StarSystemGent::lights, satellites, and Unit::SetAI().

 {
     Unit *tmp;
     for (un_iter iter = satellites.createIterator(); (tmp=*iter)!=NULL; ++iter)
         tmp->SetAI( new Order );
     /* probably not FIXME...right now doesn't work on paged out systems... not a big deal */
     for (unsigned int i = 0; i < this->lights.size(); i++)
         GFXDeleteLight( lights[i] );
     /*  */
     satellites.clear();
     insiders.clear();
     GameUnit< Planet >::Kill( erasefromsave );
 }

void GamePlanet::ProcessTerrains ( )

static

Definition at line 401 of file planet.cpp.

References Planet::DrawTerrain().

Referenced by GameStarSystem::Draw().

 {
     while ( !PlanetTerrainDrawQueue.empty() ) {
         Planet *pl = (Planet*) PlanetTerrainDrawQueue.back()->GetUnit();
         pl->DrawTerrain();
         PlanetTerrainDrawQueue.back()->SetUnit( NULL );
         delete PlanetTerrainDrawQueue.back();
         PlanetTerrainDrawQueue.pop_back();
     }
 }

void GamePlanet::reactToCollision	(	Unit *	smaller,
		const QVector &	biglocation,
		const Vector &	bignormal,
		const QVector &	smalllocation,
		const Vector &	smallnormal,
		float	dist
	)

Definition at line 451 of file planet.cpp.

References _Universe, CrashForceDock(), Unit::UnitJump::drive, Unit::GetJumpStatus(), Unit::GetOrientation(), VegaConfig::getVariable(), Identity(), InvertMatrix(), Universe::isPlayerStarship(), Unit::isUnit(), MultMatrix(), Unit::name, XMLSupport::parse_bool(), PLANETPTR, Unit::Position(), R, Vector, VectorAndPositionToMatrix(), vs_config, and VSFileSystem::vs_fprintf().

 {
 #ifdef JUMP_DEBUG
     VSFileSystem::vs_fprintf( stderr, "%s reacting to collision with %s drive %d", name.c_str(),
                               un->name.c_str(), un->GetJumpStatus().drive );
 #endif
 #ifdef FIX_TERRAIN
     if (terrain && un->isUnit() != PLANETPTR) {
         un->SetPlanetOrbitData( terraintrans );
         Matrix top;
         Identity( top );
         /*
          *  Vector posRelToTerrain = terraintrans->InvTransform(un->LocalPosition());
          *  top[12]=un->Position().i- posRelToTerrain.i;
          *  top[13]=un->Position().j- posRelToTerrain.j;
          *  top[14]=un->Position().k- posRelToTerrain.k;
          */
         Vector P, Q, R;
         un->GetOrientation( P, Q, R );
         terraintrans->InvTransformBasis( top, P, Q, R, un->Position() );
         Matrix inv, t;
 
         InvertMatrix( inv, top );
         VectorAndPositionToMatrix( t, P, Q, R, un->Position() );
         MultMatrix( top, t, inv );
 #ifdef PLANETARYTRANSFORM
         terraintrans->GrabPerpendicularOrigin( un->Position(), top );
         static int tmp = 0;
 #endif
         terrain->Collide( un, top );
     }
 #endif
     jumpReactToCollision( un );
     //screws with earth having an atmosphere... blahrgh
     if (!terrain && GetDestinations().empty() && !atmospheric) {
         //no place to go and acts like a ship
         GameUnit< Planet >::reactToCollision( un, biglocation, bignormal, smalllocation, smallnormal, dist );
         static bool planet_crash_docks =
             XMLSupport::parse_bool( vs_config->getVariable( "physics", "planet_collision_docks", "true" ) );
         if (_Universe->isPlayerStarship( un ) && planet_crash_docks)
             CrashForceDock( this, un, true );
     }
     //nothing happens...you fail to do anythign :-)
     //maybe air reisstance here? or swithc dynamics to atmos mode
 }

void GamePlanet::setAtmosphere ( Atmosphere * t)

Definition at line 545 of file planet.cpp.

 {
     atmosphere = t;
 }

PlanetaryTransform * GamePlanet::setTerrain	(	ContinuousTerrain *	t,
		float	ratiox,
		int	numwraps,
		float	scaleatmos
	)

Definition at line 530 of file planet.cpp.

References ContinuousTerrain::DisableDraw(), ContinuousTerrain::GetTotalSize(), x, and z.

 {
     terrain = t;
     terrain->DisableDraw();
     float x, z;
     t->GetTotalSize( x, z );
 #ifdef FIX_TERRAIN
     terraintrans = new PlanetaryTransform( .8*corner_max.i, x*ratiox, z, numwraps, scaleatmos );
     terraintrans->SetTransformation( &cumulative_transformation_matrix );
 
     return terraintrans;
 #endif
     return NULL;
 }

Friends And Related Function Documentation

friend class Planet::PlanetIterator

friend

Definition at line 106 of file planet.h.

friend class PlanetaryOrbit

friend

Definition at line 107 of file planet.h.

friend class UnitFactory

friend

Definition at line 55 of file planet.h.

Member Data Documentation

UnitCollection GamePlanet::satellites

Definition at line 58 of file planet.h.

Referenced by Kill().

The documentation for this class was generated from the following files:

src/cmd/planet.h
src/cmd/planet.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation