/* * 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"); }