static void gfx_ctx_check_window(bool *quit, bool *resize, unsigned *width, unsigned *height, unsigned frame_count) { (void)frame_count; unsigned new_width = *width, new_height = *height; gfx_ctx_get_video_size(&new_width, &new_height); if (new_width != *width || new_height != *height) { *resize = true; *width = new_width; *height = new_height; } XEvent event; while (XPending(g_dpy)) { XNextEvent(g_dpy, &event); switch (event.type) { case ClientMessage: if ((Atom)event.xclient.data.l[0] == g_quit_atom) g_quit = true; break; case DestroyNotify: g_quit = true; break; case MapNotify: g_has_focus = true; break; case UnmapNotify: g_has_focus = false; break; case KeyPress: case KeyRelease: x11_handle_key_event(&event); break; } } *quit = g_quit; }
static void gfx_ctx_check_window(bool *quit, bool *resize, unsigned *width, unsigned *height, unsigned frame_count) { (void)frame_count; //Request and process all available BPS events bps_event_t *event = NULL; bps_get_event(&event, 0); *quit = false; unsigned new_width, new_height; gfx_ctx_get_video_size(&new_width, &new_height); if (new_width != *width || new_height != *height) { *width = new_width; *height = new_height; *resize = true; } if (event) { int domain = bps_event_get_domain(event); if (domain == screen_get_domain()) { screen_event_t screen_event = screen_event_get_event(event); int screen_val; screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val); switch (screen_val) { case SCREEN_EVENT_MTOUCH_TOUCH: case SCREEN_EVENT_MTOUCH_MOVE: case SCREEN_EVENT_MTOUCH_RELEASE: break; } } else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event))) g_extern.lifecycle_state |= (1ULL << RARCH_QUIT_KEY); } // Check if we are exiting. if (g_extern.lifecycle_state & (1ULL << RARCH_QUIT_KEY)) *quit = true; }
static void gfx_ctx_check_window(bool *quit, bool *resize, unsigned *width, unsigned *height, unsigned frame_count) { (void)frame_count; *quit = false; unsigned new_width, new_height; gfx_ctx_get_video_size(&new_width, &new_height); if (new_width != *width || new_height != *height) { *width = new_width; *height = new_height; *resize = true; } // Check if we are exiting. if (g_extern.lifecycle_state & (1ULL << RARCH_QUIT_KEY)) *quit = true; }
static bool gfx_ctx_orientation_update(void) { gl_t *gl = (gl_t*)driver.video_data; // Get real known video size, which might have been altered by context. gfx_ctx_get_video_size(&gl->win_width, &gl->win_height); RARCH_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height); if (gl->full_x || gl->full_y) // We got bogus from gfx_ctx_get_video_size. Replace. { gl->full_x = gl->win_width; gl->full_y = gl->win_height; } #ifdef HAVE_GLSL gl_glsl_use(0); #endif gl_set_viewport(gl, gl->win_width, gl->win_height, false, true); #ifdef HAVE_GLSL gl_glsl_use(1); #endif gl_set_viewport(gl, gl->win_width, gl->win_height, false, true); }
static void gfx_ctx_check_window(bool *quit, bool *resize, unsigned *width, unsigned *height, unsigned frame_count) { (void)frame_count; struct android_app *android_app = (struct android_app*)g_android; *quit = false; unsigned new_width, new_height; gfx_ctx_get_video_size(&new_width, &new_height); if (new_width != *width || new_height != *height) { *width = new_width; *height = new_height; *resize = true; } RARCH_PERFORMANCE_INIT(alooper_pollonce); RARCH_PERFORMANCE_START(alooper_pollonce); while (ALooper_pollOnce(0, NULL, NULL, NULL) == LOOPER_ID_MAIN) { int8_t cmd; if (read(android_app->msgread, &cmd, sizeof(cmd)) != sizeof(cmd)) cmd = -1; engine_handle_cmd(android_app, cmd); } RARCH_PERFORMANCE_STOP(alooper_pollonce); // Check if we are exiting. if (g_extern.lifecycle_state & (1ULL << RARCH_QUIT_KEY)) *quit = true; }
static bool d3d_construct(d3d_video_t *d3d, const video_info_t *info, const input_driver_t **input, void **input_data) { unsigned full_x, full_y; settings_t *settings = config_get_ptr(); d3d->should_resize = false; #if defined(HAVE_MENU) d3d->menu = new overlay_t(); if (!d3d->menu) return false; d3d->menu->tex_coords[0] = 0; d3d->menu->tex_coords[1] = 0; d3d->menu->tex_coords[2] = 1; d3d->menu->tex_coords[3] = 1; d3d->menu->vert_coords[0] = 0; d3d->menu->vert_coords[1] = 1; d3d->menu->vert_coords[2] = 1; d3d->menu->vert_coords[3] = -1; #endif memset(&d3d->windowClass, 0, sizeof(d3d->windowClass)); #ifdef HAVE_WINDOW d3d->windowClass.lpfnWndProc = WndProcD3D; win32_window_init(&d3d->windowClass, true, NULL); #endif #ifdef HAVE_MONITOR bool windowed_full; RECT mon_rect; MONITORINFOEX current_mon; HMONITOR hm_to_use; win32_monitor_info(¤t_mon, &hm_to_use, &d3d->cur_mon_id); mon_rect = current_mon.rcMonitor; g_resize_width = info->width; g_resize_height = info->height; windowed_full = settings->video.windowed_fullscreen; full_x = (windowed_full || info->width == 0) ? (mon_rect.right - mon_rect.left) : info->width; full_y = (windowed_full || info->height == 0) ? (mon_rect.bottom - mon_rect.top) : info->height; RARCH_LOG("[D3D]: Monitor size: %dx%d.\n", (int)(mon_rect.right - mon_rect.left), (int)(mon_rect.bottom - mon_rect.top)); #else gfx_ctx_get_video_size(&full_x, &full_y); #endif { unsigned new_width = info->fullscreen ? full_x : info->width; unsigned new_height = info->fullscreen ? full_y : info->height; video_driver_set_size(&new_width, &new_height); } #ifdef HAVE_WINDOW DWORD style; unsigned win_width, win_height; RECT rect = {0}; video_driver_get_size(&win_width, &win_height); win32_set_style(¤t_mon, &hm_to_use, &win_width, &win_height, info->fullscreen, windowed_full, &rect, &mon_rect, &style); win32_window_create(d3d, style, &mon_rect, win_width, win_height, info->fullscreen); win32_set_window(&win_width, &win_height, info->fullscreen, windowed_full, &rect); #endif #ifdef HAVE_SHADERS /* This should only be done once here * to avoid set_shader() to be overridden * later. */ enum rarch_shader_type type = video_shader_parse_type(settings->video.shader_path, RARCH_SHADER_NONE); if (settings->video.shader_enable && type == RARCH_SHADER_CG) d3d->shader_path = settings->video.shader_path; if (!d3d_process_shader(d3d)) return false; #endif d3d->video_info = *info; if (!d3d_initialize(d3d, &d3d->video_info)) return false; gfx_ctx_input_driver(input, input_data); RARCH_LOG("[D3D]: Init complete.\n"); return true; }
void d3d_make_d3dpp(void *data, const video_info_t *info, D3DPRESENT_PARAMETERS *d3dpp) { d3d_video_t *d3d = (d3d_video_t*)data; settings_t *settings = config_get_ptr(); #ifdef _XBOX /* TODO/FIXME - get rid of global state dependencies. */ global_t *global = global_get_ptr(); #endif memset(d3dpp, 0, sizeof(*d3dpp)); d3dpp->Windowed = false; #ifndef _XBOX d3dpp->Windowed = settings->video.windowed_fullscreen || !info->fullscreen; #endif d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; if (info->vsync) { switch (settings->video.swap_interval) { default: case 1: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_ONE; break; case 2: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_TWO; break; case 3: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_THREE; break; case 4: d3dpp->PresentationInterval = D3DPRESENT_INTERVAL_FOUR; break; } } d3dpp->SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp->BackBufferCount = 2; #ifdef _XBOX d3dpp->BackBufferFormat = #ifdef _XBOX360 global->console.screen.gamma_correction ? (D3DFORMAT)MAKESRGBFMT(info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5) : #endif info->rgb32 ? D3DFMT_X8R8G8B8 : D3DFMT_LIN_R5G6B5; #else d3dpp->hDeviceWindow = win32_get_window(); d3dpp->BackBufferFormat = !d3dpp->Windowed ? D3DFMT_X8R8G8B8 : D3DFMT_UNKNOWN; #endif if (!d3dpp->Windowed) { #ifdef _XBOX unsigned width = 0; unsigned height = 0; gfx_ctx_get_video_size(&width, &height); video_driver_set_size(&width, &height); #endif video_driver_get_size(&d3dpp->BackBufferWidth, &d3dpp->BackBufferHeight); } #ifdef _XBOX d3dpp->MultiSampleType = D3DMULTISAMPLE_NONE; d3dpp->EnableAutoDepthStencil = FALSE; #if defined(_XBOX1) /* Get the "video mode" */ DWORD video_mode = XGetVideoFlags(); /* Check if we are able to use progressive mode. */ if (video_mode & XC_VIDEO_FLAGS_HDTV_480p) d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE; else d3dpp->Flags = D3DPRESENTFLAG_INTERLACED; /* Only valid in PAL mode, not valid for HDTV modes. */ if (XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I) { if (video_mode & XC_VIDEO_FLAGS_PAL_60Hz) d3dpp->FullScreen_RefreshRateInHz = 60; else d3dpp->FullScreen_RefreshRateInHz = 50; } if (XGetAVPack() == XC_AV_PACK_HDTV) { if (video_mode & XC_VIDEO_FLAGS_HDTV_480p) d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE; else if (video_mode & XC_VIDEO_FLAGS_HDTV_720p) d3dpp->Flags = D3DPRESENTFLAG_PROGRESSIVE; else if (video_mode & XC_VIDEO_FLAGS_HDTV_1080i) d3dpp->Flags = D3DPRESENTFLAG_INTERLACED; } if (widescreen_mode) d3dpp->Flags |= D3DPRESENTFLAG_WIDESCREEN; #elif defined(_XBOX360) if (!widescreen_mode) d3dpp->Flags |= D3DPRESENTFLAG_NO_LETTERBOX; if (global->console.screen.gamma_correction) d3dpp->FrontBufferFormat = (D3DFORMAT)MAKESRGBFMT(D3DFMT_LE_X8R8G8B8); else d3dpp->FrontBufferFormat = D3DFMT_LE_X8R8G8B8; d3dpp->MultiSampleQuality = 0; #endif #endif }
static void *vg_init(const video_info_t *video, const input_driver_t **input, void **input_data) { unsigned temp_width = 0, temp_height = 0; VGfloat clearColor[4] = {0, 0, 0, 1}; settings_t *settings = config_get_ptr(); driver_t *driver = driver_get_ptr(); const gfx_ctx_driver_t *ctx = NULL; vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t)); if (!vg) goto error; ctx = gfx_ctx_init_first(vg, settings->video.context_driver, GFX_CTX_OPENVG_API, 0, 0, false); if (!ctx) goto error; driver->video_context = ctx; gfx_ctx_get_video_size(vg, &temp_width, &temp_height); RARCH_LOG("Detecting screen resolution %ux%u.\n", temp_width, temp_height); if (temp_width != 0 && temp_height != 0) { video_driver_set_size_width(temp_width); video_driver_set_size_width(temp_height); } gfx_ctx_swap_interval(vg, video->vsync ? 1 : 0); gfx_ctx_update_window_title(vg); vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565; vg->keep_aspect = video->force_aspect; unsigned win_width = video->width; unsigned win_height = video->height; if (video->fullscreen && (win_width == 0) && (win_height == 0)) { video_driver_get_size(&temp_width, &temp_height); win_width = temp_width; win_height = temp_height; } if (!gfx_ctx_set_video_mode(vg, win_width, win_height, video->fullscreen)) goto error; video_driver_get_size(&temp_width, &temp_height); temp_width = 0; temp_height = 0; gfx_ctx_get_video_size(vg, &temp_width, &temp_height); vg->should_resize = true; if (temp_width != 0 && temp_height != 0) { RARCH_LOG("Verified window resolution %ux%u.\n", temp_width, temp_height); video_driver_set_size_width(temp_width); video_driver_set_size_height(temp_height); } video_driver_get_size(&temp_width, &temp_height); vg->mScreenAspect = (float)temp_width / temp_height; gfx_ctx_translate_aspect(vg, &vg->mScreenAspect, temp_width, temp_height); vgSetfv(VG_CLEAR_COLOR, 4, clearColor); vg->mTextureWidth = vg->mTextureHeight = video->input_scale * RARCH_SCALE_BASE; vg->mImage = vgCreateImage(vg->mTexType, vg->mTextureWidth, vg->mTextureHeight, video->smooth ? VG_IMAGE_QUALITY_BETTER : VG_IMAGE_QUALITY_NONANTIALIASED); vg_set_nonblock_state(vg, !video->vsync); gfx_ctx_input_driver(vg, input, input_data); if (settings->video.font_enable && font_renderer_create_default(&vg->font_driver, &vg->mFontRenderer, *settings->video.font_path ? settings->video.font_path : NULL, settings->video.font_size)) { vg->mFont = vgCreateFont(0); if (vg->mFont != VG_INVALID_HANDLE) { vg->mFontsOn = true; vg->mFontHeight = settings->video.font_size; vg->mPaintFg = vgCreatePaint(); vg->mPaintBg = vgCreatePaint(); VGfloat paintFg[] = { settings->video.msg_color_r, settings->video.msg_color_g, settings->video.msg_color_b, 1.0f }; VGfloat paintBg[] = { settings->video.msg_color_r / 2.0f, settings->video.msg_color_g / 2.0f, settings->video.msg_color_b / 2.0f, 0.5f }; vgSetParameteri(vg->mPaintFg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetParameterfv(vg->mPaintFg, VG_PAINT_COLOR, 4, paintFg); vgSetParameteri(vg->mPaintBg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetParameterfv(vg->mPaintBg, VG_PAINT_COLOR, 4, paintBg); } } if (vg_query_extension("KHR_EGL_image") && gfx_ctx_image_buffer_init(vg, video)) { pvgCreateEGLImageTargetKHR = (PFNVGCREATEEGLIMAGETARGETKHRPROC)gfx_ctx_get_proc_address("vgCreateEGLImageTargetKHR"); if (pvgCreateEGLImageTargetKHR) { RARCH_LOG("[VG] Using EGLImage buffer\n"); vg->mEglImageBuf = true; } } #if 0 const char *ext = (const char*)vgGetString(VG_EXTENSIONS); if (ext) RARCH_LOG("[VG] Supported extensions: %s\n", ext); #endif return vg; error: if (vg) free(vg); if (driver) driver->video_context = NULL; return NULL; }
static void *gl_init(const video_info_t *video, const input_driver_t **input, void **input_data) { #ifdef _WIN32 gfx_set_dwm(); #endif #ifdef RARCH_CONSOLE if (driver.video_data) return driver.video_data; #endif gl_t *gl = (gl_t*)calloc(1, sizeof(gl_t)); if (!gl) return NULL; if (!gfx_ctx_init()) { free(gl); return NULL; } unsigned full_x = 0, full_y = 0; gfx_ctx_get_video_size(&full_x, &full_y); RARCH_LOG("Detecting resolution %ux%u.\n", full_x, full_y); gfx_ctx_set_swap_interval(video->vsync ? 1 : 0, false); unsigned win_width = video->width; unsigned win_height = video->height; if (video->fullscreen && (win_width == 0) && (win_height == 0)) { win_width = full_x; win_height = full_y; } if (!gfx_ctx_set_video_mode(win_width, win_height, g_settings.video.force_16bit ? 15 : 0, video->fullscreen)) { free(gl); return NULL; } #ifndef RARCH_CONSOLE gfx_ctx_update_window_title(true); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #endif #if (defined(HAVE_XML) || defined(HAVE_CG)) && defined(_WIN32) // Win32 GL lib doesn't have some functions needed for XML shaders. // Need to load dynamically :( if (!load_gl_proc()) { gfx_ctx_destroy(); free(gl); return NULL; } #endif gl->vsync = video->vsync; gl->fullscreen = video->fullscreen; gl->full_x = full_x; gl->full_y = full_y; gl->win_width = win_width; gl->win_height = win_height; RARCH_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height); #if defined(HAVE_CG_MENU) && defined(RARCH_CONSOLE) RARCH_LOG("Initializing menu shader ...\n"); gl_cg_set_menu_shader(default_paths.menu_shader_file); #endif if (!gl_shader_init()) { RARCH_ERR("Shader init failed.\n"); gfx_ctx_destroy(); free(gl); return NULL; } RARCH_LOG("GL: Loaded %u program(s).\n", gl_shader_num()); #ifdef HAVE_FBO // Set up render to texture. gl_init_fbo(gl, RARCH_SCALE_BASE * video->input_scale, RARCH_SCALE_BASE * video->input_scale); #endif gl->keep_aspect = video->force_aspect; // Apparently need to set viewport for passes when we aren't using FBOs. gl_shader_use(0); gl_set_viewport(gl, gl->win_width, gl->win_height, false, true); gl_shader_use(1); gl_set_viewport(gl, gl->win_width, gl->win_height, false, true); bool force_smooth = false; if (gl_shader_filter_type(1, &force_smooth)) gl->tex_filter = force_smooth ? GL_LINEAR : GL_NEAREST; else gl->tex_filter = video->smooth ? GL_LINEAR : GL_NEAREST; gl->texture_type = RARCH_GL_TEXTURE_TYPE; gl->texture_fmt = video->rgb32 ? RARCH_GL_FORMAT32 : RARCH_GL_FORMAT16; gl->base_size = video->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t); glEnable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glDisable(GL_DITHER); glClearColor(0, 0, 0, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glVertexPointer(2, GL_FLOAT, 0, vertex_ptr); memcpy(gl->tex_coords, tex_coords, sizeof(tex_coords)); glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords); glColorPointer(4, GL_FLOAT, 0, white_color); set_lut_texture_coords(tex_coords); gl->tex_w = RARCH_SCALE_BASE * video->input_scale; gl->tex_h = RARCH_SCALE_BASE * video->input_scale; #ifdef HAVE_OPENGL_TEXREF glGenBuffers(1, &gl->pbo); glBindBuffer(GL_TEXTURE_REFERENCE_BUFFER_SCE, gl->pbo); glBufferData(GL_TEXTURE_REFERENCE_BUFFER_SCE, gl->tex_w * gl->tex_h * gl->base_size * TEXTURES, NULL, GL_STREAM_DRAW); #endif // Empty buffer that we use to clear out the texture with on res change. gl->empty_buf = calloc(gl->tex_w * gl->tex_h, gl->base_size); gl_init_textures(gl); for (unsigned i = 0; i < TEXTURES; i++) { gl->last_width[i] = gl->tex_w; gl->last_height[i] = gl->tex_h; } for (unsigned i = 0; i < TEXTURES; i++) { gl->prev_info[i].tex = gl->texture[(gl->tex_index - (i + 1)) & TEXTURES_MASK]; gl->prev_info[i].input_size[0] = gl->tex_w; gl->prev_info[i].tex_size[0] = gl->tex_w; gl->prev_info[i].input_size[1] = gl->tex_h; gl->prev_info[i].tex_size[1] = gl->tex_h; memcpy(gl->prev_info[i].coord, tex_coords, sizeof(tex_coords)); } gfx_ctx_input_driver(input, input_data); gl_init_font(gl, g_settings.video.font_path, g_settings.video.font_size); if (!gl_check_error()) { gfx_ctx_destroy(); free(gl); return NULL; } return gl; }