void MCStack::setacceleratedrendering(bool p_value) { // If we are turning accelerated rendering off, then destroy the tilecache. if (!p_value) { MCTileCacheDestroy(m_tilecache); m_tilecache = nil; // MW-2012-03-15: [[ Bug ]] Make sure we dirty the stack to ensure all the // layer mode attrs are rest. dirtyall(); return; } // If we are turning accelerated rendering on, and we already have a tile- // cache, then do nothing. if (m_tilecache != nil) return; // Otherwise, we configure based on platform settings. int32_t t_tile_size; int32_t t_cache_limit; MCTileCacheCompositorType t_compositor_type; #ifdef _MAC_DESKTOP t_compositor_type = kMCTileCacheCompositorCoreGraphics; t_tile_size = 32; t_cache_limit = 32 * 1024 * 1024; #elif defined(_WINDOWS_DESKTOP) || defined(_LINUX_DESKTOP) t_compositor_type = kMCTileCacheCompositorSoftware; t_tile_size = 32; t_cache_limit = 32 * 1024 * 1024; #elif defined(_IOS_MOBILE) || defined(_ANDROID_MOBILE) t_compositor_type = kMCTileCacheCompositorStaticOpenGL; const MCDisplay *t_display; MCscreen -> getdisplays(t_display, false); MCRectangle t_viewport; t_viewport = t_display -> viewport; bool t_small_screen, t_medium_screen; t_small_screen = MCMin(t_viewport . width, t_viewport . height) <= 480 && MCMax(t_viewport . width, t_viewport . height) <= 640; t_medium_screen = MCMin(t_viewport . width, t_viewport . height) <= 768 && MCMax(t_viewport . width, t_viewport . height) <= 1024; if (t_small_screen) t_tile_size = 32, t_cache_limit = 16 * 1024 * 1024; else if (t_medium_screen) t_tile_size = 64, t_cache_limit = 32 * 1024 * 1024; else t_tile_size = 64, t_cache_limit = 64 * 1024 * 1024; #endif MCTileCacheCreate(t_tile_size, t_cache_limit, m_tilecache); MCTileCacheSetViewport(m_tilecache, curcard -> getrect()); MCTileCacheSetCompositor(m_tilecache, t_compositor_type); dirtyall(); }
void MCStack::view_setcompositortilesize(uint32_t p_size) { if (m_view_tilecache != nil) { MCTileCacheSetTileSize(m_view_tilecache, p_size); dirtyall(); } }
void MCStack::view_setcompositorcachelimit(uint32_t p_limit) { if (m_view_tilecache != nil) { MCTileCacheSetCacheLimit(m_view_tilecache, p_limit); dirtyall(); } }
void MCStack::view_on_rect_changed(void) { // IM-2013-10-03: [[ FullscreenMode ]] if the view rect has changed, update the tilecache geometry view_updatetilecacheviewport(); if (view_getfullscreen() || view_platform_dirtyviewonresize()) dirtyall(); }
MCRectangle MCStack::view_setgeom(const MCRectangle &p_rect) { // IM-2014-09-23: [[ Bug 13349 ]] Defer window resizing if the screen is locked. if ((MCRedrawIsScreenLocked() || !MCRedrawIsScreenUpdateEnabled()) && (opened && getflag(F_VISIBLE))) { m_view_need_resize = true; MCRedrawScheduleUpdateForStack(this); return p_rect; } dirtyall(); return view_platform_setgeom(p_rect); }
void MCStack::view_setcompositortype(MCTileCacheCompositorType p_type) { if (p_type == kMCTileCacheCompositorNone) { MCTileCacheDestroy(m_view_tilecache); m_view_tilecache = nil; } else { if (m_view_tilecache == nil) { MCTileCacheCreate(32, 4096 * 1024, m_view_tilecache); view_updatetilecacheviewport(); } MCTileCacheSetCompositor(m_view_tilecache, p_type); } dirtyall(); }
// IM-2013-10-14: [[ FullscreenMode ]] Move update region tracking into view abstraction void MCStack::view_dirty_all(void) { view_dirty_rect(MCRectangleMake(0, 0, m_view_rect.width, m_view_rect.height)); dirtyall(); }
void MCStack::view_setacceleratedrendering(bool p_value) { #ifdef _SERVER // We don't have accelerated rendering on Server return; #else // If we are turning accelerated rendering off, then destroy the tilecache. if (!p_value) { MCTileCacheDestroy(m_view_tilecache); m_view_tilecache = nil; // MW-2012-03-15: [[ Bug ]] Make sure we dirty the stack to ensure all the // layer mode attrs are rest. dirtyall(); return; } // If we are turning accelerated rendering on, and we already have a tile- // cache, then do nothing. if (m_view_tilecache != nil) return; // Otherwise, we configure based on platform settings. int32_t t_tile_size; int32_t t_cache_limit; MCTileCacheCompositorType t_compositor_type; #ifdef _MAC_DESKTOP t_compositor_type = kMCTileCacheCompositorCoreGraphics; t_tile_size = 32; t_cache_limit = 32 * 1024 * 1024; #elif defined(_WINDOWS_DESKTOP) || defined(_LINUX_DESKTOP) || defined(__EMSCRIPTEN__) t_compositor_type = kMCTileCacheCompositorSoftware; t_tile_size = 32; t_cache_limit = 32 * 1024 * 1024; #elif defined(_IOS_MOBILE) || defined(_ANDROID_MOBILE) t_compositor_type = kMCTileCacheCompositorStaticOpenGL; const MCDisplay *t_display; MCscreen -> getdisplays(t_display, false); MCRectangle t_viewport; t_viewport = t_display -> viewport; // IM-2014-01-30: [[ HiDPI ]] Use backing-surface size to determine small, medium, or large t_viewport = MCRectangleGetScaledBounds(t_viewport, view_getbackingscale()); bool t_small_screen, t_medium_screen; t_small_screen = MCMin(t_viewport . width, t_viewport . height) <= 480 && MCMax(t_viewport . width, t_viewport . height) <= 640; t_medium_screen = MCMin(t_viewport . width, t_viewport . height) <= 768 && MCMax(t_viewport . width, t_viewport . height) <= 1024; if (t_small_screen) t_tile_size = 32, t_cache_limit = 16 * 1024 * 1024; else if (t_medium_screen) t_tile_size = 64, t_cache_limit = 32 * 1024 * 1024; else t_tile_size = 64, t_cache_limit = 64 * 1024 * 1024; #else # error "No tile cache implementation defined for this platform" #endif MCTileCacheCreate(t_tile_size, t_cache_limit, m_view_tilecache); view_updatetilecacheviewport(); MCTileCacheSetCompositor(m_view_tilecache, t_compositor_type); dirtyall(); #endif /* !_SERVER */ }
void MCStack::view_update_transform(bool p_ensure_onscreen) { MCRectangle t_view_rect; MCGAffineTransform t_transform; #if defined(_MOBILE) MCOrientation t_orientation; MCSystemGetOrientation(t_orientation); MCOrientationGetRectForOrientation(t_orientation ,m_view_requested_stack_rect); #endif // IM-2014-01-16: [[ StackScale ]] Use utility method to calculate new values view_calculate_viewports(m_view_requested_stack_rect, m_view_adjusted_stack_rect, t_view_rect, t_transform); // IM-2013-12-20: [[ ShowAll ]] Calculate new stack visible rect MCRectangle t_stack_visible_rect; t_stack_visible_rect = MCRectangleGetTransformedBounds(MCRectangleMake(0, 0, t_view_rect.width, t_view_rect.height), MCGAffineTransformInvert(t_transform)); if (m_view_fullscreenmode == kMCStackFullscreenLetterbox || m_view_fullscreenmode == kMCStackFullscreenNoScale) t_stack_visible_rect = MCU_intersect_rect(t_stack_visible_rect, MCRectangleMake(0, 0, m_view_adjusted_stack_rect.width, m_view_adjusted_stack_rect.height)); // IM-2013-10-03: [[ FullscreenMode ]] if the transform has changed, redraw everything // IM-2013-12-20: [[ ShowAll ]] if the stack viewport has changed, redraw everything bool t_rect_changed, t_transform_changed; t_rect_changed = !MCU_equal_rect(t_stack_visible_rect, m_view_stack_visible_rect); t_transform_changed = !MCGAffineTransformIsEqual(t_transform, m_view_transform); if (t_rect_changed || t_transform_changed) { m_view_transform = t_transform; m_view_stack_visible_rect = t_stack_visible_rect; dirtyall(); if (t_transform_changed) this->OnViewTransformChanged(); } // PM-2015-07-17: [[ Bug 13754 ]] Make sure stack does not disappear off screen when changing the scalefactor MCRectangle t_bounded_rect; if (p_ensure_onscreen) { // AL-2015-10-01: [[ Bug 16017 ]] Remember location of stacks on a second monitor const MCDisplay* t_nearest_display; t_nearest_display = MCscreen -> getnearestdisplay(t_view_rect); if (t_nearest_display != nil) { MCRectangle t_screen_rect; t_screen_rect = t_nearest_display -> viewport; t_bounded_rect = MCU_bound_rect(t_view_rect, t_screen_rect . x, t_screen_rect . y, t_screen_rect . width, t_screen_rect . height); } else { // In noUI mode, we don't have a nearest display. t_bounded_rect = MCU_bound_rect(t_view_rect, 0, 0, MCscreen -> getwidth(), MCscreen -> getheight()); } } else { t_bounded_rect = t_view_rect; } // IM-2014-01-16: [[ StackScale ]] Update view rect if needed view_setrect(t_bounded_rect); }