mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-03-14 06:34:10 +00:00
SDL2/Vulkan on Linux, still broken for Doom3BFG
This commit is contained in:
Eric Womer
parent
8938733050
commit
e9ef21ce5c
13 changed files with 842 additions and 102 deletions
|
|
@ -1,4 +1,4 @@
|
|||
cmake_minimum_required(VERSION 2.8)
|
||||
cmake_minimum_required(VERSION 2.8) # Eric: These are rookie numbers, you need to bump those numbers up.
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
|
||||
|
||||
project(RBDoom3BFG)
|
||||
|
|
@ -86,6 +86,13 @@ if (FORCE_COLOR_OUTPUT)
|
|||
endif ()
|
||||
endif ()
|
||||
|
||||
# Eric: Hard dependency on SDL2 for the Vulkan renderer on Linux
|
||||
if(UNIX)
|
||||
if(USE_VULKAN)
|
||||
SET(SDL2 ON)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(MSVC)
|
||||
#message(STATUS CMAKE_ROOT: ${CMAKE_ROOT})
|
||||
|
||||
|
|
@ -318,8 +325,7 @@ if(USE_VULKAN)
|
|||
message( STATUS "Using module to find Vulkan" )
|
||||
find_package(Vulkan)
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
if(NOT Vulkan_FOUND)
|
||||
message(FATAL_ERROR "Could not find Vulkan library!")
|
||||
else()
|
||||
|
|
@ -329,15 +335,16 @@ if(USE_VULKAN)
|
|||
add_definitions(-DUSE_VULKAN)
|
||||
include_directories($ENV{VULKAN_SDK}/Include)
|
||||
|
||||
find_package(XCB)
|
||||
if(NOT XCB_FOUND)
|
||||
message(FATAL_ERROR "Could not find XCB library!")
|
||||
else()
|
||||
message(STATUS ${XCB_LIBRARIES})
|
||||
# Eric: For use with SDL2/Vulkan
|
||||
if(UNIX)
|
||||
find_package(X11_XCB)
|
||||
if(X11_XCB_FOUND)
|
||||
add_definitions(-DHAVE_X11_XCB)
|
||||
list(APPEND SUBSYSTEMS [X11])
|
||||
include_directories(${X11_XCB_INCLUDE_DIRS})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
include_directories(${XCB_INCLUDE_DIRS})
|
||||
|
||||
if(SPIRV_SHADERC)
|
||||
add_definitions(-DSPIRV_SHADERC)
|
||||
|
||||
|
|
@ -548,7 +555,6 @@ file(GLOB MINIZIP_INCLUDES libs/zlib/minizip/*.h)
|
|||
file(GLOB MINIZIP_SOURCES libs/zlib/minizip/*.c libs/zlib/minizip/*.cpp)
|
||||
|
||||
|
||||
|
||||
set(FREETYPE_SOURCES
|
||||
libs/freetype/src/autofit/autofit.c
|
||||
libs/freetype/src/bdf/bdf.c
|
||||
|
|
@ -1004,6 +1010,16 @@ file(GLOB COMMON_SOURCES sys/common/*.cpp)
|
|||
file(GLOB SDL_INCLUDES sys/sdl/*.h)
|
||||
file(GLOB SDL_SOURCES sys/sdl/*.cpp)
|
||||
|
||||
# Eric: Utilize either the Vulkan or GL implementation of SDL
|
||||
if(UNIX)
|
||||
if(USE_VULKAN)
|
||||
get_filename_component(sdl_glimp_cpp_full_path ${CMAKE_CURRENT_SOURCE_DIR}/sys/sdl/sdl_glimp.cpp ABSOLUTE)
|
||||
list(REMOVE_ITEM SDL_SOURCES "${sdl_glimp_cpp_full_path}")
|
||||
else()
|
||||
get_filename_component(sdl_vkimp_cpp_full_path ${CMAKE_CURRENT_SOURCE_DIR}/sys/sdl/sdl_vkimp.cpp ABSOLUTE)
|
||||
list(REMOVE_ITEM SDL_SOURCES "${sdl_vkimp_cpp_full_path}")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
source_group("aas" FILES ${AAS_INCLUDES})
|
||||
source_group("aas" FILES ${AAS_SOURCES})
|
||||
|
|
@ -1627,11 +1643,11 @@ else()
|
|||
|
||||
set(Vulkan_LIBRARIES
|
||||
${Vulkan_LIBRARY}
|
||||
${XCB_LIBRARIES}
|
||||
${X11_XCB_LIBRARIES}
|
||||
glslang
|
||||
SPIRV
|
||||
)
|
||||
|
||||
|
||||
if(ENABLE_GLSLANG_BINARIES)
|
||||
list(APPEND Vulkan_LIBRARIES glslang-default-resource-limits)
|
||||
endif()
|
||||
|
|
@ -1710,7 +1726,7 @@ else()
|
|||
# make sure this is run after creating idlib
|
||||
add_dependencies(precomp_header_rbdoom3bfg idlib)
|
||||
endif()
|
||||
|
||||
|
||||
add_executable(RBDoom3BFG WIN32 ${RBDOOM3_SOURCES})
|
||||
|
||||
if (USE_PRECOMPILED_HEADERS)
|
||||
|
|
@ -1739,7 +1755,7 @@ else()
|
|||
${PNG_LIBRARY}
|
||||
${JPEG_LIBRARY}
|
||||
${GLEW_LIBRARY}
|
||||
${CMAKE_DL_LIBS}
|
||||
${CMAKE_DL_LIBS}
|
||||
)
|
||||
endif()
|
||||
|
||||
|
|
|
|||
32
neo/cmake/FindX11_XCB.cmake
Normal file
32
neo/cmake/FindX11_XCB.cmake
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
# - Try to find libX11-xcb
|
||||
# Once done this will define
|
||||
#
|
||||
# X11_XCB_FOUND - system has libX11-xcb
|
||||
# X11_XCB_LIBRARIES - Link these to use libX11-xcb
|
||||
# X11_XCB_INCLUDE_DIR - the libX11-xcb include dir
|
||||
# X11_XCB_DEFINITIONS - compiler switches required for using libX11-xcb
|
||||
|
||||
# Copyright (c) 2011 Fredrik Höglund <fredrik@kde.org>
|
||||
# Copyright (c) 2008 Helio Chissini de Castro, <helio@kde.org>
|
||||
# Copyright (c) 2007 Matthias Kretz, <kretz@kde.org>
|
||||
#
|
||||
# Redistribution and use is allowed according to the terms of the BSD license.
|
||||
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
|
||||
|
||||
IF (NOT WIN32)
|
||||
# use pkg-config to get the directories and then use these values
|
||||
# in the FIND_PATH() and FIND_LIBRARY() calls
|
||||
FIND_PACKAGE(PkgConfig)
|
||||
PKG_CHECK_MODULES(PKG_X11_XCB QUIET x11-xcb)
|
||||
|
||||
SET(X11_XCB_DEFINITIONS ${PKG_X11_XCB_CFLAGS})
|
||||
|
||||
FIND_PATH(X11_XCB_INCLUDE_DIR NAMES X11/Xlib-xcb.h HINTS ${PKG_X11_XCB_INCLUDE_DIRS})
|
||||
FIND_LIBRARY(X11_XCB_LIBRARIES NAMES X11-xcb HINTS ${PKG_X11_XCB_LIBRARY_DIRS})
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(X11_XCB DEFAULT_MSG X11_XCB_LIBRARIES X11_XCB_INCLUDE_DIR)
|
||||
|
||||
MARK_AS_ADVANCED(X11_XCB_INCLUDE_DIR X11_XCB_LIBRARIES)
|
||||
ENDIF (NOT WIN32)
|
||||
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
# - FindXCB
|
||||
#
|
||||
# Copyright 2015 Valve Coporation
|
||||
|
||||
find_package(PkgConfig)
|
||||
|
||||
if(NOT XCB_FIND_COMPONENTS)
|
||||
set(XCB_FIND_COMPONENTS xcb)
|
||||
endif()
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
set(XCB_FOUND true)
|
||||
set(XCB_INCLUDE_DIRS "")
|
||||
set(XCB_LIBRARIES "")
|
||||
foreach(comp ${XCB_FIND_COMPONENTS})
|
||||
# component name
|
||||
string(TOUPPER ${comp} compname)
|
||||
string(REPLACE "-" "_" compname ${compname})
|
||||
# header name
|
||||
string(REPLACE "xcb-" "" headername xcb/${comp}.h)
|
||||
# library name
|
||||
set(libname ${comp})
|
||||
|
||||
pkg_check_modules(PC_${comp} QUIET ${comp})
|
||||
|
||||
find_path(${compname}_INCLUDE_DIR NAMES ${headername}
|
||||
HINTS
|
||||
${PC_${comp}_INCLUDEDIR}
|
||||
${PC_${comp}_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
find_library(${compname}_LIBRARY NAMES ${libname}
|
||||
HINTS
|
||||
${PC_${comp}_LIBDIR}
|
||||
${PC_${comp}_LIBRARY_DIRS}
|
||||
)
|
||||
|
||||
find_package_handle_standard_args(${comp}
|
||||
FOUND_VAR ${comp}_FOUND
|
||||
REQUIRED_VARS ${compname}_INCLUDE_DIR ${compname}_LIBRARY)
|
||||
mark_as_advanced(${compname}_INCLUDE_DIR ${compname}_LIBRARY)
|
||||
|
||||
list(APPEND XCB_INCLUDE_DIRS ${${compname}_INCLUDE_DIR})
|
||||
list(APPEND XCB_LIBRARIES ${${compname}_LIBRARY})
|
||||
|
||||
if(NOT ${comp}_FOUND)
|
||||
set(XCB_FOUND false)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
list(REMOVE_DUPLICATES XCB_INCLUDE_DIRS)
|
||||
|
|
@ -131,6 +131,8 @@ void RB_SetVertexColorParms( stageVertexColor_t svc );
|
|||
//bool CreateGameWindow( gfxImpParms_t parms );
|
||||
|
||||
#if defined( USE_VULKAN )
|
||||
#include <SDL.h>
|
||||
#include <SDL_vulkan.h>
|
||||
|
||||
struct gpuInfo_t
|
||||
{
|
||||
|
|
@ -146,6 +148,10 @@ struct gpuInfo_t
|
|||
|
||||
struct vulkanContext_t
|
||||
{
|
||||
// Eric: If on linux, use this to pass SDL_Window pointer to the SDL_Vulkan_* methods not in sdl_vkimp.cpp file.
|
||||
#if defined(__linux__)
|
||||
SDL_Window* vkwindow = nullptr;
|
||||
#endif
|
||||
uint64 frameCounter;
|
||||
uint32 frameParity;
|
||||
|
||||
|
|
|
|||
|
|
@ -1187,6 +1187,42 @@ struct glimpParms_t
|
|||
int multiSamples;
|
||||
};
|
||||
|
||||
// Eric: If on Linux using Vulkan use the sdl_vkimp.cpp methods
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
#include <vector>
|
||||
|
||||
#define CLAMP(x, lo, hi) ((x) < (lo) ? (lo) : (x) > (hi) ? (hi) : (x))
|
||||
// Helper function for using SDL2 and Vulkan on Linux.
|
||||
std::vector<const char*> get_required_extensions(const std::vector<const char*>& instanceExtensions, bool enableValidationLayers);
|
||||
|
||||
const std::vector<const char*> sdlInstanceExtensions = {};
|
||||
|
||||
extern vulkanContext_t vkcontext;
|
||||
|
||||
// DG: R_GetModeListForDisplay is called before GLimp_Init(), but SDL needs SDL_Init() first.
|
||||
// So add PreInit for platforms that need it, others can just stub it.
|
||||
void VKimp_PreInit();
|
||||
|
||||
// If the desired mode can't be set satisfactorily, false will be returned.
|
||||
// If succesful, sets glConfig.nativeScreenWidth, glConfig.nativeScreenHeight, and glConfig.pixelAspect
|
||||
// The renderer will then reset the glimpParms to "safe mode" of 640x480
|
||||
// fullscreen and try again. If that also fails, the error will be fatal.
|
||||
bool VKimp_Init( glimpParms_t parms );
|
||||
|
||||
// will set up gl up with the new parms
|
||||
bool VKimp_SetScreenParms( glimpParms_t parms );
|
||||
|
||||
// Destroys the rendering context, closes the window, resets the resolution,
|
||||
// and resets the gamma ramps.
|
||||
void VKimp_Shutdown();
|
||||
|
||||
// Sets the hardware gamma ramps for gamma and brightness adjustment.
|
||||
// These are now taken as 16 bit values, so we can take full advantage
|
||||
// of dacs with >8 bits of precision
|
||||
void VKimp_SetGamma( unsigned short red[256],
|
||||
unsigned short green[256],
|
||||
unsigned short blue[256] );
|
||||
#else
|
||||
// DG: R_GetModeListForDisplay is called before GLimp_Init(), but SDL needs SDL_Init() first.
|
||||
// So add PreInit for platforms that need it, others can just stub it.
|
||||
void GLimp_PreInit();
|
||||
|
|
@ -1211,7 +1247,7 @@ void GLimp_SetGamma( unsigned short red[256],
|
|||
unsigned short green[256],
|
||||
unsigned short blue[256] );
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
============================================================
|
||||
|
|
|
|||
|
|
@ -351,6 +351,7 @@ void R_SetNewMode( const bool fullInit )
|
|||
r_fullscreen.SetInteger( 1 );
|
||||
R_GetModeListForDisplay( r_fullscreen.GetInteger() - 1, modeList );
|
||||
}
|
||||
|
||||
if( modeList.Num() < 1 )
|
||||
{
|
||||
idLib::Printf( "Going to safe mode because mode list failed." );
|
||||
|
|
@ -412,7 +413,11 @@ void R_SetNewMode( const bool fullInit )
|
|||
if( fullInit )
|
||||
{
|
||||
// create the context as well as setting up the window
|
||||
if( GLimp_Init( parms ) )
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
if( VKimp_Init( parms ) )
|
||||
#else
|
||||
if( GLimp_Init( parms ) )
|
||||
#endif
|
||||
{
|
||||
// it worked
|
||||
|
||||
|
|
@ -425,7 +430,11 @@ void R_SetNewMode( const bool fullInit )
|
|||
else
|
||||
{
|
||||
// just rebuild the window
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
if(VKimp_SetScreenParms( parms ))
|
||||
#else
|
||||
if( GLimp_SetScreenParms( parms ) )
|
||||
#endif
|
||||
{
|
||||
// it worked
|
||||
|
||||
|
|
@ -1699,8 +1708,11 @@ void R_SetColorMappings()
|
|||
int inf = idMath::Ftoi( 0xffff * pow( j / 255.0f, invg ) + 0.5f );
|
||||
tr.gammaTable[i] = idMath::ClampInt( 0, 0xFFFF, inf );
|
||||
}
|
||||
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
VKimp_SetGamma( tr.gammaTable, tr.gammaTable, tr.gammaTable);
|
||||
#else
|
||||
GLimp_SetGamma( tr.gammaTable, tr.gammaTable, tr.gammaTable );
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ If you have questions concerning this license or the applicable additional terms
|
|||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
|
||||
#ifdef __linux__
|
||||
#if 0 // defined(__linux__)
|
||||
#include "../../sys/posix/posix_public.h"
|
||||
#endif
|
||||
|
||||
|
|
@ -51,14 +51,14 @@ idCVar r_syncEveryFrame( "r_syncEveryFrame", "1", CVAR_BOOL, "Don't let the GPU
|
|||
|
||||
idCVar r_vkEnableValidationLayers( "r_vkEnableValidationLayers", "0", CVAR_BOOL | CVAR_INIT, "" );
|
||||
|
||||
vulkanContext_t vkcontext;
|
||||
|
||||
#if defined(_WIN32)
|
||||
static const int g_numInstanceExtensions = 2;
|
||||
static const char* g_instanceExtensions[ g_numInstanceExtensions ] =
|
||||
{
|
||||
VK_KHR_SURFACE_EXTENSION_NAME,
|
||||
VK_KHR_XCB_SURFACE_EXTENSION_NAME
|
||||
VK_KHR_WIN32_SURFACE_EXTENSION_NAME
|
||||
};
|
||||
#endif
|
||||
|
||||
static const int g_numDebugInstanceExtensions = 1;
|
||||
static const char* g_debugInstanceExtensions[ g_numDebugInstanceExtensions ] =
|
||||
|
|
@ -234,6 +234,7 @@ static void ValidateValidationLayers()
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
CreateVulkanInstance
|
||||
|
|
@ -253,16 +254,17 @@ static void CreateVulkanInstance()
|
|||
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||||
createInfo.pApplicationInfo = &appInfo;
|
||||
|
||||
const bool enableLayers = r_vkEnableValidationLayers.GetBool();
|
||||
const bool enableLayers = true; // r_vkEnableValidationLayers.GetBool(); EW: Testing
|
||||
|
||||
vkcontext.instanceExtensions.Clear();
|
||||
vkcontext.deviceExtensions.Clear();
|
||||
vkcontext.validationLayers.Clear();
|
||||
|
||||
#if defined(_WIN32)
|
||||
for( int i = 0; i < g_numInstanceExtensions; ++i )
|
||||
{
|
||||
vkcontext.instanceExtensions.Append( g_instanceExtensions[ i ] );
|
||||
}
|
||||
#endif
|
||||
|
||||
for( int i = 0; i < g_numDeviceExtensions; ++i )
|
||||
{
|
||||
|
|
@ -283,9 +285,15 @@ static void CreateVulkanInstance()
|
|||
|
||||
ValidateValidationLayers();
|
||||
}
|
||||
|
||||
#if defined(__linux__)
|
||||
auto extensions = get_required_extensions(sdlInstanceExtensions, enableLayers);
|
||||
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
|
||||
createInfo.ppEnabledExtensionNames = extensions.data();
|
||||
#else
|
||||
createInfo.enabledExtensionCount = vkcontext.instanceExtensions.Num();
|
||||
createInfo.ppEnabledExtensionNames = vkcontext.instanceExtensions.Ptr();
|
||||
#endif
|
||||
|
||||
createInfo.enabledLayerCount = vkcontext.validationLayers.Num();
|
||||
createInfo.ppEnabledLayerNames = vkcontext.validationLayers.Ptr();
|
||||
|
||||
|
|
@ -337,7 +345,8 @@ static void EnumeratePhysicalDevices()
|
|||
vkGetPhysicalDeviceQueueFamilyProperties( gpu.device, &numQueues, gpu.queueFamilyProps.Ptr() );
|
||||
ID_VK_VALIDATE( numQueues > 0, "vkGetPhysicalDeviceQueueFamilyProperties returned zero queues." );
|
||||
}
|
||||
|
||||
// Eric: Bypass this since on linux we use SDL_Vulkan_GetInstanceExtensions to query for extensions.
|
||||
#if defined(__linux__)
|
||||
// grab available Vulkan extensions
|
||||
{
|
||||
idLib::Printf("Getting available vulkan extensions...\n");
|
||||
|
|
@ -348,14 +357,14 @@ static void EnumeratePhysicalDevices()
|
|||
gpu.extensionProps.SetNum( numExtension );
|
||||
ID_VK_CHECK( vkEnumerateDeviceExtensionProperties( gpu.device, NULL, &numExtension, gpu.extensionProps.Ptr() ) );
|
||||
ID_VK_VALIDATE( numExtension > 0, "vkEnumerateDeviceExtensionProperties returned zero extensions." );
|
||||
|
||||
#if 0
|
||||
for( uint32 j = 0; j < numExtension; j++ )
|
||||
{
|
||||
idLib::Printf( "Found Vulkan Extension '%s' on device %d\n", gpu.extensionProps[j].extensionName, i );
|
||||
}
|
||||
#endif
|
||||
#endif // 0
|
||||
}
|
||||
#endif // __linux__
|
||||
|
||||
// grab surface specific information
|
||||
ID_VK_CHECK( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( gpu.device, vkcontext.surface, &gpu.surfaceCaps ) );
|
||||
|
|
@ -431,6 +440,11 @@ static void CreateSurface()
|
|||
|
||||
ID_VK_CHECK( vkCreateWaylandSurfaceKHR( info.inst, &createInfo, NULL, &info.surface ) );
|
||||
|
||||
#else
|
||||
#if defined(__linux__)
|
||||
if(!SDL_Vulkan_CreateSurface(vkcontext.vkwindow, vkcontext.instance, &vkcontext.surface)) {
|
||||
idLib::FatalError("Error while creating Vulkan surface: %s", SDL_GetError());
|
||||
}
|
||||
#else
|
||||
VkXcbSurfaceCreateInfoKHR createInfo = {};
|
||||
createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
|
||||
|
|
@ -440,12 +454,12 @@ static void CreateSurface()
|
|||
createInfo.window = info.window;
|
||||
|
||||
ID_VK_CHECK( vkCreateXcbSurfaceKHR( vkcontext.instance, &createInfo, NULL, &vkcontext.surface ) );
|
||||
#endif // __linux__
|
||||
|
||||
#endif // _WIN32
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=============
|
||||
CheckPhysicalDeviceExtensionSupport
|
||||
|
|
@ -554,22 +568,22 @@ static void SelectPhysicalDevice()
|
|||
switch( gpu.props.vendorID )
|
||||
{
|
||||
case 0x8086:
|
||||
idLib::Printf( "Vendor: Intel\n");
|
||||
idLib::Printf( "Device[%i] : Vendor: Intel \n", i);
|
||||
glConfig.vendor = VENDOR_INTEL;
|
||||
break;
|
||||
|
||||
case 0x10DE:
|
||||
idLib::Printf( "Vendor: NVIDIA\n");
|
||||
idLib::Printf( "Device[%i] : Vendor: NVIDIA\n", i);
|
||||
glConfig.vendor = VENDOR_NVIDIA;
|
||||
break;
|
||||
|
||||
case 0x1002:
|
||||
idLib::Printf( "Vendor: AMD\n");
|
||||
idLib::Printf( "Device[%i] : Vendor: AMD\n", i);
|
||||
glConfig.vendor = VENDOR_AMD;
|
||||
break;
|
||||
|
||||
default:
|
||||
idLib::Printf( "Vendor: Unknown (0x%x)\n", gpu.props.vendorID );
|
||||
idLib::Printf( "Device[%i] : Vendor: Unknown (0x%x)\n", i, gpu.props.vendorID );
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
@ -710,14 +724,20 @@ static VkExtent2D ChooseSurfaceExtent( VkSurfaceCapabilitiesKHR& caps )
|
|||
{
|
||||
VkExtent2D extent;
|
||||
|
||||
if( caps.currentExtent.width == -1 )
|
||||
int width;
|
||||
int height;
|
||||
SDL_Vulkan_GetDrawableSize(vkcontext.vkwindow, &width, &height);
|
||||
width = CLAMP(width, caps.minImageExtent.width, caps.maxImageExtent.width);
|
||||
height = CLAMP(height, caps.minImageExtent.height, caps.maxImageExtent.height);
|
||||
|
||||
if( caps.currentExtent.width == -1 )
|
||||
{
|
||||
extent.width = glConfig.nativeScreenWidth;
|
||||
extent.height = glConfig.nativeScreenHeight;
|
||||
extent.width = width;
|
||||
extent.height = height;
|
||||
}
|
||||
else
|
||||
{
|
||||
extent = caps.currentExtent;
|
||||
extent = caps.currentExtent;
|
||||
}
|
||||
|
||||
return extent;
|
||||
|
|
@ -966,7 +986,7 @@ static void CreateRenderTargets()
|
|||
VK_IMAGE_TILING_OPTIMAL,
|
||||
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT );
|
||||
}
|
||||
idLib::Printf( "renderSystem->GetWidth()/GetHeight() %ix%i\n", renderSystem->GetWidth(), renderSystem->GetHeight() );
|
||||
|
||||
idImageOpts depthOptions;
|
||||
depthOptions.format = FMT_DEPTH;
|
||||
depthOptions.width = renderSystem->GetWidth();
|
||||
|
|
@ -1275,8 +1295,13 @@ void idRenderBackend::Init()
|
|||
idLib::FatalError( "R_InitVulkan called while active" );
|
||||
}
|
||||
|
||||
|
||||
// DG: make sure SDL has setup video so getting supported modes in R_SetNewMode() works
|
||||
GLimp_PreInit();
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
VKimp_PreInit();
|
||||
#else
|
||||
GLimp_PreInit();
|
||||
#endif
|
||||
// DG end
|
||||
|
||||
R_SetNewMode( true );
|
||||
|
|
@ -1447,7 +1472,11 @@ void idRenderBackend::Shutdown()
|
|||
ClearContext();
|
||||
|
||||
// destroy main window
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
VKimp_Shutdown();
|
||||
#else
|
||||
GLimp_Shutdown();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -32,13 +32,18 @@ If you have questions concerning this license or the applicable additional terms
|
|||
|
||||
#if defined( USE_VULKAN )
|
||||
|
||||
//#define VK_USE_PLATFORM_XLIB_KHR
|
||||
// #define VK_USE_PLATFORM_XLIB_KHR
|
||||
|
||||
#define VK_USE_PLATFORM_XCB_KHR
|
||||
#define USE_AMD_ALLOCATOR
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#if defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
#include <xcb/xcb.h>
|
||||
#include <dlfcn.h>
|
||||
#endif
|
||||
|
||||
#if defined( USE_AMD_ALLOCATOR )
|
||||
#include "vma.h"
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ static int cmdargc = 0;
|
|||
#include <mcheck.h>
|
||||
#endif
|
||||
|
||||
#ifdef USE_VULKAN
|
||||
#if 0 // defined(USE_VULKAN)
|
||||
#include <xcb/xcb.h>
|
||||
#endif
|
||||
|
||||
|
|
@ -519,7 +519,7 @@ void Sys_ReLaunch()
|
|||
// DG end
|
||||
}
|
||||
|
||||
#ifdef USE_VULKAN
|
||||
#if 0 //defined(USE_VULKAN)
|
||||
/* Declare the global posixInfo */
|
||||
posixInfo info;
|
||||
|
||||
|
|
@ -566,7 +566,7 @@ static void createWindow(size_t winWidth, size_t winHeight)
|
|||
/* Set some properties, such as the window name, maybe? */
|
||||
xcb_change_property(info.connection, XCB_PROP_MODE_REPLACE,
|
||||
info.window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING,
|
||||
8, 7, "vkDOOM3");
|
||||
8, 7, "vkRBDoom3BFG");
|
||||
|
||||
/* map the window to the screen and flush the stream to the server */
|
||||
xcb_map_window(info.connection, info.window);
|
||||
|
|
@ -595,11 +595,11 @@ int main( int argc, const char** argv )
|
|||
Sys_Printf( "memory consistency checking enabled\n" );
|
||||
#endif
|
||||
|
||||
#ifdef USE_VULKAN
|
||||
#if 0 // defined(USE_VULKAN)
|
||||
/* Create the window if using Vulkan */
|
||||
xcb_generic_event_t *event;
|
||||
xcb_client_message_event_t *cm;
|
||||
createWindow(1600, 900);
|
||||
createWindow(1280, 720);
|
||||
#endif
|
||||
|
||||
Posix_EarlyInit( );
|
||||
|
|
@ -618,7 +618,7 @@ int main( int argc, const char** argv )
|
|||
|
||||
while( 1 )
|
||||
{
|
||||
#ifdef USE_VULKAN
|
||||
#if 0 //defined(USE_VULKAN)
|
||||
/* I'm not 100% sure if intercepting these xcb events interferes with
|
||||
* SDL's input handling or not, but I suspect that it's necessary
|
||||
* to pump some event loop. We'll see */
|
||||
|
|
|
|||
|
|
@ -72,7 +72,8 @@ enum clk_id_t { CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW };
|
|||
int clock_gettime( clk_id_t clock, struct timespec* tp );
|
||||
#endif
|
||||
|
||||
#ifdef USE_VULKAN
|
||||
// Eric: Not used on Linux since using SDL2
|
||||
#if 0 //defined(USE_VULKAN)
|
||||
/* Struct that holds global xcb state for vulkan */
|
||||
typedef struct _posixInfo {
|
||||
xcb_connection_t *connection;
|
||||
|
|
|
|||
|
|
@ -852,8 +852,11 @@ void Sys_GrabMouseCursor( bool grabIt )
|
|||
{
|
||||
flags = GRAB_SETSTATE;
|
||||
}
|
||||
|
||||
GLimp_GrabInput( flags );
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
VKimp_GrabInput( flags );
|
||||
#else
|
||||
GLimp_GrabInput( flags );
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -35,8 +35,11 @@ const int GRAB_REENABLE = ( 1 << 1 );
|
|||
const int GRAB_HIDECURSOR = ( 1 << 2 );
|
||||
const int GRAB_SETSTATE = ( 1 << 3 );
|
||||
|
||||
#if defined(__linux__) && defined(USE_VULKAN)
|
||||
void VKimp_GrabInput( int flags);
|
||||
#else
|
||||
void GLimp_GrabInput( int flags );
|
||||
|
||||
#endif
|
||||
char* Sys_ConsoleInput();
|
||||
|
||||
#endif
|
||||
|
|
|
|||
648
neo/sys/sdl/sdl_vkimp.cpp
Normal file
648
neo/sys/sdl/sdl_vkimp.cpp
Normal file
|
|
@ -0,0 +1,648 @@
|
|||
/*
|
||||
===========================================================================
|
||||
|
||||
Doom 3 GPL Source Code
|
||||
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
||||
Copyright (C) 2012 dhewg (dhewm3)
|
||||
Copyright (C) 2012-2014 Robert Beckebans
|
||||
Copyright (C) 2013 Daniel Gibson
|
||||
|
||||
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
||||
|
||||
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Doom 3 Source Code is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
||||
|
||||
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#include "../../idlib/precompiled.h"
|
||||
|
||||
// DG: SDL.h somehow needs the following functions, so #undef those silly
|
||||
// "don't use" #defines from Str.h
|
||||
#undef strncmp
|
||||
#undef strcasecmp
|
||||
#undef vsnprintf
|
||||
// DG end
|
||||
|
||||
#include <SDL.h>
|
||||
#include <SDL_vulkan.h>
|
||||
#include <vulkan/vulkan.h>
|
||||
#include <vector>
|
||||
|
||||
#include "renderer/RenderCommon.h"
|
||||
#include "sdl_local.h"
|
||||
|
||||
idCVar in_nograb( "in_nograb", "0", CVAR_SYSTEM | CVAR_NOCHEAT, "prevents input grabbing" );
|
||||
|
||||
// RB: FIXME this shit. We need the OpenGL alpha channel for advanced rendering effects
|
||||
idCVar r_waylandcompat( "r_waylandcompat", "0", CVAR_SYSTEM | CVAR_NOCHEAT | CVAR_ARCHIVE, "wayland compatible framebuffer" );
|
||||
|
||||
// RB: only relevant if using SDL 2.0
|
||||
#if defined(__APPLE__)
|
||||
// only core profile is supported on OS X
|
||||
idCVar r_useOpenGL32( "r_useOpenGL32", "2", CVAR_INTEGER, "0 = OpenGL 3.x, 1 = OpenGL 3.2 compatibility profile, 2 = OpenGL 3.2 core profile", 0, 2 );
|
||||
#elif defined(__linux__)
|
||||
// Linux open source drivers suck
|
||||
idCVar r_useOpenGL32( "r_useOpenGL32", "0", CVAR_INTEGER, "0 = OpenGL 3.x, 1 = OpenGL 3.2 compatibility profile, 2 = OpenGL 3.2 core profile", 0, 2 );
|
||||
#else
|
||||
idCVar r_useOpenGL32( "r_useOpenGL32", "1", CVAR_INTEGER, "0 = OpenGL 3.x, 1 = OpenGL 3.2 compatibility profile, 2 = OpenGL 3.2 core profile", 0, 2 );
|
||||
#endif
|
||||
// RB end
|
||||
|
||||
static bool grabbed = false;
|
||||
|
||||
vulkanContext_t vkcontext; // Eric: I added this to pass SDL_Window* window to the SDL_Vulkan_* methods that are used else were.
|
||||
|
||||
static SDL_Window* window = nullptr;
|
||||
|
||||
// Eric: Integrate this into RBDoom3BFG's source code ecosystem.
|
||||
// Helper function for using SDL2 and Vulkan on Linux.
|
||||
std::vector<const char*> get_required_extensions(const std::vector<const char*>& instanceExtensions, bool enableValidationLayers)
|
||||
{
|
||||
uint32_t sdlCount = 0;
|
||||
std::vector<const char*> sdlInstanceExtensions;
|
||||
|
||||
SDL_Vulkan_GetInstanceExtensions(nullptr, &sdlCount, nullptr);
|
||||
sdlInstanceExtensions.resize(sdlCount);
|
||||
SDL_Vulkan_GetInstanceExtensions(nullptr, &sdlCount, sdlInstanceExtensions.data());
|
||||
|
||||
if (enableValidationLayers) {
|
||||
idLib::Printf("\nNumber of availiable instance extensions\t%i\n", sdlCount);
|
||||
idLib::Printf( "Available Extension List: \n");
|
||||
for (auto ext : sdlInstanceExtensions) {
|
||||
idLib::Printf( "\t%s\n", ext);
|
||||
}
|
||||
}
|
||||
|
||||
if (enableValidationLayers) {
|
||||
sdlInstanceExtensions.push_back("VK_EXT_debug_report");
|
||||
sdlInstanceExtensions.push_back("VK_EXT_debug_utils");
|
||||
|
||||
idLib::Printf("Number of active instance extensions\t%zu\n",sdlInstanceExtensions.size());
|
||||
idLib::Printf( "Active Extension List: \n");
|
||||
for (auto const& ext : sdlInstanceExtensions) {
|
||||
idLib::Printf("\t%s\n",ext);
|
||||
}
|
||||
}
|
||||
|
||||
return sdlInstanceExtensions;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
VKimp_PreInit
|
||||
|
||||
R_GetModeListForDisplay is called before VKimp_Init(), but SDL needs SDL_Init() first.
|
||||
So do that in VKimp_PreInit()
|
||||
Calling that function more than once doesn't make a difference
|
||||
===================
|
||||
*/
|
||||
void VKimp_PreInit() // DG: added this function for SDL compatibility
|
||||
{
|
||||
if( !SDL_WasInit( SDL_INIT_VIDEO ) )
|
||||
{
|
||||
if( SDL_Init( SDL_INIT_VIDEO ) )
|
||||
{
|
||||
common->Error( "Error while initializing SDL: %s", SDL_GetError() );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Eric: Is the majority of this function not needed since switching from GL to Vulkan?
|
||||
===================
|
||||
VKimp_Init
|
||||
===================
|
||||
*/
|
||||
bool VKimp_Init( glimpParms_t parms )
|
||||
{
|
||||
|
||||
common->Printf( "Initializing Vulkan subsystem\n" );
|
||||
|
||||
VKimp_PreInit(); // DG: make sure SDL is initialized
|
||||
|
||||
// DG: make window resizable
|
||||
Uint32 flags = SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE;
|
||||
// DG end
|
||||
|
||||
if( parms.fullScreen )
|
||||
{
|
||||
flags |= SDL_WINDOW_FULLSCREEN;
|
||||
}
|
||||
|
||||
int colorbits = 24;
|
||||
int depthbits = 24;
|
||||
int stencilbits = 8;
|
||||
|
||||
for( int i = 0; i < 16; i++ )
|
||||
{
|
||||
// 0 - default
|
||||
// 1 - minus colorbits
|
||||
// 2 - minus depthbits
|
||||
// 3 - minus stencil
|
||||
if( ( i % 4 ) == 0 && i )
|
||||
{
|
||||
// one pass, reduce
|
||||
switch( i / 4 )
|
||||
{
|
||||
case 2 :
|
||||
if( colorbits == 24 )
|
||||
{
|
||||
colorbits = 16;
|
||||
}
|
||||
break;
|
||||
case 1 :
|
||||
if( depthbits == 24 )
|
||||
{
|
||||
depthbits = 16;
|
||||
}
|
||||
else if( depthbits == 16 )
|
||||
{
|
||||
depthbits = 8;
|
||||
}
|
||||
case 3 :
|
||||
if( stencilbits == 24 )
|
||||
{
|
||||
stencilbits = 16;
|
||||
}
|
||||
else if( stencilbits == 16 )
|
||||
{
|
||||
stencilbits = 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int tcolorbits = colorbits;
|
||||
int tdepthbits = depthbits;
|
||||
int tstencilbits = stencilbits;
|
||||
|
||||
if( ( i % 4 ) == 3 )
|
||||
{
|
||||
// reduce colorbits
|
||||
if( tcolorbits == 24 )
|
||||
{
|
||||
tcolorbits = 16;
|
||||
}
|
||||
}
|
||||
|
||||
if( ( i % 4 ) == 2 )
|
||||
{
|
||||
// reduce depthbits
|
||||
if( tdepthbits == 24 )
|
||||
{
|
||||
tdepthbits = 16;
|
||||
}
|
||||
else if( tdepthbits == 16 )
|
||||
{
|
||||
tdepthbits = 8;
|
||||
}
|
||||
}
|
||||
|
||||
if( ( i % 4 ) == 1 )
|
||||
{
|
||||
// reduce stencilbits
|
||||
if( tstencilbits == 24 )
|
||||
{
|
||||
tstencilbits = 16;
|
||||
}
|
||||
else if( tstencilbits == 16 )
|
||||
{
|
||||
tstencilbits = 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
tstencilbits = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int channelcolorbits = 4;
|
||||
if( tcolorbits == 24 )
|
||||
{
|
||||
channelcolorbits = 8;
|
||||
}
|
||||
|
||||
// DG: set display num for fullscreen
|
||||
int windowPos = SDL_WINDOWPOS_UNDEFINED;
|
||||
if( parms.fullScreen > 0 )
|
||||
{
|
||||
if( parms.fullScreen > SDL_GetNumVideoDisplays() )
|
||||
{
|
||||
common->Warning( "Couldn't set display to num %i because we only have %i displays",
|
||||
parms.fullScreen, SDL_GetNumVideoDisplays() );
|
||||
}
|
||||
else
|
||||
{
|
||||
// -1 because SDL starts counting displays at 0, while parms.fullScreen starts at 1
|
||||
windowPos = SDL_WINDOWPOS_UNDEFINED_DISPLAY( ( parms.fullScreen - 1 ) );
|
||||
}
|
||||
}
|
||||
// TODO: if parms.fullScreen == -1 there should be a borderless window spanning multiple displays
|
||||
/*
|
||||
* NOTE that this implicitly handles parms.fullScreen == -2 (from r_fullscreen -2) meaning
|
||||
* "do fullscreen, but I don't care on what monitor", at least on my box it's the monitor with
|
||||
* the mouse cursor.
|
||||
*/
|
||||
|
||||
window = SDL_CreateWindow( GAME_NAME,
|
||||
windowPos,
|
||||
windowPos,
|
||||
parms.width, parms.height, flags );
|
||||
// DG end
|
||||
|
||||
if( !window )
|
||||
{
|
||||
common->DPrintf( "Couldn't set GL mode %d/%d/%d: %s",
|
||||
channelcolorbits, tdepthbits, tstencilbits, SDL_GetError() );
|
||||
continue;
|
||||
}
|
||||
vkcontext.vkwindow = window;
|
||||
// RB begin
|
||||
SDL_GetWindowSize( window, &glConfig.nativeScreenWidth, &glConfig.nativeScreenHeight );
|
||||
// RB end
|
||||
|
||||
glConfig.isFullscreen = ( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN ) == SDL_WINDOW_FULLSCREEN;
|
||||
|
||||
common->Printf( "Using %d color bits, %d depth, %d stencil display\n",
|
||||
channelcolorbits, tdepthbits, tstencilbits );
|
||||
|
||||
glConfig.colorBits = tcolorbits;
|
||||
glConfig.depthBits = tdepthbits;
|
||||
glConfig.stencilBits = tstencilbits;
|
||||
|
||||
// RB begin
|
||||
glConfig.displayFrequency = 60;
|
||||
glConfig.isStereoPixelFormat = parms.stereo;
|
||||
glConfig.multisamples = parms.multiSamples;
|
||||
|
||||
glConfig.pixelAspect = 1.0f; // FIXME: some monitor modes may be distorted
|
||||
// should side-by-side stereo modes be consider aspect 0.5?
|
||||
|
||||
// RB end
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if( !window )
|
||||
{
|
||||
common->Printf( "No usable GL mode found: %s", SDL_GetError() );
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef __APPLE__
|
||||
glewExperimental = GL_TRUE;
|
||||
#endif
|
||||
|
||||
// DG: disable cursor, we have two cursors in menu (because mouse isn't grabbed in menu)
|
||||
SDL_ShowCursor( SDL_DISABLE );
|
||||
// DG end
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
Helper functions for VKimp_SetScreenParms()
|
||||
===================
|
||||
*/
|
||||
static int ScreenParmsHandleDisplayIndex( glimpParms_t parms )
|
||||
{
|
||||
int displayIdx;
|
||||
if( parms.fullScreen > 0 )
|
||||
{
|
||||
displayIdx = parms.fullScreen - 1; // first display for SDL is 0, in parms it's 1
|
||||
}
|
||||
else // -2 == use current display
|
||||
{
|
||||
displayIdx = SDL_GetWindowDisplayIndex( window );
|
||||
if( displayIdx < 0 ) // for some reason the display for the window couldn't be detected
|
||||
{
|
||||
displayIdx = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if( parms.fullScreen > SDL_GetNumVideoDisplays() )
|
||||
{
|
||||
common->Warning( "Can't set fullscreen mode to display number %i, because SDL2 only knows about %i displays!",
|
||||
parms.fullScreen, SDL_GetNumVideoDisplays() );
|
||||
return -1;
|
||||
}
|
||||
|
||||
if( parms.fullScreen != glConfig.isFullscreen )
|
||||
{
|
||||
// we have to switch to another display
|
||||
if( glConfig.isFullscreen )
|
||||
{
|
||||
// if we're already in fullscreen mode but want to switch to another monitor
|
||||
// we have to go to windowed mode first to move the window.. SDL-oddity.
|
||||
SDL_SetWindowFullscreen( window, SDL_FALSE );
|
||||
}
|
||||
// select display ; SDL_WINDOWPOS_UNDEFINED_DISPLAY() doesn't work.
|
||||
int x = SDL_WINDOWPOS_CENTERED_DISPLAY( displayIdx );
|
||||
// move window to the center of selected display
|
||||
SDL_SetWindowPosition( window, x, x );
|
||||
}
|
||||
return displayIdx;
|
||||
}
|
||||
|
||||
static bool SetScreenParmsFullscreen( glimpParms_t parms )
|
||||
{
|
||||
SDL_DisplayMode m = {0};
|
||||
int displayIdx = ScreenParmsHandleDisplayIndex( parms );
|
||||
if( displayIdx < 0 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// get current mode of display the window should be full-screened on
|
||||
SDL_GetCurrentDisplayMode( displayIdx, &m );
|
||||
|
||||
// change settings in that display mode according to parms
|
||||
// FIXME: check if refreshrate, width and height are supported?
|
||||
// m.refresh_rate = parms.displayHz;
|
||||
m.w = parms.width;
|
||||
m.h = parms.height;
|
||||
|
||||
// set that displaymode
|
||||
if( SDL_SetWindowDisplayMode( window, &m ) < 0 )
|
||||
{
|
||||
common->Warning( "Couldn't set window mode for fullscreen, reason: %s", SDL_GetError() );
|
||||
return false;
|
||||
}
|
||||
|
||||
// if we're currently not in fullscreen mode, we need to switch to fullscreen
|
||||
if( !( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN ) )
|
||||
{
|
||||
if( SDL_SetWindowFullscreen( window, SDL_TRUE ) < 0 )
|
||||
{
|
||||
common->Warning( "Couldn't switch to fullscreen mode, reason: %s!", SDL_GetError() );
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool SetScreenParmsWindowed( glimpParms_t parms )
|
||||
{
|
||||
SDL_SetWindowSize( window, parms.width, parms.height );
|
||||
SDL_SetWindowPosition( window, parms.x, parms.y );
|
||||
|
||||
// if we're currently in fullscreen mode, we need to disable that
|
||||
if( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN )
|
||||
{
|
||||
if( SDL_SetWindowFullscreen( window, SDL_FALSE ) < 0 )
|
||||
{
|
||||
common->Warning( "Couldn't switch to windowed mode, reason: %s!", SDL_GetError() );
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===================
|
||||
VKimp_SetScreenParms
|
||||
===================
|
||||
*/
|
||||
bool VKimp_SetScreenParms( glimpParms_t parms )
|
||||
{
|
||||
|
||||
if( parms.fullScreen > 0 || parms.fullScreen == -2 )
|
||||
{
|
||||
if( !SetScreenParmsFullscreen( parms ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if( parms.fullScreen == 0 ) // windowed mode
|
||||
{
|
||||
if( !SetScreenParmsWindowed( parms ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
common->Warning( "VKimp_SetScreenParms: fullScreen -1 (borderless window for multiple displays) currently unsupported!" );
|
||||
return false;
|
||||
}
|
||||
|
||||
glConfig.isFullscreen = parms.fullScreen;
|
||||
glConfig.isStereoPixelFormat = parms.stereo;
|
||||
glConfig.nativeScreenWidth = parms.width;
|
||||
glConfig.nativeScreenHeight = parms.height;
|
||||
glConfig.displayFrequency = parms.displayHz;
|
||||
glConfig.multisamples = parms.multiSamples;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
VKimp_Shutdown
|
||||
===================
|
||||
*/
|
||||
void VKimp_Shutdown()
|
||||
{
|
||||
common->Printf( "Shutting down Vulkan subsystem\n" );
|
||||
|
||||
if( window )
|
||||
{
|
||||
SDL_DestroyWindow( window );
|
||||
window = nullptr;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* Eric: Is this needed/used for Vulkan?
|
||||
=================
|
||||
VKimp_SetGamma
|
||||
=================
|
||||
*/
|
||||
void VKimp_SetGamma( unsigned short red[256], unsigned short green[256], unsigned short blue[256] )
|
||||
{
|
||||
#ifndef USE_VULKAN
|
||||
if( !window )
|
||||
{
|
||||
common->Warning( "VKimp_SetGamma called without window" );
|
||||
return;
|
||||
}
|
||||
|
||||
#if SDL_VERSION_ATLEAST(2, 0, 0)
|
||||
if( SDL_SetWindowGammaRamp( window, red, green, blue ) )
|
||||
#else
|
||||
if( SDL_SetGammaRamp( red, green, blue ) )
|
||||
#endif
|
||||
common->Warning( "Couldn't set gamma ramp: %s", SDL_GetError() );
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
VKimp_ExtensionPointer
|
||||
===================
|
||||
*/
|
||||
/*
|
||||
GLExtension_t VKimp_ExtensionPointer(const char *name) {
|
||||
assert(SDL_WasInit(SDL_INIT_VIDEO));
|
||||
|
||||
return (GLExtension_t)SDL_GL_GetProcAddress(name);
|
||||
}
|
||||
*/
|
||||
|
||||
void VKimp_GrabInput( int flags )
|
||||
{
|
||||
bool grab = flags & GRAB_ENABLE;
|
||||
|
||||
if( grab && ( flags & GRAB_REENABLE ) )
|
||||
{
|
||||
grab = false;
|
||||
}
|
||||
|
||||
if( flags & GRAB_SETSTATE )
|
||||
{
|
||||
grabbed = grab;
|
||||
}
|
||||
|
||||
if( in_nograb.GetBool() )
|
||||
{
|
||||
grab = false;
|
||||
}
|
||||
|
||||
if( !window )
|
||||
{
|
||||
common->Warning( "VKimp_GrabInput called without window" );
|
||||
return;
|
||||
}
|
||||
|
||||
// DG: disabling the cursor is now done once in VKimp_Init() because it should always be disabled
|
||||
|
||||
// DG: check for GRAB_ENABLE instead of GRAB_HIDECURSOR because we always wanna hide it
|
||||
SDL_SetRelativeMouseMode( flags & GRAB_ENABLE ? SDL_TRUE : SDL_FALSE );
|
||||
SDL_SetWindowGrab( window, grab ? SDL_TRUE : SDL_FALSE );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
DumpAllDisplayDevices
|
||||
====================
|
||||
*/
|
||||
void DumpAllDisplayDevices()
|
||||
{
|
||||
common->DPrintf( "TODO: DumpAllDisplayDevices\n" );
|
||||
}
|
||||
|
||||
class idSort_VidMode : public idSort_Quick< vidMode_t, idSort_VidMode >
|
||||
{
|
||||
public:
|
||||
int Compare( const vidMode_t& a, const vidMode_t& b ) const
|
||||
{
|
||||
int wd = a.width - b.width;
|
||||
int hd = a.height - b.height;
|
||||
int fd = a.displayHz - b.displayHz;
|
||||
return ( hd != 0 ) ? hd : ( wd != 0 ) ? wd : fd;
|
||||
}
|
||||
};
|
||||
|
||||
// RB: resolutions supported by XreaL
|
||||
static void FillStaticVidModes( idList<vidMode_t>& modeList )
|
||||
{
|
||||
modeList.AddUnique( vidMode_t( 320, 240, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 400, 300, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 512, 384, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 640, 480, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 800, 600, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 960, 720, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1024, 768, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1152, 864, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1280, 720, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1280, 768, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1280, 800, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1280, 1024, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1360, 768, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1440, 900, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1680, 1050, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1600, 1200, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1920, 1080, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 1920, 1200, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 2048, 1536, 60 ) );
|
||||
modeList.AddUnique( vidMode_t( 2560, 1600, 60 ) );
|
||||
|
||||
modeList.SortWithTemplate( idSort_VidMode() );
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
R_GetModeListForDisplay
|
||||
====================
|
||||
*/
|
||||
bool R_GetModeListForDisplay( const int requestedDisplayNum, idList<vidMode_t>& modeList )
|
||||
{
|
||||
assert( requestedDisplayNum >= 0 );
|
||||
|
||||
modeList.Clear();
|
||||
|
||||
// DG: SDL2 implementation
|
||||
if( requestedDisplayNum >= SDL_GetNumVideoDisplays() )
|
||||
{
|
||||
// requested invalid displaynum
|
||||
return false;
|
||||
}
|
||||
|
||||
int numModes = SDL_GetNumDisplayModes( requestedDisplayNum );
|
||||
if( numModes > 0 )
|
||||
{
|
||||
for( int i = 0; i < numModes; i++ )
|
||||
{
|
||||
SDL_DisplayMode m;
|
||||
int ret = SDL_GetDisplayMode( requestedDisplayNum, i, &m );
|
||||
if( ret != 0 )
|
||||
{
|
||||
common->Warning( "Can't get video mode no %i, because of %s\n", i, SDL_GetError() );
|
||||
continue;
|
||||
}
|
||||
|
||||
vidMode_t mode;
|
||||
mode.width = m.w;
|
||||
mode.height = m.h;
|
||||
mode.displayHz = m.refresh_rate ? m.refresh_rate : 60; // default to 60 if unknown (0)
|
||||
modeList.AddUnique( mode );
|
||||
}
|
||||
|
||||
if( modeList.Num() < 1 )
|
||||
{
|
||||
common->Warning( "Couldn't get a single video mode for display %i, using default ones..!\n", requestedDisplayNum );
|
||||
FillStaticVidModes( modeList );
|
||||
}
|
||||
|
||||
// sort with lowest resolution first
|
||||
modeList.SortWithTemplate( idSort_VidMode() );
|
||||
}
|
||||
else
|
||||
{
|
||||
common->Warning( "Can't get Video Info, using default modes...\n" );
|
||||
if( numModes < 0 )
|
||||
{
|
||||
common->Warning( "Reason was: %s\n", SDL_GetError() );
|
||||
}
|
||||
FillStaticVidModes( modeList );
|
||||
}
|
||||
|
||||
return true;
|
||||
// DG end
|
||||
}
|
||||
Loading…
Reference in a new issue