Mercurial > sdl-ios-xcode

comparison src/video/x11/SDL_x11render.c @ 4584:9907c8cc6015

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
X11_RenderFillRects and X11_RenderDrawRects use a server side mask pixmap of 1 bit depth now. All drawing on these pixmaps is done by server side functions such as XDrawRectangles and XFillRectangles.
author Sunny Sachanandani <sunnysachanandani@gmail.com>
date Mon, 14 Jun 2010 18:22:48 +0530
parents 5c925d4f220f
children 21600c6d6445
comparison
equal deleted inserted replaced
4583:5c925d4f220f 4584:9907c8cc6015
1 /* 1 /*
2
2 SDL - Simple DirectMedia Layer 3 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2010 Sam Lantinga 4 Copyright (C) 1997-2010 Sam Lantinga
4 5
5 This library is free software; you can redistribute it and/or 6 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public 7 modify it under the terms of the GNU Lesser General Public
94 int depth; 95 int depth;
95 int scanline_pad; 96 int scanline_pad;
96 Window xwindow; 97 Window xwindow;
97 Pixmap pixmaps[3]; 98 Pixmap pixmaps[3];
98 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 99 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
100 Pixmap mask;
99 Picture xwindow_pict; 101 Picture xwindow_pict;
100 Picture pixmap_picts[3]; 102 Picture pixmap_picts[3];
101 Picture drawable_pict; 103 Picture drawable_pict;
104 Picture mask_pict;
102 XRenderPictFormat* xwindow_pict_fmt; 105 XRenderPictFormat* xwindow_pict_fmt;
103 XRenderPictureAttributes xwindow_pict_attr; 106 GC mask_gc;
104 unsigned int xwindow_pict_attr_valuemask; 107 SDL_bool use_xrender;
105 SDL_bool xrender_available;
106 #endif 108 #endif
107 int current_pixmap; 109 int current_pixmap;
108 Drawable drawable; 110 Drawable drawable;
109 SDL_PixelFormat format; 111 SDL_PixelFormat format;
110 GC gc; 112 GC gc;
120 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 122 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
121 Picture picture; 123 Picture picture;
122 XRenderPictFormat* picture_fmt; 124 XRenderPictFormat* picture_fmt;
123 XRenderPictureAttributes picture_attr; 125 XRenderPictureAttributes picture_attr;
124 unsigned int picture_attr_valuemask; 126 unsigned int picture_attr_valuemask;
125 SDL_bool xrender_available; 127 SDL_bool use_xrender;
126 #endif 128 #endif
127 XImage *image; 129 XImage *image;
128 #ifndef NO_SHARED_MEMORY 130 #ifndef NO_SHARED_MEMORY
129 /* MIT shared memory extension information */ 131 /* MIT shared memory extension information */
130 XShmSegmentInfo shminfo; 132 XShmSegmentInfo shminfo;
215 data->scanline_pad = displaydata->scanline_pad; 217 data->scanline_pad = displaydata->scanline_pad;
216 data->xwindow = windowdata->xwindow; 218 data->xwindow = windowdata->xwindow;
217 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 219 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
218 int event_basep, error_basep; 220 int event_basep, error_basep;
219 if(XRenderQueryExtension(data->display, &event_basep, &error_basep) == True) { 221 if(XRenderQueryExtension(data->display, &event_basep, &error_basep) == True) {
220 data->xrender_available = SDL_TRUE; 222 data->use_xrender = SDL_TRUE;
221 data->xwindow_pict_fmt = XRenderFindVisualFormat(data->display, data->visual); 223 data->xwindow_pict_fmt = XRenderFindVisualFormat(data->display, data->visual);
222 if(!data->xwindow_pict_fmt) { 224 if(!data->xwindow_pict_fmt) {
223 data->xrender_available = SDL_FALSE; 225 data->use_xrender = SDL_FALSE;
226 goto fallback;
224 } 227 }
225 data->xwindow_pict = XRenderCreatePicture(data->display, data->xwindow, data->xwindow_pict_fmt, 228 data->xwindow_pict = XRenderCreatePicture(data->display, data->xwindow, data->xwindow_pict_fmt,
226 0, None); 229 0, NULL);
227 if(!data->xwindow_pict) { 230 if(!data->xwindow_pict) {
228 data->xrender_available = SDL_FALSE; 231 data->use_xrender = SDL_FALSE;
229 } 232 goto fallback;
233 }
234 // Create a 1 bit depth mask
235 data->mask = XCreatePixmap(data->display, data->xwindow, window->w, window->h, 1);
236 data->mask_pict = XRenderCreatePicture(data->display, data->mask,
237 XRenderFindStandardFormat(data->display, PictStandardA1),
238 0, NULL);
239 XGCValues gcv_mask;
240 gcv_mask.foreground = 1;
241 gcv_mask.background = 0;
242 data->mask_gc = XCreateGC(data->display, data->mask, GCBackground | GCForeground, &gcv_mask);
230 } 243 }
231 else { 244 else {
232 data->xrender_available = SDL_FALSE; 245 data->use_xrender = SDL_FALSE;
233 } 246 }
247 fallback:
234 #endif 248 #endif
235 renderer->DisplayModeChanged = X11_DisplayModeChanged; 249 renderer->DisplayModeChanged = X11_DisplayModeChanged;
236 renderer->CreateTexture = X11_CreateTexture; 250 renderer->CreateTexture = X11_CreateTexture;
237 renderer->QueryTexturePixels = X11_QueryTexturePixels; 251 renderer->QueryTexturePixels = X11_QueryTexturePixels;
238 renderer->SetTextureBlendMode = X11_SetTextureBlendMode; 252 renderer->SetTextureBlendMode = X11_SetTextureBlendMode;
279 X11_DestroyRenderer(renderer); 293 X11_DestroyRenderer(renderer);
280 SDL_SetError("XCreatePixmap() failed"); 294 SDL_SetError("XCreatePixmap() failed");
281 return NULL; 295 return NULL;
282 } 296 }
283 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 297 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
284 if(data->xrender_available == SDL_TRUE) { 298 if(data->use_xrender == SDL_TRUE) {
285 data->pixmap_picts[i] = 299 data->pixmap_picts[i] =
286 XRenderCreatePicture(data->display, data->pixmaps[i], data->xwindow_pict_fmt, 300 XRenderCreatePicture(data->display, data->pixmaps[i], data->xwindow_pict_fmt,
287 0, None); 301 0, None);
288 if(!data->pixmap_picts[i]) { 302 if(!data->pixmap_picts[i]) {
289 data->xrender_available = SDL_FALSE; 303 data->use_xrender = SDL_FALSE;
290 } 304 }
291 XRenderComposite(data->display, PictOpClear, data->pixmap_picts[i], None, data->pixmap_picts[i], 305 XRenderComposite(data->display, PictOpClear, data->pixmap_picts[i], None, data->pixmap_picts[i],
292 0, 0, 0, 0, 0, 0, window->w, window->h); 306 0, 0, 0, 0, 0, 0, window->w, window->h);
293 } 307 }
294 #endif 308 #endif
295 } 309 }
296 if (n > 0) { 310 if (n > 0) {
297 data->drawable = data->pixmaps[0]; 311 data->drawable = data->pixmaps[0];
298 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 312 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
299 if(data->xrender_available == SDL_TRUE) 313 if(data->use_xrender == SDL_TRUE)
300 data->drawable_pict = data->pixmap_picts[0]; 314 data->drawable_pict = data->pixmap_picts[0];
301 #endif 315 #endif
302 data->makedirty = SDL_TRUE; 316 data->makedirty = SDL_TRUE;
303 } else { 317 } else {
304 data->drawable = data->xwindow; 318 data->drawable = data->xwindow;
305 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 319 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
306 if(data->xrender_available == SDL_TRUE) 320 if(data->use_xrender == SDL_TRUE)
307 data->drawable_pict = data->xwindow_pict; 321 data->drawable_pict = data->xwindow_pict;
308 #endif 322 #endif
309 data->makedirty = SDL_FALSE; 323 data->makedirty = SDL_FALSE;
310 } 324 }
311 data->current_pixmap = 0; 325 data->current_pixmap = 0;
365 if (data->pixmaps[i] == None) { 379 if (data->pixmaps[i] == None) {
366 SDL_SetError("XCreatePixmap() failed"); 380 SDL_SetError("XCreatePixmap() failed");
367 return -1; 381 return -1;
368 } 382 }
369 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 383 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
370 if(data->xrender_available == SDL_TRUE) { 384 if(data->use_xrender == SDL_TRUE) {
371 data->pixmap_picts[i] = 385 data->pixmap_picts[i] =
372 XRenderCreatePicture(data->display, data->pixmaps[i], data->xwindow_pict_fmt, 386 XRenderCreatePicture(data->display, data->pixmaps[i], data->xwindow_pict_fmt,
373 0, None); 387 0, None);
374 if(!data->pixmap_picts[i]) { 388 if(!data->pixmap_picts[i]) {
375 data->xrender_available = SDL_FALSE; 389 data->use_xrender = SDL_FALSE;
376 } 390 }
377 XRenderComposite(data->display, PictOpClear, data->pixmap_picts[i], None, data->pixmap_picts[i], 391 XRenderComposite(data->display, PictOpClear, data->pixmap_picts[i], None, data->pixmap_picts[i],
378 0, 0, 0, 0, 0, 0, window->w, window->h); 392 0, 0, 0, 0, 0, 0, window->w, window->h);
379 } 393 }
380 #endif 394 #endif
418 Xrender is available at runtime. If it is available there 432 Xrender is available at runtime. If it is available there
419 can be no BadMatch error since Xrender takes care of that. 433 can be no BadMatch error since Xrender takes care of that.
420 */ 434 */
421 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 435 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
422 // Assume the texture is supported by Xrender 436 // Assume the texture is supported by Xrender
423 data->xrender_available = SDL_TRUE; 437 data->use_xrender = SDL_TRUE;
424 if(renderdata->xrender_available == SDL_FALSE) { 438 if(renderdata->use_xrender == SDL_FALSE) {
425 if (texture->format != display->current_mode.format) { 439 if (texture->format != display->current_mode.format) {
426 SDL_SetError("Texture format doesn't match window format"); 440 SDL_SetError("Texture format doesn't match window format");
427 return -1; 441 return -1;
428 } 442 }
429 } 443 }
542 SDL_SetError("XCreateImage() failed"); 556 SDL_SetError("XCreateImage() failed");
543 return -1; 557 return -1;
544 } 558 }
545 } 559 }
546 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 560 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
547 if(renderdata->xrender_available && data->pixmap) { 561 if(renderdata->use_xrender && data->pixmap) {
548 data->xrender_available = SDL_TRUE; 562 data->use_xrender = SDL_TRUE;
549 unsigned long x11_fmt_mask; // Format mask 563 unsigned long x11_fmt_mask; // Format mask
550 XRenderPictFormat x11_templ_fmt; // Format template 564 XRenderPictFormat x11_templ_fmt; // Format template
551 x11_fmt_mask = 565 x11_fmt_mask =
552 (PictFormatDepth | PictFormatRedMask | PictFormatGreenMask 566 (PictFormatDepth | PictFormatRedMask | PictFormatGreenMask
553 | PictFormatBlueMask); 567 | PictFormatBlueMask);
561 x11_templ_fmt.direct.alphaMask = Amask; 575 x11_templ_fmt.direct.alphaMask = Amask;
562 /* Return one matching XRenderPictFormat */ 576 /* Return one matching XRenderPictFormat */
563 data->picture_fmt = 577 data->picture_fmt =
564 XRenderFindFormat(renderdata->display, x11_fmt_mask, &x11_templ_fmt, 1); 578 XRenderFindFormat(renderdata->display, x11_fmt_mask, &x11_templ_fmt, 1);
565 if(!data->picture_fmt) { 579 if(!data->picture_fmt) {
566 data->xrender_available = SDL_FALSE; 580 data->use_xrender = SDL_FALSE;
567 } 581 }
568 data->picture_attr_valuemask = CPGraphicsExposure; 582 data->picture_attr_valuemask = CPGraphicsExposure;
569 (data->picture_attr).graphics_exposures = False; 583 (data->picture_attr).graphics_exposures = False;
570 data->picture = 584 data->picture =
571 XRenderCreatePicture(renderdata->display, data->pixmap, data->picture_fmt, 585 XRenderCreatePicture(renderdata->display, data->pixmap, data->picture_fmt,
572 data->picture_attr_valuemask, &(data->picture_attr)); 586 data->picture_attr_valuemask, &(data->picture_attr));
573 if(!data->picture) { 587 if(!data->picture) {
574 data->xrender_available = SDL_FALSE; 588 data->use_xrender = SDL_FALSE;
575 } 589 }
576 } 590 }
577 /* We thought we could render the texture with Xrender but this was 591 /* We thought we could render the texture with Xrender but this was
578 not possible for some reason. Now we must ensure that texture 592 not possible for some reason. Now we must ensure that texture
579 format and window format match to avoid a BadMatch error. 593 format and window format match to avoid a BadMatch error.
580 */ 594 */
581 if(data->xrender_available == SDL_FALSE) { 595 if(data->use_xrender == SDL_FALSE) {
582 if (texture->format != display->current_mode.format) { 596 if (texture->format != display->current_mode.format) {
583 SDL_SetError("Texture format doesn't match window format"); 597 SDL_SetError("Texture format doesn't match window format");
584 return -1; 598 return -1;
585 } 599 }
586 } 600 }
972 X11_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count) 986 X11_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
973 { 987 {
974 X11_RenderData *data = (X11_RenderData *) renderer->driverdata; 988 X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
975 SDL_Window *window = renderer->window; 989 SDL_Window *window = renderer->window;
976 SDL_Rect clip, rect; 990 SDL_Rect clip, rect;
977 unsigned long foreground; 991 int i, xcount;
978 XRectangle *xrects, *xrect; 992 XRectangle *xrects, *xrect;
979 int i, xcount; 993
980
981 clip.x = 0; 994 clip.x = 0;
982 clip.y = 0; 995 clip.y = 0;
983 clip.w = window->w; 996 clip.w = window->w;
984 clip.h = window->h; 997 clip.h = window->h;
985 998
986 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 999 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
987 if(data->xrender_available == SDL_TRUE) { 1000 if(data->use_xrender == SDL_TRUE) {
988 XRenderColor xrender_foreground; 1001 XRectangle xclip;
989 xrender_foreground = xrenderdrawcolor(renderer);
990 1002
991 xrects = SDL_stack_alloc(XRectangle, 4*count); 1003 xclip.x = (short)clip.x;
1004 xclip.y = (short)clip.y;
1005 xclip.width = (unsigned short)clip.w;
1006 xclip.height = (unsigned short)clip.h;
1007
1008 XRenderColor foreground;
1009 foreground = xrenderdrawcolor(renderer);
1010
1011 xrect = xrects = SDL_stack_alloc(XRectangle, count);
992 xcount = 0; 1012 xcount = 0;
993 for(i = 0; i < 4*count; i+=4) { 1013 for (i = 0; i < count; ++i) {
994 if(!SDL_IntersectRect(rects[i], &clip, &rect)) { 1014 xrect->x = (short)rects[i]->x;
995 continue; 1015 xrect->y = (short)rects[i]->y;
996 } 1016 xrect->width = (unsigned short)rects[i]->w;
997 1017 xrect->height = (unsigned short)rects[i]->h;
998 xrects[xcount].x = rect.x; 1018 ++xrect;
999 xrects[xcount].y = rect.y;
1000 xrects[xcount].width = 1;
1001 xrects[xcount].height = rect.h;
1002 ++xcount; 1019 ++xcount;
1003 xrects[xcount].x = rect.x; 1020 }
1004 xrects[xcount].y = rect.y+rect.h; 1021 if (data->makedirty) {
1005 xrects[xcount].width = rect.w; 1022 SDL_AddDirtyRect(&data->dirty, &clip);
1006 xrects[xcount].height = 1; 1023 }
1007 ++xcount; 1024 XRenderComposite(data->display, PictOpClear, data->mask_pict, None, data->mask_pict,
1008 xrects[xcount].x = rect.x+rect.w; 1025 0, 0, 0, 0, 0, 0, window->w, window->h);
1009 xrects[xcount].y = rect.y; 1026 XDrawRectangles(data->display, data->mask, data->mask_gc, xrects, xcount);
1010 xrects[xcount].width = 1; 1027 Picture fill =
1011 xrects[xcount].height = rect.h; 1028 XRenderCreateSolidFill(data->display, &foreground);
1012 ++xcount; 1029 XRenderSetPictureClipRectangles(data->display, data->drawable_pict, 0, 0, &xclip, 1);
1013 xrects[xcount].x = rect.x; 1030 XRenderComposite(data->display, PictOpOver, fill, data->mask_pict, data->drawable_pict,
1014 xrects[xcount].y = rect.y; 1031 0, 0, 0, 0, 0, 0, window->w, window->h);
1015 xrects[xcount].width = rect.w; 1032 XRenderFreePicture(data->display, fill);
1016 xrects[xcount].height = 1; 1033 SDL_stack_free(xrects);
1017 ++xcount;
1018 if(data->makedirty) {
1019 SDL_AddDirtyRect(&data->dirty, &rect);
1020 }
1021 }
1022 XRenderFillRectangles(data->display, PictOpOver, data->drawable_pict,
1023 &xrender_foreground, xrects, xcount);
1024 } 1034 }
1025 else 1035 else
1026 #endif 1036 #endif
1027 { 1037 {
1038
1039 unsigned long foreground;
1040
1028 foreground = renderdrawcolor(renderer, 1); 1041 foreground = renderdrawcolor(renderer, 1);
1029 XSetForeground(data->display, data->gc, foreground); 1042 XSetForeground(data->display, data->gc, foreground);
1030 1043
1031 xrect = xrects = SDL_stack_alloc(XRectangle, count); 1044 xrect = xrects = SDL_stack_alloc(XRectangle, count);
1032 xcount = 0; 1045 xcount = 0;
1060 X11_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count) 1073 X11_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
1061 { 1074 {
1062 X11_RenderData *data = (X11_RenderData *) renderer->driverdata; 1075 X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
1063 SDL_Window *window = renderer->window; 1076 SDL_Window *window = renderer->window;
1064 SDL_Rect clip, rect; 1077 SDL_Rect clip, rect;
1065 unsigned long foreground; 1078
1066 XRectangle *xrects, *xrect;
1067 int i, xcount;
1068
1069 clip.x = 0; 1079 clip.x = 0;
1070 clip.y = 0; 1080 clip.y = 0;
1071 clip.w = window->w; 1081 clip.w = window->w;
1072 clip.h = window->h; 1082 clip.h = window->h;
1073 1083
1074 foreground = renderdrawcolor(renderer, 1); 1084 int i, xcount;
1075 XSetForeground(data->display, data->gc, foreground); 1085 XRectangle *xrects, *xrect;
1076 1086
1077 xrect = xrects = SDL_stack_alloc(XRectangle, count); 1087 xrect = xrects = SDL_stack_alloc(XRectangle, count);
1078 xcount = 0; 1088 xcount = 0;
1079 for (i = 0; i < count; ++i) { 1089
1080 if (!SDL_IntersectRect(rects[i], &clip, &rect)) { 1090 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
1081 continue; 1091 if(data->use_xrender == SDL_TRUE) {
1082 } 1092 XRectangle xclip;
1083 1093
1084 xrect->x = (short)rect.x; 1094 xclip.x = (short)clip.x;
1085 xrect->y = (short)rect.y; 1095 xclip.y = (short)clip.y;
1086 xrect->width = (unsigned short)rect.w; 1096 xclip.width = (unsigned short)clip.w;
1087 xrect->height = (unsigned short)rect.h; 1097 xclip.height = (unsigned short)clip.h;
1088 ++xrect; 1098
1089 ++xcount; 1099 XRenderColor foreground;
1090 1100
1101 foreground = xrenderdrawcolor(renderer);
1102
1103 for (i = 0; i < count; ++i) {
1104 xrect->x = (short)rects[i]->x;
1105 xrect->y = (short)rects[i]->y;
1106 xrect->width = (unsigned short)rects[i]->w;
1107 xrect->height = (unsigned short)rects[i]->h;
1108 ++xrect;
1109 ++xcount;
1110 }
1091 if (data->makedirty) { 1111 if (data->makedirty) {
1092 SDL_AddDirtyRect(&data->dirty, &rect); 1112 SDL_AddDirtyRect(&data->dirty, &clip);
1093 } 1113 }
1094 } 1114 XRenderComposite(data->display, PictOpClear, data->mask_pict, None, data->mask_pict,
1095 if (xcount > 0) { 1115 0, 0, 0, 0, 0, 0, window->w, window->h);
1096 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 1116 XFillRectangles(data->display, data->mask, data->mask_gc,
1097 if(data->xrender_available == SDL_TRUE) 1117 xrects, xcount);
1098 { 1118 XRenderSetPictureClipRectangles(data->display, data->drawable_pict, 0, 0, &xclip, 1);
1099 XRenderColor xrender_foreground_color; 1119 Picture fill =
1100 xrender_foreground_color = xrenderdrawcolor(renderer); 1120 XRenderCreateSolidFill(data->display, &foreground);
1101 XRenderFillRectangles(data->display, PictOpOver, data->drawable_pict, 1121 XRenderComposite(data->display, PictOpOver, fill, data->mask_pict, data->drawable_pict,
1102 &xrender_foreground_color, xrects, xcount); 1122 0, 0, 0, 0, 0, 0, window->w, window->h);
1103 } 1123 XRenderFreePicture(data->display, fill);
1104 else 1124 SDL_stack_free(xrects);
1105 #endif 1125
1106 { 1126 }
1127 else
1128 #endif
1129 {
1130 unsigned long foreground;
1131 XRectangle *xrects, *xrect;
1132
1133 foreground = renderdrawcolor(renderer, 1);
1134 XSetForeground(data->display, data->gc, foreground);
1135
1136 xrect = xrects = SDL_stack_alloc(XRectangle, count);
1137 xcount = 0;
1138 for (i = 0; i < count; ++i) {
1139 if (!SDL_IntersectRect(rects[i], &clip, &rect)) {
1140 continue;
1141 }
1142
1143 xrect->x = (short)rect.x;
1144 xrect->y = (short)rect.y;
1145 xrect->width = (unsigned short)rect.w;
1146 xrect->height = (unsigned short)rect.h;
1147 ++xrect;
1148 ++xcount;
1149
1150 if (data->makedirty) {
1151 SDL_AddDirtyRect(&data->dirty, &rect);
1152 }
1153 }
1107 XFillRectangles(data->display, data->drawable, data->gc, 1154 XFillRectangles(data->display, data->drawable, data->gc,
1108 xrects, xcount); 1155 xrects, xcount);
1109 } 1156 SDL_stack_free(xrects);
1110 } 1157 }
1111 SDL_stack_free(xpoints); 1158
1112
1113 return 0; 1159 return 0;
1114 } 1160 }
1115 1161
1116 static int 1162 static int
1117 X11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, 1163 X11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
1297 /* Send the data to the display */ 1343 /* Send the data to the display */
1298 if (!(renderer->info.flags & SDL_RENDERER_SINGLEBUFFER)) { 1344 if (!(renderer->info.flags & SDL_RENDERER_SINGLEBUFFER)) {
1299 for (dirty = data->dirty.list; dirty; dirty = dirty->next) { 1345 for (dirty = data->dirty.list; dirty; dirty = dirty->next) {
1300 const SDL_Rect *rect = &dirty->rect; 1346 const SDL_Rect *rect = &dirty->rect;
1301 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER 1347 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
1302 if(data->xrender_available == SDL_TRUE) 1348 if(data->use_xrender == SDL_TRUE)
1303 { 1349 {
1304 XRenderComposite(data->display, PictOpOver, data->drawable_pict, None, data->xwindow_pict, 1350 XRenderComposite(data->display, PictOpOver, data->drawable_pict, None, data->xwindow_pict,
1305 rect->x, rect->y, 0, 0, rect->x, rect->y, rect->w+1, rect->h+1); 1351 rect->x, rect->y, 0, 0, rect->x, rect->y, rect->w, rect->h);
1306 } 1352 }
1307 else 1353 else
1308 #endif 1354 #endif
1309 { 1355 {
1310 XCopyArea(data->display, data->drawable, data->xwindow, 1356 XCopyArea(data->display, data->drawable, data->xwindow,
1311 data->gc, rect->x, rect->y, rect->w, rect->h, 1357 data->gc, rect->x, rect->y, rect->w, rect->h,
1312 rect->x, rect->y); 1358 rect->x, rect->y);
1313 } 1359 }
1314 } 1360 }
1315 SDL_ClearDirtyRects(&data->dirty); 1361 SDL_ClearDirtyRects(&data->dirty);
1316 /*#ifdef SDL_VIDEO_DRIVER_X11_XRENDER 1362 }
1317 // Clear each pixmap after a render
1318 if(data->xrender_available == SDL_TRUE) {
1319 XRenderComposite(data->display, PictOpClear, data->drawable_pict, None, data->drawable_pict,
1320 0, 0, 0, 0, 0, 0, renderer->window->w, renderer->window->h);
1321 }
1322 #endif*/
1323 }
1324 XSync(data->display, False); 1363 XSync(data->display, False);
1325 1364
1326 /* Update the flipping chain, if any */ 1365 /* Update the flipping chain, if any */
1327 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) { 1366 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
1328 data->current_pixmap = (data->current_pixmap + 1) % 2; 1367 data->current_pixmap = (data->current_pixmap + 1) % 2;
1387 if (data) { 1426 if (data) {
1388 for (i = 0; i < SDL_arraysize(data->pixmaps); ++i) { 1427 for (i = 0; i < SDL_arraysize(data->pixmaps); ++i) {
1389 if (data->pixmaps[i] != None) { 1428 if (data->pixmaps[i] != None) {
1390 XFreePixmap(data->display, data->pixmaps[i]); 1429 XFreePixmap(data->display, data->pixmaps[i]);
1391 } 1430 }
1431 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
1432 if (data->pixmap_picts[i] != None) {
1433 XRenderFreePicture(data->display, data->pixmap_picts[i]);
1434 }
1435 #endif
1392 } 1436 }
1393 if (data->gc) { 1437 if (data->gc) {
1394 XFreeGC(data->display, data->gc); 1438 XFreeGC(data->display, data->gc);
1395 } 1439 }
1440 if (data->drawable) {
1441 XFreePixmap(data->display, data->drawable);
1442 }
1443 #ifdef SDL_VIDEO_DRIVER_X11_XRENDER
1444 if (data->mask_gc) {
1445 XFreeGC(data->display, data->gc);
1446 }
1447 if (data->mask_pict) {
1448 XRenderFreePicture(data->display, data->mask_pict);
1449 }
1450 if (data->mask) {
1451 XFreePixmap(data->display, data->mask);
1452 }
1453 if (data->drawable_pict) {
1454 XRenderFreePicture(data->display, data->drawable_pict);
1455 }
1456 if (data->xwindow_pict) {
1457 XRenderFreePicture(data->display, data->xwindow_pict);
1458 }
1459 #endif
1396 SDL_FreeDirtyRects(&data->dirty); 1460 SDL_FreeDirtyRects(&data->dirty);
1397 SDL_free(data); 1461 SDL_free(data);
1398 } 1462 }
1399 SDL_free(renderer); 1463 SDL_free(renderer);
1400 } 1464 }