| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2004 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public |
| License as published by the Free Software Foundation; either |
| version 2 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public |
| License along with this library; if not, write to the Free |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| /* |
| File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability |
| 27 March 2003 |
| |
| Implements RISC OS full screen display. |
| */ |
| |
| #include "SDL_video.h" |
| #include "SDL_mouse.h" |
| #include "../SDL_sysvideo.h" |
| #include "../SDL_pixels_c.h" |
| #include "../../events/SDL_events_c.h" |
| |
| #include "SDL_riscostask.h" |
| #include "SDL_riscosvideo.h" |
| #include "SDL_riscosevents_c.h" |
| #include "SDL_riscosmouse_c.h" |
| |
| #include "kernel.h" |
| #include "swis.h" |
| #include "unixlib/os.h" |
| #include "unixlib/local.h" |
| |
| /* Private structures */ |
| typedef struct tagScreenModeBlock |
| { |
| int flags; // mode selector flags, bit 0 = 1, bit 1-7 format specifier, 8-31 reserved |
| int x_pixels; |
| int y_pixels; |
| int pixel_depth; // 2^pixel_depth = bpp,i.e. 0 = 1, 1 = 2, 4 = 16, 5 = 32 |
| int frame_rate; // -1 use first match |
| int mode_vars[5]; // array of index, value pairs terminated by -1 |
| } SCREENMODEBLOCK; |
| |
| |
| /* Helper functions */ |
| void FULLSCREEN_SetDeviceMode(_THIS); |
| int FULLSCREEN_SetMode(int width, int height, int bpp); |
| void FULLSCREEN_SetupBanks(_THIS); |
| |
| /* SDL video device functions for fullscreen mode */ |
| static int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
| static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface); |
| void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon); |
| extern int RISCOS_GetWmInfo(_THIS, SDL_SysWMinfo *info); |
| |
| /* UpdateRects variants */ |
| static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects); |
| static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects); |
| static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects); |
| static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects); |
| static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects); |
| static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects); |
| |
| /* Local helper functions */ |
| static int cmpmodes(const void *va, const void *vb); |
| static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h); |
| void FULLSCREEN_SetWriteBank(int bank); |
| void FULLSCREEN_SetDisplayBank(int bank); |
| static void FULLSCREEN_DisableEscape(); |
| static void FULLSCREEN_EnableEscape(); |
| void FULLSCREEN_BuildModeList(_THIS); |
| |
| /* Following variable is set up in riskosTask.c */ |
| extern int riscos_backbuffer; /* Create a back buffer in system memory for full screen mode */ |
| |
| /* Following is used to create a sprite back buffer */ |
| extern unsigned char *WIMP_CreateBuffer(int width, int height, int bpp); |
| |
| /* Fast assembler copy */ |
| extern void RISCOS_Put32(void *to, int pixels, int pitch, int rows, void *from, int src_skip_bytes); |
| |
| SDL_Surface *FULLSCREEN_SetVideoMode(_THIS, SDL_Surface *current, |
| int width, int height, int bpp, Uint32 flags) |
| { |
| _kernel_swi_regs regs; |
| Uint32 Rmask = 0; |
| Uint32 Gmask = 0; |
| Uint32 Bmask = 0; |
| int create_back_buffer = riscos_backbuffer; |
| |
| switch(bpp) |
| { |
| case 8: |
| flags |= SDL_HWPALETTE; |
| break; |
| |
| case 15: |
| case 16: |
| Bmask = 0x00007c00; |
| Gmask = 0x000003e0; |
| Rmask = 0x0000001f; |
| break; |
| |
| case 32: |
| Bmask = 0x00ff0000; |
| Gmask = 0x0000ff00; |
| Rmask = 0x000000ff; |
| break; |
| |
| default: |
| SDL_SetError("Pixel depth not supported"); |
| return NULL; |
| break; |
| } |
| |
| if (FULLSCREEN_SetMode(width, height, bpp) == 0) |
| { |
| SDL_SetError("Couldn't set requested mode"); |
| return (NULL); |
| } |
| |
| /* printf("Setting mode %dx%d\n", width, height); */ |
| |
| /* Allocate the new pixel format for the screen */ |
| if ( ! SDL_ReallocFormat(current, bpp, Rmask, Gmask, Bmask, 0) ) { |
| RISCOS_RestoreWimpMode(); |
| SDL_SetError("Couldn't allocate new pixel format for requested mode"); |
| return(NULL); |
| } |
| |
| /* Set up the new mode framebuffer */ |
| current->w = width; |
| this->hidden->height = current->h = height; |
| |
| regs.r[0] = -1; /* -1 for current screen mode */ |
| |
| /* Get screen width in bytes */ |
| regs.r[1] = 6; // Screen Width in bytes |
| _kernel_swi(OS_ReadModeVariable, ®s, ®s); |
| |
| current->pitch = regs.r[2]; |
| |
| if (flags & SDL_DOUBLEBUF) |
| { |
| regs.r[0] = 2; /* Screen area */ |
| _kernel_swi(OS_ReadDynamicArea, ®s, ®s); |
| |
| /* Reg 1 has amount of memory currently used for display */ |
| regs.r[0] = 2; /* Screen area */ |
| regs.r[1] = (current->pitch * height * 2) - regs.r[1]; |
| if (_kernel_swi(OS_ChangeDynamicArea, ®s, ®s) != NULL) |
| { |
| /* Can't allocate enough screen memory for double buffer */ |
| flags &= ~SDL_DOUBLEBUF; |
| } |
| } |
| |
| current->flags = flags | SDL_FULLSCREEN | SDL_HWSURFACE | SDL_PREALLOC; |
| |
| |
| /* Need to set display banks here for double buffering */ |
| if (flags & SDL_DOUBLEBUF) |
| { |
| FULLSCREEN_SetWriteBank(0); |
| FULLSCREEN_SetDisplayBank(1); |
| |
| create_back_buffer = 0; /* Don't need a back buffer for a double buffered display */ |
| } |
| |
| FULLSCREEN_SetupBanks(this); |
| |
| if (create_back_buffer) |
| { |
| /* If not double buffered we may need to create a memory |
| ** back buffer to simulate processing on other OSes. |
| ** This is turned on by setting the enviromental variable |
| ** SDL$<name>$BackBuffer >= 1 |
| */ |
| if (riscos_backbuffer == 3) |
| this->hidden->bank[0] = WIMP_CreateBuffer(width, height, bpp); |
| else |
| this->hidden->bank[0] = SDL_malloc(height * current->pitch); |
| if (this->hidden->bank[0] == 0) |
| { |
| RISCOS_RestoreWimpMode(); |
| SDL_SetError("Couldnt allocate memory for back buffer"); |
| return (NULL); |
| } |
| /* Surface updated in programs is now a software surface */ |
| current->flags &= ~SDL_HWSURFACE; |
| } |
| |
| /* Store address of allocated screen bank to be freed later */ |
| if (this->hidden->alloc_bank) SDL_free(this->hidden->alloc_bank); |
| if (create_back_buffer) |
| { |
| this->hidden->alloc_bank = this->hidden->bank[0]; |
| if (riscos_backbuffer == 3) |
| { |
| this->hidden->bank[0] += 60; /* Start of sprite data */ |
| if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */ |
| } |
| } else |
| this->hidden->alloc_bank = 0; |
| |
| // Clear both banks to black |
| SDL_memset(this->hidden->bank[0], 0, height * current->pitch); |
| SDL_memset(this->hidden->bank[1], 0, height * current->pitch); |
| |
| this->hidden->current_bank = 0; |
| current->pixels = this->hidden->bank[0]; |
| |
| /* Have to set the screen here, so SetDeviceMode will pick it up */ |
| this->screen = current; |
| |
| /* Reset device functions for the wimp */ |
| FULLSCREEN_SetDeviceMode(this); |
| |
| /* FULLSCREEN_DisableEscape(); */ |
| |
| /* We're done */ |
| return(current); |
| } |
| |
| /* Reset any device functions that have been changed because we have run in WIMP mode */ |
| void FULLSCREEN_SetDeviceMode(_THIS) |
| { |
| /* Update rects is different if we have a backbuffer */ |
| |
| if (riscos_backbuffer && (this->screen->flags & SDL_DOUBLEBUF) == 0) |
| { |
| switch(riscos_backbuffer) |
| { |
| case 2: /* ARM code full word copy */ |
| switch(this->screen->format->BytesPerPixel) |
| { |
| case 1: /* 8bpp modes */ |
| this->UpdateRects = FULLSCREEN_UpdateRects8bpp; |
| break; |
| case 2: /* 15/16bpp modes */ |
| this->UpdateRects = FULLSCREEN_UpdateRects16bpp; |
| break; |
| case 4: /* 32 bpp modes */ |
| this->UpdateRects = FULLSCREEN_UpdateRects32bpp; |
| break; |
| |
| default: /* Just default to the memcpy routine */ |
| this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy; |
| break; |
| } |
| break; |
| |
| case 3: /* Use OS sprite plot routine */ |
| this->UpdateRects = FULLSCREEN_UpdateRectsOS; |
| break; |
| |
| default: /* Old but safe memcpy */ |
| this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy; |
| break; |
| } |
| } else |
| this->UpdateRects = FULLSCREEN_UpdateRects; /* Default do nothing implementation */ |
| |
| this->SetColors = FULLSCREEN_SetColors; |
| |
| this->FlipHWSurface = FULLSCREEN_FlipHWSurface; |
| |
| this->SetCaption = FULLSCREEN_SetWMCaption; |
| this->SetIcon = NULL; |
| this->IconifyWindow = NULL; |
| |
| this->ShowWMCursor = RISCOS_ShowWMCursor; |
| this->WarpWMCursor = FULLSCREEN_WarpWMCursor; |
| |
| this->PumpEvents = FULLSCREEN_PumpEvents; |
| } |
| |
| /* Query for the list of available video modes */ |
| void FULLSCREEN_BuildModeList(_THIS) |
| { |
| _kernel_swi_regs regs; |
| char *enumInfo = NULL; |
| char *enum_ptr; |
| int *blockInfo; |
| int j; |
| int num_modes; |
| |
| /* Find out how much space we need */ |
| regs.r[0] = 2; /* Reason code */ |
| regs.r[2] = 0; /* Number of modes to skip */ |
| regs.r[6] = 0; /* pointer to block or 0 for count */ |
| regs.r[7] = 0; /* Size of block in bytes */ |
| _kernel_swi(OS_ScreenMode, ®s, ®s); |
| |
| num_modes = -regs.r[2]; |
| |
| /* Video memory should be in r[5] */ |
| this->info.video_mem = regs.r[5]/1024; |
| |
| enumInfo = (unsigned char *)SDL_malloc(-regs.r[7]); |
| if (enumInfo == NULL) |
| { |
| SDL_OutOfMemory(); |
| return; |
| } |
| /* Read mode information into block */ |
| regs.r[2] = 0; |
| regs.r[6] = (int)enumInfo; |
| regs.r[7] = -regs.r[7]; |
| _kernel_swi(OS_ScreenMode, ®s, ®s); |
| |
| enum_ptr = enumInfo; |
| |
| for (j =0; j < num_modes;j++) |
| { |
| blockInfo = (int *)enum_ptr; |
| if ((blockInfo[1] & 255) == 1) /* We understand this format */ |
| { |
| switch(blockInfo[4]) |
| { |
| case 3: /* 8 bits per pixel */ |
| FULLSCREEN_AddMode(this, 8, blockInfo[2], blockInfo[3]); |
| break; |
| case 4: /* 15 bits per pixel */ |
| FULLSCREEN_AddMode(this, 15, blockInfo[2], blockInfo[3]); |
| break; |
| case 5: /* 32 bits per pixel */ |
| FULLSCREEN_AddMode(this, 32, blockInfo[2], blockInfo[3]); |
| break; |
| } |
| } |
| |
| enum_ptr += blockInfo[0]; |
| } |
| |
| SDL_free(enumInfo); |
| |
| /* Sort the mode lists */ |
| for ( j=0; j<NUM_MODELISTS; ++j ) { |
| if ( SDL_nummodes[j] > 0 ) { |
| SDL_qsort(SDL_modelist[j], SDL_nummodes[j], sizeof *SDL_modelist[j], cmpmodes); |
| } |
| } |
| } |
| |
| static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface) |
| { |
| _kernel_swi_regs regs; |
| regs.r[0] = 19; |
| |
| FULLSCREEN_SetDisplayBank(this->hidden->current_bank); |
| this->hidden->current_bank ^= 1; |
| FULLSCREEN_SetWriteBank(this->hidden->current_bank); |
| surface->pixels = this->hidden->bank[this->hidden->current_bank]; |
| |
| /* Wait for Vsync */ |
| _kernel_swi(OS_Byte, ®s, ®s); |
| |
| return(0); |
| } |
| |
| /* Nothing to do if we are writing direct to hardware */ |
| static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects) |
| { |
| } |
| |
| /* Safe but slower Memory copy from our allocated back buffer */ |
| static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects) |
| { |
| int j; |
| char *to, *from; |
| int pitch = this->screen->pitch; |
| int row; |
| int xmult = this->screen->format->BytesPerPixel; |
| for (j = 0; j < numrects; j++) |
| { |
| from = this->hidden->bank[0] + rects->x * xmult + rects->y * pitch; |
| to = this->hidden->bank[1] + rects->x * xmult + rects->y * pitch; |
| for (row = 0; row < rects->h; row++) |
| { |
| SDL_memcpy(to, from, rects->w * xmult); |
| from += pitch; |
| to += pitch; |
| } |
| rects++; |
| } |
| } |
| |
| /* Use optimized assembler memory copy. Deliberately copies extra columns if |
| necessary to ensure the rectangle is word aligned. */ |
| static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects) |
| { |
| int j; |
| char *to, *from; |
| int pitch = this->screen->pitch; |
| int width_bytes; |
| int src_skip_bytes; |
| |
| for (j = 0; j < numrects; j++) |
| { |
| from = this->hidden->bank[0] + rects->x + rects->y * pitch; |
| to = this->hidden->bank[1] + rects->x + rects->y * pitch; |
| width_bytes = rects->w; |
| if ((int)from & 3) |
| { |
| int extra = ((int)from & 3); |
| from -= extra; |
| to -= extra; |
| width_bytes += extra; |
| } |
| if (width_bytes & 3) width_bytes += 4 - (width_bytes & 3); |
| src_skip_bytes = pitch - width_bytes; |
| |
| RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes); |
| rects++; |
| } |
| } |
| |
| /* Use optimized assembler memory copy. Deliberately copies extra columns if |
| necessary to ensure the rectangle is word aligned. */ |
| static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects) |
| { |
| int j; |
| char *to, *from; |
| int pitch = this->screen->pitch; |
| int width_bytes; |
| int src_skip_bytes; |
| |
| for (j = 0; j < numrects; j++) |
| { |
| from = this->hidden->bank[0] + (rects->x << 1) + rects->y * pitch; |
| to = this->hidden->bank[1] + (rects->x << 1) + rects->y * pitch; |
| width_bytes = (((int)rects->w) << 1); |
| if ((int)from & 3) |
| { |
| from -= 2; |
| to -= 2; |
| width_bytes += 2; |
| } |
| if (width_bytes & 3) width_bytes += 2; |
| src_skip_bytes = pitch - width_bytes; |
| |
| RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes); |
| rects++; |
| } |
| } |
| |
| /* Use optimized assembler memory copy. 32 bpp modes are always word aligned */ |
| static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects) |
| { |
| int j; |
| char *to, *from; |
| int pitch = this->screen->pitch; |
| int width; |
| |
| for (j = 0; j < numrects; j++) |
| { |
| from = this->hidden->bank[0] + (rects->x << 2) + rects->y * pitch; |
| to = this->hidden->bank[1] + (rects->x << 2) + rects->y * pitch; |
| width = (int)rects->w ; |
| |
| RISCOS_Put32(to, width, pitch, (int)rects->h, from, pitch - (width << 2)); |
| rects++; |
| } |
| } |
| |
| /* Use operating system sprite plots. Currently this is much slower than the |
| other variants however accelerated sprite plotting can be seen on the horizon |
| so this prepares for it. */ |
| static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects) |
| { |
| _kernel_swi_regs regs; |
| _kernel_oserror *err; |
| int j; |
| int y; |
| |
| regs.r[0] = 28 + 512; |
| regs.r[1] = (unsigned int)this->hidden->alloc_bank; |
| regs.r[2] = (unsigned int)this->hidden->alloc_bank+16; |
| regs.r[5] = 0; |
| |
| for (j = 0; j < numrects; j++) |
| { |
| y = this->screen->h - rects->y; /* top of clipping region */ |
| _kernel_oswrch(24); /* Set graphics clip region */ |
| _kernel_oswrch((rects->x << this->hidden->xeig) & 0xFF); /* left */ |
| _kernel_oswrch(((rects->x << this->hidden->xeig) >> 8) & 0xFF); |
| _kernel_oswrch(((y - rects->h) << this->hidden->yeig) & 0xFF); /* bottom */ |
| _kernel_oswrch((((y - rects->h) << this->hidden->yeig)>> 8) & 0xFF); |
| _kernel_oswrch(((rects->x + rects->w - 1) << this->hidden->xeig) & 0xFF); /* right */ |
| _kernel_oswrch((((rects->x + rects->w - 1)<< this->hidden->xeig) >> 8) & 0xFF); |
| _kernel_oswrch(((y-1) << this->hidden->yeig) & 0xFF); /* top */ |
| _kernel_oswrch((((y-1) << this->hidden->yeig) >> 8) & 0xFF); |
| |
| regs.r[3] = 0; |
| regs.r[4] = 0; |
| |
| if ((err = _kernel_swi(OS_SpriteOp, ®s, ®s)) != 0) |
| { |
| printf("OS_SpriteOp failed \n%s\n",err->errmess); |
| } |
| |
| rects++; |
| |
| /* Reset to full screen clipping */ |
| _kernel_oswrch(24); /* Set graphics clip region */ |
| _kernel_oswrch(0); /* left */ |
| _kernel_oswrch(0); |
| _kernel_oswrch(0); /* bottom */ |
| _kernel_oswrch(0); |
| _kernel_oswrch(((this->screen->w-1) << this->hidden->xeig) & 0xFF); /* right */ |
| _kernel_oswrch((((this->screen->w-1) << this->hidden->xeig) >> 8) & 0xFF); |
| _kernel_oswrch(((this->screen->h-1) << this->hidden->yeig) & 0xFF); /* top */ |
| _kernel_oswrch((((this->screen->h-1) << this->hidden->yeig) >> 8) & 0xFF); |
| } |
| } |
| |
| |
| int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
| { |
| _kernel_swi_regs regs; |
| int palette[256]; |
| |
| regs.r[0] = -1; |
| regs.r[1] = -1; |
| regs.r[2] = (int)palette; |
| regs.r[3] = 1024; |
| regs.r[4] = 0; |
| _kernel_swi(ColourTrans_ReadPalette, ®s, ®s); |
| |
| while(ncolors--) |
| { |
| palette[firstcolor] = ((colors->b) << 24) | ((colors->g) << 16) | ((colors->r) << 8); |
| firstcolor++; |
| colors++; |
| } |
| |
| regs.r[0] = -1; |
| regs.r[1] = -1; |
| regs.r[2] = (int)palette; |
| regs.r[3] = 0; |
| regs.r[4] = 0; |
| _kernel_swi(ColourTrans_WritePalette, ®s, ®s); |
| |
| return(1); |
| } |
| |
| |
| static int cmpmodes(const void *va, const void *vb) |
| { |
| SDL_Rect *a = *(SDL_Rect **)va; |
| SDL_Rect *b = *(SDL_Rect **)vb; |
| if(a->w == b->w) |
| return b->h - a->h; |
| else |
| return b->w - a->w; |
| } |
| |
| static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h) |
| { |
| SDL_Rect *mode; |
| int i, index; |
| int next_mode; |
| |
| /* Check to see if we already have this mode */ |
| if ( bpp < 8 ) { /* Not supported */ |
| return(0); |
| } |
| index = ((bpp+7)/8)-1; |
| for ( i=0; i<SDL_nummodes[index]; ++i ) { |
| mode = SDL_modelist[index][i]; |
| if ( (mode->w == w) && (mode->h == h) ) { |
| return(0); |
| } |
| } |
| |
| /* Set up the new video mode rectangle */ |
| mode = (SDL_Rect *)SDL_malloc(sizeof *mode); |
| if ( mode == NULL ) { |
| SDL_OutOfMemory(); |
| return(-1); |
| } |
| mode->x = 0; |
| mode->y = 0; |
| mode->w = w; |
| mode->h = h; |
| |
| /* Allocate the new list of modes, and fill in the new mode */ |
| next_mode = SDL_nummodes[index]; |
| SDL_modelist[index] = (SDL_Rect **) |
| SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); |
| if ( SDL_modelist[index] == NULL ) { |
| SDL_OutOfMemory(); |
| SDL_nummodes[index] = 0; |
| SDL_free(mode); |
| return(-1); |
| } |
| SDL_modelist[index][next_mode] = mode; |
| SDL_modelist[index][next_mode+1] = NULL; |
| SDL_nummodes[index]++; |
| |
| return(0); |
| } |
| |
| void FULLSCREEN_SetWriteBank(int bank) |
| { |
| _kernel_swi_regs regs; |
| regs.r[0] = 112; |
| regs.r[1] = bank+1; |
| _kernel_swi(OS_Byte, ®s, ®s); |
| } |
| |
| void FULLSCREEN_SetDisplayBank(int bank) |
| { |
| _kernel_swi_regs regs; |
| regs.r[0] = 113; |
| regs.r[1] = bank+1; |
| _kernel_swi(OS_Byte, ®s, ®s); |
| } |
| |
| |
| /** Disable special escape key processing */ |
| static void FULLSCREEN_DisableEscape() |
| { |
| _kernel_swi_regs regs; |
| regs.r[0] = 229; |
| regs.r[1] = 1; |
| regs.r[2] = 0; |
| _kernel_swi(OS_Byte, ®s, ®s); |
| |
| } |
| |
| /** Enable special escape key processing */ |
| static void FULLSCREEN_EnableEscape() |
| { |
| _kernel_swi_regs regs; |
| regs.r[0] = 229; |
| regs.r[1] = 0; |
| regs.r[2] = 0; |
| _kernel_swi(OS_Byte, ®s, ®s); |
| |
| } |
| |
| /** Store caption in case this is called before we create a window */ |
| void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon) |
| { |
| SDL_strlcpy(this->hidden->title, title, SDL_arraysize(this->hidden->title)); |
| } |
| |
| /* Set screen mode |
| * |
| * Returns 1 if mode is set ok, otherwise 0 |
| */ |
| |
| int FULLSCREEN_SetMode(int width, int height, int bpp) |
| { |
| SCREENMODEBLOCK smb; |
| _kernel_swi_regs regs; |
| |
| smb.flags = 1; |
| smb.x_pixels = width; |
| smb.y_pixels = height; |
| smb.mode_vars[0] = -1; |
| |
| switch(bpp) |
| { |
| case 8: |
| smb.pixel_depth = 3; |
| /* Note: Need to set ModeFlags to 128 and NColour variables to 255 get full 8 bit palette */ |
| smb.mode_vars[0] = 0; smb.mode_vars[1] = 128; /* Mode flags */ |
| smb.mode_vars[2] = 3; smb.mode_vars[3] = 255; /* NColour (number of colours -1) */ |
| smb.mode_vars[4] = -1; /* End of list */ |
| break; |
| |
| case 15: |
| case 16: |
| smb.pixel_depth = 4; |
| break; |
| |
| case 32: |
| smb.pixel_depth = 5; |
| break; |
| |
| default: |
| SDL_SetError("Pixel depth not supported"); |
| return 0; |
| break; |
| } |
| |
| smb.frame_rate = -1; |
| |
| regs.r[0] = 0; |
| regs.r[1] = (int)&smb; |
| |
| if (_kernel_swi(OS_ScreenMode, ®s, ®s) != 0) |
| { |
| SDL_SetError("Couldn't set requested mode"); |
| return 0; |
| } |
| |
| /* Turn cursor off*/ |
| _kernel_oswrch(23);_kernel_oswrch(1);_kernel_oswrch(0); |
| _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0); |
| _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0); |
| _kernel_oswrch(0);_kernel_oswrch(0); |
| |
| return 1; |
| } |
| |
| /* Get Start addresses for the screen banks */ |
| void FULLSCREEN_SetupBanks(_THIS) |
| { |
| _kernel_swi_regs regs; |
| int block[5]; |
| block[0] = 148; /* Write screen start */ |
| block[1] = 149; /* Display screen start */ |
| block[2] = 4; /* X eig factor */ |
| block[3] = 5; /* Y eig factor */ |
| block[4] = -1; /* End of list of variables to request */ |
| |
| regs.r[0] = (int)block; |
| regs.r[1] = (int)block; |
| _kernel_swi(OS_ReadVduVariables, ®s, ®s); |
| |
| this->hidden->bank[0] = (void *)block[0]; |
| this->hidden->bank[1] = (void *)block[1]; |
| this->hidden->xeig = block[2]; |
| this->hidden->yeig = block[3]; |
| } |
| |
| /* Toggle to full screen mode from the WIMP */ |
| |
| int FULLSCREEN_ToggleFromWimp(_THIS) |
| { |
| int width = this->screen->w; |
| int height = this->screen->h; |
| int bpp = this->screen->format->BitsPerPixel; |
| |
| RISCOS_StoreWimpMode(); |
| if (FULLSCREEN_SetMode(width, height, bpp)) |
| { |
| char *buffer = this->hidden->alloc_bank; /* This is start of sprite data */ |
| /* Support back buffer mode only */ |
| if (riscos_backbuffer == 0) riscos_backbuffer = 1; |
| |
| FULLSCREEN_SetupBanks(this); |
| |
| this->hidden->bank[0] = buffer + 60; /* Start of sprite data */ |
| if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */ |
| |
| this->hidden->current_bank = 0; |
| this->screen->pixels = this->hidden->bank[0]; |
| |
| /* Copy back buffer to screen memory */ |
| SDL_memcpy(this->hidden->bank[1], this->hidden->bank[0], width * height * this->screen->format->BytesPerPixel); |
| |
| FULLSCREEN_SetDeviceMode(this); |
| return 1; |
| } else |
| RISCOS_RestoreWimpMode(); |
| |
| return 0; |
| } |