-- premake5.lua

-- This file describes the build configuration for Slang so

-- that premake can generate platform-specific build files

-- using Premake 5 (https://premake.github.io/).

--

-- To update the build files that are checked in to the Slang repository,

-- run a `premake5` binary and specify the appropriate action, e.g.:

--

-- premake5.exe --os=windows vs2015

--

-- If you are trying to build Slang on another platform, then you

-- can try invoking `premake5` for your desired OS and build format

-- and see what happens.

--

-- If you are going to modify this file to change/customize the Slang

-- build, then you may need to read up on Premake's approach and

-- how it uses/abuses Lua syntax. A few important things to note:

--

-- * Everything that *looks* like a declarative (e.g., `kind "SharedLib"`)

-- is actually a Lua function call (e.g., `kind("SharedLib")`) that

-- modifies the behind-the-scenes state that describes the build.

--

-- * Many of these function calls are "sticky" and affect subsequent

-- calls, so ordering matters a *lot*. This file uses indentation to

-- represent some of the flow of state, but it is important to recognize

-- that the indentation is not semantically significant.

--

-- * Because the configuration logic is just executable Lua code, we

-- can capture and re-use bits of configuration logic in ordinary

-- Lua subroutines.

--

-- Now let's move on to the actual build:

-- The "workspace" represents the overall build (the "solution" in

-- Visual Studio terms). It sets up basic build settings that will

-- apply across all projects.

--

-- To output linux will output to linux

-- % premake5 --os=linux gmake2 --build-location="build.linux"

--

-- % cd build.linux

-- % make config=release_x64

-- or

-- % make config=debug_x64

--

-- From in the build directory you can use

-- % premake5 --file=../premake5.lua --os=linux gmake2

-- Fail if we try to use the deprecated 'gmake' generator

if _ACTION == "gmake" then

premake.error "Please use the 'gmake2' generator instead of 'gmake'"

end

--

-- Add the package path for slang-pack/slang-util

-- The question mark is there the name of the module is inserted.

---

local modulePath = "external/slang-binaries/lua-modules/?.lua"

package.path = package.path .. ";" .. modulePath

-- Load the slack package manager module

slangPack = require("slang-pack")

slangUtil = require("slang-util")

-- Load the dependencies from the json file

deps = slangPack.loadDependencies("deps/target-deps.json")

newoption {

trigger = "override-module",

description = "(Optional) Specify a lua file that can override functions",

value = "path"

}

newoption {

trigger = "build-location",

description = "(Optional) Specifiy the location to place solution on root Makefile",

value = "path"

}

newoption {

trigger = "execute-binary",

description = "(Optional) If true binaries used in build will be executed (disable on cross compilation)",

value = "bool",

default = "true",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "build-glslang",

description = "(Optional) If true glslang and spirv-opt will be built",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-cuda",

description = "(Optional) If true will enable cuda tests, if CUDA is found via CUDA_PATH",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-nvapi",

description = "(Optional) If true will enable NVAPI, if NVAPI is found via external/nvapi",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "cuda-sdk-path",

description = "(Optional) Path to the root of CUDA SDK. If set will enable CUDA in build (ie in effect sets enable-cuda=true too)",

value = "path"

}

newoption {

trigger = "enable-optix",

description = "(Optional) If true will enable OptiX build/ tests (also implicitly enables CUDA)",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "optix-sdk-path",

description = "(Optional) Path to the root of OptiX SDK. (Implicitly enabled OptiX and CUDA)",

value = "path"

}

newoption {

trigger = "enable-profile",

description = "(Optional) If true will enable slang-profile tool - suitable for gprof usage on linux",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-embed-stdlib",

description = "(Optional) If true build slang with an embedded version of the stdlib",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-xlib",

description = "(Optional) If true build `gfx` and `platform` with xlib to support windowed apps on linux.",

value = "bool",

default = "true",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-experimental-projects",

description = "(Optional) If true include experimental projects in build.",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "disable-stdlib-source",

description = "(Optional) If true stdlib source will not be included in binary.",

value = "bool",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "skip-source-generation",

description = "(Optional) If true will skip source generation steps.",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "deploy-slang-llvm",

description = "(Optional) If true will copy slang-llvm to output directory.",

value = "bool",

default = "true",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "deploy-slang-glslang",

description = "(Optional) If true will copy slang-glslang to output directory.",

value = "bool",

default = "true",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "full-debug-validation",

description = "(Optional) If true will enable full IR validation in debug build. (SLOW!)",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-asan",

description = "(Optional) If true will enable ASAN (address santizier).",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "dx-on-vk",

description = "(Optional) If true will use dxvk and vkd3d-proton for DirectX support",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "enable-aftermath",

description = "(Optional) Enable aftermath in GFX, and add aftermath crash example to project",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

newoption {

trigger = "default-spirv-direct",

description = "(Optional) Development flag to make the default SPIR-V path generate directly rather than via GLSL",

value = "bool",

default = "false",

allowed = { { "true", "True"}, { "false", "False" } }

}

buildLocation = _OPTIONS["build-location"]

executeBinary = (_OPTIONS["execute-binary"] == "true")

buildGlslang = (_OPTIONS["build-glslang"] == "true")

enableCuda = not not (_OPTIONS["enable-cuda"] == "true" or _OPTIONS["cuda-sdk-path"])

enableProfile = (_OPTIONS["enable-profile"] == "true")

optixPath = _OPTIONS["optix-sdk-path"]

enableOptix = not not (_OPTIONS["enable-optix"] == "true" or optixPath)

enableProfile = (_OPTIONS["enable-profile"] == "true")

enableEmbedStdLib = (_OPTIONS["enable-embed-stdlib"] == "true")

enableXlib = (_OPTIONS["enable-xlib"] == "true")

skipSourceGeneration = (_OPTIONS["skip-source-generation"] == "true")

deployLLVM = (_OPTIONS["deploy-slang-llvm"] == "true")

deployGLSLang = (_OPTIONS["deploy-slang-glslang"] == "true")

fullDebugValidation = (_OPTIONS["full-debug-validation"] == "true")

enableAsan = (_OPTIONS["enable-asan"] == "true")

dxOnVk = (_OPTIONS["dx-on-vk"] == "true")

enableAftermath = (_OPTIONS["enable-aftermath"] == "true")

defaultSPIRVDirect = (_OPTIONS["default-spirv-direct"] == "true")

-- If stdlib embedding is enabled, disable stdlib source embedding by default

disableStdlibSource = enableEmbedStdLib

-- If embedding is enabled, and the setting `disable-stdlib-source` setting is set, use it's value

if enableEmbedStdLib and _OPTIONS["disable-stdlib-source"] ~= nil then

disableStdlibSource = (_OPTIONS["disable-stdlib-source"] == "true")

end

if enableAftermath then

aftermathPath = "external/nv-aftermath"

if not os.isfile(path.join(aftermathPath, "nsight-aftermath-usage-guidelines.txt")) then

print("external/nv-aftermath directory must hold aftermath SDK")

os.exit(0)

end

printf("Enabled aftermath")

end

-- Determine the target info

targetInfo = slangUtil.getTargetInfo()

--

-- Update the dependencies for the target

--

deps:update(targetInfo.name)

-- Get the target name that can be used as paths that generate for different configurations (ie contains premake Tokens)

targetName = targetInfo.tokenName

-- This is the path where nvapi is expected to be found

nvapiPath = "external/nvapi"

if enableOptix then

optixPath = optixPath or "C:/ProgramData/NVIDIA Corporation/OptiX SDK 7.0.0/"

enableCuda = true

end

-- cudaPath is only set if cuda is enabled, and CUDA_PATH enviromental variable is set

cudaPath = nil

if enableCuda then

-- Get the CUDA path. Use the value set on cuda-sdk-path by default, if not set use the environment variable.

cudaPath = (_OPTIONS["cuda-sdk-path"] or os.getenv("CUDA_PATH"))

end

-- TODO(JS): What's the point in the enable-xlib command line option if it's just overridden here?

if targetInfo.isWindows or os.target() == "macosx" then

enableXlib = false

end

-- Even if we have the nvapi path, we only want to currently enable on windows targets

enableNvapi = not not (os.isdir(nvapiPath) and targetInfo.isWindows and _OPTIONS["enable-nvapi"] == "true")

if enableNvapi then

printf("Enabled NVAPI")

end

overrideModule = {}

local overrideModulePath = _OPTIONS["override-module"]

if overrideModulePath then

overrideModule = require(overrideModulePath)

end

-- This is needed for gcc, for the 'fileno' functions on cygwin

-- _GNU_SOURCE makes realpath available in gcc

if targetInfo.os == "cygwin" then

buildoptions { "-D_POSIX_SOURCE" }

filter { "toolset:gcc*" }

buildoptions { "-D_GNU_SOURCE" }

end

function getPlatforms(targetInfo)

return { "x86", "x64", "aarch64" }

end

workspace "slang"

-- We will support debug/release configuration and x86/x64 builds.

configurations { "Debug", "Release" }

platforms(getPlatforms(targetInfo))

if buildLocation then

location(buildLocation)

end

flags "MultiProcessorCompile"

--

-- Make slang-test the startup project.

--

-- https://premake.github.io/docs/startproject

startproject "slang-test"

-- The output binary directory will be derived from the OS

-- and configuration options, e.g. `bin/windows-x64/debug/`

targetdir("bin/" .. targetName .. "/%{cfg.buildcfg:lower()}")

cppdialect "C++17"

-- Statically link to the C/C++ runtime rather than create a DLL dependency.

staticruntime "On"

-- Turn off edit and continue for all projects. This is needed to avoid

-- linking warnings.

editandcontinue "Off"

-- Once we've set up the common settings, we will make some tweaks

-- that only apply in a subset of cases. Each call to `filter()`

-- changes the "active" filter for subsequent commands. In

-- effect, those commands iwll be ignored when the conditions of

-- the filter aren't satisfied.

-- Our `x64` platform should (obviously) target the x64

-- architecture and similarly for x86.

--

-- https://premake.github.io/docs/architecture/

--

filter { "platforms:x64" }

architecture "x64"

filter { "platforms:x86" }

architecture "x86"

filter { "platforms:aarch64" }

architecture "ARM64"

filter { "platforms:aarch64", "toolset:clang" }

buildoptions { "-arch arm64" }

linkoptions { "-arch arm64" }

filter { "toolset:clang or gcc*" }

-- Makes all symbols hidden by default unless explicitly 'exported'

buildoptions { "-fvisibility=hidden" }

filter { "toolset:clang or gcc*", "files:source/compiler-core/slang-dxc-compiler.cpp" }

-- For the DXC headers

buildoptions { "-fms-extensions" }

-- Disable some warnings

filter { "toolset:clang or gcc*" }

buildoptions {

"-Wno-switch",

"-Wno-parentheses",

"-Wno-unused-local-typedefs",

}

filter { "toolset:gcc*", "language:C++" }

buildoptions { "-Wno-class-memaccess" }

-- If a function returns an address/reference to a local, we want it to produce an error, because

-- it probably means something very bad.

buildoptions { "-Werror=return-local-addr" }

filter { "toolset:clang", "language:C++" }

buildoptions { "-Wno-assume" }

filter { "toolset:clang or gcc*", "language:C++" }

buildoptions { "-Wno-reorder", "-Wno-invalid-offsetof" }

-- Enable some warnings on clang/gcc which are on by default in MSVC

filter { "toolset:clang or gcc*", "language:C++" }

buildoptions { "-Wnarrowing" }

-- When compiling the debug configuration, we want to turn

-- optimization off, make sure debug symbols are output,

-- and add the same preprocessor definition that VS

-- would add by default.

filter { "configurations:debug" }

optimize "Off"

symbols "On"

defines { "_DEBUG" }

-- staticruntime "Off"

-- For the release configuration we will turn optimizations on

-- (we do not yet micro-manage the optimization settings)

-- and set the preprocessor definition that VS would add by default.

filter { "configurations:release" }

optimize "On"

defines { "NDEBUG" }

filter { "system:linux" }

links { "dl" }

--

-- `--no-undefined` - by default if a symbol is not found in a link it will assume it will be resolved at runtime (!)

-- this option ensures that all the referenced symbols exist

--

linkoptions{ "-Wl,-rpath,'$$ORIGIN',--no-as-needed,--no-undefined" }

-- allow libraries to be listed in any order (do not require dependency order)

linkgroups "On"

filter {}

-- For including windows.h in a way that minimized namespace pollution.

-- Although we define these here, we still set them manually in any header

-- files which may be included by another project

defines { "WIN32_LEAN_AND_MEAN", "VC_EXTRALEAN", "NOMINMAX", "_ITERATOR_DEBUG_LEVEL=0" }

if dxOnVk then

defines { "SLANG_CONFIG_DX_ON_VK" }

end

if defaultSPIRVDirect then

defines { "SLANG_CONFIG_DEFAULT_SPIRV_DIRECT" }

end

function dump(o)

end

function dumpTable(o)

end

function getExecutableSuffix()

end

--

-- We are now going to start defining the projects, where

-- each project builds some binary artifact (an executable,

-- library, etc.).

--

-- All of our projects follow a common structure, so rather

-- than reiterate a bunch of build settings, we define

-- some subroutines that make the configuration as concise

-- as possible.

--

-- First, we will define a helper routine for adding all

-- the relevant files from a given directory path:

--

-- Note that this does not work recursively

-- so projects that spread their source over multiple

-- directories will need to take more steps.

function addSourceDir(path)

end

-- Adds CUDA dependency to a project

function addCUDAIfEnabled()

end

--

-- Next we will define a helper routine that all of our

-- projects will bottleneck through. Here `name` is

-- the name for the project (and the base name for

-- whatever output file it produces), while `sourceDir`

-- is the directory that holds the source.

--

-- E.g., for the `slangc` project, the source code

-- is nested in `source/`, so we'd (indirectly) call:

--

-- baseSlangProject("slangc", "source/slangc")

--

-- NOTE! This function will add any source from the sourceDir, *if* it's specified.

-- Pass nil if adding files is not wanted.

function baseSlangProject(name, sourceDir)

end

-- We can now use the `baseSlangProject()` subroutine to

-- define helpers for the different categories of project

-- in our source tree.

--

-- For example, the Slang project has several tools that

-- are used during building/testing, but don't need to

-- be distributed. These always have their source code in

-- `tools/<project-name>/`.

--

function tool(name)

end

-- "Standard" projects will be those that go to make the binary

-- packages for slang: the shared libraries and executables.

--

function standardProject(name, sourceDir)

end

function toolSharedLibrary(name)

end

function exampleLibrary(name)

end

exampleLibrary "example-base"

-- Finally we have the example programs that show how to use Slang.

--

function example(name)

end

--

-- Create a project that is used as a build step, typically to

-- build items needed for other dependencies

---

function generatorProject(name, sourcePath, projectKind)

end

--

-- With all of these helper routines defined, we can now define the

-- actual projects quite simply. For example, here is the entire

-- declaration of the "Hello, World" example project:

--

example "hello-world"

kind "ConsoleApp"

includedirs {"external/vulkan/include"}

-- Note how we are calling our custom `example()` subroutine with

-- the same syntax sugar that Premake usually advocates for their

-- `project()` function. This allows us to treat `example` as

-- a kind of specialized "subclass" of `project`

--

-- Let's go ahead and set up the projects for our other example now.

example "platform-test"

example "triangle"

example "ray-tracing"

example "ray-tracing-pipeline"

example "autodiff-texture"

example "gpu-printing"

kind "ConsoleApp"

example "shader-toy"

example "model-viewer"

example "shader-object"

kind "ConsoleApp"

example "cpu-com-example"

kind "ConsoleApp"

example "cpu-hello-world"

kind "ConsoleApp"

if enableAftermath then

example "nv-aftermath-example"

filter {}

local aftermathIncludePath = path.join(aftermathPath, "include")

local aftermathLibPath = path.join(aftermathPath, "lib")

-- Add the aftermath includes

includedirs { aftermathIncludePath }

-- Add the libs directory.

-- Additionally we need to copy dlls that are needed for aftermath usage such that they

-- are available from the executable.

filter { "platforms:x86" }

local libPath = path.join(aftermathLibPath, "x86")

libdirs { libPath }

links { "GFSDK_Aftermath_Lib.x86" }

postbuildcommands {

'{COPY} "$(SolutionDir)"' .. libPath .. '/*.* "%{cfg.targetdir}"'

}

filter { "platforms:x64" }

local libPath = path.join(aftermathLibPath, "x64")

libdirs { libPath }

links { "GFSDK_Aftermath_Lib.x64" }

postbuildcommands {

'{COPY} "$(SolutionDir)"' .. libPath .. '/*.* "%{cfg.targetdir}"'

}

end

-- Most of the other projects have more interesting configuration going

-- on, so let's walk through them in order of increasing complexity.

--

-- The `core` project is a static library that has all the basic types

-- and routines that get shared across both the Slang compiler/runtime

-- and the various tool projects. It's build is pretty simple:

--

standardProject("core", "source/core")

uuid "F9BE7957-8399-899E-0C49-E714FDDD4B65"

kind "StaticLib"

-- We need the core library to be relocatable to be able to link with slang.so

pic "On"

-- For our core implementation, we want to use the most

-- aggressive warning level supported by the target, and

-- to treat every warning as an error to make sure we

-- keep our code free of warnings.

--

warnings "Extra"

includedirs { "external/miniz" }

if targetInfo.isWindows then

addSourceDir "source/core/windows"

else

addSourceDir "source/core/unix"

end

standardProject("compiler-core", "source/compiler-core")

uuid "12C1E89D-F5D0-41D3-8E8D-FB3F358F8126"

kind "StaticLib"

-- We need the compiler-core library to be relocatable to be able to link with slang.so

pic "On"

links { "core" }

-- For our core implementation, we want to use the most

-- aggressive warning level supported by the target, and

-- to treat every warning as an error to make sure we

-- keep our code free of warnings.

--

warnings "Extra"

if targetInfo.isWindows then

addSourceDir "source/compiler-core/windows"

else

addSourceDir "source/compiler-core/unix"

end

standardProject("slang-rt", "source/slang-rt")

uuid "DFC79D72-91DE-434C-871B-B3943B488BEB"

kind "SharedLib"

pic "On"

warnings "Extra"

links {"miniz", "lz4"}

includedirs { "external/miniz" }

defines { "SLANG_RT_DYNAMIC", "SLANG_RT_DYNAMIC_EXPORT" }

addSourceDir "source/core"

if targetInfo.isWindows then

addSourceDir "source/core/windows"

else

addSourceDir "source/core/unix"

links { "pthread" }

end

--

-- The cpp extractor is a tool that scans C++ header files to extract

-- reflection like information, and generate files to handle

-- RTTI fast/simply

---

tool "slang-cpp-extractor"

uuid "CA8A30D1-8FA9-4330-B7F7-84709246D8DC"

includedirs { "." }

links { "compiler-core", "core" }

tool "slang-spirv-embed-generator"

uuid "8da787cc-0e04-450f-8e29-88eac5ebe9bb"

includedirs { "." }

links { "compiler-core", "core" }

tool "slang-lookup-generator"

uuid "3242baa7-fc4c-4f76-83bc-e4403099dc1d"

includedirs { "." }

links { "compiler-core", "core" }