sdl

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "src/dependency/bgfx.cmake"]
 	path = src/dependency/bgfx.cmake
 	url = https://github.com/bkaradzic/bgfx.cmake
+[submodule "src/dependency/SDL"]
+	path = src/dependency/SDL
+	url = https://github.com/libsdl-org/SDL

src/.ignore

@@ -0,0 +1 @@
+dependency/

src/CMakeLists.txt

@@ -5,9 +5,15 @@ if (MSVC)
 
 else()
 add_compile_options(-g -gcodeview)
-add_link_options(-fuse-ld=lld -g -Wl,--pdb=)
+add_link_options(-g -Wl,--pdb=)
+# add_link_options(-fuse-ld=lld -g -Wl,--pdb=)
 endif()
 
+# set the output directory for built objects.
+# This makes sure that the dynamic library goes into the build directory automatically.
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIGURATION>")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIGURATION>")
+
 # Engine
 file(GLOB_RECURSE sources_engine engine/*.cpp engine/*.h)
 add_executable(PuzGameEngine ${sources_engine})
@@ -22,11 +28,15 @@ file(GLOB_RECURSE sources_game game/*.cpp game/*.h)
 add_library(PuzGame SHARED ${sources_game})
 set_property(TARGET PuzGame PROPERTY CXX_STANDARD 17)
 
+# SDL
+add_subdirectory("${CMAKE_SOURCE_DIR}/dependency/SDL" EXCLUDE_FROM_ALL)
+
+# BGFX
 SET(BGFX_BUILD_TOOLS ON)
-SET(BGFX_BUILD_EXAMPLES ON)
+SET(BGFX_BUILD_EXAMPLES OFF)
 #SET(BGFX_CONFIG_MULTITHREADED OFF)
 add_subdirectory("${CMAKE_SOURCE_DIR}/dependency/bgfx.cmake")
 
-target_link_libraries(PuzGame bx bimg bgfx)
+target_link_libraries(PuzGame bx bimg bgfx SDL3::SDL3)
 target_link_libraries(PuzGameEngine bx)
 set_target_properties(PuzGame PROPERTIES OUTPUT_NAME "PuzGame2")

src/engine/main.cpp

@@ -41,55 +41,6 @@ namespace
   Shutdown ShutdownFunc;
 }
 
-LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
-{
-  LRESULT Res = 0;
-  
-  switch (message)
-  {
-    default:
-    {
-      Res = DefWindowProcW(hwnd, message, wparam, lparam);
-      break;
-    }
-  }
-  return Res;
-}
-
-HWND InitWindow()
-{
-  uint32_t startWidth = 1920;
-  uint32_t startHeight = 1080;
-  HINSTANCE instance = (HINSTANCE)GetModuleHandle(NULL);
-
-  WNDCLASSEXW wnd;
-  bx::memSet(&wnd, 0, sizeof(wnd));
-  wnd.cbSize = sizeof(wnd);
-  wnd.style = CS_HREDRAW | CS_VREDRAW;
-  wnd.lpfnWndProc = WndProc;
-  wnd.hInstance = instance;
-  wnd.hIcon = LoadIcon(NULL, IDI_APPLICATION);
-  wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
-  wnd.lpszClassName = L"EngineWin";
-  wnd.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
-  RegisterClassExW(&wnd);
-  
-  HWND window = CreateWindowExW(0, L"EngineWin", L"PuzGame", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, startWidth, startHeight, NULL, NULL, instance, 0);
-  if (window == NULL)
-  {
-    DWORD err = GetLastError();
-    printf("Failed to create window: %#x!\n", err);
-  }
-
-  DevData.hDevDir = CreateFileW(L"cmake-build", FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-  if (DevData.hDevDir == NULL)
-  {
-    printf("Failed to monitor dev dir!\n");
-  }
-  
-  return window;
-}
-
 unsigned long FileWatcherThread(void* data)
 {
   DWORD bytesReturned = 0;
@@ -185,12 +136,8 @@ bool ReloadDLL()
 
 int main()
 {
-  HWND window = InitWindow();
-  if (window == NULL) return 1;
-
 	char PathBuf[512]{ 0 };
 	GetCurrentDirectory(sizeof(PathBuf), PathBuf);
-
 	printf("Current path: %s\n", PathBuf);
 
 	if (!ReloadDLL()) return 1;
@@ -198,28 +145,16 @@ int main()
 	DWORD fileWatcherThreadId = 0;
 	CreateThread(NULL, 0, FileWatcherThread, NULL, 0, &fileWatcherThreadId);
 
-  StartupFunc(window);
+	StartupFunc(nullptr);
 	bool isRunning = true;
 	while (isRunning)
 	{
-    MSG msg;
-    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
-		{
-			if (msg.message == WM_QUIT)
-			{
-			  isRunning = false;
-			}
-
-			TranslateMessage(&msg);
-			DispatchMessage(&msg);
-    }
-
 		if (DevData.FileWatcher.Change)
 		{
 			DevData.FileWatcher.Change = false;
 			ShutdownFunc();
 			ReloadDLL();
-      StartupFunc(window);
+			StartupFunc(nullptr);
 		}
 
 		UpdateFunc();

src/game/Setup.cpp

@@ -1,7 +1,9 @@
 #include "Setup.h"
 #include "Log.h"
+#include "SDL3/SDL_video.h"
 #include "rendering/Rendering.h"
 #include <cstdint>
+#include <SDL3/SDL.h>
 
 namespace Game
 {
@@ -20,7 +22,29 @@ namespace Game
   void Setup(void* window)
   {
     Log("Game Setup Start!");
-    Instance.Rendering.Setup(window);
+    if (!SDL_Init(SDL_INIT_VIDEO))
+    {
+      Log("Failed to init SDL!");
+      return;
+    }
+    SDL_Window* sdlWindow = SDL_CreateWindow("SDL", 1920, 1080, SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
+    if (sdlWindow == nullptr)
+    {
+      Log("Failed to init SDL Window!");
+      return;
+    }
+    auto props = SDL_GetWindowProperties(sdlWindow);
+    SDL_EnumerateProperties(props, [](void*, SDL_PropertiesID id, const char* name)
+        {
+            Log("Prop: %s", name);
+        }, nullptr);
+    void* hwnd = SDL_GetPointerProperty(props, "SDL.window.win32.hwnd", nullptr);
+    if (hwnd == nullptr)
+    {
+      Log("Failed to get window pointer!");
+      return;
+    }
+    Instance.Rendering.Setup(hwnd);
   }
 
   void Update()

src/game/rendering/Rendering.cpp

@@ -1,15 +1,22 @@
 #include "Rendering.h"
 #include "../Log.h"
 #include "bgfx/defines.h"
+#include "bgfx/platform.h"
 #include "bx/timer.h"
 #include <bx/file.h>
 #include <bgfx/bgfx.h>
-#include <bx/filepath.h>
-#include <bx/readerwriter.h>
 
 namespace Game
 {
-  static VertexData CubeVertices[] =
+	struct PosColorVertex
+	{
+		float x;
+		float y;
+		float z;
+		uint32_t abgr;
+	};
+
+	static PosColorVertex cubeVertices[] =
 	{
 		{-1.0f,  1.0f,  1.0f, 0xff000000 },
 		{ 1.0f,  1.0f,  1.0f, 0xff0000ff },
@@ -21,19 +28,19 @@ namespace Game
 		{ 1.0f, -1.0f, -1.0f, 0xffffffff },
 	};
 
-  const uint16_t CubeIndices[] =
+	static const uint16_t cubeTriList[] =
 	{
-  	0, 1, 2, // 0
+		0, 1, 2,
 		1, 3, 2,
-  	4, 6, 5, // 2
+		4, 6, 5,
 		5, 6, 7,
-  	0, 2, 4, // 4
+		0, 2, 4,
 		4, 2, 6,
-  	1, 5, 3, // 6
+		1, 5, 3,
 		5, 7, 3,
-  	0, 4, 1, // 8
+		0, 4, 1,
 		4, 5, 1,
-  	2, 3, 6, // 10
+		2, 3, 6,
 		6, 3, 7,
 	};
 
@@ -42,61 +49,62 @@ namespace Game
 
 		static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const bx::FilePath& _filePath)
 		{
-    	if (bx::open(_reader, _filePath) )
+			if (bx::open(_reader, _filePath))
 			{
 				uint32_t size = (uint32_t)bx::getSize(_reader);
-    		const bgfx::Memory* mem = bgfx::alloc(size+1);
+				const bgfx::Memory* mem = bgfx::alloc(size + 1);
 				bx::read(_reader, mem->data, size, bx::ErrorAssert{});
 				bx::close(_reader);
-    		mem->data[mem->size-1] = '\0';
+				mem->data[mem->size - 1] = '\0';
 				return mem;
 			}
 
-    	Log("Failed to load %s.", _filePath.getCPtr() );
+			Log("Failed to load %s.", _filePath.getCPtr());
 			return NULL;
 		}
 
-    bgfx::ShaderHandle LoadShader(const char* name)
+		bgfx::ShaderHandle loadShader(const char* FILENAME)
 		{
-      bx::FilePath filePath{"game/compiled-shaders/"};
+			const char* shaderPath = "???";
-      switch (bgfx::getRendererType())
-    	{
-    	case bgfx::RendererType::Noop:
-    	case bgfx::RendererType::Direct3D11:
-    	case bgfx::RendererType::Direct3D12: filePath.join("dx11");  break;
-    	case bgfx::RendererType::Agc:
-    	case bgfx::RendererType::Gnm:        filePath.join("pssl");  break;
-    	case bgfx::RendererType::Metal:      filePath.join("metal"); break;
-    	case bgfx::RendererType::Nvn:        filePath.join("nvn");   break;
-    	case bgfx::RendererType::OpenGL:     filePath.join("glsl");  break;
-    	case bgfx::RendererType::OpenGLES:   filePath.join("essl");  break;
-    	case bgfx::RendererType::Vulkan:     filePath.join("spirv"); break;
 
-    	case bgfx::RendererType::Count:
+			switch (bgfx::getRendererType()) {
-    		BX_ASSERT(false, "You should not be here!");
+			case bgfx::RendererType::Noop: break;
-    		break;
+			case bgfx::RendererType::Direct3D11:
+			case bgfx::RendererType::Direct3D12: shaderPath = "game/compiled-shaders/dx11/";  break;
+			case bgfx::RendererType::Gnm:        shaderPath = "game/compiled-shaders/pssl/";  break;
+			case bgfx::RendererType::Metal:      shaderPath = "game/compiled-shaders/metal/"; break;
+			case bgfx::RendererType::OpenGL:     shaderPath = "game/compiled-shaders/glsl/";  break;
+			case bgfx::RendererType::OpenGLES:   shaderPath = "game/compiled-shaders/essl/";  break;
+			case bgfx::RendererType::Vulkan:     shaderPath = "game/compiled-shaders/spirv/"; break;
 			}
 
-    	char fileName[512]{0};
+			char buffer[512]{ 0 };
-    	bx::strCopy(fileName, sizeof(fileName), name);
+			bx::strCopy(buffer, sizeof(buffer), shaderPath);
-    	bx::strCat(fileName, sizeof(fileName), ".bin");
+			bx::strCat(buffer, sizeof(buffer), FILENAME);
-    	filePath.join(fileName);
+			bx::strCat(buffer, sizeof(buffer), ".bin");
 
-      bx::FileReader fileReader;
+			FILE* file = fopen(buffer, "rb");
-      const bgfx::Memory* mem = loadMem(&fileReader, filePath.getCPtr());
+			fseek(file, 0, SEEK_END);
-      if (mem == nullptr) return {};
+			long fileSize = ftell(file);
-      bgfx::ShaderHandle result = bgfx::createShader(mem);
+			fseek(file, 0, SEEK_SET);
-    	return result;
+
+			const bgfx::Memory* mem = bgfx::alloc(fileSize + 1);
+			fread(mem->data, 1, fileSize, file);
+			mem->data[mem->size - 1] = '\0';
+			fclose(file);
+
+			return bgfx::createShader(mem);
 		}
 	}
 
 	void GameRendering::Setup(void* window)
 	{
+		bgfx::renderFrame();
 		bgfx::Init init;
-    init.type = bgfx::RendererType::OpenGL;
+		init.type = bgfx::RendererType::Direct3D12;
-    //init.debug = true;
+		init.debug = true;
-    //init.callback = &Callback;
+		init.callback = &Callback;
-    init.platformData.nwh = (void*)window;
+		init.platformData.nwh = window;
 		init.platformData.ndt = nullptr;
 		init.platformData.type = bgfx::NativeWindowHandleType::Default;
 		init.resolution.width = State.WindowWidth;
@@ -118,66 +126,31 @@ namespace Game
 			.add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true)
 			.end();
 
-    VertexBuffer = bgfx::createVertexBuffer(bgfx::makeRef(CubeVertices, sizeof(CubeVertices)), VertLayout);
+		VertexBuffer = bgfx::createVertexBuffer(bgfx::makeRef(cubeVertices, sizeof(cubeVertices)), VertLayout);
-    IndexBuffer = bgfx::createIndexBuffer(bgfx::makeRef(CubeIndices, sizeof(CubeIndices)));
+		IndexBuffer = bgfx::createIndexBuffer(bgfx::makeRef(cubeTriList, sizeof(cubeTriList)));
-    bgfx::ShaderHandle vertexShader = LoadShader("vert");
+		bgfx::ShaderHandle vertexShader = loadShader("vert");
-    bgfx::ShaderHandle fragmentShader = LoadShader("frag");
+		bgfx::ShaderHandle fragmentShader = loadShader("frag");
-    bgfx::createProgram(vertexShader, fragmentShader, true);
+		Shader = bgfx::createProgram(vertexShader, fragmentShader, true);
 		State.StartTime = bx::getHPCounter();
 	}
 
 	void GameRendering::Update()
 	{
-    bgfx::setViewRect(0, 0, 0, State.WindowWidth, State.WindowHeight);
+		bgfx::touch(0);
-
 		const bx::Vec3 at = { 0.0f, 0.0f,  0.0f };
-  	const bx::Vec3 eye = { 0.0f, 0.0f, -35.0f };
+		const bx::Vec3 eye = { 0.0f, 0.0f, -5.0f };
-
-  	// Set view and projection matrix for view 0.
-  	{
 		float view[16];
 		bx::mtxLookAt(view, eye, at);
-
 		float proj[16];
-  		bx::mtxProj(proj, 60.0f, float(State.WindowWidth)/float(State.WindowHeight), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth);
+		bx::mtxProj(proj, 60.0f, float(State.WindowWidth) / float(State.WindowHeight), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth);
 		bgfx::setViewTransform(0, view, proj);
 
-  		// Set view 0 default viewport.
-  		bgfx::setViewRect(0, 0, 0, State.WindowWidth, State.WindowHeight);
-  	}
-	  
-		// Set render states.
-		uint64_t state = 0
-			| BGFX_STATE_WRITE_RGB
-			| BGFX_STATE_WRITE_A
-			| BGFX_STATE_WRITE_Z
-			| BGFX_STATE_DEPTH_TEST_LESS
-   		    | BGFX_STATE_CULL_CW
-			| BGFX_STATE_MSAA
-			;
-
-	  float time = (bx::getHPCounter() - State.StartTime) / (float)bx::getHPFrequency();
-  	for (int32_t i = 0; i < 11 * 11; ++i)
-  	{
-  	  uint32_t xx = i % 11;
-  	  uint32_t yy = i / 11;
-			float mtx[16];
-			bx::mtxRotateXY(mtx, time + xx*0.21f, time + yy*0.37f);
-			mtx[12] = -15.0f + float(xx)*3.0f;
-			mtx[13] = -15.0f + float(yy)*3.0f;
-			mtx[14] = 0.0f;
-
-			// Set model matrix for rendering.
-			bgfx::setTransform(mtx);
-
-			// Set vertex and index buffer.
 		bgfx::setVertexBuffer(0, VertexBuffer);
 		bgfx::setIndexBuffer(IndexBuffer);
 
-			bgfx::setState(state);
+		bgfx::dbgTextPrintf(10, 10, 0x0F, "TEST");
+
 		bgfx::submit(0, Shader);
-		}
-    bgfx::dbgTextPrintf(1, 1, 0x0F, "Time: %f", time);
 		bgfx::frame();
 	}
 

src/game/rendering/Rendering.h

@@ -1,8 +1,7 @@
 #pragma once
-#include "bimg/bimg.h"
 #include <bgfx/bgfx.h>
-#include <cstdio>
 #include <bx/string.h>
+#include <cstdio>
 
 namespace Game
 {