src/video/psp/SDL_pspvideo.c
author Sam Lantinga
Fri, 27 Jan 2017 21:23:27 -0800
changeset 10861 71d8f9afb690
parent 10737 3406a0f8b041
child 10945 1300a3135d61
permissions -rw-r--r--
Fixed bug 3569 - GL_UpdateViewport leaves PROJECTION matrix selected

Tom Seddon

GL_ActivateRenderer may call GL_UpdateViewport, which leaves the GL_PROJECTION matrix selected. But after GL_ResetState, the GL_MODELVIEW matrix is selected, suggesting that's the intended default state.

It seems at least like these should be consistent. Presumably GL_UpdateViewport should be doing a glMatrixMode(GL_MODELVIEW) before it finishes.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2017 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 
    22 #include "../../SDL_internal.h"
    23 
    24 #if SDL_VIDEO_DRIVER_PSP
    25 
    26 /* SDL internals */
    27 #include "../SDL_sysvideo.h"
    28 #include "SDL_version.h"
    29 #include "SDL_syswm.h"
    30 #include "SDL_loadso.h"
    31 #include "SDL_events.h"
    32 #include "../../events/SDL_mouse_c.h"
    33 #include "../../events/SDL_keyboard_c.h"
    34 
    35 
    36 
    37 /* PSP declarations */
    38 #include "SDL_pspvideo.h"
    39 #include "SDL_pspevents_c.h"
    40 #include "SDL_pspgl_c.h"
    41 
    42 /* unused
    43 static SDL_bool PSP_initialized = SDL_FALSE;
    44 */
    45 static int
    46 PSP_Available(void)
    47 {
    48     return 1;
    49 }
    50 
    51 static void
    52 PSP_Destroy(SDL_VideoDevice * device)
    53 {
    54 /*    SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata; */
    55 
    56     if (device->driverdata != NULL) {
    57         device->driverdata = NULL;
    58     }
    59 }
    60 
    61 static SDL_VideoDevice *
    62 PSP_Create()
    63 {
    64     SDL_VideoDevice *device;
    65     SDL_VideoData *phdata;
    66     SDL_GLDriverData *gldata;
    67     int status;
    68 
    69     /* Check if PSP could be initialized */
    70     status = PSP_Available();
    71     if (status == 0) {
    72         /* PSP could not be used */
    73         return NULL;
    74     }
    75 
    76     /* Initialize SDL_VideoDevice structure */
    77     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
    78     if (device == NULL) {
    79         SDL_OutOfMemory();
    80         return NULL;
    81     }
    82 
    83     /* Initialize internal PSP specific data */
    84     phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
    85     if (phdata == NULL) {
    86         SDL_OutOfMemory();
    87         SDL_free(device);
    88         return NULL;
    89     }
    90 
    91         gldata = (SDL_GLDriverData *) SDL_calloc(1, sizeof(SDL_GLDriverData));
    92     if (gldata == NULL) {
    93         SDL_OutOfMemory();
    94         SDL_free(device);
    95         SDL_free(phdata);
    96         return NULL;
    97     }
    98     device->gl_data = gldata;
    99 
   100     device->driverdata = phdata;
   101 
   102     phdata->egl_initialized = SDL_TRUE;
   103 
   104 
   105     /* Setup amount of available displays */
   106     device->num_displays = 0;
   107 
   108     /* Set device free function */
   109     device->free = PSP_Destroy;
   110 
   111     /* Setup all functions which we can handle */
   112     device->VideoInit = PSP_VideoInit;
   113     device->VideoQuit = PSP_VideoQuit;
   114     device->GetDisplayModes = PSP_GetDisplayModes;
   115     device->SetDisplayMode = PSP_SetDisplayMode;
   116     device->CreateWindow = PSP_CreateWindow;
   117     device->CreateWindowFrom = PSP_CreateWindowFrom;
   118     device->SetWindowTitle = PSP_SetWindowTitle;
   119     device->SetWindowIcon = PSP_SetWindowIcon;
   120     device->SetWindowPosition = PSP_SetWindowPosition;
   121     device->SetWindowSize = PSP_SetWindowSize;
   122     device->ShowWindow = PSP_ShowWindow;
   123     device->HideWindow = PSP_HideWindow;
   124     device->RaiseWindow = PSP_RaiseWindow;
   125     device->MaximizeWindow = PSP_MaximizeWindow;
   126     device->MinimizeWindow = PSP_MinimizeWindow;
   127     device->RestoreWindow = PSP_RestoreWindow;
   128     device->SetWindowGrab = PSP_SetWindowGrab;
   129     device->DestroyWindow = PSP_DestroyWindow;
   130     device->GetWindowWMInfo = PSP_GetWindowWMInfo;
   131     device->GL_LoadLibrary = PSP_GL_LoadLibrary;
   132     device->GL_GetProcAddress = PSP_GL_GetProcAddress;
   133     device->GL_UnloadLibrary = PSP_GL_UnloadLibrary;
   134     device->GL_CreateContext = PSP_GL_CreateContext;
   135     device->GL_MakeCurrent = PSP_GL_MakeCurrent;
   136     device->GL_SetSwapInterval = PSP_GL_SetSwapInterval;
   137     device->GL_GetSwapInterval = PSP_GL_GetSwapInterval;
   138     device->GL_SwapWindow = PSP_GL_SwapWindow;
   139     device->GL_DeleteContext = PSP_GL_DeleteContext;
   140     device->HasScreenKeyboardSupport = PSP_HasScreenKeyboardSupport;
   141     device->ShowScreenKeyboard = PSP_ShowScreenKeyboard;
   142     device->HideScreenKeyboard = PSP_HideScreenKeyboard;
   143     device->IsScreenKeyboardShown = PSP_IsScreenKeyboardShown;
   144 
   145     device->PumpEvents = PSP_PumpEvents;
   146 
   147     return device;
   148 }
   149 
   150 VideoBootStrap PSP_bootstrap = {
   151     "PSP",
   152     "PSP Video Driver",
   153     PSP_Available,
   154     PSP_Create
   155 };
   156 
   157 /*****************************************************************************/
   158 /* SDL Video and Display initialization/handling functions                   */
   159 /*****************************************************************************/
   160 int
   161 PSP_VideoInit(_THIS)
   162 {
   163     SDL_VideoDisplay display;
   164     SDL_DisplayMode current_mode;
   165 
   166     SDL_zero(current_mode);
   167 
   168     current_mode.w = 480;
   169     current_mode.h = 272;
   170 
   171     current_mode.refresh_rate = 60;
   172     /* 32 bpp for default */
   173     current_mode.format = SDL_PIXELFORMAT_ABGR8888;
   174 
   175     current_mode.driverdata = NULL;
   176 
   177     SDL_zero(display);
   178     display.desktop_mode = current_mode;
   179     display.current_mode = current_mode;
   180     display.driverdata = NULL;
   181 
   182     SDL_AddVideoDisplay(&display);
   183 
   184     return 1;
   185 }
   186 
   187 void
   188 PSP_VideoQuit(_THIS)
   189 {
   190 
   191 }
   192 
   193 void
   194 PSP_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
   195 {
   196 
   197 }
   198 
   199 int
   200 PSP_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
   201 {
   202     return 0;
   203 }
   204 #define EGLCHK(stmt)                            \
   205     do {                                        \
   206         EGLint err;                             \
   207                                                 \
   208         stmt;                                   \
   209         err = eglGetError();                    \
   210         if (err != EGL_SUCCESS) {               \
   211             SDL_SetError("EGL error %d", err);  \
   212             return 0;                           \
   213         }                                       \
   214     } while (0)
   215 
   216 int
   217 PSP_CreateWindow(_THIS, SDL_Window * window)
   218 {
   219     SDL_WindowData *wdata;
   220 
   221     /* Allocate window internal data */
   222     wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
   223     if (wdata == NULL) {
   224         return SDL_OutOfMemory();
   225     }
   226 
   227     /* Setup driver data for this window */
   228     window->driverdata = wdata;
   229 
   230 
   231     /* Window has been successfully created */
   232     return 0;
   233 }
   234 
   235 int
   236 PSP_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
   237 {
   238     return SDL_Unsupported();
   239 }
   240 
   241 void
   242 PSP_SetWindowTitle(_THIS, SDL_Window * window)
   243 {
   244 }
   245 void
   246 PSP_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
   247 {
   248 }
   249 void
   250 PSP_SetWindowPosition(_THIS, SDL_Window * window)
   251 {
   252 }
   253 void
   254 PSP_SetWindowSize(_THIS, SDL_Window * window)
   255 {
   256 }
   257 void
   258 PSP_ShowWindow(_THIS, SDL_Window * window)
   259 {
   260 }
   261 void
   262 PSP_HideWindow(_THIS, SDL_Window * window)
   263 {
   264 }
   265 void
   266 PSP_RaiseWindow(_THIS, SDL_Window * window)
   267 {
   268 }
   269 void
   270 PSP_MaximizeWindow(_THIS, SDL_Window * window)
   271 {
   272 }
   273 void
   274 PSP_MinimizeWindow(_THIS, SDL_Window * window)
   275 {
   276 }
   277 void
   278 PSP_RestoreWindow(_THIS, SDL_Window * window)
   279 {
   280 }
   281 void
   282 PSP_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
   283 {
   284 
   285 }
   286 void
   287 PSP_DestroyWindow(_THIS, SDL_Window * window)
   288 {
   289 }
   290 
   291 /*****************************************************************************/
   292 /* SDL Window Manager function                                               */
   293 /*****************************************************************************/
   294 SDL_bool
   295 PSP_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
   296 {
   297     if (info->version.major <= SDL_MAJOR_VERSION) {
   298         return SDL_TRUE;
   299     } else {
   300         SDL_SetError("application not compiled with SDL %d.%d\n",
   301                      SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
   302         return SDL_FALSE;
   303     }
   304 
   305     /* Failed to get window manager information */
   306     return SDL_FALSE;
   307 }
   308 
   309 
   310 /* TO Write Me */
   311 SDL_bool PSP_HasScreenKeyboardSupport(_THIS)
   312 {
   313     return SDL_FALSE;
   314 }
   315 void PSP_ShowScreenKeyboard(_THIS, SDL_Window *window)
   316 {
   317 }
   318 void PSP_HideScreenKeyboard(_THIS, SDL_Window *window)
   319 {
   320 }
   321 SDL_bool PSP_IsScreenKeyboardShown(_THIS, SDL_Window *window)
   322 {
   323     return SDL_FALSE;
   324 }
   325 
   326 
   327 #endif /* SDL_VIDEO_DRIVER_PSP */
   328 
   329 /* vi: set ts=4 sw=4 expandtab: */