Beispiel #1
0
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;
}
Beispiel #2
0
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;
}
Beispiel #3
0
	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();
		}
	}
Beispiel #4
0
// 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>();
	}
}
Beispiel #5
0
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);
}
Beispiel #6
0
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;
}
Beispiel #7
0
	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);
	}