src/render/SDL_render.c
author David Ludwig <dludwig@pobox.com>
Tue, 13 Aug 2013 20:09:52 -0400
changeset 8478 337b5dc0797b
parent 8477 ad08f0d710f3
child 8535 e8ee0708ef5c
permissions -rw-r--r--
WinRT: build fixes and additional WinRT-related integrations with SDL 2.0.0
slouken@5154
     1
/*
slouken@5535
     2
  Simple DirectMedia Layer
slouken@6885
     3
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
slouken@5154
     4
slouken@5535
     5
  This software is provided 'as-is', without any express or implied
slouken@5535
     6
  warranty.  In no event will the authors be held liable for any damages
slouken@5535
     7
  arising from the use of this software.
slouken@5154
     8
slouken@5535
     9
  Permission is granted to anyone to use this software for any purpose,
slouken@5535
    10
  including commercial applications, and to alter it and redistribute it
slouken@5535
    11
  freely, subject to the following restrictions:
slouken@5154
    12
slouken@5535
    13
  1. The origin of this software must not be misrepresented; you must not
slouken@5535
    14
     claim that you wrote the original software. If you use this software
slouken@5535
    15
     in a product, an acknowledgment in the product documentation would be
slouken@5535
    16
     appreciated but is not required.
slouken@5535
    17
  2. Altered source versions must be plainly marked as such, and must not be
slouken@5535
    18
     misrepresented as being the original software.
slouken@5535
    19
  3. This notice may not be removed or altered from any source distribution.
slouken@5154
    20
*/
slouken@5154
    21
#include "SDL_config.h"
slouken@5154
    22
slouken@5154
    23
/* The SDL 2D rendering system */
slouken@5154
    24
slouken@5192
    25
#include "SDL_hints.h"
slouken@5221
    26
#include "SDL_log.h"
slouken@5154
    27
#include "SDL_render.h"
slouken@5154
    28
#include "SDL_sysrender.h"
slouken@5195
    29
#include "software/SDL_render_sw_c.h"
slouken@5154
    30
slouken@5154
    31
slouken@5528
    32
#define SDL_WINDOWRENDERDATA    "_SDL_WindowRenderData"
slouken@5528
    33
slouken@5154
    34
#define CHECK_RENDERER_MAGIC(renderer, retval) \
slouken@5154
    35
    if (!renderer || renderer->magic != &renderer_magic) { \
slouken@5154
    36
        SDL_SetError("Invalid renderer"); \
slouken@5154
    37
        return retval; \
slouken@5154
    38
    }
slouken@5154
    39
slouken@5154
    40
#define CHECK_TEXTURE_MAGIC(texture, retval) \
slouken@5154
    41
    if (!texture || texture->magic != &texture_magic) { \
slouken@5154
    42
        SDL_SetError("Invalid texture"); \
slouken@5154
    43
        return retval; \
slouken@5154
    44
    }
slouken@5154
    45
slouken@5154
    46
slouken@7109
    47
#if !SDL_RENDER_DISABLED
slouken@5154
    48
static const SDL_RenderDriver *render_drivers[] = {
slouken@5154
    49
#if SDL_VIDEO_RENDER_D3D
slouken@5154
    50
    &D3D_RenderDriver,
slouken@5154
    51
#endif
dludwig@8478
    52
#if SDL_VIDEO_RENDER_D3D11
dludwig@8478
    53
    &D3D11_RenderDriver,
dludwig@8478
    54
#endif
slouken@5154
    55
#if SDL_VIDEO_RENDER_OGL
slouken@5154
    56
    &GL_RenderDriver,
slouken@5154
    57
#endif
slouken@5209
    58
#if SDL_VIDEO_RENDER_OGL_ES2
slouken@5209
    59
    &GLES2_RenderDriver,
slouken@5209
    60
#endif
slouken@5154
    61
#if SDL_VIDEO_RENDER_OGL_ES
slouken@5201
    62
    &GLES_RenderDriver,
slouken@5201
    63
#endif
slouken@5199
    64
#if SDL_VIDEO_RENDER_DIRECTFB
slouken@5199
    65
    &DirectFB_RenderDriver,
slouken@5199
    66
#endif
kimonline@7009
    67
#if SDL_VIDEO_RENDER_PSP
kimonline@7009
    68
    &PSP_RenderDriver,
kimonline@7009
    69
#endif
slouken@5154
    70
    &SW_RenderDriver
slouken@7109
    71
};
slouken@5226
    72
#endif /* !SDL_RENDER_DISABLED */
slouken@7109
    73
slouken@5154
    74
static char renderer_magic;
slouken@5154
    75
static char texture_magic;
slouken@5154
    76
slouken@6530
    77
static int UpdateLogicalSize(SDL_Renderer *renderer);
slouken@6530
    78
slouken@5154
    79
int
slouken@5154
    80
SDL_GetNumRenderDrivers(void)
slouken@5154
    81
{
slouken@7109
    82
#if !SDL_RENDER_DISABLED
slouken@5154
    83
    return SDL_arraysize(render_drivers);
slouken@7109
    84
#else
slouken@7109
    85
    return 0;
slouken@7109
    86
#endif
slouken@5154
    87
}
slouken@5154
    88
slouken@5154
    89
int
slouken@5154
    90
SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
slouken@5154
    91
{
slouken@7109
    92
#if !SDL_RENDER_DISABLED
slouken@5154
    93
    if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
icculus@7037
    94
        return SDL_SetError("index must be in the range of 0 - %d",
icculus@7037
    95
                            SDL_GetNumRenderDrivers() - 1);
slouken@5154
    96
    }
slouken@5154
    97
    *info = render_drivers[index]->info;
slouken@5154
    98
    return 0;
slouken@7109
    99
#else
slouken@7109
   100
    return SDL_SetError("SDL not built with rendering support");
slouken@7109
   101
#endif
slouken@5154
   102
}
slouken@5154
   103
slouken@5154
   104
static int
slouken@5154
   105
SDL_RendererEventWatch(void *userdata, SDL_Event *event)
slouken@5154
   106
{
slouken@5154
   107
    SDL_Renderer *renderer = (SDL_Renderer *)userdata;
slouken@5154
   108
slouken@5297
   109
    if (event->type == SDL_WINDOWEVENT) {
slouken@5154
   110
        SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
slouken@5154
   111
        if (window == renderer->window) {
slouken@5297
   112
            if (renderer->WindowEvent) {
slouken@5297
   113
                renderer->WindowEvent(renderer, &event->window);
slouken@5297
   114
            }
slouken@5297
   115
slouken@7240
   116
            if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
slouken@6530
   117
                if (renderer->logical_w) {
slouken@6530
   118
                    UpdateLogicalSize(renderer);
slouken@7240
   119
                } else {
slouken@7240
   120
                    /* Window was resized, reset viewport */
slouken@6528
   121
                    int w, h;
slouken@6528
   122
slouken@6260
   123
                    SDL_GetWindowSize(window, &w, &h);
slouken@6260
   124
                    if (renderer->target) {
slouken@6260
   125
                        renderer->viewport_backup.x = 0;
slouken@6260
   126
                        renderer->viewport_backup.y = 0;
slouken@6260
   127
                        renderer->viewport_backup.w = w;
slouken@6260
   128
                        renderer->viewport_backup.h = h;
slouken@6260
   129
                    } else {
slouken@6528
   130
                        renderer->viewport.x = 0;
slouken@6528
   131
                        renderer->viewport.y = 0;
slouken@6528
   132
                        renderer->viewport.w = w;
slouken@6528
   133
                        renderer->viewport.h = h;
slouken@6528
   134
                        renderer->UpdateViewport(renderer);
slouken@6260
   135
                    }
slouken@6260
   136
                }
slouken@6260
   137
            } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {
slouken@6260
   138
                renderer->hidden = SDL_TRUE;
slouken@6260
   139
            } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {
slouken@6260
   140
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {
slouken@6260
   141
                    renderer->hidden = SDL_FALSE;
slouken@6260
   142
                }
slouken@6060
   143
            } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
slouken@6260
   144
                renderer->hidden = SDL_TRUE;
slouken@6060
   145
            } else if (event->window.event == SDL_WINDOWEVENT_RESTORED) {
slouken@6260
   146
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
slouken@6260
   147
                    renderer->hidden = SDL_FALSE;
slouken@6260
   148
                }
slouken@5297
   149
            }
slouken@5154
   150
        }
slouken@6530
   151
    } else if (event->type == SDL_MOUSEMOTION) {
slouken@6530
   152
        if (renderer->logical_w) {
slouken@6530
   153
            event->motion.x -= renderer->viewport.x;
slouken@6530
   154
            event->motion.y -= renderer->viewport.y;
slouken@6530
   155
            event->motion.x = (int)(event->motion.x / renderer->scale.x);
slouken@6530
   156
            event->motion.y = (int)(event->motion.y / renderer->scale.y);
slouken@7496
   157
            if (event->motion.xrel > 0) {
slouken@7496
   158
                event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / renderer->scale.x));
slouken@7496
   159
            } else if (event->motion.xrel < 0) {
slouken@7496
   160
                event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / renderer->scale.x));
slouken@7496
   161
            }
slouken@7496
   162
            if (event->motion.yrel > 0) {
slouken@7496
   163
                event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / renderer->scale.y));
slouken@7496
   164
            } else if (event->motion.yrel < 0) {
slouken@7496
   165
                event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / renderer->scale.y));
slouken@7496
   166
            }
slouken@6530
   167
        }
slouken@6530
   168
    } else if (event->type == SDL_MOUSEBUTTONDOWN ||
slouken@6530
   169
               event->type == SDL_MOUSEBUTTONUP) {
slouken@6530
   170
        if (renderer->logical_w) {
slouken@6530
   171
            event->button.x -= renderer->viewport.x;
slouken@6530
   172
            event->button.y -= renderer->viewport.y;
slouken@6530
   173
            event->button.x = (int)(event->button.x / renderer->scale.x);
slouken@6530
   174
            event->button.y = (int)(event->button.y / renderer->scale.y);
slouken@6530
   175
        }
slouken@5154
   176
    }
slouken@5154
   177
    return 0;
slouken@5154
   178
}
slouken@5154
   179
slouken@6258
   180
int
slouken@6258
   181
SDL_CreateWindowAndRenderer(int width, int height, Uint32 window_flags,
slouken@6258
   182
                            SDL_Window **window, SDL_Renderer **renderer)
slouken@6258
   183
{
slouken@6258
   184
    *window = SDL_CreateWindow(NULL, SDL_WINDOWPOS_UNDEFINED,
slouken@6258
   185
                                     SDL_WINDOWPOS_UNDEFINED,
slouken@6258
   186
                                     width, height, window_flags);
slouken@6258
   187
    if (!*window) {
slouken@6258
   188
        *renderer = NULL;
slouken@6258
   189
        return -1;
slouken@6258
   190
    }
slouken@6258
   191
slouken@6258
   192
    *renderer = SDL_CreateRenderer(*window, -1, 0);
slouken@6258
   193
    if (!*renderer) {
slouken@6258
   194
        return -1;
slouken@6258
   195
    }
slouken@6258
   196
slouken@6258
   197
    return 0;
slouken@6258
   198
}
slouken@6258
   199
slouken@5154
   200
SDL_Renderer *
slouken@5154
   201
SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
slouken@5154
   202
{
slouken@7109
   203
#if !SDL_RENDER_DISABLED
slouken@5154
   204
    SDL_Renderer *renderer = NULL;
slouken@5154
   205
    int n = SDL_GetNumRenderDrivers();
slouken@5192
   206
    const char *hint;
slouken@5192
   207
slouken@5528
   208
    if (!window) {
slouken@5528
   209
        SDL_SetError("Invalid window");
slouken@5528
   210
        return NULL;
slouken@5528
   211
    }
slouken@5528
   212
slouken@5528
   213
    if (SDL_GetRenderer(window)) {
slouken@5528
   214
        SDL_SetError("Renderer already associated with window");
slouken@5528
   215
        return NULL;
slouken@5528
   216
    }
slouken@5528
   217
slouken@5192
   218
    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
slouken@5192
   219
    if (hint) {
slouken@5192
   220
        if (*hint == '0') {
slouken@5192
   221
            flags &= ~SDL_RENDERER_PRESENTVSYNC;
slouken@5192
   222
        } else {
slouken@5192
   223
            flags |= SDL_RENDERER_PRESENTVSYNC;
slouken@5192
   224
        }
slouken@5192
   225
    }
slouken@5154
   226
slouken@5154
   227
    if (index < 0) {
slouken@5192
   228
        hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);
slouken@5192
   229
        if (hint) {
slouken@5154
   230
            for (index = 0; index < n; ++index) {
slouken@5154
   231
                const SDL_RenderDriver *driver = render_drivers[index];
slouken@5154
   232
slouken@5192
   233
                if (SDL_strcasecmp(hint, driver->info.name) == 0) {
slouken@5154
   234
                    /* Create a new renderer instance */
slouken@5154
   235
                    renderer = driver->CreateRenderer(window, flags);
slouken@5154
   236
                    break;
slouken@5154
   237
                }
slouken@5154
   238
            }
slouken@5192
   239
        }
slouken@5192
   240
slouken@5192
   241
        if (!renderer) {
slouken@5154
   242
            for (index = 0; index < n; ++index) {
slouken@5154
   243
                const SDL_RenderDriver *driver = render_drivers[index];
slouken@5154
   244
slouken@5154
   245
                if ((driver->info.flags & flags) == flags) {
slouken@5154
   246
                    /* Create a new renderer instance */
slouken@5154
   247
                    renderer = driver->CreateRenderer(window, flags);
slouken@5154
   248
                    if (renderer) {
slouken@5154
   249
                        /* Yay, we got one! */
slouken@5154
   250
                        break;
slouken@5154
   251
                    }
slouken@5154
   252
                }
slouken@5154
   253
            }
slouken@5154
   254
        }
slouken@5154
   255
        if (index == n) {
slouken@5154
   256
            SDL_SetError("Couldn't find matching render driver");
slouken@5154
   257
            return NULL;
slouken@5154
   258
        }
slouken@5154
   259
    } else {
slouken@5154
   260
        if (index >= SDL_GetNumRenderDrivers()) {
slouken@5154
   261
            SDL_SetError("index must be -1 or in the range of 0 - %d",
slouken@5154
   262
                         SDL_GetNumRenderDrivers() - 1);
slouken@5154
   263
            return NULL;
slouken@5154
   264
        }
slouken@5154
   265
        /* Create a new renderer instance */
slouken@5154
   266
        renderer = render_drivers[index]->CreateRenderer(window, flags);
slouken@5154
   267
    }
slouken@5154
   268
slouken@5154
   269
    if (renderer) {
slouken@5154
   270
        renderer->magic = &renderer_magic;
slouken@5166
   271
        renderer->window = window;
slouken@6528
   272
        renderer->scale.x = 1.0f;
slouken@6528
   273
        renderer->scale.y = 1.0f;
slouken@5154
   274
slouken@6260
   275
        if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {
slouken@6260
   276
            renderer->hidden = SDL_TRUE;
slouken@6060
   277
        } else {
slouken@6260
   278
            renderer->hidden = SDL_FALSE;
slouken@6060
   279
        }
slouken@6060
   280
slouken@5528
   281
        SDL_SetWindowData(window, SDL_WINDOWRENDERDATA, renderer);
slouken@5528
   282
slouken@5297
   283
        SDL_RenderSetViewport(renderer, NULL);
slouken@5297
   284
slouken@5154
   285
        SDL_AddEventWatch(SDL_RendererEventWatch, renderer);
slouken@5221
   286
slouken@5221
   287
        SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
slouken@5221
   288
                    "Created renderer: %s", renderer->info.name);
slouken@5154
   289
    }
slouken@5154
   290
    return renderer;
slouken@7109
   291
#else
slouken@7109
   292
    SDL_SetError("SDL not built with rendering support");
slouken@7109
   293
    return NULL;
slouken@7109
   294
#endif
slouken@5154
   295
}
slouken@5154
   296
slouken@5166
   297
SDL_Renderer *
slouken@5166
   298
SDL_CreateSoftwareRenderer(SDL_Surface * surface)
slouken@5166
   299
{
slouken@5226
   300
#if !SDL_RENDER_DISABLED
slouken@5297
   301
    SDL_Renderer *renderer;
slouken@5297
   302
slouken@5297
   303
    renderer = SW_CreateRendererForSurface(surface);
slouken@5297
   304
slouken@5297
   305
    if (renderer) {
slouken@5297
   306
        renderer->magic = &renderer_magic;
slouken@6532
   307
        renderer->scale.x = 1.0f;
slouken@6532
   308
        renderer->scale.y = 1.0f;
slouken@5297
   309
slouken@5297
   310
        SDL_RenderSetViewport(renderer, NULL);
slouken@5297
   311
    }
slouken@5297
   312
    return renderer;
slouken@5226
   313
#else
slouken@5226
   314
    SDL_SetError("SDL not built with rendering support");
slouken@5226
   315
    return NULL;
slouken@5226
   316
#endif /* !SDL_RENDER_DISABLED */
slouken@5166
   317
}
slouken@5166
   318
slouken@5528
   319
SDL_Renderer *
slouken@5528
   320
SDL_GetRenderer(SDL_Window * window)
slouken@5528
   321
{
slouken@5528
   322
    return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);
slouken@5528
   323
}
slouken@5528
   324
slouken@5154
   325
int
slouken@5154
   326
SDL_GetRendererInfo(SDL_Renderer * renderer, SDL_RendererInfo * info)
slouken@5154
   327
{
slouken@5154
   328
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
   329
slouken@5154
   330
    *info = renderer->info;
slouken@5154
   331
    return 0;
slouken@5154
   332
}
slouken@5154
   333
slouken@7239
   334
int
slouken@7239
   335
SDL_GetRendererOutputSize(SDL_Renderer * renderer, int *w, int *h)
slouken@7239
   336
{
slouken@7239
   337
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@7239
   338
slouken@7239
   339
    if (renderer->target) {
slouken@7239
   340
        return SDL_QueryTexture(renderer->target, NULL, NULL, w, h);
slouken@7239
   341
    } else if (renderer->window) {
slouken@7239
   342
        SDL_GetWindowSize(renderer->window, w, h);
slouken@7239
   343
        return 0;
slouken@7239
   344
    } else if (renderer->GetOutputSize) {
slouken@7239
   345
        return renderer->GetOutputSize(renderer, w, h);
slouken@7239
   346
    } else {
slouken@7239
   347
        /* This should never happen */
slouken@7239
   348
        SDL_SetError("Renderer doesn't support querying output size");
slouken@7239
   349
        return -1;
slouken@7239
   350
    }
slouken@7239
   351
}
slouken@7239
   352
slouken@5156
   353
static SDL_bool
slouken@5156
   354
IsSupportedFormat(SDL_Renderer * renderer, Uint32 format)
slouken@5156
   355
{
slouken@5156
   356
    Uint32 i;
slouken@5156
   357
slouken@5156
   358
    for (i = 0; i < renderer->info.num_texture_formats; ++i) {
slouken@5156
   359
        if (renderer->info.texture_formats[i] == format) {
slouken@5156
   360
            return SDL_TRUE;
slouken@5156
   361
        }
slouken@5156
   362
    }
slouken@5156
   363
    return SDL_FALSE;
slouken@5156
   364
}
slouken@5156
   365
slouken@5156
   366
static Uint32
slouken@5156
   367
GetClosestSupportedFormat(SDL_Renderer * renderer, Uint32 format)
slouken@5156
   368
{
slouken@5156
   369
    Uint32 i;
slouken@5156
   370
slouken@5268
   371
    if (SDL_ISPIXELFORMAT_FOURCC(format)) {
slouken@5268
   372
        /* Look for an exact match */
slouken@5268
   373
        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
slouken@5268
   374
            if (renderer->info.texture_formats[i] == format) {
slouken@5268
   375
                return renderer->info.texture_formats[i];
slouken@5268
   376
            }
slouken@5268
   377
        }
slouken@5268
   378
    } else {
slouken@5268
   379
        SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
slouken@5268
   380
slouken@5268
   381
        /* We just want to match the first format that has the same channels */
slouken@5268
   382
        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
slouken@5300
   383
            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
slouken@5300
   384
                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {
slouken@5268
   385
                return renderer->info.texture_formats[i];
slouken@5268
   386
            }
slouken@5156
   387
        }
slouken@5156
   388
    }
slouken@5156
   389
    return renderer->info.texture_formats[0];
slouken@5156
   390
}
slouken@5156
   391
slouken@5154
   392
SDL_Texture *
slouken@5154
   393
SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)
slouken@5154
   394
{
slouken@5154
   395
    SDL_Texture *texture;
slouken@5154
   396
slouken@5154
   397
    CHECK_RENDERER_MAGIC(renderer, NULL);
slouken@5154
   398
slouken@5413
   399
    if (!format) {
slouken@5413
   400
        format = renderer->info.texture_formats[0];
slouken@5413
   401
    }
slouken@5156
   402
    if (SDL_ISPIXELFORMAT_INDEXED(format)) {
slouken@5156
   403
        SDL_SetError("Palettized textures are not supported");
slouken@5156
   404
        return NULL;
slouken@5156
   405
    }
slouken@5154
   406
    if (w <= 0 || h <= 0) {
slouken@5154
   407
        SDL_SetError("Texture dimensions can't be 0");
slouken@5156
   408
        return NULL;
slouken@5154
   409
    }
slouken@5154
   410
    texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
slouken@5154
   411
    if (!texture) {
slouken@5154
   412
        SDL_OutOfMemory();
slouken@5156
   413
        return NULL;
slouken@5154
   414
    }
slouken@5154
   415
    texture->magic = &texture_magic;
slouken@5154
   416
    texture->format = format;
slouken@5154
   417
    texture->access = access;
slouken@5154
   418
    texture->w = w;
slouken@5154
   419
    texture->h = h;
slouken@5154
   420
    texture->r = 255;
slouken@5154
   421
    texture->g = 255;
slouken@5154
   422
    texture->b = 255;
slouken@5154
   423
    texture->a = 255;
slouken@5154
   424
    texture->renderer = renderer;
slouken@5154
   425
    texture->next = renderer->textures;
slouken@5154
   426
    if (renderer->textures) {
slouken@5154
   427
        renderer->textures->prev = texture;
slouken@5154
   428
    }
slouken@5154
   429
    renderer->textures = texture;
slouken@5154
   430
slouken@5156
   431
    if (IsSupportedFormat(renderer, format)) {
slouken@5156
   432
        if (renderer->CreateTexture(renderer, texture) < 0) {
slouken@5156
   433
            SDL_DestroyTexture(texture);
slouken@5156
   434
            return 0;
slouken@5156
   435
        }
slouken@5156
   436
    } else {
slouken@5156
   437
        texture->native = SDL_CreateTexture(renderer,
slouken@5156
   438
                                GetClosestSupportedFormat(renderer, format),
slouken@5156
   439
                                access, w, h);
slouken@5156
   440
        if (!texture->native) {
slouken@5156
   441
            SDL_DestroyTexture(texture);
slouken@5156
   442
            return NULL;
slouken@5156
   443
        }
slouken@5156
   444
slouken@6497
   445
        /* Swap textures to have texture before texture->native in the list */
slouken@6497
   446
        texture->native->next = texture->next;
slouken@6533
   447
        if (texture->native->next) {
slouken@6533
   448
            texture->native->next->prev = texture->native;
slouken@6533
   449
        }
slouken@6497
   450
        texture->prev = texture->native->prev;
slouken@6533
   451
        if (texture->prev) {
slouken@6533
   452
            texture->prev->next = texture;
slouken@6533
   453
        }
slouken@6497
   454
        texture->native->prev = texture;
slouken@6497
   455
        texture->next = texture->native;
slouken@6497
   456
        renderer->textures = texture;
slouken@6497
   457
slouken@5156
   458
        if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
slouken@5156
   459
            texture->yuv = SDL_SW_CreateYUVTexture(format, w, h);
slouken@5156
   460
            if (!texture->yuv) {
slouken@5156
   461
                SDL_DestroyTexture(texture);
slouken@5156
   462
                return NULL;
slouken@5156
   463
            }
slouken@5156
   464
        } else if (access == SDL_TEXTUREACCESS_STREAMING) {
slouken@5156
   465
            /* The pitch is 4 byte aligned */
slouken@5156
   466
            texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
slouken@5342
   467
            texture->pixels = SDL_calloc(1, texture->pitch * h);
slouken@5156
   468
            if (!texture->pixels) {
slouken@5156
   469
                SDL_DestroyTexture(texture);
slouken@5156
   470
                return NULL;
slouken@5156
   471
            }
slouken@5156
   472
        }
slouken@5154
   473
    }
slouken@5154
   474
    return texture;
slouken@5154
   475
}
slouken@5154
   476
slouken@5154
   477
SDL_Texture *
slouken@5158
   478
SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
slouken@5154
   479
{
slouken@5158
   480
    const SDL_PixelFormat *fmt;
slouken@5158
   481
    SDL_bool needAlpha;
slouken@5158
   482
    Uint32 i;
slouken@5158
   483
    Uint32 format;
slouken@5158
   484
    SDL_Texture *texture;
slouken@5154
   485
slouken@5154
   486
    CHECK_RENDERER_MAGIC(renderer, NULL);
slouken@5154
   487
slouken@5154
   488
    if (!surface) {
slouken@5154
   489
        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
slouken@5154
   490
        return NULL;
slouken@5154
   491
    }
slouken@5158
   492
slouken@5158
   493
    /* See what the best texture format is */
slouken@5154
   494
    fmt = surface->format;
slouken@5158
   495
    if (fmt->Amask || SDL_GetColorKey(surface, NULL) == 0) {
slouken@5158
   496
        needAlpha = SDL_TRUE;
slouken@5154
   497
    } else {
slouken@5158
   498
        needAlpha = SDL_FALSE;
slouken@5158
   499
    }
slouken@5158
   500
    format = renderer->info.texture_formats[0];
slouken@5158
   501
    for (i = 0; i < renderer->info.num_texture_formats; ++i) {
slouken@5268
   502
        if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
slouken@5268
   503
            SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {
slouken@5158
   504
            format = renderer->info.texture_formats[i];
slouken@5158
   505
            break;
slouken@5154
   506
        }
slouken@5154
   507
    }
slouken@5154
   508
slouken@5158
   509
    texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,
slouken@5158
   510
                                surface->w, surface->h);
slouken@5154
   511
    if (!texture) {
slouken@5158
   512
        return NULL;
slouken@5154
   513
    }
slouken@5158
   514
slouken@5288
   515
    if (format == surface->format->format) {
slouken@5154
   516
        if (SDL_MUSTLOCK(surface)) {
slouken@5154
   517
            SDL_LockSurface(surface);
slouken@5158
   518
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
slouken@5154
   519
            SDL_UnlockSurface(surface);
slouken@5154
   520
        } else {
slouken@5158
   521
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
slouken@5154
   522
        }
slouken@5154
   523
    } else {
slouken@5297
   524
        SDL_PixelFormat *dst_fmt;
slouken@5158
   525
        SDL_Surface *temp = NULL;
slouken@5154
   526
slouken@5154
   527
        /* Set up a destination surface for the texture update */
slouken@5297
   528
        dst_fmt = SDL_AllocFormat(format);
slouken@5297
   529
        temp = SDL_ConvertSurface(surface, dst_fmt, 0);
slouken@5297
   530
        SDL_FreeFormat(dst_fmt);
slouken@5158
   531
        if (temp) {
slouken@5158
   532
            SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
slouken@5158
   533
            SDL_FreeSurface(temp);
slouken@5158
   534
        } else {
slouken@5154
   535
            SDL_DestroyTexture(texture);
slouken@5158
   536
            return NULL;
slouken@5154
   537
        }
slouken@5154
   538
    }
slouken@5154
   539
slouken@5154
   540
    {
slouken@5154
   541
        Uint8 r, g, b, a;
slouken@5154
   542
        SDL_BlendMode blendMode;
slouken@5154
   543
slouken@5154
   544
        SDL_GetSurfaceColorMod(surface, &r, &g, &b);
slouken@5154
   545
        SDL_SetTextureColorMod(texture, r, g, b);
slouken@5154
   546
slouken@5154
   547
        SDL_GetSurfaceAlphaMod(surface, &a);
slouken@5154
   548
        SDL_SetTextureAlphaMod(texture, a);
slouken@5154
   549
slouken@5154
   550
        if (SDL_GetColorKey(surface, NULL) == 0) {
slouken@5154
   551
            /* We converted to a texture with alpha format */
slouken@5154
   552
            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
slouken@5154
   553
        } else {
slouken@5154
   554
            SDL_GetSurfaceBlendMode(surface, &blendMode);
slouken@5154
   555
            SDL_SetTextureBlendMode(texture, blendMode);
slouken@5154
   556
        }
slouken@5154
   557
    }
slouken@5154
   558
    return texture;
slouken@5154
   559
}
slouken@5154
   560
slouken@5154
   561
int
slouken@5154
   562
SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,
slouken@5154
   563
                 int *w, int *h)
slouken@5154
   564
{
slouken@5154
   565
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   566
slouken@5154
   567
    if (format) {
slouken@5154
   568
        *format = texture->format;
slouken@5154
   569
    }
slouken@5154
   570
    if (access) {
slouken@5154
   571
        *access = texture->access;
slouken@5154
   572
    }
slouken@5154
   573
    if (w) {
slouken@5154
   574
        *w = texture->w;
slouken@5154
   575
    }
slouken@5154
   576
    if (h) {
slouken@5154
   577
        *h = texture->h;
slouken@5154
   578
    }
slouken@5154
   579
    return 0;
slouken@5154
   580
}
slouken@5154
   581
slouken@5154
   582
int
slouken@5154
   583
SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
slouken@5154
   584
{
slouken@5154
   585
    SDL_Renderer *renderer;
slouken@5154
   586
slouken@5154
   587
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   588
slouken@5154
   589
    renderer = texture->renderer;
slouken@5154
   590
    if (r < 255 || g < 255 || b < 255) {
slouken@5154
   591
        texture->modMode |= SDL_TEXTUREMODULATE_COLOR;
slouken@5154
   592
    } else {
slouken@5154
   593
        texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
slouken@5154
   594
    }
slouken@5154
   595
    texture->r = r;
slouken@5154
   596
    texture->g = g;
slouken@5154
   597
    texture->b = b;
slouken@5156
   598
    if (texture->native) {
slouken@5156
   599
        return SDL_SetTextureColorMod(texture->native, r, g, b);
slouken@5156
   600
    } else if (renderer->SetTextureColorMod) {
slouken@5154
   601
        return renderer->SetTextureColorMod(renderer, texture);
slouken@5154
   602
    } else {
slouken@5154
   603
        return 0;
slouken@5154
   604
    }
slouken@5154
   605
}
slouken@5154
   606
slouken@5154
   607
int
slouken@5154
   608
SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,
slouken@5154
   609
                       Uint8 * b)
slouken@5154
   610
{
slouken@5154
   611
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   612
slouken@5154
   613
    if (r) {
slouken@5154
   614
        *r = texture->r;
slouken@5154
   615
    }
slouken@5154
   616
    if (g) {
slouken@5154
   617
        *g = texture->g;
slouken@5154
   618
    }
slouken@5154
   619
    if (b) {
slouken@5154
   620
        *b = texture->b;
slouken@5154
   621
    }
slouken@5154
   622
    return 0;
slouken@5154
   623
}
slouken@5154
   624
slouken@5154
   625
int
slouken@5154
   626
SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
slouken@5154
   627
{
slouken@5154
   628
    SDL_Renderer *renderer;
slouken@5154
   629
slouken@5154
   630
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   631
slouken@5154
   632
    renderer = texture->renderer;
slouken@5154
   633
    if (alpha < 255) {
slouken@5154
   634
        texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;
slouken@5154
   635
    } else {
slouken@5154
   636
        texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
slouken@5154
   637
    }
slouken@5154
   638
    texture->a = alpha;
slouken@5156
   639
    if (texture->native) {
slouken@5156
   640
        return SDL_SetTextureAlphaMod(texture->native, alpha);
slouken@5156
   641
    } else if (renderer->SetTextureAlphaMod) {
slouken@5154
   642
        return renderer->SetTextureAlphaMod(renderer, texture);
slouken@5154
   643
    } else {
slouken@5154
   644
        return 0;
slouken@5154
   645
    }
slouken@5154
   646
}
slouken@5154
   647
slouken@5154
   648
int
slouken@5154
   649
SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)
slouken@5154
   650
{
slouken@5154
   651
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   652
slouken@5154
   653
    if (alpha) {
slouken@5154
   654
        *alpha = texture->a;
slouken@5154
   655
    }
slouken@5154
   656
    return 0;
slouken@5154
   657
}
slouken@5154
   658
slouken@5154
   659
int
slouken@5154
   660
SDL_SetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode blendMode)
slouken@5154
   661
{
slouken@5154
   662
    SDL_Renderer *renderer;
slouken@5154
   663
slouken@5154
   664
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   665
slouken@5154
   666
    renderer = texture->renderer;
slouken@5154
   667
    texture->blendMode = blendMode;
slouken@5156
   668
    if (texture->native) {
slouken@5180
   669
        return SDL_SetTextureBlendMode(texture->native, blendMode);
slouken@5156
   670
    } else if (renderer->SetTextureBlendMode) {
slouken@5154
   671
        return renderer->SetTextureBlendMode(renderer, texture);
slouken@5154
   672
    } else {
slouken@5154
   673
        return 0;
slouken@5154
   674
    }
slouken@5154
   675
}
slouken@5154
   676
slouken@5154
   677
int
slouken@5154
   678
SDL_GetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode *blendMode)
slouken@5154
   679
{
slouken@5154
   680
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   681
slouken@5154
   682
    if (blendMode) {
slouken@5154
   683
        *blendMode = texture->blendMode;
slouken@5154
   684
    }
slouken@5154
   685
    return 0;
slouken@5154
   686
}
slouken@5154
   687
slouken@5156
   688
static int
slouken@5156
   689
SDL_UpdateTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5156
   690
                     const void *pixels, int pitch)
slouken@5156
   691
{
slouken@5156
   692
    SDL_Texture *native = texture->native;
slouken@5156
   693
    SDL_Rect full_rect;
slouken@5156
   694
slouken@5156
   695
    if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
slouken@5156
   696
        return -1;
slouken@5156
   697
    }
slouken@5156
   698
slouken@5156
   699
    full_rect.x = 0;
slouken@5156
   700
    full_rect.y = 0;
slouken@5156
   701
    full_rect.w = texture->w;
slouken@5156
   702
    full_rect.h = texture->h;
slouken@5156
   703
    rect = &full_rect;
slouken@5156
   704
slouken@5156
   705
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
slouken@5156
   706
        /* We can lock the texture and copy to it */
slouken@5156
   707
        void *native_pixels;
slouken@5156
   708
        int native_pitch;
slouken@5156
   709
slouken@5156
   710
        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
slouken@5156
   711
            return -1;
slouken@5156
   712
        }
slouken@5156
   713
        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
slouken@5156
   714
                            rect->w, rect->h, native_pixels, native_pitch);
slouken@5156
   715
        SDL_UnlockTexture(native);
slouken@5156
   716
    } else {
slouken@5156
   717
        /* Use a temporary buffer for updating */
slouken@5156
   718
        void *temp_pixels;
slouken@5156
   719
        int temp_pitch;
slouken@5156
   720
slouken@5156
   721
        temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
slouken@5156
   722
        temp_pixels = SDL_malloc(rect->h * temp_pitch);
slouken@5156
   723
        if (!temp_pixels) {
icculus@7037
   724
            return SDL_OutOfMemory();
slouken@5156
   725
        }
slouken@5156
   726
        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
slouken@5156
   727
                            rect->w, rect->h, temp_pixels, temp_pitch);
slouken@5156
   728
        SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
slouken@5156
   729
        SDL_free(temp_pixels);
slouken@5156
   730
    }
slouken@5156
   731
    return 0;
slouken@5156
   732
}
slouken@5156
   733
slouken@5156
   734
static int
slouken@5156
   735
SDL_UpdateTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5156
   736
                        const void *pixels, int pitch)
slouken@5156
   737
{
slouken@5156
   738
    SDL_Texture *native = texture->native;
slouken@5156
   739
slouken@5156
   740
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
slouken@5156
   741
        /* We can lock the texture and copy to it */
slouken@5156
   742
        void *native_pixels;
slouken@5156
   743
        int native_pitch;
slouken@5156
   744
slouken@5156
   745
        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
slouken@5156
   746
            return -1;
slouken@5156
   747
        }
slouken@5156
   748
        SDL_ConvertPixels(rect->w, rect->h,
slouken@5156
   749
                          texture->format, pixels, pitch,
slouken@5156
   750
                          native->format, native_pixels, native_pitch);
slouken@5156
   751
        SDL_UnlockTexture(native);
slouken@5156
   752
    } else {
slouken@5156
   753
        /* Use a temporary buffer for updating */
slouken@5156
   754
        void *temp_pixels;
slouken@5156
   755
        int temp_pitch;
slouken@5156
   756
slouken@5156
   757
        temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
slouken@5156
   758
        temp_pixels = SDL_malloc(rect->h * temp_pitch);
slouken@5156
   759
        if (!temp_pixels) {
icculus@7037
   760
            return SDL_OutOfMemory();
slouken@5156
   761
        }
slouken@5156
   762
        SDL_ConvertPixels(rect->w, rect->h,
slouken@5156
   763
                          texture->format, pixels, pitch,
slouken@5156
   764
                          native->format, temp_pixels, temp_pitch);
slouken@5156
   765
        SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
slouken@5156
   766
        SDL_free(temp_pixels);
slouken@5156
   767
    }
slouken@5156
   768
    return 0;
slouken@5156
   769
}
slouken@5156
   770
slouken@5154
   771
int
slouken@5154
   772
SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5154
   773
                  const void *pixels, int pitch)
slouken@5154
   774
{
slouken@5154
   775
    SDL_Renderer *renderer;
slouken@5154
   776
    SDL_Rect full_rect;
slouken@5154
   777
slouken@5154
   778
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   779
slouken@7409
   780
    if (!pixels) {
slouken@7409
   781
        return SDL_InvalidParamError("pixels");
slouken@7409
   782
    }
slouken@7409
   783
    if (!pitch) {
slouken@7409
   784
        return SDL_InvalidParamError("pitch");
slouken@7409
   785
    }
slouken@7409
   786
slouken@5154
   787
    if (!rect) {
slouken@5154
   788
        full_rect.x = 0;
slouken@5154
   789
        full_rect.y = 0;
slouken@5154
   790
        full_rect.w = texture->w;
slouken@5154
   791
        full_rect.h = texture->h;
slouken@5154
   792
        rect = &full_rect;
slouken@5154
   793
    }
slouken@5156
   794
slouken@5156
   795
    if (texture->yuv) {
slouken@5156
   796
        return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
slouken@5156
   797
    } else if (texture->native) {
slouken@5156
   798
        return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
slouken@5156
   799
    } else {
slouken@5156
   800
        renderer = texture->renderer;
slouken@5156
   801
        return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
slouken@5156
   802
    }
slouken@5156
   803
}
slouken@5156
   804
slouken@5156
   805
static int
slouken@5156
   806
SDL_LockTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5156
   807
                   void **pixels, int *pitch)
slouken@5156
   808
{
slouken@5156
   809
    return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
slouken@5156
   810
}
slouken@5156
   811
slouken@5156
   812
static int
slouken@5156
   813
SDL_LockTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5156
   814
                      void **pixels, int *pitch)
slouken@5156
   815
{
slouken@5156
   816
    texture->locked_rect = *rect;
slouken@5156
   817
    *pixels = (void *) ((Uint8 *) texture->pixels +
slouken@5156
   818
                        rect->y * texture->pitch +
slouken@5156
   819
                        rect->x * SDL_BYTESPERPIXEL(texture->format));
slouken@5156
   820
    *pitch = texture->pitch;
slouken@5156
   821
    return 0;
slouken@5154
   822
}
slouken@5154
   823
slouken@5154
   824
int
slouken@5156
   825
SDL_LockTexture(SDL_Texture * texture, const SDL_Rect * rect,
slouken@5154
   826
                void **pixels, int *pitch)
slouken@5154
   827
{
slouken@5154
   828
    SDL_Renderer *renderer;
slouken@5154
   829
    SDL_Rect full_rect;
slouken@5154
   830
slouken@5154
   831
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
   832
slouken@5154
   833
    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
icculus@7037
   834
        return SDL_SetError("SDL_LockTexture(): texture must be streaming");
slouken@5154
   835
    }
slouken@5156
   836
slouken@5154
   837
    if (!rect) {
slouken@5154
   838
        full_rect.x = 0;
slouken@5154
   839
        full_rect.y = 0;
slouken@5154
   840
        full_rect.w = texture->w;
slouken@5154
   841
        full_rect.h = texture->h;
slouken@5154
   842
        rect = &full_rect;
slouken@5154
   843
    }
slouken@5156
   844
slouken@5156
   845
    if (texture->yuv) {
slouken@5156
   846
        return SDL_LockTextureYUV(texture, rect, pixels, pitch);
slouken@5156
   847
    } else if (texture->native) {
slouken@5156
   848
        return SDL_LockTextureNative(texture, rect, pixels, pitch);
slouken@5156
   849
    } else {
slouken@5156
   850
        renderer = texture->renderer;
slouken@5156
   851
        return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
slouken@5156
   852
    }
slouken@5156
   853
}
slouken@5156
   854
slouken@5156
   855
static void
slouken@5156
   856
SDL_UnlockTextureYUV(SDL_Texture * texture)
slouken@5156
   857
{
slouken@5156
   858
    SDL_Texture *native = texture->native;
slouken@5156
   859
    void *native_pixels;
slouken@5156
   860
    int native_pitch;
slouken@5156
   861
    SDL_Rect rect;
slouken@5156
   862
slouken@5156
   863
    rect.x = 0;
slouken@5156
   864
    rect.y = 0;
slouken@5156
   865
    rect.w = texture->w;
slouken@5156
   866
    rect.h = texture->h;
slouken@5156
   867
slouken@5156
   868
    if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
slouken@5156
   869
        return;
slouken@5156
   870
    }
slouken@5156
   871
    SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
slouken@5156
   872
                        rect.w, rect.h, native_pixels, native_pitch);
slouken@5156
   873
    SDL_UnlockTexture(native);
slouken@5156
   874
}
slouken@5156
   875
slouken@6044
   876
static void
slouken@5156
   877
SDL_UnlockTextureNative(SDL_Texture * texture)
slouken@5156
   878
{
slouken@5156
   879
    SDL_Texture *native = texture->native;
slouken@5156
   880
    void *native_pixels;
slouken@5156
   881
    int native_pitch;
slouken@5156
   882
    const SDL_Rect *rect = &texture->locked_rect;
slouken@5156
   883
    const void* pixels = (void *) ((Uint8 *) texture->pixels +
slouken@5156
   884
                        rect->y * texture->pitch +
slouken@5156
   885
                        rect->x * SDL_BYTESPERPIXEL(texture->format));
slouken@5156
   886
    int pitch = texture->pitch;
slouken@5156
   887
slouken@5156
   888
    if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
slouken@5156
   889
        return;
slouken@5156
   890
    }
slouken@5156
   891
    SDL_ConvertPixels(rect->w, rect->h,
slouken@5156
   892
                      texture->format, pixels, pitch,
slouken@5156
   893
                      native->format, native_pixels, native_pitch);
slouken@5156
   894
    SDL_UnlockTexture(native);
slouken@5154
   895
}
slouken@5154
   896
slouken@5154
   897
void
slouken@5154
   898
SDL_UnlockTexture(SDL_Texture * texture)
slouken@5154
   899
{
slouken@5154
   900
    SDL_Renderer *renderer;
slouken@5154
   901
slouken@5154
   902
    CHECK_TEXTURE_MAGIC(texture, );
slouken@5154
   903
slouken@5154
   904
    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
slouken@5154
   905
        return;
slouken@5154
   906
    }
slouken@5156
   907
    if (texture->yuv) {
slouken@5156
   908
        SDL_UnlockTextureYUV(texture);
slouken@5156
   909
    } else if (texture->native) {
slouken@5156
   910
        SDL_UnlockTextureNative(texture);
slouken@5156
   911
    } else {
slouken@5156
   912
        renderer = texture->renderer;
slouken@5156
   913
        renderer->UnlockTexture(renderer, texture);
slouken@5154
   914
    }
slouken@5154
   915
}
slouken@5154
   916
slouken@6246
   917
SDL_bool
slouken@6246
   918
SDL_RenderTargetSupported(SDL_Renderer *renderer)
slouken@6246
   919
{
slouken@6247
   920
    if (!renderer || !renderer->SetRenderTarget) {
slouken@6246
   921
        return SDL_FALSE;
slouken@6246
   922
    }
slouken@6246
   923
    return (renderer->info.flags & SDL_RENDERER_TARGETTEXTURE) != 0;
slouken@6246
   924
}
slouken@6246
   925
slouken@6246
   926
int
slouken@6247
   927
SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
slouken@6246
   928
{
slouken@6246
   929
    if (!SDL_RenderTargetSupported(renderer)) {
icculus@7037
   930
        return SDL_Unsupported();
slouken@6246
   931
    }
slouken@6246
   932
    if (texture == renderer->target) {
slouken@6246
   933
        /* Nothing to do! */
slouken@6246
   934
        return 0;
slouken@6246
   935
    }
slouken@6246
   936
slouken@6246
   937
    /* texture == NULL is valid and means reset the target to the window */
slouken@6246
   938
    if (texture) {
slouken@6246
   939
        CHECK_TEXTURE_MAGIC(texture, -1);
slouken@6246
   940
        if (renderer != texture->renderer) {
icculus@7037
   941
            return SDL_SetError("Texture was not created with this renderer");
slouken@6246
   942
        }
gabomdq@6337
   943
        if (texture->access != SDL_TEXTUREACCESS_TARGET) {
icculus@7037
   944
            return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
slouken@6246
   945
        }
slouken@6246
   946
        if (texture->native) {
slouken@6246
   947
            /* Always render to the native texture */
slouken@6246
   948
            texture = texture->native;
slouken@6246
   949
        }
slouken@6246
   950
    }
slouken@6246
   951
slouken@6246
   952
    if (texture && !renderer->target) {
slouken@6246
   953
        /* Make a backup of the viewport */
slouken@6246
   954
        renderer->viewport_backup = renderer->viewport;
slouken@7141
   955
        renderer->clip_rect_backup = renderer->clip_rect;
slouken@6528
   956
        renderer->scale_backup = renderer->scale;
slouken@6581
   957
        renderer->logical_w_backup = renderer->logical_w;
slouken@6581
   958
        renderer->logical_h_backup = renderer->logical_h;
slouken@6246
   959
    }
slouken@6246
   960
    renderer->target = texture;
slouken@6246
   961
slouken@6247
   962
    if (renderer->SetRenderTarget(renderer, texture) < 0) {
slouken@6246
   963
        return -1;
slouken@6246
   964
    }
slouken@6246
   965
slouken@6246
   966
    if (texture) {
slouken@6528
   967
        renderer->viewport.x = 0;
slouken@6528
   968
        renderer->viewport.y = 0;
slouken@6528
   969
        renderer->viewport.w = texture->w;
slouken@6528
   970
        renderer->viewport.h = texture->h;
slouken@6528
   971
        renderer->scale.x = 1.0f;
slouken@6528
   972
        renderer->scale.y = 1.0f;
slouken@7339
   973
        renderer->logical_w = texture->w;
slouken@7339
   974
        renderer->logical_h = texture->h;
slouken@6246
   975
    } else {
slouken@6528
   976
        renderer->viewport = renderer->viewport_backup;
slouken@7141
   977
        renderer->clip_rect = renderer->clip_rect_backup;
slouken@6528
   978
        renderer->scale = renderer->scale_backup;
slouken@6581
   979
        renderer->logical_w = renderer->logical_w_backup;
slouken@6581
   980
        renderer->logical_h = renderer->logical_h_backup;
slouken@6246
   981
    }
slouken@6528
   982
    if (renderer->UpdateViewport(renderer) < 0) {
slouken@6246
   983
        return -1;
slouken@6246
   984
    }
slouken@7141
   985
    if (renderer->UpdateClipRect(renderer) < 0) {
slouken@7141
   986
        return -1;
slouken@7141
   987
    }
slouken@6246
   988
slouken@6246
   989
    /* All set! */
slouken@6246
   990
    return 0;
slouken@6246
   991
}
slouken@6246
   992
slouken@6578
   993
SDL_Texture *
slouken@6578
   994
SDL_GetRenderTarget(SDL_Renderer *renderer)
slouken@6578
   995
{
slouken@6578
   996
    return renderer->target;
slouken@6578
   997
}
slouken@6578
   998
slouken@6530
   999
static int
slouken@6530
  1000
UpdateLogicalSize(SDL_Renderer *renderer)
slouken@6530
  1001
{
slouken@6530
  1002
    int w, h;
slouken@6530
  1003
    float want_aspect;
slouken@6530
  1004
    float real_aspect;
slouken@6530
  1005
    float scale;
slouken@6530
  1006
    SDL_Rect viewport;
slouken@6530
  1007
slouken@7239
  1008
    if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
slouken@7239
  1009
        return -1;
slouken@6530
  1010
    }
slouken@6530
  1011
slouken@6530
  1012
    want_aspect = (float)renderer->logical_w / renderer->logical_h;
slouken@6530
  1013
    real_aspect = (float)w / h;
slouken@6530
  1014
slouken@6530
  1015
    /* Clear the scale because we're setting viewport in output coordinates */
slouken@6530
  1016
    SDL_RenderSetScale(renderer, 1.0f, 1.0f);
slouken@6530
  1017
slouken@6530
  1018
    if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
slouken@6530
  1019
        /* The aspect ratios are the same, just scale appropriately */
slouken@6530
  1020
        scale = (float)w / renderer->logical_w;
slouken@6530
  1021
        SDL_RenderSetViewport(renderer, NULL);
slouken@6530
  1022
    } else if (want_aspect > real_aspect) {
slouken@6530
  1023
        /* We want a wider aspect ratio than is available - letterbox it */
slouken@6530
  1024
        scale = (float)w / renderer->logical_w;
slouken@6530
  1025
        viewport.x = 0;
slouken@6530
  1026
        viewport.w = w;
slouken@6530
  1027
        viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
slouken@6530
  1028
        viewport.y = (h - viewport.h) / 2;
slouken@6530
  1029
        SDL_RenderSetViewport(renderer, &viewport);
slouken@6530
  1030
    } else {
slouken@6530
  1031
        /* We want a narrower aspect ratio than is available - use side-bars */
slouken@6530
  1032
        scale = (float)h / renderer->logical_h;
slouken@6530
  1033
        viewport.y = 0;
slouken@6530
  1034
        viewport.h = h;
slouken@6530
  1035
        viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
slouken@6530
  1036
        viewport.x = (w - viewport.w) / 2;
slouken@6530
  1037
        SDL_RenderSetViewport(renderer, &viewport);
slouken@6530
  1038
    }
slouken@6530
  1039
slouken@6530
  1040
    /* Set the new scale */
slouken@6530
  1041
    SDL_RenderSetScale(renderer, scale, scale);
slouken@6531
  1042
slouken@6531
  1043
    return 0;
slouken@6530
  1044
}
slouken@6530
  1045
slouken@6530
  1046
int
slouken@6530
  1047
SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h)
slouken@6530
  1048
{
slouken@6530
  1049
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@6530
  1050
slouken@6530
  1051
    if (!w || !h) {
slouken@6530
  1052
        /* Clear any previous logical resolution */
slouken@6530
  1053
        renderer->logical_w = 0;
slouken@6530
  1054
        renderer->logical_h = 0;
slouken@6530
  1055
        SDL_RenderSetViewport(renderer, NULL);
slouken@6530
  1056
        SDL_RenderSetScale(renderer, 1.0f, 1.0f);
slouken@6530
  1057
        return 0;
slouken@6530
  1058
    }
slouken@6530
  1059
slouken@6530
  1060
    renderer->logical_w = w;
slouken@6530
  1061
    renderer->logical_h = h;
slouken@6530
  1062
slouken@6530
  1063
    return UpdateLogicalSize(renderer);
slouken@6530
  1064
}
slouken@6530
  1065
slouken@6530
  1066
void
slouken@6530
  1067
SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h)
slouken@6530
  1068
{
slouken@6530
  1069
    CHECK_RENDERER_MAGIC(renderer, );
slouken@6530
  1070
slouken@6530
  1071
    if (w) {
slouken@6530
  1072
        *w = renderer->logical_w;
slouken@6530
  1073
    }
slouken@6530
  1074
    if (h) {
slouken@6530
  1075
        *h = renderer->logical_h;
slouken@6530
  1076
    }
slouken@6530
  1077
}
slouken@6530
  1078
slouken@5297
  1079
int
slouken@5297
  1080
SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
slouken@5297
  1081
{
slouken@5297
  1082
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5297
  1083
slouken@5297
  1084
    if (rect) {
slouken@6528
  1085
        renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
slouken@6528
  1086
        renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
slouken@6528
  1087
        renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
slouken@6528
  1088
        renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
slouken@5297
  1089
    } else {
slouken@5297
  1090
        renderer->viewport.x = 0;
slouken@5297
  1091
        renderer->viewport.y = 0;
slouken@7239
  1092
        if (SDL_GetRendererOutputSize(renderer, &renderer->viewport.w, &renderer->viewport.h) < 0) {
slouken@7239
  1093
            return -1;
slouken@5297
  1094
        }
slouken@5297
  1095
    }
slouken@5297
  1096
    return renderer->UpdateViewport(renderer);
slouken@5297
  1097
}
slouken@5297
  1098
slouken@5224
  1099
void
slouken@5297
  1100
SDL_RenderGetViewport(SDL_Renderer * renderer, SDL_Rect * rect)
slouken@5224
  1101
{
slouken@5224
  1102
    CHECK_RENDERER_MAGIC(renderer, );
slouken@5224
  1103
slouken@6528
  1104
    if (rect) {
slouken@6528
  1105
        rect->x = (int)(renderer->viewport.x / renderer->scale.x);
slouken@6528
  1106
        rect->y = (int)(renderer->viewport.y / renderer->scale.y);
slouken@6528
  1107
        rect->w = (int)(renderer->viewport.w / renderer->scale.x);
slouken@6528
  1108
        rect->h = (int)(renderer->viewport.h / renderer->scale.y);
slouken@6528
  1109
    }
slouken@6528
  1110
}
slouken@6528
  1111
slouken@6528
  1112
int
slouken@7141
  1113
SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
slouken@7141
  1114
{
philipp@7143
  1115
    CHECK_RENDERER_MAGIC(renderer, -1)
slouken@7141
  1116
slouken@7141
  1117
    if (rect) {
slouken@7141
  1118
        renderer->clip_rect.x = (int)SDL_floor(rect->x * renderer->scale.x);
slouken@7141
  1119
        renderer->clip_rect.y = (int)SDL_floor(rect->y * renderer->scale.y);
slouken@7141
  1120
        renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
slouken@7141
  1121
        renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
slouken@7141
  1122
    } else {
slouken@7141
  1123
        SDL_zero(renderer->clip_rect);
slouken@7141
  1124
    }
slouken@7141
  1125
    return renderer->UpdateClipRect(renderer);
slouken@7141
  1126
}
slouken@7141
  1127
slouken@7141
  1128
void
slouken@7141
  1129
SDL_RenderGetClipRect(SDL_Renderer * renderer, SDL_Rect * rect)
slouken@7141
  1130
{
slouken@7141
  1131
    CHECK_RENDERER_MAGIC(renderer, )
slouken@7141
  1132
slouken@7141
  1133
    if (rect) {
slouken@7141
  1134
        rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
slouken@7141
  1135
        rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
slouken@7141
  1136
        rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
slouken@7141
  1137
        rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
slouken@7141
  1138
    }
slouken@7141
  1139
}
slouken@7141
  1140
slouken@7141
  1141
int
slouken@6528
  1142
SDL_RenderSetScale(SDL_Renderer * renderer, float scaleX, float scaleY)
slouken@6528
  1143
{
slouken@6528
  1144
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@6528
  1145
slouken@6528
  1146
    renderer->scale.x = scaleX;
slouken@6528
  1147
    renderer->scale.y = scaleY;
slouken@6528
  1148
    return 0;
slouken@6528
  1149
}
slouken@6528
  1150
slouken@6528
  1151
void
slouken@6528
  1152
SDL_RenderGetScale(SDL_Renderer * renderer, float *scaleX, float *scaleY)
slouken@6528
  1153
{
slouken@6528
  1154
    CHECK_RENDERER_MAGIC(renderer, );
slouken@6528
  1155
slouken@6528
  1156
    if (scaleX) {
slouken@6528
  1157
        *scaleX = renderer->scale.x;
slouken@6528
  1158
    }
slouken@6528
  1159
    if (scaleY) {
slouken@6528
  1160
        *scaleY = renderer->scale.y;
slouken@6528
  1161
    }
slouken@5224
  1162
}
slouken@5224
  1163
slouken@5154
  1164
int
slouken@5154
  1165
SDL_SetRenderDrawColor(SDL_Renderer * renderer,
slouken@5154
  1166
                       Uint8 r, Uint8 g, Uint8 b, Uint8 a)
slouken@5154
  1167
{
slouken@5154
  1168
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1169
slouken@5154
  1170
    renderer->r = r;
slouken@5154
  1171
    renderer->g = g;
slouken@5154
  1172
    renderer->b = b;
slouken@5154
  1173
    renderer->a = a;
slouken@5154
  1174
    return 0;
slouken@5154
  1175
}
slouken@5154
  1176
slouken@5154
  1177
int
slouken@5154
  1178
SDL_GetRenderDrawColor(SDL_Renderer * renderer,
slouken@5154
  1179
                       Uint8 * r, Uint8 * g, Uint8 * b, Uint8 * a)
slouken@5154
  1180
{
slouken@5154
  1181
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1182
slouken@5154
  1183
    if (r) {
slouken@5154
  1184
        *r = renderer->r;
slouken@5154
  1185
    }
slouken@5154
  1186
    if (g) {
slouken@5154
  1187
        *g = renderer->g;
slouken@5154
  1188
    }
slouken@5154
  1189
    if (b) {
slouken@5154
  1190
        *b = renderer->b;
slouken@5154
  1191
    }
slouken@5154
  1192
    if (a) {
slouken@5154
  1193
        *a = renderer->a;
slouken@5154
  1194
    }
slouken@5154
  1195
    return 0;
slouken@5154
  1196
}
slouken@5154
  1197
slouken@5154
  1198
int
slouken@5154
  1199
SDL_SetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
slouken@5154
  1200
{
slouken@5154
  1201
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1202
slouken@5154
  1203
    renderer->blendMode = blendMode;
slouken@5154
  1204
    return 0;
slouken@5154
  1205
}
slouken@5154
  1206
slouken@5154
  1207
int
slouken@5154
  1208
SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode *blendMode)
slouken@5154
  1209
{
slouken@5154
  1210
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1211
slouken@5154
  1212
    *blendMode = renderer->blendMode;
slouken@5154
  1213
    return 0;
slouken@5154
  1214
}
slouken@5154
  1215
slouken@5154
  1216
int
slouken@5154
  1217
SDL_RenderClear(SDL_Renderer * renderer)
slouken@5154
  1218
{
slouken@5154
  1219
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1220
slouken@6260
  1221
    /* Don't draw while we're hidden */
slouken@6260
  1222
    if (renderer->hidden) {
slouken@6060
  1223
        return 0;
slouken@6060
  1224
    }
slouken@5154
  1225
    return renderer->RenderClear(renderer);
slouken@5154
  1226
}
slouken@5154
  1227
slouken@5154
  1228
int
slouken@5154
  1229
SDL_RenderDrawPoint(SDL_Renderer * renderer, int x, int y)
slouken@5154
  1230
{
slouken@5154
  1231
    SDL_Point point;
slouken@5154
  1232
slouken@5154
  1233
    point.x = x;
slouken@5154
  1234
    point.y = y;
slouken@5154
  1235
    return SDL_RenderDrawPoints(renderer, &point, 1);
slouken@5154
  1236
}
slouken@5154
  1237
slouken@6528
  1238
static int
slouken@6528
  1239
RenderDrawPointsWithRects(SDL_Renderer * renderer,
slouken@6528
  1240
                     const SDL_Point * points, int count)
slouken@6528
  1241
{
slouken@6528
  1242
    SDL_FRect *frects;
slouken@6528
  1243
    int i;
slouken@6528
  1244
    int status;
slouken@6528
  1245
slouken@6528
  1246
    frects = SDL_stack_alloc(SDL_FRect, count);
slouken@6528
  1247
    if (!frects) {
icculus@7037
  1248
        return SDL_OutOfMemory();
slouken@6528
  1249
    }
slouken@6528
  1250
    for (i = 0; i < count; ++i) {
slouken@6528
  1251
        frects[i].x = points[i].x * renderer->scale.x;
slouken@6528
  1252
        frects[i].y = points[i].y * renderer->scale.y;
slouken@6528
  1253
        frects[i].w = renderer->scale.x;
slouken@6528
  1254
        frects[i].h = renderer->scale.y;
slouken@6528
  1255
    }
slouken@6528
  1256
slouken@6528
  1257
    status = renderer->RenderFillRects(renderer, frects, count);
slouken@6528
  1258
slouken@6528
  1259
    SDL_stack_free(frects);
slouken@6528
  1260
slouken@6528
  1261
    return status;
slouken@6528
  1262
}
slouken@6528
  1263
slouken@5154
  1264
int
slouken@5154
  1265
SDL_RenderDrawPoints(SDL_Renderer * renderer,
slouken@5154
  1266
                     const SDL_Point * points, int count)
slouken@5154
  1267
{
slouken@6528
  1268
    SDL_FPoint *fpoints;
slouken@6528
  1269
    int i;
slouken@6528
  1270
    int status;
slouken@6528
  1271
slouken@5154
  1272
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1273
slouken@5154
  1274
    if (!points) {
icculus@7037
  1275
        return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
slouken@5154
  1276
    }
slouken@5154
  1277
    if (count < 1) {
slouken@5154
  1278
        return 0;
slouken@5154
  1279
    }
slouken@6260
  1280
    /* Don't draw while we're hidden */
slouken@6260
  1281
    if (renderer->hidden) {
slouken@6060
  1282
        return 0;
slouken@6060
  1283
    }
slouken@6528
  1284
slouken@6528
  1285
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
slouken@6528
  1286
        return RenderDrawPointsWithRects(renderer, points, count);
slouken@6528
  1287
    }
slouken@6528
  1288
slouken@6528
  1289
    fpoints = SDL_stack_alloc(SDL_FPoint, count);
slouken@6528
  1290
    if (!fpoints) {
icculus@7037
  1291
        return SDL_OutOfMemory();
slouken@6528
  1292
    }
slouken@6528
  1293
    for (i = 0; i < count; ++i) {
slouken@6528
  1294
        fpoints[i].x = points[i].x * renderer->scale.x;
slouken@6528
  1295
        fpoints[i].y = points[i].y * renderer->scale.y;
slouken@6528
  1296
    }
slouken@6528
  1297
slouken@6528
  1298
    status = renderer->RenderDrawPoints(renderer, fpoints, count);
slouken@6528
  1299
slouken@6528
  1300
    SDL_stack_free(fpoints);
slouken@6528
  1301
slouken@6528
  1302
    return status;
slouken@5154
  1303
}
slouken@5154
  1304
slouken@5154
  1305
int
slouken@5154
  1306
SDL_RenderDrawLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
slouken@5154
  1307
{
slouken@5154
  1308
    SDL_Point points[2];
slouken@5154
  1309
slouken@5154
  1310
    points[0].x = x1;
slouken@5154
  1311
    points[0].y = y1;
slouken@5154
  1312
    points[1].x = x2;
slouken@5154
  1313
    points[1].y = y2;
slouken@5154
  1314
    return SDL_RenderDrawLines(renderer, points, 2);
slouken@5154
  1315
}
slouken@5154
  1316
slouken@6528
  1317
static int
slouken@6528
  1318
RenderDrawLinesWithRects(SDL_Renderer * renderer,
slouken@6528
  1319
                     const SDL_Point * points, int count)
slouken@6528
  1320
{
slouken@6528
  1321
    SDL_FRect *frect;
slouken@6528
  1322
    SDL_FRect *frects;
slouken@6528
  1323
    SDL_FPoint fpoints[2];
slouken@6528
  1324
    int i, nrects;
slouken@6528
  1325
    int status;
slouken@6528
  1326
slouken@6528
  1327
    frects = SDL_stack_alloc(SDL_FRect, count-1);
slouken@6528
  1328
    if (!frects) {
icculus@7037
  1329
        return SDL_OutOfMemory();
slouken@6528
  1330
    }
slouken@6528
  1331
slouken@6528
  1332
    status = 0;
slouken@6528
  1333
    nrects = 0;
slouken@6528
  1334
    for (i = 0; i < count-1; ++i) {
slouken@6528
  1335
        if (points[i].x == points[i+1].x) {
slouken@6528
  1336
            int minY = SDL_min(points[i].y, points[i+1].y);
slouken@6528
  1337
            int maxY = SDL_max(points[i].y, points[i+1].y);
slouken@6528
  1338
slouken@6528
  1339
            frect = &frects[nrects++];
slouken@6528
  1340
            frect->x = points[i].x * renderer->scale.x;
slouken@6528
  1341
            frect->y = minY * renderer->scale.y;
slouken@6528
  1342
            frect->w = renderer->scale.x;
slouken@6528
  1343
            frect->h = (maxY - minY + 1) * renderer->scale.y;
slouken@6528
  1344
        } else if (points[i].y == points[i+1].y) {
slouken@6528
  1345
            int minX = SDL_min(points[i].x, points[i+1].x);
slouken@6528
  1346
            int maxX = SDL_max(points[i].x, points[i+1].x);
slouken@6528
  1347
slouken@6528
  1348
            frect = &frects[nrects++];
slouken@6528
  1349
            frect->x = minX * renderer->scale.x;
slouken@6528
  1350
            frect->y = points[i].y * renderer->scale.y;
slouken@6528
  1351
            frect->w = (maxX - minX + 1) * renderer->scale.x;
slouken@6528
  1352
            frect->h = renderer->scale.y;
slouken@6528
  1353
        } else {
slouken@6528
  1354
            /* FIXME: We can't use a rect for this line... */
aschiffler@7073
  1355
            fpoints[0].x = points[i].x * renderer->scale.x;
aschiffler@7073
  1356
            fpoints[0].y = points[i].y * renderer->scale.y;
aschiffler@7073
  1357
            fpoints[1].x = points[i+1].x * renderer->scale.x;
aschiffler@7073
  1358
            fpoints[1].y = points[i+1].y * renderer->scale.y;
slouken@6528
  1359
            status += renderer->RenderDrawLines(renderer, fpoints, 2);
slouken@6528
  1360
        }
slouken@6528
  1361
    }
slouken@6528
  1362
slouken@6528
  1363
    status += renderer->RenderFillRects(renderer, frects, nrects);
slouken@6528
  1364
slouken@6528
  1365
    SDL_stack_free(frects);
slouken@6528
  1366
slouken@6528
  1367
    if (status < 0) {
slouken@6528
  1368
        status = -1;
slouken@6528
  1369
    }
slouken@6528
  1370
    return status;
slouken@6528
  1371
}
slouken@6528
  1372
slouken@5154
  1373
int
slouken@5154
  1374
SDL_RenderDrawLines(SDL_Renderer * renderer,
slouken@5154
  1375
                    const SDL_Point * points, int count)
slouken@5154
  1376
{
slouken@6528
  1377
    SDL_FPoint *fpoints;
slouken@6528
  1378
    int i;
slouken@6528
  1379
    int status;
slouken@6528
  1380
slouken@5154
  1381
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1382
slouken@5154
  1383
    if (!points) {
icculus@7037
  1384
        return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
slouken@5154
  1385
    }
slouken@5154
  1386
    if (count < 2) {
slouken@5154
  1387
        return 0;
slouken@5154
  1388
    }
slouken@6260
  1389
    /* Don't draw while we're hidden */
slouken@6260
  1390
    if (renderer->hidden) {
slouken@6060
  1391
        return 0;
slouken@6060
  1392
    }
slouken@6528
  1393
slouken@6528
  1394
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
slouken@6528
  1395
        return RenderDrawLinesWithRects(renderer, points, count);
slouken@6528
  1396
    }
slouken@6528
  1397
slouken@6528
  1398
    fpoints = SDL_stack_alloc(SDL_FPoint, count);
slouken@6528
  1399
    if (!fpoints) {
icculus@7037
  1400
        return SDL_OutOfMemory();
slouken@6528
  1401
    }
slouken@6528
  1402
    for (i = 0; i < count; ++i) {
slouken@6528
  1403
        fpoints[i].x = points[i].x * renderer->scale.x;
slouken@6528
  1404
        fpoints[i].y = points[i].y * renderer->scale.y;
slouken@6528
  1405
    }
slouken@6528
  1406
slouken@6528
  1407
    status = renderer->RenderDrawLines(renderer, fpoints, count);
slouken@6528
  1408
slouken@6528
  1409
    SDL_stack_free(fpoints);
slouken@6528
  1410
slouken@6528
  1411
    return status;
slouken@5154
  1412
}
slouken@5154
  1413
slouken@5154
  1414
int
slouken@5154
  1415
SDL_RenderDrawRect(SDL_Renderer * renderer, const SDL_Rect * rect)
slouken@5154
  1416
{
slouken@5154
  1417
    SDL_Rect full_rect;
slouken@5154
  1418
    SDL_Point points[5];
slouken@5154
  1419
slouken@5154
  1420
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1421
slouken@5154
  1422
    /* If 'rect' == NULL, then outline the whole surface */
slouken@5154
  1423
    if (!rect) {
slouken@6528
  1424
        SDL_RenderGetViewport(renderer, &full_rect);
slouken@5154
  1425
        full_rect.x = 0;
slouken@5154
  1426
        full_rect.y = 0;
slouken@5154
  1427
        rect = &full_rect;
slouken@5154
  1428
    }
slouken@5154
  1429
slouken@5154
  1430
    points[0].x = rect->x;
slouken@5154
  1431
    points[0].y = rect->y;
slouken@5154
  1432
    points[1].x = rect->x+rect->w-1;
slouken@5154
  1433
    points[1].y = rect->y;
slouken@5154
  1434
    points[2].x = rect->x+rect->w-1;
slouken@5154
  1435
    points[2].y = rect->y+rect->h-1;
slouken@5154
  1436
    points[3].x = rect->x;
slouken@5154
  1437
    points[3].y = rect->y+rect->h-1;
slouken@5154
  1438
    points[4].x = rect->x;
slouken@5154
  1439
    points[4].y = rect->y;
slouken@5154
  1440
    return SDL_RenderDrawLines(renderer, points, 5);
slouken@5154
  1441
}
slouken@5154
  1442
slouken@5154
  1443
int
slouken@5154
  1444
SDL_RenderDrawRects(SDL_Renderer * renderer,
slouken@5297
  1445
                    const SDL_Rect * rects, int count)
slouken@5154
  1446
{
slouken@5154
  1447
    int i;
slouken@5154
  1448
slouken@5154
  1449
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1450
slouken@5154
  1451
    if (!rects) {
icculus@7037
  1452
        return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
slouken@5154
  1453
    }
slouken@5154
  1454
    if (count < 1) {
slouken@5154
  1455
        return 0;
slouken@5154
  1456
    }
slouken@5154
  1457
slouken@6260
  1458
    /* Don't draw while we're hidden */
slouken@6260
  1459
    if (renderer->hidden) {
slouken@6060
  1460
        return 0;
slouken@6060
  1461
    }
slouken@5154
  1462
    for (i = 0; i < count; ++i) {
slouken@5297
  1463
        if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
slouken@5154
  1464
            return -1;
slouken@5154
  1465
        }
slouken@5154
  1466
    }
slouken@5154
  1467
    return 0;
slouken@5154
  1468
}
slouken@5154
  1469
slouken@5154
  1470
int
slouken@5154
  1471
SDL_RenderFillRect(SDL_Renderer * renderer, const SDL_Rect * rect)
slouken@5154
  1472
{
slouken@7511
  1473
    SDL_Rect full_rect = { 0, 0, 0, 0 };
slouken@6232
  1474
slouken@5331
  1475
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@6232
  1476
slouken@5331
  1477
    /* If 'rect' == NULL, then outline the whole surface */
slouken@5331
  1478
    if (!rect) {
slouken@6528
  1479
        SDL_RenderGetViewport(renderer, &full_rect);
slouken@5331
  1480
        full_rect.x = 0;
slouken@5331
  1481
        full_rect.y = 0;
slouken@5331
  1482
        rect = &full_rect;
slouken@5331
  1483
    }
slouken@5297
  1484
    return SDL_RenderFillRects(renderer, rect, 1);
slouken@5154
  1485
}
slouken@5154
  1486
slouken@5154
  1487
int
slouken@5154
  1488
SDL_RenderFillRects(SDL_Renderer * renderer,
slouken@5297
  1489
                    const SDL_Rect * rects, int count)
slouken@5154
  1490
{
slouken@6528
  1491
    SDL_FRect *frects;
slouken@6528
  1492
    int i;
slouken@6528
  1493
    int status;
slouken@6528
  1494
slouken@5154
  1495
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1496
slouken@5154
  1497
    if (!rects) {
icculus@7037
  1498
        return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
slouken@5154
  1499
    }
slouken@5154
  1500
    if (count < 1) {
slouken@5154
  1501
        return 0;
slouken@5154
  1502
    }
slouken@6260
  1503
    /* Don't draw while we're hidden */
slouken@6260
  1504
    if (renderer->hidden) {
slouken@6060
  1505
        return 0;
slouken@6060
  1506
    }
slouken@6528
  1507
slouken@6528
  1508
    frects = SDL_stack_alloc(SDL_FRect, count);
slouken@6528
  1509
    if (!frects) {
icculus@7037
  1510
        return SDL_OutOfMemory();
slouken@6528
  1511
    }
slouken@6528
  1512
    for (i = 0; i < count; ++i) {
slouken@6528
  1513
        frects[i].x = rects[i].x * renderer->scale.x;
slouken@6528
  1514
        frects[i].y = rects[i].y * renderer->scale.y;
slouken@6528
  1515
        frects[i].w = rects[i].w * renderer->scale.x;
slouken@6528
  1516
        frects[i].h = rects[i].h * renderer->scale.y;
slouken@6528
  1517
    }
slouken@6528
  1518
slouken@6528
  1519
    status = renderer->RenderFillRects(renderer, frects, count);
slouken@6528
  1520
slouken@6528
  1521
    SDL_stack_free(frects);
slouken@6528
  1522
slouken@6528
  1523
    return status;
slouken@5154
  1524
}
slouken@5154
  1525
slouken@5154
  1526
int
slouken@5154
  1527
SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
slouken@5154
  1528
               const SDL_Rect * srcrect, const SDL_Rect * dstrect)
slouken@5154
  1529
{
icculus@6545
  1530
    SDL_Rect real_srcrect = { 0, 0, 0, 0 };
icculus@6545
  1531
    SDL_Rect real_dstrect = { 0, 0, 0, 0 };
slouken@6528
  1532
    SDL_FRect frect;
slouken@5154
  1533
slouken@5154
  1534
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1535
    CHECK_TEXTURE_MAGIC(texture, -1);
slouken@5154
  1536
slouken@5154
  1537
    if (renderer != texture->renderer) {
icculus@7037
  1538
        return SDL_SetError("Texture was not created with this renderer");
slouken@5154
  1539
    }
slouken@5154
  1540
slouken@5154
  1541
    real_srcrect.x = 0;
slouken@5154
  1542
    real_srcrect.y = 0;
slouken@5154
  1543
    real_srcrect.w = texture->w;
slouken@5154
  1544
    real_srcrect.h = texture->h;
slouken@5154
  1545
    if (srcrect) {
slouken@5154
  1546
        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
slouken@5154
  1547
            return 0;
slouken@5154
  1548
        }
slouken@5154
  1549
    }
slouken@5154
  1550
slouken@6528
  1551
    SDL_RenderGetViewport(renderer, &real_dstrect);
slouken@5154
  1552
    real_dstrect.x = 0;
slouken@5154
  1553
    real_dstrect.y = 0;
slouken@5369
  1554
    if (dstrect) {
slouken@7563
  1555
        if (!SDL_HasIntersection(dstrect, &real_dstrect)) {
slouken@5369
  1556
            return 0;
slouken@5369
  1557
        }
slouken@7563
  1558
        real_dstrect = *dstrect;
slouken@5154
  1559
    }
slouken@5154
  1560
slouken@5156
  1561
    if (texture->native) {
slouken@5156
  1562
        texture = texture->native;
slouken@5156
  1563
    }
slouken@5156
  1564
slouken@6260
  1565
    /* Don't draw while we're hidden */
slouken@6260
  1566
    if (renderer->hidden) {
slouken@6060
  1567
        return 0;
slouken@6060
  1568
    }
slouken@6528
  1569
slouken@6528
  1570
    frect.x = real_dstrect.x * renderer->scale.x;
slouken@6528
  1571
    frect.y = real_dstrect.y * renderer->scale.y;
slouken@6528
  1572
    frect.w = real_dstrect.w * renderer->scale.x;
slouken@6528
  1573
    frect.h = real_dstrect.h * renderer->scale.y;
slouken@6528
  1574
slouken@6528
  1575
    return renderer->RenderCopy(renderer, texture, &real_srcrect, &frect);
slouken@5154
  1576
}
slouken@5154
  1577
gabomdq@6320
  1578
gabomdq@6320
  1579
int
gabomdq@6320
  1580
SDL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
gabomdq@6320
  1581
               const SDL_Rect * srcrect, const SDL_Rect * dstrect,
gabomdq@6320
  1582
               const double angle, const SDL_Point *center, const SDL_RendererFlip flip)
gabomdq@6320
  1583
{
icculus@6546
  1584
    SDL_Rect real_srcrect = { 0, 0, 0, 0 };
icculus@6546
  1585
    SDL_Rect real_dstrect = { 0, 0, 0, 0 };
gabomdq@6320
  1586
    SDL_Point real_center;
slouken@6528
  1587
    SDL_FRect frect;
slouken@6528
  1588
    SDL_FPoint fcenter;
gabomdq@6320
  1589
gabomdq@6320
  1590
    CHECK_RENDERER_MAGIC(renderer, -1);
gabomdq@6320
  1591
    CHECK_TEXTURE_MAGIC(texture, -1);
gabomdq@6320
  1592
gabomdq@6320
  1593
    if (renderer != texture->renderer) {
icculus@7037
  1594
        return SDL_SetError("Texture was not created with this renderer");
gabomdq@6320
  1595
    }
gabomdq@6320
  1596
    if (!renderer->RenderCopyEx) {
icculus@7037
  1597
        return SDL_SetError("Renderer does not support RenderCopyEx");
gabomdq@6320
  1598
    }
slouken@7191
  1599
gabomdq@6320
  1600
    real_srcrect.x = 0;
gabomdq@6320
  1601
    real_srcrect.y = 0;
gabomdq@6320
  1602
    real_srcrect.w = texture->w;
gabomdq@6320
  1603
    real_srcrect.h = texture->h;
gabomdq@6320
  1604
    if (srcrect) {
gabomdq@6320
  1605
        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
gabomdq@6320
  1606
            return 0;
gabomdq@6320
  1607
        }
gabomdq@6320
  1608
    }
gabomdq@6320
  1609
gabomdq@6320
  1610
    /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
slouken@6528
  1611
    if (dstrect) {
slouken@6528
  1612
        real_dstrect = *dstrect;
slouken@6528
  1613
    } else {
slouken@6528
  1614
        SDL_RenderGetViewport(renderer, &real_dstrect);
gabomdq@6399
  1615
        real_dstrect.x = 0;
gabomdq@6399
  1616
        real_dstrect.y = 0;
gabomdq@6320
  1617
    }
gabomdq@6320
  1618
gabomdq@6320
  1619
    if (texture->native) {
gabomdq@6320
  1620
        texture = texture->native;
gabomdq@6320
  1621
    }
gabomdq@6320
  1622
gabomdq@6320
  1623
    if(center) real_center = *center;
gabomdq@6320
  1624
    else {
gabomdq@6320
  1625
        real_center.x = real_dstrect.w/2;
gabomdq@6320
  1626
        real_center.y = real_dstrect.h/2;
gabomdq@6320
  1627
    }
gabomdq@6320
  1628
slouken@6528
  1629
    frect.x = real_dstrect.x * renderer->scale.x;
slouken@6528
  1630
    frect.y = real_dstrect.y * renderer->scale.y;
slouken@6528
  1631
    frect.w = real_dstrect.w * renderer->scale.x;
slouken@6528
  1632
    frect.h = real_dstrect.h * renderer->scale.y;
slouken@6528
  1633
slouken@6528
  1634
    fcenter.x = real_center.x * renderer->scale.x;
slouken@6528
  1635
    fcenter.y = real_center.y * renderer->scale.y;
slouken@6528
  1636
slouken@6528
  1637
    return renderer->RenderCopyEx(renderer, texture, &real_srcrect, &frect, angle, &fcenter, flip);
gabomdq@6320
  1638
}
gabomdq@6320
  1639
slouken@5154
  1640
int
slouken@5154
  1641
SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
slouken@5154
  1642
                     Uint32 format, void * pixels, int pitch)
slouken@5154
  1643
{
slouken@5154
  1644
    SDL_Rect real_rect;
slouken@5154
  1645
slouken@5154
  1646
    CHECK_RENDERER_MAGIC(renderer, -1);
slouken@5154
  1647
slouken@5154
  1648
    if (!renderer->RenderReadPixels) {
icculus@7037
  1649
        return SDL_Unsupported();
slouken@5154
  1650
    }
slouken@5154
  1651
slouken@5154
  1652
    if (!format) {
icculus@6389
  1653
        format = SDL_GetWindowPixelFormat(renderer->window);
slouken@5154
  1654
    }
slouken@5154
  1655
slouken@5464
  1656
    real_rect.x = renderer->viewport.x;
slouken@5464
  1657
    real_rect.y = renderer->viewport.y;
slouken@5297
  1658
    real_rect.w = renderer->viewport.w;
slouken@5297
  1659
    real_rect.h = renderer->viewport.h;
slouken@5154
  1660
    if (rect) {
slouken@5154
  1661
        if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
slouken@5154
  1662
            return 0;
slouken@5154
  1663
        }
slouken@5154
  1664
        if (real_rect.y > rect->y) {
slouken@5154
  1665
            pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
slouken@5154
  1666
        }
slouken@5154
  1667
        if (real_rect.x > rect->x) {
slouken@5464
  1668
            int bpp = SDL_BYTESPERPIXEL(format);
slouken@5154
  1669
            pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
slouken@5154
  1670
        }
slouken@5154
  1671
    }
slouken@5154
  1672
slouken@5154
  1673
    return renderer->RenderReadPixels(renderer, &real_rect,
slouken@5154
  1674
                                      format, pixels, pitch);
slouken@5154
  1675
}
slouken@5154
  1676
slouken@5154
  1677
void
slouken@5154
  1678
SDL_RenderPresent(SDL_Renderer * renderer)
slouken@5154
  1679
{
slouken@5154
  1680
    CHECK_RENDERER_MAGIC(renderer, );
slouken@5154
  1681
slouken@6260
  1682
    /* Don't draw while we're hidden */
slouken@6260
  1683
    if (renderer->hidden) {
slouken@6060
  1684
        return;
slouken@6060
  1685
    }
slouken@5154
  1686
    renderer->RenderPresent(renderer);
slouken@5154
  1687
}
slouken@5154
  1688
slouken@5154
  1689
void
slouken@5154
  1690
SDL_DestroyTexture(SDL_Texture * texture)
slouken@5154
  1691
{
slouken@5154
  1692
    SDL_Renderer *renderer;
slouken@5154
  1693
slouken@5154
  1694
    CHECK_TEXTURE_MAGIC(texture, );
slouken@7419
  1695
slouken@7419
  1696
    renderer = texture->renderer;
slouken@7419
  1697
    if (texture == renderer->target) {
slouken@7419
  1698
        SDL_SetRenderTarget(renderer, NULL);
slouken@7419
  1699
    }
slouken@7419
  1700
slouken@5154
  1701
    texture->magic = NULL;
slouken@5154
  1702
slouken@5154
  1703
    if (texture->next) {
slouken@5154
  1704
        texture->next->prev = texture->prev;
slouken@5154
  1705
    }
slouken@5154
  1706
    if (texture->prev) {
slouken@5154
  1707
        texture->prev->next = texture->next;
slouken@5154
  1708
    } else {
slouken@5154
  1709
        renderer->textures = texture->next;
slouken@5154
  1710
    }
slouken@5154
  1711
slouken@5156
  1712
    if (texture->native) {
slouken@5156
  1713
        SDL_DestroyTexture(texture->native);
slouken@5156
  1714
    }
slouken@5156
  1715
    if (texture->yuv) {
slouken@5156
  1716
        SDL_SW_DestroyYUVTexture(texture->yuv);
slouken@5156
  1717
    }
slouken@5156
  1718
    if (texture->pixels) {
slouken@5156
  1719
        SDL_free(texture->pixels);
slouken@5156
  1720
    }
slouken@5156
  1721
slouken@5154
  1722
    renderer->DestroyTexture(renderer, texture);
slouken@5154
  1723
    SDL_free(texture);
slouken@5154
  1724
}
slouken@5154
  1725
slouken@5154
  1726
void
slouken@5154
  1727
SDL_DestroyRenderer(SDL_Renderer * renderer)
slouken@5154
  1728
{
slouken@5154
  1729
    CHECK_RENDERER_MAGIC(renderer, );
slouken@5154
  1730
slouken@5154
  1731
    SDL_DelEventWatch(SDL_RendererEventWatch, renderer);
slouken@5154
  1732
slouken@5154
  1733
    /* Free existing textures for this renderer */
slouken@5154
  1734
    while (renderer->textures) {
slouken@5154
  1735
        SDL_DestroyTexture(renderer->textures);
slouken@5154
  1736
    }
slouken@5154
  1737
slouken@6417
  1738
    if (renderer->window) {
slouken@6417
  1739
        SDL_SetWindowData(renderer->window, SDL_WINDOWRENDERDATA, NULL);
slouken@6417
  1740
    }
slouken@5528
  1741
slouken@5154
  1742
    /* It's no longer magical... */
slouken@5154
  1743
    renderer->magic = NULL;
slouken@5154
  1744
slouken@5154
  1745
    /* Free the renderer instance */
slouken@5154
  1746
    renderer->DestroyRenderer(renderer);
slouken@5154
  1747
}
slouken@5154
  1748
gabomdq@6414
  1749
int SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh)
gabomdq@6414
  1750
{
gabomdq@6414
  1751
    SDL_Renderer *renderer;
gabomdq@6414
  1752
gabomdq@6415
  1753
    CHECK_TEXTURE_MAGIC(texture, -1);
gabomdq@6414
  1754
    renderer = texture->renderer;
slouken@7318
  1755
    if (texture->native) {
slouken@7318
  1756
        return SDL_GL_BindTexture(texture->native, texw, texh);
slouken@7318
  1757
    } else if (renderer && renderer->GL_BindTexture) {
gabomdq@6414
  1758
        return renderer->GL_BindTexture(renderer, texture, texw, texh);
slouken@7318
  1759
    } else {
slouken@7318
  1760
        return SDL_Unsupported();
gabomdq@6414
  1761
    }
gabomdq@6414
  1762
}
gabomdq@6414
  1763
gabomdq@6414
  1764
int SDL_GL_UnbindTexture(SDL_Texture *texture)
gabomdq@6414
  1765
{
gabomdq@6414
  1766
    SDL_Renderer *renderer;
gabomdq@6414
  1767
gabomdq@6415
  1768
    CHECK_TEXTURE_MAGIC(texture, -1);
gabomdq@6414
  1769
    renderer = texture->renderer;
gabomdq@6414
  1770
    if (renderer && renderer->GL_UnbindTexture) {
gabomdq@6414
  1771
        return renderer->GL_UnbindTexture(renderer, texture);
gabomdq@6414
  1772
    }
gabomdq@6414
  1773
icculus@7037
  1774
    return SDL_Unsupported();
gabomdq@6414
  1775
}
gabomdq@6414
  1776
slouken@5154
  1777
/* vi: set ts=4 sw=4 expandtab: */