static void SW_DestroyRenderer(SDL_Renderer * renderer) { SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); int i; if (data) { for (i = 0; i < SDL_arraysize(data->texture); ++i) { if (data->texture[i]) { DestroyTexture(data->renderer, data->texture[i]); } } if (data->surface.format) { SDL_SetSurfacePalette(&data->surface, NULL); SDL_FreeFormat(data->surface.format); } if (display->palette) { SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged, data); } if (data->renderer) { data->renderer->DestroyRenderer(data->renderer); } SDL_FreeDirtyRects(&data->dirty); SDL_free(data); } SDL_free(renderer); }
static int SDL_DUMMY_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_Rect * dstrect) { SDL_DUMMY_RenderData *data = (SDL_DUMMY_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_Surface *target = data->screens[data->current_screen]; void *pixels = (Uint8 *) target->pixels + dstrect->y * target->pitch + dstrect->x * target->format->BytesPerPixel; return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata, srcrect, display->current_mode.format, dstrect->w, dstrect->h, pixels, target->pitch); } else { SDL_Surface *surface = (SDL_Surface *) texture->driverdata; SDL_Surface *target = data->screens[data->current_screen]; SDL_Rect real_srcrect = *srcrect; SDL_Rect real_dstrect = *dstrect; return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect); } }
static int DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture) { SDL_DFB_RENDERERDATA(renderer); SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DFB_DEVICEDATA(display->device); DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; DirectFB_TextureData *data = texture->driverdata; DFBDisplayLayerConfig layconf; int ret; if (renddata->isyuvdirect && (dispdata->vidID >= 0) && (!dispdata->vidIDinuse) && SDL_ISPIXELFORMAT_FOURCC(data->format)) { layconf.flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_SURFACE_CAPS; layconf.width = texture->w; layconf.height = texture->h; layconf.pixelformat = SDLToDFBPixelFormat(data->format); layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE; SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb, dispdata->vidID, &dispdata->vidlayer)); SDL_DFB_CHECKERR(dispdata-> vidlayer->SetCooperativeLevel(dispdata->vidlayer, DLSCL_EXCLUSIVE)); if (devdata->use_yuv_underlays) { ret = dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1); if (ret != DFB_OK) SDL_DFB_DEBUG("Underlay Setlevel not supported\n"); } SDL_DFB_CHECKERR(dispdata-> vidlayer->SetConfiguration(dispdata->vidlayer, &layconf)); SDL_DFB_CHECKERR(dispdata-> vidlayer->GetSurface(dispdata->vidlayer, &data->surface)); dispdata->vidIDinuse = 1; data->display = display; return 0; } return 1; error: if (dispdata->vidlayer) { SDL_DFB_RELEASE(data->surface); SDL_DFB_CHECKERR(dispdata-> vidlayer->SetCooperativeLevel(dispdata->vidlayer, DLSCL_ADMINISTRATIVE)); SDL_DFB_RELEASE(dispdata->vidlayer); } return 1; }
static int gf_activaterenderer(SDL_Renderer* renderer) { SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata; SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(rdata->window); SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata; /* Setup current surface as visible */ // gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1); /* Set visible surface when hardware in idle state */ // gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE); return 0; }
static int D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); Uint32 display_format = display->current_mode.format; D3D_TextureData *data; HRESULT result; data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data)); if (!data) { SDL_OutOfMemory(); return -1; } texture->driverdata = data; if (SDL_ISPIXELFORMAT_FOURCC(texture->format) && (texture->format != SDL_PIXELFORMAT_YUY2 || !D3D_IsTextureFormatAvailable(renderdata->d3d, display_format, texture->format)) && (texture->format != SDL_PIXELFORMAT_YVYU || !D3D_IsTextureFormatAvailable(renderdata->d3d, display_format, texture->format))) { data->yuv = SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h); if (!data->yuv) { return -1; } data->format = display->current_mode.format; } else { data->format = texture->format; } result = IDirect3DDevice9_CreateTexture(renderdata->device, texture->w, texture->h, 1, 0, PixelFormatToD3DFMT(data->format), D3DPOOL_SDL, &data->texture, NULL); if (FAILED(result)) { D3D_SetError("CreateTexture()", result); return -1; } return 0; }
static int D3D_DisplayModeChanged(SDL_Renderer * renderer) { D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); data->pparams.BackBufferWidth = window->w; data->pparams.BackBufferHeight = window->h; if (window->flags & SDL_WINDOW_FULLSCREEN) { data->pparams.BackBufferFormat = PixelFormatToD3DFMT(display->fullscreen_mode.format); } else { data->pparams.BackBufferFormat = D3DFMT_UNKNOWN; } return D3D_Reset(renderer); }
void WIN_SetWindowPosition(_THIS, SDL_Window * window) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; RECT rect; SDL_Rect bounds; DWORD style; HWND top; BOOL menu; int x, y; /* Figure out what the window area will be */ if (window->flags & SDL_WINDOW_FULLSCREEN) { top = HWND_TOPMOST; } else { top = HWND_NOTOPMOST; } style = GetWindowLong(hwnd, GWL_STYLE); rect.left = 0; rect.top = 0; rect.right = window->w; rect.bottom = window->h; #ifdef _WIN32_WCE menu = FALSE; #else menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL); #endif AdjustWindowRectEx(&rect, style, menu, 0); WIN_GetDisplayBounds(_this, display, &bounds); if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->x == SDL_WINDOWPOS_CENTERED) { x = bounds.x + (bounds.w - window->w) / 2; } else { x = bounds.x + window->x + rect.left; } if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->y == SDL_WINDOWPOS_CENTERED) { y = bounds.y + (bounds.h - window->h) / 2; } else { y = bounds.y + window->y + rect.top; } SetWindowPos(hwnd, top, x, y, 0, 0, (SWP_NOCOPYBITS | SWP_NOSIZE)); }
static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture) { SDL_RenderData* renderdata=(SDL_RenderData*)renderer->driverdata; SDL_Window* window=SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay* display=SDL_GetDisplayFromWindow(window); SDL_TextureData* tdata=NULL; /* Allocate texture driver data */ tdata=(SDL_TextureData*)SDL_calloc(1, sizeof(SDL_TextureData)); if (tdata==NULL) { SDL_OutOfMemory(); return -1; } /* Set texture driver data */ texture->driverdata=tdata; }
SDL_Renderer * SW_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DisplayMode *displayMode = &display->current_mode; SDL_Renderer *renderer; SW_RenderData *data; int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; Uint32 renderer_flags; const char *desired_driver; if (!SDL_PixelFormatEnumToMasks (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { SDL_SetError("Unknown display format"); return NULL; } renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { SDL_OutOfMemory(); return NULL; } data = (SW_RenderData *) SDL_calloc(1, sizeof(*data)); if (!data) { SW_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } renderer->ActivateRenderer = SW_ActivateRenderer; renderer->DisplayModeChanged = SW_DisplayModeChanged; renderer->RenderPoint = SW_RenderPoint; renderer->RenderLine = SW_RenderLine; renderer->RenderFill = SW_RenderFill; renderer->RenderCopy = SW_RenderCopy; renderer->RenderPresent = SW_RenderPresent; renderer->DestroyRenderer = SW_DestroyRenderer; renderer->info.name = SW_RenderDriver.info.name; renderer->info.flags = 0; renderer->window = window->id; renderer->driverdata = data; Setup_SoftwareRenderer(renderer); 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; } data->format = displayMode->format; /* Find a render driver that we can use to display data */ renderer_flags = (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD); if (flags & SDL_RENDERER_PRESENTVSYNC) { renderer_flags |= SDL_RENDERER_PRESENTVSYNC; } desired_driver = SDL_getenv("SDL_VIDEO_RENDERER_SWDRIVER"); for (i = 0; i < display->num_render_drivers; ++i) { SDL_RenderDriver *driver = &display->render_drivers[i]; if (driver->info.name == SW_RenderDriver.info.name) { continue; } if (desired_driver && SDL_strcasecmp(desired_driver, driver->info.name) != 0) { continue; } data->renderer = driver->CreateRenderer(window, renderer_flags); if (data->renderer) { break; } } if (i == display->num_render_drivers) { SW_DestroyRenderer(renderer); SDL_SetError("Couldn't find display render driver"); return NULL; } if (data->renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) { renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; } /* Create the textures we'll use for display */ for (i = 0; i < n; ++i) { data->texture[i] = CreateTexture(data->renderer, data->format, window->w, window->h); if (!data->texture[i]) { SW_DestroyRenderer(renderer); return NULL; } } data->current_texture = 0; /* Create a surface we'll use for rendering */ data->surface.flags = SDL_PREALLOC; data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); if (!data->surface.format) { SW_DestroyRenderer(renderer); return NULL; } SDL_SetSurfacePalette(&data->surface, display->palette); /* Set up a palette watch on the display palette */ if (display->palette) { SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data); } return renderer; }
SDL_GLContext X11_GL_CreateContext(_THIS, SDL_Window * window) { SDL_WindowData *data = (SDL_WindowData *) window->driverdata; Display *display = data->videodata->display; int screen = ((SDL_DisplayData *) SDL_GetDisplayFromWindow(window)-> driverdata)->screen; XWindowAttributes xattr; XVisualInfo v, *vinfo; int n; GLXContext context = NULL; /* We do this to create a clean separation between X and GLX errors. */ XSync(display, False); XGetWindowAttributes(display, data->window, &xattr); v.screen = screen; v.visualid = XVisualIDFromVisual(xattr.visual); vinfo = XGetVisualInfo(display, VisualScreenMask | VisualIDMask, &v, &n); if (vinfo) { if (_this->gl_config.major_version < 3) { context = _this->gl_data->glXCreateContext(display, vinfo, NULL, True); } else { /* If we want a GL 3.0 context or later we need to get a temporary context to grab the new context creation function */ GLXContext temp_context = _this->gl_data->glXCreateContext(display, vinfo, NULL, True); if (!temp_context) { SDL_SetError("Could not create GL context"); return NULL; } else { int attribs[] = { GLX_CONTEXT_MAJOR_VERSION_ARB, _this->gl_config.major_version, GLX_CONTEXT_MINOR_VERSION_ARB, _this->gl_config.minor_version, 0 }; /* Get a pointer to the context creation function for GL 3.0 */ PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs = (PFNGLXCREATECONTEXTATTRIBSARBPROC) _this->gl_data-> glXGetProcAddress((GLubyte *) "glXCreateContextAttribsARB"); if (!glXCreateContextAttribs) { SDL_SetError("GL 3.x is not supported"); context = temp_context; } else { /* Create a GL 3.x context */ GLXFBConfig *framebuffer_config = NULL; int fbcount = 0; GLXFBConfig *(*glXChooseFBConfig) (Display * disp, int screen, const int *attrib_list, int *nelements); glXChooseFBConfig = (GLXFBConfig * (*)(Display *, int, const int *, int *)) _this->gl_data-> glXGetProcAddress((GLubyte *) "glXChooseFBConfig"); if (!glXChooseFBConfig || !(framebuffer_config = glXChooseFBConfig(display, DefaultScreen(display), NULL, &fbcount))) { SDL_SetError ("No good framebuffers found. GL 3.x disabled"); context = temp_context; } else { context = glXCreateContextAttribs(display, framebuffer_config[0], NULL, True, attribs); _this->gl_data->glXDestroyContext(display, temp_context); } } } } XFree(vinfo); } XSync(display, False); if (!context) { SDL_SetError("Could not create GL context"); return NULL; } if (X11_GL_MakeCurrent(_this, window, context) < 0) { X11_GL_DeleteContext(_this, context); return NULL; } return context; }
SDL_Renderer * SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DisplayMode *displayMode = &display->current_mode; SDL_Renderer *renderer; SDL_DUMMY_RenderData *data; int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; if (!SDL_PixelFormatEnumToMasks (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { SDL_SetError("Unknown display format"); return NULL; } renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { SDL_OutOfMemory(); return NULL; } data = (SDL_DUMMY_RenderData *) SDL_malloc(sizeof(*data)); if (!data) { SDL_DUMMY_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } SDL_zerop(data); renderer->RenderPoint = SDL_DUMMY_RenderPoint; renderer->RenderLine = SDL_DUMMY_RenderLine; renderer->RenderFill = SDL_DUMMY_RenderFill; renderer->RenderCopy = SDL_DUMMY_RenderCopy; renderer->RenderPresent = SDL_DUMMY_RenderPresent; renderer->DestroyRenderer = SDL_DUMMY_DestroyRenderer; renderer->info.name = SDL_DUMMY_RenderDriver.info.name; renderer->info.flags = 0; renderer->window = window->id; renderer->driverdata = data; Setup_SoftwareRenderer(renderer); 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->screens[i] = SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask, Bmask, Amask); if (!data->screens[i]) { SDL_DUMMY_DestroyRenderer(renderer); return NULL; } SDL_SetSurfacePalette(data->screens[i], display->palette); } data->current_screen = 0; return renderer; }
static int SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_WindowData *data; /* Allocate the window data */ data = (SDL_WindowData *) SDL_malloc(sizeof(*data)); if (!data) { SDL_OutOfMemory(); return -1; } data->windowID = window->id; data->hwnd = hwnd; data->hdc = GetDC(hwnd); data->created = created; data->mouse_pressed = SDL_FALSE; data->videodata = videodata; /* Associate the data with the window */ if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) { ReleaseDC(hwnd, data->hdc); SDL_free(data); WIN_SetError("SetProp() failed"); return -1; } /* Set up the window proc function */ data->wndproc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC); if (data->wndproc == NULL) { data->wndproc = DefWindowProc; } else { SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc); } /* Fill in the SDL window with the window data */ { POINT point; point.x = 0; point.y = 0; if (ClientToScreen(hwnd, &point)) { SDL_Rect bounds; WIN_GetDisplayBounds(_this, display, &bounds); window->x = point.x - bounds.x; window->y = point.y - bounds.y; } } { RECT rect; if (GetClientRect(hwnd, &rect)) { window->w = rect.right; window->h = rect.bottom; } } { DWORD style = GetWindowLong(hwnd, GWL_STYLE); if (style & WS_VISIBLE) { window->flags |= SDL_WINDOW_SHOWN; } else { window->flags &= ~SDL_WINDOW_SHOWN; } if (style & (WS_BORDER | WS_THICKFRAME)) { window->flags &= ~SDL_WINDOW_BORDERLESS; } else { window->flags |= SDL_WINDOW_BORDERLESS; } if (style & WS_THICKFRAME) { window->flags |= SDL_WINDOW_RESIZABLE; } else { window->flags &= ~SDL_WINDOW_RESIZABLE; } if (style & WS_MAXIMIZE) { window->flags |= SDL_WINDOW_MAXIMIZED; } else { window->flags &= ~SDL_WINDOW_MAXIMIZED; } if (style & WS_MINIMIZE) { window->flags |= SDL_WINDOW_MINIMIZED; } else { window->flags &= ~SDL_WINDOW_MINIMIZED; } } if (GetFocus() == hwnd) { int index = data->videodata->keyboard; window->flags |= SDL_WINDOW_INPUT_FOCUS; SDL_SetKeyboardFocus(index, data->windowID); if (window->flags & SDL_WINDOW_INPUT_GRABBED) { RECT rect; GetClientRect(hwnd, &rect); ClientToScreen(hwnd, (LPPOINT) & rect); ClientToScreen(hwnd, (LPPOINT) & rect + 1); ClipCursor(&rect); } } /* All done! */ window->driverdata = data; return 0; }
int WIN_CreateWindow(_THIS, SDL_Window * window) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); RAWINPUTDEVICE Rid; AXIS TabX, TabY; LOGCONTEXTA lc; HWND hwnd; HWND top; RECT rect; SDL_Rect bounds; DWORD style = (WS_CLIPSIBLINGS | WS_CLIPCHILDREN); int x, y; int w, h; if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) { style |= WS_POPUP; } else { style |= (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX); } if ((window->flags & SDL_WINDOW_RESIZABLE) && !(window->flags & SDL_WINDOW_FULLSCREEN)) { style |= (WS_THICKFRAME | WS_MAXIMIZEBOX); } /* Figure out what the window area will be */ if (window->flags & SDL_WINDOW_FULLSCREEN) { top = HWND_TOPMOST; } else { top = HWND_NOTOPMOST; } rect.left = 0; rect.top = 0; rect.right = window->w; rect.bottom = window->h; AdjustWindowRectEx(&rect, style, FALSE, 0); w = (rect.right - rect.left); h = (rect.bottom - rect.top); WIN_GetDisplayBounds(_this, display, &bounds); if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->x == SDL_WINDOWPOS_CENTERED) { x = bounds.x + (bounds.w - window->w) / 2; } else if (window->x == SDL_WINDOWPOS_UNDEFINED) { if (bounds.x == 0) { x = CW_USEDEFAULT; } else { x = bounds.x; } } else { x = bounds.x + window->x + rect.left; } if ((window->flags & SDL_WINDOW_FULLSCREEN) || window->y == SDL_WINDOWPOS_CENTERED) { y = bounds.y + (bounds.h - window->h) / 2; } else if (window->x == SDL_WINDOWPOS_UNDEFINED) { if (bounds.x == 0) { y = CW_USEDEFAULT; } else { y = bounds.y; } } else { y = bounds.y + window->y + rect.top; } hwnd = CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL, SDL_Instance, NULL); if (!hwnd) { WIN_SetError("Couldn't create window"); return -1; } /* we're configuring the tablet data. See Wintab reference for more info */ if (videodata->wintabDLL && videodata->WTInfoA(WTI_DEFSYSCTX, 0, &lc) != 0) { lc.lcPktData = PACKETDATA; lc.lcPktMode = PACKETMODE; lc.lcOptions |= CXO_MESSAGES; lc.lcOptions |= CXO_SYSTEM; lc.lcMoveMask = PACKETDATA; lc.lcBtnDnMask = lc.lcBtnUpMask = PACKETDATA; videodata->WTInfoA(WTI_DEVICES, DVC_X, &TabX); videodata->WTInfoA(WTI_DEVICES, DVC_Y, &TabY); lc.lcInOrgX = 0; lc.lcInOrgY = 0; lc.lcInExtX = TabX.axMax; lc.lcInExtY = TabY.axMax; lc.lcOutOrgX = 0; lc.lcOutOrgY = 0; lc.lcOutExtX = GetSystemMetrics(SM_CXSCREEN); lc.lcOutExtY = -GetSystemMetrics(SM_CYSCREEN); if (window->id > highestId) { HCTX *tmp_hctx; highestId = window->id; tmp_hctx = (HCTX *) SDL_realloc(g_hCtx, (highestId + 1) * sizeof(HCTX)); if (!tmp_hctx) { SDL_OutOfMemory(); DestroyWindow(hwnd); return -1; } g_hCtx = tmp_hctx; } g_hCtx[window->id] = videodata->WTOpenA(hwnd, &lc, TRUE); } #ifndef _WIN32_WCE /* has no RawInput */ /* we're telling the window, we want it to report raw input events from mice */ Rid.usUsagePage = 0x01; Rid.usUsage = 0x02; Rid.dwFlags = RIDEV_INPUTSINK; Rid.hwndTarget = hwnd; RegisterRawInputDevices(&Rid, 1, sizeof(Rid)); #endif WIN_PumpEvents(_this); if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) { DestroyWindow(hwnd); return -1; } #ifdef SDL_VIDEO_OPENGL_WGL if (window->flags & SDL_WINDOW_OPENGL) { if (WIN_GL_SetupWindow(_this, window) < 0) { WIN_DestroyWindow(_this, window); return -1; } } #endif return 0; }
static int DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DFB_DEVICEDATA(display->device); DirectFB_TextureData *data; DFBResult ret; DFBSurfaceDescription dsc; SDL_DFB_CALLOC(data, 1, sizeof(*data)); texture->driverdata = data; data->format = texture->format; data->pitch = (texture->w * SDL_BYTESPERPIXEL(data->format)); if (DirectFB_AcquireVidLayer(renderer, texture) != 0) { /* fill surface description */ dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.width = texture->w; dsc.height = texture->h; /* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance * No DSCAPS_SYSTEMONLY either - let dfb decide * 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8 * Depends on other settings as well. Let dfb decide. */ dsc.caps = DSCAPS_PREMULTIPLIED; #if 0 if (texture->access == SDL_TEXTUREACCESS_STREAMING) dsc.caps |= DSCAPS_SYSTEMONLY; else dsc.caps |= DSCAPS_VIDEOONLY; #endif /* find the right pixelformat */ dsc.pixelformat = SDLToDFBPixelFormat(data->format); if (dsc.pixelformat == DSPF_UNKNOWN) { SDL_SetError("Unknown pixel format %d\n", data->format); goto error; } data->pixels = NULL; /* Create the surface */ SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &data->surface)); if (SDL_ISPIXELFORMAT_INDEXED(data->format) && !SDL_ISPIXELFORMAT_FOURCC(data->format)) { SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface, &data->palette)); } } #if (DFB_VERSION_ATLEAST(1,2,0)) data->render_options = DSRO_NONE; #endif if (texture->access == SDL_TEXTUREACCESS_STREAMING) { data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format); SDL_DFB_CALLOC(data->pixels, 1, texture->h * data->pitch); } return 0; error: SDL_DFB_RELEASE(data->palette); SDL_DFB_RELEASE(data->surface); SDL_DFB_FREE(texture->driverdata); return -1; }
SDL_Renderer * D3D_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_VideoData *videodata = (SDL_VideoData *) display->device->driverdata; SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata; SDL_Renderer *renderer; D3D_RenderData *data; HRESULT result; D3DPRESENT_PARAMETERS pparams; IDirect3DSwapChain9 *chain; D3DCAPS9 caps; renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { SDL_OutOfMemory(); return NULL; } data = (D3D_RenderData *) SDL_calloc(1, sizeof(*data)); if (!data) { D3D_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } data->d3d = videodata->d3d; renderer->DisplayModeChanged = D3D_DisplayModeChanged; renderer->CreateTexture = D3D_CreateTexture; renderer->QueryTexturePixels = D3D_QueryTexturePixels; renderer->SetTexturePalette = D3D_SetTexturePalette; renderer->GetTexturePalette = D3D_GetTexturePalette; renderer->SetTextureColorMod = D3D_SetTextureColorMod; renderer->SetTextureAlphaMod = D3D_SetTextureAlphaMod; renderer->SetTextureBlendMode = D3D_SetTextureBlendMode; renderer->SetTextureScaleMode = D3D_SetTextureScaleMode; renderer->UpdateTexture = D3D_UpdateTexture; renderer->LockTexture = D3D_LockTexture; renderer->UnlockTexture = D3D_UnlockTexture; renderer->DirtyTexture = D3D_DirtyTexture; renderer->RenderPoint = D3D_RenderPoint; renderer->RenderLine = D3D_RenderLine; renderer->RenderFill = D3D_RenderFill; renderer->RenderCopy = D3D_RenderCopy; renderer->RenderPresent = D3D_RenderPresent; renderer->DestroyTexture = D3D_DestroyTexture; renderer->DestroyRenderer = D3D_DestroyRenderer; renderer->info = D3D_RenderDriver.info; renderer->window = window->id; renderer->driverdata = data; renderer->info.flags = SDL_RENDERER_ACCELERATED; SDL_zero(pparams); pparams.BackBufferWidth = window->w; pparams.BackBufferHeight = window->h; if (window->flags & SDL_WINDOW_FULLSCREEN) { pparams.BackBufferFormat = PixelFormatToD3DFMT(display->fullscreen_mode.format); } else { pparams.BackBufferFormat = D3DFMT_UNKNOWN; } if (flags & SDL_RENDERER_PRESENTFLIP2) { pparams.BackBufferCount = 2; pparams.SwapEffect = D3DSWAPEFFECT_FLIP; } else if (flags & SDL_RENDERER_PRESENTFLIP3) { pparams.BackBufferCount = 3; pparams.SwapEffect = D3DSWAPEFFECT_FLIP; } else if (flags & SDL_RENDERER_PRESENTCOPY) { pparams.BackBufferCount = 1; pparams.SwapEffect = D3DSWAPEFFECT_COPY; } else { pparams.BackBufferCount = 1; pparams.SwapEffect = D3DSWAPEFFECT_DISCARD; } if (window->flags & SDL_WINDOW_FULLSCREEN) { pparams.Windowed = FALSE; pparams.FullScreen_RefreshRateInHz = display->fullscreen_mode.refresh_rate; } else { pparams.Windowed = TRUE; pparams.FullScreen_RefreshRateInHz = 0; } if (flags & SDL_RENDERER_PRESENTVSYNC) { pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE; } else { pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; } IDirect3D9_GetDeviceCaps(videodata->d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps); result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT, /* FIXME */ D3DDEVTYPE_HAL, windowdata->hwnd, (caps. DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING, &pparams, &data->device); if (FAILED(result)) { D3D_DestroyRenderer(renderer); D3D_SetError("CreateDevice()", result); return NULL; } data->beginScene = SDL_TRUE; /* Get presentation parameters to fill info */ result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain); if (FAILED(result)) { D3D_DestroyRenderer(renderer); D3D_SetError("GetSwapChain()", result); return NULL; } result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams); if (FAILED(result)) { IDirect3DSwapChain9_Release(chain); D3D_DestroyRenderer(renderer); D3D_SetError("GetPresentParameters()", result); return NULL; } IDirect3DSwapChain9_Release(chain); switch (pparams.SwapEffect) { case D3DSWAPEFFECT_COPY: renderer->info.flags |= SDL_RENDERER_PRESENTCOPY; break; case D3DSWAPEFFECT_FLIP: switch (pparams.BackBufferCount) { case 2: renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2; break; case 3: renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3; break; } break; case D3DSWAPEFFECT_DISCARD: renderer->info.flags |= SDL_RENDERER_PRESENTDISCARD; break; } if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) { renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; } data->pparams = pparams; IDirect3DDevice9_GetDeviceCaps(data->device, &caps); renderer->info.max_texture_width = caps.MaxTextureWidth; renderer->info.max_texture_height = caps.MaxTextureHeight; /* Set up parameters for rendering */ IDirect3DDevice9_SetVertexShader(data->device, NULL); IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1); IDirect3DDevice9_SetRenderState(data->device, D3DRS_ZENABLE, D3DZB_FALSE); IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE, D3DCULL_NONE); IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE); /* Enable color modulation by diffuse color */ IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE); IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE); IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); /* Enable alpha modulation by diffuse alpha */ IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE); IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE); /* Disable second texture stage, since we're done */ IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE); IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE); return renderer; }
static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags) { SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(window); SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata; SDL_WindowData* wdata = (SDL_WindowData*)window->driverdata; SDL_Renderer* renderer = NULL; SDL_RenderData* rdata = NULL; uint32_t it; int32_t jt; int32_t status; /* Check if it is OpenGL ES window */ if ((window->flags & SDL_WINDOW_OPENGL)==SDL_WINDOW_OPENGL) { /* No error, just no need to create 2D renderer for OpenGL ES window */ return NULL; } /* Allocate new renderer structure */ renderer=(SDL_Renderer*)SDL_calloc(1, sizeof(SDL_Renderer)); if (renderer==NULL) { SDL_OutOfMemory(); return NULL; } /* Allocate renderer data */ rdata=(SDL_RenderData*)SDL_calloc(1, sizeof(SDL_RenderData)); if (rdata==NULL) { SDL_free(renderer); SDL_OutOfMemory(); return NULL; } renderer->DisplayModeChanged=gf_displaymodechanged; renderer->ActivateRenderer=gf_activaterenderer; renderer->CreateTexture=gf_createtexture; renderer->QueryTexturePixels=gf_querytexturepixels; renderer->SetTexturePalette=gf_settexturepalette; renderer->GetTexturePalette=gf_gettexturepalette; renderer->SetTextureAlphaMod=gf_settexturealphamod; renderer->SetTextureColorMod=gf_settexturecolormod; renderer->SetTextureBlendMode=gf_settextureblendmode; renderer->SetTextureScaleMode=gf_settexturescalemode; renderer->UpdateTexture=gf_updatetexture; renderer->LockTexture=gf_locktexture; renderer->UnlockTexture=gf_unlocktexture; renderer->DirtyTexture=gf_dirtytexture; renderer->RenderPoint=gf_renderpoint; renderer->RenderLine=gf_renderline; renderer->RenderFill=gf_renderfill; renderer->RenderCopy=gf_rendercopy; renderer->RenderPresent = gf_renderpresent; renderer->DestroyTexture = gf_destroytexture; renderer->DestroyRenderer = gf_destroyrenderer; renderer->info = gf_renderdriver.info; renderer->window = window->id; renderer->driverdata = rdata; /* Set render acceleration flag in case it is accelerated */ if ((didata->caps & SDL_GF_ACCELERATED)==SDL_GF_ACCELERATED) { renderer->info.flags=SDL_RENDERER_ACCELERATED; } else { renderer->info.flags&=~(SDL_RENDERER_ACCELERATED); } rdata->window=window; /* Check if upper level requested synchronization on vsync signal */ if ((flags & SDL_RENDERER_PRESENTVSYNC)==SDL_RENDERER_PRESENTVSYNC) { rdata->enable_vsync=SDL_TRUE; } else { rdata->enable_vsync=SDL_FALSE; } /* Check what buffer copy/flip scheme is requested */ rdata->surfaces_count=0; if ((flags & SDL_RENDERER_SINGLEBUFFER)==SDL_RENDERER_SINGLEBUFFER) { if ((flags & SDL_RENDERER_PRESENTDISCARD)==SDL_RENDERER_PRESENTDISCARD) { renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD; } else { renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY; } rdata->surfaces_count=1; rdata->surface_visible_idx=0; rdata->surface_render_idx=0; } else { if ((flags & SDL_RENDERER_PRESENTFLIP2)==SDL_RENDERER_PRESENTFLIP2) { renderer->info.flags|=SDL_RENDERER_PRESENTFLIP2; rdata->surfaces_count=2; rdata->surface_visible_idx=0; rdata->surface_render_idx=1; } else { if ((flags & SDL_RENDERER_PRESENTFLIP3)==SDL_RENDERER_PRESENTFLIP3) { renderer->info.flags|=SDL_RENDERER_PRESENTFLIP3; rdata->surfaces_count=3; rdata->surface_visible_idx=0; rdata->surface_render_idx=1; } else { renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY; rdata->surfaces_count=1; rdata->surface_visible_idx=0; rdata->surface_render_idx=0; } } } /* Create layer surfaces, which could be visible */ for (it=0; it<rdata->surfaces_count; it++) { /* TODO: add palette creation */ /* Create displayable surfaces */ status=gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0, didata->current_mode.w, didata->current_mode.h, qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format), NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE); if (status!=GF_ERR_OK) { /* Free already allocated surfaces */ for (jt=it-1; jt>0; jt--) { gf_surface_free(rdata->surface[jt]); rdata->surface[jt]=NULL; } SDL_free(rdata); SDL_free(renderer); if (status==GF_ERR_MEM) { SDL_SetError("unsufficient free video memory"); } else { SDL_SetError("error during displayable surface creation"); } return NULL; } /* Get detailed information about allocated surface */ gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]); } return renderer; }
SDL_Renderer * DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_DFB_WINDOWDATA(window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_Renderer *renderer = NULL; DirectFB_RenderData *data = NULL; DFBResult ret; DFBSurfaceCapabilities scaps; char *p; SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer)); SDL_DFB_CALLOC(data, 1, sizeof(*data)); renderer->DisplayModeChanged = DirectFB_DisplayModeChanged; renderer->ActivateRenderer = DirectFB_ActivateRenderer; renderer->CreateTexture = DirectFB_CreateTexture; renderer->QueryTexturePixels = DirectFB_QueryTexturePixels; renderer->SetTexturePalette = DirectFB_SetTexturePalette; renderer->GetTexturePalette = DirectFB_GetTexturePalette; renderer->SetTextureAlphaMod = DirectFB_SetTextureAlphaMod; renderer->SetTextureColorMod = DirectFB_SetTextureColorMod; renderer->SetTextureBlendMode = DirectFB_SetTextureBlendMode; renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode; renderer->UpdateTexture = DirectFB_UpdateTexture; renderer->LockTexture = DirectFB_LockTexture; renderer->UnlockTexture = DirectFB_UnlockTexture; renderer->DirtyTexture = DirectFB_DirtyTexture; renderer->RenderPoint = DirectFB_RenderPoint; renderer->RenderLine = DirectFB_RenderLine; renderer->RenderFill = DirectFB_RenderFill; renderer->RenderCopy = DirectFB_RenderCopy; renderer->RenderPresent = DirectFB_RenderPresent; renderer->DestroyTexture = DirectFB_DestroyTexture; renderer->DestroyRenderer = DirectFB_DestroyRenderer; renderer->info = DirectFB_RenderDriver.info; renderer->window = window->id; /* SDL window id */ renderer->driverdata = data; renderer->info.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD; data->window = window; data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT; if (flags & SDL_RENDERER_PRESENTVSYNC) { data->flipflags |= DSFLIP_WAITFORSYNC; renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; } else data->flipflags |= DSFLIP_ONSYNC; SDL_DFB_CHECKERR(windata->surface-> GetCapabilities(windata->surface, &scaps)); if (scaps & DSCAPS_DOUBLE) renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2; else if (scaps & DSCAPS_TRIPLE) renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3; else renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER; data->isyuvdirect = 0; /* default is off! */ p = SDL_getenv(DFBENV_USE_YUV_DIRECT); if (p) data->isyuvdirect = atoi(p); /* Set up a palette watch on the display palette */ if (display->palette) { SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data); } return renderer; error: SDL_DFB_FREE(renderer); SDL_DFB_FREE(data); return NULL; }