static Uint8 SetWindowResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h)
{
GPU_Target* target = renderer->current_context_target;
GPU_Log(" %s (dummy)\n", __func__);
if(target == NULL)
return 0;
// Don't need to resize (only update internals) when resolution isn't changing.
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
if(target->context->window_w != w || target->context->window_h != h)
{
SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), w, h);
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
}
// Store the resolution for fullscreen_desktop changes
target->context->stored_window_w = target->context->window_w;
target->context->stored_window_h = target->context->window_h;
// Update base dimensions
target->base_w = target->context->window_w;
target->base_h = target->context->window_h;
// Resets virtual resolution
target->w = target->base_w;
target->h = target->base_h;
target->using_virtual_resolution = 0;
return 1;
}
void
loop()
{
SDL_Event event;
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d resized to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
}
}
if (event.window.event == SDL_WINDOWEVENT_MOVED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d moved to %d,%d (display %s)\n",
event.window.windowID,
event.window.data1,
event.window.data2,
SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
}
}
}
if (event.type == SDL_KEYUP) {
SDL_bool updateCursor = SDL_FALSE;
if (event.key.keysym.sym == SDLK_LEFT) {
--system_cursor;
if (system_cursor < 0) {
system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
}
updateCursor = SDL_TRUE;
} else if (event.key.keysym.sym == SDLK_RIGHT) {
++system_cursor;
if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
system_cursor = 0;
}
updateCursor = SDL_TRUE;
}
if (updateCursor) {
SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
SDL_FreeCursor(cursor);
cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
SDL_SetCursor(cursor);
}
}
}
#ifdef __EMSCRIPTEN__
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
static Uint8 SetFullscreen(GPU_Renderer* renderer, Uint8 enable_fullscreen, Uint8 use_desktop_resolution)
{
GPU_Target* target = renderer->current_context_target;
// These values should actually come from the window
Uint8 was_fullscreen = !enable_fullscreen;
Uint8 is_fullscreen = enable_fullscreen;
GPU_Log(" %s (dummy)\n", __func__);
//if(SetWindowFullscreen(target->context->windowID, enable_fullscreen) >= 0)
{
// If we just went fullscreen, save the original resolution
// We do this because you can't depend on the resolution to be preserved by SDL
// SDL_WINDOW_FULLSCREEN_DESKTOP changes the resolution and SDL_WINDOW_FULLSCREEN can change it when a given mode is not available
if(!was_fullscreen && is_fullscreen)
{
target->context->stored_window_w = target->context->window_w;
target->context->stored_window_h = target->context->window_h;
}
// If we're in windowed mode now and a resolution was stored, restore the original window resolution
if(was_fullscreen && !is_fullscreen && (target->context->stored_window_w != 0 && target->context->stored_window_h != 0))
SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), target->context->stored_window_w, target->context->stored_window_h);
// Update window dims
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
}
if(is_fullscreen != was_fullscreen)
{
// If virtual res is not set, we need to update the target dims and reset stuff that no longer is right
if(!target->using_virtual_resolution)
{
// Update dims
target->w = target->context->window_w;
target->h = target->context->window_h;
}
// Reset viewport
target->viewport = GPU_MakeRect(0, 0, target->context->window_w, target->context->window_h);
// Update viewport here
// Reset clip
GPU_UnsetClip(target);
// Update camera here
}
target->base_w = target->context->window_w;
target->base_h = target->context->window_h;
return is_fullscreen;
}
static GPU_Target* Init(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
{
SDL_Window* window;
GPU_Log(" %s (dummy)\n", __func__);
renderer->requested_id = renderer_request;
renderer->GPU_init_flags = GPU_GetPreInitFlags();
renderer->SDL_init_flags = SDL_flags;
window = NULL;
// Is there a window already set up that we are supposed to use?
if(renderer->current_context_target != NULL)
window = SDL_GetWindowFromID(renderer->current_context_target->context->windowID);
else
window = SDL_GetWindowFromID(GPU_GetInitWindow());
if(window == NULL)
{
// Set up window flags
if(!(renderer->SDL_init_flags & SDL_WINDOW_HIDDEN))
renderer->SDL_init_flags |= SDL_WINDOW_SHOWN;
window = SDL_CreateWindow("",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
w, h,
renderer->SDL_init_flags);
if(window == NULL)
{
GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Window creation failed.");
return NULL;
}
GPU_SetInitWindow(SDL_GetWindowID(window));
}
else
renderer->SDL_init_flags = SDL_flags;
renderer->enabled_features = 0xFFFFFFFF; // Pretend to support them all
renderer->current_context_target = renderer->impl->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target);
if(renderer->current_context_target == NULL)
return NULL;
// If the dimensions of the window don't match what we asked for, then set up a virtual resolution to pretend like they are.
if(!(renderer->GPU_init_flags & GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION) && w != 0 && h != 0 && (w != renderer->current_context_target->w || h != renderer->current_context_target->h))
renderer->impl->SetVirtualResolution(renderer, renderer->current_context_target, w, h);
return renderer->current_context_target;
}
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);
}
void destroy_group(Group* groups, int i)
{
GPU_FreeImage(groups[i].sprite.image);
SDL_DestroyWindow(SDL_GetWindowFromID(groups[i].target->context->windowID));
GPU_FreeTarget(groups[i].target);
groups[i].target = NULL;
}
static void MakeCurrent(GPU_Renderer* renderer, GPU_Target* target, Uint32 windowID)
{
GPU_Log(" %s (dummy)\n", __func__);
if(target == NULL || target->context == NULL)
return;
renderer->current_context_target = target;
// Reset if the target's window was changed
if(target->context->windowID != windowID)
{
// Update the window mappings
GPU_RemoveWindowMapping(windowID);
// Don't remove the target's current mapping. That lets other windows refer to it.
target->context->windowID = windowID;
GPU_AddWindowMapping(target);
// Update target's window size
SDL_GetWindowSize(SDL_GetWindowFromID(windowID), &target->context->window_w, &target->context->window_h);
target->base_w = target->context->window_w;
target->base_h = target->context->window_h;
// Reset the camera here for this window
}
}
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
SDL_RendererEventWatch(void *userdata, SDL_Event *event)
{
SDL_Renderer *renderer = (SDL_Renderer *)userdata;
if (event->type == SDL_WINDOWEVENT) {
SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
if (window == renderer->window) {
if (renderer->WindowEvent) {
renderer->WindowEvent(renderer, &event->window);
}
if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
/* Try to keep the previous viewport centered */
int w, h;
SDL_Rect viewport;
SDL_GetWindowSize(window, &w, &h);
viewport.x = (w - renderer->viewport.w) / 2;
viewport.y = (h - renderer->viewport.h) / 2;
viewport.w = renderer->viewport.w;
viewport.h = renderer->viewport.h;
SDL_RenderSetViewport(renderer, &viewport);
} else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
renderer->minimized = SDL_TRUE;
} else if (event->window.event == SDL_WINDOWEVENT_RESTORED) {
renderer->minimized = SDL_FALSE;
}
}
}
return 0;
}
void Sys_Quit (void)
{
SDL_Window *window = SDL_GetWindowFromID(windowID);
SDL_DestroyWindow(window);
SDL_Quit();
exit (0);
}
/**
* Events don't always have valid windows,
* but GHOST needs a window _always_. fallback to the GL window.
*/
static SDL_Window *SDL_GetWindowFromID_fallback(Uint32 id)
{
SDL_Window *sdl_win = SDL_GetWindowFromID(id);
if (sdl_win == NULL) {
sdl_win = SDL_GL_GetCurrentWindow();
}
return sdl_win;
}
ZWindow* ZWindowFromId(uint32_t id)
{
SDL_Window* wnd=SDL_GetWindowFromID(id);
if(wnd)
return (ZWindow*)SDL_GetWindowData(wnd,WND_USER_DATA);
else
return NULL;
}
static void processWindowEvent(SDL_WindowEvent* we){
switch (we->event) {
case SDL_WINDOWEVENT_RESIZED:
printf("SDL_WINDOWEVENT_RESIZED (%d, %d)\n", we->data1, we->data2);
resizeTexture(&gTexture, &gOsb, we->data1, we->data2,
SDL_GetRenderer(SDL_GetWindowFromID(we->windowID)));
break;
}
}
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 lua_SDL_GetWindowFromID(State & state){
Stack * stack = state.stack;
Window * interfaceWindow = state.getInterface<Window>("LuaSDL_Window");
SDL_Window * window = SDL_GetWindowFromID(stack->to<int>(1));
if (window){
interfaceWindow->push(window);
return 1;
}
return 0;
}
static struct sdl2_console *get_scon_from_window(uint32_t window_id)
{
int i;
for (i = 0; i < sdl2_num_outputs; i++) {
if (sdl2_console[i].real_window == SDL_GetWindowFromID(window_id)) {
return &sdl2_console[i];
}
}
return NULL;
}
static cg_filter_return_t
sdl_window_event_filter(SDL_WindowEvent *event,
cg_device_t *dev)
{
SDL_Window *window;
cg_framebuffer_t *framebuffer;
window = SDL_GetWindowFromID(event->windowID);
if (window == NULL)
return CG_FILTER_CONTINUE;
framebuffer = SDL_GetWindowData(window, CG_SDL_WINDOW_DATA_KEY);
if (framebuffer == NULL || framebuffer->dev != dev)
return CG_FILTER_CONTINUE;
if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
cg_display_t *display = dev->display;
cg_renderer_t *renderer = display->renderer;
cg_renderer_sdl2_t *sdl_renderer = renderer->winsys;
float width = event->data1;
float height = event->data2;
cg_onscreen_sdl2_t *sdl_onscreen;
_cg_framebuffer_winsys_update_size(framebuffer, width, height);
/* We only want to notify that a resize happened when the
* application calls cg_device_dispatch so instead of
* immediately notifying we queue an idle callback */
if (!sdl_renderer->resize_notify_idle) {
sdl_renderer->resize_notify_idle = _cg_loop_add_idle(
renderer,
flush_pending_resize_notifications_idle,
dev,
NULL);
}
sdl_onscreen = CG_ONSCREEN(framebuffer)->winsys;
sdl_onscreen->pending_resize_notify = true;
} else if (event->event == SDL_WINDOWEVENT_EXPOSED) {
cg_onscreen_dirty_info_t info;
/* Sadly SDL doesn't seem to report the rectangle of the expose
* event so we'll just queue the whole window */
info.x = 0;
info.y = 0;
info.width = framebuffer->width;
info.height = framebuffer->height;
_cg_onscreen_queue_dirty(CG_ONSCREEN(framebuffer), &info);
}
return CG_FILTER_CONTINUE;
}
int
main(int argc, char *argv[])
{
int i, done;
SDL_Event event;
/* Initialize test framework */
state = CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
}
state->skip_renderer = SDL_TRUE;
for (i = 1; i < argc;) {
int consumed;
consumed = CommonArg(state, i);
if (consumed == 0) {
consumed = -1;
}
if (consumed < 0) {
fprintf(stderr, "Usage: %s %s\n", argv[0], CommonUsage(state));
quit(1);
}
i += consumed;
}
if (!CommonInit(state)) {
quit(2);
}
/* Main render loop */
done = 0;
while (!done) {
/* Check for events */
while (SDL_PollEvent(&event)) {
CommonEvent(state, &event, &done);
if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_MOVED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
printf("Window %d moved to %d,%d (display %d)\n",
event.window.windowID,
event.window.data1,
event.window.data2,
SDL_GetWindowDisplay(window));
}
}
}
}
}
quit(0);
// keep the compiler happy ...
return(0);
}
void SDLApplication::parseWindowEvent(const SDL_Event& event, Uint32 windowID)
{
SDL_Window* window = SDL_GetWindowFromID(windowID);
for (size_t i=0; i<windows.size(); ++i)
if (windows[i]->displayWindow == window)
{
windows[i]->ProcessSDLEvent(event);
break;
}
return;
}
static int
DirectFB_ActivateRenderer(SDL_Renderer * renderer)
{
SDL_DFB_RENDERERDATA(renderer);
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_DFB_WINDOWDATA(window);
if (renddata->size_changed || windata->wm_needs_redraw) {
DirectFB_AdjustWindowSurface(window);
}
return 0;
}
void RenderBlock::initializeRenderer(SDL_Window *window) {
_renderer = SDL_CreateRenderer(window, -1,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (!_renderer)
emit error("SDL_CreateRenderer error: ");
_windowId = SDL_GetWindowID(window);
// autoscaling
SDL_Window *w = SDL_GetWindowFromID(_windowId);
int x, y;
SDL_GetWindowSize(w, &x, &y);
SDL_RenderSetLogicalSize(_renderer, x, y);
}
static void jl_ct_handle_resize__(jlgr_t* jlgr) {
if(jlgr->main.ct.event.type==SDL_WINDOWEVENT) { //Resize
if((jlgr->main.ct.event.window.event == SDL_WINDOWEVENT_RESIZED)
&& (SDL_GetWindowFromID(
jlgr->main.ct.event.window.windowID) ==
jlgr->wm.displayWindow->w))
{
JL_PRINT_DEBUG(jlgr->jl, "INPUT/RESIZE");
jlgr_resz(jlgr,
jlgr->main.ct.event.window.data1,
jlgr->main.ct.event.window.data2);
}
}
}
bool HandleEvent(SDL_Event *Event) {
bool ShouldQuit = false;
switch(Event->type) {
case SDL_QUIT:
{
printf("SDL_QUIT\n");
ShouldQuit = true;
} break;
case SDL_WINDOWEVENT:
{
switch(Event->window.event) {
case SDL_WINDOWEVENT_RESIZED:
{
printf("SDL_WINDOWEVENT_RESIZED (%d, %d)\n",
Event->window.data1,
Event->window.data2);
} break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
{
printf("SDL_WINDOWEVENT_FOCUS_GAINED\n");
} break;
case SDL_WINDOWEVENT_EXPOSED:
{
printf("Window exposed");
SDL_Window *Window = SDL_GetWindowFromID(Event->window.windowID);
SDL_Renderer *Renderer = SDL_GetRenderer(Window);
static bool isWhite = true;
if (isWhite == true) {
SDL_SetRenderDrawColor(Renderer, 255, 255, 255, 255);
isWhite = false;
}
else {
SDL_SetRenderDrawColor(Renderer, 0 , 0, 0, 255);
isWhite = true;
}
SDL_RenderClear(Renderer);
SDL_RenderPresent(Renderer);
} break;
}
} break;
}
return(ShouldQuit);
}
static inline sdl_window_info * window_from_id(Uint32 windowID)
{
sdl_window_info *w;
SDL_Window *window = SDL_GetWindowFromID(windowID);
for (w = sdl_window_list; w != NULL; w = w->m_next)
{
//printf("w->window_id: %d\n", w->window_id);
if (w->sdl_window() == window)
{
return w;
}
}
return NULL;
}
Ptr<Window> App::getWindowFromId(unsigned int id) const
{
SDL_Window * sdlWindow = SDL_GetWindowFromID(id);
if(sdlWindow != NULL)
{
for(auto const & window : windows)
{
if(sdlWindow == window->getSDLWindow())
{
return window;
}
}
}
return Ptr<Window>();
}
inline void
SDLHandleEvent(SDL_Event *Event, window_dimensions *WindowDimensions) {
SDL_Renderer *Renderer;
SDL_Window *Window;
Window = SDL_GetWindowFromID(Event->window.windowID);
Renderer = SDL_GetRenderer(Window);
switch(Event->type) {
case SDL_CONTROLLERDEVICEADDED:
SDLOpenGameControllers();
break;
case SDL_CONTROLLERDEVICEREMOVED:
SDLCloseGameControllers();
printf("Controller device removed\n");
break;
case SDL_CONTROLLERDEVICEREMAPPED:
printf("Controller device remapped\n");
break;
case SDL_QUIT:
GlobalRunning = false;
break;
case SDL_WINDOWEVENT:
switch(Event->window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
SDLCreateNewTexture(&GlobalBuffer,
Renderer,
Event->window.data1, Event->window.data2,
4);
WindowDimensions->Width = Event->window.data1;
WindowDimensions->Height = Event->window.data2;
break;
case SDL_WINDOWEVENT_EXPOSED:
SDLBlitFrameToWindow(&GlobalBuffer, Renderer);
break;
}
break;
}
}
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);
}
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;
}
static void
DirectFB_RenderPresent(SDL_Renderer * renderer)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_DFB_WINDOWDATA(window);
DFBRectangle sr;
DFBResult ret;
sr.x = 0;
sr.y = 0;
sr.w = window->w;
sr.h = window->h;
/* Send the data to the display */
SDL_DFB_CHECK(windata->window_surface->Flip(windata->window_surface, NULL,
data->flipflags));
}
