/* * Create a surface on the stack for quick blit operations */ static SDL_INLINE SDL_bool SDL_CreateSurfaceOnStack(int width, int height, Uint32 pixel_format, void * pixels, int pitch, SDL_Surface * surface, SDL_PixelFormat * format, SDL_BlitMap * blitmap) { if (SDL_ISPIXELFORMAT_INDEXED(pixel_format)) { SDL_SetError("Indexed pixel formats not supported"); return SDL_FALSE; } if (SDL_InitFormat(format, pixel_format) < 0) { return SDL_FALSE; } SDL_zerop(surface); surface->flags = SDL_PREALLOC; surface->format = format; surface->pixels = pixels; surface->w = width; surface->h = height; surface->pitch = pitch; /* We don't actually need to set up the clip rect for our purposes */ /* SDL_SetClipRect(surface, NULL); */ /* Allocate an empty mapping */ SDL_zerop(blitmap); blitmap->info.r = 0xFF; blitmap->info.g = 0xFF; blitmap->info.b = 0xFF; blitmap->info.a = 0xFF; surface->map = blitmap; /* The surface is ready to go */ surface->refcount = 1; return SDL_TRUE; }
void DirectFB_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); SDL_Surface *surface = NULL; DFBResult ret; if (icon) { SDL_PixelFormat format; DFBSurfaceDescription dsc; Uint32 *dest; Uint32 *p; int pitch, i; /* Convert the icon to ARGB for modern window managers */ SDL_InitFormat(&format, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000); surface = SDL_ConvertSurface(icon, &format, 0); if (!surface) { return; } dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.caps = DSCAPS_VIDEOONLY; dsc.width = surface->w; dsc.height = surface->h; dsc.pixelformat = DSPF_ARGB; SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &windata->icon)); SDL_DFB_CHECKERR(windata->icon->Lock(windata->icon, DSLF_WRITE, (void *) &dest, &pitch)); p = surface->pixels; for (i = 0; i < surface->h; i++) memcpy((char *) dest + i * pitch, (char *) p + i * surface->pitch, 4 * surface->w); windata->icon->Unlock(windata->icon); SDL_FreeSurface(surface); } else { SDL_DFB_RELEASE(windata->icon); } return; error: if (surface) SDL_FreeSurface(surface); SDL_DFB_RELEASE(windata->icon); return; }
int Android_VideoInit(_THIS) { SDL_DisplayMode mode; mode.format = Android_ScreenFormat; mode.w = Android_ScreenWidth; mode.h = Android_ScreenHeight; mode.refresh_rate = Android_ScreenRate; mode.driverdata = NULL; // Urho3D: merge patch found in https://bugzilla.libsdl.org/show_bug.cgi?id=2291 submitted by Thomas Faller SDL_PixelFormat pixelFormat; Uint32 mask; int bitCount; /* We need to set color sizes */ if(!SDL_InitFormat(&pixelFormat, mode.format)){ for(mask = pixelFormat.Rmask >> pixelFormat.Rshift, bitCount = 0; mask > 0; mask >>= 1) bitCount += 1; SDL_GL_SetAttribute(SDL_GL_RED_SIZE, bitCount); for(mask = pixelFormat.Gmask >> pixelFormat.Gshift, bitCount = 0; mask > 0; mask >>= 1) bitCount += 1; SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, bitCount); for(mask = pixelFormat.Bmask >> pixelFormat.Bshift, bitCount = 0; mask > 0; mask >>= 1) bitCount += 1; SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, bitCount); for(mask = pixelFormat.Amask >> pixelFormat.Ashift, bitCount = 0; mask > 0; mask >>= 1) bitCount += 1; SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, bitCount); } if (SDL_AddBasicVideoDisplay(&mode) < 0) { return -1; } SDL_AddDisplayMode(&_this->displays[0], &mode); Android_InitKeyboard(); Android_InitTouch(); Android_InitMouse(); /* We're done! */ return 0; }
/* * Allocate a pixel format structure and fill it according to the given info. */ SDL_PixelFormat * SDL_AllocFormat(int bpp, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { SDL_PixelFormat *format; /* Allocate an empty pixel format structure */ format = SDL_malloc(sizeof(*format)); if (format == NULL) { SDL_OutOfMemory(); return (NULL); } /* Set up the format */ return SDL_InitFormat(format, bpp, Rmask, Gmask, Bmask, Amask); }
int SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst) { long fp_offset; int i, pad; SDL_Surface *surface; Uint8 *bits; /* The Win32 BMP file header (14 bytes) */ char magic[2] = { 'B', 'M' }; Uint32 bfSize; Uint16 bfReserved1; Uint16 bfReserved2; Uint32 bfOffBits; /* The Win32 BITMAPINFOHEADER struct (40 bytes) */ Uint32 biSize; Sint32 biWidth; Sint32 biHeight; Uint16 biPlanes; Uint16 biBitCount; Uint32 biCompression; Uint32 biSizeImage; Sint32 biXPelsPerMeter; Sint32 biYPelsPerMeter; Uint32 biClrUsed; Uint32 biClrImportant; /* Make sure we have somewhere to save */ surface = NULL; if (dst) { SDL_bool save32bit = SDL_FALSE; #ifdef SAVE_32BIT_BMP /* We can save alpha information in a 32-bit BMP */ if (saveme->map->info.flags & SDL_COPY_COLORKEY || saveme->format->Amask) { save32bit = SDL_TRUE; } #endif /* SAVE_32BIT_BMP */ if (saveme->format->palette && !save32bit) { if (saveme->format->BitsPerPixel == 8) { surface = saveme; } else { SDL_SetError("%d bpp BMP files not supported", saveme->format->BitsPerPixel); } } else if ((saveme->format->BitsPerPixel == 24) && #if SDL_BYTEORDER == SDL_LIL_ENDIAN (saveme->format->Rmask == 0x00FF0000) && (saveme->format->Gmask == 0x0000FF00) && (saveme->format->Bmask == 0x000000FF) #else (saveme->format->Rmask == 0x000000FF) && (saveme->format->Gmask == 0x0000FF00) && (saveme->format->Bmask == 0x00FF0000) #endif ) { surface = saveme; } else { SDL_PixelFormat format; /* If the surface has a colorkey or alpha channel we'll save a 32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */ if (save32bit) { SDL_InitFormat(&format, #if SDL_BYTEORDER == SDL_LIL_ENDIAN SDL_PIXELFORMAT_ARGB8888 #else SDL_PIXELFORMAT_BGRA8888 #endif ); } else { SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24); } surface = SDL_ConvertSurface(saveme, &format, 0); if (!surface) { SDL_SetError("Couldn't convert image to %d bpp", format.BitsPerPixel); } } } if (surface && (SDL_LockSurface(surface) == 0)) { const int bw = surface->w * surface->format->BytesPerPixel; /* Set the BMP file header values */ bfSize = 0; /* We'll write this when we're done */ bfReserved1 = 0; bfReserved2 = 0; bfOffBits = 0; /* We'll write this when we're done */ /* Write the BMP file header values */ fp_offset = SDL_RWtell(dst); SDL_ClearError(); SDL_RWwrite(dst, magic, 2, 1); SDL_WriteLE32(dst, bfSize); SDL_WriteLE16(dst, bfReserved1); SDL_WriteLE16(dst, bfReserved2); SDL_WriteLE32(dst, bfOffBits); /* Set the BMP info values */ biSize = 40; biWidth = surface->w; biHeight = surface->h; biPlanes = 1; biBitCount = surface->format->BitsPerPixel; biCompression = BI_RGB; biSizeImage = surface->h * surface->pitch; biXPelsPerMeter = 0; biYPelsPerMeter = 0; if (surface->format->palette) { biClrUsed = surface->format->palette->ncolors; } else { biClrUsed = 0; } biClrImportant = 0; /* Write the BMP info values */ SDL_WriteLE32(dst, biSize); SDL_WriteLE32(dst, biWidth); SDL_WriteLE32(dst, biHeight); SDL_WriteLE16(dst, biPlanes); SDL_WriteLE16(dst, biBitCount); SDL_WriteLE32(dst, biCompression); SDL_WriteLE32(dst, biSizeImage); SDL_WriteLE32(dst, biXPelsPerMeter); SDL_WriteLE32(dst, biYPelsPerMeter); SDL_WriteLE32(dst, biClrUsed); SDL_WriteLE32(dst, biClrImportant); /* Write the palette (in BGR color order) */ if (surface->format->palette) { SDL_Color *colors; int ncolors; colors = surface->format->palette->colors; ncolors = surface->format->palette->ncolors; for (i = 0; i < ncolors; ++i) { SDL_RWwrite(dst, &colors[i].b, 1, 1); SDL_RWwrite(dst, &colors[i].g, 1, 1); SDL_RWwrite(dst, &colors[i].r, 1, 1); SDL_RWwrite(dst, &colors[i].unused, 1, 1); } } /* Write the bitmap offset */ bfOffBits = SDL_RWtell(dst) - fp_offset; if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } SDL_WriteLE32(dst, bfOffBits); if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } /* Write the bitmap image upside down */ bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch); pad = ((bw % 4) ? (4 - (bw % 4)) : 0); while (bits > (Uint8 *) surface->pixels) { bits -= surface->pitch; if (SDL_RWwrite(dst, bits, 1, bw) != bw) { SDL_Error(SDL_EFWRITE); break; } if (pad) { const Uint8 padbyte = 0; for (i = 0; i < pad; ++i) { SDL_RWwrite(dst, &padbyte, 1, 1); } } } /* Write the BMP file size */ bfSize = SDL_RWtell(dst) - fp_offset; if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } SDL_WriteLE32(dst, bfSize); if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } /* Close it up.. */ SDL_UnlockSurface(surface); if (surface != saveme) { SDL_FreeSurface(surface); } } if (freedst && dst) { SDL_RWclose(dst); } return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1); }
void WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon) { HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; HICON hicon = NULL; if (icon) { BYTE *icon_bmp; int icon_len; SDL_RWops *dst; SDL_PixelFormat format; SDL_Surface *surface; /* Create temporary bitmap buffer */ icon_len = 40 + icon->h * icon->w * 4; icon_bmp = SDL_stack_alloc(BYTE, icon_len); dst = SDL_RWFromMem(icon_bmp, icon_len); if (!dst) { SDL_stack_free(icon_bmp); return; } /* Write the BITMAPINFO header */ SDL_WriteLE32(dst, 40); SDL_WriteLE32(dst, icon->w); SDL_WriteLE32(dst, icon->h * 2); SDL_WriteLE16(dst, 1); SDL_WriteLE16(dst, 32); SDL_WriteLE32(dst, BI_RGB); SDL_WriteLE32(dst, icon->h * icon->w * 4); SDL_WriteLE32(dst, 0); SDL_WriteLE32(dst, 0); SDL_WriteLE32(dst, 0); SDL_WriteLE32(dst, 0); /* Convert the icon to a 32-bit surface with alpha channel */ SDL_InitFormat(&format, SDL_PIXELFORMAT_ARGB8888); surface = SDL_ConvertSurface(icon, &format, 0); if (surface) { /* Write the pixels upside down into the bitmap buffer */ int y = surface->h; while (y--) { Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch; SDL_RWwrite(dst, src, surface->pitch, 1); } SDL_FreeSurface(surface); /* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */ #ifndef _WIN32_WCE hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000); #endif } SDL_RWclose(dst); SDL_stack_free(icon_bmp); } /* Set the icon for the window */ SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon); /* Set the icon in the task manager (should we do this?) */ SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon); }
int SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst) { Sint64 fp_offset; int i, pad; SDL_Surface *surface; Uint8 *bits; SDL_bool save32bit = SDL_FALSE; SDL_bool saveLegacyBMP = SDL_FALSE; /* The Win32 BMP file header (14 bytes) */ char magic[2] = { 'B', 'M' }; Uint32 bfSize; Uint16 bfReserved1; Uint16 bfReserved2; Uint32 bfOffBits; /* The Win32 BITMAPINFOHEADER struct (40 bytes) */ Uint32 biSize; Sint32 biWidth; Sint32 biHeight; Uint16 biPlanes; Uint16 biBitCount; Uint32 biCompression; Uint32 biSizeImage; Sint32 biXPelsPerMeter; Sint32 biYPelsPerMeter; Uint32 biClrUsed; Uint32 biClrImportant; /* The additional header members from the Win32 BITMAPV4HEADER struct (108 bytes in total) */ Uint32 bV4RedMask = 0; Uint32 bV4GreenMask = 0; Uint32 bV4BlueMask = 0; Uint32 bV4AlphaMask = 0; Uint32 bV4CSType = 0; Sint32 bV4Endpoints[3 * 3] = {0}; Uint32 bV4GammaRed = 0; Uint32 bV4GammaGreen = 0; Uint32 bV4GammaBlue = 0; /* Make sure we have somewhere to save */ surface = NULL; if (dst) { #ifdef SAVE_32BIT_BMP /* We can save alpha information in a 32-bit BMP */ if (saveme->format->BitsPerPixel >= 8 && (saveme->format->Amask || saveme->map->info.flags & SDL_COPY_COLORKEY)) { save32bit = SDL_TRUE; } #endif /* SAVE_32BIT_BMP */ if (saveme->format->palette && !save32bit) { if (saveme->format->BitsPerPixel == 8) { surface = saveme; } else { SDL_SetError("%d bpp BMP files not supported", saveme->format->BitsPerPixel); } } else if ((saveme->format->BitsPerPixel == 24) && !save32bit && #if SDL_BYTEORDER == SDL_LIL_ENDIAN (saveme->format->Rmask == 0x00FF0000) && (saveme->format->Gmask == 0x0000FF00) && (saveme->format->Bmask == 0x000000FF) #else (saveme->format->Rmask == 0x000000FF) && (saveme->format->Gmask == 0x0000FF00) && (saveme->format->Bmask == 0x00FF0000) #endif ) { surface = saveme; } else { SDL_PixelFormat format; /* If the surface has a colorkey or alpha channel we'll save a 32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */ if (save32bit) { SDL_InitFormat(&format, SDL_PIXELFORMAT_BGRA32); } else { SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24); } surface = SDL_ConvertSurface(saveme, &format, 0); if (!surface) { SDL_SetError("Couldn't convert image to %d bpp", format.BitsPerPixel); } } } else { /* Set no error here because it may overwrite a more useful message from SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */ return -1; } if (save32bit) { saveLegacyBMP = SDL_GetHintBoolean(SDL_HINT_BMP_SAVE_LEGACY_FORMAT, SDL_FALSE); } if (surface && (SDL_LockSurface(surface) == 0)) { const int bw = surface->w * surface->format->BytesPerPixel; /* Set the BMP file header values */ bfSize = 0; /* We'll write this when we're done */ bfReserved1 = 0; bfReserved2 = 0; bfOffBits = 0; /* We'll write this when we're done */ /* Write the BMP file header values */ fp_offset = SDL_RWtell(dst); SDL_ClearError(); SDL_RWwrite(dst, magic, 2, 1); SDL_WriteLE32(dst, bfSize); SDL_WriteLE16(dst, bfReserved1); SDL_WriteLE16(dst, bfReserved2); SDL_WriteLE32(dst, bfOffBits); /* Set the BMP info values */ biSize = 40; biWidth = surface->w; biHeight = surface->h; biPlanes = 1; biBitCount = surface->format->BitsPerPixel; biCompression = BI_RGB; biSizeImage = surface->h * surface->pitch; biXPelsPerMeter = 0; biYPelsPerMeter = 0; if (surface->format->palette) { biClrUsed = surface->format->palette->ncolors; } else { biClrUsed = 0; } biClrImportant = 0; /* Set the BMP info values for the version 4 header */ if (save32bit && !saveLegacyBMP) { biSize = 108; biCompression = BI_BITFIELDS; /* The BMP format is always little endian, these masks stay the same */ bV4RedMask = 0x00ff0000; bV4GreenMask = 0x0000ff00; bV4BlueMask = 0x000000ff; bV4AlphaMask = 0xff000000; bV4CSType = LCS_WINDOWS_COLOR_SPACE; bV4GammaRed = 0; bV4GammaGreen = 0; bV4GammaBlue = 0; } /* Write the BMP info values */ SDL_WriteLE32(dst, biSize); SDL_WriteLE32(dst, biWidth); SDL_WriteLE32(dst, biHeight); SDL_WriteLE16(dst, biPlanes); SDL_WriteLE16(dst, biBitCount); SDL_WriteLE32(dst, biCompression); SDL_WriteLE32(dst, biSizeImage); SDL_WriteLE32(dst, biXPelsPerMeter); SDL_WriteLE32(dst, biYPelsPerMeter); SDL_WriteLE32(dst, biClrUsed); SDL_WriteLE32(dst, biClrImportant); /* Write the BMP info values for the version 4 header */ if (save32bit && !saveLegacyBMP) { SDL_WriteLE32(dst, bV4RedMask); SDL_WriteLE32(dst, bV4GreenMask); SDL_WriteLE32(dst, bV4BlueMask); SDL_WriteLE32(dst, bV4AlphaMask); SDL_WriteLE32(dst, bV4CSType); for (i = 0; i < 3 * 3; i++) { SDL_WriteLE32(dst, bV4Endpoints[i]); } SDL_WriteLE32(dst, bV4GammaRed); SDL_WriteLE32(dst, bV4GammaGreen); SDL_WriteLE32(dst, bV4GammaBlue); } /* Write the palette (in BGR color order) */ if (surface->format->palette) { SDL_Color *colors; int ncolors; colors = surface->format->palette->colors; ncolors = surface->format->palette->ncolors; for (i = 0; i < ncolors; ++i) { SDL_RWwrite(dst, &colors[i].b, 1, 1); SDL_RWwrite(dst, &colors[i].g, 1, 1); SDL_RWwrite(dst, &colors[i].r, 1, 1); SDL_RWwrite(dst, &colors[i].a, 1, 1); } } /* Write the bitmap offset */ bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset); if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } SDL_WriteLE32(dst, bfOffBits); if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } /* Write the bitmap image upside down */ bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch); pad = ((bw % 4) ? (4 - (bw % 4)) : 0); while (bits > (Uint8 *) surface->pixels) { bits -= surface->pitch; if (SDL_RWwrite(dst, bits, 1, bw) != bw) { SDL_Error(SDL_EFWRITE); break; } if (pad) { const Uint8 padbyte = 0; for (i = 0; i < pad; ++i) { SDL_RWwrite(dst, &padbyte, 1, 1); } } } /* Write the BMP file size */ bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset); if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } SDL_WriteLE32(dst, bfSize); if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) { SDL_Error(SDL_EFSEEK); } /* Close it up.. */ SDL_UnlockSurface(surface); if (surface != saveme) { SDL_FreeSurface(surface); } } if (freedst && dst) { SDL_RWclose(dst); } return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1); }
SDL_Renderer * X11_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = window->display; SDL_DisplayData *displaydata = (SDL_DisplayData *) display->driverdata; SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata; SDL_Renderer *renderer; SDL_RendererInfo *info; X11_RenderData *data; XGCValues gcv; int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { SDL_OutOfMemory(); return NULL; } data = (X11_RenderData *) SDL_calloc(1, sizeof(*data)); if (!data) { X11_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } data->display = windowdata->videodata->display; data->screen = displaydata->screen; data->visual = displaydata->visual; data->depth = displaydata->depth; data->scanline_pad = displaydata->scanline_pad; data->xwindow = windowdata->xwindow; renderer->DisplayModeChanged = X11_DisplayModeChanged; renderer->CreateTexture = X11_CreateTexture; renderer->QueryTexturePixels = X11_QueryTexturePixels; renderer->SetTextureBlendMode = X11_SetTextureBlendMode; renderer->SetTextureScaleMode = X11_SetTextureScaleMode; renderer->UpdateTexture = X11_UpdateTexture; renderer->LockTexture = X11_LockTexture; renderer->UnlockTexture = X11_UnlockTexture; renderer->SetDrawBlendMode = X11_SetDrawBlendMode; renderer->RenderDrawPoints = X11_RenderDrawPoints; renderer->RenderDrawLines = X11_RenderDrawLines; renderer->RenderDrawRects = X11_RenderDrawRects; renderer->RenderFillRects = X11_RenderFillRects; renderer->RenderCopy = X11_RenderCopy; renderer->RenderReadPixels = X11_RenderReadPixels; renderer->RenderWritePixels = X11_RenderWritePixels; renderer->RenderPresent = X11_RenderPresent; renderer->DestroyTexture = X11_DestroyTexture; renderer->DestroyRenderer = X11_DestroyRenderer; renderer->info = X11_RenderDriver.info; renderer->window = window; renderer->driverdata = data; renderer->info.flags = SDL_RENDERER_ACCELERATED; if (flags & SDL_RENDERER_SINGLEBUFFER) { renderer->info.flags |= (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY); n = 0; } else if (flags & SDL_RENDERER_PRESENTFLIP2) { renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2; n = 2; } else if (flags & SDL_RENDERER_PRESENTFLIP3) { renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3; n = 3; } else { renderer->info.flags |= SDL_RENDERER_PRESENTCOPY; n = 1; } for (i = 0; i < n; ++i) { data->pixmaps[i] = XCreatePixmap(data->display, data->xwindow, window->w, window->h, displaydata->depth); if (data->pixmaps[i] == None) { X11_DestroyRenderer(renderer); SDL_SetError("XCreatePixmap() failed"); return NULL; } } if (n > 0) { data->drawable = data->pixmaps[0]; data->makedirty = SDL_TRUE; } else { data->drawable = data->xwindow; data->makedirty = SDL_FALSE; } data->current_pixmap = 0; /* Get the format of the window */ if (!SDL_PixelFormatEnumToMasks (display->current_mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { SDL_SetError("Unknown display format"); X11_DestroyRenderer(renderer); return NULL; } SDL_InitFormat(&data->format, bpp, Rmask, Gmask, Bmask, Amask); /* Create the drawing context */ gcv.graphics_exposures = False; data->gc = XCreateGC(data->display, data->xwindow, GCGraphicsExposures, &gcv); if (!data->gc) { X11_DestroyRenderer(renderer); SDL_SetError("XCreateGC() failed"); return NULL; } return renderer; }