Mercurial > sdl-ios-xcode

comparison src/video/photon/SDL_photon_render.c @ 3375:dd105b317335

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Continue working on 2D support for Photon/QNX.
author Mike Gorchak <lestat@i.com.ua>
date Sat, 10 Oct 2009 20:15:20 +0000
parents 7f684f249ec9
children 90935231e9b6
comparison
equal deleted inserted replaced
3374:725b16784e96 3375:dd105b317335
66 static void photon_unlocktexture(SDL_Renderer * renderer, 66 static void photon_unlocktexture(SDL_Renderer * renderer,
67 SDL_Texture * texture); 67 SDL_Texture * texture);
68 static void photon_dirtytexture(SDL_Renderer * renderer, 68 static void photon_dirtytexture(SDL_Renderer * renderer,
69 SDL_Texture * texture, int numrects, 69 SDL_Texture * texture, int numrects,
70 const SDL_Rect * rects); 70 const SDL_Rect * rects);
71 static int photon_setdrawcolor(SDL_Renderer * renderer);
72 static int photon_setdrawblendmode(SDL_Renderer * renderer);
71 static int photon_renderpoint(SDL_Renderer * renderer, int x, int y); 73 static int photon_renderpoint(SDL_Renderer * renderer, int x, int y);
72 static int photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, 74 static int photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,
73 int y2); 75 int y2);
74 static int photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect); 76 static int photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);
75 static int photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture, 77 static int photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
78 static void photon_renderpresent(SDL_Renderer * renderer); 80 static void photon_renderpresent(SDL_Renderer * renderer);
79 static void photon_destroytexture(SDL_Renderer * renderer, 81 static void photon_destroytexture(SDL_Renderer * renderer,
80 SDL_Texture * texture); 82 SDL_Texture * texture);
81 static void photon_destroyrenderer(SDL_Renderer * renderer); 83 static void photon_destroyrenderer(SDL_Renderer * renderer);
82 84
85 static int _photon_recreate_surfaces(SDL_Renderer * renderer);
86
83 SDL_RenderDriver photon_renderdriver = { 87 SDL_RenderDriver photon_renderdriver = {
84 photon_createrenderer, 88 photon_createrenderer,
85 { 89 {
86 "photon", 90 "photon",
87 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | 91 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
90 SDL_RENDERER_ACCELERATED), 94 SDL_RENDERER_ACCELERATED),
91 (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR | 95 (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
92 SDL_TEXTUREMODULATE_ALPHA), 96 SDL_TEXTUREMODULATE_ALPHA),
93 (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK | 97 (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
94 SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD), 98 SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
95 (SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW), 99 (SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW |
96 13, 100 SDL_TEXTURESCALEMODE_FAST | SDL_TEXTURESCALEMODE_BEST),
97 { 101 10,
98 SDL_PIXELFORMAT_INDEX8, 102 {SDL_PIXELFORMAT_INDEX8,
99 SDL_PIXELFORMAT_RGB555, 103 SDL_PIXELFORMAT_RGB555,
100 SDL_PIXELFORMAT_RGB565, 104 SDL_PIXELFORMAT_RGB565,
105 SDL_PIXELFORMAT_RGB24,
101 SDL_PIXELFORMAT_RGB888, 106 SDL_PIXELFORMAT_RGB888,
102 SDL_PIXELFORMAT_BGR888,
103 SDL_PIXELFORMAT_ARGB8888, 107 SDL_PIXELFORMAT_ARGB8888,
104 SDL_PIXELFORMAT_RGBA8888,
105 SDL_PIXELFORMAT_ABGR8888,
106 SDL_PIXELFORMAT_BGRA8888,
107 SDL_PIXELFORMAT_YV12, 108 SDL_PIXELFORMAT_YV12,
108 SDL_PIXELFORMAT_YUY2, 109 SDL_PIXELFORMAT_YUY2,
109 SDL_PIXELFORMAT_UYVY, 110 SDL_PIXELFORMAT_UYVY,
110 SDL_PIXELFORMAT_YVYU}, 111 SDL_PIXELFORMAT_YVYU},
111 0, 112 0,
148 renderer->SetTextureScaleMode = photon_settexturescalemode; 149 renderer->SetTextureScaleMode = photon_settexturescalemode;
149 renderer->UpdateTexture = photon_updatetexture; 150 renderer->UpdateTexture = photon_updatetexture;
150 renderer->LockTexture = photon_locktexture; 151 renderer->LockTexture = photon_locktexture;
151 renderer->UnlockTexture = photon_unlocktexture; 152 renderer->UnlockTexture = photon_unlocktexture;
152 renderer->DirtyTexture = photon_dirtytexture; 153 renderer->DirtyTexture = photon_dirtytexture;
154 renderer->SetDrawColor = photon_setdrawcolor;
155 renderer->SetDrawBlendMode = photon_setdrawblendmode;
153 renderer->RenderPoint = photon_renderpoint; 156 renderer->RenderPoint = photon_renderpoint;
154 renderer->RenderLine = photon_renderline; 157 renderer->RenderLine = photon_renderline;
155 renderer->RenderFill = photon_renderfill; 158 renderer->RenderFill = photon_renderfill;
156 renderer->RenderCopy = photon_rendercopy; 159 renderer->RenderCopy = photon_rendercopy;
157 renderer->RenderPresent = photon_renderpresent; 160 renderer->RenderPresent = photon_renderpresent;
165 if ((didata->caps & SDL_PHOTON_ACCELERATED) == SDL_PHOTON_ACCELERATED) { 168 if ((didata->caps & SDL_PHOTON_ACCELERATED) == SDL_PHOTON_ACCELERATED) {
166 renderer->info.flags = SDL_RENDERER_ACCELERATED; 169 renderer->info.flags = SDL_RENDERER_ACCELERATED;
167 } else { 170 } else {
168 renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED); 171 renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);
169 } 172 }
170
171 rdata->window = window;
172 173
173 /* Check if upper level requested synchronization on vsync signal */ 174 /* Check if upper level requested synchronization on vsync signal */
174 if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) { 175 if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {
175 rdata->enable_vsync = SDL_TRUE; 176 rdata->enable_vsync = SDL_TRUE;
176 } else { 177 } else {
212 rdata->surface_render_idx = 0; 213 rdata->surface_render_idx = 0;
213 } 214 }
214 } 215 }
215 } 216 }
216 217
218 /* Create new graphics context */
219 if (rdata->gc==NULL)
220 {
221 rdata->gc=PgCreateGC(0);
222 PgDefaultGC(rdata->gc);
223 }
224
217 return renderer; 225 return renderer;
218 } 226 }
219 227
220 void 228 void
221 photon_addrenderdriver(_THIS) 229 photon_addrenderdriver(_THIS)
223 uint32_t it; 231 uint32_t it;
224 232
225 for (it = 0; it < _this->num_displays; it++) { 233 for (it = 0; it < _this->num_displays; it++) {
226 SDL_AddRenderDriver(it, &photon_renderdriver); 234 SDL_AddRenderDriver(it, &photon_renderdriver);
227 } 235 }
236 }
237
238 /****************************************************************************/
239 /* Render helper functions */
240 /****************************************************************************/
241
242 static int _photon_recreate_surfaces(SDL_Renderer * renderer)
243 {
244 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
245 SDL_VideoDisplay *display = NULL;
246 SDL_DisplayData *didata = NULL;
247 SDL_Window *window = NULL;
248 SDL_WindowData *wdata = NULL;
249 SDL_VideoData *phdata = NULL;
250 uint32_t allocate_task=SDL_PHOTON_SURFTYPE_UNKNOWN;
251 int32_t status;
252
253 /* Obtain window and display structures */
254 window=SDL_GetWindowFromID(renderer->window);
255 wdata=(SDL_WindowData*)window->driverdata;
256 display=SDL_GetDisplayFromWindow(window);
257 didata=(SDL_DisplayData *) display->driverdata;
258 phdata=(SDL_VideoData *) display->device->driverdata;
259
260 /* Check if it is OpenGL ES window */
261 if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
262 /* If so, do not waste surfaces */
263 rdata->surfaces_type=SDL_PHOTON_SURFTYPE_UNKNOWN;
264 return 0;
265 }
266
267 if (rdata->surfaces_type==SDL_PHOTON_SURFTYPE_UNKNOWN)
268 {
269 /* Try to allocate offscreen surfaces */
270 allocate_task=SDL_PHOTON_SURFTYPE_OFFSCREEN;
271 }
272 else
273 {
274 uint32_t it;
275
276 if (rdata->surfaces_type==SDL_PHOTON_SURFTYPE_OFFSCREEN)
277 {
278 /* Create offscreen surfaces */
279 allocate_task=SDL_PHOTON_SURFTYPE_OFFSCREEN;
280
281 /* Destroy current surfaces */
282 for (it=0; it<SDL_PHOTON_MAX_SURFACES; it++)
283 {
284 if (rdata->osurfaces[it] != NULL)
285 {
286 PhDCRelease(rdata->osurfaces[it]);
287 rdata->osurfaces[it] = NULL;
288 }
289 }
290 }
291 else
292 {
293 if (rdata->surfaces_type==SDL_PHOTON_SURFTYPE_PHIMAGE)
294 {
295 /* Create shared phimage surfaces */
296 allocate_task=SDL_PHOTON_SURFTYPE_PHIMAGE;
297
298 /* Destroy current surfaces */
299 for (it=0; it<SDL_PHOTON_MAX_SURFACES; it++)
300 {
301 if (rdata->pcontexts[it]!=NULL)
302 {
303 PmMemReleaseMC(rdata->pcontexts[it]);
304 rdata->pcontexts[it]=NULL;
305 }
306 if (rdata->psurfaces[it]!=NULL)
307 {
308 if (rdata->psurfaces[it]->palette!=NULL)
309 {
310 SDL_free(rdata->psurfaces[it]->palette);
311 rdata->psurfaces[it]->palette=NULL;
312 }
313 /* Destroy shared memory for PhImage_t */
314 PgShmemDestroy(rdata->psurfaces[it]->image);
315 rdata->psurfaces[it]->image=NULL;
316 SDL_free(rdata->psurfaces[it]);
317 rdata->psurfaces[it]=NULL;
318 }
319 }
320 }
321 }
322 }
323
324 /* Check if current device is not the same as target */
325 if (phdata->current_device_id != didata->device_id) {
326 /* Set target device as default for Pd and Pg functions */
327 status = PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
328 if (status != 0) {
329 SDL_SetError("Photon: Can't set default target device\n");
330 return -1;
331 }
332 phdata->current_device_id = didata->device_id;
333 }
334
335 switch (allocate_task)
336 {
337 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
338 {
339 int32_t it;
340 int32_t jt;
341
342 /* Try the hardware accelerated offscreen surfaces first */
343 for (it=0; it<rdata->surfaces_count; it++)
344 {
345 rdata->osurfaces[it]=PdCreateOffscreenContext(0, window->w, window->h,
346 Pg_OSC_MEM_LINEAR_ACCESSIBLE |
347 /* in case if 2D acceleration is not available use CPU optimized surfaces */
348 Pg_OSC_MEM_HINT_CPU_READ | Pg_OSC_MEM_HINT_CPU_WRITE |
349 /* in case if 2D acceleration is available use it */
350 Pg_OSC_MEM_2D_WRITABLE | Pg_OSC_MEM_2D_READABLE);
351
352 /* If we can't create an offscreen surface, then fallback to software */
353 if (rdata->osurfaces[it]==NULL)
354 {
355 /* Destroy previously allocated surface(s) */
356 for (jt = it - 1; jt > 0; jt--)
357 {
358 PhDCRelease(rdata->osurfaces[jt]);
359 rdata->osurfaces[jt] = NULL;
360 }
361 break;
362 }
363 }
364
365 /* Check if all required surfaces have been created */
366 if (rdata->osurfaces[0]!=NULL)
367 {
368 rdata->surfaces_type=SDL_PHOTON_SURFTYPE_OFFSCREEN;
369 /* exit from switch if surfaces have been created */
370 break;
371 }
372 else
373 {
374 /* else fall through to software phimage surface allocation */
375 }
376 }
377 /* fall through */
378 case SDL_PHOTON_SURFTYPE_PHIMAGE:
379 {
380 int32_t it;
381 int32_t jt;
382 uint32_t image_pfmt=photon_sdl_to_image_pixelformat(didata->current_mode.format);
383
384 /* Try to allocate the software surfaces in shared memory */
385 for (it=0; it<rdata->surfaces_count; it++)
386 {
387 /* If this surface with palette, create a palette space */
388 if (image_pfmt==Pg_IMAGE_PALETTE_BYTE)
389 {
390 rdata->psurfaces[it]=PhCreateImage(NULL, window->w, window->h,
391 image_pfmt, NULL, 256, 1);
392 }
393 else
394 {
395 rdata->psurfaces[it]=PhCreateImage(NULL, window->w, window->h,
396 image_pfmt, NULL, 0, 1);
397 }
398
399 if (rdata->psurfaces[it]!=NULL)
400 {
401 PhPoint_t translation={0, 0};
402 PhDim_t dimension={window->w, window->h};
403
404 /* Create memory context for PhImage_t */
405 rdata->pcontexts[it]=PmMemCreateMC(rdata->psurfaces[it], &dimension, &translation);
406 }
407
408 if ((rdata->psurfaces[it]==NULL) || (rdata->pcontexts[it]==NULL))
409 {
410 /* Destroy previously allocated surface(s) */
411 for (jt = it - 1; jt > 0; jt--)
412 {
413 if (rdata->pcontexts[jt]!=NULL)
414 {
415 PmMemReleaseMC(rdata->pcontexts[it]);
416 rdata->pcontexts[jt]=NULL;
417 }
418 if (rdata->psurfaces[jt]!=NULL)
419 {
420 if (rdata->psurfaces[jt]->palette!=NULL)
421 {
422 SDL_free(rdata->psurfaces[jt]->palette);
423 rdata->psurfaces[jt]->palette=NULL;
424 }
425 /* Destroy shared memory for PhImage_t */
426 PgShmemDestroy(rdata->psurfaces[jt]->image);
427 rdata->psurfaces[jt]->image=NULL;
428 SDL_free(rdata->psurfaces[jt]);
429 rdata->psurfaces[jt] = NULL;
430 }
431 }
432 break;
433 }
434 }
435
436 /* Check if all required surfaces have been created */
437 if (rdata->psurfaces[0]!=NULL)
438 {
439 rdata->surfaces_type=SDL_PHOTON_SURFTYPE_PHIMAGE;
440 }
441 else
442 {
443 rdata->surfaces_type=SDL_PHOTON_SURFTYPE_UNKNOWN;
444 }
445 }
446 break;
447 case SDL_PHOTON_SURFTYPE_UNKNOWN:
448 {
449 /* do nothing with surface allocation */
450 rdata->surfaces_type=SDL_PHOTON_SURFTYPE_UNKNOWN;
451 }
452 break;
453 }
454
455 /* Check if one of two allocation scheme was successful */
456 if (rdata->surfaces_type==SDL_PHOTON_SURFTYPE_UNKNOWN)
457 {
458 SDL_SetError("Photon: primary surface(s) allocation failure");
459 return -1;
460 }
461
462 /* Store current surface dimensions */
463 rdata->window_width=window->w;
464 rdata->window_height=window->h;
465
466 /* If current copy/flip scheme is single buffer, then set initial parameters */
467 if ((renderer->info.flags & SDL_RENDERER_SINGLEBUFFER)==SDL_RENDERER_SINGLEBUFFER)
468 {
469 rdata->surface_visible_idx = 0;
470 rdata->surface_render_idx = 0;
471 }
472
473 /* If current copy/flip scheme is double buffer, then set initial parameters */
474 if ((renderer->info.flags & SDL_RENDERER_PRESENTFLIP2)==SDL_RENDERER_PRESENTFLIP2)
475 {
476 rdata->surface_visible_idx = 0;
477 rdata->surface_render_idx = 1;
478 }
479
480 /* If current copy/flip scheme is triple buffer, then set initial parameters */
481 if ((renderer->info.flags & SDL_RENDERER_PRESENTFLIP3)==SDL_RENDERER_PRESENTFLIP3)
482 {
483 rdata->surface_visible_idx = 0;
484 rdata->surface_render_idx = 1;
485 }
486
487 switch (rdata->surfaces_type)
488 {
489 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
490 PgSetGCCx(rdata->osurfaces[rdata->surface_render_idx], rdata->gc);
491 break;
492 case SDL_PHOTON_SURFTYPE_PHIMAGE:
493 PgSetGCCx(rdata->pcontexts[rdata->surface_render_idx], rdata->gc);
494 break;
495 case SDL_PHOTON_SURFTYPE_UNKNOWN:
496 break;
497 }
498
499 return 0;
500 }
501
502 int _photon_update_rectangles(SDL_Renderer* renderer, PhRect_t* rect)
503 {
504 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
505 SDL_Window *window = window=SDL_GetWindowFromID(renderer->window);
506 SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
507 PhPoint_t src_point;
508
509 /* If currently single buffer is in use, we have to flush all data */
510 if (rdata->surface_render_idx==rdata->surface_visible_idx)
511 {
512 /* Flush all undrawn graphics data to surface */
513 switch (rdata->surfaces_type)
514 {
515 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
516 PgFlushCx(rdata->osurfaces[rdata->surface_visible_idx]);
517 PgWaitHWIdle();
518 break;
519 case SDL_PHOTON_SURFTYPE_PHIMAGE:
520 PmMemFlush(rdata->pcontexts[rdata->surface_visible_idx], rdata->psurfaces[rdata->surface_visible_idx]);
521 break;
522 case SDL_PHOTON_SURFTYPE_UNKNOWN:
523 return;
524 }
525 }
526
527 PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
528
529 src_point.x = rect->ul.x;
530 src_point.y = rect->ul.y;
531
532 switch (rdata->surfaces_type)
533 {
534 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
535 PgContextBlit(rdata->osurfaces[rdata->surface_visible_idx], rect, NULL, rect);
536 break;
537 case SDL_PHOTON_SURFTYPE_PHIMAGE:
538 PgDrawPhImageRectv(&src_point, rdata->psurfaces[rdata->surface_visible_idx], rect, 0);
539 break;
540 case SDL_PHOTON_SURFTYPE_UNKNOWN:
541 break;
542 }
228 } 543 }
229 544
230 /****************************************************************************/ 545 /****************************************************************************/
231 /* SDL render interface */ 546 /* SDL render interface */
232 /****************************************************************************/ 547 /****************************************************************************/
548
549 static int
550 photon_activaterenderer(SDL_Renderer * renderer)
551 {
552 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
553 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
554 SDL_WindowData *wdata = (SDL_WindowData *)window->driverdata;
555
556 if ((rdata->window_width!=window->w) || (rdata->window_height!=window->h))
557 {
558 return _photon_recreate_surfaces(renderer);
559 }
560
561 switch (rdata->surfaces_type)
562 {
563 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
564 PgSetGCCx(rdata->osurfaces[rdata->surface_render_idx], rdata->gc);
565 break;
566 case SDL_PHOTON_SURFTYPE_PHIMAGE:
567 PgSetGCCx(rdata->pcontexts[rdata->surface_render_idx], rdata->gc);
568 break;
569 case SDL_PHOTON_SURFTYPE_UNKNOWN:
570 break;
571 }
572
573 return 0;
574 }
575
233 static int 576 static int
234 photon_displaymodechanged(SDL_Renderer * renderer) 577 photon_displaymodechanged(SDL_Renderer * renderer)
235 { 578 {
236 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata; 579 return _photon_recreate_surfaces(renderer);
237
238 /* Remove all allocated surfaces, they are no more valid */
239
240 /* TODO: Add video mode change detection and new parameters detection */
241
242 return 0;
243 }
244
245 static int
246 photon_activaterenderer(SDL_Renderer * renderer)
247 {
248 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
249 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(rdata->window);
250 SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
251
252 return 0;
253 } 580 }
254 581
255 static int 582 static int
256 photon_createtexture(SDL_Renderer * renderer, SDL_Texture * texture) 583 photon_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)
257 { 584 {
267 return -1; 594 return -1;
268 } 595 }
269 596
270 /* Set texture driver data */ 597 /* Set texture driver data */
271 texture->driverdata = tdata; 598 texture->driverdata = tdata;
272
273 } 599 }
274 600
275 static int 601 static int
276 photon_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture, 602 photon_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,
277 void **pixels, int *pitch) 603 void **pixels, int *pitch)
334 int numrects, const SDL_Rect * rects) 660 int numrects, const SDL_Rect * rects)
335 { 661 {
336 } 662 }
337 663
338 static int 664 static int
665 photon_setdrawcolor(SDL_Renderer * renderer)
666 {
667 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
668
669 switch (rdata->surfaces_type)
670 {
671 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
672 case SDL_PHOTON_SURFTYPE_PHIMAGE:
673 PgSetFillColorCx(rdata->gc, PgRGB(renderer->r, renderer->g, renderer->b));
674 PgSetStrokeColorCx(rdata->gc, PgRGB(renderer->r, renderer->g, renderer->b));
675 break;
676 case SDL_PHOTON_SURFTYPE_UNKNOWN:
677 break;
678 }
679 }
680
681 static int
682 photon_setdrawblendmode(SDL_Renderer * renderer)
683 {
684 }
685
686 static int
339 photon_renderpoint(SDL_Renderer * renderer, int x, int y) 687 photon_renderpoint(SDL_Renderer * renderer, int x, int y)
340 { 688 {
689 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
690
691 switch (rdata->surfaces_type)
692 {
693 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
694 PgDrawIPixelCx(rdata->osurfaces[rdata->surface_render_idx], x, y);
695 break;
696 case SDL_PHOTON_SURFTYPE_PHIMAGE:
697 PgDrawIPixelCx(rdata->pcontexts[rdata->surface_render_idx], x, y);
698 break;
699 case SDL_PHOTON_SURFTYPE_UNKNOWN:
700 break;
701 }
341 } 702 }
342 703
343 static int 704 static int
344 photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2) 705 photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
345 { 706 {
707 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
708
709 switch (rdata->surfaces_type)
710 {
711 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
712 PgDrawILineCx(rdata->osurfaces[rdata->surface_render_idx], x1, y1, x2, y2);
713 break;
714 case SDL_PHOTON_SURFTYPE_PHIMAGE:
715 PgDrawILineCx(rdata->pcontexts[rdata->surface_render_idx], x1, y1, x2, y2);
716 break;
717 case SDL_PHOTON_SURFTYPE_UNKNOWN:
718 break;
719 }
346 } 720 }
347 721
348 static int 722 static int
349 photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect) 723 photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)
350 { 724 {
725 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
726
727 switch (rdata->surfaces_type)
728 {
729 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
730 PgDrawIRectCx(rdata->osurfaces[rdata->surface_render_idx], rect->x, rect->y, rect->w+rect->x-1, rect->h+rect->y-1, Pg_DRAW_FILL);
731 break;
732 case SDL_PHOTON_SURFTYPE_PHIMAGE:
733 PgDrawIRectCx(rdata->pcontexts[rdata->surface_render_idx], rect->x, rect->y, rect->w+rect->x-1, rect->h+rect->y-1, Pg_DRAW_FILL);
734 break;
735 case SDL_PHOTON_SURFTYPE_UNKNOWN:
736 break;
737 }
351 } 738 }
352 739
353 static int 740 static int
354 photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture, 741 photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
355 const SDL_Rect * srcrect, const SDL_Rect * dstrect) 742 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
357 } 744 }
358 745
359 static void 746 static void
360 photon_renderpresent(SDL_Renderer * renderer) 747 photon_renderpresent(SDL_Renderer * renderer)
361 { 748 {
749 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
750 SDL_Window *window = window=SDL_GetWindowFromID(renderer->window);
751 SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
752 PhRect_t src_rect;
753 PhPoint_t src_point;
754
755 /* Flush all undrawn graphics data to surface */
756 switch (rdata->surfaces_type)
757 {
758 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
759 PgFlushCx(rdata->osurfaces[rdata->surface_render_idx]);
760 PgWaitHWIdle();
761 break;
762 case SDL_PHOTON_SURFTYPE_PHIMAGE:
763 PmMemFlush(rdata->pcontexts[rdata->surface_render_idx], rdata->psurfaces[rdata->surface_render_idx]);
764 break;
765 case SDL_PHOTON_SURFTYPE_UNKNOWN:
766 return;
767 }
768
769 PgFFlush(Ph_START_DRAW);
770 PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
771
772 /* Set blit area */
773 src_rect.ul.x = 0;
774 src_rect.ul.y = 0;
775 src_rect.lr.x = rdata->window_width - 1;
776 src_rect.lr.y = rdata->window_height - 1;
777
778 src_point.x = 0;
779 src_point.y = 0;
780
781 switch (rdata->surfaces_type)
782 {
783 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
784 PgContextBlit(rdata->osurfaces[rdata->surface_render_idx], &src_rect, NULL, &src_rect);
785 break;
786 case SDL_PHOTON_SURFTYPE_PHIMAGE:
787 PgDrawPhImagev(&src_point, rdata->psurfaces[rdata->surface_render_idx], 0);
788 break;
789 case SDL_PHOTON_SURFTYPE_UNKNOWN:
790 break;
791 }
792
793 /* finish blit */
794 PgFFlush(Ph_DONE_DRAW);
795 PgWaitHWIdle();
362 } 796 }
363 797
364 static void 798 static void
365 photon_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture) 799 photon_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)
366 { 800 {
368 802
369 static void 803 static void
370 photon_destroyrenderer(SDL_Renderer * renderer) 804 photon_destroyrenderer(SDL_Renderer * renderer)
371 { 805 {
372 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata; 806 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
807 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
808 SDL_WindowData *wdata = (SDL_WindowData *)window->driverdata;
373 uint32_t it; 809 uint32_t it;
374 810
811 /* Destroy graphics context */
812 if (rdata->gc!=NULL)
813 {
814 PgDestroyGC(rdata->gc);
815 rdata->gc=NULL;
816 }
817
818 switch (rdata->surfaces_type)
819 {
820 case SDL_PHOTON_SURFTYPE_OFFSCREEN:
821 {
822 /* Destroy current surfaces */
823 for (it=0; it<SDL_PHOTON_MAX_SURFACES; it++)
824 {
825 if (rdata->osurfaces[it] != NULL)
826 {
827 PhDCRelease(rdata->osurfaces[it]);
828 rdata->osurfaces[it] = NULL;
829 }
830 }
831 }
832 break;
833 case SDL_PHOTON_SURFTYPE_PHIMAGE:
834 {
835 /* Destroy current surfaces */
836 for (it=0; it<SDL_PHOTON_MAX_SURFACES; it++)
837 {
838 if (rdata->pcontexts[it]!=NULL)
839 {
840 PmMemReleaseMC(rdata->pcontexts[it]);
841 rdata->pcontexts[it]=NULL;
842 }
843 if (rdata->psurfaces[it]!=NULL)
844 {
845 if (rdata->psurfaces[it]->palette!=NULL)
846 {
847 SDL_free(rdata->psurfaces[it]->palette);
848 rdata->psurfaces[it]->palette=NULL;
849 }
850 /* Destroy shared memory for PhImage_t */
851 PgShmemDestroy(rdata->psurfaces[it]->image);
852 rdata->psurfaces[it]->image=NULL;
853 SDL_free(rdata->psurfaces[it]);
854 rdata->psurfaces[it]=NULL;
855 }
856 }
857 }
858 break;
859 case SDL_PHOTON_SURFTYPE_UNKNOWN:
860 {
861 /* nothing to do */
862 }
863 break;
864 }
375 } 865 }
376 866
377 /* vi: set ts=4 sw=4 expandtab: */ 867 /* vi: set ts=4 sw=4 expandtab: */