Merge pull request #151 from SamHellawell/master

Allow to specify which tools to compile

.github/dependabot.yml

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

CMakeLists.txt

@@ -21,14 +21,23 @@ 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_RENDERER_WEBGPU     "Enables the webgpu renderer"         OFF )
+if (MSVC AND (MSVC_VERSION GREATER_EQUAL 1914))
+    add_compile_options("/Zc:__cplusplus")
+endif()
+
+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_AMALGAMATED                "Amalgamated bgfx build for faster compilation" OFF )
+option( BX_AMALGAMATED                  "Amalgamated bx build for faster compilation"   OFF )
+option( BGFX_CONFIG_MULTITHREADED       "Build bgfx with multithreaded configuration"   ON )
+option( BGFX_CONFIG_RENDERER_WEBGPU     "Enables the webgpu renderer"                   OFF )
+option( BX_CONFIG_DEBUG                 "Log debug messages (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" )
@@ -57,19 +66,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 )
@@ -110,7 +119,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}"
 	)
@@ -154,6 +163,8 @@ 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}"

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

@@ -47,7 +47,7 @@ else()
 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")
@@ -56,6 +56,10 @@ if(BGFX_CONFIG_RENDERER_WEBGPU)
     endif()
 endif()
 
+if(EMSCRIPTEN)
+	target_link_options(bgfx PUBLIC "-sMAX_WEBGL_VERSION=2")
+endif()
+
 if( NOT ${BGFX_OPENGL_VERSION} STREQUAL "" )
 	target_compile_definitions( bgfx PRIVATE BGFX_CONFIG_RENDERER_OPENGL_MIN_VERSION=${BGFX_OPENGL_VERSION} )
 endif()
@@ -70,12 +74,11 @@ if( MSVC )
 endif()
 
 # Add debug config required in bx headers since bx is private
-if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-    target_compile_definitions( bgfx PUBLIC "BX_CONFIG_DEBUG=1" )
-else()
-    target_compile_definitions( bgfx PUBLIC "BX_CONFIG_DEBUG=0" )
-endif()
-
+target_compile_definitions(bgfx
+       PUBLIC
+               "BX_CONFIG_DEBUG=$<IF:$<CONFIG:Debug>,1,$<BOOL:${BX_CONFIG_DEBUG}>>"
+               "BGFX_CONFIG_MULTITHREADED=$<BOOL:${BGFX_CONFIG_MULTITHREADED}>"
+)
 
 # Includes
 target_include_directories( bgfx
@@ -92,15 +95,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,16 @@
 # 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-codec.cmake )
+include( ${CMAKE_CURRENT_LIST_DIR}/3rdparty/astc.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} )

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 )
@@ -67,24 +71,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" )
 
-if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-	target_compile_definitions( bx PUBLIC "BX_CONFIG_DEBUG=1" )
-else()
-	target_compile_definitions( bx PUBLIC "BX_CONFIG_DEBUG=0" )
-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
@@ -275,6 +278,7 @@ if( BGFX_BUILD_EXAMPLES )
 		44-sss
 		45-bokeh
 		46-fsr
+		47-pixelformats
 	)
 
 	foreach( EXAMPLE ${BGFX_EXAMPLES} )

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,7 +10,7 @@
 
 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" )

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()