static void position_system_lights(Frame *camFrame, Frame *frame, int &lightNum)
{
if (lightNum > 3) return;
// not using frame->GetSBodyFor() because it snoops into parent frames,
// causing duplicate finds for static and rotating frame
SBody *body = frame->m_sbody;
if (body && (body->GetSuperType() == SBody::SUPERTYPE_STAR)) {
int light;
switch (lightNum) {
case 3: light = GL_LIGHT3; break;
case 2: light = GL_LIGHT2; break;
case 1: light = GL_LIGHT1; break;
default: light = GL_LIGHT0; break;
}
// position light at sol
matrix4x4d m;
Frame::GetFrameTransform(frame, camFrame, m);
vector3d lpos = (m * vector3d(0,0,0));
double dist = lpos.Length() / AU;
lpos *= 1.0/dist; // normalize
float lightPos[4];
lightPos[0] = float(lpos.x);
lightPos[1] = float(lpos.y);
lightPos[2] = float(lpos.z);
lightPos[3] = 0;
const float *col = StarSystem::starRealColors[body->type];
float lightCol[4] = { col[0], col[1], col[2], 0 };
float ambCol[4] = { 0,0,0,0 };
if (Render::IsHDREnabled()) {
for (int i=0; i<4; i++) {
// not too high or we overflow our float16 colorbuffer
lightCol[i] *= float(std::min(10.0*StarSystem::starLuminosities[body->type] / dist, 10000.0));
}
}
glLightfv(light, GL_POSITION, lightPos);
glLightfv(light, GL_DIFFUSE, lightCol);
glLightfv(light, GL_AMBIENT, ambCol);
glLightfv(light, GL_SPECULAR, lightCol);
glEnable(light);
lightNum++;
}
for (std::list<Frame*>::iterator i = frame->m_children.begin(); i!=frame->m_children.end(); ++i) {
position_system_lights(camFrame, *i, lightNum);
}
}
/*
* Attribute: superType
*
* The supertype of the body, as a <Constants.BodySuperType> constant
*
* Availability:
*
* alpha 10
*
* Status:
*
* stable
*/
static int l_sbody_attr_super_type(lua_State *l)
{
SBody *sbody = LuaSBody::GetFromLua(1);
lua_pushstring(l, LuaConstants::GetConstantString(l, "BodySuperType", sbody->GetSuperType()));
return 1;
}
static int l_sbody_attr_is_scoopable(lua_State *l)
{
SBody * sbody = LuaSBody::GetFromLua(1);
lua_pushboolean(l, sbody->IsScoopable());
return 1;
}
static int l_sbody_attr_has_atmosphere(lua_State *l)
{
SBody * sbody = LuaSBody::GetFromLua(1);
lua_pushboolean(l, sbody->HasAtmosphere());
return 1;
}
/*
* Attribute: gravity
*
* The gravity on the surface of the body (m/s).
*
* Availability:
*
* alpha 21
*
* Status:
*
* experimental
*/
static int l_sbody_attr_gravity(lua_State *l)
{
SBody *sbody = LuaSBody::GetFromLua(1);
lua_pushnumber(l, sbody->CalcSurfaceGravity());
return 1;
}
/*
* Attribute: mass
*
* The mass of the body, in kilograms (kg).
*
* Availability:
*
* alpha 16
*
* Status:
*
* experimental
*/
static int l_sbody_attr_mass(lua_State *l)
{
SBody *sbody = LuaSBody::GetFromLua(1);
lua_pushnumber(l, sbody->GetMass());
return 1;
}
void Game::SwitchToNormalSpace()
{
// remove the player from hyperspace
m_space->RemoveBody(m_player.Get());
// create a new space for the system
const SystemPath &dest = m_player->GetHyperspaceDest();
m_space.Reset(new Space(this, dest));
// put the player in it
m_player->SetFrame(m_space->GetRootFrame());
m_space->AddBody(m_player.Get());
// place it
m_player->SetPosition(m_space->GetHyperspaceExitPoint(m_hyperspaceSource));
m_player->SetVelocity(vector3d(0,0,-100.0));
m_player->SetRotMatrix(matrix4x4d::Identity());
// place the exit cloud
HyperspaceCloud *cloud = new HyperspaceCloud(0, Pi::game->GetTime(), true);
cloud->SetFrame(m_space->GetRootFrame());
cloud->SetPosition(m_player->GetPosition());
m_space->AddBody(cloud);
for (std::list<HyperspaceCloud*>::iterator i = m_hyperspaceClouds.begin(); i != m_hyperspaceClouds.end(); ++i) {
cloud = *i;
cloud->SetFrame(m_space->GetRootFrame());
cloud->SetPosition(m_space->GetHyperspaceExitPoint(m_hyperspaceSource));
m_space->AddBody(cloud);
if (cloud->GetDueDate() < Pi::game->GetTime()) {
// they emerged from hyperspace some time ago
Ship *ship = cloud->EvictShip();
ship->SetFrame(m_space->GetRootFrame());
ship->SetVelocity(vector3d(0,0,-100.0));
ship->SetRotMatrix(matrix4x4d::Identity());
ship->Enable();
ship->SetFlightState(Ship::FLYING);
const SystemPath &sdest = ship->GetHyperspaceDest();
if (sdest.IsSystemPath()) {
// travelling to the system as a whole, so just dump them on
// the cloud - we can't do any better in this case
ship->SetPosition(cloud->GetPosition());
}
else {
// on their way to a body. they're already in-system so we
// want to simulate some travel to their destination. we
// naively assume full accel for half the distance, flip and
// full brake for the rest.
Body *target_body = m_space->FindBodyForPath(&sdest);
double dist_to_target = cloud->GetPositionRelTo(target_body).Length();
double half_dist_to_target = dist_to_target / 2.0;
double accel = -(ship->GetShipType().linThrust[ShipType::THRUSTER_FORWARD] / ship->GetMass());
double travel_time = Pi::game->GetTime() - cloud->GetDueDate();
// I can't help but feel some actual math would do better here
double speed = 0;
double dist = 0;
while (travel_time > 0 && dist <= half_dist_to_target) {
speed += accel;
dist += speed;
travel_time--;
}
while (travel_time > 0 && dist < dist_to_target) {
speed -= accel;
dist += speed;
travel_time--;
}
if (travel_time <= 0) {
vector3d pos =
target_body->GetPositionRelTo(m_space->GetRootFrame()) +
cloud->GetPositionRelTo(target_body).Normalized() * (dist_to_target - dist);
ship->SetPosition(pos);
}
else {
// ship made it with time to spare. just put it somewhere
// near the body. the script should be issuing a dock or
// flyto command in onEnterSystem so it should sort it
// itself out long before the player can get near
SBody *sbody = m_space->GetStarSystem()->GetBodyByPath(&sdest);
if (sbody->type == SBody::TYPE_STARPORT_ORBITAL) {
ship->SetFrame(target_body->GetFrame());
ship->SetPosition(MathUtil::RandomPointOnSphere(1000.0)*1000.0); // somewhere 1000km out
}
else {
if (sbody->type == SBody::TYPE_STARPORT_SURFACE) {
sbody = sbody->parent;
SystemPath path = m_space->GetStarSystem()->GetPathOf(sbody);
target_body = m_space->FindBodyForPath(&path);
}
double sdist = sbody->GetRadius()*2.0;
ship->SetFrame(target_body->GetFrame());
ship->SetPosition(MathUtil::RandomPointOnSphere(sdist));
}
}
}
m_space->AddBody(ship);
Pi::luaOnEnterSystem->Queue(ship);
}
}
m_hyperspaceClouds.clear();
m_state = STATE_NORMAL;
}