hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 1617

Browse Source
This commit is contained in:
pineappleEA
2021-04-20 21:40:33 +02:00
parent 242b6f6b49
commit f46563104f
510 changed files with 141726 additions and 62846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
externals/SDL/src/render/SDL_render.c vendored
View File

@@ -22,12 +22,11 @@
/* The SDL 2D rendering system */
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_log.h"
#include "SDL_render.h"
#include "SDL_sysrender.h"
#include "software/SDL_render_sw_c.h"
#include "../video/SDL_pixels_c.h"
#if defined(__ANDROID__)
# include "../core/android/SDL_android.h"
@@ -660,15 +659,17 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
event->motion.y -= (int)(viewport.y * renderer->dpi_scale.y);
event->motion.x = (int)(event->motion.x / (scale.x * renderer->dpi_scale.x));
event->motion.y = (int)(event->motion.y / (scale.y * renderer->dpi_scale.y));
if (event->motion.xrel > 0) {
event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
} else if (event->motion.xrel < 0) {
event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
if (event->motion.xrel != 0 && renderer->relative_scaling) {
float rel = renderer->xrel + event->motion.xrel / (scale.x * renderer->dpi_scale.x);
float trunc = SDL_truncf(rel);
renderer->xrel = rel - trunc;
event->motion.xrel = (Sint32) trunc;
}
if (event->motion.yrel > 0) {
event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
} else if (event->motion.yrel < 0) {
event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
if (event->motion.yrel != 0 && renderer->relative_scaling) {
float rel = renderer->yrel + event->motion.yrel / (scale.y * renderer->dpi_scale.y);
float trunc = SDL_truncf(rel);
renderer->yrel = rel - trunc;
event->motion.yrel = (Sint32) trunc;
}
}
}
@@ -686,40 +687,60 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
event->button.x = (int)(event->button.x / (scale.x * renderer->dpi_scale.x));
event->button.y = (int)(event->button.y / (scale.y * renderer->dpi_scale.y));
}
}
}
} else if (event->type == SDL_FINGERDOWN ||
event->type == SDL_FINGERUP ||
event->type == SDL_FINGERMOTION) {
int logical_w, logical_h;
float physical_w, physical_h;
SDL_Rect viewport;
SDL_FPoint scale;
GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
if (logical_w) {
/* !!! FIXME: we probably should drop events that are outside of the
!!! FIXME: viewport, but we can't do that from an event watcher,
!!! FIXME: and we would have to track if a touch happened outside
!!! FIXME: the viewport and then slid into it to insert extra
!!! FIXME: events, which is a mess, so for now we just clamp these
!!! FIXME: events to the edge. */
if (renderer->GetOutputSize) {
int w, h;
renderer->GetOutputSize(renderer, &w, &h);
physical_w = (float) w;
physical_h = (float) h;
} else {
int w, h;
SDL_GetWindowSize(renderer->window, &w, &h);
physical_w = ((float) w) * renderer->dpi_scale.x;
physical_h = ((float) h) * renderer->dpi_scale.y;
}
if (renderer->GetOutputSize) {
renderer->GetOutputSize(renderer, &w, &h);
if (physical_w == 0.0f) { /* nowhere for the touch to go, avoid division by zero and put it dead center. */
event->tfinger.x = 0.5f;
} else {
const float normalized_viewport_x = ((float) viewport.x) / physical_w;
const float normalized_viewport_w = ((float) viewport.w) / physical_w;
if (event->tfinger.x <= normalized_viewport_x) {
event->tfinger.x = 0.0f; /* to the left of the viewport, clamp to the edge. */
} else if (event->tfinger.x >= (normalized_viewport_x + normalized_viewport_w)) {
event->tfinger.x = 1.0f; /* to the right of the viewport, clamp to the edge. */
} else {
SDL_GetWindowSize(renderer->window, &w, &h);
event->tfinger.x = (event->tfinger.x - normalized_viewport_x) / normalized_viewport_w;
}
}
event->tfinger.x *= (w - 1);
event->tfinger.y *= (h - 1);
event->tfinger.x -= (viewport.x * renderer->dpi_scale.x);
event->tfinger.y -= (viewport.y * renderer->dpi_scale.y);
event->tfinger.x = (event->tfinger.x / (scale.x * renderer->dpi_scale.x));
event->tfinger.y = (event->tfinger.y / (scale.y * renderer->dpi_scale.y));
if (logical_w > 1) {
event->tfinger.x = event->tfinger.x / (logical_w - 1);
if (physical_h == 0.0f) { /* nowhere for the touch to go, avoid division by zero and put it dead center. */
event->tfinger.y = 0.5f;
} else {
const float normalized_viewport_y = ((float) viewport.y) / physical_h;
const float normalized_viewport_h = ((float) viewport.h) / physical_h;
if (event->tfinger.y <= normalized_viewport_y) {
event->tfinger.y = 0.0f; /* to the left of the viewport, clamp to the edge. */
} else if (event->tfinger.y >= (normalized_viewport_y + normalized_viewport_h)) {
event->tfinger.y = 1.0f; /* to the right of the viewport, clamp to the edge. */
} else {
event->tfinger.x = 0.5f;
}
if (logical_h > 1) {
event->tfinger.y = event->tfinger.y / (logical_h - 1);
} else {
event->tfinger.y = 0.5f;
event->tfinger.y = (event->tfinger.y - normalized_viewport_y) / normalized_viewport_h;
}
}
}
@@ -873,6 +894,8 @@ SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
}
}
renderer->relative_scaling = SDL_GetHintBoolean(SDL_HINT_MOUSE_RELATIVE_SCALING, SDL_TRUE);
if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {
renderer->hidden = SDL_TRUE;
} else {
@@ -1165,12 +1188,10 @@ SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
/* If Palette contains alpha values, promotes to alpha format */
if (fmt->palette) {
for (i = 0; i < fmt->palette->ncolors; i++) {
Uint8 alpha_value = fmt->palette->colors[i].a;
if (alpha_value != 0 && alpha_value != SDL_ALPHA_OPAQUE) {
needAlpha = SDL_TRUE;
break;
}
SDL_bool is_opaque, has_alpha_channel;
SDL_DetectPalette(fmt->palette, &is_opaque, &has_alpha_channel);
if (!is_opaque) {
needAlpha = SDL_TRUE;
}
}
@@ -1743,7 +1764,8 @@ SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect,
{
SDL_Rect real_rect;
void *pixels = NULL;
int pitch, ret;
int pitch = 0; /* fix static analysis */
int ret;
if (texture == NULL || surface == NULL) {
return -1;
@@ -1856,12 +1878,6 @@ SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
if (!SDL_RenderTargetSupported(renderer)) {
return SDL_Unsupported();
}
if (texture == renderer->target) {
/* Nothing to do! */
return 0;
}
FlushRenderCommands(renderer); /* time to send everything to the GPU! */
/* texture == NULL is valid and means reset the target to the window */
if (texture) {
@@ -1878,6 +1894,13 @@ SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
}
}
if (texture == renderer->target) {
/* Nothing to do! */
return 0;
}
FlushRenderCommands(renderer); /* time to send everything to the GPU! */
SDL_LockMutex(renderer->target_mutex);
if (texture && !renderer->target) {

7
externals/SDL/src/render/SDL_sysrender.h vendored
View File

@@ -189,6 +189,13 @@ struct SDL_Renderer
/* The pixel to point coordinate scale */
SDL_FPoint dpi_scale;
/* Whether or not to scale relative mouse motion */
SDL_bool relative_scaling;
/* Remainder from scaled relative motion */
float xrel;
float yrel;
/* The list of textures */
SDL_Texture *textures;
SDL_Texture *target;

1
externals/SDL/src/render/SDL_yuv_sw.c vendored
View File

@@ -24,7 +24,6 @@
#if SDL_HAVE_YUV
#include "SDL_assert.h"
#include "SDL_yuv_sw_c.h"

2
externals/SDL/src/render/direct3d/SDL_render_d3d.c vendored
View File

@@ -30,8 +30,6 @@
#include "SDL_hints.h"
#include "SDL_loadso.h"
#include "SDL_syswm.h"
#include "SDL_log.h"
#include "SDL_assert.h"
#include "../SDL_sysrender.h"
#include "../SDL_d3dmath.h"
#include "../../video/windows/SDL_windowsvideo.h"

18
externals/SDL/src/render/direct3d11/SDL_render_d3d11.c vendored
View File

@@ -2325,6 +2325,7 @@ D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
D3D11_RenderData * data = (D3D11_RenderData *) renderer->driverdata;
ID3D11RenderTargetView *renderTargetView = NULL;
ID3D11Texture2D *backBuffer = NULL;
ID3D11Texture2D *stagingTexture = NULL;
HRESULT result;
@@ -2334,14 +2335,15 @@ D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
D3D11_BOX srcBox;
D3D11_MAPPED_SUBRESOURCE textureMemory;
/* Retrieve a pointer to the back buffer: */
result = IDXGISwapChain_GetBuffer(data->swapChain,
0,
&SDL_IID_ID3D11Texture2D,
(void **)&backBuffer
);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::GetBuffer [get back buffer]"), result);
ID3D11DeviceContext_OMGetRenderTargets(data->d3dContext, 1, &renderTargetView, NULL);
if (renderTargetView == NULL) {
SDL_SetError("%s, ID3D11DeviceContext::OMGetRenderTargets failed", __FUNCTION__);
goto done;
}
ID3D11View_GetResource(renderTargetView, (ID3D11Resource**)&backBuffer);
if (backBuffer == NULL) {
SDL_SetError("%s, ID3D11View::GetResource failed", __FUNCTION__);
goto done;
}

99
externals/SDL/src/render/metal/SDL_render_metal.m vendored
View File

@@ -23,8 +23,6 @@
#if SDL_VIDEO_RENDER_METAL && !SDL_RENDER_DISABLED
#include "SDL_hints.h"
#include "SDL_log.h"
#include "SDL_assert.h"
#include "SDL_syswm.h"
#include "SDL_metal.h"
#include "../SDL_sysrender.h"
@@ -41,16 +39,27 @@
#ifdef __MACOSX__
#include "SDL_shaders_metal_osx.h"
#elif defined(__TVOS__)
#if TARGET_OS_SIMULATOR
#include "SDL_shaders_metal_tvsimulator.h"
#else
#include "SDL_shaders_metal_tvos.h"
#endif
#else
#if TARGET_OS_SIMULATOR
#include "SDL_shaders_metal_iphonesimulator.h"
#else
#include "SDL_shaders_metal_ios.h"
#endif
#endif
/* Apple Metal renderer implementation */
/* Used to re-create the window with Metal capability */
extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
/* macOS requires constants in a buffer to have a 256 byte alignment. */
/* Use native type alignments from https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf */
#ifdef __MACOSX__
#if defined(__MACOSX__) || TARGET_OS_SIMULATOR
#define CONSTANT_ALIGN(x) (256)
#else
#define CONSTANT_ALIGN(x) (x < 4 ? 4 : x)
@@ -1042,6 +1051,44 @@ METAL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
return 0;
}
static int
METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{
SDL_assert(count >= 2); /* should have been checked at the higher level. */
const size_t vertlen = (sizeof (float) * 2) * count;
float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
SDL_memcpy(verts, points, vertlen);
/* If the line segment is completely horizontal or vertical,
make it one pixel longer, to satisfy the diamond-exit rule.
We should probably do this for diagonal lines too, but we'd have to
do some trigonometry to figure out the correct pixel and generally
when we have problems with pixel perfection, it's for straight lines
that are missing a pixel that frames something and not arbitrary
angles. Maybe !!! FIXME for later, though. */
points += count - 2; /* update the last line. */
verts += (count * 2) - 2;
const float xstart = points[0].x;
const float ystart = points[0].y;
const float xend = points[1].x;
const float yend = points[1].y;
if (ystart == yend) { /* horizontal line */
verts[0] += (xend > xstart) ? 1.0f : -1.0f;
} else if (xstart == xend) { /* vertical line */
verts[1] += (yend > ystart) ? 1.0f : -1.0f;
}
return 0;
}
static int
METAL_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{
@@ -1516,15 +1563,21 @@ METAL_RenderPresent(SDL_Renderer * renderer)
{ @autoreleasepool {
METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
if (data.mtlcmdencoder != nil) {
[data.mtlcmdencoder endEncoding];
}
if (data.mtlbackbuffer != nil) {
[data.mtlcmdbuffer presentDrawable:data.mtlbackbuffer];
}
if (data.mtlcmdbuffer != nil) {
[data.mtlcmdbuffer commit];
// If we don't have a command buffer, we can't present, so activate to get one.
if (data.mtlcmdencoder == nil) {
// We haven't even gotten a backbuffer yet? Clear it to black. Otherwise, load the existing data.
if (data.mtlbackbuffer == nil) {
MTLClearColor color = MTLClearColorMake(0.0f, 0.0f, 0.0f, 1.0f);
METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &color, nil);
} else {
METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
}
}
[data.mtlcmdencoder endEncoding];
[data.mtlcmdbuffer presentDrawable:data.mtlbackbuffer];
[data.mtlcmdbuffer commit];
data.mtlcmdencoder = nil;
data.mtlcmdbuffer = nil;
data.mtlbackbuffer = nil;
@@ -1579,6 +1632,8 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_MetalView view = NULL;
CAMetalLayer *layer = nil;
SDL_SysWMinfo syswm;
Uint32 window_flags;
SDL_bool changed_window = SDL_FALSE;
SDL_VERSION(&syswm.version);
if (!SDL_GetWindowWMInfo(window, &syswm)) {
@@ -1589,9 +1644,20 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
return NULL;
}
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_METAL)) {
changed_window = SDL_TRUE;
if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_OPENGL)) | SDL_WINDOW_METAL) < 0) {
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
if (changed_window) {
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
@@ -1601,6 +1667,9 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
if (mtldevice == nil) {
SDL_free(renderer);
SDL_SetError("Failed to obtain Metal device");
if (changed_window) {
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
@@ -1611,6 +1680,9 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
[mtldevice release];
#endif
SDL_free(renderer);
if (changed_window) {
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
@@ -1623,6 +1695,9 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
#endif
SDL_Metal_DestroyView(view);
SDL_free(renderer);
if (changed_window) {
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
@@ -1783,7 +1858,7 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->QueueSetViewport = METAL_QueueSetViewport;
renderer->QueueSetDrawColor = METAL_QueueSetDrawColor;
renderer->QueueDrawPoints = METAL_QueueDrawPoints;
renderer->QueueDrawLines = METAL_QueueDrawPoints; // lines and points queue the same way.
renderer->QueueDrawLines = METAL_QueueDrawLines;
renderer->QueueFillRects = METAL_QueueFillRects;
renderer->QueueCopy = METAL_QueueCopy;
renderer->QueueCopyEx = METAL_QueueCopyEx;

3071
externals/SDL/src/render/metal/SDL_shaders_metal_ios.h vendored
View File

File diff suppressed because it is too large Load Diff

2086
externals/SDL/src/render/metal/SDL_shaders_metal_iphonesimulator.h vendored Executable file
View File

File diff suppressed because it is too large Load Diff

3375
externals/SDL/src/render/metal/SDL_shaders_metal_osx.h vendored
View File

File diff suppressed because it is too large Load Diff

3071
externals/SDL/src/render/metal/SDL_shaders_metal_tvos.h vendored
View File

File diff suppressed because it is too large Load Diff

2089
externals/SDL/src/render/metal/SDL_shaders_metal_tvsimulator.h vendored Executable file
View File

File diff suppressed because it is too large Load Diff

4
externals/SDL/src/render/metal/build-metal-shaders.sh vendored
View File

@@ -6,7 +6,7 @@ cd `dirname "$0"`
generate_shaders()
{
fileplatform=$1
fileplatform=$1
compileplatform=$2
sdkplatform=$3
minversion=$4
@@ -19,4 +19,6 @@ generate_shaders()
generate_shaders osx osx macosx 10.11
generate_shaders ios ios iphoneos 8.0
generate_shaders iphonesimulator ios iphonesimulator 8.0
generate_shaders tvos ios appletvos 9.0
generate_shaders tvsimulator ios appletvsimulator 9.0

122
externals/SDL/src/render/opengl/SDL_render_gl.c vendored
View File

@@ -23,8 +23,6 @@
#if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
#include "SDL_hints.h"
#include "SDL_log.h"
#include "SDL_assert.h"
#include "SDL_opengl.h"
#include "../SDL_sysrender.h"
#include "SDL_shaders_gl.h"
@@ -585,7 +583,6 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
renderdata->glGenTextures(1, &data->utexture);
renderdata->glGenTextures(1, &data->vtexture);
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->utexture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
@@ -610,8 +607,6 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
GL_CLAMP_TO_EDGE);
renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w+1)/2,
(texture_h+1)/2, 0, format, type, NULL);
renderdata->glDisable(textype);
}
if (texture->format == SDL_PIXELFORMAT_NV12 ||
@@ -619,8 +614,6 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
data->nv12 = SDL_TRUE;
renderdata->glGenTextures(1, &data->utexture);
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->utexture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
scaleMode);
@@ -632,7 +625,6 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
GL_CLAMP_TO_EDGE);
renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w+1)/2,
(texture_h+1)/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
renderdata->glDisable(textype);
}
return GL_CheckError("", renderer);
@@ -653,7 +645,6 @@ GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
renderdata->drawstate.texture = NULL; /* we trash this state. */
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->texture);
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / texturebpp));
@@ -696,7 +687,6 @@ GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
(rect->w + 1)/2, (rect->h + 1)/2,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixels);
}
renderdata->glDisable(textype);
return GL_CheckError("glTexSubImage2D()", renderer);
}
@@ -716,7 +706,6 @@ GL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
renderdata->drawstate.texture = NULL; /* we trash this state. */
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->texture);
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
@@ -735,7 +724,6 @@ GL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
(rect->w + 1)/2, (rect->h + 1)/2,
data->format, data->formattype, Vplane);
renderdata->glDisable(textype);
return GL_CheckError("glTexSubImage2D()", renderer);
}
@@ -776,15 +764,12 @@ GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Scale
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->texture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
renderdata->glDisable(textype);
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV) {
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->utexture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
@@ -792,16 +777,13 @@ GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Scale
renderdata->glBindTexture(textype, data->vtexture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
renderdata->glDisable(textype);
}
if (texture->format == SDL_PIXELFORMAT_NV12 ||
texture->format == SDL_PIXELFORMAT_NV21) {
renderdata->glEnable(textype);
renderdata->glBindTexture(textype, data->utexture);
renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
renderdata->glDisable(textype);
}
}
@@ -865,6 +847,48 @@ GL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FP
return 0;
}
static int
GL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{
int i;
const size_t vertlen = (sizeof (GLfloat) * 2) * count;
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
/* Offset to hit the center of the pixel. */
for (i = 0; i < count; i++) {
*(verts++) = 0.5f + points[i].x;
*(verts++) = 0.5f + points[i].y;
}
/* Make the last line segment one pixel longer, to satisfy the
diamond-exit rule. */
verts -= 4;
{
const GLfloat xstart = verts[0];
const GLfloat ystart = verts[1];
const GLfloat xend = verts[2];
const GLfloat yend = verts[3];
if (ystart == yend) { /* horizontal line */
verts[2] += (xend > xstart) ? 1.0f : -1.0f;
} else if (xstart == xend) { /* vertical line */
verts[3] += (yend > ystart) ? 1.0f : -1.0f;
} else { /* bump a pixel in the direction we are moving in. */
const GLfloat deltax = xend - xstart;
const GLfloat deltay = yend - ystart;
const GLfloat angle = SDL_atan2f(deltay, deltax);
verts[2] += SDL_cosf(angle);
verts[3] += SDL_sinf(angle);
}
}
return 0;
}
static int
GL_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{
@@ -1228,59 +1252,13 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
case SDL_RENDERCMD_DRAW_LINES: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
const size_t count = cmd->data.draw.count;
SDL_assert(count >= 2);
SetDrawState(data, cmd, SHADER_SOLID);
if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
data->glBegin(GL_LINE_LOOP);
/* GL_LINE_LOOP takes care of the final segment */
for (i = 1; i < count; ++i, verts += 2) {
data->glVertex2f(verts[0], verts[1]);
}
data->glEnd();
} else {
#if defined(__MACOSX__) || defined(__WIN32__)
#else
int x1, y1, x2, y2;
#endif
data->glBegin(GL_LINE_STRIP);
for (i = 0; i < count; ++i, verts += 2) {
data->glVertex2f(verts[0], verts[1]);
}
data->glEnd();
verts -= 2 * count;
/* The line is half open, so we need one more point to complete it.
* http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node47.html
* If we have to, we can use vertical line and horizontal line textures
* for vertical and horizontal lines, and then create custom textures
* for diagonal lines and software render those. It's terrible, but at
* least it would be pixel perfect.
*/
data->glBegin(GL_POINTS);
#if defined(__MACOSX__) || defined(__WIN32__)
/* Mac OS X and Windows seem to always leave the last point open */
data->glVertex2f(verts[(count-1)*2], verts[(count*2)-1]);
#else
/* Linux seems to leave the right-most or bottom-most point open */
x1 = verts[0];
y1 = verts[1];
x2 = verts[(count-1)*2];
y2 = verts[(count*2)-1];
if (x1 > x2) {
data->glVertex2f(x1, y1);
} else if (x2 > x1) {
data->glVertex2f(x2, y2);
}
if (y1 > y2) {
data->glVertex2f(x1, y1);
} else if (y2 > y1) {
data->glVertex2f(x2, y2);
}
#endif
data->glEnd();
data->glBegin(GL_LINE_STRIP);
for (i = 0; i < count; ++i, verts += 2) {
data->glVertex2f(verts[0], verts[1]);
}
data->glEnd();
break;
}
@@ -1566,7 +1544,7 @@ GL_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
}
SDL_Renderer *
static SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
@@ -1589,7 +1567,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
@@ -1619,7 +1597,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->QueueSetViewport = GL_QueueSetViewport;
renderer->QueueSetDrawColor = GL_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
renderer->QueueDrawPoints = GL_QueueDrawPoints;
renderer->QueueDrawLines = GL_QueueDrawPoints; /* lines and points queue vertices the same way. */
renderer->QueueDrawLines = GL_QueueDrawLines;
renderer->QueueFillRects = GL_QueueFillRects;
renderer->QueueCopy = GL_QueueCopy;
renderer->QueueCopyEx = GL_QueueCopyEx;

1
externals/SDL/src/render/opengl/SDL_shaders_gl.c vendored
View File

@@ -23,7 +23,6 @@
#if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
#include "SDL_stdinc.h"
#include "SDL_log.h"
#include "SDL_opengl.h"
#include "SDL_video.h"
#include "SDL_shaders_gl.h"

57
externals/SDL/src/render/opengles/SDL_render_gles.c vendored
View File

@@ -22,7 +22,6 @@
#if SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_opengles.h"
#include "../SDL_sysrender.h"
@@ -561,6 +560,48 @@ GLES_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_
return 0;
}
static int
GLES_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{
int i;
const size_t vertlen = (sizeof (GLfloat) * 2) * count;
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
/* Offset to hit the center of the pixel. */
for (i = 0; i < count; i++) {
*(verts++) = 0.5f + points[i].x;
*(verts++) = 0.5f + points[i].y;
}
/* Make the last line segment one pixel longer, to satisfy the
diamond-exit rule. */
verts -= 4;
{
const GLfloat xstart = verts[0];
const GLfloat ystart = verts[1];
const GLfloat xend = verts[2];
const GLfloat yend = verts[3];
if (ystart == yend) { /* horizontal line */
verts[2] += (xend > xstart) ? 1.0f : -1.0f;
} else if (xstart == xend) { /* vertical line */
verts[3] += (yend > ystart) ? 1.0f : -1.0f;
} else { /* bump a pixel in the direction we are moving in. */
const GLfloat deltax = xend - xstart;
const GLfloat deltay = yend - ystart;
const GLfloat angle = SDL_atan2f(deltay, deltax);
verts[2] += SDL_cosf(angle);
verts[3] += SDL_sinf(angle);
}
}
return 0;
}
static int
GLES_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{
@@ -901,16 +942,10 @@ GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vert
case SDL_RENDERCMD_DRAW_LINES: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
const size_t count = cmd->data.draw.count;
SDL_assert(count >= 2);
SetDrawState(data, cmd);
data->glVertexPointer(2, GL_FLOAT, 0, verts);
if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
/* GL_LINE_LOOP takes care of the final segment */
data->glDrawArrays(GL_LINE_LOOP, 0, (GLsizei) (count - 1));
} else {
data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
/* We need to close the endpoint of the line */
data->glDrawArrays(GL_POINTS, (GLsizei) (count - 1), 1);
}
data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
break;
}
@@ -1129,7 +1164,7 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
@@ -1159,7 +1194,7 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->QueueSetViewport = GLES_QueueSetViewport;
renderer->QueueSetDrawColor = GLES_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
renderer->QueueDrawPoints = GLES_QueueDrawPoints;
renderer->QueueDrawLines = GLES_QueueDrawPoints; /* lines and points queue vertices the same way. */
renderer->QueueDrawLines = GLES_QueueDrawLines;
renderer->QueueFillRects = GLES_QueueFillRects;
renderer->QueueCopy = GLES_QueueCopy;
renderer->QueueCopyEx = GLES_QueueCopyEx;

58
externals/SDL/src/render/opengles2/SDL_render_gles2.c vendored
View File

@@ -22,7 +22,6 @@
#if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_opengles2.h"
#include "../SDL_sysrender.h"
@@ -783,6 +782,48 @@ GLES2_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
return 0;
}
static int
GLES2_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
{
int i;
const size_t vertlen = (sizeof (GLfloat) * 2) * count;
GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
if (!verts) {
return -1;
}
cmd->data.draw.count = count;
/* Offset to hit the center of the pixel. */
for (i = 0; i < count; i++) {
*(verts++) = 0.5f + points[i].x;
*(verts++) = 0.5f + points[i].y;
}
/* Make the last line segment one pixel longer, to satisfy the
diamond-exit rule. */
verts -= 4;
{
const GLfloat xstart = verts[0];
const GLfloat ystart = verts[1];
const GLfloat xend = verts[2];
const GLfloat yend = verts[3];
if (ystart == yend) { /* horizontal line */
verts[2] += (xend > xstart) ? 1.0f : -1.0f;
} else if (xstart == xend) { /* vertical line */
verts[3] += (yend > ystart) ? 1.0f : -1.0f;
} else { /* bump a pixel in the direction we are moving in. */
const GLfloat deltax = xend - xstart;
const GLfloat deltay = yend - ystart;
const GLfloat angle = SDL_atan2f(deltay, deltax);
verts[2] += SDL_cosf(angle);
verts[3] += SDL_sinf(angle);
}
}
return 0;
}
static int
GLES2_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{
@@ -1294,17 +1335,10 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
}
case SDL_RENDERCMD_DRAW_LINES: {
const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
const size_t count = cmd->data.draw.count;
SDL_assert(count >= 2);
if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) {
if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
/* GL_LINE_LOOP takes care of the final segment */
data->glDrawArrays(GL_LINE_LOOP, 0, (GLsizei) (count - 1));
} else {
data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
/* We need to close the endpoint of the line */
data->glDrawArrays(GL_POINTS, (GLsizei) (count - 1), 1);
}
data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
}
break;
}
@@ -1977,7 +2011,7 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
if (SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
@@ -2099,7 +2133,7 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
renderer->QueueSetViewport = GLES2_QueueSetViewport;
renderer->QueueSetDrawColor = GLES2_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
renderer->QueueDrawPoints = GLES2_QueueDrawPoints;
renderer->QueueDrawLines = GLES2_QueueDrawPoints; /* lines and points queue vertices the same way. */
renderer->QueueDrawLines = GLES2_QueueDrawLines;
renderer->QueueFillRects = GLES2_QueueFillRects;
renderer->QueueCopy = GLES2_QueueCopy;
renderer->QueueCopyEx = GLES2_QueueCopyEx;

1
externals/SDL/src/render/psp/SDL_render_psp.c vendored
View File

@@ -23,7 +23,6 @@
#if SDL_VIDEO_RENDER_PSP
#include "SDL_hints.h"
#include "SDL_assert.h"
#include "../SDL_sysrender.h"
#include <pspkernel.h>

1
externals/SDL/src/render/software/SDL_render_sw.c vendored
View File

@@ -25,7 +25,6 @@
#include "../SDL_sysrender.h"
#include "SDL_render_sw_c.h"
#include "SDL_hints.h"
#include "SDL_assert.h"
#include "SDL_draw.h"
#include "SDL_blendfillrect.h"