23 #if SDL_VIDEO_DRIVER_DIRECTFB
30 #include "../SDL_sysvideo.h"
31 #include "../../render/SDL_sysrender.h"
33 #ifndef DFB_VERSION_ATLEAST
35 #define DFB_VERSIONNUM(X, Y, Z) \
36 ((X)*1000 + (Y)*100 + (Z))
38 #define DFB_COMPILEDVERSION \
39 DFB_VERSIONNUM(DIRECTFB_MAJOR_VERSION, DIRECTFB_MINOR_VERSION, DIRECTFB_MICRO_VERSION)
41 #define DFB_VERSION_ATLEAST(X, Y, Z) \
42 (DFB_COMPILEDVERSION >= DFB_VERSIONNUM(X, Y, Z))
44 #define SDL_DFB_CHECK(x) x
49 #define USE_DISPLAY_PALETTE (0)
52 #define SDL_DFB_RENDERERDATA(rend) DirectFB_RenderData *renddata = ((rend) ? (DirectFB_RenderData *) (rend)->driverdata : NULL)
59 static void DirectFB_ActivateRenderer(
SDL_Renderer * renderer);
60 static int DirectFB_CreateTexture(
SDL_Renderer * renderer,
62 static int DirectFB_QueryTexturePixels(
SDL_Renderer * renderer,
64 void **
pixels,
int *pitch);
65 static int DirectFB_SetTexturePalette(
SDL_Renderer * renderer,
68 int firstcolor,
int ncolors);
69 static int DirectFB_GetTexturePalette(
SDL_Renderer * renderer,
72 int firstcolor,
int ncolors);
73 static int DirectFB_SetTextureAlphaMod(
SDL_Renderer * renderer,
75 static int DirectFB_SetTextureColorMod(
SDL_Renderer * renderer,
77 static int DirectFB_SetTextureBlendMode(
SDL_Renderer * renderer,
79 static int DirectFB_SetTextureScaleMode(
SDL_Renderer * renderer,
81 static int DirectFB_UpdateTexture(
SDL_Renderer * renderer,
84 const void *
pixels,
int pitch);
88 void **
pixels,
int *pitch);
89 static void DirectFB_UnlockTexture(
SDL_Renderer * renderer,
91 static void DirectFB_DirtyTexture(
SDL_Renderer * renderer,
94 static int DirectFB_SetDrawBlendMode(
SDL_Renderer * renderer);
95 static int DirectFB_RenderDrawPoints(
SDL_Renderer * renderer,
97 static int DirectFB_RenderDrawLines(
SDL_Renderer * renderer,
99 static int DirectFB_RenderDrawRects(
SDL_Renderer * renderer,
101 static int DirectFB_RenderFillRects(
SDL_Renderer * renderer,
107 static void DirectFB_RenderPresent(
SDL_Renderer * renderer);
108 static void DirectFB_DestroyTexture(
SDL_Renderer * renderer,
110 static void DirectFB_DestroyRenderer(
SDL_Renderer * renderer);
115 static int DirectFB_UpdateViewport(
SDL_Renderer * renderer);
116 static int DirectFB_UpdateClipRect(
SDL_Renderer * renderer);
122 #define SDL_DFB_WINDOWSURFACE(win) IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface;
125 DirectFB_CreateRenderer,
146 DFBSurfaceFlipFlags flipflags;
149 DFBSurfaceBlittingFlags blitFlags;
150 DFBSurfaceDrawingFlags drawFlags;
152 } DirectFB_RenderData;
160 IDirectFBPalette *palette;
165 #if (DFB_VERSION_ATLEAST(1,2,0))
166 DFBSurfaceRenderOptions render_options;
168 } DirectFB_TextureData;
171 SDLtoDFBRect(
const SDL_Rect * sr, DFBRectangle * dr)
179 SDLtoDFBRect_Float(
const SDL_FRect * sr, DFBRectangle * dr)
189 TextureHasAlpha(DirectFB_TextureData *
data)
197 switch (data->format) {
214 static inline IDirectFBSurface *get_dfb_surface(
SDL_Window *window)
222 return wm_info.
info.dfb.surface;
225 static inline IDirectFBWindow *get_dfb_window(
SDL_Window *window)
233 return wm_info.
info.dfb.window;
237 SetBlendMode(DirectFB_RenderData * data,
int blendMode,
238 DirectFB_TextureData *
source)
240 IDirectFBSurface *destsurf = data->target;
243 if (1 || data->lastBlendMode != blendMode) {
247 data->blitFlags = DSBLIT_NOFX;
248 data->drawFlags = DSDRAW_NOFX;
249 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
250 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO));
253 case SDL_BLENDMODE_MASK:
254 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
255 data->drawFlags = DSDRAW_BLEND;
256 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
257 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
261 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
262 data->drawFlags = DSDRAW_BLEND;
263 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
264 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
267 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
268 data->drawFlags = DSDRAW_BLEND;
272 if (source && TextureHasAlpha(source))
273 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
275 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
276 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE));
279 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
280 data->drawFlags = DSDRAW_BLEND;
281 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ZERO));
282 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_SRCCOLOR));
286 data->lastBlendMode = blendMode;
291 DisplayPaletteChanged(
void *userdata,
SDL_Palette * palette)
293 #if USE_DISPLAY_PALETTE
294 DirectFB_RenderData *data = (DirectFB_RenderData *) userdata;
295 SDL_DFB_WINDOWSURFACE(data->window);
296 IDirectFBPalette *surfpal;
307 for (i = 0; i < ncolors; ++
i) {
325 SDL_DFB_RENDERERDATA(renderer);
338 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
339 IDirectFBSurface *destsurf = data->target;
341 DirectFB_ActivateRenderer(renderer);
343 PrepareDraw(renderer);
345 destsurf->Clear(destsurf, renderer->
r, renderer->
g, renderer->
b, renderer->
a);
354 IDirectFBSurface *winsurf = get_dfb_surface(window);
357 DirectFB_RenderData *data =
NULL;
358 DFBSurfaceCapabilities scaps;
391 renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
392 renderer->SetTexturePalette = DirectFB_SetTexturePalette;
393 renderer->GetTexturePalette = DirectFB_GetTexturePalette;
394 renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode;
395 renderer->DirtyTexture = DirectFB_DirtyTexture;
396 renderer->SetDrawBlendMode = DirectFB_SetDrawBlendMode;
397 renderer->RenderDrawRects = DirectFB_RenderDrawRects;
400 renderer->
info = DirectFB_RenderDriver.
info;
401 renderer->
window = window;
407 data->window = window;
408 data->target = winsurf;
410 data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
413 data->flipflags |= DSFLIP_WAITFORSYNC | DSFLIP_ONSYNC;
416 data->flipflags |= DSFLIP_ONSYNC;
421 if (scaps & DSCAPS_DOUBLE)
422 renderer->
info.
flags |= SDL_RENDERER_PRESENTFLIP2;
423 else if (scaps & DSCAPS_TRIPLE)
424 renderer->
info.
flags |= SDL_RENDERER_PRESENTFLIP3;
426 renderer->
info.
flags |= SDL_RENDERER_SINGLEBUFFER;
433 if (display-> palette) {
434 SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
449 SDL_DFB_RENDERERDATA(renderer);
453 if (renddata->size_changed ) {
466 DirectFB_TextureData *data = texture->
driverdata;
467 DFBDisplayLayerConfig layconf;
470 if (devdata->use_yuv_direct && (dispdata->
vidID >= 0)
474 DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
476 layconf.width = texture->
w;
477 layconf.height = texture->
h;
479 layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
485 vidlayer->SetCooperativeLevel(dispdata->
vidlayer,
488 if (devdata->use_yuv_underlays) {
494 vidlayer->SetConfiguration(dispdata->
vidlayer,
497 vidlayer->GetSurface(dispdata->
vidlayer,
508 vidlayer->SetCooperativeLevel(dispdata->
vidlayer,
509 DLSCL_ADMINISTRATIVE));
521 DirectFB_TextureData *
data;
522 DFBSurfaceDescription dsc;
523 DFBSurfacePixelFormat pixelformat;
525 DirectFB_ActivateRenderer(renderer);
532 if (pixelformat == DSPF_UNKNOWN) {
533 SDL_SetError(
"Unknown pixel format %d\n", data->format);
537 data->format = texture->
format;
538 data->pitch = texture->
w * DFB_BYTES_PER_PIXEL(pixelformat);
540 if (DirectFB_AcquireVidLayer(renderer, texture) != 0) {
543 DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
544 dsc.width = texture->
w;
545 dsc.height = texture->
h;
549 dsc.width += (dsc.width % 2);
550 dsc.height += (dsc.height % 2);
557 dsc.caps = DSCAPS_PREMULTIPLIED;
560 dsc.caps |= DSCAPS_SYSTEMONLY;
562 dsc.caps |= DSCAPS_VIDEOONLY;
565 dsc.pixelformat = pixelformat;
579 DFBPaletteDescription pal_desc;
580 pal_desc.flags = DPDESC_SIZE;
582 SDL_DFB_CHECKERR(devdata->dfb->CreatePalette(devdata->dfb, &pal_desc,&data->palette));
588 #if (DFB_VERSION_ATLEAST(1,2,0))
589 data->render_options = DSRO_NONE;
595 SDL_DFB_ALLOC_CLEAR(data->pixels, (texture->
h * data->pitch + ((texture->
h + texture->
h % 2) * (data->pitch + data->pitch % 2) * 2) / 4));
614 DirectFB_TextureData *texturedata =
617 if (texturedata->display) {
620 *pixels = texturedata->pixels;
621 *pitch = texturedata->pitch;
632 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
635 DFBColor entries[256];
641 for (i = 0; i < ncolors; ++
i) {
642 entries[
i].r = colors[
i].
r;
643 entries[
i].g = colors[
i].
g;
644 entries[
i].b = colors[
i].
b;
648 palette->SetEntries(data->palette, entries, ncolors, firstcolor));
651 return SDL_SetError(
"YUV textures don't have a palette");
660 int firstcolor,
int ncolors)
662 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
666 DFBColor entries[256];
670 palette->GetEntries(data->palette, entries, ncolors,
673 for (i = 0; i < ncolors; ++
i) {
674 colors[
i].
r = entries[
i].r;
675 colors[
i].
g = entries[
i].g;
676 colors[
i].
b = entries[
i].b;
681 return SDL_SetError(
"YUV textures don't have a palette");
735 #if (DFB_VERSION_ATLEAST(1,2,0))
737 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
739 switch (texture->scaleMode) {
740 case SDL_SCALEMODE_NONE:
741 case SDL_SCALEMODE_FAST:
742 data->render_options = DSRO_NONE;
744 case SDL_SCALEMODE_SLOW:
745 data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;
747 case SDL_SCALEMODE_BEST:
748 data->render_options =
749 DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;
752 data->render_options = DSRO_NONE;
753 texture->scaleMode = SDL_SCALEMODE_NONE;
763 const SDL_Rect * rect,
const void *pixels,
int pitch)
765 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
774 DirectFB_ActivateRenderer(renderer);
782 DSLF_WRITE | DSLF_READ,
783 ((
void **) &dpixels), &dpitch));
784 src = (
Uint8 *) pixels;
785 dst = (
Uint8 *) dpixels + rect->
y * dpitch + rect->
x * bpp;
795 src = (
Uint8 *) pixels + texture->
h * pitch;
796 dst = (
Uint8 *) dpixels + texture->
h * dpitch + rect->
y * dpitch / 4 + rect->
x * bpp / 2;
797 for (
row = 0;
row < rect->
h / 2 + (rect->
h & 1); ++
row) {
802 src = (
Uint8 *) pixels + texture->
h * pitch + texture->
h * pitch / 4;
803 dst = (
Uint8 *) dpixels + texture->
h * dpitch + texture->
h * dpitch / 4 + rect->
y * dpitch / 4 + rect->
x * bpp / 2;
804 for (
row = 0;
row < rect->
h / 2 + (rect->
h & 1); ++
row) {
820 const SDL_Rect * rect,
void **pixels,
int *pitch)
822 DirectFB_TextureData *texturedata =
825 DirectFB_ActivateRenderer(renderer);
829 SDL_AddDirtyRect(&texturedata->dirty, rect);
833 if (texturedata->display) {
838 DSLF_WRITE | DSLF_READ,
844 (
void *) ((
Uint8 *) texturedata->pixels +
845 rect->
y * texturedata->pitch +
847 *pitch = texturedata->pitch;
848 texturedata->isDirty = 1;
859 DirectFB_TextureData *texturedata =
862 DirectFB_ActivateRenderer(renderer);
864 if (texturedata->display) {
865 SDL_DFB_CHECK(texturedata->surface->Unlock(texturedata->surface));
866 texturedata->pixels =
NULL;
873 int numrects,
const SDL_Rect * rects)
875 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
878 for (i = 0; i < numrects; ++
i) {
879 SDL_AddDirtyRect(&data->dirty, &rects[i]);
886 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
887 DirectFB_TextureData *tex_data =
NULL;
889 DirectFB_ActivateRenderer(renderer);
891 tex_data = (DirectFB_TextureData *) texture->
driverdata;
892 data->target = tex_data->surface;
894 data->target = get_dfb_surface(data->window);
896 data->lastBlendMode = 0;
904 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
905 IDirectFBSurface *destsurf = data->target;
924 r = ((
int) r * (
int)
a) / 255;
925 g = ((
int)
g * (
int)
a) / 255;
926 b = ((
int)
b * (
int)
a) / 255;
937 static int DirectFB_RenderDrawPoints(
SDL_Renderer * renderer,
940 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
941 IDirectFBSurface *destsurf = data->target;
942 DFBRegion clip_region;
945 DirectFB_ActivateRenderer(renderer);
947 PrepareDraw(renderer);
948 destsurf->GetClip(destsurf, &clip_region);
949 for (i=0; i <
count; i++) {
950 int x = points[
i].
x + clip_region.x1;
951 int y = points[
i].
y + clip_region.y1;
959 static int DirectFB_RenderDrawLines(
SDL_Renderer * renderer,
962 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
963 IDirectFBSurface *destsurf = data->target;
964 DFBRegion clip_region;
967 DirectFB_ActivateRenderer(renderer);
969 PrepareDraw(renderer);
971 #if (DFB_VERSION_ATLEAST(1,2,0))
975 destsurf->GetClip(destsurf, &clip_region);
976 for (i=0; i < count - 1; i++) {
977 int x1 = points[
i].
x + clip_region.x1;
978 int y1 = points[
i].
y + clip_region.y1;
979 int x2 = points[i + 1].
x + clip_region.x1;
980 int y2 = points[i + 1].
y + clip_region.y1;
992 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
993 IDirectFBSurface *destsurf = data->target;
994 DFBRegion clip_region;
997 DirectFB_ActivateRenderer(renderer);
999 PrepareDraw(renderer);
1001 destsurf->GetClip(destsurf, &clip_region);
1002 for (i=0; i<
count; i++) {
1004 dst.
x += clip_region.x1;
1005 dst.
y += clip_region.y1;
1018 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1019 IDirectFBSurface *destsurf = data->target;
1020 DFBRegion clip_region;
1023 DirectFB_ActivateRenderer(renderer);
1025 PrepareDraw(renderer);
1027 destsurf->GetClip(destsurf, &clip_region);
1028 for (i=0; i<
count; i++) {
1030 dst.
x += clip_region.x1;
1031 dst.
y += clip_region.y1;
1045 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1046 IDirectFBSurface *destsurf = data->target;
1047 DirectFB_TextureData *texturedata =
1048 (DirectFB_TextureData *) texture->
driverdata;
1050 DFBRegion clip_region;
1051 DFBRectangle sr, dr;
1053 DirectFB_ActivateRenderer(renderer);
1055 SDLtoDFBRect(srcrect, &sr);
1056 SDLtoDFBRect_Float(dstrect, &dr);
1058 destsurf->GetClip(destsurf, &clip_region);
1059 dr.x += clip_region.x1;
1060 dr.y += clip_region.y1;
1062 if (texturedata->display) {
1065 IDirectFBWindow *dfbwin = get_dfb_window(window);
1071 vidlayer->SetSourceRectangle(dispdata->
vidlayer,
1072 sr.x, sr.y, sr.w, sr.h));
1073 dfbwin->GetPosition(dfbwin, &px, &py);
1074 px += windata->client.x;
1075 py += windata->client.y;
1077 vidlayer->SetScreenRectangle(dispdata->
vidlayer,
1083 DFBSurfaceBlittingFlags flags = 0;
1086 if (texturedata->dirty.list) {
1087 SDL_DirtyRect *dirty;
1090 int pitch = texturedata->pitch;
1092 for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) {
1095 (
void *) ((
Uint8 *) texturedata->pixels +
1096 rect->
y * pitch + rect->
x * bpp);
1097 DirectFB_UpdateTexture(renderer, texture, rect,
1099 texturedata->pitch);
1101 SDL_ClearDirtyRects(&texturedata->dirty);
1104 if (texturedata->isDirty)
1110 rect.
w = texture->
w;
1111 rect.
h = texture->
h;
1113 DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch);
1116 alpha = r = g = b = 0xff;
1119 flags |= DSBLIT_BLEND_COLORALPHA;
1126 flags |= DSBLIT_COLORIZE;
1129 SetColor(destsurf, r, g, b, alpha));
1133 SetBlendMode(data, texture->
blendMode, texturedata);
1136 data->blitFlags | flags));
1138 #if (DFB_VERSION_ATLEAST(1,2,0))
1144 if (srcrect->
w == dstrect->
w && srcrect->
h == dstrect->
h) {
1146 texturedata->surface,
1150 texturedata->surface,
1162 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1167 DirectFB_ActivateRenderer(renderer);
1169 if (shape_data && shape_data->
surface) {
1171 SDL_DFB_CHECK(windata->window_surface->SetSrcBlendFunction(windata->window_surface, DSBF_ONE));
1172 SDL_DFB_CHECK(windata->window_surface->SetDstBlendFunction(windata->window_surface, DSBF_ONE));
1173 SDL_DFB_CHECK(windata->window_surface->SetDrawingFlags(windata->window_surface, DSDRAW_BLEND));
1174 SDL_DFB_CHECK(windata->window_surface->SetColor(windata->window_surface, 0, 0, 0, 0xff));
1175 SDL_DFB_CHECK(windata->window_surface->FillRectangle(windata->window_surface, 0,0, windata->size.w, windata->size.h));
1178 SDL_DFB_CHECK(windata->surface->SetSrcBlendFunction(windata->surface, DSBF_DESTCOLOR));
1179 SDL_DFB_CHECK(windata->surface->SetDstBlendFunction(windata->surface, DSBF_ZERO));
1180 SDL_DFB_CHECK(windata->surface->SetBlittingFlags(windata->surface, DSBLIT_BLEND_ALPHACHANNEL));
1181 #if (DFB_VERSION_ATLEAST(1,2,0))
1182 SDL_DFB_CHECK(windata->surface->SetRenderOptions(windata->surface, DSRO_NONE));
1195 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
1197 DirectFB_ActivateRenderer(renderer);
1204 if (data->display) {
1210 DLSCL_ADMINISTRATIVE));
1221 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1224 if (display->palette) {
1225 SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged, data);
1236 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1237 IDirectFBSurface *winsurf = data->target;
1242 dreg.x2 = dreg.x1 + renderer->
viewport.
w - 1;
1243 dreg.y2 = dreg.y1 + renderer->
viewport.
h - 1;
1245 winsurf->SetClip(winsurf, &dreg);
1253 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1254 IDirectFBSurface *destsurf = get_dfb_surface(data->window);
1258 region.x1 = rect->
x;
1259 region.x2 = rect->
x + rect->
w;
1260 region.y1 = rect->
y;
1261 region.y2 = rect->
y + rect->
h;
1278 DFBSurfacePixelFormat dfb_format;
1279 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1280 IDirectFBSurface *winsurf = data->target;
1282 DirectFB_ActivateRenderer(renderer);
1284 winsurf->GetPixelFormat(winsurf, &dfb_format);
1286 winsurf->Lock(winsurf, DSLF_READ, (
void **) &laypixels, &laypitch);
1290 sdl_format, laypixels, laypitch,
1291 format, pixels, pitch);
1293 winsurf->Unlock(winsurf);
1301 Uint32 format,
const void * pixels,
int pitch)
1308 DFBSurfacePixelFormat dfb_format;
1310 SDL_DFB_CHECK(windata->surface->GetPixelFormat(windata->surface, &dfb_format));
1313 SDL_DFB_CHECK(windata->surface->Lock(windata->surface, DSLF_WRITE, (
void **) &laypixels, &laypitch));
1317 format, pixels, pitch,
1318 sdl_format, laypixels, laypitch);
int(* UpdateClipRect)(SDL_Renderer *renderer)
DECLSPEC SDL_bool SDLCALL SDL_GetWindowWMInfo(SDL_Window *window, SDL_SysWMinfo *info)
This function allows access to driver-dependent window information.
void DirectFB_SetSupportedPixelFormats(SDL_RendererInfo *ri)
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Copy a block of pixels of one format to another format.
int(* RenderClear)(SDL_Renderer *renderer)
#define SDL_ISPIXELFORMAT_INDEXED(format)
int(* RenderDrawPoints)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
DFBSurfacePixelFormat DirectFB_SDLToDFBPixelFormat(Uint32 format)
DECLSPEC void SDLCALL SDL_free(void *mem)
GLboolean GLboolean GLboolean GLboolean a
#define SDL_BYTESPERPIXEL(X)
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
IDirectFBSurface * surface
Uint32 DirectFB_DFBToSDLPixelFormat(DFBSurfacePixelFormat pixelformat)
GLuint GLfloat GLfloat GLfloat GLfloat y1
GLfixed GLfixed GLfixed y2
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
#define SDL_DFB_RELEASE(x)
#define SDL_VERSION(x)
Macro to determine SDL version program was compiled against.
EGLContext EGLenum target
uint32_t Uint32
An unsigned 32-bit integer type.
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
GLenum GLenum GLvoid * row
#define SDL_DFB_DEVICEDATA(dev)
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
SDL_WindowShaper * shaper
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
DECLSPEC void *SDLCALL SDL_memset(void *dst, int c, size_t len)
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum format
DECLSPEC int SDLCALL SDL_SetError(const char *fmt,...)
int(* SetTextureColorMod)(SDL_Renderer *renderer, SDL_Texture *texture)
GLclampf GLclampf GLclampf alpha
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* RenderCopy)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
union SDL_SysWMinfo::@78 info
Window state change event data (event.window.*)
GLuint GLfloat GLfloat GLfloat x1
int(* SetTextureBlendMode)(SDL_Renderer *renderer, SDL_Texture *texture)
EGLSurface EGLint EGLint y
#define SDL_DFB_ALLOC_CLEAR(r, s)
#define SDL_DFB_CHECKERR(x...)
GLenum GLenum GLuint texture
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
#define SDL_DFB_WINDOWDATA(win)
DECLSPEC void *SDLCALL SDL_memcpy(void *dst, const void *src, size_t len)
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
SDL_VideoDisplay * SDL_GetDisplayForWindow(SDL_Window *window)
#define SDL_DFB_CHECK(x...)
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
uint8_t Uint8
An unsigned 8-bit integer type.
#define SDL_DFB_DEBUG(x...)
GLdouble GLdouble GLdouble r
GLdouble GLdouble GLdouble b
IDirectFBDisplayLayer * vidlayer
int(* UpdateViewport)(SDL_Renderer *renderer)
GLuint GLdouble GLdouble GLint GLint const GLdouble * points
#define SDL_ISPIXELFORMAT_FOURCC(format)
void(* RenderPresent)(SDL_Renderer *renderer)
void(* DestroyRenderer)(SDL_Renderer *renderer)
GLsizei GLsizei GLchar * source
int(* SetTextureAlphaMod)(SDL_Renderer *renderer, SDL_Texture *texture)
#define SDL_Unsupported()
A rectangle, with the origin at the upper left.