GameStarSystem Class Reference

#include <star_system.h>

Inheritance diagram for GameStarSystem:

Public Member Functions
virtual	~GameStarSystem ()
	GameStarSystem (const char *filename, const Vector &centr=Vector(0, 0, 0), const float timeofyear=0)
Background *	getBackground ()
void	activateLightMap (int stage=1)
	activates the light map texture More...
Texture *	getLightMap ()
Terrain *	getTerrain (unsigned int which)
unsigned int	numTerrain ()
	activates the light map texture More...
ContinuousTerrain *	getContTerrain (unsigned int which)
unsigned int	numContTerrain ()
ClickList *	getClickList ()
void	Draw (bool DrawCockpit=true)
void	Update (float priority, bool executeDirector)
	update a simulation atom ExecuteDirector must be false if star system is just loaded before mission is loaded More...
void	SwapIn ()
	re-enables the included lights and terrains More...
void	SwapOut ()
	Disables included lights and terrains. More...
virtual void	VolitalizeJumpAnimation (const int ani)
virtual void	DoJumpingComeSightAndSound (Unit *un)
virtual int	DoJumpingLeaveSightAndSound (Unit *un)
void	createBackground (StarSystem::StarXML *xml)
Public Member Functions inherited from StarSystem
	StarSystem ()
	StarSystem (const char *filename, const Vector &centroid=Vector(0, 0, 0), const float timeofyear=0)
virtual	~StarSystem ()
void	SetZone (unsigned int zonenum)
unsigned int	GetZone ()
virtual void	AddMissileToQueue (class MissileEffect *)
virtual void	UpdateMissiles ()
void	UpdateUnitPhysics (bool firstframe)
void	RequestPhysics (Unit *un, unsigned int queue)
	Requeues the unit so that it is simulated ASAP. More...
void	Update (float priority, bool executeDirector)
	update a simulation atom ExecuteDirector must be false if star system is just loaded before mission is loaded More...
void	Update (float priority)
unsigned int	getCurrentSimFrame () const
	Gets the current simulation frame. More...
void	ExecuteUnitAI ()
std::string	getFileName () const
std::string	getName ()
UnitCollection &	getUnitList ()
	Loads the star system from an XML file. More...
UnitCollection &	gravitationalUnits ()
Unit *	nextSignificantUnit ()
void	AddUnit (Unit *unit)
bool	RemoveUnit (Unit *unit)
	Removes from draw list. More...
bool	JumpTo (Unit *unit, Unit *jumppoint, const std::string &system, bool force=false, bool save_coordinates=false)

Static Public Member Functions
static void	DrawJumpStars ()
Static Public Member Functions inherited from StarSystem
static void	beginElement (void *userData, const XML_Char *name, const XML_Char **atts)
static void	endElement (void *userData, const XML_Char *name)
static void	ProcessPendingJumps ()

Friends
class	Atmosphere

Additional Inherited Members
Public Attributes inherited from StarSystem
struct StarSystem::Statistics	stats
std::multimap< Unit *, Unit * >	last_collisions
class CollideTable *	collidetable
CollideMap *	collidemap [2]
class bolt_draw *	bolts
Protected Types inherited from StarSystem
enum	PHYSICS_STAGE { MISSION_SIMULATION, PROCESS_UNIT, PHY_NUM }
	Physics is divided into 3 stages spread over 3 frames. More...
Protected Member Functions inherited from StarSystem
void	LoadXML (const char *, const Vector &centroid, const float timeofyear)
void	beginElement (const std::string &name, const AttributeList &attributes)
void	endElement (const std::string &name)
void	AddStarsystemToUniverse (const std::string &filename)
	The Light Map corresponding for the BP for spheremapping. More...
void	RemoveStarsystemFromUniverse ()
Protected Attributes inherited from StarSystem
struct StarSystem::StarXML *	xml
enum StarSystem::PHYSICS_STAGE	current_stage
std::vector< Terrain * >	terrains
	Stars, planets, etc. Orbital mechanics precalculated. More...
std::vector< ContinuousTerrain * >	contterrains
UnitCollection	drawList
	Everything to be drawn. Folded missiles in here oneday. More...
UnitCollection	GravitationalUnits
UnitCollection	physics_buffer [SIM_QUEUE_SIZE+1]
unsigned int	current_sim_location
unsigned char	no_collision_time
	Objects subject to global gravitron physics (disabled) More...
char *	name
	system name More...
std::string	filename
un_iter	sigIter
double	time
	to track the next given physics frame More...
Stars *	stars
	The background associated with this system. More...
int	lightcontext
std::vector< class MissileEffect * >	dischargedMissiles
unsigned int	zone

Detailed Description

Star System Scene management for a star system Per-Frame Drawing & Physics simulation

Definition at line 21 of file star_system.h.

Constructor & Destructor Documentation

GameStarSystem::~GameStarSystem ( )

virtual

Definition at line 115 of file star_system.cpp.

References _Universe, StarSystem::bolts, Universe::popActiveStarSystem(), Universe::pushActiveStarSystem(), StarSystem::RemoveStarsystemFromUniverse(), and StarSystem::stars.

{
    _Universe->pushActiveStarSystem( this );
#ifdef NV_CUBE_MAP
    delete LightMap[0];
    delete LightMap[1];
    delete LightMap[2];
    delete LightMap[3];
    delete LightMap[4];
    delete LightMap[5];
#else
    delete LightMap[0];
#endif
    delete bg;
    delete stars;
    //delete [] name;
    delete bolts;
    //delete collidetable;//BAD BAD BAD we need this to happen later!

    _Universe->popActiveStarSystem();
    RemoveStarsystemFromUniverse();
}

GameStarSystem::GameStarSystem	(	const char *	filename,
		const Vector &	centr = Vector( 0, 0, 0 ),
		const float	timeofyear = 0
	)

adds to jumping table;

Definition at line 46 of file star_system.cpp.

References _Universe, StarSystem::AddStarsystemToUniverse(), StarSystem::bolts, StarSystem::collidetable, StarSystem::current_stage, GFXCreateLightContext(), Atmosphere::Parameters::high_ambient_color, Atmosphere::Parameters::high_color, StarSystem::lightcontext, StarSystem::LoadXML(), Atmosphere::Parameters::low_ambient_color, Atmosphere::Parameters::low_color, StarSystem::MISSION_SIMULATION, StarSystem::name, StarSystem::no_collision_time, Universe::popActiveStarSystem(), Universe::pushActiveStarSystem(), Atmosphere::Parameters::radius, Atmosphere::Parameters::scattering, StarSystem::time, and UpdateTime().

{
    no_collision_time = 0;               //(int)(1+2.000/SIMULATION_ATOM);
    name  = NULL;
    _Universe->pushActiveStarSystem( this );
    GFXCreateLightContext( lightcontext );
    bolts = new bolt_draw;
    collidetable   = new CollideTable( this );

    current_stage  = MISSION_SIMULATION;

    LoadXML( filename, centr, timeofyear );
    if (!name)
        name = strdup( filename );
    AddStarsystemToUniverse( filename );
    UpdateTime();
    time = 0;

    Atmosphere::Parameters params;

    params.radius = 40000;

    params.low_color[0] = GFXColor( 0, 0.5, 0.0 );

    params.low_color[1] = GFXColor( 0, 1.0, 0.0 );

    params.low_ambient_color[0] = GFXColor( 0.0/255.0, 0.0/255.0, 0.0/255.0 );

    params.low_ambient_color[1] = GFXColor( 0.0/255.0, 0.0/255.0, 0.0/255.0 );

    params.high_color[0] = GFXColor( 0.5, 0.0, 0.0 );

    params.high_color[1] = GFXColor( 1.0, 0.0, 0.0 );

    params.high_ambient_color[0] = GFXColor( 0, 0, 0 );

    params.high_ambient_color[1] = GFXColor( 0, 0, 0 );

    params.scattering = 5;

    _Universe->popActiveStarSystem();
}

Member Function Documentation

void GameStarSystem::activateLightMap ( int  stage = 1)

virtual

activates the light map texture

Reimplemented from StarSystem.

Definition at line 95 of file star_system.cpp.

References CUBE_MAP_GEN, CUBEMAP, GFXActiveTexture(), GFXADDTEXTURE, GFXTextureCoordGenMode(), GFXTextureEnv(), GFXToggleTexture(), Texture::MakeActive(), SPHERE_MAP_GEN, and TEXTURE2D.

{
    GFXActiveTexture( stage );
#ifdef NV_CUBE_MAP
    LightMap[0]->MakeActive( stage );
#else
    LightMap[0]->MakeActive( stage );
#endif
    GFXTextureEnv( stage, GFXADDTEXTURE );
#ifdef NV_CUBE_MAP
    GFXToggleTexture( true, stage, CUBEMAP );
    GFXTextureCoordGenMode( stage, CUBE_MAP_GEN, NULL, NULL );
#else
    const float tempo[4] = {1, 0, 0, 0};
    GFXToggleTexture( true, stage, TEXTURE2D );
    GFXTextureCoordGenMode( stage, SPHERE_MAP_GEN, tempo, tempo );
#endif
    GFXActiveTexture( 0 );
}

void GameStarSystem::createBackground ( StarSystem::StarXML *  xml)

virtual

Reimplemented from StarSystem.

Definition at line 422 of file star_system.cpp.

References StarSystem::StarXML::backgroundColor, StarSystem::StarXML::backgroundDegamma, StarSystem::StarXML::backgroundname, VSFileSystem::VSFile::Close(), CUBEMAP, CUBEMAP_NEGATIVE_X, CUBEMAP_NEGATIVE_Y, CUBEMAP_NEGATIVE_Z, CUBEMAP_POSITIVE_X, CUBEMAP_POSITIVE_Y, CUBEMAP_POSITIVE_Z, DEFAULT_ADDRESS_MODE, EnvironmentMapGeneratorMain(), f, StarSystem::filename, g_game, VegaConfig::getVariable(), GFXFALSE, GFXTRUE, MIPMAP, StarSystem::StarXML::numnearstars, StarSystem::StarXML::numstars, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), XMLSupport::parse_int(), StarSystem::StarXML::reflectivity, vs_options::starblend, StarSystem::stars, StarSystem::StarXML::starsp, BaseUtil::Texture(), TEXTURE2D, TEXTURE_2D, VSFileSystem::TextureFile, TRILINEAR, vs_config, and game_data_t::zfar.

{
#ifdef NV_CUBE_MAP
    printf( "using NV_CUBE_MAP\n" );
    static int max_cube_size = XMLSupport::parse_int( vs_config->getVariable( "graphics", "max_cubemap_size", "1024" ) );
    LightMap[0] = new Texture( (xml->backgroundname+"_light.cube").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_POSITIVE_X,
                              GFXFALSE, max_cube_size );
    if ( LightMap[0]->LoadSuccess() && LightMap[0]->isCube() ) {
        LightMap[1] = LightMap[2] = LightMap[3] = LightMap[4] = LightMap[5] = 0;
    } else {
        delete LightMap[0];
        LightMap[0] = new Texture( (xml->backgroundname+"_right.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_POSITIVE_X,
                                  GFXFALSE, max_cube_size );
        LightMap[1] = new Texture( (xml->backgroundname+"_left.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_NEGATIVE_X,
                                  GFXFALSE, max_cube_size, GFXFALSE, GFXFALSE, DEFAULT_ADDRESS_MODE,
                                  LightMap[0] );
        LightMap[2] = new Texture( (xml->backgroundname+"_up.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_POSITIVE_Y,
                                  GFXFALSE, max_cube_size, GFXFALSE, GFXFALSE, DEFAULT_ADDRESS_MODE,
                                  LightMap[0] );
        LightMap[3] = new Texture( (xml->backgroundname+"_down.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_NEGATIVE_Y,
                                  GFXFALSE, max_cube_size, GFXFALSE, GFXFALSE, DEFAULT_ADDRESS_MODE,
                                  LightMap[0] );
        LightMap[4] = new Texture( (xml->backgroundname+"_front.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_POSITIVE_Z,
                                  GFXFALSE, max_cube_size, GFXFALSE, GFXFALSE, DEFAULT_ADDRESS_MODE,
                                  LightMap[0] );
        LightMap[5] = new Texture( (xml->backgroundname+"_back.image").c_str(), 1, TRILINEAR, CUBEMAP, CUBEMAP_NEGATIVE_Z,
                                  GFXFALSE, max_cube_size, GFXFALSE, GFXFALSE, DEFAULT_ADDRESS_MODE,
                                  LightMap[0] );
    }
#else
    string  bglight = xml->backgroundname+"_light.image";
    string  bgfile  = xml->backgroundname+"_light.image";
    VSFile  f;
    VSError err     = f.OpenReadOnly( bgfile, VSFileSystem::TextureFile );
    if (err > Ok)
        EnvironmentMapGeneratorMain( xml->backgroundname.c_str(), bglight.c_str(), 0, xml->reflectivity, 1 );
    else
        f.Close();
    LightMap[0] = new Texture( bgfile.c_str(), 1, MIPMAP, TEXTURE2D, TEXTURE_2D, GFXTRUE );
#endif

    bg = new Background( 
        xml->backgroundname.c_str(), 
        xml->numstars, 
        g_game.zfar*.9, 
        filename,
        xml->backgroundColor,
        xml->backgroundDegamma );
    stars = new Stars( xml->numnearstars, xml->starsp );
    stars->SetBlend( game_options.starblend, game_options.starblend );
}

void GameStarSystem::DoJumpingComeSightAndSound ( Unit *  un)

virtual

Reimplemented from StarSystem.

Definition at line 124 of file star_system_jump.cpp.

References AddJumpAnimation(), Unit::GetOrientation(), vs_options::jumpgatesize, Unit::LocalPosition(), q, Unit::rSize(), Vector, and VolatileJumpAnimations.

{
    Vector p, q, r;
    un->GetOrientation( p, q, r );
    unsigned int myani = AddJumpAnimation( un->LocalPosition(), un->rSize()*game_options.jumpgatesize, true );
    VolatileJumpAnimations[myani].a->SetOrientation( p, q, r );
}

int GameStarSystem::DoJumpingLeaveSightAndSound ( Unit *  un)

virtual

Reimplemented from StarSystem.

Definition at line 132 of file star_system_jump.cpp.

References AddJumpAnimation(), AUDCreateSound(), AUDPlay(), Unit::UnitJump::delay, Unit::GetJumpStatus(), Unit::GetOrientation(), Unit::GetVelocity(), vs_options::jumpleave, Unit::LocalPosition(), Unit::Position(), q, Unit::rSize(), and Vector.

{
    int        ani;
    Vector     p, q, r;
    un->GetOrientation( p, q, r );
    ani = AddJumpAnimation( un->Position()+r.Cast()*un->rSize()*(un->GetJumpStatus().delay+.25), 10*un->rSize() );
    static int jumpleave = AUDCreateSound( game_options.jumpleave, false );
    AUDPlay( jumpleave, un->LocalPosition(), un->GetVelocity(), 1 );
    return ani;
}

void GameStarSystem::Draw ( bool  DrawCockpit = true)

virtual

Adds to draw list Draws a frame of action, interpolating between physics frames

this is the final, smoothly calculated cam

Reimplemented from StarSystem.

Definition at line 228 of file star_system.cpp.

References _Universe, Universe::AccessCamera(), Universe::AccessCockpit(), UnitWithinRangeLocator< T >::action, Universe::activeStarSystem(), UnitCollection::UnitIterator::advance(), calc_blend_factor(), cam_setup_phase, StarSystem::collidemap, ConditionalCursorDraw(), StarSystem::contterrains, UnitCollection::createIterator(), Unit::cumulative_transformation, Unit::cur_sim_queue_slot, Unit::curr_physical_state, UnitCollection::UnitIterator::current(), StarSystem::current_stage, DEPTHTEST, DEPTHWRITE, Bolt::Draw(), Background::Draw(), Stars::Draw(), UnitDrawer::draw(), Cockpit::Draw(), vs_options::draw_near_stars_in_front_of_planets, ParticleTrail::DrawAndUpdate(), DrawJumpStars(), UnitDrawer::drawParents(), findObjectsFromPosition(), FOG_OFF, StarSystem::getCurrentSimFrame(), Camera::GetNebula(), Cockpit::GetParent(), Camera::GetPosition(), Cockpit::GetSaveParent(), GFXColor4f(), GFXDisable(), GFXEnable(), GFXFogMode(), GFXGetLightContextAmbient(), GFXLightContextAmbient(), GFXPopGlobalEffects(), GFXTRUE, UnitDrawer::grav_acquire(), StarSystem::GravitationalUnits, i, Identity(), interpolation_blend_factor, Unit::isSubUnit(), LIGHTING, linear_interpolate(), CollideArray::lower_bound(), Magnitude(), UnitDrawer::parent, UnitDrawer::parenttarget, particleTrail, StarSystem::PHY_NUM, StarSystem::physics_buffer, Unit::Position(), vs_options::precull_dist, Unit::prev_physical_state, Halo::ProcessDrawQueue(), Animation::ProcessDrawQueue(), Beam::ProcessDrawQueue(), GamePlanet::ProcessTerrains(), Mesh::ProcessUndrawnMeshes(), Mesh::ProcessZFarMeshes(), queryTime(), QVector, Terrain::RenderAll(), Unit::rSize(), saved_interpolation_blend_factor, Nebula::SetFogState(), Cockpit::SetupViewPort(), Unit::sim_atom_multiplier, SIM_QUEUE_SIZE, SIMULATION_ATOM, StarSystem::stars, Unit::Target(), StarSystem::time, Unit::UNIT_ONLY, AnimatedTexture::UpdateAllFrame(), MeshAnimation::UpdateFrames(), Camera::UpdateGFX(), and WarpTrailDraw().

{
    double starttime = queryTime();
    GFXEnable( DEPTHTEST );
    GFXEnable( DEPTHWRITE );
    saved_interpolation_blend_factor = interpolation_blend_factor =
                                           (1./PHY_NUM)*( (PHY_NUM*time)/SIMULATION_ATOM+current_stage );
    GFXColor4f( 1, 1, 1, 1 );
    if (DrawCockpit)
        AnimatedTexture::UpdateAllFrame();
    for (unsigned int i = 0; i < contterrains.size(); ++i)
        contterrains[i]->AdjustTerrain( this );
    Unit *par;
    bool  alreadysetviewport = false;
    if ( ( par = _Universe->AccessCockpit()->GetParent() ) == NULL ) {
        _Universe->AccessCamera()->UpdateGFX( GFXTRUE );
    } else if ( !par->isSubUnit() ) {
        //now we can assume world is topps
        par->cumulative_transformation = linear_interpolate( par->prev_physical_state,
                                                             par->curr_physical_state,
                                                             interpolation_blend_factor );
        Unit *targ = par->Target();
        if ( targ && !targ->isSubUnit() ) {
            targ->cumulative_transformation = linear_interpolate( targ->prev_physical_state,
                                                                  targ->curr_physical_state,
                                                                  interpolation_blend_factor );
        }
        _Universe->AccessCockpit()->SetupViewPort( true );
        alreadysetviewport = true;
    }
    double setupdrawtime = queryTime();
    {
        cam_setup_phase = true;

        Unit *saveparent = _Universe->AccessCockpit()->GetSaveParent();
        Unit *targ = NULL;
        if (saveparent)
            targ = saveparent->Target();
        //Array containing the two interesting units, so as not to have to copy-paste code
        Unit *camunits[2] = {saveparent, targ};
        float backup = SIMULATION_ATOM;
        unsigned int cur_sim_frame = _Universe->activeStarSystem()->getCurrentSimFrame();
        for (int i = 0; i < 2; ++i) {
            Unit *unit = camunits[i];
            //Make sure unit is not null;
            if ( unit && !unit->isSubUnit() ) {
                interpolation_blend_factor = calc_blend_factor( saved_interpolation_blend_factor,
                                                                unit->sim_atom_multiplier,
                                                                unit->cur_sim_queue_slot,
                                                                cur_sim_frame );
                SIMULATION_ATOM = backup*unit->sim_atom_multiplier;
                ( (GameUnit< Unit >*)unit )->GameUnit< Unit >::Draw();
            }
        }
        interpolation_blend_factor = saved_interpolation_blend_factor;
        SIMULATION_ATOM = backup;


        _Universe->AccessCockpit()->SetupViewPort( true );

        cam_setup_phase = false;
    }
    setupdrawtime = queryTime()-setupdrawtime;
    GFXDisable( LIGHTING );
    bg->Draw();
    double drawtime    = queryTime();

    double maxdrawtime = 0;

    //Ballpark estimate of when an object of configurable size first becomes one pixel

    QVector    drawstartpos = _Universe->AccessCamera()->GetPosition();

    Collidable key_iterator( 0, 1, drawstartpos );
    UnitWithinRangeOfPosition< UnitDrawer >drawer( game_options.precull_dist, 0, key_iterator );
    //Need to draw really big stuff (i.e. planets, deathstars, and other mind-bogglingly big things that shouldn't be culled despited extreme distance
    Unit *unit;
    if ( ( drawer.action.parent = _Universe->AccessCockpit()->GetParent() ) != NULL )
        drawer.action.parenttarget = drawer.action.parent->Target();
    for (un_iter iter = this->GravitationalUnits.createIterator(); (unit = *iter) != NULL; ++iter) {
        float distance = ( drawstartpos-unit->Position() ).Magnitude()-unit->rSize();
        if (distance < game_options.precull_dist)
            drawer.action.grav_acquire( unit );
        else
            drawer.action.draw( unit );
    }
    //Need to get iterator to approx camera position
    CollideMap::iterator parent = collidemap[Unit::UNIT_ONLY]->lower_bound( key_iterator );
    findObjectsFromPosition( this->collidemap[Unit::UNIT_ONLY], parent, &drawer, drawstartpos, 0, true );
    drawer.action.drawParents();     //draw units targeted by camera
    //FIXME  maybe we could do bolts & units instead of unit only--and avoid bolt drawing step

#if 0
    for (unsigned int sim_counter = 0; sim_counter <= SIM_QUEUE_SIZE; ++sim_counter) {
        double tmp    = queryTime();
        Unit  *unit;
        UnitCollection::UnitIterator iter = physics_buffer[sim_counter].createIterator();
        float  backup = SIMULATION_ATOM;
        unsigned int cur_sim_frame = _Universe->activeStarSystem()->getCurrentSimFrame();
        while ( ( unit = iter.current() ) != NULL ) {
            interpolation_blend_factor = calc_blend_factor( saved_interpolation_blend_factor,
                                                            unit->sim_atom_multiplier,
                                                            unit->cur_sim_queue_slot,
                                                            cur_sim_frame );
            //if (par&&par->Target()==unit) {
            //printf ("i:%f s:%f m:%d c:%d l:%d\n",interpolation_blend_factor,saved_interpolation_blend_factor,unit->sim_atom_multiplier,sim_counter,current_sim_location);
            //}
            SIMULATION_ATOM = backup*unit->sim_atom_multiplier;
            ( (GameUnit< Unit >*)unit )->Draw();
            iter.advance();
        }
        interpolation_blend_factor = saved_interpolation_blend_factor;
        SIMULATION_ATOM = backup;
        tmp = queryTime()-tmp;
        if (tmp > maxdrawtime) maxdrawtime = tmp;
    }
#endif
    drawtime = queryTime()-drawtime;
    WarpTrailDraw();

    GFXFogMode( FOG_OFF );

    GFXColor tmpcol( 0, 0, 0, 1 );
    GFXGetLightContextAmbient( tmpcol );
    double   processmesh = queryTime();
    if (!game_options.draw_near_stars_in_front_of_planets) stars->Draw();
    Mesh::ProcessZFarMeshes();
    if (game_options.draw_near_stars_in_front_of_planets) stars->Draw();
    GFXEnable( DEPTHTEST );
    GFXEnable( DEPTHWRITE );
    //need to wait for lights to finish
    GamePlanet::ProcessTerrains();
    Terrain::RenderAll();
    Mesh::ProcessUndrawnMeshes( true );
    processmesh = queryTime()-processmesh;
    Nebula *neb;

    Matrix  ident;
    Identity( ident );

    GFXPopGlobalEffects();
    GFXLightContextAmbient( tmpcol );
    if ( ( neb = _Universe->AccessCamera()->GetNebula() ) )
        neb->SetFogState();
    Beam::ProcessDrawQueue();
    Bolt::Draw();

    GFXFogMode( FOG_OFF );
    Animation::ProcessDrawQueue();
    Halo::ProcessDrawQueue();
    particleTrail.DrawAndUpdate();
    GameStarSystem::DrawJumpStars();
    ConditionalCursorDraw( false );
    if (DrawCockpit)
        _Universe->AccessCockpit()->Draw();
    double fintime = queryTime()-starttime;
    MeshAnimation::UpdateFrames();
}

void GameStarSystem::DrawJumpStars ( )

static

Definition at line 86 of file star_system_jump.cpp.

References a, Unit::UnitJump::delay, Unit::GetJumpStatus(), Unit::GetOrientation(), i, JumpAnimations, vs_options::jumpgatesize, k, pendingjump, Unit::Position(), q, Unit::rSize(), Vector, and VolatileJumpAnimations.

Referenced by Draw().

{
    for (unsigned int kk = 0; kk < pendingjump.size(); ++kk) {
        int k = pendingjump[kk]->animation;
        if (k != -1) {
            Unit *un = pendingjump[kk]->un.GetUnit();
            if (un) {
                Vector p, q, r;
                un->GetOrientation( p, q, r );

                JumpAnimations[k].a->SetPosition( un->Position()+r.Cast()*un->rSize()*(pendingjump[kk]->delay+.25) );
                JumpAnimations[k].a->SetOrientation( p, q, r );
                float dd = un->rSize()*game_options.jumpgatesize
                           *(un->GetJumpStatus().delay-pendingjump[kk]->delay)/(float) un->GetJumpStatus().delay;
                JumpAnimations[k].a->SetDimensions( dd, dd );
            }
        }
    }
    unsigned int i;
    for (i = 0; i < JumpAnimations.size(); ++i)
        if (JumpAnimations[i].a)
            JumpAnimations[i].a->Draw();
    for (i = 0; i < VolatileJumpAnimations.size(); ++i)
        if (VolatileJumpAnimations[i].a) {
            float hei, wid;
            VolatileJumpAnimations[i].a->GetDimensions( hei, wid );
            VolatileJumpAnimations[i].a->SetDimensions( VolatileJumpAnimations[i].percent*hei,
                                                        VolatileJumpAnimations[i].percent*wid );
            if ( VolatileJumpAnimations[i].a->Done() ) {
                delete VolatileJumpAnimations[i].a;
                VolatileJumpAnimations.erase( VolatileJumpAnimations.begin()+i );
                --i;
            } else {
                VolatileJumpAnimations[i].a->Draw();
            }
        }
}

Background* GameStarSystem::getBackground ( )

inlinevirtual

Reimplemented from StarSystem.

Definition at line 36 of file star_system.h.

    {
        return bg;
    }

ClickList * GameStarSystem::getClickList ( )

virtual

Loads the star system from an XML file returns xy sorted bounding spheres of all units in current view

Reimplemented from StarSystem.

Definition at line 138 of file star_system.cpp.

References StarSystem::drawList.

{
    return new ClickList( this, &drawList );
}

ContinuousTerrain* GameStarSystem::getContTerrain ( unsigned int  which)

inlinevirtual

Reimplemented from StarSystem.

Definition at line 52 of file star_system.h.

References StarSystem::contterrains.

    {
        return contterrains[which];
    }

Texture * GameStarSystem::getLightMap ( )

virtual

Reimplemented from StarSystem.

Definition at line 90 of file star_system.cpp.

{
    return LightMap[0];
}

Terrain* GameStarSystem::getTerrain ( unsigned int  which)

inlinevirtual

Reimplemented from StarSystem.

Definition at line 44 of file star_system.h.

References StarSystem::terrains.

    {
        return terrains[which];
    }

unsigned int GameStarSystem::numContTerrain ( )

inlinevirtual

Reimplemented from StarSystem.

Definition at line 56 of file star_system.h.

References StarSystem::contterrains.

    {
        return contterrains.size();
    }

unsigned int GameStarSystem::numTerrain ( )

inlinevirtual

activates the light map texture

Reimplemented from StarSystem.

Definition at line 48 of file star_system.h.

References StarSystem::terrains.

    {
        return terrains.size();
    }

void GameStarSystem::SwapIn ( )

virtual

re-enables the included lights and terrains

Reimplemented from StarSystem.

Definition at line 149 of file star_system.cpp.

References GFXSetLightContext(), and StarSystem::lightcontext.

{
    GFXSetLightContext( lightcontext );
}

void GameStarSystem::SwapOut ( )

virtual

Disables included lights and terrains.

Reimplemented from StarSystem.

Definition at line 154 of file star_system.cpp.

{}

void GameStarSystem::Update	(	float	priority,
		bool	executeDirector
	)

update a simulation atom ExecuteDirector must be false if star system is just loaded before mission is loaded

void GameStarSystem::VolitalizeJumpAnimation ( const int  ani)

virtual

Reimplemented from StarSystem.

Definition at line 77 of file star_system_jump.cpp.

References a, AnimationNulls, JumpAnimations, vs_options::jumpanimationshrink, and VolatileJumpAnimations.

{
    if (ani != -1) {
        VolatileJumpAnimations.push_back( ResizeAni( JumpAnimations[ani].a, game_options.jumpanimationshrink ) );
        JumpAnimations[ani].a = NULL;
        AnimationNulls.push_back( ani );
    }
}

Friends And Related Function Documentation

friend class Atmosphere

friend

Definition at line 76 of file star_system.h.

---

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

• src/star_system.h
• src/star_system.cpp
• src/star_system_jump.cpp