After a six day outing to South Dakota, I'm happy to return and get right back to work on SDL's meta-build system!
Cleaning up Project Syntax
Before, the project syntax was rather icky. It involved a lot of table manipulation, assignment, listing, you name it. I just didn't like it. I didn't plan on keeping it from the beginning. In fact, I wanted a syntax closer to premake's.
With premake, you just do a bunch of function calls in a specific order. However, it doesn't feel like you're making function calls. That's because in Lua, you don't need surrounding parentheses when making a function call if you're passing it one parameter and that parameter is either a table or a string. Conveniently, everything in premake takes either a string or a table. So, in all their examples, they demonstrate passing string literals and inline tables. This gives almost a functional programming feel (which is obviously the end goal on Lua's part). It's just so much cleaner and more elegant. I wanted this.
Hence, I created a series of new functions which maintained a minimal inner state where all the project files were able to call these functions and build projects functionally, rather than uses data structures. Take this example of how looked before the new system:
SDL_project = {
name = "SDL2",
kind = "SharedLib",
language = "C++",
dependencyTree = { },
uuid = os.uuid(),
sourcedir = "../src",
-- as dependencies...?
customLinks = { }
}
-- statically link on mac osx
if os.get() == "macosx" then
SDL_project.kind = "StaticLib"
elseif os.get() == "windows" then
table.insert(SDL_project.customLinks, "winmm")
table.insert(SDL_project.customLinks, "imm32")
table.insert(SDL_project.customLinks, "oleaut32")
table.insert(SDL_project.customLinks, "version")
end
projects["SDL2"] = SDL_project
-- dependency functions must return the following:
-- <foundDep> <name> [includes] [libs] [inputs]
function directXDep()
print("Checking DirectX dependencies...")
local foundInc, incpath = find_dependency_dir_windows("DXSDK_DIR", "C:/Program Files;C:/Program Files (x86)", "DirectX", "Include")
local foundLib, libpath = find_dependency_dir_windows("DXSDK_DIR", "C:/Program Files;C:/Program Files (x86)", "DirectX", "Lib/x86")
if not foundInc or not foundLib then return false, "DirectX" end
return true, "DirectX", { incpath }, { libpath }, { }
end
-- TODO: convert this to be functional (like premake), so the syntax isn't as
-- repetitive
-- format is { dependencyLambda }
-- if not in table, it will be excluded from the project
-- if dependency lambda is nil, it will always be included
local dep = SDL_project.dependencyTree;
-- setup dependency tree for SDL 2
dep["/"] = { nil }
dep["/atomic/"] = { nil }
dep["/audio/"] = { nil }
...
dep["/video/"] = { nil }
dep["/video/dummy/"] = { nil }
-- platform-specific implementations
if os.get() == "windows" then
dep["/audio/directsound/"] = { nil }
dep["/audio/winmm/"] = { nil }
...
dep["/render/opengl/"] = { nil }
-- added exclusion filter to thread/generic to avoid double linking warnings
-- and incorrect linking
dep["/thread/generic/"] = { nil, files = { "SDL_syscond.c", "SDL_sysmutex_c.h" } }
dep["/thread/windows/"] = { nil }
dep["/timer/windows/"] = { nil }
dep["/video/windows/"] = { nil }
elseif os.get() == "macosx" then
dep["/audio/coreaudio/"] = { nil }
dep["/file/cocoa/"] = { nil }
...
dep["/video/cocoa/"] = { nil }
dep["/video/x11/"] = { nil }
else
print("SDL2 via premake is not supported on platform: " .. os.get())
end
That was the old file, shortened. It's obviously disgusting and ugly. At least, it is compared to the newer version:
function directXDep()
print("Checking DirectX dependencies...")
local foundInc, incpath = find_dependency_dir_windows("DXSDK_DIR", "C:/Program Files;C:/Program Files (x86)", "DirectX", "Include")
local foundLib, libpath = find_dependency_dir_windows("DXSDK_DIR", "C:/Program Files;C:/Program Files (x86)", "DirectX", "Lib/x86")
if not foundInc or not foundLib then return false, "DirectX" end
return true, "DirectX", { incpath }, { libpath }, { }
end
function winmmDep()
print("Checking winmm dependencies...")
local libpath = os.findlib("winmm")
local foundLib = libpath ~= nil
if not foundLib then return false, "winmm" end
return true, "winmm", { }, { libpath }, { "winmm" }
end
SDL_project "SDL2"
SDL_kind "SharedLib"
SDL_language "C++"
SDL_sourcedir "../src"
-- dependency tree for SDL2
SDL_dependency ""
-- unnamed means it's not a dependency
-- no OS means platform-independent
-- this is a minimal setup that should
-- essentially work on every target platform
SDL_paths
{
"/",
"/atomic/",
"/audio/",
"/audio/disk/",
"/audio/dummy/",
"/cpuinfo/",
"/events/",
"/file/",
"/haptic/",
"/joystick/",
"/power/",
"/render/",
"/render/software/",
"/stdlib/",
"/thread/",
"/timer/",
"/video/",
"/video/dummy/"
}
-- windows dependencies
SDL_dependency "windows"
SDL_os "windows"
SDL_links { "imm32", "oleaut32", "version" }
SDL_paths
{
"/core/windows/",
"/haptic/windows/",
"/joystick/windows/",
"/libm/",
"/loadso/windows/",
"/power/windows/",
"/render/opengl/",
"/thread/windows/",
"/timer/windows/",
"/video/windows/"
}
SDL_files
{
-- these files have to be specified uniquely to avoid double
-- and incorrect linking
"/thread/generic/SDL_syscond.c",
"/thread/generic/SDL_sysmutex_c.h"
}
-- winmm dependency
SDL_dependency "winmm"
SDL_os "windows"
SDL_depfunc(winmmDep)
SDL_paths { "/audio/winmm/" }
-- directx dependency
SDL_dependency "directx"
SDL_os "windows"
SDL_depfunc(directXDep)
SDL_paths
{
"/audio/directsound/",
"/audio/xaudio2/",
"/render/direct3d/"
}
SDL_dependency "macosx"
SDL_os "macosx"
SDL_paths
{
"/audio/coreaudio/",
"/file/cocoa/",
"/haptic/darwin/",
"/joystick/darwin/",
"/loadso/dlopen/",
"/power/macosx/",
"/render/opengl/",
"/thread/pthread/",
"/timer/unix/",
"/video/cocoa/",
"/video/x11/"
}
The beauty of this new code goes without explanation, but I will point some things out. I didn't have to trim it at all in my paste here, because it's hardly longer than the trimmed other version. The code length is shorter and there's less to type. I also increased the length of this version by separating the winmm dependencies from the general windows dependencies. The flexibility here is self-explanatory.
Complex SDL Configurations
I mentioned or hinted a while back at wanting more sophisticated means of building SDL. An example I gave was the ability to build SDL without any sort of native renderer, and having it still work. Ie, the windows solution file for SDL should not depend on OpenGL or DirectX at all. If someone doesn't have DirectX installed, they should still be able to build SDL. Granted, they will be missing a significant number of features, but that doesn't mean it shouldn't build, link, and run correctly.
However, simply omitting a few libraries from SDL is not enough to stop it from expecting those links. If I do not include /render/opengl, it will compile fine, but it won't link fine. Why? Because SDL is expecting the functions in /render/opengl to be there. How do we stop SDL from expecting something we don't want to be there?
Enter configure and autotools.
SDL's "assumption system" is based on a single configuration header file, which differs from operating system to operating system (on windows, it's SDL_config_windows.h). On a Unix environment, one can use the configure script to check for system dependencies and generate an appropriate config header file that allows SDL to build properly. This is very nice, but it was not taken into consideration for Windows or Mac OS X.
I've implemented a new function in the functionally-driven project definition system for setting up custom defines that can be pasted into a generated config file. For example, the following configuration directive is for setting up the defines needed to enable DirectX support in SDL:
SDL_config
{
["SDL_AUDIO_DRIVER_DSOUND"] = 1,
["SDL_AUDIO_DRIVER_XAUDIO2"] = 1,
["SDL_JOYSTICK_DINPUT"] = 1,
["SDL_HAPTIC_DINPUT"] = 1,
["SDL_VIDEO_RENDER_D3D"] = 1
}
The only thing next to do is to decide whether to generate a config file or try to use compiler-level defines to simply set flags. Due to various defines in the SDL_config_windows.h file, I cannot just set compiler-level defines, unless I change that file to use #ifndef when setting some of the defines (it does it for many of the other defines, which is nice).
After that is decided, I'll be able to support a lot more flexibility when building SDL than was possible before on both Windows and Mac OS X. Also, if the build system is extended to other platforms, it will conveniently similar to the processing of configure and autotools for generating a makefile, if developers are interested in that.
Until next time,
Ben
