Ejemplo n.º 1
0
		void screenShot(const char* filePath,
			uint32_t width,
			uint32_t height,
			uint32_t pitch,
			const void* data,
			uint32_t size,
			bool yflip) override
		{
			#pragma pack(1)
				struct TGAHeader
				{
					char idLength;
					char colourMapType;
					char dataType;
					short int colourMapOrigin;
					short int colourMapLength;
					char colourMapDepth;
					short int xOrigin;
					short int yOrigin;
					short int width;
					short int height;
					char bitsPerPixel;
					char imageDescriptor;
				};
			#pragma pack()

			TGAHeader header;
			setMemory(&header, 0, sizeof(header));
			int bytes_per_pixel = 4;
			header.bitsPerPixel = (char)(bytes_per_pixel * 8);
			header.height = (short)height;
			header.width = (short)width;
			header.dataType = 2;

			Lumix::FS::OsFile file;
			if(!file.open(filePath, Lumix::FS::Mode::CREATE | Lumix::FS::Mode::WRITE, m_renderer.m_allocator))
			{
				g_log_error.log("renderer") << "Failed to save screenshot to " << filePath;
				return;
			}
			file.write(&header, sizeof(header));

			file.write(data, size);
			file.close();
		}
Ejemplo n.º 2
0
void ShaderEditor::generate(const char* path, ShaderType shader_type)
{
	char sc_path[Lumix::MAX_PATH_LENGTH];
	Lumix::PathUtils::FileInfo info(path);
	Lumix::copyString(sc_path, info.m_dir);
	Lumix::catString(sc_path, info.m_basename);
	if(shader_type == ShaderType::FRAGMENT)
	{
		Lumix::catString(sc_path, "_fs.sc");
	}
	else
	{
		Lumix::catString(sc_path, "_vs.sc");
	}

	Lumix::FS::OsFile file;
	if(!file.open(sc_path, Lumix::FS::Mode::WRITE | Lumix::FS::Mode::CREATE, m_allocator))
	{
		Lumix::g_log_error.log("Editor") << "Could not create file " << sc_path;
		return;
	}

	Lumix::OutputBlob blob(m_allocator);
	blob.reserve(4096);

	if(shader_type == ShaderType::FRAGMENT)
	{
		blob << "$input ";
		bool first = true;
		bool inputs[(int)VertexOutput::COUNT];
		memset(inputs, 0, sizeof(inputs));
		for (auto* node : m_fragment_nodes)
		{
			if (node->m_type != (int)NodeType::FRAGMENT_INPUT) continue;

			auto* input_node = static_cast<FragmentInputNode*>(node);
			inputs[(int)input_node->m_vertex_output] = true;
		}

		for (int i = 0; i < (int)VertexOutput::COUNT; ++i)
		{
			if(!inputs[i]) continue;
			
			if(!first) blob << ", ";
			blob << getVertexOutputBGFXName((VertexOutput)i);
			first = false;
		}
		blob << "\n";
	}
	else
	{
		writeVertexShaderHeader(blob, m_vertex_nodes);
	}

	blob << "#include \"common.sh\"\n";

	for (int i = 0; i < Lumix::lengthOf(m_textures); ++i)
	{
		if (!m_textures[i][0]) continue;

		blob << "SAMPLER2D(" << m_textures[i] << ", " << i << ");\n";
	}

	auto& nodes = shader_type == ShaderType::FRAGMENT ? m_fragment_nodes : m_vertex_nodes;
	for (auto* node : nodes)
	{
		node->generateBeforeMain(blob);
	}

	blob << "void main() {\n";
	for(auto& node : nodes)
	{
		if (node->m_type == (int)NodeType::FRAGMENT_OUTPUT ||
			node->m_type == (int)NodeType::VERTEX_OUTPUT ||
			node->m_type == (int)NodeType::POSITION_OUTPUT)
		{
			node->generate(blob);
		}
	}
	blob << "}\n";

	file.write(blob.getData(), blob.getSize());
	file.close();
}
Ejemplo n.º 3
0
bool Settings::save()
{
	auto& actions = m_app.getActions();
	Lumix::FS::OsFile file;
	auto& allocator = m_app.getWorldEditor()->getAllocator();
	if (!file.open(SETTINGS_PATH, Lumix::FS::Mode::CREATE_AND_WRITE, allocator)) return false;

	file << "window = { x = " << m_window.x 
		<< ", y = " << m_window.y 
		<< ", w = " << m_window.w
		<< ", h = " << m_window.h << " }\n";

	file << "maximized = " << (m_is_maximized ? "true" : "false") << "\n";

	auto writeBool = [&file](const char* name, bool value) {
		file << name << " = " << (value ? "true\n" : "false\n");
	};

	writeBool("settings_opened", m_is_opened);
	writeBool("asset_browser_opened", m_is_asset_browser_opened);
	writeBool("entity_list_opened", m_is_entity_list_opened);
	writeBool("entity_template_list_opened", m_is_entity_template_list_opened);
	writeBool("log_opened", m_is_log_opened);
	writeBool("profiler_opened", m_is_profiler_opened);
	writeBool("properties_opened", m_is_properties_opened);
	writeBool("error_reporting_enabled", m_is_crash_reporting_enabled);
	file << "mouse_sensitivity_x = " << m_mouse_sensitivity_x << "\n";
	file << "mouse_sensitivity_y = " << m_mouse_sensitivity_y << "\n";
	
	saveStyle(file);

	file << "data_dir = \"";
	const char* c = m_data_dir;
	while (*c)
	{
		if (*c == '\\') file << "\\\\";
		else file << *c;
		++c;
	}
	file << "\"\n";

	file << "custom = {\n";
	lua_getglobal(m_state, "custom");
	lua_pushnil(m_state);
	bool first = true;
	while (lua_next(m_state, -2))
	{
		if (!first) file << ",\n";
		const char* name = lua_tostring(m_state, -2);
		switch (lua_type(m_state, -1))
		{
			case LUA_TBOOLEAN:
				file << name << " = " << (lua_toboolean(m_state, -1) != 0 ? "true" : "false");
				break;
			case LUA_TNUMBER:
				file << name << " = " << (int)lua_tonumber(m_state, -1);
				break;
			default:
				ASSERT(false);
				break;
		}
		lua_pop(m_state, 1);
		first = false;
	}
	lua_pop(m_state, 1);
	file << "}\n";

	file << "actions = {\n";
	for (int i = 0; i < actions.size(); ++i)
	{
		file << "\t" << actions[i]->name << " = {" 
			<< actions[i]->shortcut[0] << ", "
			<< actions[i]->shortcut[1] << ", " 
			<< actions[i]->shortcut[2] << "},\n";
	}
	file << "}\n";

	file << "toolbar = {\n";
	for (auto* action : m_app.getToolbarActions())
	{
		file << "\t\"" << action->name << "\",\n";
	}
	file << "}\n";

	ImGui::SaveDock(file);

	file.close();

	return true;
}
Ejemplo n.º 4
0
void ProfilerUIImpl::saveResourceList()
{
	Lumix::FS::OsFile file;
	if (file.open("resources.csv", Lumix::FS::Mode::CREATE | Lumix::FS::Mode::WRITE, m_allocator))
	{
		auto& managers = m_resource_manager.getAll();
		for (auto* i : managers)
		{
			auto& resources = i->getResourceTable();
			for (auto& res : resources)
			{
				file.write(res->getPath().c_str(), res->getPath().length());
				file.write(", ", 2);
				char tmp[50];
				Lumix::toCString(res->size() / 1024.0f, tmp, Lumix::lengthOf(tmp), 3);
				file.write(tmp, Lumix::stringLength(tmp));
				file.write("KB, ", 4);
				
				const char* state = getResourceStateString(res->getState());
				file.write(state, Lumix::stringLength(state));
				
				file.write(", ", 4);
				Lumix::toCString(res->getRefCount(), tmp, Lumix::lengthOf(tmp));
				file.write(tmp, Lumix::stringLength(tmp));
				file.write("\n", 4);
			}
		}
		file.close();
	}
}