e14743d1 |
1 | /* |
2 | SDL - Simple DirectMedia Layer |
3 | Copyright (C) 1997-2009 Sam Lantinga |
4 | |
5 | This library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Library General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2 of the License, or (at your option) any later version. |
9 | |
10 | This library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Library General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Library General Public |
16 | License along with this library; if not, write to the Free |
17 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
18 | |
19 | Sam Lantinga |
20 | slouken@libsdl.org |
21 | */ |
22 | #include "SDL_config.h" |
23 | |
24 | /* |
25 | File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability |
26 | 27 March 2003 |
27 | |
28 | Implements RISC OS full screen display. |
29 | */ |
30 | |
31 | #include "SDL_video.h" |
32 | #include "SDL_mouse.h" |
33 | #include "../SDL_sysvideo.h" |
34 | #include "../SDL_pixels_c.h" |
35 | #include "../../events/SDL_events_c.h" |
36 | |
37 | #include "SDL_riscostask.h" |
38 | #include "SDL_riscosvideo.h" |
39 | #include "SDL_riscosevents_c.h" |
40 | #include "SDL_riscosmouse_c.h" |
41 | |
42 | #include "kernel.h" |
43 | #include "swis.h" |
44 | #include "unixlib/os.h" |
45 | #include "unixlib/local.h" |
46 | |
47 | /* Private structures */ |
48 | typedef struct tagScreenModeBlock |
49 | { |
50 | int flags; // mode selector flags, bit 0 = 1, bit 1-7 format specifier, 8-31 reserved |
51 | int x_pixels; |
52 | int y_pixels; |
53 | int pixel_depth; // 2^pixel_depth = bpp,i.e. 0 = 1, 1 = 2, 4 = 16, 5 = 32 |
54 | int frame_rate; // -1 use first match |
55 | int mode_vars[5]; // array of index, value pairs terminated by -1 |
56 | } SCREENMODEBLOCK; |
57 | |
58 | |
59 | /* Helper functions */ |
60 | void FULLSCREEN_SetDeviceMode(_THIS); |
61 | int FULLSCREEN_SetMode(int width, int height, int bpp); |
62 | void FULLSCREEN_SetupBanks(_THIS); |
63 | |
64 | /* SDL video device functions for fullscreen mode */ |
65 | static int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
66 | static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface); |
67 | void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon); |
68 | extern int RISCOS_GetWmInfo(_THIS, SDL_SysWMinfo *info); |
69 | |
70 | /* UpdateRects variants */ |
71 | static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects); |
72 | static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects); |
73 | static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects); |
74 | static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects); |
75 | static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects); |
76 | static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects); |
77 | |
78 | /* Local helper functions */ |
79 | static int cmpmodes(const void *va, const void *vb); |
80 | static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h); |
81 | void FULLSCREEN_SetWriteBank(int bank); |
82 | void FULLSCREEN_SetDisplayBank(int bank); |
83 | static void FULLSCREEN_DisableEscape(); |
84 | static void FULLSCREEN_EnableEscape(); |
85 | void FULLSCREEN_BuildModeList(_THIS); |
86 | |
87 | /* Following variable is set up in riskosTask.c */ |
88 | extern int riscos_backbuffer; /* Create a back buffer in system memory for full screen mode */ |
89 | |
90 | /* Following is used to create a sprite back buffer */ |
91 | extern unsigned char *WIMP_CreateBuffer(int width, int height, int bpp); |
92 | |
93 | /* Fast assembler copy */ |
94 | extern void RISCOS_Put32(void *to, int pixels, int pitch, int rows, void *from, int src_skip_bytes); |
95 | |
96 | SDL_Surface *FULLSCREEN_SetVideoMode(_THIS, SDL_Surface *current, |
97 | int width, int height, int bpp, Uint32 flags) |
98 | { |
99 | _kernel_swi_regs regs; |
100 | Uint32 Rmask = 0; |
101 | Uint32 Gmask = 0; |
102 | Uint32 Bmask = 0; |
103 | int create_back_buffer = riscos_backbuffer; |
104 | |
105 | switch(bpp) |
106 | { |
107 | case 8: |
108 | flags |= SDL_HWPALETTE; |
109 | break; |
110 | |
111 | case 15: |
112 | case 16: |
113 | Bmask = 0x00007c00; |
114 | Gmask = 0x000003e0; |
115 | Rmask = 0x0000001f; |
116 | break; |
117 | |
118 | case 32: |
119 | Bmask = 0x00ff0000; |
120 | Gmask = 0x0000ff00; |
121 | Rmask = 0x000000ff; |
122 | break; |
123 | |
124 | default: |
125 | SDL_SetError("Pixel depth not supported"); |
126 | return NULL; |
127 | break; |
128 | } |
129 | |
130 | if (FULLSCREEN_SetMode(width, height, bpp) == 0) |
131 | { |
132 | SDL_SetError("Couldn't set requested mode"); |
133 | return (NULL); |
134 | } |
135 | |
136 | /* printf("Setting mode %dx%d\n", width, height); */ |
137 | |
138 | /* Allocate the new pixel format for the screen */ |
139 | if ( ! SDL_ReallocFormat(current, bpp, Rmask, Gmask, Bmask, 0) ) { |
140 | RISCOS_RestoreWimpMode(); |
141 | SDL_SetError("Couldn't allocate new pixel format for requested mode"); |
142 | return(NULL); |
143 | } |
144 | |
145 | /* Set up the new mode framebuffer */ |
146 | current->w = width; |
147 | this->hidden->height = current->h = height; |
148 | |
149 | regs.r[0] = -1; /* -1 for current screen mode */ |
150 | |
151 | /* Get screen width in bytes */ |
152 | regs.r[1] = 6; // Screen Width in bytes |
153 | _kernel_swi(OS_ReadModeVariable, ®s, ®s); |
154 | |
155 | current->pitch = regs.r[2]; |
156 | |
157 | if (flags & SDL_DOUBLEBUF) |
158 | { |
159 | regs.r[0] = 2; /* Screen area */ |
160 | _kernel_swi(OS_ReadDynamicArea, ®s, ®s); |
161 | |
162 | /* Reg 1 has amount of memory currently used for display */ |
163 | regs.r[0] = 2; /* Screen area */ |
164 | regs.r[1] = (current->pitch * height * 2) - regs.r[1]; |
165 | if (_kernel_swi(OS_ChangeDynamicArea, ®s, ®s) != NULL) |
166 | { |
167 | /* Can't allocate enough screen memory for double buffer */ |
168 | flags &= ~SDL_DOUBLEBUF; |
169 | } |
170 | } |
171 | |
172 | current->flags = flags | SDL_FULLSCREEN | SDL_HWSURFACE | SDL_PREALLOC; |
173 | |
174 | |
175 | /* Need to set display banks here for double buffering */ |
176 | if (flags & SDL_DOUBLEBUF) |
177 | { |
178 | FULLSCREEN_SetWriteBank(0); |
179 | FULLSCREEN_SetDisplayBank(1); |
180 | |
181 | create_back_buffer = 0; /* Don't need a back buffer for a double buffered display */ |
182 | } |
183 | |
184 | FULLSCREEN_SetupBanks(this); |
185 | |
186 | if (create_back_buffer) |
187 | { |
188 | /* If not double buffered we may need to create a memory |
189 | ** back buffer to simulate processing on other OSes. |
190 | ** This is turned on by setting the enviromental variable |
191 | ** SDL$<name>$BackBuffer >= 1 |
192 | */ |
193 | if (riscos_backbuffer == 3) |
194 | this->hidden->bank[0] = WIMP_CreateBuffer(width, height, bpp); |
195 | else |
196 | this->hidden->bank[0] = SDL_malloc(height * current->pitch); |
197 | if (this->hidden->bank[0] == 0) |
198 | { |
199 | RISCOS_RestoreWimpMode(); |
200 | SDL_SetError("Couldnt allocate memory for back buffer"); |
201 | return (NULL); |
202 | } |
203 | /* Surface updated in programs is now a software surface */ |
204 | current->flags &= ~SDL_HWSURFACE; |
205 | } |
206 | |
207 | /* Store address of allocated screen bank to be freed later */ |
208 | if (this->hidden->alloc_bank) SDL_free(this->hidden->alloc_bank); |
209 | if (create_back_buffer) |
210 | { |
211 | this->hidden->alloc_bank = this->hidden->bank[0]; |
212 | if (riscos_backbuffer == 3) |
213 | { |
214 | this->hidden->bank[0] += 60; /* Start of sprite data */ |
215 | if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */ |
216 | } |
217 | } else |
218 | this->hidden->alloc_bank = 0; |
219 | |
220 | // Clear both banks to black |
221 | SDL_memset(this->hidden->bank[0], 0, height * current->pitch); |
222 | SDL_memset(this->hidden->bank[1], 0, height * current->pitch); |
223 | |
224 | this->hidden->current_bank = 0; |
225 | current->pixels = this->hidden->bank[0]; |
226 | |
227 | /* Have to set the screen here, so SetDeviceMode will pick it up */ |
228 | this->screen = current; |
229 | |
230 | /* Reset device functions for the wimp */ |
231 | FULLSCREEN_SetDeviceMode(this); |
232 | |
233 | /* FULLSCREEN_DisableEscape(); */ |
234 | |
235 | /* We're done */ |
236 | return(current); |
237 | } |
238 | |
239 | /* Reset any device functions that have been changed because we have run in WIMP mode */ |
240 | void FULLSCREEN_SetDeviceMode(_THIS) |
241 | { |
242 | /* Update rects is different if we have a backbuffer */ |
243 | |
244 | if (riscos_backbuffer && (this->screen->flags & SDL_DOUBLEBUF) == 0) |
245 | { |
246 | switch(riscos_backbuffer) |
247 | { |
248 | case 2: /* ARM code full word copy */ |
249 | switch(this->screen->format->BytesPerPixel) |
250 | { |
251 | case 1: /* 8bpp modes */ |
252 | this->UpdateRects = FULLSCREEN_UpdateRects8bpp; |
253 | break; |
254 | case 2: /* 15/16bpp modes */ |
255 | this->UpdateRects = FULLSCREEN_UpdateRects16bpp; |
256 | break; |
257 | case 4: /* 32 bpp modes */ |
258 | this->UpdateRects = FULLSCREEN_UpdateRects32bpp; |
259 | break; |
260 | |
261 | default: /* Just default to the memcpy routine */ |
262 | this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy; |
263 | break; |
264 | } |
265 | break; |
266 | |
267 | case 3: /* Use OS sprite plot routine */ |
268 | this->UpdateRects = FULLSCREEN_UpdateRectsOS; |
269 | break; |
270 | |
271 | default: /* Old but safe memcpy */ |
272 | this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy; |
273 | break; |
274 | } |
275 | } else |
276 | this->UpdateRects = FULLSCREEN_UpdateRects; /* Default do nothing implementation */ |
277 | |
278 | this->SetColors = FULLSCREEN_SetColors; |
279 | |
280 | this->FlipHWSurface = FULLSCREEN_FlipHWSurface; |
281 | |
282 | this->SetCaption = FULLSCREEN_SetWMCaption; |
283 | this->SetIcon = NULL; |
284 | this->IconifyWindow = NULL; |
285 | |
286 | this->ShowWMCursor = RISCOS_ShowWMCursor; |
287 | this->WarpWMCursor = FULLSCREEN_WarpWMCursor; |
288 | |
289 | this->PumpEvents = FULLSCREEN_PumpEvents; |
290 | } |
291 | |
292 | /* Query for the list of available video modes */ |
293 | void FULLSCREEN_BuildModeList(_THIS) |
294 | { |
295 | _kernel_swi_regs regs; |
296 | char *enumInfo = NULL; |
297 | char *enum_ptr; |
298 | int *blockInfo; |
299 | int j; |
300 | int num_modes; |
301 | |
302 | /* Find out how much space we need */ |
303 | regs.r[0] = 2; /* Reason code */ |
304 | regs.r[2] = 0; /* Number of modes to skip */ |
305 | regs.r[6] = 0; /* pointer to block or 0 for count */ |
306 | regs.r[7] = 0; /* Size of block in bytes */ |
307 | _kernel_swi(OS_ScreenMode, ®s, ®s); |
308 | |
309 | num_modes = -regs.r[2]; |
310 | |
311 | /* Video memory should be in r[5] */ |
312 | this->info.video_mem = regs.r[5]/1024; |
313 | |
314 | enumInfo = (unsigned char *)SDL_malloc(-regs.r[7]); |
315 | if (enumInfo == NULL) |
316 | { |
317 | SDL_OutOfMemory(); |
318 | return; |
319 | } |
320 | /* Read mode information into block */ |
321 | regs.r[2] = 0; |
322 | regs.r[6] = (int)enumInfo; |
323 | regs.r[7] = -regs.r[7]; |
324 | _kernel_swi(OS_ScreenMode, ®s, ®s); |
325 | |
326 | enum_ptr = enumInfo; |
327 | |
328 | for (j =0; j < num_modes;j++) |
329 | { |
330 | blockInfo = (int *)enum_ptr; |
331 | if ((blockInfo[1] & 255) == 1) /* We understand this format */ |
332 | { |
333 | switch(blockInfo[4]) |
334 | { |
335 | case 3: /* 8 bits per pixel */ |
336 | FULLSCREEN_AddMode(this, 8, blockInfo[2], blockInfo[3]); |
337 | break; |
338 | case 4: /* 15 bits per pixel */ |
339 | FULLSCREEN_AddMode(this, 15, blockInfo[2], blockInfo[3]); |
340 | break; |
341 | case 5: /* 32 bits per pixel */ |
342 | FULLSCREEN_AddMode(this, 32, blockInfo[2], blockInfo[3]); |
343 | break; |
344 | } |
345 | } |
346 | |
347 | enum_ptr += blockInfo[0]; |
348 | } |
349 | |
350 | SDL_free(enumInfo); |
351 | |
352 | /* Sort the mode lists */ |
353 | for ( j=0; j<NUM_MODELISTS; ++j ) { |
354 | if ( SDL_nummodes[j] > 0 ) { |
355 | SDL_qsort(SDL_modelist[j], SDL_nummodes[j], sizeof *SDL_modelist[j], cmpmodes); |
356 | } |
357 | } |
358 | } |
359 | |
360 | static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface) |
361 | { |
362 | _kernel_swi_regs regs; |
363 | regs.r[0] = 19; |
364 | |
365 | FULLSCREEN_SetDisplayBank(this->hidden->current_bank); |
366 | this->hidden->current_bank ^= 1; |
367 | FULLSCREEN_SetWriteBank(this->hidden->current_bank); |
368 | surface->pixels = this->hidden->bank[this->hidden->current_bank]; |
369 | |
370 | /* Wait for Vsync */ |
371 | _kernel_swi(OS_Byte, ®s, ®s); |
372 | |
373 | return(0); |
374 | } |
375 | |
376 | /* Nothing to do if we are writing direct to hardware */ |
377 | static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects) |
378 | { |
379 | } |
380 | |
381 | /* Safe but slower Memory copy from our allocated back buffer */ |
382 | static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects) |
383 | { |
384 | int j; |
385 | char *to, *from; |
386 | int pitch = this->screen->pitch; |
387 | int row; |
388 | int xmult = this->screen->format->BytesPerPixel; |
389 | for (j = 0; j < numrects; j++) |
390 | { |
391 | from = this->hidden->bank[0] + rects->x * xmult + rects->y * pitch; |
392 | to = this->hidden->bank[1] + rects->x * xmult + rects->y * pitch; |
393 | for (row = 0; row < rects->h; row++) |
394 | { |
395 | SDL_memcpy(to, from, rects->w * xmult); |
396 | from += pitch; |
397 | to += pitch; |
398 | } |
399 | rects++; |
400 | } |
401 | } |
402 | |
403 | /* Use optimized assembler memory copy. Deliberately copies extra columns if |
404 | necessary to ensure the rectangle is word aligned. */ |
405 | static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects) |
406 | { |
407 | int j; |
408 | char *to, *from; |
409 | int pitch = this->screen->pitch; |
410 | int width_bytes; |
411 | int src_skip_bytes; |
412 | |
413 | for (j = 0; j < numrects; j++) |
414 | { |
415 | from = this->hidden->bank[0] + rects->x + rects->y * pitch; |
416 | to = this->hidden->bank[1] + rects->x + rects->y * pitch; |
417 | width_bytes = rects->w; |
418 | if ((int)from & 3) |
419 | { |
420 | int extra = ((int)from & 3); |
421 | from -= extra; |
422 | to -= extra; |
423 | width_bytes += extra; |
424 | } |
425 | if (width_bytes & 3) width_bytes += 4 - (width_bytes & 3); |
426 | src_skip_bytes = pitch - width_bytes; |
427 | |
428 | RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes); |
429 | rects++; |
430 | } |
431 | } |
432 | |
433 | /* Use optimized assembler memory copy. Deliberately copies extra columns if |
434 | necessary to ensure the rectangle is word aligned. */ |
435 | static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects) |
436 | { |
437 | int j; |
438 | char *to, *from; |
439 | int pitch = this->screen->pitch; |
440 | int width_bytes; |
441 | int src_skip_bytes; |
442 | |
443 | for (j = 0; j < numrects; j++) |
444 | { |
445 | from = this->hidden->bank[0] + (rects->x << 1) + rects->y * pitch; |
446 | to = this->hidden->bank[1] + (rects->x << 1) + rects->y * pitch; |
447 | width_bytes = (((int)rects->w) << 1); |
448 | if ((int)from & 3) |
449 | { |
450 | from -= 2; |
451 | to -= 2; |
452 | width_bytes += 2; |
453 | } |
454 | if (width_bytes & 3) width_bytes += 2; |
455 | src_skip_bytes = pitch - width_bytes; |
456 | |
457 | RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes); |
458 | rects++; |
459 | } |
460 | } |
461 | |
462 | /* Use optimized assembler memory copy. 32 bpp modes are always word aligned */ |
463 | static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects) |
464 | { |
465 | int j; |
466 | char *to, *from; |
467 | int pitch = this->screen->pitch; |
468 | int width; |
469 | |
470 | for (j = 0; j < numrects; j++) |
471 | { |
472 | from = this->hidden->bank[0] + (rects->x << 2) + rects->y * pitch; |
473 | to = this->hidden->bank[1] + (rects->x << 2) + rects->y * pitch; |
474 | width = (int)rects->w ; |
475 | |
476 | RISCOS_Put32(to, width, pitch, (int)rects->h, from, pitch - (width << 2)); |
477 | rects++; |
478 | } |
479 | } |
480 | |
481 | /* Use operating system sprite plots. Currently this is much slower than the |
482 | other variants however accelerated sprite plotting can be seen on the horizon |
483 | so this prepares for it. */ |
484 | static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects) |
485 | { |
486 | _kernel_swi_regs regs; |
487 | _kernel_oserror *err; |
488 | int j; |
489 | int y; |
490 | |
491 | regs.r[0] = 28 + 512; |
492 | regs.r[1] = (unsigned int)this->hidden->alloc_bank; |
493 | regs.r[2] = (unsigned int)this->hidden->alloc_bank+16; |
494 | regs.r[5] = 0; |
495 | |
496 | for (j = 0; j < numrects; j++) |
497 | { |
498 | y = this->screen->h - rects->y; /* top of clipping region */ |
499 | _kernel_oswrch(24); /* Set graphics clip region */ |
500 | _kernel_oswrch((rects->x << this->hidden->xeig) & 0xFF); /* left */ |
501 | _kernel_oswrch(((rects->x << this->hidden->xeig) >> 8) & 0xFF); |
502 | _kernel_oswrch(((y - rects->h) << this->hidden->yeig) & 0xFF); /* bottom */ |
503 | _kernel_oswrch((((y - rects->h) << this->hidden->yeig)>> 8) & 0xFF); |
504 | _kernel_oswrch(((rects->x + rects->w - 1) << this->hidden->xeig) & 0xFF); /* right */ |
505 | _kernel_oswrch((((rects->x + rects->w - 1)<< this->hidden->xeig) >> 8) & 0xFF); |
506 | _kernel_oswrch(((y-1) << this->hidden->yeig) & 0xFF); /* top */ |
507 | _kernel_oswrch((((y-1) << this->hidden->yeig) >> 8) & 0xFF); |
508 | |
509 | regs.r[3] = 0; |
510 | regs.r[4] = 0; |
511 | |
512 | if ((err = _kernel_swi(OS_SpriteOp, ®s, ®s)) != 0) |
513 | { |
514 | printf("OS_SpriteOp failed \n%s\n",err->errmess); |
515 | } |
516 | |
517 | rects++; |
518 | |
519 | /* Reset to full screen clipping */ |
520 | _kernel_oswrch(24); /* Set graphics clip region */ |
521 | _kernel_oswrch(0); /* left */ |
522 | _kernel_oswrch(0); |
523 | _kernel_oswrch(0); /* bottom */ |
524 | _kernel_oswrch(0); |
525 | _kernel_oswrch(((this->screen->w-1) << this->hidden->xeig) & 0xFF); /* right */ |
526 | _kernel_oswrch((((this->screen->w-1) << this->hidden->xeig) >> 8) & 0xFF); |
527 | _kernel_oswrch(((this->screen->h-1) << this->hidden->yeig) & 0xFF); /* top */ |
528 | _kernel_oswrch((((this->screen->h-1) << this->hidden->yeig) >> 8) & 0xFF); |
529 | } |
530 | } |
531 | |
532 | |
533 | int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
534 | { |
535 | _kernel_swi_regs regs; |
536 | int palette[256]; |
537 | |
538 | regs.r[0] = -1; |
539 | regs.r[1] = -1; |
540 | regs.r[2] = (int)palette; |
541 | regs.r[3] = 1024; |
542 | regs.r[4] = 0; |
543 | _kernel_swi(ColourTrans_ReadPalette, ®s, ®s); |
544 | |
545 | while(ncolors--) |
546 | { |
547 | palette[firstcolor] = ((colors->b) << 24) | ((colors->g) << 16) | ((colors->r) << 8); |
548 | firstcolor++; |
549 | colors++; |
550 | } |
551 | |
552 | regs.r[0] = -1; |
553 | regs.r[1] = -1; |
554 | regs.r[2] = (int)palette; |
555 | regs.r[3] = 0; |
556 | regs.r[4] = 0; |
557 | _kernel_swi(ColourTrans_WritePalette, ®s, ®s); |
558 | |
559 | return(1); |
560 | } |
561 | |
562 | |
563 | static int cmpmodes(const void *va, const void *vb) |
564 | { |
565 | SDL_Rect *a = *(SDL_Rect **)va; |
566 | SDL_Rect *b = *(SDL_Rect **)vb; |
567 | if(a->w == b->w) |
568 | return b->h - a->h; |
569 | else |
570 | return b->w - a->w; |
571 | } |
572 | |
573 | static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h) |
574 | { |
575 | SDL_Rect *mode; |
576 | int i, index; |
577 | int next_mode; |
578 | |
579 | /* Check to see if we already have this mode */ |
580 | if ( bpp < 8 ) { /* Not supported */ |
581 | return(0); |
582 | } |
583 | index = ((bpp+7)/8)-1; |
584 | for ( i=0; i<SDL_nummodes[index]; ++i ) { |
585 | mode = SDL_modelist[index][i]; |
586 | if ( (mode->w == w) && (mode->h == h) ) { |
587 | return(0); |
588 | } |
589 | } |
590 | |
591 | /* Set up the new video mode rectangle */ |
592 | mode = (SDL_Rect *)SDL_malloc(sizeof *mode); |
593 | if ( mode == NULL ) { |
594 | SDL_OutOfMemory(); |
595 | return(-1); |
596 | } |
597 | mode->x = 0; |
598 | mode->y = 0; |
599 | mode->w = w; |
600 | mode->h = h; |
601 | |
602 | /* Allocate the new list of modes, and fill in the new mode */ |
603 | next_mode = SDL_nummodes[index]; |
604 | SDL_modelist[index] = (SDL_Rect **) |
605 | SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); |
606 | if ( SDL_modelist[index] == NULL ) { |
607 | SDL_OutOfMemory(); |
608 | SDL_nummodes[index] = 0; |
609 | SDL_free(mode); |
610 | return(-1); |
611 | } |
612 | SDL_modelist[index][next_mode] = mode; |
613 | SDL_modelist[index][next_mode+1] = NULL; |
614 | SDL_nummodes[index]++; |
615 | |
616 | return(0); |
617 | } |
618 | |
619 | void FULLSCREEN_SetWriteBank(int bank) |
620 | { |
621 | _kernel_swi_regs regs; |
622 | regs.r[0] = 112; |
623 | regs.r[1] = bank+1; |
624 | _kernel_swi(OS_Byte, ®s, ®s); |
625 | } |
626 | |
627 | void FULLSCREEN_SetDisplayBank(int bank) |
628 | { |
629 | _kernel_swi_regs regs; |
630 | regs.r[0] = 113; |
631 | regs.r[1] = bank+1; |
632 | _kernel_swi(OS_Byte, ®s, ®s); |
633 | } |
634 | |
635 | |
636 | /** Disable special escape key processing */ |
637 | static void FULLSCREEN_DisableEscape() |
638 | { |
639 | _kernel_swi_regs regs; |
640 | regs.r[0] = 229; |
641 | regs.r[1] = 1; |
642 | regs.r[2] = 0; |
643 | _kernel_swi(OS_Byte, ®s, ®s); |
644 | |
645 | } |
646 | |
647 | /** Enable special escape key processing */ |
648 | static void FULLSCREEN_EnableEscape() |
649 | { |
650 | _kernel_swi_regs regs; |
651 | regs.r[0] = 229; |
652 | regs.r[1] = 0; |
653 | regs.r[2] = 0; |
654 | _kernel_swi(OS_Byte, ®s, ®s); |
655 | |
656 | } |
657 | |
658 | /** Store caption in case this is called before we create a window */ |
659 | void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon) |
660 | { |
661 | SDL_strlcpy(this->hidden->title, title, SDL_arraysize(this->hidden->title)); |
662 | } |
663 | |
664 | /* Set screen mode |
665 | * |
666 | * Returns 1 if mode is set ok, otherwise 0 |
667 | */ |
668 | |
669 | int FULLSCREEN_SetMode(int width, int height, int bpp) |
670 | { |
671 | SCREENMODEBLOCK smb; |
672 | _kernel_swi_regs regs; |
673 | |
674 | smb.flags = 1; |
675 | smb.x_pixels = width; |
676 | smb.y_pixels = height; |
677 | smb.mode_vars[0] = -1; |
678 | |
679 | switch(bpp) |
680 | { |
681 | case 8: |
682 | smb.pixel_depth = 3; |
683 | /* Note: Need to set ModeFlags to 128 and NColour variables to 255 get full 8 bit palette */ |
684 | smb.mode_vars[0] = 0; smb.mode_vars[1] = 128; /* Mode flags */ |
685 | smb.mode_vars[2] = 3; smb.mode_vars[3] = 255; /* NColour (number of colours -1) */ |
686 | smb.mode_vars[4] = -1; /* End of list */ |
687 | break; |
688 | |
689 | case 15: |
690 | case 16: |
691 | smb.pixel_depth = 4; |
692 | break; |
693 | |
694 | case 32: |
695 | smb.pixel_depth = 5; |
696 | break; |
697 | |
698 | default: |
699 | SDL_SetError("Pixel depth not supported"); |
700 | return 0; |
701 | break; |
702 | } |
703 | |
704 | smb.frame_rate = -1; |
705 | |
706 | regs.r[0] = 0; |
707 | regs.r[1] = (int)&smb; |
708 | |
709 | if (_kernel_swi(OS_ScreenMode, ®s, ®s) != 0) |
710 | { |
711 | SDL_SetError("Couldn't set requested mode"); |
712 | return 0; |
713 | } |
714 | |
715 | /* Turn cursor off*/ |
716 | _kernel_oswrch(23);_kernel_oswrch(1);_kernel_oswrch(0); |
717 | _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0); |
718 | _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0); |
719 | _kernel_oswrch(0);_kernel_oswrch(0); |
720 | |
721 | return 1; |
722 | } |
723 | |
724 | /* Get Start addresses for the screen banks */ |
725 | void FULLSCREEN_SetupBanks(_THIS) |
726 | { |
727 | _kernel_swi_regs regs; |
728 | int block[5]; |
729 | block[0] = 148; /* Write screen start */ |
730 | block[1] = 149; /* Display screen start */ |
731 | block[2] = 4; /* X eig factor */ |
732 | block[3] = 5; /* Y eig factor */ |
733 | block[4] = -1; /* End of list of variables to request */ |
734 | |
735 | regs.r[0] = (int)block; |
736 | regs.r[1] = (int)block; |
737 | _kernel_swi(OS_ReadVduVariables, ®s, ®s); |
738 | |
739 | this->hidden->bank[0] = (void *)block[0]; |
740 | this->hidden->bank[1] = (void *)block[1]; |
741 | this->hidden->xeig = block[2]; |
742 | this->hidden->yeig = block[3]; |
743 | } |
744 | |
745 | /* Toggle to full screen mode from the WIMP */ |
746 | |
747 | int FULLSCREEN_ToggleFromWimp(_THIS) |
748 | { |
749 | int width = this->screen->w; |
750 | int height = this->screen->h; |
751 | int bpp = this->screen->format->BitsPerPixel; |
752 | |
753 | RISCOS_StoreWimpMode(); |
754 | if (FULLSCREEN_SetMode(width, height, bpp)) |
755 | { |
756 | char *buffer = this->hidden->alloc_bank; /* This is start of sprite data */ |
757 | /* Support back buffer mode only */ |
758 | if (riscos_backbuffer == 0) riscos_backbuffer = 1; |
759 | |
760 | FULLSCREEN_SetupBanks(this); |
761 | |
762 | this->hidden->bank[0] = buffer + 60; /* Start of sprite data */ |
763 | if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */ |
764 | |
765 | this->hidden->current_bank = 0; |
766 | this->screen->pixels = this->hidden->bank[0]; |
767 | |
768 | /* Copy back buffer to screen memory */ |
769 | SDL_memcpy(this->hidden->bank[1], this->hidden->bank[0], width * height * this->screen->format->BytesPerPixel); |
770 | |
771 | FULLSCREEN_SetDeviceMode(this); |
772 | return 1; |
773 | } else |
774 | RISCOS_RestoreWimpMode(); |
775 | |
776 | return 0; |
777 | } |