Properly export when making shared library

Fixes using a dll in windows

.github/dependabot.yml

@@ -3,4 +3,4 @@ updates:
   - package-ecosystem: "gitsubmodule"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "monthly"

.github/workflows/release.yml

@@ -25,11 +25,11 @@ jobs:
       - id: version
         run: |
           API_VERSION=$(grep -Eo "BGFX_API_VERSION UINT32_C\([0-9]+\)" bgfx/include/bgfx/defines.h | grep -Eo "[0-9]+" | tail -1)
-          REVISION=$(cd bgfx && git rev-list HEAD --count)
+          BGFX_REVISION=$(cd bgfx && git rev-list HEAD --count)
+          BGFX_CMAKE_REVISION=$(git rev-list HEAD --count)
           SHA=$(cd bgfx && git rev-parse HEAD)
-          SHA7="${GITHUB_SHA::7}"
-          TAG="v1.${API_VERSION}.${REVISION}-${SHA7}"
-          echo "::set-output name=revision::${REVISION}"
+          TAG="v1.${API_VERSION}.${BGFX_REVISION}-${BGFX_CMAKE_REVISION}"
+          echo "::set-output name=revision::${BGFX_REVISION}"
           echo "::set-output name=sha::${SHA}"
           echo "::set-output name=tag::${TAG}"
 
@@ -75,11 +75,10 @@ jobs:
       # Run CMake to generate project files
       - name: Generate project files
         run: |
-          cmake -B "${{ env.CMAKE_BUILD_DIR }}" -DCMAKE_INSTALL_PREFIX="${{ env.CMAKE_INSTALL_DIR }}" -DCMAKE_DEBUG_POSTFIX=d -DBGFX_BUILD_EXAMPLES=OFF -DBGFX_BUILD_TOOLS=ON -DBGFX_INSTALL=ON -DBGFX_AMALGAMATED=ON
+          cmake -B "${{ env.CMAKE_BUILD_DIR }}" -DCMAKE_INSTALL_PREFIX="${{ env.CMAKE_INSTALL_DIR }}" -DCMAKE_DEBUG_POSTFIX=d -DBGFX_BUILD_EXAMPLES=OFF -DBGFX_BUILD_TOOLS=ON -DBGFX_INSTALL=ON -DBGFX_AMALGAMATED=ON -DCMAKE_BUILD_TYPE=Release
       # Build the install targets
       - name: Build
         run: |
-          cmake --build "${{ env.CMAKE_BUILD_DIR }}" --target install --config Debug
           cmake --build "${{ env.CMAKE_BUILD_DIR }}" --target install --config Release
       - uses: actions/upload-artifact@v2
         with:

.gitignore

@@ -13,3 +13,4 @@ install_manifest.txt
 generated/*
 !generated/*.in
 cmake_install.cmake
+.cache/

CMakeLists.txt

@@ -21,20 +21,43 @@ if( APPLE AND NOT XCODE )
 	set( CMAKE_CXX_FLAGS "-ObjC++" )
 endif()
 
-option( BGFX_BUILD_TOOLS      "Build bgfx tools."                             ON  )
-option( BGFX_BUILD_EXAMPLES   "Build bgfx examples."                          ON  )
-option( BGFX_INSTALL          "Create installation target."                   ON  )
-option( BGFX_INSTALL_EXAMPLES "Install examples and their runtimes."          OFF )
-option( BGFX_CUSTOM_TARGETS   "Include convenience custom targets."           ON  )
-option( BGFX_AMALGAMATED      "Amalgamated bgfx build for faster compilation" OFF )
-option( BX_AMALGAMATED        "Amalgamated bx build for faster compilation"   OFF )
-option( BGFX_CONFIG_DEBUG     "Enables debug configuration on all builds"     OFF )
-option( BGFX_CONFIG_RENDERER_WEBGPU     "Enables the webgpu renderer"         OFF )
+if (MSVC AND (MSVC_VERSION GREATER_EQUAL 1914))
+    add_compile_options("/Zc:__cplusplus")
+endif()
+
+option( BX_AMALGAMATED                  "Amalgamated bx build for faster compilation"         OFF )
+option( BX_CONFIG_DEBUG                 "Log debug messages (default: on in debug)"           OFF )
+option( BGFX_AMALGAMATED                "Amalgamated bgfx build for faster compilation"       OFF )
+option( BGFX_BUILD_TOOLS                "Build bgfx tools."                                   ON  )
+option( BGFX_BUILD_TOOLS_SHADER         "Build bgfx shader tools."                            ON  )
+option( BGFX_BUILD_TOOLS_GEOMETRY       "Build bgfx geometry tools."                          ON  )
+option( BGFX_BUILD_TOOLS_TEXTURE        "Build bgfx texture tools."                           ON  )
+option( BGFX_BUILD_EXAMPLES             "Build bgfx examples."                                ON  )
+option( BGFX_INSTALL                    "Create installation target."                         ON  )
+option( BGFX_INSTALL_EXAMPLES           "Install examples and their runtimes."                OFF )
+option( BGFX_CUSTOM_TARGETS             "Include convenience custom targets."                 ON  )
+option( BGFX_CONFIG_MULTITHREADED       "Build bgfx with multithreaded configuration"         ON )
+option( BGFX_CONFIG_RENDERER_WEBGPU     "Enable the webgpu renderer"                          OFF )
+option( BGFX_CONFIG_DEBUG_ANNOTATION    "Enable gfx debug annotations (default: on in debug)" OFF )
 
 set( BGFX_OPENGL_VERSION   ""       CACHE STRING "Specify minimum opengl version" )
 set( BGFX_OPENGLES_VERSION ""       CACHE STRING "Specify minimum OpenGL ES version" )
 set( BGFX_LIBRARY_TYPE     "STATIC" CACHE STRING "Linking type for library" )
 
+set( BGFX_CONFIG_DEFAULT_MAX_ENCODERS             "" CACHE STRING "Specify default maximum encoder count (multithreaded only)" )
+set( BGFX_CONFIG_MAX_DRAW_CALLS                   "" CACHE STRING "Specify maximum draw calls" )
+set( BGFX_CONFIG_MAX_VIEWS                        "" CACHE STRING "Specify maximum view count (should be a power of two)" )
+set( BGFX_CONFIG_MAX_FRAME_BUFFERS                "" CACHE STRING "Specify maximum frame buffers" )
+set( BGFX_CONFIG_MAX_VERTEX_LAYOUTS               "" CACHE STRING "Specify maximum vertex layouts" )
+set( BGFX_CONFIG_MAX_VERTEX_BUFFERS               "" CACHE STRING "Specify maximum vertex buffer count" )
+set( BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS       "" CACHE STRING "Specify maximum dynamic vertex buffer count" )
+set( BGFX_CONFIG_MAX_INDEX_BUFFERS                "" CACHE STRING "Specify maximum index buffer count" )
+set( BGFX_CONFIG_MAX_DYNAMIC_INDEX_BUFFERS        "" CACHE STRING "Specify maximum dynamic index buffer count" )
+set( BGFX_CONFIG_MAX_TEXTURES                     "" CACHE STRING "Specify maximum texture count" )
+set( BGFX_CONFIG_MAX_TEXTURE_SAMPLERS             "" CACHE STRING "Specify maximum texture samplers" )
+set( BGFX_CONFIG_MAX_SHADERS                      "" CACHE STRING "Specify shader count" )
+set( BGFX_CONFIG_SORT_KEY_NUM_BITS_PROGRAM        "" CACHE STRING "Specify maximum program count as 2^(program bits)" )
+
 set_property( CACHE BGFX_LIBRARY_TYPE PROPERTY STRINGS STATIC SHARED )
 
 if( BGFX_LIBRARY_TYPE MATCHES "SHARED" )
@@ -58,19 +81,19 @@ elseif( NOT IS_ABSOLUTE "${BGFX_DIR}")
 endif()
 
 # sets project version from api ver / git rev
-include( cmake/version.cmake )
+include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.cmake )
 
-include( cmake/shared.cmake )
-include( cmake/bx.cmake )
-include( cmake/bimg.cmake )
-include( cmake/bgfx.cmake )
+include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/shared.cmake )
+include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/bx.cmake )
+include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/bimg.cmake )
+include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/bgfx.cmake )
 
 if( BGFX_BUILD_TOOLS )
-	include( cmake/tools.cmake )
+	include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/tools.cmake )
 endif()
 
 if( BGFX_BUILD_TOOLS OR BGFX_BUILD_EXAMPLES )
-	include( cmake/examples.cmake )
+	include( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/examples.cmake )
 endif()
 
 if( BGFX_INSTALL )
@@ -111,7 +134,7 @@ if( BGFX_INSTALL )
 	#   * TARGETS_EXPORT_NAME
 	#   * PROJECT_NAME
 	configure_package_config_file(
-		"cmake/Config.cmake.in"
+		"${CMAKE_CURRENT_SOURCE_DIR}/cmake/Config.cmake.in"
 		"${project_config}"
 		INSTALL_DESTINATION "${config_install_dir}"
 	)
@@ -126,7 +149,7 @@ if( BGFX_INSTALL )
 			 INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 	)
 	if( NOT BGFX_LIBRARY_TYPE MATCHES "SHARED" )
-		install( TARGETS bimg bx astc-codec astc edtaa3 etc1 etc2 iqa squish nvtt pvrtc tinyexr
+		install( TARGETS bimg bx astc-encoder edtaa3 etc1 etc2 iqa squish nvtt pvrtc tinyexr
 				 EXPORT "${TARGETS_EXPORT_NAME}"
 				 LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
 				 ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
@@ -155,22 +178,30 @@ if( BGFX_INSTALL )
 	)
 
 	# install tools
+	install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/bgfxToolUtils.cmake
+		DESTINATION "${config_install_dir}")
 	if( BGFX_BUILD_TOOLS )
-		install( TARGETS shaderc
-			EXPORT "${TARGETS_EXPORT_NAME}"
-			DESTINATION "${CMAKE_INSTALL_BINDIR}" )
-		install( TARGETS geometryc
-			EXPORT "${TARGETS_EXPORT_NAME}"
-			DESTINATION "${CMAKE_INSTALL_BINDIR}" )
-    	install( TARGETS geometryv
-			EXPORT "${TARGETS_EXPORT_NAME}"
-			DESTINATION "${CMAKE_INSTALL_BINDIR}" )
-		install( TARGETS texturec
-			EXPORT "${TARGETS_EXPORT_NAME}"
-			DESTINATION "${CMAKE_INSTALL_BINDIR}" )
-		install( TARGETS texturev
-			EXPORT "${TARGETS_EXPORT_NAME}"
-			DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+		if (BGFX_BUILD_TOOLS_SHADER)
+			install( TARGETS shaderc
+				EXPORT "${TARGETS_EXPORT_NAME}"
+				DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+		endif()
+		if (BGFX_BUILD_TOOLS_GEOMETRY)
+			install( TARGETS geometryc
+				EXPORT "${TARGETS_EXPORT_NAME}"
+				DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+			install( TARGETS geometryv
+				EXPORT "${TARGETS_EXPORT_NAME}"
+				DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+		endif()
+		if (BGFX_BUILD_TOOLS_TEXTURE)
+			install( TARGETS texturec
+				EXPORT "${TARGETS_EXPORT_NAME}"
+				DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+			install( TARGETS texturev
+				EXPORT "${TARGETS_EXPORT_NAME}"
+				DESTINATION "${CMAKE_INSTALL_BINDIR}" )
+		endif()
 	endif()
 
 	# install examples

cmake/3rdparty/astc-encoder.cmake

@@ -8,21 +8,21 @@
 # You should have received a copy of the CC0 Public Domain Dedication along with
 # this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 
-if( TARGET astc-codec )
+if( TARGET astc-encoder )
 	return()
 endif()
 
 file(
 	GLOB
-	ASTC_CODEC_SOURCES
-	${BIMG_DIR}/3rdparty/astc-codec/src/decoder/*.cc
-	${BIMG_DIR}/3rdparty/astc-codec/src/decoder/*.h
+	ASTC_ENCODER_SOURCES
+	${BIMG_DIR}/3rdparty/astc-encoder/source/*.cpp
+	${BIMG_DIR}/3rdparty/astc-encoder/include/*.h
 )
 
-add_library( astc-codec STATIC ${ASTC_CODEC_SOURCES} )
-target_include_directories( astc-codec
+add_library( astc-encoder STATIC ${ASTC_ENCODER_SOURCES} )
+target_include_directories( astc-encoder
 	PUBLIC
 		$<BUILD_INTERFACE:${BIMG_DIR}/3rdparty>
-		$<BUILD_INTERFACE:${BIMG_DIR}/3rdparty/astc-codec>
-		$<BUILD_INTERFACE:${BIMG_DIR}/3rdparty/astc-codec/include> )
-set_target_properties( astc-codec PROPERTIES FOLDER "bgfx/3rdparty" )
+		$<BUILD_INTERFACE:${BIMG_DIR}/3rdparty/astc-encoder>
+		$<BUILD_INTERFACE:${BIMG_DIR}/3rdparty/astc-encoder/include> )
+set_target_properties( astc-encoder PROPERTIES FOLDER "bgfx/3rdparty" )

cmake/3rdparty/astc.cmake

@@ -1,19 +0,0 @@
-# bgfx.cmake - bgfx building in cmake
-# Written in 2017 by Joshua Brookover <joshua.al.brookover@gmail.com>
-
-# To the extent possible under law, the author(s) have dedicated all copyright
-# and related and neighboring rights to this software to the public domain
-# worldwide. This software is distributed without any warranty.
-
-# You should have received a copy of the CC0 Public Domain Dedication along with
-# this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
-
-if( TARGET astc )
-	return()
-endif()
-
-file( GLOB ASTC_SOURCES ${BIMG_DIR}/3rdparty/astc/*.cpp ${BIMG_DIR}/3rdparty/astc/*.h )
-
-add_library( astc STATIC ${ASTC_SOURCES} )
-target_include_directories( astc PUBLIC $<BUILD_INTERFACE:${BIMG_DIR}/3rdparty> )
-set_target_properties( astc PROPERTIES FOLDER "bgfx/3rdparty" )

cmake/3rdparty/glsl-optimizer.cmake

@@ -27,7 +27,8 @@ string(REPLACE "-fsanitize=undefined" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" )
 
 # glcpp
 file( GLOB GLCPP_SOURCES ${BGFX_DIR}/3rdparty/glsl-optimizer/src/glsl/glcpp/*.c ${BGFX_DIR}/3rdparty/glsl-optimizer/src/util/*.c )
-add_library( glcpp ${GLCPP_SOURCES} )
+# Library must be static because hash_table_ctor referenced in function glcpp_parser_create
+add_library( glcpp STATIC ${GLCPP_SOURCES} )
 target_include_directories( glcpp PUBLIC ${GLSL-OPTIMIZER_INCLUDES} )
 if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")
 	target_compile_options( glcpp PRIVATE "-fno-strict-aliasing")
@@ -39,7 +40,8 @@ set_target_properties( glcpp PROPERTIES FOLDER "bgfx/3rdparty" )
 
 # mesa
 file( GLOB MESA_SOURCES ${BGFX_DIR}/3rdparty/glsl-optimizer/src/mesa/program/*.c ${BGFX_DIR}/3rdparty/glsl-optimizer/src/mesa/main/*.c )
-add_library( mesa ${MESA_SOURCES} )
+# Library must be static because mesa/program/prog_hash_table.c uses _mesa_error_no_memory which is in glsl/standalone_scaffolding.cpp of glsl-optimizer
+add_library( mesa STATIC ${MESA_SOURCES} )
 target_include_directories( mesa PUBLIC ${GLSL-OPTIMIZER_INCLUDES} )
 if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")
 	target_compile_options( mesa PRIVATE "-fno-strict-aliasing")
@@ -53,7 +55,7 @@ set_target_properties( mesa PROPERTIES FOLDER "bgfx/3rdparty" )
 file( GLOB GLSL-OPTIMIZER_SOURCES ${BGFX_DIR}/3rdparty/glsl-optimizer/src/glsl/*.cpp ${BGFX_DIR}/3rdparty/glsl-optimizer/src/glsl/*.c )
 file( GLOB GLSL-OPTIMIZER_SOURCES_REMOVE ${BGFX_DIR}/3rdparty/glsl-optimizer/src/glsl/main.cpp ${BGFX_DIR}/3rdparty/glsl-optimizer/src/glsl/builtin_stubs.cpp )
 list( REMOVE_ITEM GLSL-OPTIMIZER_SOURCES ${GLSL-OPTIMIZER_SOURCES_REMOVE} )
-add_library( glsl-optimizer ${GLSL-OPTIMIZER_SOURCES} )
+add_library( glsl-optimizer STATIC ${GLSL-OPTIMIZER_SOURCES} )
 target_link_libraries( glsl-optimizer glcpp mesa )
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	target_compile_options( glsl-optimizer

cmake/Config.cmake.in

@@ -1,4 +1,25 @@
 @PACKAGE_INIT@
 
 include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
-check_required_components("@PROJECT_NAME@") 
+get_target_property(BGFX_INCLUDE_PATH bgfx::bgfx INTERFACE_INCLUDE_DIRECTORIES)
+list(GET BGFX_INCLUDE_PATH 0 BGFX_INCLUDE_PATH_1) # bgfx::bgfx exports include directory twice?
+set(BGFX_SHADER_INCLUDE_PATH ${BGFX_INCLUDE_PATH_1}/bgfx)
+
+# If cross compiling, we need a host-compatible version of shaderc to compile shaders
+if (@CMAKE_CROSSCOMPILING@ AND NOT TARGET bgfx::shaderc)
+  find_program(
+    shaderc_EXECUTABLE REQUIRED
+    NAMES bgfx-shaderc shaderc
+    PATHS /usr/bin
+          ${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/packages/bgfx_x64-linux/tools/bgfx
+          ${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/packages/bgfx_x64-windows/tools/bgfx
+          ${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/packages/bgfx_x64-osx/tools/bgfx
+  )
+  add_executable(bgfx::shaderc IMPORTED)
+  set_target_properties(
+    bgfx::shaderc PROPERTIES IMPORTED_LOCATION "${shaderc_EXECUTABLE}"
+  )
+endif ()
+
+include("${CMAKE_CURRENT_LIST_DIR}/bgfxToolUtils.cmake")
+check_required_components("@PROJECT_NAME@") 

cmake/bgfx.cmake

@@ -40,10 +40,15 @@ else()
 endif()
 
 # Create the bgfx target
-add_library( bgfx ${BGFX_LIBRARY_TYPE} ${BGFX_SOURCES} )
+if(BGFX_LIBRARY_TYPE STREQUAL STATIC)
+    add_library( bgfx STATIC ${BGFX_SOURCES} )
+else()
+    add_library( bgfx SHARED ${BGFX_SOURCES} )
+    target_compile_definitions( bgfx PUBLIC BGFX_SHARED_LIB_BUILD=1 )
+endif()
 
 if(BGFX_CONFIG_RENDERER_WEBGPU)
-    include(cmake/3rdparty/webgpu.cmake)
+    include(${CMAKE_CURRENT_LIST_DIR}/3rdparty/webgpu.cmake)
     target_compile_definitions( bgfx PRIVATE BGFX_CONFIG_RENDERER_WEBGPU=1)
     if (EMSCRIPTEN)
         target_link_options(bgfx PRIVATE "-s USE_WEBGPU=1")
@@ -52,10 +57,8 @@ if(BGFX_CONFIG_RENDERER_WEBGPU)
     endif()
 endif()
 
-# Enable BGFX_CONFIG_DEBUG in Debug configuration
-target_compile_definitions( bgfx PRIVATE "$<$<CONFIG:Debug>:BGFX_CONFIG_DEBUG=1>" )
-if(BGFX_CONFIG_DEBUG)
-	target_compile_definitions( bgfx PRIVATE BGFX_CONFIG_DEBUG=1)
+if(EMSCRIPTEN)
+	target_link_options(bgfx PUBLIC "-sMAX_WEBGL_VERSION=2")
 endif()
 
 if( NOT ${BGFX_OPENGL_VERSION} STREQUAL "" )
@@ -66,16 +69,64 @@ if( NOT ${BGFX_OPENGLES_VERSION} STREQUAL "" )
 	target_compile_definitions( bgfx PRIVATE BGFX_CONFIG_RENDERER_OPENGLES_MIN_VERSION=${BGFX_OPENGLES_VERSION} )
 endif()
 
+if( NOT ${BGFX_CONFIG_DEFAULT_MAX_ENCODERS} STREQUAL "" )
+	target_compile_definitions( bgfx
+		PUBLIC
+				"BGFX_CONFIG_DEFAULT_MAX_ENCODERS=$<IF:$<BOOL:${BGFX_CONFIG_MULTITHREADED}>,${BGFX_CONFIG_DEFAULT_MAX_ENCODERS},1>" )
+endif()
+
+set(BGFX_CONFIG_OPTIONS "")
+list(APPEND BGFX_CONFIG_OPTIONS
+	"BGFX_CONFIG_MAX_DRAW_CALLS"
+	"BGFX_CONFIG_MAX_VIEWS"
+	"BGFX_CONFIG_MAX_FRAME_BUFFERS"
+	"BGFX_CONFIG_MAX_VERTEX_LAYOUTS"
+	"BGFX_CONFIG_MAX_VERTEX_BUFFERS"
+	"BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS"
+	"BGFX_CONFIG_MAX_INDEX_BUFFERS"
+	"BGFX_CONFIG_MAX_DYNAMIC_INDEX_BUFFERS"
+	"BGFX_CONFIG_MAX_TEXTURES"
+	"BGFX_CONFIG_MAX_TEXTURE_SAMPLERS"
+	"BGFX_CONFIG_MAX_SHADERS"
+	"BGFX_CONFIG_SORT_KEY_NUM_BITS_PROGRAM"
+)
+foreach(BGFX_CONFIG_OPTION IN LISTS BGFX_CONFIG_OPTIONS)
+	if( NOT ${${BGFX_CONFIG_OPTION}} STREQUAL "" )
+		target_compile_definitions( bgfx PUBLIC "${BGFX_CONFIG_OPTION}=${${BGFX_CONFIG_OPTION}}" )
+	endif()
+endforeach()
+
 # Special Visual Studio Flags
 if( MSVC )
 	target_compile_definitions( bgfx PRIVATE "_CRT_SECURE_NO_WARNINGS" )
 endif()
 
+# Add debug config required in bx headers since bx is private
+target_compile_definitions(bgfx
+       PUBLIC
+               "BX_CONFIG_DEBUG=$<OR:$<CONFIG:Debug>,$<BOOL:${BX_CONFIG_DEBUG}>>"
+               "BGFX_CONFIG_DEBUG_ANNOTATION=$<AND:$<NOT:$<STREQUAL:${CMAKE_SYSTEM_NAME},WindowsStore>>,$<OR:$<CONFIG:Debug>,$<BOOL:${BGFX_CONFIG_DEBUG_ANNOTATION}>>>"
+               "BGFX_CONFIG_MULTITHREADED=$<BOOL:${BGFX_CONFIG_MULTITHREADED}>"
+)
+
+# directx-headers
+set (DIRECTX_HEADERS)
+if (UNIX AND NOT APPLE AND NOT EMSCRIPTEN AND NOT ANDROID)  # Only Linux
+	set (DIRECTX_HEADERS 
+		${BGFX_DIR}/3rdparty/directx-headers/include/directx
+		${BGFX_DIR}/3rdparty/directx-headers/include
+		${BGFX_DIR}/3rdparty/directx-headers/include/wsl/stubs )
+elseif (WIN32)  # Only Windows
+	set (DIRECTX_HEADERS 
+		${BGFX_DIR}/3rdparty/directx-headers/include/directx
+		${BGFX_DIR}/3rdparty/directx-headers/include )
+endif()
+
 # Includes
 target_include_directories( bgfx
 	PRIVATE
+		${DIRECTX_HEADERS}
 		${BGFX_DIR}/3rdparty
-		${BGFX_DIR}/3rdparty/dxsdk/include
 		${BGFX_DIR}/3rdparty/khronos
 	PUBLIC
 		$<BUILD_INTERFACE:${BGFX_DIR}/include>
@@ -86,15 +137,20 @@ target_link_libraries( bgfx PRIVATE bx bimg )
 
 # Frameworks required on iOS, tvOS and macOS
 if( ${CMAKE_SYSTEM_NAME} MATCHES iOS|tvOS )
-	target_link_libraries (bgfx PUBLIC "-framework OpenGLES  -framework Metal -framework UIKit -framework CoreGraphics -framework QuartzCore")
+	target_link_libraries (bgfx PUBLIC 
+		"-framework OpenGLES -framework Metal -framework UIKit -framework CoreGraphics -framework QuartzCore -framework IOKit -framework CoreFoundation")
 elseif( APPLE )
 	find_library( COCOA_LIBRARY Cocoa )
 	find_library( METAL_LIBRARY Metal )
 	find_library( QUARTZCORE_LIBRARY QuartzCore )
+	find_library( IOKIT_LIBRARY IOKit )
+	find_library( COREFOUNDATION_LIBRARY CoreFoundation )
 	mark_as_advanced( COCOA_LIBRARY )
 	mark_as_advanced( METAL_LIBRARY )
 	mark_as_advanced( QUARTZCORE_LIBRARY )
-	target_link_libraries( bgfx PUBLIC ${COCOA_LIBRARY} ${METAL_LIBRARY} ${QUARTZCORE_LIBRARY} )
+	mark_as_advanced( IOKIT_LIBRARY )
+	mark_as_advanced( COREFOUNDATION_LIBRARY )
+	target_link_libraries( bgfx PUBLIC ${COCOA_LIBRARY} ${METAL_LIBRARY} ${QUARTZCORE_LIBRARY} ${IOKIT_LIBRARY} ${COREFOUNDATION_LIBRARY} )
 endif()
 
 if( UNIX AND NOT APPLE AND NOT EMSCRIPTEN AND NOT ANDROID )

cmake/bgfxToolUtils.cmake

@@ -0,0 +1,277 @@
+# shaderc_parse(
+#	FILE filename
+#	OUTPUT filename
+#	FRAGMENT|VERTEX|COMPUTE
+#	ANDROID|ASM_JS|IOS|LINUX|NACL|OSX|WINDOWS
+#	[PROFILE profile]
+#	[O 0|1|2|3]
+#	[VARYINGDEF filename]
+#	[BIN2C filename]
+#	[INCLUDES include;include]
+#	[DEFINES include;include]
+#	[DEPENDS]
+#	[PREPROCESS]
+#	[RAW]
+#	[VERBOSE]
+#	[DEBUG]
+#	[DISASM]
+#	[WERROR]
+# )
+function( shaderc_parse ARG_OUT )
+	cmake_parse_arguments( ARG "DEPENDS;ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS;PREPROCESS;RAW;FRAGMENT;VERTEX;COMPUTE;VERBOSE;DEBUG;DISASM;WERROR" "FILE;OUTPUT;VARYINGDEF;BIN2C;PROFILE;O" "INCLUDES;DEFINES" ${ARGN} )
+	set( CLI "" )
+
+	# -f
+	if( ARG_FILE )
+		list( APPEND CLI "-f" "${ARG_FILE}" )
+	endif()
+
+	# -i
+	if( ARG_INCLUDES )
+		foreach( INCLUDE ${ARG_INCLUDES} )
+			list( APPEND CLI "-i" )
+			list( APPEND CLI "${INCLUDE}" )
+		endforeach()
+	endif()
+
+	# -o
+	if( ARG_OUTPUT )
+		list( APPEND CLI "-o" "${ARG_OUTPUT}" )
+	endif()
+
+	# --bin2c
+	if( ARG_BIN2C )
+		list( APPEND CLI "--bin2c" "${ARG_BIN2C}" )
+	endif()
+
+	# --depends
+	if( ARG_DEPENDS )
+		list( APPEND CLI "--depends" )
+	endif()
+
+	# --platform
+	set( PLATFORM "" )
+	set( PLATFORMS "ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS" )
+	foreach( P ${PLATFORMS} )
+		if( ARG_${P} )
+			if( PLATFORM )
+				message( SEND_ERROR "Call to shaderc_parse() cannot have both flags ${PLATFORM} and ${P}." )
+				return()
+			endif()
+			set( PLATFORM "${P}" )
+		endif()
+	endforeach()
+	if( "${PLATFORM}" STREQUAL "" )
+		message( SEND_ERROR "Call to shaderc_parse() must have a platform flag: ${PLATFORMS}" )
+		return()
+	elseif( "${PLATFORM}" STREQUAL "ANDROID" )
+		list( APPEND CLI "--platform" "android" )
+	elseif( "${PLATFORM}" STREQUAL "ASM_JS" )
+		list( APPEND CLI "--platform" "asm.js" )
+	elseif( "${PLATFORM}" STREQUAL "IOS" )
+		list( APPEND CLI "--platform" "ios" )
+	elseif( "${PLATFORM}" STREQUAL "LINUX" )
+		list( APPEND CLI "--platform" "linux" )
+	elseif( "${PLATFORM}" STREQUAL "NACL" )
+		list( APPEND CLI "--platform" "nacl" )
+	elseif( "${PLATFORM}" STREQUAL "OSX" )
+		list( APPEND CLI "--platform" "osx" )
+	elseif( "${PLATFORM}" STREQUAL "WINDOWS" )
+		list( APPEND CLI "--platform" "windows" )
+	endif()
+
+	# --preprocess
+	if( ARG_PREPROCESS )
+		list( APPEND CLI "--preprocess" )
+	endif()
+
+	# --define
+	if( ARG_DEFINES )
+		list( APPEND CLI "--defines" )
+		set( DEFINES "" )
+		foreach( DEFINE ${ARG_DEFINES} )
+			if( NOT "${DEFINES}" STREQUAL "" )
+				set( DEFINES "${DEFINES}\\\\;${DEFINE}" )
+			else()
+				set( DEFINES "${DEFINE}" )
+			endif()
+		endforeach()
+		list( APPEND CLI "${DEFINES}" )
+	endif()
+
+	# --raw
+	if( ARG_RAW )
+		list( APPEND CLI "--raw" )
+	endif()
+
+	# --type
+	set( TYPE "" )
+	set( TYPES "FRAGMENT;VERTEX;COMPUTE" )
+	foreach( T ${TYPES} )
+		if( ARG_${T} )
+			if( TYPE )
+				message( SEND_ERROR "Call to shaderc_parse() cannot have both flags ${TYPE} and ${T}." )
+				return()
+			endif()
+			set( TYPE "${T}" )
+		endif()
+	endforeach()
+	if( "${TYPE}" STREQUAL "" )
+		message( SEND_ERROR "Call to shaderc_parse() must have a type flag: ${TYPES}" )
+		return()
+	elseif( "${TYPE}" STREQUAL "FRAGMENT" )
+		list( APPEND CLI "--type" "fragment" )
+	elseif( "${TYPE}" STREQUAL "VERTEX" )
+		list( APPEND CLI "--type" "vertex" )
+	elseif( "${TYPE}" STREQUAL "COMPUTE" )
+		list( APPEND CLI "--type" "compute" )
+	endif()
+
+	# --varyingdef
+	if( ARG_VARYINGDEF )
+		list( APPEND CLI "--varyingdef" "${ARG_VARYINGDEF}" )
+	endif()
+
+	# --verbose
+	if( ARG_VERBOSE )
+		list( APPEND CLI "--verbose" )
+	endif()
+
+	# --debug
+	if( ARG_DEBUG )
+		list( APPEND CLI "--debug" )
+	endif()
+
+	# --disasm
+	if( ARG_DISASM )
+		list( APPEND CLI "--disasm" )
+	endif()
+
+	# --profile
+	if( ARG_PROFILE )
+		list( APPEND CLI "--profile" "${ARG_PROFILE}" )
+	endif()
+
+	# -O
+	if( ARG_O )
+		list( APPEND CLI "-O" "${ARG_O}" )
+	endif()
+
+	# --Werror
+	if( ARG_WERROR )
+		list( APPEND CLI "--Werror" )
+	endif()
+
+	set( ${ARG_OUT} ${CLI} PARENT_SCOPE )
+endfunction()
+
+function (_get_profile_ext PROFILE PROFILE_EXT)
+  string(REPLACE 300_es essl PROFILE ${PROFILE})
+  string(REPLACE 120 glsl PROFILE ${PROFILE})
+  string(REPLACE spirv spv PROFILE ${PROFILE})
+  string(REPLACE metal mtl PROFILE ${PROFILE})
+  string(REPLACE vs_3_0 dx9 PROFILE ${PROFILE})
+  string(REPLACE vs_4_0 dx10 PROFILE ${PROFILE})
+  string(REPLACE vs_5_0 dx11 PROFILE ${PROFILE})
+  string(REPLACE ps_3_0 dx9 PROFILE ${PROFILE})
+  string(REPLACE ps_4_0 dx10 PROFILE ${PROFILE})
+  string(REPLACE ps_5_0 dx11 PROFILE ${PROFILE})
+  string(REPLACE cs_4_0 dx10 PROFILE ${PROFILE})
+  string(REPLACE cs_5_0 dx11 PROFILE ${PROFILE})
+
+  set(${PROFILE_EXT}
+      ${PROFILE}
+      PARENT_SCOPE
+  )
+endfunction ()
+
+# compile_shader_to_header(
+#   TYPE VERTEX|FRAGMENT|COMPUTE
+#   SHADERS filenames
+#   VARYING_DEF filename
+#   OUTPUT_DIR directory
+#)
+#
+function (compile_shader_to_header)
+  set(options "")
+  set(oneValueArgs TYPE VARYING_DEF OUTPUT_DIR)
+  set(multiValueArgs SHADERS)
+  cmake_parse_arguments(
+    ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}"
+  )
+
+  set(PROFILES 120 300_es spirv) # pssl
+  if (UNIX AND NOT APPLE)
+    set(PLATFORM LINUX)
+  elseif (EMSCRIPTEN)
+    set(PLATFORM ASM_JS)
+  elseif (APPLE)
+    set(PLATFORM OSX)
+    list(APPEND PROFILES metal)
+  elseif (
+    WIN32
+    OR MINGW
+    OR MSYS
+    OR CYGWIN
+  )
+    set(PLATFORM WINDOWS)
+    if (ARGS_TYPE STREQUAL "VERTEX")
+      list(APPEND PROFILES vs_3_0)
+      list(APPEND PROFILES vs_4_0)
+      list(APPEND PROFILES vs_5_0)
+    elseif (ARGS_TYPE STREQUAL "FRAGMENT")
+      list(APPEND PROFILES ps_3_0)
+      list(APPEND PROFILES ps_4_0)
+      list(APPEND PROFILES ps_5_0)
+    elseif (ARGS_TYPE STREQUAL "COMPUTE")
+      list(APPEND PROFILES cs_4_0)
+      list(APPEND PROFILES cs_5_0)
+    else ()
+      message(error "shaderc: Unsupported type")
+    endif ()
+  else ()
+    message(error "shaderc: Unsupported platform")
+  endif ()
+
+  foreach (SHADER_FILE ${ARGS_SHADERS})
+    source_group("Shaders" FILES "${SHADER}")
+    get_filename_component(SHADER_FILE_BASENAME ${SHADER_FILE} NAME)
+    get_filename_component(SHADER_FILE_NAME_WE ${SHADER_FILE} NAME_WE)
+    get_filename_component(SHADER_FILE_ABSOLUTE ${SHADER_FILE} ABSOLUTE)
+
+    # Build output targets and their commands
+    set(OUTPUTS "")
+    set(COMMANDS "")
+    foreach (PROFILE ${PROFILES})
+      _get_profile_ext(${PROFILE} PROFILE_EXT)
+      set(OUTPUT
+          ${ARGS_OUTPUT_DIR}/${SHADER_FILE_BASENAME}.${PROFILE_EXT}.bin.h
+      )
+      set(PLATFORM_I ${PLATFORM})
+      if (PROFILE STREQUAL "spirv")
+        set(PLATFORM_I LINUX)
+      endif ()
+      shaderc_parse(
+        CLI #
+        ${ARGS_TYPE} ${PLATFORM_I} WERROR
+        "$<$<CONFIG:debug>:DEBUG>$<$<CONFIG:relwithdebinfo>:DEBUG>"
+        FILE ${SHADER_FILE_ABSOLUTE}
+        OUTPUT ${OUTPUT}
+        PROFILE ${PROFILE}
+        O "$<$<CONFIG:debug>:0>$<$<CONFIG:release>:3>$<$<CONFIG:relwithdebinfo>:3>$<$<CONFIG:minsizerel>:3>"
+        VARYINGDEF ${ARGS_VARYING_DEF}
+        INCLUDES ${BGFX_SHADER_INCLUDE_PATH}
+        BIN2C BIN2C ${SHADER_FILE_NAME_WE}_${PROFILE_EXT}
+      )
+      list(APPEND OUTPUTS ${OUTPUT})
+      list(APPEND COMMANDS COMMAND bgfx::shaderc ${CLI})
+    endforeach ()
+
+    add_custom_command(
+      OUTPUT ${OUTPUTS}
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${ARGS_OUTPUT_DIR} ${COMMANDS}
+      MAIN_DEPENDENCY ${SHADER_FILE_ABSOLUTE}
+      DEPENDS ${ARGS_VARYING_DEF}
+    )
+  endforeach ()
+endfunction ()

cmake/bimg.cmake

@@ -9,16 +9,15 @@
 # this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 
 # Third party libs
-include( cmake/3rdparty/astc-codec.cmake )
-include( cmake/3rdparty/astc.cmake )
-include( cmake/3rdparty/edtaa3.cmake )
-include( cmake/3rdparty/etc1.cmake )
-include( cmake/3rdparty/etc2.cmake )
-include( cmake/3rdparty/iqa.cmake )
-include( cmake/3rdparty/libsquish.cmake )
-include( cmake/3rdparty/nvtt.cmake )
-include( cmake/3rdparty/pvrtc.cmake )
-include( cmake/3rdparty/tinyexr.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/astc-encoder.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/edtaa3.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/etc1.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/etc2.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/iqa.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/libsquish.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/nvtt.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/pvrtc.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/tinyexr.cmake )
 
 # Ensure the directory exists
 if( NOT IS_DIRECTORY ${BIMG_DIR} )
@@ -39,7 +38,7 @@ target_include_directories( bimg
 		$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
 # bimg dependencies
-target_link_libraries( bimg PUBLIC bx PRIVATE astc-codec astc edtaa3 etc1 etc2 iqa squish nvtt pvrtc tinyexr )
+target_link_libraries( bimg PUBLIC bx PRIVATE astc-encoder edtaa3 etc1 etc2 iqa squish nvtt pvrtc tinyexr )
 
 # Put in a "bgfx" folder in Visual Studio
 set_target_properties( bimg PROPERTIES FOLDER "bgfx" )

cmake/bx.cmake

@@ -30,6 +30,10 @@ endif()
 # Create the bx target
 add_library( bx STATIC ${BX_SOURCES} )
 
+target_compile_features( bx PUBLIC cxx_std_14 )
+# (note: see bx\scripts\toolchain.lua for equivalent compiler flag)
+target_compile_options( bx PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/Zc:__cplusplus> )
+
 # Link against psapi on Windows
 if( WIN32 )
 	target_link_libraries( bx PUBLIC psapi )
@@ -55,11 +59,16 @@ elseif( WIN32 )
 		PUBLIC
 			$<BUILD_INTERFACE:${BX_DIR}/include/compat/msvc>
 			$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/compat/msvc> )
-elseif( APPLE )
+elseif( APPLE )  # APPLE is technically UNIX... ORDERING MATTERS!
 	target_include_directories( bx
 		PUBLIC
-		    $<BUILD_INTERFACE:${BX_DIR}/include/compat/osx>
-		    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/compat/osx> )
+			$<BUILD_INTERFACE:${BX_DIR}/include/compat/osx>
+			$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/compat/osx> )
+elseif ( UNIX )
+	target_include_directories( bx
+		PUBLIC
+			$<BUILD_INTERFACE:${BX_DIR}/include/compat/linux>
+			$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/compat/linux> )
 endif()
 
 # All configurations
@@ -67,23 +76,25 @@ target_compile_definitions( bx PUBLIC "__STDC_LIMIT_MACROS" )
 target_compile_definitions( bx PUBLIC "__STDC_FORMAT_MACROS" )
 target_compile_definitions( bx PUBLIC "__STDC_CONSTANT_MACROS" )
 
-target_compile_definitions( bx PRIVATE "$<$<CONFIG:Debug>:BX_CONFIG_DEBUG=1>" )
-if(BGFX_CONFIG_DEBUG)
-	target_compile_definitions( bx PRIVATE BX_CONFIG_DEBUG=1)
-endif()
+target_compile_definitions(bx PUBLIC "BX_CONFIG_DEBUG=$<IF:$<CONFIG:Debug>,1,$<BOOL:${BX_CONFIG_DEBUG}>>")
 
 # Additional dependencies on Unix
-if( UNIX AND NOT APPLE AND NOT ANDROID )
+if (ANDROID)
+    # For __android_log_write
+    find_library( LOG_LIBRARY log )
+    mark_as_advanced( LOG_LIBRARY )
+	target_link_libraries( bx PUBLIC ${LOG_LIBRARY} )
+elseif( APPLE )
+	find_library( FOUNDATION_LIBRARY Foundation)
+	mark_as_advanced( FOUNDATION_LIBRARY )
+	target_link_libraries( bx PUBLIC ${FOUNDATION_LIBRARY} )
+elseif( UNIX )
 	# Threads
 	find_package( Threads )
 	target_link_libraries( bx ${CMAKE_THREAD_LIBS_INIT} dl )
 
 	# Real time (for clock_gettime)
 	target_link_libraries( bx rt )
-elseif(APPLE)
-	find_library( FOUNDATION_LIBRARY Foundation)
-	mark_as_advanced( FOUNDATION_LIBRARY )
-	target_link_libraries( bx PUBLIC ${FOUNDATION_LIBRARY} )
 endif()
 
 # Put in a "bgfx" folder in Visual Studio

cmake/examples.cmake

@@ -10,10 +10,11 @@
 
 include( CMakeParseArguments )
 
-include( cmake/util/ConfigureDebugging.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/util/ConfigureDebugging.cmake )
 
-include( cmake/3rdparty/dear-imgui.cmake )
-include( cmake/3rdparty/meshoptimizer.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/dear-imgui.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/meshoptimizer.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/bgfxToolUtils.cmake )
 
 function( add_bgfx_shader FILE FOLDER )
 	get_filename_component( FILENAME "${FILE}" NAME_WE )
@@ -171,7 +172,7 @@ function( add_example ARG_NAME )
 	target_compile_definitions( example-${ARG_NAME} PRIVATE "-D_CRT_SECURE_NO_WARNINGS" "-D__STDC_FORMAT_MACROS" "-DENTRY_CONFIG_IMPLEMENT_MAIN=1" )
 
 	# Configure shaders
-	if( NOT ARG_COMMON AND NOT IOS AND NOT EMSCRIPTEN)
+	if( NOT ARG_COMMON AND NOT IOS AND NOT EMSCRIPTEN AND NOT ANDROID)
 		foreach( SHADER ${SHADERS} )
 			add_bgfx_shader( ${SHADER} ${ARG_NAME} )
 		endforeach()
@@ -179,10 +180,12 @@ function( add_example ARG_NAME )
 	endif()
 
 	if (NOT ARG_COMMON AND EMSCRIPTEN)
-		target_link_libraries(example-${ARG_NAME}
-			"-s PRECISE_F32=1"
-			"-s TOTAL_MEMORY=268435456"
-			"--memory-init-file 1")
+		set_target_properties(example-${ARG_NAME}
+			PROPERTIES
+				LINK_FLAGS
+					"-s PRECISE_F32=1 -s TOTAL_MEMORY=268435456 -s ENVIRONMENT=web --memory-init-file 1 --emrun"
+				SUFFIX ".html"
+		)
 	endif()
 
 	# Directory name
@@ -274,6 +277,8 @@ if( BGFX_BUILD_EXAMPLES )
 		43-denoise
 		44-sss
 		45-bokeh
+		46-fsr
+		47-pixelformats
 	)
 
 	foreach( EXAMPLE ${BGFX_EXAMPLES} )

cmake/shared.cmake

@@ -21,13 +21,6 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/generated/shader.cpp.in
 target_sources( bgfx-shader INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/generated/shader.cpp )
 target_include_directories( bgfx-shader INTERFACE ${BGFX_DIR}/include )
 
-add_library( bgfx-bounds INTERFACE )
-configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/generated/bounds.cpp.in
-                ${CMAKE_CURRENT_BINARY_DIR}/generated/bounds.cpp )
-target_sources( bgfx-bounds INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/generated/bounds.cpp )
-target_include_directories( bgfx-bounds INTERFACE ${BGFX_DIR}/include )
-target_include_directories( bgfx-bounds INTERFACE ${BGFX_DIR}/examples/common )
-
 # Frameworks required on OS X
 if( ${CMAKE_SYSTEM_NAME} MATCHES Darwin )
 	find_library( COCOA_LIBRARY Cocoa )

cmake/tools.cmake

@@ -13,8 +13,16 @@ if( BGFX_CUSTOM_TARGETS )
 	set_target_properties( tools PROPERTIES FOLDER "bgfx/tools" )
 endif()
 
-include( cmake/tools/geometryc.cmake )
-include( cmake/tools/geometryv.cmake )
-include( cmake/tools/shaderc.cmake )
-include( cmake/tools/texturec.cmake )
-include( cmake/tools/texturev.cmake )
+if( BGFX_BUILD_TOOLS_SHADER )
+	include( ${CMAKE_CURRENT_LIST_DIR}/tools/shaderc.cmake )
+endif()
+
+if( BGFX_BUILD_TOOLS_GEOMETRY )
+	include( ${CMAKE_CURRENT_LIST_DIR}/tools/geometryc.cmake )
+	include( ${CMAKE_CURRENT_LIST_DIR}/tools/geometryv.cmake )
+endif()
+
+if( BGFX_BUILD_TOOLS_TEXTURE )
+	include( ${CMAKE_CURRENT_LIST_DIR}/tools/texturec.cmake )
+	include( ${CMAKE_CURRENT_LIST_DIR}/tools/texturev.cmake )
+endif()

cmake/tools/geometryc.cmake

@@ -10,12 +10,12 @@
 
 include( CMakeParseArguments )
 
-include( cmake/3rdparty/meshoptimizer.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/meshoptimizer.cmake )
 
 add_executable( geometryc ${BGFX_DIR}/tools/geometryc/geometryc.cpp )
 target_compile_definitions( geometryc PRIVATE "-D_CRT_SECURE_NO_WARNINGS" )
 set_target_properties( geometryc PROPERTIES FOLDER "bgfx/tools" )
-target_link_libraries( geometryc bx bgfx-bounds bgfx-vertexlayout meshoptimizer )
+target_link_libraries( geometryc bx bgfx-vertexlayout meshoptimizer )
 if( BGFX_CUSTOM_TARGETS )
 	add_dependencies( tools geometryc )
 endif()

cmake/tools/geometryv.cmake

@@ -11,6 +11,9 @@
 add_executable( geometryv ${BGFX_DIR}/tools/geometryv/geometryv.cpp )
 set_target_properties( geometryv PROPERTIES FOLDER "bgfx/tools" )
 target_link_libraries( geometryv example-common )
+if(EMSCRIPTEN)
+	target_link_options( geometryv PRIVATE -sMAX_WEBGL_VERSION=2 )
+endif()
 if( BGFX_CUSTOM_TARGETS )
 	add_dependencies( tools geometryv )
 endif()

cmake/tools/shaderc.cmake

@@ -10,12 +10,12 @@
 
 include( CMakeParseArguments )
 
-include( cmake/3rdparty/fcpp.cmake )
-include( cmake/3rdparty/glsl-optimizer.cmake )
-include( cmake/3rdparty/glslang.cmake )
-include( cmake/3rdparty/spirv-cross.cmake )
-include( cmake/3rdparty/spirv-tools.cmake )
-include( cmake/3rdparty/webgpu.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/fcpp.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/glsl-optimizer.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/glslang.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/spirv-cross.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/spirv-tools.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/webgpu.cmake )
 
 add_executable( shaderc ${BGFX_DIR}/tools/shaderc/shaderc.cpp ${BGFX_DIR}/tools/shaderc/shaderc.h ${BGFX_DIR}/tools/shaderc/shaderc_glsl.cpp ${BGFX_DIR}/tools/shaderc/shaderc_hlsl.cpp ${BGFX_DIR}/tools/shaderc/shaderc_pssl.cpp ${BGFX_DIR}/tools/shaderc/shaderc_spirv.cpp ${BGFX_DIR}/tools/shaderc/shaderc_metal.cpp )
 target_compile_definitions( shaderc PRIVATE "-D_CRT_SECURE_NO_WARNINGS" )
@@ -32,338 +32,3 @@ elseif (IOS)
 	set_target_properties(shaderc PROPERTIES MACOSX_BUNDLE ON
 											 MACOSX_BUNDLE_GUI_IDENTIFIER shaderc)
 endif()
-
-function( add_shader ARG_FILE )
-	# Parse arguments
-	cmake_parse_arguments( ARG "FRAGMENT;VERTEX;COMPUTE" "OUTPUT;GLSL_VERSION;DX9_MODEL;DX11_MODEL" "PLATFORMS" ${ARGN} )
-
-	# Get filename
-	get_filename_component( FILENAME "${ARG_FILE}" NAME_WE )
-
-	# Determine if fragment or vertex or compute
-	if( ARG_FRAGMENT AND ARG_VERTEX AND ARG_COMPUTE )
-		message( SEND_ERROR "add_shader cannot be called with all FRAGMENT and VERTEX and COMPUTE." )
-		return()
-	elseif( ARG_FRAGMENT AND ARG_VERTEX )
-		message( SEND_ERROR "add_shader cannot be called with both FRAGMENT and VERTEX." )
-		return()
-	elseif( ARG_FRAGMENT AND ARG_COMPUTE )
-		message( SEND_ERROR "add_shader cannot be called with both FRAGMENT and COMPUTE." )
-		return()
-	elseif( ARG_VERTEX AND ARG_COMPUTE )
-		message( SEND_ERROR "add_shader cannot be called with both VERTEX and COMPUTE." )
-		return()
-	endif()
-
-	if( ARG_FRAGMENT )
-		set( TYPE "FRAGMENT" )
-		set( D3D_PREFIX "ps" )
-	elseif( ARG_VERTEX )
-		set( TYPE "VERTEX" )
-		set( D3D_PREFIX "vs" )
-	elseif( ARG_COMPUTE )
-		set( TYPE "COMPUTE" )
-		set( D3D_PREFIX "cs" )
-	else()
-		message( SEND_ERROR "add_shader must be called with either FRAGMENT or VERTEX or COMPUTE." )
- 		return()
-	endif()
-
-	# Determine compatible platforms
-	if( ARG_PLATFORMS )
-		set( PLATFORMS ${ARG_PLATFORMS} )
-	else()
-		if( MSVC )
-			set( PLATFORMS dx9 dx11 glsl essl asm.js spirv )
-		elseif( APPLE )
-			set( PLATFORMS metal glsl essl asm.js spirv )
-		else()
-			set( PLATFORMS glsl essl asm.js spirv )
-		endif()
-	endif()
-
-	# Build options
-	set( BASE_OPTIONS
-		FILE ${ARG_FILE}
-		${TYPE}
-		INCLUDES ${BGFX_DIR}/src
-	)
-
-	# Parse profiles
-	set( DX9_PROFILE PROFILE ${D3D_PREFIX}_3_0 )
-	if( ARG_DX9_MODEL )
-		set( DX9_PROFILE PROFILE ${D3D_PREFIX}_${ARG_DX9_MODEL} )
-	endif()
-	set( DX11_PROFILE PROFILE ${D3D_PREFIX}_5_0 )
-	if( ARG_DX11_MODEL )
-		set( DX11_PROFILE PROFILE ${D3D_PREFIX}_${ARG_DX11_MODEL} )
-	endif()
-	set( GLSL_PROFILE PROFILE 120 )
-	if( ARG_COMPUTE )
-		set( GLSL_PROFILE PROFILE 430 )
-	endif()
-	if( ARG_GLSL_VERSION )
-		set( GLSL_PROFILE PROFILE ${ARG_GLSL_VERSION} )
-	endif()
-	set( SPIRV_PROFILE PROFILE spirv )
-
-	# Add commands
-	set( OUTPUTS "" )
-	set( COMMANDS "" )
-	foreach( PLATFORM ${PLATFORMS} )
-		set( OPTIONS ${BASE_OPTIONS} )
-		set( OUTPUT "${ARG_OUTPUT}/${PLATFORM}/${FILENAME}.bin" )
-		get_filename_component( OUTPUT "${OUTPUT}" ABSOLUTE )
-
-		if( "${PLATFORM}" STREQUAL "dx9" )
-			list( APPEND OPTIONS
-				WINDOWS
-				${DX9_PROFILE}
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "dx11" )
-			list( APPEND OPTIONS
-				WINDOWS
-				${DX11_PROFILE}
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "metal" )
-			list( APPEND OPTIONS
-				OSX
-				PROFILE metal
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "glsl" )
-			list( APPEND OPTIONS
-				LINUX
-				${GLSL_PROFILE}
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "essl" )
-			list( APPEND OPTIONS
-				ANDROID
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "asm.js" )
-			list( APPEND OPTIONS
-				ASM_JS
-				OUTPUT ${OUTPUT}
-			)
-		elseif( "${PLATFORM}" STREQUAL "spirv" )
-			list( APPEND OPTIONS
-				LINUX
-				${SPIRV_PROFILE}
-				OUTPUT ${OUTPUT}
-			)
-		else()
-			message( SEND_ERROR "add_shader given bad platform: ${PLATFORM}" )
-			return()
-		endif()
-
-		list( APPEND OUTPUTS ${OUTPUT} )
-		shaderc_parse( CMD ${OPTIONS} )
-		list( APPEND COMMANDS COMMAND "${CMAKE_COMMAND}" -E make_directory "${ARG_OUTPUT}/${PLATFORM}" )
-		list( APPEND COMMANDS COMMAND "$<TARGET_FILE:shaderc>" ${CMD} )
-	endforeach()
-
-	# Add command
-	add_custom_command(
-		MAIN_DEPENDENCY
-		${ARG_FILE}
-		OUTPUT
-		${OUTPUTS}
-		${COMMANDS}
-		COMMENT "Compiling shader ${ARG_FILE}"
-		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-	)
-
-	# Add to custom filter
-	source_group( "Shader Files" FILES ${ARG_FILE} )
-endfunction()
-
-# shaderc( FILE file OUTPUT file ... )
-# See shaderc_parse() below for inputs
-function( shaderc )
-	cmake_parse_arguments( ARG "" "FILE;OUTPUT;LABEL" "" ${ARGN} )
-	set( LABEL "" )
-	if( ARG_LABEL )
-		set( LABEL " (${ARG_LABEL})" )
-	endif()
-	shaderc_parse( CLI FILE ${ARG_FILE} OUTPUT ${ARG_OUTPUT} ${ARG_UNPARSED_ARGUMENTS} )
-	get_filename_component( OUTDIR "${ARG_OUTPUT}" ABSOLUTE )
-	get_filename_component( OUTDIR "${OUTDIR}" DIRECTORY )
-	add_custom_command( OUTPUT ${ARG_OUTPUT}
-		COMMAND ${CMAKE_COMMAND} -E make_directory "${OUTDIR}"
-		COMMAND "$<TARGET_FILE:shaderc>" ${CLI}
-		MAIN_DEPENDENCY ${ARG_FILE}
-		COMMENT "Compiling shader ${ARG_FILE}${LABEL}"
-		WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-	)
-endfunction()
-
-# shaderc_parse(
-#	FILE filename
-#	OUTPUT filename
-#	FRAGMENT|VERTEX|COMPUTE
-#	ANDROID|ASM_JS|IOS|LINUX|NACL|OSX|WINDOWS
-#	[PROFILE profile]
-#	[O 0|1|2|3]
-#	[VARYINGDEF filename]
-#	[BIN2C filename]
-#	[INCLUDES include;include]
-#	[DEFINES include;include]
-#	[DEPENDS]
-#	[PREPROCESS]
-#	[RAW]
-#	[VERBOSE]
-#	[DEBUG]
-#	[DISASM]
-#	[WERROR]
-# )
-function( shaderc_parse ARG_OUT )
-	cmake_parse_arguments( ARG "DEPENDS;ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS;PREPROCESS;RAW;FRAGMENT;VERTEX;COMPUTE;VERBOSE;DEBUG;DISASM;WERROR" "FILE;OUTPUT;VARYINGDEF;BIN2C;PROFILE;O" "INCLUDES;DEFINES" ${ARGN} )
-	set( CLI "" )
-
-	# -f
-	if( ARG_FILE )
-		list( APPEND CLI "-f" "${ARG_FILE}" )
-	endif()
-
-	# -i
-	if( ARG_INCLUDES )
-		foreach( INCLUDE ${ARG_INCLUDES} )
-			list( APPEND CLI "-i" )
-			list( APPEND CLI "${INCLUDE}" )			
-		endforeach()
-	endif()
-
-	# -o
-	if( ARG_OUTPUT )
-		list( APPEND CLI "-o" "${ARG_OUTPUT}" )
-	endif()
-
-	# --bin2c
-	if( ARG_BIN2C )
-		list( APPEND CLI "--bin2c" "${ARG_BIN2C}" )
-	endif()
-
-	# --depends
-	if( ARG_DEPENDS )
-		list( APPEND CLI "--depends" )
-	endif()
-
-	# --platform
-	set( PLATFORM "" )
-	set( PLATFORMS "ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS" )
-	foreach( P ${PLATFORMS} )
-		if( ARG_${P} )
-			if( PLATFORM )
-				message( SEND_ERROR "Call to shaderc_parse() cannot have both flags ${PLATFORM} and ${P}." )
-				return()
-			endif()
-			set( PLATFORM "${P}" )
-		endif()
-	endforeach()
-	if( "${PLATFORM}" STREQUAL "" )
-		message( SEND_ERROR "Call to shaderc_parse() must have a platform flag: ${PLATFORMS}" )
-		return()
-	elseif( "${PLATFORM}" STREQUAL "ANDROID" )
-		list( APPEND CLI "--platform" "android" )
-	elseif( "${PLATFORM}" STREQUAL "ASM_JS" )
-		list( APPEND CLI "--platform" "asm.js" )
-	elseif( "${PLATFORM}" STREQUAL "IOS" )
-		list( APPEND CLI "--platform" "ios" )
-	elseif( "${PLATFORM}" STREQUAL "LINUX" )
-		list( APPEND CLI "--platform" "linux" )
-	elseif( "${PLATFORM}" STREQUAL "NACL" )
-		list( APPEND CLI "--platform" "nacl" )
-	elseif( "${PLATFORM}" STREQUAL "OSX" )
-		list( APPEND CLI "--platform" "osx" )
-	elseif( "${PLATFORM}" STREQUAL "WINDOWS" )
-		list( APPEND CLI "--platform" "windows" )
-	endif()
-
-	# --preprocess
-	if( ARG_PREPROCESS )
-		list( APPEND CLI "--preprocess" )
-	endif()
-
-	# --define
-	if( ARG_DEFINES )
-		list( APPEND CLI "--defines" )
-		set( DEFINES "" )
-		foreach( DEFINE ${ARG_DEFINES} )
-			if( NOT "${DEFINES}" STREQUAL "" )
-				set( DEFINES "${DEFINES}\\\\;${DEFINE}" )
-			else()
-				set( DEFINES "${DEFINE}" )
-			endif()
-		endforeach()
-		list( APPEND CLI "${DEFINES}" )
-	endif()
-
-	# --raw
-	if( ARG_RAW )
-		list( APPEND CLI "--raw" )
-	endif()
-
-	# --type
-	set( TYPE "" )
-	set( TYPES "FRAGMENT;VERTEX;COMPUTE" )
-	foreach( T ${TYPES} )
-		if( ARG_${T} )
-			if( TYPE )
-				message( SEND_ERROR "Call to shaderc_parse() cannot have both flags ${TYPE} and ${T}." )
-				return()
-			endif()
-			set( TYPE "${T}" )
-		endif()
-	endforeach()
-	if( "${TYPE}" STREQUAL "" )
-		message( SEND_ERROR "Call to shaderc_parse() must have a type flag: ${TYPES}" )
-		return()
-	elseif( "${TYPE}" STREQUAL "FRAGMENT" )
-		list( APPEND CLI "--type" "fragment" )
-	elseif( "${TYPE}" STREQUAL "VERTEX" )
-		list( APPEND CLI "--type" "vertex" )
-	elseif( "${TYPE}" STREQUAL "COMPUTE" )
-		list( APPEND CLI "--type" "compute" )
-	endif()
-
-	# --varyingdef
-	if( ARG_VARYINGDEF )
-		list( APPEND CLI "--varyingdef" "${ARG_VARYINGDEF}" )
-	endif()
-
-	# --verbose
-	if( ARG_VERBOSE )
-		list( APPEND CLI "--verbose" )
-	endif()
-
-	# --debug
-	if( ARG_DEBUG )
-		list( APPEND CLI "--debug" )
-	endif()
-
-	# --disasm
-	if( ARG_DISASM )
-		list( APPEND CLI "--disasm" )
-	endif()
-
-	# --profile
-	if( ARG_PROFILE )
-		list( APPEND CLI "--profile" "${ARG_PROFILE}" )
-	endif()
-
-	# -O
-	if( ARG_O )
-		list( APPEND CLI "-O" "${ARG_O}" )
-	endif()
-
-	# --Werror
-	if( ARG_WERROR )
-		list( APPEND CLI "--Werror" )
-	endif()
-
-	set( ${ARG_OUT} ${CLI} PARENT_SCOPE )
-endfunction()

cmake/tools/texturev.cmake

@@ -13,6 +13,9 @@ include( CMakeParseArguments )
 add_executable( texturev ${BGFX_DIR}/tools/texturev/texturev.cpp )
 set_target_properties( texturev PROPERTIES FOLDER "bgfx/tools" )
 target_link_libraries( texturev example-common )
+if (EMSCRIPTEN)
+	target_link_options( texturev PRIVATE -sMAX_WEBGL_VERSION=2 )
+endif()
 if( BGFX_CUSTOM_TARGETS )
 	add_dependencies( tools texturev )
 endif()
@@ -20,4 +23,4 @@ endif()
 if (IOS)
 	set_target_properties(texturev PROPERTIES MACOSX_BUNDLE ON
 										      MACOSX_BUNDLE_GUI_IDENTIFIER texturev)
-endif()
+endif()