Mercurial > sdl-ios-xcode

comparison src/video/qnxgf/SDL_qnxgf.c @ 3109:7b3a09fb9c8b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Support for HID devices (mice and keyboards only for now) has been added
author Mike Gorchak <lestat@i.com.ua>
date Tue, 28 Apr 2009 04:33:30 +0000
parents 82e60908fab1
children b17f1ae7ad66
comparison
equal deleted inserted replaced
3108:aa1897bee1e9 3109:7b3a09fb9c8b
35 #include <gf/gf.h> 35 #include <gf/gf.h>
36 36
37 #include "SDL_qnxgf.h" 37 #include "SDL_qnxgf.h"
38 #include "SDL_gf_render.h" 38 #include "SDL_gf_render.h"
39 #include "SDL_gf_pixelfmt.h" 39 #include "SDL_gf_pixelfmt.h"
40 #include "SDL_gf_opengles.h"
41 #include "SDL_gf_input.h"
40 42
41 /******************************************************************************/ 43 /******************************************************************************/
42 /* SDL Generic video modes, which could provide GF */ 44 /* SDL Generic video modes, which could provide GF */
43 /* This is real pain in the ass. GF is just wrapper around a selected driver */ 45 /* This is real pain in the ass. GF is just wrapper around a selected driver */
44 /* some drivers could support double scan modes, like 320x200, 512x384, etc */ 46 /* some drivers could support double scan modes, like 320x200, 512x384, etc */
246 SDL_free(gfdata); 248 SDL_free(gfdata);
247 SDL_free(device); 249 SDL_free(device);
248 return NULL; 250 return NULL;
249 } 251 }
250 252
253 if (gfdata->gfdev_info.description==NULL)
254 {
255 gf_dev_detach(gfdata->gfdev);
256 SDL_SetError("GF: Failed to initialize graphics driver");
257 return NULL;
258 }
259
251 /* Setup amount of available displays and current display */ 260 /* Setup amount of available displays and current display */
252 device->num_displays=0; 261 device->num_displays=0;
253 device->current_display=0; 262 device->current_display=0;
254 263
255 /* Setup device shutdown function */ 264 /* Setup device shutdown function */
310 { 319 {
311 SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata; 320 SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata;
312 uint32_t it; 321 uint32_t it;
313 uint32_t jt; 322 uint32_t jt;
314 char* override; 323 char* override;
324 int32_t status;
325
326 /* By default GF uses buffer swap on vsync */
327 gfdata->swapinterval=1;
315 328
316 /* Add each detected output to SDL */ 329 /* Add each detected output to SDL */
317 for (it=0; it<gfdata->gfdev_info.ndisplays; it++) 330 for (it=0; it<gfdata->gfdev_info.ndisplays; it++)
318 { 331 {
319 SDL_VideoDisplay display; 332 SDL_VideoDisplay display;
320 SDL_DisplayMode current_mode; 333 SDL_DisplayMode current_mode;
321 SDL_DisplayData* didata; 334 SDL_DisplayData* didata;
322 int status;
323 335
324 didata=(SDL_DisplayData*)SDL_calloc(1, sizeof(SDL_DisplayData)); 336 didata=(SDL_DisplayData*)SDL_calloc(1, sizeof(SDL_DisplayData));
325 if (didata==NULL) 337 if (didata==NULL)
326 { 338 {
327 /* memory allocation problem */ 339 /* memory allocation problem */
328 SDL_OutOfMemory(); 340 SDL_OutOfMemory();
329 return -1; 341 return -1;
330 } 342 }
331 343
344 /* Set default cursor settings, maximum 128x128 cursor */
345 didata->cursor_visible=SDL_FALSE;
346 didata->cursor.type=GF_CURSOR_BITMAP;
347 didata->cursor.hotspot.x=0;
348 didata->cursor.hotspot.y=0;
349 didata->cursor.cursor.bitmap.w=SDL_VIDEO_GF_MAX_CURSOR_SIZE;
350 didata->cursor.cursor.bitmap.h=SDL_VIDEO_GF_MAX_CURSOR_SIZE;
351 didata->cursor.cursor.bitmap.stride=(didata->cursor.cursor.bitmap.w+7)/
352 (sizeof(uint8_t)*8);
353 didata->cursor.cursor.bitmap.color0=0x00000000;
354 didata->cursor.cursor.bitmap.color1=0x00000000;
355 didata->cursor.cursor.bitmap.image0=SDL_calloc(sizeof(uint8_t), (didata->cursor.cursor.bitmap.w+7)*
356 didata->cursor.cursor.bitmap.h/(sizeof(uint8_t)*8));
357 if (didata->cursor.cursor.bitmap.image0==NULL)
358 {
359 SDL_free(didata);
360 SDL_OutOfMemory();
361 return -1;
362 }
363 didata->cursor.cursor.bitmap.image1=SDL_calloc(sizeof(uint8_t), (didata->cursor.cursor.bitmap.w+7)*
364 didata->cursor.cursor.bitmap.h/(sizeof(uint8_t)*8));
365 if (didata->cursor.cursor.bitmap.image1==NULL)
366 {
367 SDL_OutOfMemory();
368 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
369 SDL_free(didata);
370 return -1;
371 }
372
373 /* Query current display settings */
332 status=gf_display_query(gfdata->gfdev, it, &didata->display_info); 374 status=gf_display_query(gfdata->gfdev, it, &didata->display_info);
333 if (status==GF_ERR_OK) 375 if (status==GF_ERR_OK)
334 { 376 {
335 SDL_zero(current_mode); 377 SDL_zero(current_mode);
336 current_mode.w=didata->display_info.xres; 378 current_mode.w=didata->display_info.xres;
340 current_mode.driverdata=NULL; 382 current_mode.driverdata=NULL;
341 } 383 }
342 else 384 else
343 { 385 {
344 /* video initialization problem */ 386 /* video initialization problem */
387 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
388 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
345 SDL_free(didata); 389 SDL_free(didata);
346 SDL_SetError("GF: Display query failed"); 390 SDL_SetError("GF: Display query failed");
347 return -1; 391 return -1;
348 } 392 }
349 393
350 /* Attach GF to selected display */ 394 /* Attach GF to selected display */
351 status=gf_display_attach(&didata->display, gfdata->gfdev, it, NULL); 395 status=gf_display_attach(&didata->display, gfdata->gfdev, it, NULL);
352 if (status!=GF_ERR_OK) 396 if (status!=GF_ERR_OK)
353 { 397 {
354 /* video initialization problem */ 398 /* video initialization problem */
399 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
400 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
355 SDL_free(didata); 401 SDL_free(didata);
356 SDL_SetError("GF: Couldn't attach to display"); 402 SDL_SetError("GF: Couldn't attach to display");
357 return -1; 403 return -1;
358 } 404 }
359 405
362 408
363 /* Attach to main display layer */ 409 /* Attach to main display layer */
364 status=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0); 410 status=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0);
365 if (status!=GF_ERR_OK) 411 if (status!=GF_ERR_OK)
366 { 412 {
413 /* Failed to attach to main layer */
414 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
415 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
416 SDL_free(didata);
367 SDL_SetError("GF: Couldn't attach to main layer, it could be busy"); 417 SDL_SetError("GF: Couldn't attach to main layer, it could be busy");
368 418 return -1;
369 /* Failed to attach to main layer */ 419 }
420
421 /* Mark main display layer is attached */
422 didata->layer_attached=SDL_TRUE;
423
424 /* Set layer source and destination viewport */
425 gf_layer_set_src_viewport(didata->layer, 0, 0, current_mode.w-1, current_mode.h-1);
426 gf_layer_set_dst_viewport(didata->layer, 0, 0, current_mode.w-1, current_mode.h-1);
427
428 /* Create main visible on display surface */
429 status=gf_surface_create_layer(&didata->surface[0], &didata->layer,
430 1, 0, current_mode.w, current_mode.h,
431 qnxgf_sdl_to_gf_pixelformat(current_mode.format),
432 NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |
433 GF_SURFACE_CREATE_SHAREABLE);
434 if (status!=GF_ERR_OK)
435 {
436 gf_layer_disable(didata->layer);
437 gf_layer_detach(didata->layer);
438 didata->layer_attached=SDL_FALSE;
439 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
440 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
441 SDL_free(didata);
442 SDL_SetError("GF: Can't create main layer surface at init (%d)\n", status);
443 return -1;
444 }
445
446 /* Set just created surface as main visible on the layer */
447 // gf_layer_set_surfaces(didata->layer, &didata->surface[0], 1);
448
449 /* Update layer parameters */
450 status=gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
451 if (status!=GF_ERR_OK)
452 {
453 /* Free allocated surface */
454 gf_surface_free(didata->surface[0]);
455 didata->surface[0]=NULL;
456
457 /* Disable and detach from layer */
458 gf_layer_disable(didata->layer);
459 gf_layer_detach(didata->layer);
460 didata->layer_attached=SDL_FALSE;
461 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
462 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
463 SDL_free(didata);
464 SDL_SetError("GF: Can't update layer parameters\n");
370 return -1; 465 return -1;
371 } 466 }
372 467
373 /* Enable layer in case if hardware supports layer enable/disable */ 468 /* Enable layer in case if hardware supports layer enable/disable */
374 gf_layer_enable(didata->layer); 469 gf_layer_enable(didata->layer);
375
376 /* Mark main display layer is attached */
377 didata->layer_attached=SDL_TRUE;
378 470
379 /* Copy device name for each display */ 471 /* Copy device name for each display */
380 SDL_strlcpy(didata->description, gfdata->gfdev_info.description, SDL_VIDEO_GF_DEVICENAME_MAX-1); 472 SDL_strlcpy(didata->description, gfdata->gfdev_info.description, SDL_VIDEO_GF_DEVICENAME_MAX-1);
381 473
382 /* Search device capabilities and possible workarounds */ 474 /* Search device capabilities and possible workarounds */
393 jt++; 485 jt++;
394 } while(1); 486 } while(1);
395 487
396 /* Initialize display structure */ 488 /* Initialize display structure */
397 SDL_zero(display); 489 SDL_zero(display);
398 display.desktop_mode = current_mode; 490 display.desktop_mode=current_mode;
399 display.current_mode = current_mode; 491 display.current_mode=current_mode;
400 display.driverdata = didata; 492 display.driverdata=didata;
401 didata->current_mode=current_mode; 493 didata->current_mode=current_mode;
402 SDL_AddVideoDisplay(&display); 494 SDL_AddVideoDisplay(&display);
403 495
404 /* Check for environment variables which could override some SDL settings */ 496 /* Check for environment variables which could override some SDL settings */
405 didata->custom_refresh=0; 497 didata->custom_refresh=0;
409 if (SDL_sscanf(override, "%u", &didata->custom_refresh)!=1) 501 if (SDL_sscanf(override, "%u", &didata->custom_refresh)!=1)
410 { 502 {
411 didata->custom_refresh=0; 503 didata->custom_refresh=0;
412 } 504 }
413 } 505 }
414 } 506
507 /* Get all display modes for this display */
508 _this->current_display=it;
509 qnxgf_getdisplaymodes(_this);
510 }
511
512 /* Restore default display */
513 _this->current_display=0;
415 514
416 /* Add GF renderer to SDL */ 515 /* Add GF renderer to SDL */
417 gf_addrenderdriver(_this); 516 gf_addrenderdriver(_this);
418 517
518 /* Add GF input devices */
519 status=gf_addinputdevices(_this);
520 if (status!=0)
521 {
522 /* SDL error is set by gf_addinputdevices() function */
523 return -1;
524 }
525
419 /* video has been initialized successfully */ 526 /* video has been initialized successfully */
420 return 1; 527 return 1;
421 } 528 }
422 529
423 void qnxgf_videoquit(_THIS) 530 void qnxgf_videoquit(_THIS)
424 { 531 {
425 SDL_DisplayData* didata; 532 SDL_DisplayData* didata;
426 uint32_t it; 533 uint32_t it;
427 534
428 /* SDL will restore our desktop mode on exit */ 535 /* Delete GF input devices */
536 gf_delinputdevices(_this);
537
538 /* SDL will restore old desktop mode on exit */
429 for(it=0; it<_this->num_displays; it++) 539 for(it=0; it<_this->num_displays; it++)
430 { 540 {
431 didata=_this->displays[it].driverdata; 541 didata=_this->displays[it].driverdata;
542
543 /* Free cursor image */
544 if (didata->cursor.cursor.bitmap.image0!=NULL)
545 {
546 SDL_free((void*)didata->cursor.cursor.bitmap.image0);
547 }
548 if (didata->cursor.cursor.bitmap.image1!=NULL)
549 {
550 SDL_free((void*)didata->cursor.cursor.bitmap.image1);
551 }
552
553 /* Free main surface */
554 if (didata->surface[0]!=NULL)
555 {
556 gf_surface_free(didata->surface[0]);
557 didata->surface[0]=NULL;
558 }
559
560 /* Free back surface */
561 if (didata->surface[1]!=NULL)
562 {
563 gf_surface_free(didata->surface[1]);
564 didata->surface[1]=NULL;
565 }
566
567 /* Free second back surface */
568 if (didata->surface[2]!=NULL)
569 {
570 gf_surface_free(didata->surface[2]);
571 didata->surface[2]=NULL;
572 }
573
574 /* Detach layer before quit */
575 if (didata->layer_attached==SDL_TRUE)
576 {
577 /* Disable layer if hardware supports this */
578 gf_layer_disable(didata->layer);
579
580 /* Detach from layer, free it for others */
581 gf_layer_detach(didata->layer);
582
583 /* Mark it as detached */
584 didata->layer_attached=SDL_FALSE;
585 }
432 586
433 /* Detach from selected display */ 587 /* Detach from selected display */
434 gf_display_detach(didata->display); 588 gf_display_detach(didata->display);
435 } 589 }
436 } 590 }
521 675
522 int qnxgf_setdisplaymode(_THIS, SDL_DisplayMode* mode) 676 int qnxgf_setdisplaymode(_THIS, SDL_DisplayMode* mode)
523 { 677 {
524 SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata; 678 SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
525 uint32_t refresh_rate=0; 679 uint32_t refresh_rate=0;
526 int result; 680 int status;
527 681
528 /* Current display dimensions and bpp are no more valid */ 682 /* Current display dimensions and bpp are no more valid */
529 didata->current_mode.format=SDL_PIXELFORMAT_UNKNOWN; 683 didata->current_mode.format=SDL_PIXELFORMAT_UNKNOWN;
530 didata->current_mode.w=0; 684 didata->current_mode.w=0;
531 didata->current_mode.h=0; 685 didata->current_mode.h=0;
615 /* Let video driver decide what to do with this */ 769 /* Let video driver decide what to do with this */
616 refresh_rate=0; 770 refresh_rate=0;
617 } 771 }
618 } 772 }
619 773
774 /* Free main surface */
775 if (didata->surface[0]!=NULL)
776 {
777 gf_surface_free(didata->surface[0]);
778 didata->surface[0]=NULL;
779 }
780
781 /* Free back surface */
782 if (didata->surface[1]!=NULL)
783 {
784 gf_surface_free(didata->surface[1]);
785 didata->surface[1]=NULL;
786 }
787
788 /* Free second back surface */
789 if (didata->surface[2]!=NULL)
790 {
791 gf_surface_free(didata->surface[2]);
792 didata->surface[2]=NULL;
793 }
794
620 /* Detach layer before switch to new graphics mode */ 795 /* Detach layer before switch to new graphics mode */
621 if (didata->layer_attached==SDL_TRUE) 796 if (didata->layer_attached==SDL_TRUE)
622 { 797 {
623 /* Disable layer if hardware supports this */ 798 /* Disable layer if hardware supports this */
624 gf_layer_disable(didata->layer); 799 gf_layer_disable(didata->layer);
629 /* Mark it as detached */ 804 /* Mark it as detached */
630 didata->layer_attached=SDL_FALSE; 805 didata->layer_attached=SDL_FALSE;
631 } 806 }
632 807
633 /* Set new display video mode */ 808 /* Set new display video mode */
634 result=gf_display_set_mode(didata->display, mode->w, mode->h, refresh_rate, 809 status=gf_display_set_mode(didata->display, mode->w, mode->h, refresh_rate,
635 qnxgf_sdl_to_gf_pixelformat(mode->format), 0); 810 qnxgf_sdl_to_gf_pixelformat(mode->format), 0);
636 if (result!=GF_ERR_OK) 811 if (status!=GF_ERR_OK)
637 { 812 {
638 /* Display mode/resolution switch has been failed */ 813 /* Display mode/resolution switch has been failed */
639 SDL_SetError("GF: Mode is not supported by graphics driver"); 814 SDL_SetError("GF: Mode is not supported by graphics driver");
640 return -1; 815 return -1;
641 } 816 }
644 didata->current_mode=*mode; 819 didata->current_mode=*mode;
645 didata->current_mode.refresh_rate=refresh_rate; 820 didata->current_mode.refresh_rate=refresh_rate;
646 } 821 }
647 822
648 /* Attach to main display layer */ 823 /* Attach to main display layer */
649 result=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0); 824 status=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0);
650 if (result!=GF_ERR_OK) 825 if (status!=GF_ERR_OK)
651 { 826 {
652 SDL_SetError("GF: Couldn't attach to main layer, it could be busy"); 827 SDL_SetError("GF: Couldn't attach to main layer, it could be busy");
653 828
654 /* Failed to attach to main displayable layer */ 829 /* Failed to attach to main displayable layer */
655 return -1; 830 return -1;
656 } 831 }
657 832
833 /* Mark main display layer is attached */
834 didata->layer_attached=SDL_TRUE;
835
836 /* Set layer source and destination viewport */
837 gf_layer_set_src_viewport(didata->layer, 0, 0, mode->w-1, mode->h-1);
838 gf_layer_set_dst_viewport(didata->layer, 0, 0, mode->w-1, mode->h-1);
839
840 /* Create main visible on display surface */
841 status=gf_surface_create_layer(&didata->surface[0], &didata->layer, 1, 0,
842 mode->w, mode->h, qnxgf_sdl_to_gf_pixelformat(mode->format),
843 NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |
844 GF_SURFACE_CREATE_SHAREABLE);
845 if (status!=GF_ERR_OK)
846 {
847 gf_layer_disable(didata->layer);
848 gf_layer_detach(didata->layer);
849 didata->layer_attached=SDL_FALSE;
850 SDL_SetError("GF: Can't create main layer surface at modeswitch (%d)\n", status);
851 return -1;
852 }
853
854 /* Set just created surface as main visible on the layer */
855 gf_layer_set_surfaces(didata->layer, &didata->surface[0], 1);
856
857 /* Update layer parameters */
858 status=gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
859 if (status!=GF_ERR_OK)
860 {
861 /* Free main surface */
862 gf_surface_free(didata->surface[0]);
863 didata->surface[0]=NULL;
864
865 /* Detach layer */
866 gf_layer_disable(didata->layer);
867 gf_layer_detach(didata->layer);
868 didata->layer_attached=SDL_FALSE;
869 SDL_SetError("GF: Can't update layer parameters\n");
870 return -1;
871 }
872
873 /* Restore cursor if it was visible */
874 if (didata->cursor_visible==SDL_TRUE)
875 {
876 gf_cursor_set(didata->display, 0, &didata->cursor);
877 gf_cursor_enable(didata->display, 0);
878 }
879
658 /* Enable layer in case if hardware supports layer enable/disable */ 880 /* Enable layer in case if hardware supports layer enable/disable */
659 gf_layer_enable(didata->layer); 881 gf_layer_enable(didata->layer);
660
661 /* Mark main display layer is attached */
662 didata->layer_attached=SDL_TRUE;
663 882
664 return 0; 883 return 0;
665 } 884 }
666 885
667 int qnxgf_setdisplaypalette(_THIS, SDL_Palette* palette) 886 int qnxgf_setdisplaypalette(_THIS, SDL_Palette* palette)
764 return -1; 983 return -1;
765 } 984 }
766 } 985 }
767 } 986 }
768 987
769 /* Setup our own window decorations, which are depend on fullscreen mode */ 988 /* Setup our own window decorations and states, which are depend on fullscreen mode */
770 window->flags|=SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS | 989 window->flags|=SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS |
771 SDL_WINDOW_MAXIMIZED | SDL_WINDOW_INPUT_GRABBED | 990 SDL_WINDOW_MAXIMIZED | SDL_WINDOW_INPUT_GRABBED |
772 SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS; 991 SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS;
773 window->flags&=~(SDL_WINDOW_RESIZABLE | SDL_WINDOW_MINIMIZED); 992 window->flags&=~(SDL_WINDOW_RESIZABLE | SDL_WINDOW_MINIMIZED);
774 993
821 SDL_SetError("GF: OpenGL ES support is not compiled in"); 1040 SDL_SetError("GF: OpenGL ES support is not compiled in");
822 return -1; 1041 return -1;
823 #endif /* SDL_VIDEO_OPENGL_ES */ 1042 #endif /* SDL_VIDEO_OPENGL_ES */
824 } 1043 }
825 1044
1045 /* Enable mouse event collecting */
1046 hiddi_enable_mouse();
1047
1048 /* By default last created window got a input focus */
1049 SDL_SetKeyboardFocus(0, window->id);
1050 SDL_SetMouseFocus(0, window->id);
1051
826 /* Window has been successfully created */ 1052 /* Window has been successfully created */
827 return 0; 1053 return 0;
828 } 1054 }
829 1055
830 int qnxgf_createwindowfrom(_THIS, SDL_Window* window, const void* data) 1056 int qnxgf_createwindowfrom(_THIS, SDL_Window* window, const void* data)
894 1120
895 /* Free any 3D target if it was created before */ 1121 /* Free any 3D target if it was created before */
896 if (wdata->target_created==SDL_TRUE) 1122 if (wdata->target_created==SDL_TRUE)
897 { 1123 {
898 gf_3d_target_free(wdata->target); 1124 gf_3d_target_free(wdata->target);
899 } 1125 wdata->target_created==SDL_FALSE;
900 1126 }
901 1127
902 gfdata->egl_refcount--; 1128 gfdata->egl_refcount--;
903 if (gfdata->egl_refcount==0) 1129 if (gfdata->egl_refcount==0)
904 { 1130 {
905 /* Terminate connection to OpenGL ES */ 1131 /* Terminate connection to OpenGL ES */
999 { 1225 {
1000 return function_address; 1226 return function_address;
1001 } 1227 }
1002 } 1228 }
1003 1229
1230 /* Add emulated OpenGL ES 1.1 functions */
1231 if (SDL_strcmp(proc, "glTexParameteri")==0)
1232 {
1233 return glTexParameteri;
1234 }
1235 if (SDL_strcmp(proc, "glTexParameteriv")==0)
1236 {
1237 return glTexParameteriv;
1238 }
1239 if (SDL_strcmp(proc, "glColor4ub")==0)
1240 {
1241 return glColor4ub;
1242 }
1243
1004 /* Failed to get GL ES function address pointer */ 1244 /* Failed to get GL ES function address pointer */
1005 SDL_SetError("GF: Cannot locate given function name"); 1245 SDL_SetError("GF: Cannot locate OpenGL ES function name");
1006 return NULL; 1246 return NULL;
1007 #else 1247 #else
1008 SDL_SetError("GF: OpenGL ES support is not compiled in"); 1248 SDL_SetError("GF: OpenGL ES support is not compiled in");
1009 return NULL; 1249 return NULL;
1010 #endif /* SDL_VIDEO_OPENGL_ES */ 1250 #endif /* SDL_VIDEO_OPENGL_ES */
1034 EGLBoolean status; 1274 EGLBoolean status;
1035 int32_t gfstatus; 1275 int32_t gfstatus;
1036 EGLint configs; 1276 EGLint configs;
1037 uint32_t surfaces; 1277 uint32_t surfaces;
1038 uint32_t attr_pos; 1278 uint32_t attr_pos;
1279 EGLint attr_value;
1280 EGLint cit;
1281
1282 /* Choose buffeingr scheme */
1283 if (!_this->gl_config.double_buffer)
1284 {
1285 surfaces=1;
1286 }
1287 else
1288 {
1289 surfaces=2;
1290 }
1291
1292 /* Free main surface */
1293 if (didata->surface[0]!=NULL)
1294 {
1295 gf_surface_free(didata->surface[0]);
1296 didata->surface[0]=NULL;
1297 }
1298
1299 /* Free back surface */
1300 if (didata->surface[1]!=NULL)
1301 {
1302 gf_surface_free(didata->surface[1]);
1303 didata->surface[1]=NULL;
1304 }
1305
1306 /* Free second back surface */
1307 if (didata->surface[2]!=NULL)
1308 {
1309 gf_surface_free(didata->surface[2]);
1310 didata->surface[2]=NULL;
1311 }
1312
1313 /* Detach layer before switch to new graphics mode */
1314 if (didata->layer_attached==SDL_TRUE)
1315 {
1316 /* Disable layer if hardware supports this */
1317 gf_layer_disable(didata->layer);
1318
1319 /* Detach from layer, free it for others */
1320 gf_layer_detach(didata->layer);
1321
1322 /* Mark it as detached */
1323 didata->layer_attached=SDL_FALSE;
1324 }
1325
1326 /* Attach to main display layer */
1327 gfstatus=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0);
1328 if (gfstatus!=GF_ERR_OK)
1329 {
1330 SDL_SetError("GF: Couldn't attach to main layer, it could be busy");
1331
1332 /* Failed to attach to main displayable layer */
1333 return NULL;
1334 }
1335
1336 /* Mark main display layer is attached */
1337 didata->layer_attached=SDL_TRUE;
1338
1339 /* Set layer source and destination viewport */
1340 gf_layer_set_src_viewport(didata->layer, 0, 0, didata->current_mode.w-1, didata->current_mode.h-1);
1341 gf_layer_set_dst_viewport(didata->layer, 0, 0, didata->current_mode.w-1, didata->current_mode.h-1);
1342
1343 /* Create main visible on display surface */
1344 gfstatus=gf_surface_create_layer(&didata->surface[0], &didata->layer, 1, 0,
1345 didata->current_mode.w, didata->current_mode.h, qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format),
1346 NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |
1347 GF_SURFACE_CREATE_SHAREABLE);
1348 if (gfstatus!=GF_ERR_OK)
1349 {
1350 gf_layer_disable(didata->layer);
1351 gf_layer_detach(didata->layer);
1352 didata->layer_attached=SDL_FALSE;
1353 SDL_SetError("GF: Can't create main layer surface at glctx (%d)\n", gfstatus);
1354 return NULL;
1355 }
1356
1357 /* Set just created surface as main visible on the layer */
1358 // gf_layer_set_surfaces(didata->layer, &didata->surface[0], 1);
1359
1360 if (surfaces>1)
1361 {
1362 /* Create back display surface */
1363 gfstatus=gf_surface_create_layer(&didata->surface[1], &didata->layer, 1, 0,
1364 didata->current_mode.w, didata->current_mode.h, qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format),
1365 NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |
1366 GF_SURFACE_CREATE_SHAREABLE);
1367 if (gfstatus!=GF_ERR_OK)
1368 {
1369 gf_surface_free(didata->surface[0]);
1370 gf_layer_disable(didata->layer);
1371 gf_layer_detach(didata->layer);
1372 didata->layer_attached=SDL_FALSE;
1373 SDL_SetError("GF: Can't create main layer surface at glctx (%d)\n", gfstatus);
1374 return NULL;
1375 }
1376 }
1377
1378 /* Update layer parameters */
1379 gfstatus=gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
1380 if (gfstatus!=GF_ERR_OK)
1381 {
1382 /* Free main and back surfaces */
1383 gf_surface_free(didata->surface[1]);
1384 didata->surface[1]=NULL;
1385 gf_surface_free(didata->surface[0]);
1386 didata->surface[0]=NULL;
1387
1388 /* Detach layer */
1389 gf_layer_disable(didata->layer);
1390 gf_layer_detach(didata->layer);
1391 didata->layer_attached=SDL_FALSE;
1392 SDL_SetError("GF: Can't update layer parameters\n");
1393 return NULL;
1394 }
1395
1396 /* Enable layer in case if hardware supports layer enable/disable */
1397 gf_layer_enable(didata->layer);
1039 1398
1040 /* Prepare attributes list to pass them to OpenGL ES */ 1399 /* Prepare attributes list to pass them to OpenGL ES */
1041 attr_pos=0; 1400 attr_pos=0;
1042 wdata->gles_attributes[attr_pos++]=EGL_NATIVE_VISUAL_ID; 1401 wdata->gles_attributes[attr_pos++]=EGL_NATIVE_VISUAL_ID;
1043 wdata->gles_attributes[attr_pos++]=qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format); 1402 wdata->gles_attributes[attr_pos++]=qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
1067 { 1426 {
1068 wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE; 1427 wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
1069 wdata->gles_attributes[attr_pos++]=_this->gl_config.buffer_size; 1428 wdata->gles_attributes[attr_pos++]=_this->gl_config.buffer_size;
1070 } 1429 }
1071 1430
1072 /* OpenGL ES 1.0 uses double buffer by default, so if application */
1073 /* do not requested double buffering, switch to single buffer */
1074 if (!_this->gl_config.double_buffer)
1075 {
1076 wdata->gles_attributes[attr_pos++]=EGL_SINGLE_BUFFER;
1077 wdata->gles_attributes[attr_pos++]=EGL_TRUE;
1078 surfaces=1;
1079 }
1080 else
1081 {
1082 surfaces=2;
1083 }
1084
1085 /* Set number of samples in multisampling */ 1431 /* Set number of samples in multisampling */
1086 if (_this->gl_config.multisamplesamples) 1432 if (_this->gl_config.multisamplesamples)
1087 { 1433 {
1088 wdata->gles_attributes[attr_pos++]=EGL_SAMPLES; 1434 wdata->gles_attributes[attr_pos++]=EGL_SAMPLES;
1089 wdata->gles_attributes[attr_pos++]=_this->gl_config.multisamplesamples; 1435 wdata->gles_attributes[attr_pos++]=_this->gl_config.multisamplesamples;
1098 1444
1099 /* Finish attributes list */ 1445 /* Finish attributes list */
1100 wdata->gles_attributes[attr_pos]=EGL_NONE; 1446 wdata->gles_attributes[attr_pos]=EGL_NONE;
1101 1447
1102 /* Request first suitable framebuffer configuration */ 1448 /* Request first suitable framebuffer configuration */
1103 status=eglChooseConfig(gfdata->egldisplay, wdata->gles_attributes, &wdata->gles_config, 1, &configs); 1449 status=eglChooseConfig(gfdata->egldisplay, wdata->gles_attributes,
1450 wdata->gles_configs, SDL_VIDEO_GF_OPENGLES_CONFS, &configs);
1104 if (status!=EGL_TRUE) 1451 if (status!=EGL_TRUE)
1105 { 1452 {
1106 SDL_SetError("GF: Can't find closest configuration for OpenGL ES"); 1453 SDL_SetError("GF: Can't find closest configuration for OpenGL ES");
1107 return NULL; 1454 return NULL;
1108 } 1455 }
1109 1456
1457 /* Check if nothing has been found, try "don't care" settings */
1458 if (configs==0)
1459 {
1460 int32_t it;
1461 int32_t jt;
1462 GLint depthbits[4]={32, 24, 16, EGL_DONT_CARE};
1463
1464 for (it=0; it<4; it++)
1465 {
1466 for (jt=16; jt>=0; jt--)
1467 {
1468 /* Don't care about color buffer bits, use what exist */
1469 /* Replace previous data set with EGL_DONT_CARE */
1470 attr_pos=0;
1471 wdata->gles_attributes[attr_pos++]=EGL_NATIVE_VISUAL_ID;
1472 wdata->gles_attributes[attr_pos++]=qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
1473 wdata->gles_attributes[attr_pos++]=EGL_RED_SIZE;
1474 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1475 wdata->gles_attributes[attr_pos++]=EGL_GREEN_SIZE;
1476 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1477 wdata->gles_attributes[attr_pos++]=EGL_BLUE_SIZE;
1478 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1479 wdata->gles_attributes[attr_pos++]=EGL_ALPHA_SIZE;
1480 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1481 wdata->gles_attributes[attr_pos++]=EGL_BUFFER_SIZE;
1482 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1483
1484 /* Try to find requested or smallest depth */
1485 if (_this->gl_config.depth_size)
1486 {
1487 wdata->gles_attributes[attr_pos++]=EGL_DEPTH_SIZE;
1488 wdata->gles_attributes[attr_pos++]=depthbits[it];
1489 }
1490 else
1491 {
1492 wdata->gles_attributes[attr_pos++]=EGL_DEPTH_SIZE;
1493 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1494 }
1495
1496 if (_this->gl_config.stencil_size)
1497 {
1498 wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
1499 wdata->gles_attributes[attr_pos++]=jt;
1500 }
1501 else
1502 {
1503 wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
1504 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1505
1506 /* exit from stencil loop */
1507 jt=0;
1508 }
1509
1510 /* Don't care about antialiasing */
1511 wdata->gles_attributes[attr_pos++]=EGL_SAMPLES;
1512 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1513 wdata->gles_attributes[attr_pos++]=EGL_SAMPLE_BUFFERS;
1514 wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
1515 wdata->gles_attributes[attr_pos]=EGL_NONE;
1516
1517 /* Request first suitable framebuffer configuration */
1518 status=eglChooseConfig(gfdata->egldisplay, wdata->gles_attributes,
1519 wdata->gles_configs, SDL_VIDEO_GF_OPENGLES_CONFS, &configs);
1520 if (status!=EGL_TRUE)
1521 {
1522 SDL_SetError("Photon: Can't find closest configuration for OpenGL ES");
1523 return NULL;
1524 }
1525 if (configs!=0)
1526 {
1527 break;
1528 }
1529 }
1530 if (configs!=0)
1531 {
1532 break;
1533 }
1534 }
1535
1536 /* No available configs */
1537 if (configs==0)
1538 {
1539 SDL_SetError("Photon: Can't find any configuration for OpenGL ES");
1540 return NULL;
1541 }
1542 }
1543
1544 /* Initialize config index */
1545 wdata->gles_config=0;
1546
1547 /* Now check each configuration to find out the best */
1548 for (cit=0; cit<configs; cit++)
1549 {
1550 uint32_t stencil_found;
1551 uint32_t depth_found;
1552
1553 stencil_found=0;
1554 depth_found=0;
1555
1556 if (_this->gl_config.stencil_size)
1557 {
1558 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[cit], EGL_STENCIL_SIZE, &attr_value);
1559 if (status==EGL_TRUE)
1560 {
1561 if (attr_value!=0)
1562 {
1563 stencil_found=1;
1564 }
1565 }
1566 }
1567 else
1568 {
1569 stencil_found=1;
1570 }
1571
1572 if (_this->gl_config.depth_size)
1573 {
1574 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[cit], EGL_DEPTH_SIZE, &attr_value);
1575 if (status==EGL_TRUE)
1576 {
1577 if (attr_value!=0)
1578 {
1579 depth_found=1;
1580 }
1581 }
1582 }
1583 else
1584 {
1585 depth_found=1;
1586 }
1587
1588 /* Exit from loop if found appropriate configuration */
1589 if ((depth_found!=0) && (stencil_found!=0))
1590 {
1591 break;
1592 }
1593 }
1594
1595 /* If best could not be found, use first */
1596 if (cit==configs)
1597 {
1598 cit=0;
1599 }
1600 wdata->gles_config=cit;
1601
1110 /* Create OpenGL ES context */ 1602 /* Create OpenGL ES context */
1111 wdata->gles_context=eglCreateContext(gfdata->egldisplay, wdata->gles_config, EGL_NO_CONTEXT, NULL); 1603 wdata->gles_context=eglCreateContext(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_NO_CONTEXT, NULL);
1112 if (wdata->gles_context==EGL_NO_CONTEXT) 1604 if (wdata->gles_context==EGL_NO_CONTEXT)
1113 { 1605 {
1114 SDL_SetError("GF: OpenGL ES context creation has been failed"); 1606 SDL_SetError("GF: OpenGL ES context creation has been failed");
1115 return NULL; 1607 return NULL;
1116 } 1608 }
1117 1609
1118 /* Free any 3D target if it was created before */ 1610 /* Free any 3D target if it was created before */
1119 if (wdata->target_created==SDL_TRUE) 1611 if (wdata->target_created==SDL_TRUE)
1120 { 1612 {
1121 gf_3d_target_free(wdata->target); 1613 gf_3d_target_free(wdata->target);
1614 wdata->target_created==SDL_FALSE;
1122 } 1615 }
1123 1616
1124 /* Create surface(s) target for OpenGL ES */ 1617 /* Create surface(s) target for OpenGL ES */
1125 gfstatus=gf_3d_target_create(&wdata->target, didata->layer, NULL, 1618 gfstatus=gf_3d_target_create(&wdata->target, didata->layer, &didata->surface[0],
1126 surfaces, didata->current_mode.w, didata->current_mode.h, 1619 surfaces, didata->current_mode.w, didata->current_mode.h,
1127 qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format)); 1620 qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format));
1128
1129 if (gfstatus!=GF_ERR_OK) 1621 if (gfstatus!=GF_ERR_OK)
1130 { 1622 {
1131 /* Destroy just created context */ 1623 /* Destroy just created context */
1132 eglDestroyContext(gfdata->egldisplay, wdata->gles_context); 1624 eglDestroyContext(gfdata->egldisplay, wdata->gles_context);
1133 wdata->gles_context=EGL_NO_CONTEXT; 1625 wdata->gles_context=EGL_NO_CONTEXT;
1141 { 1633 {
1142 wdata->target_created=SDL_TRUE; 1634 wdata->target_created=SDL_TRUE;
1143 } 1635 }
1144 1636
1145 /* Create target rendering surface on whole screen */ 1637 /* Create target rendering surface on whole screen */
1146 wdata->gles_surface=eglCreateWindowSurface(gfdata->egldisplay, wdata->gles_config, wdata->target, NULL); 1638 wdata->gles_surface=eglCreateWindowSurface(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], wdata->target, NULL);
1147 if (wdata->gles_surface==EGL_NO_SURFACE) 1639 if (wdata->gles_surface==EGL_NO_SURFACE)
1148 { 1640 {
1149 /* Destroy 3d target */ 1641 /* Destroy 3d target */
1150 gf_3d_target_free(wdata->target); 1642 gf_3d_target_free(wdata->target);
1151 wdata->target_created=SDL_FALSE; 1643 wdata->target_created=SDL_FALSE;
1190 } 1682 }
1191 1683
1192 /* Always clear stereo enable, since OpenGL ES do not supports stereo */ 1684 /* Always clear stereo enable, since OpenGL ES do not supports stereo */
1193 _this->gl_config.stereo=0; 1685 _this->gl_config.stereo=0;
1194 1686
1195 /* Failed to create GL ES context */ 1687 /* Get back samples and samplebuffers configurations. Rest framebuffer */
1688 /* parameters could be obtained through the OpenGL ES API */
1689 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_SAMPLES, &attr_value);
1690 if (status==EGL_TRUE)
1691 {
1692 _this->gl_config.multisamplesamples=attr_value;
1693 }
1694 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_SAMPLE_BUFFERS, &attr_value);
1695 if (status==EGL_TRUE)
1696 {
1697 _this->gl_config.multisamplebuffers=attr_value;
1698 }
1699
1700 /* Get back stencil and depth buffer sizes */
1701 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_DEPTH_SIZE, &attr_value);
1702 if (status==EGL_TRUE)
1703 {
1704 _this->gl_config.depth_size=attr_value;
1705 }
1706 status=eglGetConfigAttrib(gfdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_STENCIL_SIZE, &attr_value);
1707 if (status==EGL_TRUE)
1708 {
1709 _this->gl_config.stencil_size=attr_value;
1710 }
1711
1712 /* Restore cursor if it was visible */
1713 if (didata->cursor_visible==SDL_TRUE)
1714 {
1715 gf_cursor_set(didata->display, 0, &didata->cursor);
1716 gf_cursor_enable(didata->display, 0);
1717 }
1718
1719 /* GL ES context was successfully created */
1196 return wdata->gles_context; 1720 return wdata->gles_context;
1197 #else 1721 #else
1198 SDL_SetError("GF: OpenGL ES support is not compiled in"); 1722 SDL_SetError("GF: OpenGL ES support is not compiled in");
1199 return NULL; 1723 return NULL;
1200 #endif /* SDL_VIDEO_OPENGL_ES */ 1724 #endif /* SDL_VIDEO_OPENGL_ES */
1281 { 1805 {
1282 #if defined(SDL_VIDEO_OPENGL_ES) 1806 #if defined(SDL_VIDEO_OPENGL_ES)
1283 SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata; 1807 SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata;
1284 SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata; 1808 SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
1285 1809
1810 /* Finish all drawings */
1811 glFinish();
1812
1813 /* Swap buffers */
1286 eglSwapBuffers(gfdata->egldisplay, wdata->gles_surface); 1814 eglSwapBuffers(gfdata->egldisplay, wdata->gles_surface);
1287 #else 1815 #else
1288 SDL_SetError("GF: OpenGL ES support is not compiled in"); 1816 SDL_SetError("GF: OpenGL ES support is not compiled in");
1289 return; 1817 return;
1290 #endif /* SDL_VIDEO_OPENGL_ES */ 1818 #endif /* SDL_VIDEO_OPENGL_ES */