Finished Vulkan initialization

Author: ergo720

.github/workflows/ci.yml

@@ -65,7 +65,7 @@ jobs:
         uses: humbletim/setup-vulkan-sdk@v1.2.1
         with:
           vulkan-query-version: '1.4.341.0'
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-components: Vulkan-Headers, Vulkan-Loader, Glslang, SPIRV-Tools
           vulkan-use-cache: true
       - name: Generate CMake Files
         # NOTES:

CMakeLists.txt

@@ -23,7 +23,7 @@ if(${WINDEPLOYQT_EXECUTABLE} STREQUAL "")
 endif()
 endif()
 
-find_package(Vulkan REQUIRED)
+find_package(Vulkan REQUIRED COMPONENTS glslang)
 
 find_package(Git)
 if(Git_FOUND)
@@ -44,10 +44,6 @@ set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
 set(CMAKE_AUTOUIC ON)
 
-option(LIB86CPU_BUILD_SHARED_LIB "Build shared libraries" OFF)
-option(LIB86CPU_XBOX_BUILD "Building Xbox version" ON)
-add_subdirectory("import/lib86cpu")
-
 if(CMAKE_GENERATOR MATCHES "Visual Studio")
  set(GENERATOR_IS_VS TRUE)
 elseif(CMAKE_GENERATOR MATCHES "Unix Makefiles")
@@ -62,6 +58,43 @@ else()
 message(FATAL_ERROR "Unsupported compiler")
 endif()
 
+set(SHADER_DIR "${CMAKE_CURRENT_SOURCE_DIR}/shaders")
+file(GLOB_RECURSE SHADERS CONFIGURE_DEPENDS
+ ${SHADER_DIR}/*.comp
+)
+
+if(${GENERATOR_IS_VS})
+ set(SPIRV_BIN "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/shaders")
+else()
+ set(SPIRV_BIN "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/shaders")
+endif()
+
+function(compile_shader shader)
+ get_filename_component(FILE_NAME ${shader} NAME)
+ set(SPIRV_OUTPUT "${SPIRV_BIN}/${FILE_NAME}.spv")
+
+ add_custom_command(
+	OUTPUT ${SPIRV_OUTPUT}
+	COMMAND glslang --target-env vulkan1.1 ${shader} -o ${SPIRV_OUTPUT}
+	COMMENT "Compiling ${shader} to SPIR-V"
+	DEPENDS ${shader}
+	VERBATIM
+ )
+
+ list(APPEND SPIRV_SHADERS ${SPIRV_OUTPUT})
+ set(SPIRV_SHADERS ${SPIRV_SHADERS} PARENT_SCOPE)
+endfunction()
+
+foreach(SHADER ${SHADERS})
+ compile_shader(${SHADER})
+endforeach()
+
+add_custom_target(Shaders ALL DEPENDS ${SPIRV_SHADERS})
+
+option(LIB86CPU_BUILD_SHARED_LIB "Build shared libraries" OFF)
+option(LIB86CPU_XBOX_BUILD "Building Xbox version" ON)
+add_subdirectory("import/lib86cpu")
+
 if(${GENERATOR_IS_UMAKE})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Debug")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release")
@@ -80,6 +113,7 @@ include_directories(
  ${NXBX_ROOT_DIR}/src/qt
  ${NXBX_ROOT_DIR}/src/nxbx/fs
  ${NXBX_ROOT_DIR}/src/nxbx/hw
+ ${NXBX_ROOT_DIR}/src/nxbx/hw/video/renderer
  ${Vulkan_INCLUDE_DIRS}
 )
 
@@ -134,6 +168,8 @@ set(HEADERS
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/pvga.hpp"
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/pvideo.hpp"
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/puser.hpp"
+ "${NXBX_ROOT_DIR}/src/nxbx/hw/video/renderer/graphics_api.hpp"
+ "${NXBX_ROOT_DIR}/src/nxbx/hw/video/renderer/vk/init.hpp"
 )
 
 set(SOURCES
@@ -180,12 +216,14 @@ set(SOURCES
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/pvga.cpp"
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/pvideo.cpp"
  "${NXBX_ROOT_DIR}/src/nxbx/hw/video/gpu/puser.cpp"
+ "${NXBX_ROOT_DIR}/src/nxbx/hw/video/renderer/vk/init.cpp"
 )
 
 source_group(TREE ${NXBX_ROOT_DIR} PREFIX header FILES ${HEADERS})
 source_group(TREE ${NXBX_ROOT_DIR} PREFIX source FILES ${SOURCES})
 
 add_executable(nxbx ${HEADERS} ${SOURCES})
+add_dependencies(nxbx Shaders)
 target_link_libraries(nxbx
 	PRIVATE cpu
 	PRIVATE Qt6::Core

import/lib86cpu

@@ -0,0 +1,6 @@
+#version 450
+
+void main()
+{
+	// pb pusher compute shader not implemented yet
+}

shaders/pb_pusher.comp

@@ -34,6 +34,7 @@ struct init_info_t {
 	std::string keys_path;
 	disas_syntax syntax;
 	uint32_t use_dbg;
+	uint32_t vkdbg;
 	console_t console_type;
 	input_t input_type;
 	int32_t sync_part;
@@ -43,6 +44,8 @@ struct boot_params {
 	disas_syntax syntax;
 	uint32_t use_dbg;
 	console_t console_type;
+	std::string nxbx_dir;
+	uint32_t vkdbg;
 };
 
 namespace Host

src/common/host.hpp

@@ -22,6 +22,7 @@
 #define module_enabled() check_if_enabled<log_module::MODULE_NAME>()
 #define mod_lv2str(lv, mod, msg) mod_lv_to_string<log_lv::lv, log_module::mod>(msg)
 #define lv2str(lv, msg) mod_lv_to_string<log_lv::lv, log_module::MODULE_NAME>(msg)
+#define highestlv2str(msg) mod_lv_to_string<log_lv::highest, log_module::MODULE_NAME>(msg)
 
 #define NUM_OF_LOG_MODULES32 std::to_underlying(log_module::max) / 32 + 1
 
@@ -68,6 +69,7 @@ enum class log_module : int32_t
 	adm1032,
 	conexant,
 	usb0,
+	vulkan,
 	max,
 };
 
@@ -100,7 +102,8 @@ inline constexpr std::array module_to_str =
 	"SMC -> ",
 	"ADM -> ",
 	"CONEXANT -> ",
-	"USB0 -> "
+	"USB0 -> ",
+	"VULKAN -> "
 };
 static_assert(module_to_str.size() == (uint32_t)(log_module::max));
 

src/common/logger.hpp

@@ -4,6 +4,8 @@
 #include "console.hpp"
 #include "io.hpp"
 #include "clock.hpp"
+#include "cpu.hpp"
+#include "vk/init.hpp"
 #include <functional>
 
 
@@ -30,12 +32,24 @@ console::console(const boot_params &params)
 		m_machine.deinit();
 		return;
 	}
+	// We only support Vulkan for now
+	try {
+		m_renderer = new Vulkan;
+		dynamic_cast<Vulkan *>(m_renderer)->setValidationLayers(params.vkdbg);
+		m_renderer->init(params.nxbx_dir, m_machine.getCpu()->getRamPtr(), m_machine.getCpu()->getRamsize());
+	}
+	catch (std::runtime_error e) {
+		logger(e.what());
+		return;
+	}
 	io::init(m_machine.get86cpu());
 	m_state = console_state::initialized;
 }
 
 void console::deinit()
 {
+	m_renderer->deinit();
+	delete m_renderer;
 	io::stop();
 	m_machine.deinit();
 	m_state = console_state::shut_down;

src/nxbx/console.cpp

@@ -7,6 +7,7 @@
 #include "machine.hpp"
 #include "smc.hpp"
 #include "host.hpp"
+#include "graphics_api.hpp"
 #include <atomic>
 #include <thread>
 
@@ -45,6 +46,7 @@ class console {
 	std::atomic<console_state> m_state;
 	boot_params m_params;
 	std::jthread m_cpu_thr;
+	GraphicsAPI *m_renderer;
 };
 
 extern console* g_console;

src/nxbx/console.hpp

@@ -37,12 +37,14 @@ class cpu::Impl
 	uint64_t checkPeriodicEvents(uint64_t now);
 	cpu_t *get86cpu() { return m_lc86cpu; }
 	uint32_t getRamsize() { return m_ramsize; }
+	uint8_t *getRamPtr() { return m_ram; }
 
 private:
 	void updateIo(bool is_update);
 	uint64_t checkPeriodicEvents();
 	static void cpu_logger(log_level lv, const unsigned count, const char *msg, ...);
 
+	uint8_t *m_ram;
 	uint32_t m_ramsize;
 	bool m_is_dbg_present;
 	// connected devices
@@ -142,7 +144,8 @@ void cpu::Impl::init(const boot_params &params, machine *machine)
 	}
 
 	// Init lib86cpu
-	if (!LC86_SUCCESS(cpu_new(m_ramsize, m_lc86cpu))) {
+	// The ram pointer must have a proper alignment to be imported in Vulkan. Here, we are using the same value used in parallel-rdp
+	if (!LC86_SUCCESS(cpu_new(m_ramsize, m_lc86cpu, { nullptr, nullptr }, 64 * 1024))) {
 		throw std::runtime_error(lv2str(highest, "Failed to create cpu instance"));
 	}
 
@@ -166,13 +169,13 @@ void cpu::Impl::init(const boot_params &params, machine *machine)
 	updateIo(false);
 
 	// Load kernel exe into ram
-	uint8_t *ram = get_ram_ptr(m_lc86cpu);
+	m_ram = get_ram_ptr(m_lc86cpu);
 	uint32_t ImageAddress = peHeader->OptionalHeader.ImageBase - CONTIGUOUS_MEMORY_BASE; // =0x10000
-	std::memcpy(&ram[ImageAddress], dosHeader, peHeader->OptionalHeader.SizeOfHeaders);
+	std::memcpy(&m_ram[ImageAddress], dosHeader, peHeader->OptionalHeader.SizeOfHeaders);
 
 	PIMAGE_SECTION_HEADER sections = reinterpret_cast<PIMAGE_SECTION_HEADER>(reinterpret_cast<uint8_t *>(peHeader) + sizeof(IMAGE_NT_HEADERS32));
 	for (uint16_t i = 0; i < peHeader->FileHeader.NumberOfSections; ++i) {
-		uint8_t *dest = &ram[ImageAddress + sections[i].VirtualAddress];
+		uint8_t *dest = &m_ram[ImageAddress + sections[i].VirtualAddress];
 		std::memcpy(dest, reinterpret_cast<uint8_t *>(dosHeader) + sections[i].PointerToRawData, sections[i].SizeOfRawData);
 		if (sections[i].SizeOfRawData < sections[i].Misc.VirtualSize) {
 			std::memset(dest + sections[i].SizeOfRawData, 0, sections[i].Misc.VirtualSize - sections[i].SizeOfRawData);
@@ -182,17 +185,17 @@ void cpu::Impl::init(const boot_params &params, machine *machine)
 	// Make sure that we run the latest version of the kernel
 	// NOTE: this must happen after the kernel has been loaded in the guest virtual memory, because the export table is given with guest relative virtual addresses
 	bool KernelVersionFound = false;
-	PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(&ram[ImageAddress + peHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress]);
+	PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(&m_ram[ImageAddress + peHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress]);
 	uint32_t NumOfNames = ImageExportDirectory->NumberOfNames;
-	uint32_t *ExportAddressTable = (uint32_t *)(&ram[ImageAddress + ImageExportDirectory->AddressOfFunctions]);
-	uint16_t *NameOrdinalsPointer = (uint16_t *)(&ram[ImageAddress + ImageExportDirectory->AddressOfNameOrdinals]);
-	uint32_t *ExportNamePointerTable = (uint32_t *)(&ram[ImageAddress + ImageExportDirectory->AddressOfNames]);
+	uint32_t *ExportAddressTable = (uint32_t *)(&m_ram[ImageAddress + ImageExportDirectory->AddressOfFunctions]);
+	uint16_t *NameOrdinalsPointer = (uint16_t *)(&m_ram[ImageAddress + ImageExportDirectory->AddressOfNameOrdinals]);
+	uint32_t *ExportNamePointerTable = (uint32_t *)(&m_ram[ImageAddress + ImageExportDirectory->AddressOfNames]);
 
 	for (uint32_t i = 0; i < NumOfNames; i++) {
-		char *ExportName = (char *)(&ram[ImageAddress + ExportNamePointerTable[i]]);
+		char *ExportName = (char *)(&m_ram[ImageAddress + ExportNamePointerTable[i]]);
 		if (std::strcmp("NboxkrnlVersion", ExportName) == 0) {
-			uint32_t *NboxkrnlVersionAddress = (uint32_t *)(&ram[ImageAddress + ExportAddressTable[NameOrdinalsPointer[i]]]);
-			std::string FoundNboxkrnlVersion((const char *)&ram[(*NboxkrnlVersionAddress) - CONTIGUOUS_MEMORY_BASE]);
+			uint32_t *NboxkrnlVersionAddress = (uint32_t *)(&m_ram[ImageAddress + ExportAddressTable[NameOrdinalsPointer[i]]]);
+			std::string FoundNboxkrnlVersion((const char *)&m_ram[(*NboxkrnlVersionAddress) - CONTIGUOUS_MEMORY_BASE]);
 			std::string ExpectedNboxkrnlVersion(_NBOXKRNL_HEAD_REF);
 			auto pos = ExpectedNboxkrnlVersion.find_first_of('\t');
 			if (pos != std::string::npos) {
@@ -457,6 +460,11 @@ uint32_t cpu::getRamsize()
 	return m_impl->getRamsize();
 }
 
+uint8_t *cpu::getRamPtr()
+{
+	return m_impl->getRamPtr();
+}
+
 uint64_t cpu::checkPeriodicEvents(uint64_t now)
 {
 	return m_impl->checkPeriodicEvents(now);

src/nxbx/hw/cpu.cpp

@@ -27,6 +27,7 @@ class cpu
 	uint64_t checkPeriodicEvents(uint64_t now);
 	cpu_t *get86cpu();
 	uint32_t getRamsize();
+	uint8_t *getRamPtr();
 
 private:
 	class Impl;