/*
* Function: New
*
* Creates a new <SystemPath> object
*
* > path = SystemPath.New(sectorX, sectorY, sectorZ, systemIndex, bodyIndex)
*
* Parameters:
*
* sectorX - galactic sector X coordinate
*
* sectorY - galactic sector Y coordinate
*
* sectorZ - galactic sector Z coordinate
*
* systemIndex - optional. the numeric index of the system within the sector
*
* bodyIndex - optional. the numeric index of a specific body within the
* system. Defaults to 0, which typically corresponds to the
* primary star.
*
* Availability:
*
* alpha 10, alpha 13 (updated)
*
* Status:
*
* stable
*/
static int l_sbodypath_new(lua_State *l)
{
Sint32 sector_x = luaL_checkinteger(l, 1);
Sint32 sector_y = luaL_checkinteger(l, 2);
Sint32 sector_z = luaL_checkinteger(l, 3);
SystemPath path(sector_x, sector_y, sector_z);
if (lua_gettop(l) > 3) {
path.systemIndex = luaL_checkinteger(l, 4);
// if this is a system path, then check that the system exists
Sector s(sector_x, sector_y, sector_z);
if (size_t(path.systemIndex) >= s.m_systems.size())
luaL_error(l, "System %d in sector <%d,%d,%d> does not exist", path.systemIndex, sector_x, sector_y, sector_z);
if (lua_gettop(l) > 4) {
path.bodyIndex = luaL_checkinteger(l, 5);
// and if it's a body path, check that the body exists
RefCountedPtr<StarSystem> sys = StarSystem::GetCached(path);
if (size_t(path.bodyIndex) >= sys->m_bodies.size()) {
luaL_error(l, "Body %d in system <%d,%d,%d : %d ('%s')> does not exist",
path.bodyIndex, sector_x, sector_y, sector_z, path.systemIndex, sys->GetName().c_str());
}
}
}
LuaSystemPath::PushToLua(&path);
return 1;
}
void SystemInfoView::OnBodySelected(SystemBody *b)
{
{
Output("\n");
Output("Gas, liquid, ice: %f, %f, %f\n", b->GetVolatileGas().ToFloat(), b->GetVolatileLiquid().ToFloat(), b->GetVolatileIces().ToFloat());
}
SystemPath path = m_system->GetPathOf(b);
RefCountedPtr<StarSystem> currentSys = Pi::game->GetSpace()->GetStarSystem();
bool isCurrentSystem = (currentSys && currentSys->GetSystemPath() == m_system->GetSystemPath());
if (path == m_selectedBodyPath) {
if (isCurrentSystem) {
Pi::player->SetNavTarget(0);
}
} else {
if (isCurrentSystem) {
Body* body = Pi::game->GetSpace()->FindBodyForPath(&path);
if(body != 0)
Pi::player->SetNavTarget(body);
} else if (b->GetSuperType() == SystemBody::SUPERTYPE_STAR) { // We allow hyperjump to any star of the system
Pi::sectorView->SetSelected(path);
}
}
UpdateIconSelections();
}
/*
* Method: GetSystemBody
*
* Get a <SystemBody> object for the body that this path points to
*
* > body = path:GetSystemBody()
*
* Return:
*
* body - the <SystemBody>
*
* Availability:
*
* alpha 10
*
* Status:
*
* stable
*/
static int l_sbodypath_get_system_body(lua_State *l)
{
SystemPath *path = LuaSystemPath::GetFromLua(1);
RefCountedPtr<StarSystem> s = StarSystem::GetCached(path);
SBody *sbody = s->GetBodyByPath(path);
LuaSBody::PushToLua(sbody);
return 1;
}
/*
* Method: GetStarSystem
*
* Get a <StarSystem> object for the system that this path points to
*
* > system = path:GetStarSystem()
*
* Return:
*
* system - the <StarSystem>
*
* Availability:
*
* alpha 10
*
* Status:
*
* stable
*/
static int l_sbodypath_get_star_system(lua_State *l)
{
SystemPath *path = LuaObject<SystemPath>::CheckFromLua(1);
RefCountedPtr<StarSystem> s = StarSystem::GetCached(path);
// LuaObject<StarSystem> shares ownership of the StarSystem,
// because LuaAcquirer<LuaObject<StarSystem>> uses IncRefCount and DecRefCount
LuaObject<StarSystem>::PushToLua(s.Get());
return 1;
}
void Galaxy::Dump(FILE* file, Sint32 centerX, Sint32 centerY, Sint32 centerZ, Sint32 radius)
{
for (Sint32 sx = centerX - radius; sx <= centerX + radius; ++sx) {
for (Sint32 sy = centerY - radius; sy <= centerY + radius; ++sy) {
for (Sint32 sz = centerZ - radius; sz <= centerZ + radius; ++sz) {
RefCountedPtr<const Sector> sector = Pi::GetGalaxy()->GetSector(SystemPath(sx, sy, sz));
sector->Dump(file);
}
m_starSystemAttic.ClearCache();
}
}
}
RefCountedPtr<T> GalaxyObjectCache<T,CompareT>::GetIfCached(const SystemPath& path)
{
PROFILE_SCOPED()
RefCountedPtr<T> s;
typename AtticMap::iterator i = m_attic.find(path);
if (i != m_attic.end()) {
s.Reset(i->second);
}
return s;
}
static size_t LoadDDSFromFile(const std::string &filename, PicoDDS::DDSImage& dds)
{
RefCountedPtr<FileSystem::FileData> filedata = FileSystem::gameDataFiles.ReadFile(filename);
if (!filedata) {
Output("LoadDDSFromFile: %s: could not read file\n", filename.c_str());
return 0;
}
// read the dds file
const size_t sizeRead = dds.Read( filedata->GetData(), filedata->GetSize() );
return sizeRead;
}
/*
* Method: GetStarSystem
*
* Get a <StarSystem> object for the system that this path points to
*
* > system = path:GetStarSystem()
*
* Return:
*
* system - the <StarSystem>
*
* Availability:
*
* alpha 10
*
* Status:
*
* stable
*/
static int l_sbodypath_get_star_system(lua_State *l)
{
SystemPath *path = LuaObject<SystemPath>::CheckFromLua(1);
if (path->IsSectorPath())
return luaL_error(l, "SystemPath:GetStarSystem() self argument does not refer to a system");
RefCountedPtr<StarSystem> s = Pi::game->GetGalaxy()->GetStarSystem(path);
// LuaObject<StarSystem> shares ownership of the StarSystem,
// because LuaAcquirer<LuaObject<StarSystem>> uses IncRefCount and DecRefCount
LuaObject<StarSystem>::PushToLua(s.Get());
return 1;
}
Game::Game(const SystemPath &path, double time) :
m_galaxy(GalaxyGenerator::Create()),
m_time(time),
m_state(STATE_NORMAL),
m_wantHyperspace(false),
m_timeAccel(TIMEACCEL_1X),
m_requestedTimeAccel(TIMEACCEL_1X),
m_forceTimeAccel(false)
{
// Now that we have a Galaxy, check the starting location
if (!path.IsBodyPath())
throw InvalidGameStartLocation("SystemPath is not a body path");
RefCountedPtr<const Sector> s = m_galaxy->GetSector(path);
if (size_t(path.systemIndex) >= s->m_systems.size()) {
char buf[128];
std::sprintf(buf, "System %u in sector <%d,%d,%d> does not exist",
unsigned(path.systemIndex), int(path.sectorX), int(path.sectorY), int(path.sectorZ));
throw InvalidGameStartLocation(std::string(buf));
}
RefCountedPtr<StarSystem> sys = m_galaxy->GetStarSystem(path);
if (path.bodyIndex >= sys->GetNumBodies()) {
char buf[256];
std::sprintf(buf, "Body %d in system <%d,%d,%d : %d ('%s')> does not exist", unsigned(path.bodyIndex),
int(path.sectorX), int(path.sectorY), int(path.sectorZ), unsigned(path.systemIndex), sys->GetName().c_str());
throw InvalidGameStartLocation(std::string(buf));
}
m_space.reset(new Space(this, m_galaxy, path));
Body *b = m_space->FindBodyForPath(&path);
assert(b);
m_player.reset(new Player("kanara"));
m_space->AddBody(m_player.get());
m_player->SetFrame(b->GetFrame());
if (b->GetType() == Object::SPACESTATION) {
m_player->SetDockedWith(static_cast<SpaceStation*>(b), 0);
} else {
const SystemBody *sbody = b->GetSystemBody();
m_player->SetPosition(vector3d(0, 1.5*sbody->GetRadius(), 0));
m_player->SetVelocity(vector3d(0,0,0));
}
Polit::Init(m_galaxy);
CreateViews();
EmitPauseState(IsPaused());
}
RefCountedPtr<T> GalaxyObjectCache<T,CompareT>::GetCached(const SystemPath& path)
{
PROFILE_SCOPED()
RefCountedPtr<T> s = this->GetIfCached(path);
if (!s) {
++m_cacheMisses;
s = m_galaxyGenerator->Generate<T,GalaxyObjectCache<T,CompareT>>(path, this);
m_attic.insert( std::make_pair(path, s.Get()));
} else {
++m_cacheHits;
}
return s;
}
bool SectorCustomSystemsGenerator::Apply(Random& rng, RefCountedPtr<Galaxy> galaxy, RefCountedPtr<Sector> sector, GalaxyGenerator::SectorConfig* config)
{
PROFILE_SCOPED()
const int sx = sector->sx;
const int sy = sector->sy;
const int sz = sector->sz;
if ((sx >= -m_customOnlyRadius) && (sx <= m_customOnlyRadius-1) &&
(sy >= -m_customOnlyRadius) && (sy <= m_customOnlyRadius-1) &&
(sz >= -m_customOnlyRadius) && (sz <= m_customOnlyRadius-1))
config->isCustomOnly = true;
const std::vector<const CustomSystem*> &systems = galaxy->GetCustomSystems()->GetCustomSystemsForSector(sx, sy, sz);
if (systems.size() == 0) return true;
Uint32 sysIdx = 0;
for (std::vector<const CustomSystem*>::const_iterator it = systems.begin(); it != systems.end(); ++it, ++sysIdx) {
const CustomSystem *cs = *it;
Sector::System s(sector.Get(), sx, sy, sz, sysIdx);
s.m_pos = Sector::SIZE*cs->pos;
s.m_name = cs->name;
for (s.m_numStars=0; s.m_numStars<cs->numStars; s.m_numStars++) {
if (cs->primaryType[s.m_numStars] == 0) break;
s.m_starType[s.m_numStars] = cs->primaryType[s.m_numStars];
}
s.m_customSys = cs;
s.m_seed = cs->seed;
if (cs->want_rand_explored) {
/*
* 0 - ~500ly from sol: explored
* ~500ly - ~700ly (65-90 sectors): gradual
* ~700ly+: unexplored
*/
int dist = isqrt(1 + sx*sx + sy*sy + sz*sz);
if (((dist <= 90) && ( dist <= 65 || rng.Int32(dist) <= 40)) || galaxy->GetFactions()->IsHomeSystem(SystemPath(sx, sy, sz, sysIdx)))
s.m_explored = StarSystem::eEXPLORED_AT_START;
else
s.m_explored = StarSystem::eUNEXPLORED;
} else {
if (cs->explored)
s.m_explored = StarSystem::eEXPLORED_AT_START;
else
s.m_explored = StarSystem::eUNEXPLORED;
}
sector->m_systems.push_back(s);
}
return true;
}
Label3D::Label3D(Graphics::Renderer *r, RefCountedPtr<Text::DistanceFieldFont> font)
: Node(r, NODE_SOLID) //appropriate for alpha testing
, m_font(font)
{
Graphics::MaterialDescriptor matdesc;
matdesc.textures = 1;
matdesc.alphaTest = true;
matdesc.lighting = true;
m_geometry.Reset(font->CreateVertexArray());
m_material.Reset(r->CreateMaterial(matdesc));
m_material->texture0 = font->GetTexture();
m_material->diffuse = Color::WHITE;
m_material->emissive = Color(0.15f);
m_material->specular = Color::WHITE;
}
/*
* Attribute: parent
*
* The parent of the body, as a <SystemBody>. A body orbits its parent.
*
* Availability:
*
* alpha 14
*
* Status:
*
* stable
*/
static int l_sbody_attr_parent(lua_State *l)
{
SystemBody *sbody = LuaObject<SystemBody>::CheckFromLua(1);
// sbody->parent is 0 as it was cleared by the acquirer. we need to go
// back to the starsystem proper to get what we need.
RefCountedPtr<StarSystem> s = Pi::game->GetGalaxy()->GetStarSystem(sbody->GetPath());
SystemBody *live_sbody = s->GetBodyByPath(sbody->GetPath());
if (!live_sbody->GetParent())
return 0;
LuaObject<SystemBody>::PushToLua(live_sbody->GetParent());
return 1;
}
/*
* Attribute: parent
*
* The parent of the body, as a <SystemBody>. A body orbits its parent.
*
* Availability:
*
* alpha 14
*
* Status:
*
* stable
*/
static int l_sbody_attr_parent(lua_State *l)
{
SystemBody *sbody = LuaSystemBody::CheckFromLua(1);
// sbody->parent is 0 as it was cleared by the acquirer. we need to go
// back to the starsystem proper to get what we need.
RefCountedPtr<StarSystem> s = StarSystem::GetCached(sbody->path);
SystemBody *live_sbody = s->GetBodyByPath(sbody->path);
if (!live_sbody->parent)
return 0;
LuaSystemBody::PushToLua(live_sbody->parent);
return 1;
}
void SystemInfoView::UpdateIconSelections()
{
//navtarget can be only set in current system
for (std::vector<std::pair<std::string, BodyIcon*> >::iterator it = m_bodyIcons.begin();
it != m_bodyIcons.end(); ++it) {
(*it).second->SetSelected(false);
RefCountedPtr<StarSystem> currentSys = Pi::game->GetSpace()->GetStarSystem();
if (currentSys && currentSys->GetPath() == m_system->GetPath() &&
Pi::player->GetNavTarget() &&
(*it).first == Pi::player->GetNavTarget()->GetLabel()) {
(*it).second->SetSelected(true);
}
}
}
/**
take in a configuration xml document and a system
context and initialize the transport
*/
int
RpcHttpClientTransport::init(
const DOMNode* config,
RefCountedPtr<SysContext>& ctx )
{
REFCOUNTED_CAST(iSysComponent, StdLogger, ctx->getComponent( StdLogger::getRegistryName()), _logger);
ASSERT_D(_logger != NULL);
// parsing for proxy server
if ( config->getNodeType() == DOMNode::ELEMENT_NODE )
{
const DOMElement* configElem = (const DOMElement*)config;
// look for the listening port setting
String val;
Mapping attrs;
DOMNodeList* nodes = DomUtils::getNodeList( configElem, RPC_PROXY_NAME );
if ( DomUtils::getNodeValue( (const DOMElement*)nodes->item( 0 ), &val, &attrs ) )
{
Mapping::const_iterator it = attrs.find( RPC_PROXY_PORTATTR );
if( it != attrs.end() )
{
_proxy = val;
_proxyPort = StringUtils::toInt( (*it).second );
}
else
{
CBLOGERR(_logger,
NTEXT("RpcHttpClientTransport::init: can't find attributes to configure Proxy Port"));
}
}
}
return 0;
}
void UpdateVBOs() {
PROFILE_SCOPED()
//create buffer and upload data
Graphics::VertexBufferDesc vbd;
vbd.attrib[0].semantic = Graphics::ATTRIB_POSITION;
vbd.attrib[0].format = Graphics::ATTRIB_FORMAT_FLOAT3;
vbd.attrib[1].semantic = Graphics::ATTRIB_NORMAL;
vbd.attrib[1].format = Graphics::ATTRIB_FORMAT_FLOAT3;
vbd.numVertices = ctx->NUMVERTICES();
vbd.usage = Graphics::BUFFER_USAGE_STATIC;
m_vertexBuffer.reset(Pi::renderer->CreateVertexBuffer(vbd));
GasPatchContext::VBOVertex* vtxPtr = m_vertexBuffer->Map<GasPatchContext::VBOVertex>(Graphics::BUFFER_MAP_WRITE);
assert(m_vertexBuffer->GetDesc().stride == sizeof(GasPatchContext::VBOVertex));
const Sint32 edgeLen = ctx->edgeLen;
const double frac = ctx->frac;
for (Sint32 y=0; y<edgeLen; y++) {
for (Sint32 x=0; x<edgeLen; x++) {
const vector3d p = GetSpherePoint(x*frac, y*frac);
const vector3d pSubCentroid = p - clipCentroid;
clipRadius = std::max(clipRadius, p.Length());
vtxPtr->pos = vector3f(pSubCentroid);
vtxPtr->norm = vector3f(p);
++vtxPtr; // next vertex
}
}
m_vertexBuffer->Unmap();
}
void SystemInfoView::OnBodySelected(SBody *b)
{
{
printf("\n");
printf("Gas, liquid, ice: %f, %f, %f\n", b->m_volatileGas.ToFloat(), b->m_volatileLiquid.ToFloat(), b->m_volatileIces.ToFloat());
}
SystemPath path = m_system->GetPathOf(b);
RefCountedPtr<StarSystem> currentSys = Pi::game->GetSpace()->GetStarSystem();
if (currentSys && currentSys->GetPath() == m_system->GetPath()) {
Body* body = Pi::game->GetSpace()->FindBodyForPath(&path);
if(body != 0)
Pi::player->SetNavTarget(body);
}
UpdateIconSelections();
}
SDLSurfacePtr LoadSurfaceFromFile(const std::string &fname, FileSystem::FileSource &source)
{
RefCountedPtr<FileSystem::FileData> filedata = FileSystem::gameDataFiles.ReadFile(fname);
if (!filedata) {
Output("LoadSurfaceFromFile: %s: could not read file\n", fname.c_str());
return SDLSurfacePtr();
}
SDL_RWops *datastream = SDL_RWFromConstMem(filedata->GetData(), filedata->GetSize());
SDL_Surface *surface = IMG_Load_RW(datastream, 1);
if (!surface) {
Output("LoadSurfaceFromFile: %s: %s\n", fname.c_str(), IMG_GetError());
return SDLSurfacePtr();
}
return SDLSurfacePtr::WrapNew(surface);
}
int
SerSerializationMgr::postInit(
const DOMNode* config,
RefCountedPtr<SysContext>& ctx )
{
if ( _logger == NULL )
{
REFCOUNTED_CAST(iSysComponent, StdLogger, ctx->getComponent(StdLogger::getRegistryName()), _logger);
}
if ( _paths == NULL )
{
REFCOUNTED_CAST(iSysComponent, SysPathMgr, ctx->getComponent(SysPathMgr::getRegistryName()), _paths);
}
return 0;
}
void TextureBuilder::LoadSurface()
{
assert(!m_surface);
RefCountedPtr<FileSystem::FileData> filedata = FileSystem::gameDataFiles.ReadFile(m_filename);
if (!filedata) {
fprintf(stderr, "TextureBuilder::CreateFromFile: %s: could not read file\n", m_filename.c_str());
return;
}
SDL_RWops *datastream = SDL_RWFromConstMem(filedata->GetData(), filedata->GetSize());
m_surface = IMG_Load_RW(datastream, 1);
if (!m_surface) {
fprintf(stderr, "TextureBuilder::CreateFromFile: %s: %s\n", m_filename.c_str(), IMG_GetError());
//m_surface = IMG_Load(unknownTextureFilename.c_str());
return;
}
}
void UnixSignalHandler::waitforstop(RefCountedPtr<iSvrService> &localService)
{
//This function is a blocking call until the service has stopped
while (!localService->isStopped())
{
ThdManager::Sleep( 1000 );
}
}
Label3D::Label3D(Graphics::Renderer *r, RefCountedPtr<Text::DistanceFieldFont> font)
: Node(r, NODE_TRANSPARENT)
, m_font(font)
{
Graphics::MaterialDescriptor matdesc;
matdesc.textures = 1;
matdesc.alphaTest = true;
matdesc.lighting = true;
m_geometry.reset(font->CreateVertexArray());
m_material.Reset(r->CreateMaterial(matdesc));
m_material->texture0 = font->GetTexture();
m_material->diffuse = Color::WHITE;
m_material->emissive = Color(38, 38, 38);
m_material->specular = Color::WHITE;
Graphics::RenderStateDesc rsd;
rsd.depthWrite = false;
m_renderState = r->CreateRenderState(rsd);
}
void Init() {
PROFILE_SCOPED()
frac = 1.0 / double(edgeLen-1);
// also want vtx indices for tris not touching edge of patch
indices.reset(new unsigned short[IDX_VBO_COUNT_ALL_IDX()]);
unsigned short *idx = indices.get();
for (int x=0; x<edgeLen-1; x++) {
for (int y=0; y<edgeLen-1; y++) {
idx[0] = x + edgeLen*y;
idx[1] = x+1 + edgeLen*y;
idx[2] = x + edgeLen*(y+1);
idx+=3;
idx[0] = x+1 + edgeLen*y;
idx[1] = x+1 + edgeLen*(y+1);
idx[2] = x + edgeLen*(y+1);
idx+=3;
}
}
// these will hold the optimised indices
std::vector<unsigned short> pl_short;
// populate the N indices lists from the arrays built during InitTerrainIndices()
// iterate over each index list and optimize it
unsigned int tri_count = GetIndices(pl_short);
VertexCacheOptimizerUShort vco;
VertexCacheOptimizerUShort::Result res = vco.Optimize(&pl_short[0], tri_count);
assert(0 == res);
//create buffer & copy
indexBuffer.Reset(Pi::renderer->CreateIndexBuffer(pl_short.size(), Graphics::BUFFER_USAGE_STATIC));
Uint16* idxPtr = indexBuffer->Map(Graphics::BUFFER_MAP_WRITE);
for (Uint32 j = 0; j < pl_short.size(); j++) {
idxPtr[j] = pl_short[j];
}
indexBuffer->Unmap();
if (indices) {
indices.reset();
}
}
void
SysComponentLoader::updateComponentContext(
RefCountedPtr<SysContext> &ctx,
const DOMDocument* doc )
{
std::vector<DOMProcessingInstruction*> pis;
DomUtils::findProcessingInstructions( doc, TARGET_NAME, pis );
for ( std::vector<DOMProcessingInstruction*>::const_iterator it = pis.begin();
it != pis.end(); it++ )
{
// check to see if the processing instruction has the
// following attributes:
// "component-name" - name of the class to create
// "component-config" - path of the config tree for the component
//
Mapping attrs;
if ( DomUtils::getAttributes( (*it), attrs ) )
{
String cmpName;
attrs.getIfAvailable(CMP_NAME_ATTR, cmpName);
RefCountedPtr<iSysComponent> cmp = ctx->getComponent( cmpName );
if ( cmp != NULL )
{
// locate it's configuration and call it to initialize
String xmlIsland;
attrs.getIfAvailable(CMP_CFG_ATTR, xmlIsland);
if ( xmlIsland.length() > 0 )
{
const DOMNode* theNode = (const DOMNode*)doc->getDocumentElement();
DOMElement* xmlNode = NULL;
DomUtils::selectSingleNode( theNode, xmlIsland, (DOMNode**)&xmlNode );
cmp->update( xmlNode );
}
}
}
}
}
Galaxy::Galaxy() : GALAXY_RADIUS(50000.0), SOL_OFFSET_X(25000.0), SOL_OFFSET_Y(0.0), m_galaxybmp(nullptr), m_factions(this), m_customSystems(this)
{
static const std::string filename("galaxy.bmp");
RefCountedPtr<FileSystem::FileData> filedata = FileSystem::gameDataFiles.ReadFile(filename);
if (!filedata) {
Output("Galaxy: couldn't load '%s'\n", filename.c_str());
Pi::Quit();
}
SDL_RWops *datastream = SDL_RWFromConstMem(filedata->GetData(), filedata->GetSize());
m_galaxybmp = SDL_LoadBMP_RW(datastream, 1);
if (!m_galaxybmp) {
Output("Galaxy: couldn't load: %s (%s)\n", filename.c_str(), SDL_GetError());
Pi::Quit();
}
m_starSystemCache = m_starSystemAttic.NewSlaveCache();
}
Model *BinaryConverter::Load(const std::string &shortname, const std::string &basepath)
{
FileSystem::FileSource &fileSource = FileSystem::gameDataFiles;
for (FileSystem::FileEnumerator files(fileSource, basepath, FileSystem::FileEnumerator::Recurse); !files.Finished(); files.Next()) {
const FileSystem::FileInfo &info = files.Current();
const std::string &fpath = info.GetPath();
//check it's the expected type
if (info.IsFile() && ends_with_ci(fpath, SGM_EXTENSION)) {
//check it's the wanted name & load it
const std::string name = info.GetName();
if (shortname == name.substr(0, name.length() - SGM_EXTENSION.length())) {
//curPath is used to find textures, patterns,
//possibly other data files for this model.
//Strip trailing slash
m_curPath = info.GetDir();
if (m_curPath[m_curPath.length()-1] == '/')
m_curPath = m_curPath.substr(0, m_curPath.length()-1);
RefCountedPtr<FileSystem::FileData> binfile = info.Read();
if (binfile.Valid()) {
Model* model(nullptr);
size_t outSize(0);
// decompress the loaded ByteRange in memory
const ByteRange bin = binfile->AsByteRange();
void *pDecompressedData = tinfl_decompress_mem_to_heap(&bin[0], bin.Size(), &outSize, 0);
if (pDecompressedData) {
// now parse in-memory representation as new ByteRange.
Serializer::Reader rd(ByteRange(static_cast<char*>(pDecompressedData), outSize));
model = CreateModel(rd);
mz_free(pDecompressedData);
}
return model;
}
}
}
}
throw (LoadingError("File not found"));
return nullptr;
}
void NavLights::Init(Graphics::Renderer *renderer)
{
assert(!g_initted);
Graphics::MaterialDescriptor desc;
desc.textures = 1;
matWhite.Reset(renderer->CreateMaterial(desc));
matRed.Reset(renderer->CreateMaterial(desc));
matGreen.Reset(renderer->CreateMaterial(desc));
matBlue.Reset(renderer->CreateMaterial(desc));
matYellow.Reset(renderer->CreateMaterial(desc));
//not cached because modelviewer clears everything...
matWhite->texture0 = Graphics::TextureBuilder::Billboard("textures/halo.png").CreateTexture(renderer);
matRed->texture0 = Graphics::TextureBuilder::Billboard("textures/halo_red.png").CreateTexture(renderer);
matGreen->texture0 = Graphics::TextureBuilder::Billboard("textures/halo_green.png").CreateTexture(renderer);
matBlue->texture0 = Graphics::TextureBuilder::Billboard("textures/halo_blue.png").CreateTexture(renderer);
matYellow->texture0 = Graphics::TextureBuilder::Billboard("textures/halo_yellow.png").CreateTexture(renderer);
g_initted = true;
}
Shader(GLenum type, const std::string &filename, const std::string &defines) {
RefCountedPtr<FileSystem::FileData> code = FileSystem::gameDataFiles.ReadFile(filename);
if (!code)
OS::Error("Could not load %s", filename.c_str());
// Load some common code
RefCountedPtr<FileSystem::FileData> logzCode = FileSystem::gameDataFiles.ReadFile("shaders/gl2/logz.glsl");
assert(logzCode);
RefCountedPtr<FileSystem::FileData> libsCode = FileSystem::gameDataFiles.ReadFile("shaders/gl2/lib.glsl");
assert(libsCode);
AppendSource(s_glslVersion);
AppendSource(defines.c_str());
if (type == GL_VERTEX_SHADER)
AppendSource("#define VERTEX_SHADER\n");
else
AppendSource("#define FRAGMENT_SHADER\n");
AppendSource(logzCode->AsStringRange().StripUTF8BOM());
AppendSource(libsCode->AsStringRange().StripUTF8BOM());
AppendSource(code->AsStringRange().StripUTF8BOM());
shader = glCreateShader(type);
Compile(shader);
// CheckGLSL may use OS::Warning instead of OS::Error so the game may still (attempt to) run
if (!check_glsl_errors(filename.c_str(), shader))
throw ShaderException();
};
static int l_set_hyperspace_target(lua_State *l)
{
LuaObject<Player>::CheckFromLua(1);
if (Pi::game->IsNormalSpace()) {
const SystemPath path = *LuaObject<SystemPath>::CheckFromLua(2);
if (!path.IsSystemPath()) {
if (!path.IsBodyPath()) {
return luaL_error(l, "Player:SetHyperspaceTarget() -- second parameter is not a system path or the path of a star");
}
RefCountedPtr<StarSystem> sys = Pi::game->GetGalaxy()->GetStarSystem(path);
// Lua should never be able to get an invalid SystemPath
// (note: this may change if it becomes possible to remove systems during the game)
assert(path.bodyIndex < sys->GetNumBodies());
SystemBody *sbody = sys->GetBodyByPath(path);
if (!sbody->GetSuperType() == SystemBody::SUPERTYPE_STAR)
return luaL_error(l, "Player:SetHyperspaceTarget() -- second parameter is not a system path or the path of a star");
}
Pi::game->GetSectorView()->SetHyperspaceTarget(path);
return 0;
} else
return luaL_error(l, "Player:SetHyperspaceTarget() cannot be used while in hyperspace");
}
