mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2026-04-03 06:09:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed SDL_RendererFlags

Browse Source 
The flags parameter has been removed from SDL_CreateRenderer() and SDL_RENDERER_PRESENTVSYNC has been replaced with SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER during window creation and SDL_PROP_RENDERER_VSYNC_NUMBER after renderer creation.

SDL_SetRenderVSync() now takes additional values besides 0 and 1.

The maximum texture size has been removed from SDL_RendererInfo, replaced with SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER.
This commit is contained in:
Sam Lantinga
2024-05-13 10:31:55 -07:00
parent 678cfd23c0
commit 17520c2e6e
41 changed files with 265 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
src/render/SDL_render.c
View File

@@ -857,7 +857,7 @@ int SDL_CreateWindowAndRenderer(const char *title, int width, int height, SDL_Wi
return -1;
}
*renderer = SDL_CreateRenderer(*window, NULL, 0);
*renderer = SDL_CreateRenderer(*window, NULL);
if (!*renderer) {
SDL_DestroyWindow(*window);
*window = NULL;
@@ -969,7 +969,7 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
if (hint && *hint) {
SDL_SetBooleanProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE));
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE));
}
if (surface) {
@@ -1019,16 +1019,6 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
}
}
if (SDL_GetBooleanProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
renderer->wanted_vsync = SDL_TRUE;
if (!(renderer->info.flags & SDL_RENDERER_PRESENTVSYNC)) {
renderer->simulate_vsync = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
}
SDL_CalculateSimulatedVSyncInterval(renderer, window);
VerifyDrawQueueFunctions(renderer);
renderer->magic = &SDL_renderer_magic;
@@ -1102,12 +1092,24 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
SDL_AddEventWatch(SDL_RendererEventWatch, renderer);
}
int vsync = (int)SDL_GetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0);
if (SDL_SetRenderVSync(renderer, vsync) < 0) {
if (vsync == 0) {
// Some renderers require vsync enabled
SDL_SetRenderVSync(renderer, 1);
}
}
SDL_CalculateSimulatedVSyncInterval(renderer, window);
SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
"Created renderer: %s", renderer->info.name);
#ifdef SDL_PLATFORM_ANDROID
Android_ActivityMutex_Unlock();
#endif
SDL_ClearError();
return renderer;
error:
@@ -1125,15 +1127,12 @@ error:
#endif
}
SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, const char *name, SDL_RendererFlags flags)
SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, const char *name)
{
SDL_Renderer *renderer;
SDL_PropertiesID props = SDL_CreateProperties();
SDL_SetProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window);
SDL_SetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, name);
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_SetBooleanProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_TRUE);
}
renderer = SDL_CreateRendererWithProperties(props);
SDL_DestroyProperties(props);
return renderer;
@@ -1305,9 +1304,9 @@ SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_Propert
SDL_SetError("Texture dimensions can't be 0");
return NULL;
}
if ((renderer->info.max_texture_width && w > renderer->info.max_texture_width) ||
(renderer->info.max_texture_height && h > renderer->info.max_texture_height)) {
SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
int max_texture_size = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 0);
if (max_texture_size && (w > max_texture_size || h > max_texture_size)) {
SDL_SetError("Texture dimensions are limited to %dx%d", max_texture_size, max_texture_size);
return NULL;
}
@@ -4726,10 +4725,6 @@ int SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
{
CHECK_RENDERER_MAGIC(renderer, -1);
if (vsync != 0 && vsync != 1) {
return SDL_Unsupported();
}
renderer->wanted_vsync = vsync ? SDL_TRUE : SDL_FALSE;
/* for the software renderer, forward eventually the call to the WindowTexture renderer */
@@ -4742,17 +4737,25 @@ int SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
}
#endif
if (!renderer->SetVSync ||
renderer->SetVSync(renderer, vsync) != 0) {
renderer->simulate_vsync = vsync ? SDL_TRUE : SDL_FALSE;
if (renderer->simulate_vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
if (!renderer->SetVSync) {
switch (vsync) {
case 0:
renderer->simulate_vsync = SDL_FALSE;
break;
case 1:
renderer->simulate_vsync = SDL_TRUE;
break;
default:
return SDL_Unsupported();
}
} else if (renderer->SetVSync(renderer, vsync) < 0) {
if (vsync == 1) {
renderer->simulate_vsync = SDL_TRUE;
} else {
return -1;
}
} else {
renderer->simulate_vsync = SDL_FALSE;
}
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, vsync);
return 0;
}
@@ -4762,6 +4765,6 @@ int SDL_GetRenderVSync(SDL_Renderer *renderer, int *vsync)
if (!vsync) {
return SDL_InvalidParamError("vsync");
}
*vsync = renderer->wanted_vsync;
*vsync = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, 0);
return 0;
}

55
src/render/direct3d/SDL_render_d3d.c
View File

@@ -1552,13 +1552,38 @@ static int D3D_Reset(SDL_Renderer *renderer)
static int D3D_SetVSync(SDL_Renderer *renderer, const int vsync)
{
D3D_RenderData *data = (D3D_RenderData *)renderer->driverdata;
if (vsync) {
data->pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
data->pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
DWORD PresentationInterval;
switch (vsync) {
case 0:
PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
break;
case 1:
PresentationInterval = D3DPRESENT_INTERVAL_ONE;
break;
case 2:
PresentationInterval = D3DPRESENT_INTERVAL_TWO;
break;
case 3:
PresentationInterval = D3DPRESENT_INTERVAL_THREE;
break;
case 4:
PresentationInterval = D3DPRESENT_INTERVAL_FOUR;
break;
default:
return SDL_Unsupported();
}
D3DCAPS9 caps;
HRESULT result = IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
if (FAILED(result)) {
return D3D_SetError("GetDeviceCaps()", result);
}
if (!(caps.PresentationIntervals & PresentationInterval)) {
return SDL_Unsupported();
}
data->pparams.PresentationInterval = PresentationInterval;
if (D3D_Reset(renderer) < 0) {
/* D3D_Reset will call SDL_SetError() */
return -1;
@@ -1644,17 +1669,17 @@ int D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propertie
pparams.BackBufferFormat = D3DFMT_UNKNOWN;
pparams.FullScreen_RefreshRateInHz = 0;
}
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
} else {
pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
}
pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
/* Get the adapter for the display that the window is on */
displayID = SDL_GetDisplayForWindow(window);
data->adapter = SDL_Direct3D9GetAdapterIndex(displayID);
IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
result = IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
if (FAILED(result)) {
D3D_DestroyRenderer(renderer);
return D3D_SetError("GetDeviceCaps()", result);
}
device_flags = D3DCREATE_FPU_PRESERVE;
if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) {
@@ -1690,14 +1715,10 @@ int D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propertie
return D3D_SetError("GetPresentParameters()", result);
}
IDirect3DSwapChain9_Release(chain);
if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
data->pparams = pparams;
IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
renderer->info.max_texture_width = caps.MaxTextureWidth;
renderer->info.max_texture_height = caps.MaxTextureHeight;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, SDL_min(caps.MaxTextureWidth, caps.MaxTextureHeight));
if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
data->enableSeparateAlphaBlend = SDL_TRUE;

82
src/render/direct3d11/SDL_render_d3d11.c
View File

@@ -170,6 +170,8 @@ typedef struct
ID3D11DeviceContext1 *d3dContext;
IDXGISwapChain1 *swapChain;
DXGI_SWAP_EFFECT swapEffect;
UINT syncInterval;
UINT presentFlags;
ID3D11RenderTargetView *mainRenderTargetView;
ID3D11RenderTargetView *currentOffscreenRenderTargetView;
ID3D11InputLayout *inputLayout;
@@ -690,21 +692,21 @@ static HRESULT D3D11_CreateDeviceResources(SDL_Renderer *renderer)
switch (data->featureLevel) {
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
renderer->info.max_texture_width = renderer->info.max_texture_height = 16384;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
break;
case D3D_FEATURE_LEVEL_10_1:
case D3D_FEATURE_LEVEL_10_0:
renderer->info.max_texture_width = renderer->info.max_texture_height = 8192;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 8192);
break;
case D3D_FEATURE_LEVEL_9_3:
renderer->info.max_texture_width = renderer->info.max_texture_height = 4096;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 4096);
break;
case D3D_FEATURE_LEVEL_9_2:
case D3D_FEATURE_LEVEL_9_1:
renderer->info.max_texture_width = renderer->info.max_texture_height = 2048;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 2048);
break;
default:
@@ -2692,31 +2694,19 @@ done:
static int D3D11_RenderPresent(SDL_Renderer *renderer)
{
D3D11_RenderData *data = (D3D11_RenderData *)renderer->driverdata;
UINT syncInterval;
UINT presentFlags;
HRESULT result;
DXGI_PRESENT_PARAMETERS parameters;
SDL_zero(parameters);
#if SDL_WINAPI_FAMILY_PHONE
syncInterval = 1;
presentFlags = 0;
result = IDXGISwapChain_Present(data->swapChain, syncInterval, presentFlags);
result = IDXGISwapChain_Present(data->swapChain, data->syncInterval, data->presentFlags);
#else
if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
syncInterval = 1;
presentFlags = 0;
} else {
syncInterval = 0;
presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
}
/* The application may optionally specify "dirty" or "scroll"
* rects to improve efficiency in certain scenarios.
* This option is not available on Windows Phone 8, to note.
*/
result = IDXGISwapChain1_Present1(data->swapChain, syncInterval, presentFlags, &parameters);
result = IDXGISwapChain1_Present1(data->swapChain, data->syncInterval, data->presentFlags, &parameters);
#endif
/* Discard the contents of the render target.
@@ -2747,19 +2737,39 @@ static int D3D11_RenderPresent(SDL_Renderer *renderer)
return 0;
}
#if SDL_WINAPI_FAMILY_PHONE
/* no-op. */
#else
static int D3D11_SetVSync(SDL_Renderer *renderer, const int vsync)
{
if (vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
D3D11_RenderData *data = (D3D11_RenderData *)renderer->driverdata;
#if SDL_WINAPI_FAMILY_PHONE
/* VSync is required in Windows Phone, at least for Win Phone 8.0 and 8.1.
* Failure to use it seems to either result in:
*
* - with the D3D11 debug runtime turned OFF, vsync seemingly gets turned
* off (framerate doesn't get capped), but nothing appears on-screen
*
* - with the D3D11 debug runtime turned ON, vsync gets automatically
* turned back on, and the following gets output to the debug console:
*
* DXGI ERROR: IDXGISwapChain::Present: Interval 0 is not supported, changed to Interval 1. [ UNKNOWN ERROR #1024: ]
*/
if (vsync == 0) {
return SDL_Unsupported();
}
#endif
if (vsync < 0) {
return SDL_Unsupported();
}
if (vsync > 0) {
data->syncInterval = vsync;
data->presentFlags = 0;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
data->syncInterval = 0;
data->presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
}
return 0;
}
#endif
static int D3D11_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
{
@@ -2803,6 +2813,7 @@ static int D3D11_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
renderer->RenderPresent = D3D11_RenderPresent;
renderer->DestroyTexture = D3D11_DestroyTexture;
renderer->DestroyRenderer = D3D11_DestroyRenderer;
renderer->SetVSync = D3D11_SetVSync;
renderer->driverdata = data;
D3D11_InvalidateCachedState(renderer);
@@ -2817,25 +2828,8 @@ static int D3D11_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
#if SDL_WINAPI_FAMILY_PHONE
/* VSync is required in Windows Phone, at least for Win Phone 8.0 and 8.1.
* Failure to use it seems to either result in:
*
* - with the D3D11 debug runtime turned OFF, vsync seemingly gets turned
* off (framerate doesn't get capped), but nothing appears on-screen
*
* - with the D3D11 debug runtime turned ON, vsync gets automatically
* turned back on, and the following gets output to the debug console:
*
* DXGI ERROR: IDXGISwapChain::Present: Interval 0 is not supported, changed to Interval 1. [ UNKNOWN ERROR #1024: ]
*/
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
#else
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer->SetVSync = D3D11_SetVSync;
#endif
data->syncInterval = 0;
data->presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
/* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
* order to give init functions access to the underlying window handle:

40
src/render/direct3d12/SDL_render_d3d12.c
View File

@@ -212,6 +212,8 @@ typedef struct
ID3D12GraphicsCommandList2 *commandList;
DXGI_SWAP_EFFECT swapEffect;
UINT swapFlags;
UINT syncInterval;
UINT presentFlags;
DXGI_FORMAT renderTargetFormat;
SDL_bool pixelSizeChanged;
@@ -3085,10 +3087,6 @@ done:
static int D3D12_RenderPresent(SDL_Renderer *renderer)
{
D3D12_RenderData *data = (D3D12_RenderData *)renderer->driverdata;
#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
UINT syncInterval;
UINT presentFlags;
#endif
HRESULT result;
/* Transition the render target to present state */
@@ -3104,18 +3102,10 @@ static int D3D12_RenderPresent(SDL_Renderer *renderer)
#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
result = D3D12_XBOX_PresentFrame(data->commandQueue, data->frameToken, data->renderTargets[data->currentBackBufferIndex]);
#else
if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
syncInterval = 1;
presentFlags = 0;
} else {
syncInterval = 0;
presentFlags = DXGI_PRESENT_ALLOW_TEARING;
}
/* The application may optionally specify "dirty" or "scroll"
* rects to improve efficiency in certain scenarios.
*/
result = D3D_CALL(data->swapChain, Present, syncInterval, presentFlags);
result = D3D_CALL(data->swapChain, Present, data->syncInterval, data->presentFlags);
#endif
if (FAILED(result) && result != DXGI_ERROR_WAS_STILL_DRAWING) {
@@ -3166,10 +3156,18 @@ static int D3D12_RenderPresent(SDL_Renderer *renderer)
static int D3D12_SetVSync(SDL_Renderer *renderer, const int vsync)
{
if (vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
D3D12_RenderData *data = (D3D12_RenderData *)renderer->driverdata;
if (vsync < 0) {
return SDL_Unsupported();
}
if (vsync > 0) {
data->syncInterval = vsync;
data->presentFlags = 0;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
data->syncInterval = 0;
data->presentFlags = DXGI_PRESENT_ALLOW_TEARING;
}
return 0;
}
@@ -3221,6 +3219,7 @@ int D3D12_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propert
renderer->RenderPresent = D3D12_RenderPresent;
renderer->DestroyTexture = D3D12_DestroyTexture;
renderer->DestroyRenderer = D3D12_DestroyRenderer;
renderer->SetVSync = D3D12_SetVSync;
renderer->driverdata = data;
D3D12_InvalidateCachedState(renderer);
@@ -3234,13 +3233,10 @@ int D3D12_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propert
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
renderer->info.max_texture_width = 16384;
renderer->info.max_texture_height = 16384;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer->SetVSync = D3D12_SetVSync;
data->syncInterval = 0;
data->presentFlags = DXGI_PRESENT_ALLOW_TEARING;
/* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
* order to give init functions access to the underlying window handle:

33
src/render/metal/SDL_render_metal.m
View File

@@ -1829,17 +1829,25 @@ static int METAL_SetVSync(SDL_Renderer *renderer, const int vsync)
#if (defined(SDL_PLATFORM_MACOS) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST
if (@available(macOS 10.13, *)) {
METAL_RenderData *data = (__bridge METAL_RenderData *)renderer->driverdata;
if (vsync) {
data.mtllayer.displaySyncEnabled = YES;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
switch (vsync) {
case 0:
data.mtllayer.displaySyncEnabled = NO;
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
break;
case 1:
data.mtllayer.displaySyncEnabled = YES;
break;
default:
return SDL_Unsupported();
}
return 0;
}
#endif
return SDL_SetError("This Apple OS does not support displaySyncEnabled!");
switch (vsync) {
case 1:
return 0;
default:
return SDL_Unsupported();
}
}
static SDL_MetalView GetWindowView(SDL_Window *window)
@@ -2153,15 +2161,9 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
#if (defined(SDL_PLATFORM_MACOS) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST
if (@available(macOS 10.13, *)) {
data.mtllayer.displaySyncEnabled = SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE);
if (data.mtllayer.displaySyncEnabled) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
} else
#endif
{
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
data.mtllayer.displaySyncEnabled = NO;
}
#endif
/* https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf */
maxtexsize = 4096;
@@ -2197,8 +2199,7 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
}
#endif
renderer->info.max_texture_width = maxtexsize;
renderer->info.max_texture_height = maxtexsize;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, maxtexsize);
return 0;
}

43
src/render/opengl/SDL_render_gl.c
View File

@@ -1589,12 +1589,9 @@ static int GL_SetVSync(SDL_Renderer *renderer, const int vsync)
{
int retval;
int interval = 0;
if (vsync) {
retval = SDL_GL_SetSwapInterval(1);
} else {
retval = SDL_GL_SetSwapInterval(0);
}
if (retval != 0) {
retval = SDL_GL_SetSwapInterval(vsync);
if (retval < 0) {
return retval;
}
@@ -1602,13 +1599,10 @@ static int GL_SetVSync(SDL_Renderer *renderer, const int vsync)
if (retval < 0) {
return retval;
}
if (interval != 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
if (interval != vsync) {
return SDL_Unsupported();
}
return retval;
return 0;
}
static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
@@ -1678,7 +1672,6 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->SetVSync = GL_SetVSync;
renderer->info.flags = 0; /* will set some flags below. */
renderer->driverdata = data;
GL_InvalidateCachedState(renderer);
renderer->window = window;
@@ -1711,21 +1704,6 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
*/
#endif
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
{
int interval = 0;
if (SDL_GL_GetSwapInterval(&interval) < 0) {
/* Error */
} else if (interval != 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
}
/* Check for debug output support */
if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
(value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
@@ -1768,19 +1746,16 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
if (non_power_of_two_supported) {
data->GL_ARB_texture_non_power_of_two_supported = SDL_TRUE;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
renderer->info.max_texture_height = value;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
} else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
data->textype = GL_TEXTURE_RECTANGLE_ARB;
data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
renderer->info.max_texture_width = value;
renderer->info.max_texture_height = value;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
} else {
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
renderer->info.max_texture_height = value;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
}
/* Check for multitexture support */

54
src/render/opengles2/SDL_render_gles2.c
View File

@@ -2014,12 +2014,19 @@ static int GLES2_SetVSync(SDL_Renderer *renderer, const int vsync)
{
int retval;
int interval = 0;
if (vsync) {
retval = SDL_GL_SetSwapInterval(1);
} else {
retval = SDL_GL_SetSwapInterval(0);
#ifdef SDL_PLATFORM_WINRT
/* DLudwig, 2013-11-29: ANGLE for WinRT doesn't seem to work unless VSync
* is turned on. Not doing so will freeze the screen's contents to that
* of the first drawn frame.
*/
if (vsync == 0) {
return SDL_Unsupported();
}
if (retval != 0) {
#endif
retval = SDL_GL_SetSwapInterval(vsync);
if (retval < 0) {
return retval;
}
@@ -2027,13 +2034,10 @@ static int GLES2_SetVSync(SDL_Renderer *renderer, const int vsync)
if (retval < 0) {
return retval;
}
if (interval != 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
if (interval != vsync) {
return SDL_Unsupported();
}
return retval;
return 0;
}
/*************************************************************************************************
@@ -2117,29 +2121,6 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
goto error;
}
#ifdef SDL_PLATFORM_WINRT
/* DLudwig, 2013-11-29: ANGLE for WinRT doesn't seem to work unless VSync
* is turned on. Not doing so will freeze the screen's contents to that
* of the first drawn frame.
*/
SDL_SetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_TRUE);
#endif
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
{
int interval = 0;
if (SDL_GL_GetSwapInterval(&interval) < 0) {
/* Error */
} else if (interval != 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
}
/* Check for debug output support */
if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
(value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
@@ -2148,10 +2129,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
#if USE_VERTEX_BUFFER_OBJECTS
/* we keep a few of these and cycle through them, so data can live for a few frames. */

29
src/render/ps2/SDL_render_ps2.c
View File

@@ -54,7 +54,7 @@ typedef struct
uint64_t drawColor;
SDL_Rect *viewport;
int32_t vsync_callback_id;
uint8_t vsync; /* 0 (Disabled), 1 (Enabled), 2 (Dynamic) */
int vsync; /* 0 (Disabled), 1 (Enabled), -1 (Dynamic) */
} PS2_RenderData;
static int vsync_sema_id = 0;
@@ -544,7 +544,7 @@ static int PS2_RenderPresent(SDL_Renderer *renderer)
PS2_RenderData *data = (PS2_RenderData *)renderer->driverdata;
if (data->gsGlobal->DoubleBuffering == GS_SETTING_OFF) {
if (data->vsync == 2) { // Dynamic
if (data->vsync == -1) { // Dynamic
gsKit_sync(data->gsGlobal);
} else if (data->vsync == 1) {
gsKit_vsync_wait();
@@ -553,7 +553,7 @@ static int PS2_RenderPresent(SDL_Renderer *renderer)
} else {
gsKit_queue_exec(data->gsGlobal);
gsKit_finish();
if (data->vsync == 2) { // Dynamic
if (data->vsync == -1) { // Dynamic
gsKit_sync(data->gsGlobal);
} else if (data->vsync == 1) {
gsKit_vsync_wait();
@@ -607,8 +607,16 @@ static void PS2_DestroyRenderer(SDL_Renderer *renderer)
static int PS2_SetVSync(SDL_Renderer *renderer, const int vsync)
{
PS2_RenderData *data = (PS2_RenderData *)renderer->driverdata;
SDL_bool dynamicVsync = SDL_GetHintBoolean(SDL_HINT_RENDER_PS2_DYNAMIC_VSYNC, SDL_FALSE);
data->vsync = vsync ? (dynamicVsync ? 2 : 1) : 0;
switch (vsync) {
case -1:
case 0:
case 1:
// Supported
break;
default:
return SDL_Unsupported();
}
data->vsync = vsync;
return 0;
}
@@ -617,7 +625,6 @@ static int PS2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
PS2_RenderData *data;
GSGLOBAL *gsGlobal;
ee_sema_t sema;
SDL_bool dynamicVsync;
SDL_SetupRendererColorspace(renderer, create_props);
@@ -669,10 +676,6 @@ static int PS2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
gsKit_clear(gsGlobal, GS_BLACK);
data->gsGlobal = gsGlobal;
dynamicVsync = SDL_GetHintBoolean(SDL_HINT_RENDER_PS2_DYNAMIC_VSYNC, SDL_FALSE);
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
data->vsync = (dynamicVsync ? 2 : 1);
}
renderer->WindowEvent = PS2_WindowEvent;
renderer->CreateTexture = PS2_CreateTexture;
@@ -699,12 +702,8 @@ static int PS2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
renderer->info.name = PS2_RenderDriver.name;
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
renderer->info.max_texture_width = 1024;
renderer->info.max_texture_height = 1024;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 1024);
if (data->vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
return 0;
}

12
src/render/psp/SDL_render_psp.c
View File

@@ -1333,19 +1333,12 @@ static int PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR4444);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
renderer->info.max_texture_width = 512;
renderer->info.max_texture_height = 512;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 512);
data->initialized = SDL_TRUE;
data->most_recent_target = NULL;
data->least_recent_target = NULL;
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
data->vsync = SDL_TRUE;
} else {
data->vsync = SDL_FALSE;
}
pixelformat = PixelFormatToPSPFMT(SDL_GetWindowPixelFormat(window));
switch (pixelformat) {
case GU_PSM_4444:
@@ -1399,9 +1392,6 @@ static int PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, psp_on_vblank, data);
sceKernelEnableSubIntr(PSP_VBLANK_INT, 0);
if (data->vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
return 0;
}

2
src/render/software/SDL_render_sw.c
View File

@@ -1179,7 +1179,7 @@ static int SW_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
const SDL_bool no_hint_set = (!hint || !*hint);
if (no_hint_set) {
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0)) {
SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
} else {
SDL_SetHint(SDL_HINT_RENDER_VSYNC, "0");

12
src/render/vitagxm/SDL_render_vita_gxm.c
View File

@@ -185,10 +185,8 @@ static int VITA_GXM_SetVSync(SDL_Renderer *renderer, const int vsync)
VITA_GXM_RenderData *data = renderer->driverdata;
if (vsync) {
data->displayData.wait_vblank = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
data->displayData.wait_vblank = SDL_FALSE;
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
}
return 0;
}
@@ -246,18 +244,10 @@ static int VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, S
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
renderer->info.max_texture_width = 4096;
renderer->info.max_texture_height = 4096;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 4096);
data->initialized = SDL_TRUE;
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
data->displayData.wait_vblank = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
data->displayData.wait_vblank = SDL_FALSE;
}
#ifdef DEBUG_RAZOR
sceSysmoduleLoadModule(SCE_SYSMODULE_RAZOR_HUD);
sceSysmoduleLoadModule(SCE_SYSMODULE_RAZOR_CAPTURE);

27
src/render/vulkan/SDL_render_vulkan.c
View File

@@ -293,6 +293,7 @@ typedef struct
VkSurfaceCapabilitiesKHR surfaceCapabilities;
VkSurfaceFormatKHR *surfaceFormats;
SDL_bool recreateSwapchain;
int vsync;
VkFramebuffer *framebuffers;
VkRenderPass renderPasses[SDL_VULKAN_NUM_RENDERPASSES];
@@ -2091,7 +2092,7 @@ static VkResult VULKAN_CreateSwapChain(SDL_Renderer *renderer, int w, int h)
/* Choose a present mode. If vsync is requested, then use VK_PRESENT_MODE_FIFO_KHR which is guaranteed to be supported */
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
if (!(renderer->info.flags & SDL_RENDERER_PRESENTVSYNC)) {
if (!rendererData->vsync) {
uint32_t presentModeCount = 0;
result = vkGetPhysicalDeviceSurfacePresentModesKHR(rendererData->physicalDevice, rendererData->surface, &presentModeCount, NULL);
if (result != VK_SUCCESS) {
@@ -4024,13 +4025,16 @@ static int VULKAN_SetVSync(SDL_Renderer *renderer, const int vsync)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->driverdata;
Uint32 prevFlags = renderer->info.flags;
if (vsync) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} else {
renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
switch (vsync) {
case 0:
case 1:
/* Supported */
break;
default:
return SDL_Unsupported();
}
if (prevFlags != renderer->info.flags) {
if (vsync != rendererData->vsync) {
rendererData->vsync = vsync;
rendererData->recreateSwapchain = SDL_TRUE;
}
return 0;
@@ -4083,6 +4087,7 @@ static int VULKAN_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL
renderer->RenderPresent = VULKAN_RenderPresent;
renderer->DestroyTexture = VULKAN_DestroyTexture;
renderer->DestroyRenderer = VULKAN_DestroyRenderer;
renderer->SetVSync = VULKAN_SetVSync;
renderer->driverdata = rendererData;
VULKAN_InvalidateCachedState(renderer);
@@ -4091,13 +4096,7 @@ static int VULKAN_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR2101010);
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA64_FLOAT);
renderer->info.max_texture_width = 16384;
renderer->info.max_texture_height = 16384;
if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_BOOLEAN, SDL_FALSE)) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer->SetVSync = VULKAN_SetVSync;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
/* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
* order to give init functions access to the underlying window handle: