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; }
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; }
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(); } }
// static RefCountedPtr<Galaxy> GalaxyGenerator::Create(const std::string &name, Version version) { if (version == LAST_VERSION) version = GetLastVersion(name); RefCountedPtr<GalaxyGenerator> galgen; if (name == "legacy") { Output("Creating new galaxy generator '%s' version %d\n", name.c_str(), version); if (version == 0 || version == 1) { galgen.Reset((new GalaxyGenerator(name, version)) ->AddSectorStage(new SectorCustomSystemsGenerator(CustomSystem::CUSTOM_ONLY_RADIUS)) ->AddSectorStage(new SectorRandomSystemsGenerator) ->AddSectorStage(new SectorPersistenceGenerator(version)) ->AddStarSystemStage(new StarSystemFromSectorGenerator) ->AddStarSystemStage(new StarSystemCustomGenerator) ->AddStarSystemStage(new StarSystemRandomGenerator) ->AddStarSystemStage(new PopulateStarSystemGenerator)); } } if (galgen) { if (s_galaxy && galgen->m_name == s_galaxy->GetGeneratorName() && galgen->m_version == s_galaxy->GetGeneratorVersion()) { Output("Clearing and re-using previous Galaxy object\n"); s_galaxy->SetGalaxyGenerator(galgen); s_galaxy->FlushCaches(); return s_galaxy; } assert(name == "legacy"); // Once whe have have more, this will become an if switch // NB : The galaxy density image MUST be in BMP format due to OSX failing to load pngs the same as Linux/Windows s_galaxy = RefCountedPtr<Galaxy>(new DensityMapGalaxy(galgen, "galaxy_dense.bmp", 50000.0, 25000.0, 0.0, "factions", "systems")); s_galaxy->Init(); return s_galaxy; } else { Output("Galaxy generation failed: Unknown generator '%s' version %d\n", name.c_str(), version); return RefCountedPtr<Galaxy>(); } }
void StaticGeometry::DrawBoundingBox(const Aabb &bb) { const vector3f min(bb.min.x, bb.min.y, bb.min.z); const vector3f max(bb.max.x, bb.max.y, bb.max.z); const vector3f fbl(min.x, min.y, min.z); //front bottom left const vector3f fbr(max.x, min.y, min.z); //front bottom right const vector3f ftl(min.x, max.y, min.z); //front top left const vector3f ftr(max.x, max.y, min.z); //front top right const vector3f rtl(min.x, max.y, max.z); //rear top left const vector3f rtr(max.x, max.y, max.z); //rear top right const vector3f rbl(min.x, min.y, max.z); //rear bottom left const vector3f rbr(max.x, min.y, max.z); //rear bottom right const Color c(Color::WHITE); std::unique_ptr<Graphics::VertexArray> vts(new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_DIFFUSE)); //Front face vts->Add(ftr, c); //3 vts->Add(fbr, c); //1 vts->Add(fbl, c); //0 vts->Add(fbl, c); //0 vts->Add(ftl, c); //2 vts->Add(ftr, c); //3 //Rear face vts->Add(rbr, c); //7 vts->Add(rtr, c); //5 vts->Add(rbl, c); //6 vts->Add(rbl, c); //6 vts->Add(rtr, c); //5 vts->Add(rtl, c); //4 //Top face vts->Add(rtl, c); //4 vts->Add(rtr, c); //5 vts->Add(ftr, c); //3 vts->Add(ftr, c); //3 vts->Add(ftl, c); //2 vts->Add(rtl, c); //4 //bottom face vts->Add(fbr, c); //1 vts->Add(rbr, c); //7 vts->Add(rbl, c); //6 vts->Add(rbl, c); //6 vts->Add(fbl, c); //0 vts->Add(fbr, c); //1 //left face vts->Add(fbl, c); //0 vts->Add(rbl, c); //6 vts->Add(rtl, c); //4 vts->Add(rtl, c); //4 vts->Add(ftl, c); //2 vts->Add(fbl, c); //0 //right face vts->Add(rtr, c); //5 vts->Add(rbr, c); //7 vts->Add(fbr, c); //1 vts->Add(fbr, c); //1 vts->Add(ftr, c); //3 vts->Add(rtr, c); //5 Graphics::Renderer *r = GetRenderer(); Graphics::RenderStateDesc rsd; rsd.cullMode = Graphics::CULL_NONE; RefCountedPtr<Graphics::VertexBuffer> vb; //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_DIFFUSE; vbd.attrib[1].format = Graphics::ATTRIB_FORMAT_UBYTE4; vbd.numVertices = vts->GetNumVerts(); vbd.usage = Graphics::BUFFER_USAGE_STATIC; vb.Reset( m_renderer->CreateVertexBuffer(vbd) ); vb->Populate( *vts ); r->SetWireFrameMode(true); r->DrawBuffer(vb.Get(), r->CreateRenderState(rsd), Graphics::vtxColorMaterial); r->SetWireFrameMode(false); }
bool Resource::Load() { if (m_loaded) return true; Json::Reader reader; Json::Value data; std::string filename = "lang/" + m_name + "/" + m_langCode + ".json"; RefCountedPtr<FileSystem::FileData> fd = FileSystem::gameDataFiles.ReadFile(filename); if (!fd) { Output("couldn't open language file '%s'\n", filename.c_str()); return false; } if (!reader.parse(fd->GetData(), fd->GetData()+fd->GetSize(), data)) { Output("couldn't read language file '%s': %s\n", filename.c_str(), reader.getFormattedErrorMessages().c_str()); return false; } fd.Reset(); for (Json::Value::iterator i = data.begin(); i != data.end(); ++i) { const std::string token(i.key().asString()); if (token.empty()) { Output("%s: found empty token, skipping it\n", filename.c_str()); continue; } if (!valid_token(token)) { Output("%s: invalid token '%s', skipping it\n", filename.c_str(), token.c_str()); continue; } Json::Value message((*i).get("message", Json::nullValue)); if (message.isNull()) { Output("%s: no 'message' key for token '%s', skipping it\n", filename.c_str(), token.c_str()); continue; } if (!message.isString()) { Output("%s: value for token '%s' is not a string, skipping it\n", filename.c_str(), token.c_str()); continue; } std::string text(message.asString()); if (text.empty()) { Output("%s: empty value for token '%s', skipping it\n", filename.c_str(), token.c_str()); continue; } // extracted quoted string if (text[0] == '"' && text[text.size()-1] == '"') text = text.substr(1, text.size()-2); // adjust for escaped newlines { std::string adjustedText; adjustedText.reserve(text.size()); unsigned int ii; for (ii = 0; ii < text.size()-1; ii++) { const char *c = &text[ii]; if (c[0] == '\\' && c[1] == 'n') { ii++; adjustedText += '\n'; } else adjustedText += *c; } if (ii != text.size()) adjustedText += text[ii++]; assert(ii == text.size()); text = adjustedText; } m_strings[token] = text; } m_loaded = true; return true; }
void DrawOutdent(const float size[2], Graphics::RenderState *state) { PROFILE_SCOPED() // locals RefCountedPtr<Graphics::VertexBuffer> vb; RefCountedPtr<Graphics::IndexBuffer> ib[3]; // see if we have this size of indent in the cache already const vector2f vsize(size[0], size[1]); MapOutdentBuffers::iterator bufIt = s_outdentBuffers.find(vsize); if (bufIt != s_outdentBuffers.end()) { // found it vb = bufIt->second.vb; ib[0] = bufIt->second.ib[0]; ib[1] = bufIt->second.ib[1]; ib[2] = bufIt->second.ib[2]; } else { // generate it const vector3f vertices[] = { /* 0 */ vector3f(0, 0, 0), /* 1 */ vector3f(0, size[1], 0), /* 2 */ vector3f(size[0], size[1], 0), /* 3 */ vector3f(size[0], 0, 0), /* 4 */ vector3f(BORDER_WIDTH, BORDER_WIDTH, 0), /* 5 */ vector3f(BORDER_WIDTH, size[1] - BORDER_WIDTH, 0), /* 6 */ vector3f(size[0] - BORDER_WIDTH, size[1] - BORDER_WIDTH, 0), /* 7 */ vector3f(size[0] - BORDER_WIDTH, BORDER_WIDTH, 0) }; const Uint32 indices[] = { 0, 1, 5, 0, 5, 4, 0, 4, 7, 0, 7, 3, 3, 7, 6, 3, 6, 2, 1, 2, 6, 1, 6, 5, 4, 5, 6, 4, 6, 7 }; // create buffer Graphics::VertexBufferDesc vbd; vbd.attrib[0].semantic = Graphics::ATTRIB_POSITION; vbd.attrib[0].format = Graphics::ATTRIB_FORMAT_FLOAT3; vbd.numVertices = 8; vbd.usage = Graphics::BUFFER_USAGE_STATIC; // Upload data vb.Reset(Screen::GetRenderer()->CreateVertexBuffer(vbd)); TPos* vtxPtr = vb->Map<TPos>(Graphics::BUFFER_MAP_WRITE); assert(vb->GetDesc().stride == sizeof(TPos)); for (Uint32 i = 0; i < 8; i++) { vtxPtr[i].pos = vertices[i]; } vb->Unmap(); // indices Uint32 IndexStart = 0; Uint32 IndexEnd = 12; Uint32 NumIndices = 12; ib[0].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices)); IndexStart += NumIndices; NumIndices = 12; IndexEnd += NumIndices; ib[1].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices)); IndexStart += NumIndices; NumIndices = 6; IndexEnd += NumIndices; ib[2].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices)); TOutdentBuffers tib; tib.vb = vb; tib.ib[0] = ib[0]; tib.ib[1] = ib[1]; tib.ib[2] = ib[2]; s_outdentBuffers[vsize] = tib; } // Draw it! Screen::flatColorMaterial->diffuse = Color(153,153,153,255); Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[0].Get(), state, Screen::flatColorMaterial); Screen::flatColorMaterial->diffuse = Colors::bgShadow; Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[1].Get(), state, Screen::flatColorMaterial); Screen::flatColorMaterial->diffuse = Colors::bg; Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[2].Get(), state, Screen::flatColorMaterial); }