pages/SDL-Video.html-inc

   1 <div class="pod">
   2 <!-- INDEX START -->
   3 <h3 id="TOP">Index</h3>
   4
   5 <ul><li><a href="#NAME">NAME</a></li>
   6 <li><a href="#CATEGORY">CATEGORY</a></li>
   7 <li><a href="#SYNOPSIS">SYNOPSIS</a></li>
   8 <li><a href="#Core_Functions">Core Functions</a>
   9 <ul><li><a href="#get_video_surface">get_video_surface</a></li>
  10 <li><a href="#get_video_info">get_video_info</a></li>
  11 <li><a href="#video_driver_name">video_driver_name</a></li>
  12 <li><a href="#list_modes_formats_flags">list_modes(formats,flags)</a></li>
  13 <li><a href="#video_mode_ok_width_height_bpp_flags">video_mode_ok(width,height,bpp,flags)</a></li>
  14 <li><a href="#set_video_mode_width_height_bpp_flag">set_video_mode(width,height,bpp,flags)</a>
  15 <ul><li><a href="#List_of_avalaibles_flags">List of avalaibles flags</a></li>
  16 </ul>
  17 </li>
  18 <li><a href="#convert_surface_surface_format_flags">convert_surface(surface,format,flags)</a></li>
  19 <li><a href="#display_format">display_format</a></li>
  20 <li><a href="#display_format_alpha">display_format_alpha</a></li>
  21 <li><a href="#load_BMP_filename">load_BMP(filename)</a></li>
  22 <li><a href="#save_BMP_surface_filename">save_BMP(surface,filename)</a></li>
  23 <li><a href="#set_color_key_surface_flag_key">set_color_key(surface,flag,key)</a></li>
  24 <li><a href="#set_alpha_surface_flag_key">set_alpha(surface,flag,key)</a></li>
  25 <li><a href="#fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</a></li>
  26 </ul>
  27 </li>
  28 <li><a href="#Surface_locking_and_unlocking">Surface locking and unlocking</a>
  29 <ul><li><a href="#lock_surface_surface">lock_surface(surface)</a></li>
  30 <li><a href="#unlock_surface_surface">unlock_surface(surface)</a></li>
  31 <li><a href="#MUSTLOCK_surface">MUSTLOCK(surface)</a></li>
  32 </ul>
  33 </li>
  34 <li><a href="#Screen_Updating_Functions">Screen Updating Functions</a>
  35 <ul><li><a href="#set_clip_rect_surface_rect">set_clip_rect(surface,rect)</a></li>
  36 <li><a href="#get_clip_rect_surface_rect">get_clip_rect(surface,rect)</a></li>
  37 <li><a href="#blit_surface_src_src_rect_dest_dest_">blit_surface(src,src_rect,dest,dest_rect)</a></li>
  38 <li><a href="#update_rect_surface_x_y_width_height">update_rect(surface,x,y,width,height)</a></li>
  39 <li><a href="#update_rects_surface_rects">update_rects(surface,rects) </a></li>
  40 <li><a href="#flip_surface">flip(surface)</a></li>
  41 </ul>
  42 </li>
  43 <li><a href="#Palette_Color_and_Pixel_Functions">Palette, Color and Pixel Functions</a>
  44 <ul><li><a href="#set_colors_surface_start_colors">set_colors(surface,start,colors)</a></li>
  45 <li><a href="#set_palette_surface_flags_start_colo">set_palette(surface,flags,start,colors)</a></li>
  46 <li><a href="#set_gamma_r_g_b">set_gamma(r,g,b)</a></li>
  47 <li><a href="#get_gamma_ramp_rt_gt_bt">get_gamma_ramp(rt,gt,bt)</a></li>
  48 <li><a href="#set_gamma_ramp_rt_gt_bt">set_gamma_ramp(rt,gt,bt)</a></li>
  49 <li><a href="#map_RGB_pixel_format_r_g_b">map_RGB(pixel_format,r,g,b)</a></li>
  50 <li><a href="#map_RGBA_pixel_format_r_g_b_a">map_RGBA(pixel_format,r,g,b,a)</a></li>
  51 <li><a href="#get_RGB_pixel_format_pixel">get_RGB(pixel_format,pixel)</a></li>
  52 <li><a href="#get_RGBA_pixel_format_pixel">get_RGBA(pixel_format,pixel)</a></li>
  53 </ul>
  54 </li>
  55 <li><a href="#GL_Methods">GL Methods</a>
  56 <ul><li><a href="#GL_load_library_path">GL_load_library(path)</a></li>
  57 <li><a href="#GL_get_proc_address_proc">GL_get_proc_address(proc)</a></li>
  58 <li><a href="#GL_get_attribute_attr">GL_get_attribute(attr)</a></li>
  59 <li><a href="#GL_set_attribute_attr_value">GL_set_attribute(attr,value)</a></li>
  60 <li><a href="#GL_swap_buffers">GL_swap_buffers</a></li>
  61 <li><a href="#GL_attr_to_be_coded">GL_attr *** to be coded</a></li>
  62 </ul>
  63 </li>
  64 <li><a href="#Video_Overlay_Functions">Video Overlay Functions</a>
  65 <ul><li><a href="#lock_YUV_overlay_overlay">lock_YUV_overlay(overlay)</a></li>
  66 <li><a href="#unlock_YUV_overlay_overlay">unlock_YUV_overlay(overlay)</a></li>
  67 <li><a href="#display_YUV_overlay_overlay_dstrect">display_YUV_overlay(overlay,dstrect)</a></li>
  68 </ul>
  69 </li>
  70 <li><a href="#Window_Management_Functions">Window Management Functions</a>
  71 <ul><li><a href="#wm_set_caption_title_icon">wm_set_caption(title,icon)</a></li>
  72 <li><a href="#wm_get_caption">wm_get_caption()</a></li>
  73 <li><a href="#wm_set_icon_icon">wm_set_icon(icon)</a></li>
  74 <li><a href="#wm_grab_input_mode">wm_grab_input(mode)</a></li>
  75 <li><a href="#wm_iconify_window">wm_iconify_window()</a></li>
  76 <li><a href="#wm_toggle_fullscreen_surface">wm_toggle_fullscreen(surface)</a></li>
  77 </ul>
  78 </li>
  79 <li><a href="#SEE_ALSO">SEE ALSO</a>
  80 <ul><li><a href="#Category_Objects">Category Objects</a>
  81 </li>
  82 </ul>
  83 </li>
  84 </ul><hr />
  85 <!-- INDEX END --><a href="assets/Video.png" target="_blank"><img src="assets/Video.png" style="height: 160px" alt="Video.png"/></a><a href="assets/Video_lock_surface.png" target="_blank"><img src="assets/Video_lock_surface.png" style="height: 160px" alt="Video_lock_surface.png"/></a><hr />
  86
  87 <h1 id="NAME">NAME</h1><p><a href="#TOP" class="toplink">Top</a></p>
  88 <div id="NAME_CONTENT">
  89 <p>SDL::Video - Bindings to the video category in SDL API</p>
  90
  91 </div>
  92 <h1 id="CATEGORY">CATEGORY</h1><p><a href="#TOP" class="toplink">Top</a></p>
  93 <div id="CATEGORY_CONTENT">
  94 <p>Core, Video</p>
  95
  96 </div>
  97 <h1 id="SYNOPSIS">SYNOPSIS</h1><p><a href="#TOP" class="toplink">Top</a></p>
  98 <div id="SYNOPSIS_CONTENT">
  99 <pre> use SDL;
 100  use SDL::Video;
 101  use SDL::Surface;
 102  use SDL::Rect;
 103
 104  # the size of the window box or the screen resolution if fullscreen
 105  my $screen_width   = 800;
 106  my $screen_height  = 600;
 107
 108  SDL::init(SDL_INIT_VIDEO);
 109
 110  # setting video mode
 111  my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
 112
 113  # drawing something somewhere
 114  my $mapped_color   = SDL::Video::map_RGB($screen_surface-&gt;format(), 0, 0, 255); # blue
 115  SDL::Video::fill_rect($screen_surface,
 116                        SDL::Rect-&gt;new($screen_width / 4, $screen_height / 4,
 117                                       $screen_width / 2, $screen_height / 2), $mapped_color);
 118
 119  # update an area on the screen so its visible
 120  SDL::Video::update_rect($screen_surface, 0, 0, $screen_width, $screen_height);
 121
 122  sleep(5); # just to have time to see it
 123
 124  SDL::quit();
 125
 126 </pre>
 127
 128 </div>
 129 <h1 id="Core_Functions">Core Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
 130 <div id="Core_Functions_CONTENT">
 131
 132 </div>
 133 <h2 id="get_video_surface">get_video_surface</h2>
 134 <div id="get_video_surface_CONTENT">
 135 <pre> my $surface = SDL::Video::get_video_surface();
 136
 137 </pre>
 138 <p>This function returns the current display <a href="/SDL-Surface.html">SDL::Surface</a>. If SDL is doing format conversion on the display surface, this
 139 function returns the publicly visible surface, not the real video surface.</p>
 140 <p>Example:</p>
 141 <pre> # somewhere after you set the video mode
 142  my $surface = SDL::Video::get_video_surface();
 143
 144  printf( &quot;our screen is %d pixels wide and %d pixels high\n&quot;, $surface-&gt;w, $surface-&gt;h );
 145
 146 </pre>
 147
 148 </div>
 149 <h2 id="get_video_info">get_video_info</h2>
 150 <div id="get_video_info_CONTENT">
 151 <pre> my $video_info = SDL::Video::get_video_info();
 152
 153 </pre>
 154 <p>This function returns a read-only <a href="/SDL-VideoInfo.html">SDL::VideoInfo</a> containing information about the video hardware. If it is called before
 155 <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a>, the <code>vfmt</code> member of the returned structure will contain the pixel
 156 format of the <strong>best</strong> video mode. </p>
 157 <p>Example:</p>
 158 <pre> use SDL;
 159  use SDL::Video;
 160  use SDL::VideoInfo;
 161  use SDL::PixelFormat;
 162
 163  SDL::init(SDL_INIT_VIDEO);
 164
 165  my $video_info = SDL::Video::get_video_info();
 166
 167  printf( &quot;we can have %dbits per pixel\n&quot;, $video_info-&gt;vfmt-&gt;BitsPerPixel );
 168
 169  SDL::quit();
 170
 171 </pre>
 172
 173 </div>
 174 <h2 id="video_driver_name">video_driver_name</h2>
 175 <div id="video_driver_name_CONTENT">
 176 <pre> my $driver_name = SDL::Video::video_driver_name();
 177
 178 </pre>
 179 <p>This function will return the name of the initialized video driver up to a maximum of 1024 characters. The driver name is a simple one
 180 word identifier like <code>&quot;x11&quot;</code>, <code>&quot;windib&quot;</code> or <code>&quot;directx&quot;</code>.</p>
 181 <p><strong>Note</strong>: Some platforms allow selection of the video driver through the <code>SDL_VIDEODRIVER</code> environment variable. </p>
 182 <p>Example:</p>
 183 <pre> use SDL;
 184  use SDL::Video;
 185
 186  SDL::init(SDL_INIT_VIDEO);
 187
 188  print SDL::Video::video_driver_name() . &quot;\n&quot;;
 189
 190  SDL::quit();
 191
 192 </pre>
 193
 194 </div>
 195 <h2 id="list_modes_formats_flags">list_modes(formats,flags)</h2>
 196 <div id="list_modes_formats_flags_CONTENT">
 197 <pre> my @modes = @{ SDL::Video::list_modes( $pixel_format, $flags ) };
 198
 199 </pre>
 200 <p>Returns a ref to an array of available screen dimensions for the given format and video flags,
 201 or it return undef if no modes are available.</p>
 202 <p>Example:</p>
 203 <pre> use SDL;
 204  use SDL::Video;
 205  use SDL::VideoInfo;
 206  use SDL::PixelFormat;
 207  use SDL::Rect;
 208
 209  SDL::init(SDL_INIT_VIDEO);
 210
 211  my $video_info = SDL::Video::get_video_info();
 212
 213  my @modes = @{ SDL::Video::list_modes($video_info-&gt;vfmt, SDL_NOFRAME) };
 214
 215  if($#modes &gt; 0)
 216  {
 217      print(&quot;available modes:\n&quot;);
 218      foreach my $index ( @modes )
 219      {
 220          printf(&quot;%03d: %d x %d\n&quot;, $index, $modes[$index]-&gt;w, $modes[$index]-&gt;h );
 221      }
 222  }
 223  elsif($#modes == 0)
 224  {
 225      printf(&quot;%s video modes available\n&quot;, $modes[0]);
 226  }
 227
 228  SDL::quit();
 229
 230 </pre>
 231
 232 </div>
 233 <h2 id="video_mode_ok_width_height_bpp_flags">video_mode_ok(width,height,bpp,flags)</h2>
 234 <div id="video_mode_ok_width_height_bpp_flags-2">
 235 <pre> my $bpp_ok = SDL::Video::video_mode_ok( $width, $height, $bpp, $flags );
 236
 237 </pre>
 238 <p>This function is used to check whether the requested mode is supported by the current video device. The arguments passed to this function
 239 are the same as those you would pass to <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a>.
 240 It returns <code>0</code> if the mode is not supported at all, otherwise the suggested <code>bpp</code>.</p>
 241 <p>Example:</p>
 242 <pre> use SDL;
 243  use SDL::Video;
 244
 245  SDL::init(SDL_INIT_VIDEO);
 246
 247  my $video_mode_ok = SDL::Video::video_mode_ok( 800, 600, 32, SDL_SWSURFACE );
 248
 249  unless($video_mode_ok)
 250  {
 251      printf( &quot;this video mode is not supported\n&quot; );
 252  }
 253
 254  SDL::quit();
 255
 256 </pre>
 257
 258 </div>
 259 <h2 id="set_video_mode_width_height_bpp_flag">set_video_mode(width,height,bpp,flags)</h2>
 260 <div id="set_video_mode_width_height_bpp_flag-2">
 261 <pre> my $surface = SDL::Video::set_video_mode( 800, 600, 32, SDL_SWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
 262
 263 </pre>
 264 <p>Sets up a video mode with the specified width, height, bits-per-pixel and flags.
 265 <code>set_video_mode</code> returns a <a href="/SDL-Surface.html">SDL::Surface</a> on success otherwise it returns undef on error, the error message is retrieved
 266 using <code>SDL::get_error</code>.</p>
 267
 268 </div>
 269 <h3 id="List_of_avalaibles_flags">List of avalaibles flags</h3>
 270 <div id="List_of_avalaibles_flags_CONTENT">
 271 <dl>
 272         <dt><code>SDL_SWSURFACE</code></dt>
 273         <dd>
 274                 <p>Create the video surface in system memory</p>
 275         </dd>
 276         <dt><code>SDL_HWSURFACE</code></dt>
 277         <dd>
 278                 <p>Create the video surface in video memory</p>
 279         </dd>
 280         <dt><code>SDL_ASYNCBLIT</code></dt>
 281         <dd>
 282                 <p>Enables the use of asynchronous updates of the display surface.
 283 This will usually slow down blitting on single CPU machines, but may provide a speed increase on SMP systems.</p>
 284         </dd>
 285         <dt><code>SDL_ANYFORMAT</code></dt>
 286         <dd>
 287                 <p>Normally, if a video surface of the requested bits-per-pixel (bpp) is not available, SDL will emulate one with a shadow surface.
 288 Passing <code>SDL_ANYFORMAT</code> prevents this and causes SDL to use the video surface, regardless of its pixel depth.</p>
 289         </dd>
 290         <dt><code>SDL_HWPALETTE</code></dt>
 291         <dd>
 292                 <p>Give SDL exclusive palette access. Without this flag you may not always get the colors you request with SDL::set_colors or SDL::set_palette.</p>
 293         </dd>
 294         <dt><code>SDL_DOUBLEBUF</code></dt>
 295         <dd>
 296                 <p>Enable hardware double buffering; only valid with <code>SDL_HWSURFACE</code>. Calling <a href="#flip_surface">SDL::Video::flip</a> will flip the buffers and update
 297 the screen.
 298 All drawing will take place on the surface that is not displayed at the moment.
 299 If double buffering could not be enabled then <a href="#flip_surface">SDL::Video::flip</a> will just perform a
 300 <a href="#update_rect_surface_x_y_width_height">SDL::Video::update_rect</a> on the entire screen.</p>
 301         </dd>
 302         <dt><code>SDL_FULLSCREEN</code></dt>
 303         <dd>
 304                 <p>SDL will attempt to use a fullscreen mode. If a hardware resolution change is not possible (for whatever reason),
 305 the next higher resolution will be used and the display window centered on a black background.</p>
 306         </dd>
 307         <dt><code>SDL_OPENGL</code></dt>
 308         <dd>
 309                 <p>Create an OpenGL rendering context. You should have previously set OpenGL video attributes with
 310 <a href="#GL_set_attribute_attr_value">SDL::Video::GL_set_attribute</a>.</p>
 311         </dd>
 312         <dt><code>SDL_OPENGLBLIT</code></dt>
 313         <dd>
 314                 <p>Create an OpenGL rendering context, like above, but allow normal blitting operations.
 315 The screen (2D) surface may have an alpha channel, and SDL::update_rects must be used for updating changes to the screen surface.
 316 NOTE: This option is kept for compatibility only, and will be removed in next versions. Is not recommended for new code.</p>
 317         </dd>
 318         <dt><code>SDL_RESIZABLE</code></dt>
 319         <dd>
 320                 <p>Create a resizable window.
 321 When the window is resized by the user a <code>SDL_VIDEORESIZE</code> event is generated and
 322 <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a> can be called again with the new size.</p>
 323         </dd>
 324         <dt><code>SDL_NOFRAME</code></dt>
 325         <dd>
 326                 <p>If possible, SDL_NOFRAME causes SDL to create a window with no title bar or frame decoration.
 327 Fullscreen modes automatically have this flag set.</p>
 328         </dd>
 329 </dl>
 330 <p><strong>Note 1</strong>: Use <code>SDL_SWSURFACE</code> if you plan on doing per-pixel manipulations, or blit surfaces with alpha channels, and require a high framerate.
 331 When you use hardware surfaces (by passing the flag <code>SDL_HWSURFACE</code> as parameter), SDL copies the surfaces from video memory to system memory
 332 when you lock them, and back when you unlock them. This can cause a major performance hit. Be aware that you may request a hardware surface,
 333 but receive a software surface because the video driver doesn't support hardware surface. Many platforms can only provide a hardware surface
 334 when using <code>SDL_FULLSCREEN</code>. The <code>SDL_HWSURFACE</code> flag is best used when the surfaces you'll be blitting can also be stored in video memory.</p>
 335 <p><strong>Note 2</strong>: If you want to control the position on the screen when creating a windowed surface, you may do so by setting the environment
 336 variables <code>SDL_VIDEO_CENTERED=center</code> or <code>SDL_VIDEO_WINDOW_POS=x,y</code>. You can also set them via <code>SDL::putenv</code>.</p>
 337 <p><strong>Note 3</strong>: This function should be called in the main thread of your application.</p>
 338 <p><strong>User note 1</strong>: Some have found that enabling OpenGL attributes like <code>SDL_GL_STENCIL_SIZE</code> (the stencil buffer size) before the video mode has
 339 been set causes the application to simply ignore those attributes, while enabling attributes after the video mode has been set works fine.</p>
 340 <p><strong>User note 2</strong>: Also note that, in Windows, setting the video mode resets the current OpenGL context. You must execute again the OpenGL
 341 initialization code (set the clear color or the shade model, or reload textures, for example) after calling SDL::set_video_mode. In Linux,
 342 however, it works fine, and the initialization code only needs to be executed after the first call to
 343 <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a> (although there is no harm in executing the initialization code after
 344 each call to <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a>, for example for a multiplatform application). </p>
 345
 346 </div>
 347 <h2 id="convert_surface_surface_format_flags">convert_surface(surface,format,flags)</h2>
 348 <div id="convert_surface_surface_format_flags-2">
 349 <pre> $converted_surface = SDL::Video::convert_surface( $surface, $format, $flags );
 350
 351 </pre>
 352 <p>Creates a new SDL::surface of the specified <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a>, and then copies and maps the given surface to it.
 353 It is also useful for making a copy of a surface.</p>
 354 <p>The flags parameter is passed to <code>SDL::Surface-&gt;new()</code> and has those semantics.
 355 This function is used internally by <code>SDL::Video::display_format</code>.
 356 This function can only be called after <code>SDL::init</code>. </p>
 357 <p>it returns a <code>SDL::Surface</code> on success or <code>undef</code> on error.</p>
 358
 359 </div>
 360 <h2 id="display_format">display_format</h2>
 361 <div id="display_format_CONTENT">
 362 <pre> $new_surface = SDL::Video::display_format( $surface );
 363
 364 </pre>
 365 <p>This function takes a surface and copies it to a new surface of the pixel format and colors of the video framebuffer, suitable for fast
 366 blitting onto the display surface. It calls <code>SDL::Video::convert_surface</code>.</p>
 367 <p>If you want to take advantage of hardware colorkey or alpha blit acceleration, you should set the colorkey and alpha value before calling
 368 this function.</p>
 369 <p>If you want an alpha channel, see <code>SDL::Video::display_format_alpha</code>.
 370 Return Value</p>
 371 <p><strong>Note</strong>: Remember to use a different variable for the returned surface, otherwise you have a memory leak, since the original surface isn't freed. </p>
 372
 373 </div>
 374 <h2 id="display_format_alpha">display_format_alpha</h2>
 375 <div id="display_format_alpha_CONTENT">
 376 <pre> $new_surface = SDL::Video::display_format_alpha( $surface );
 377
 378 </pre>
 379 <p>This function takes a surface and copies it to a new surface of the pixel format and colors of the video framebuffer plus an alpha channel,
 380 suitable for fast blitting onto the display surface. It calls <code>SDL::Video::convert_surface</code>.</p>
 381 <p>If you want to take advantage of hardware colorkey or alpha blit acceleration, you should set the colorkey and alpha value before calling
 382 this function.</p>
 383 <p>This function can be used to convert a colorkey to an alpha channel, if the <code>SDL_SRCCOLORKEY</code> flag is set on the surface. The generated
 384 surface will then be transparent (alpha=0) where the pixels match the colorkey, and opaque (alpha=255) elsewhere.</p>
 385 <p><strong>Note</strong>: The video surface must be initialised using <code>SDL::Video::set_video_mode</code> before this function is called, or it will segfault.</p>
 386
 387 </div>
 388 <h2 id="load_BMP_filename">load_BMP(filename)</h2>
 389 <div id="load_BMP_filename_CONTENT">
 390 <pre> $surface = SDL::Video::load_BMP( $filename );
 391
 392 </pre>
 393 <p>Loads a <code>SDL::Surface</code> from a named Windows BMP file.
 394 <code>SDL::Video::load_BMP</code> returns a <code>SDL::Surface</code> on success or <code>undef</code> on error.</p>
 395 <p><strong>Note</strong>: When loading a 24-bit Windows BMP file, pixel data points are loaded as blue, green, red, and NOT red, green, blue (as one might expect). </p>
 396 <pre> use SDL;
 397  use SDL::Video;
 398  use SDL::Rect;
 399  use SDL::Surface;
 400
 401  my $screen_width  = 640;
 402  my $screen_height = 480;
 403
 404  SDL::init(SDL_INIT_VIDEO);
 405
 406  my $screen  = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
 407
 408  my $picture = SDL::Video::load_BMP('test.bmp');
 409
 410  die(SDL::get_error) unless $picture;
 411
 412  my $rect    = SDL::Rect-&gt;new(0, 0, $screen_width, $screen_height);
 413
 414  SDL::Video::blit_surface( $picture, SDL::Rect-&gt;new(0, 0, $picture-&gt;w, $picture-&gt;h),
 415                            $screen,  SDL::Rect-&gt;new(0, 0, $screen-&gt;w,  $screen-&gt;h) );
 416
 417  SDL::Video::update_rect( $screen, 0, 0, $screen_width, $screen_height );
 418
 419  sleep(2);
 420
 421  SDL::quit;
 422
 423 </pre>
 424
 425 </div>
 426 <h2 id="save_BMP_surface_filename">save_BMP(surface,filename)</h2>
 427 <div id="save_BMP_surface_filename_CONTENT">
 428 <pre> $saved_BMP = SDL::Video::save_BMP( $surface, $filename );
 429
 430 </pre>
 431 <p>Saves the given <code>SDL::Surface</code> as a Windows BMP file named filename.
 432 it returns 0 on success or -1 on error.</p>
 433
 434 </div>
 435 <h2 id="set_color_key_surface_flag_key">set_color_key(surface,flag,key)</h2>
 436 <div id="set_color_key_surface_flag_key_CONTE">
 437 <pre> $set_color_key = SDL::Video::set_color_key( $surface, $flag, $key );
 438
 439 </pre>
 440 <p>Sets the color key (transparent pixel) in a blittable surface and enables or disables RLE blit acceleration.</p>
 441 <p>RLE acceleration can substantially speed up blitting of images with large horizontal runs of transparent pixels (i.e., pixels that match
 442 the key value).
 443 The key must be of the same pixel format as the surface, <code>SDL::Video::map_RGB</code> is often useful for obtaining an acceptable value.
 444 If flag is <code>SDL_SRCCOLORKEY</code> then key is the transparent pixel value in the source image of a blit.</p>
 445 <p>If <code>flag</code> is OR'd with <code>SDL_RLEACCEL</code> then the surface will be drawn using RLE acceleration when drawn with SDL::Blit_surface.
 446 The surface will actually be encoded for RLE acceleration the first time <code>SDL::Video::blit_surface</code> or <code>SDL::Video::display_format</code>
 447 is called on the surface.
 448 If <code>flag</code> is <code>0</code>, this function clears any current color key. </p>
 449 <p><code>SDL::Video::set_color_key</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
 450
 451 </div>
 452 <h2 id="set_alpha_surface_flag_key">set_alpha(surface,flag,key)</h2>
 453 <div id="set_alpha_surface_flag_key_CONTENT">
 454 <pre> $set_alpha = SDL::Video::set_alpha( $surface, $flag, $key );
 455
 456 </pre>
 457 <p><code>set_alpha</code> is used for setting the per-surface alpha value and/or enabling and disabling alpha blending.</p>
 458 <p>The surface parameter specifies which SDL::surface whose alpha attributes you wish to adjust.
 459 flags is used to specify whether alpha blending should be used ( <code>SDL_SRCALPHA</code> ) and whether the surface should use RLE acceleration for
 460 blitting ( <code>SDL_RLEACCEL</code> ).
 461 flags can be an OR'd combination of these two options, one of these options or <code>0</code>.
 462 If <code>SDL_SRCALPHA</code> is not passed as a flag then all alpha information is ignored when blitting the surface.
 463 The alpha parameter is the per-surface alpha value; a surface need not have an alpha channel to use per-surface alpha and blitting can
 464 still be accelerated with <code>SDL_RLEACCEL</code>.</p>
 465 <p><strong>Note</strong>: The per-surface alpha value of 128 is considered a special case and is optimised, so it's much faster than other per-surface values.</p>
 466 <p>Alpha affects surface blitting in the following ways: </p>
 467 <dl>
 468         <dt>RGBA-&gt;RGB with SDL_SRCALPHA</dt>
 469         <dd>
 470                 <p>The source is alpha-blended with the destination, using the alpha channel.
 471 SDL_SRCCOLORKEY and the per-surface alpha are ignored.</p>
 472         </dd>
 473         <dt>RGBA-&gt;RGB without SDL_SRCALPHA</dt>
 474         <dd>
 475                 <p>The RGB data is copied from the source. The source alpha channel and the per-surface alpha value are ignored.
 476 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.</p>
 477         </dd>
 478         <dt>RGB-&gt;RGBA with SDL_SRCALPHA</dt>
 479         <dd>
 480                 <p>The source is alpha-blended with the destination using the per-surface alpha value.
 481 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
 482 The alpha channel of the copied pixels is set to opaque.</p>
 483         </dd>
 484         <dt>RGB-&gt;RGBA without SDL_SRCALPHA</dt>
 485         <dd>
 486                 <p>The RGB data is copied from the source and the alpha value of the copied pixels is set to opaque.
 487 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.</p>
 488         </dd>
 489         <dt>RGBA-&gt;RGBA with SDL_SRCALPHA</dt>
 490         <dd>
 491                 <p>The source is alpha-blended with the destination using the source alpha channel.
 492 The alpha channel in the destination surface is left untouched. SDL_SRCCOLORKEY is ignored.</p>
 493         </dd>
 494         <dt>RGBA-&gt;RGBA without SDL_SRCALPHA</dt>
 495         <dd>
 496                 <p>The RGBA data is copied to the destination surface.
 497 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.</p>
 498         </dd>
 499         <dt>RGB-&gt;RGB with SDL_SRCALPHA</dt>
 500         <dd>
 501                 <p>The source is alpha-blended with the destination using the per-surface alpha value.
 502 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.</p>
 503         </dd>
 504         <dt>RGB-&gt;RGB without SDL_SRCALPHA</dt>
 505         <dd>
 506                 <p>The RGB data is copied from the source.
 507 If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.</p>
 508         </dd>
 509 </dl>
 510 <p><strong>Note</strong>: When blitting, the presence or absence of <code>SDL_SRCALPHA</code> is relevant only on the source surface, not the destination.
 511 <strong>Note</strong>: Note that RGBA-&gt;RGBA blits (with <code>SDL_SRCALPHA</code> set) keep the alpha of the destination surface. This means that you cannot compose
 512 two arbitrary RGBA surfaces this way and get the result you would expect from &quot;overlaying&quot; them; the destination alpha will work as a mask.</p>
 513 <p><strong>Note</strong>: Also note that per-pixel and per-surface alpha cannot be combined; the per-pixel alpha is always used if available. </p>
 514 <p><code>SDL::Video::set_alpha</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
 515
 516 </div>
 517 <h2 id="fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</h2>
 518 <div id="fill_rect_dest_dest_rect_pixel_CONTE">
 519 <pre> $fill_rect = SDL::Video::fill_rect( $dest, $dest_rect, $pixel );
 520
 521 </pre>
 522 <p>This function performs a fast fill of the given <a href="/SDL-Rect.html">SDL::Rect</a> with the given <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a>. If dest_rect is NULL, the whole surface
 523 will be filled with color.</p>
 524 <p>The color should be a pixel of the format used by the surface, and can be generated by the <code>SDL::Video::map_RGB</code> or <code>SDL::Video::map_RGBA</code>
 525 functions. If the color value contains an alpha value then the destination is simply &quot;filled&quot; with that alpha information, no blending takes
 526 place.</p>
 527 <p>If there is a clip rectangle set on the destination (set via <code>SDL::Video::set_clip_rect</code>), then this function will clip based on the
 528 intersection of the clip rectangle and the dstrect rectangle, and the dstrect rectangle will be modified to represent the area actually filled.</p>
 529 <p>If you call this on the video surface (ie: the value of <code>SDL::Video::get_video_surface</code>) you may have to update the video surface to see the
 530 result. This can happen if you are using a shadowed surface that is not double buffered in Windows XP using build 1.2.9. </p>
 531 <p><code>SDL::Video::fill_rect</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
 532 <p>for an example see <a href="#SYNOPSIS">SYNOPSIS</a>.</p>
 533
 534 </div>
 535 <h1 id="Surface_locking_and_unlocking">Surface locking and unlocking</h1><p><a href="#TOP" class="toplink">Top</a></p>
 536 <div id="Surface_locking_and_unlocking_CONTEN">
 537
 538 </div>
 539 <h2 id="lock_surface_surface">lock_surface(surface)</h2>
 540 <div id="lock_surface_surface_CONTENT">
 541 <pre> int SDL::Video::lock_surface( $surface );
 542
 543 </pre>
 544 <p><code>SDL::Video::lock_surface</code> sets up the given <a href="/SDL-Surface.html">SDL::Surface</a> for directly accessing the pixels.
 545 Between calls to SDL::lock_surface and SDL::unlock_surface, you can write to ( <code>surface-</code>set_pixels&gt;) and read from ( <code>surface-</code>get_pixels&gt; ),
 546 using the pixel format stored in <code>surface-</code>format&gt;.
 547 Once you are done accessing the surface, you should use <code>SDL::Video::unlock_surface</code> to release the lock.</p>
 548 <p>Not all surfaces require locking. If <code>SDL::Video::MUSTLOCK(surface)</code> evaluates to <code>0</code>, then reading and writing pixels to the surface can
 549 be performed at any time, and the pixel format of the surface will not change.
 550 No operating system or library calls should be made between the lock/unlock pairs, as critical system locks may be held during this time.
 551 <code>SDL::Video::lock_surface</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
 552 <p><strong>Note</strong>: Since SDL 1.1.8, the surface locks are recursive. This means that you can lock a surface multiple times, but each lock must have
 553 a matching unlock.</p>
 554 <pre> use strict;
 555  use warnings;
 556  use Carp;
 557
 558  use SDL v2.3;
 559  use SDL::Video;
 560  use SDL::Event;
 561  use SDL::Events;
 562  use SDL::Surface;
 563
 564  my $screen;
 565
 566  sub putpixel
 567  {
 568      my($x, $y, $color) = @_;
 569      my $lineoffset     = $y * ($screen-&gt;pitch / 4);
 570      $screen-&gt;set_pixels( $lineoffset+ $x, $color);
 571  }
 572
 573  sub render
 574  {
 575      if( SDL::Video::MUSTLOCK( $screen) )
 576      {
 577          return if (SDL::Video::lock_surface( $screen ) &lt; 0)
 578      }
 579
 580      my $ticks                = SDL::get_ticks();
 581      my ($i, $y, $yofs, $ofs) = (0,0,0,0);
 582      for ($i = 0; $i &lt; 480; $i++)
 583      {
 584          for (my $j = 0, $ofs = $yofs; $j &lt; 640; $j++, $ofs++)
 585          {
 586              $screen-&gt;set_pixels( $ofs, (  $i * $i + $j * $j + $ticks ) );
 587          }
 588          $yofs += $screen-&gt;pitch / 4;
 589      }
 590
 591      putpixel(10, 10, 0xff0000);
 592      putpixel(11, 10, 0xff0000);
 593      putpixel(10, 11, 0xff0000);
 594      putpixel(11, 11, 0xff0000);
 595
 596      SDL::Video::unlock_surface($screen) if (SDL::Video::MUSTLOCK($screen));
 597
 598      SDL::Video::update_rect($screen, 0, 0, 640, 480);
 599
 600      return 0;
 601  }
 602
 603  sub main
 604  {
 605      carp 'Unable to init SDL: '.SDL::get_error() if( SDL::init(SDL_INIT_VIDEO) &lt; 0);
 606
 607      $screen = SDL::Video::set_video_mode( 640, 480, 32, SDL_SWSURFACE);
 608
 609      carp 'Unable to set 640x480x32 video' . SDL::get_error() if(!$screen);
 610
 611      while(1)
 612      {
 613          render();
 614
 615          my $event = SDL::Event-&gt;new();
 616
 617          while( SDL::Events::poll_event($event) )
 618          {
 619              my $type = $event-&gt;type;
 620              return 0 if( $type == SDL_KEYDOWN || $type == SDL_QUIT);
 621          }
 622          SDL::Events::pump_events();
 623      }
 624  }
 625
 626  main();
 627
 628  SDL::quit;
 629
 630 </pre>
 631
 632 </div>
 633 <h2 id="unlock_surface_surface">unlock_surface(surface)</h2>
 634 <div id="unlock_surface_surface_CONTENT">
 635 <pre> void SDL::Video::unlock_surface( $surface );
 636
 637 </pre>
 638 <p>Surfaces that were previously locked using <code>SDL::Video::lock_surface</code> must be unlocked with <code>SDL::Video::unlock_surface</code>. Surfaces should
 639 be unlocked as soon as possible.
 640 <code>SDL::Video::unlock_surface</code> doesn't return anything.</p>
 641 <p><strong>Note</strong>: Since 1.1.8, the surface locks are recursive. See <code>SDL::Video::lock_surface</code> for more information. </p>
 642
 643 </div>
 644 <h2 id="MUSTLOCK_surface">MUSTLOCK(surface)</h2>
 645 <div id="MUSTLOCK_surface_CONTENT">
 646 <pre> int SDL::Video::MUSTLOCK( $surface );
 647
 648 </pre>
 649 <p><code>MUSTLOCK</code> returns <code>0</code> if the surface does not have to be locked during pixel operations, otherwise <code>1</code>.</p>
 650
 651 </div>
 652 <h1 id="Screen_Updating_Functions">Screen Updating Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
 653 <div id="Screen_Updating_Functions_CONTENT">
 654
 655 </div>
 656 <h2 id="set_clip_rect_surface_rect">set_clip_rect(surface,rect)</h2>
 657 <div id="set_clip_rect_surface_rect_CONTENT">
 658 <pre> SDL::Video::set_clip_rect( $surface, $rect );
 659
 660 </pre>
 661 <p>Sets the clipping rectangle for the given <a href="/SDL-Surface.html">SDL::Surface</a>. When this surface is the destination of a blit, only the area within the clip
 662 rectangle will be drawn into.
 663 The rectangle pointed to by rect will be clipped to the edges of the surface so that the clip rectangle for a surface can never fall
 664 outside the edges of the surface.
 665 If rect is NULL the clipping rectangle will be set to the full size of the surface.
 666 <code>SDL::Video::set_clip_rect</code> doesn't returns anything.</p>
 667
 668 </div>
 669 <h2 id="get_clip_rect_surface_rect">get_clip_rect(surface,rect)</h2>
 670 <div id="get_clip_rect_surface_rect_CONTENT">
 671 <pre> SDL::Video::get_clip_rect( $surface, $rect );
 672
 673 </pre>
 674 <p>Gets the clipping rectangle for the given <a href="/SDL-Surface.html">SDL::Surface</a>. When this surface is the destination of a blit, only the area within the clip
 675 rectangle is drawn into.
 676 The rectangle pointed to by rect will be filled with the clipping rectangle of the surface.
 677 <code>SDL::Video::get_clip_rect</code> doesn't returns anything;</p>
 678 <pre> use SDL;
 679  use SDL::Video;
 680  use SDL::Rect;
 681  use SDL::Surface;
 682
 683  my $screen_width  = 640;
 684  my $screen_height = 480;
 685
 686  SDL::init(SDL_INIT_VIDEO);
 687
 688  my $screen  = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
 689
 690  my $rect = SDL::Rect-&gt;new(0, 0, 0, 0);
 691
 692  SDL::Video::get_clip_rect($screen, $rect);
 693
 694  printf( &quot;rect is %d, %d, %d, %d\n&quot;, $rect-&gt;x, $rect-&gt;y, $rect-&gt;w, $rect-&gt;h);
 695
 696  SDL::quit;
 697
 698 </pre>
 699
 700 </div>
 701 <h2 id="blit_surface_src_src_rect_dest_dest_">blit_surface(src,src_rect,dest,dest_rect)</h2>
 702 <div id="blit_surface_src_src_rect_dest_dest_-2">
 703 <pre> SDL::Video::blit_surface( $src_surface, $src_rect, $dest_surface, $dest_rect );
 704
 705 </pre>
 706 <p>This performs a fast blit from the given source <a href="/SDL-Surface.html">SDL::Surface</a> to the given destination <a href="/SDL-Surface.html">SDL::Surface</a>.
 707 The width and height in <code>src_surface</code> determine the size of the copied rectangle. Only the position is used in the <code>dst_rect</code>
 708 (the width and height are ignored). Blits with negative <code>dst_rect</code> coordinates will be clipped properly.
 709 If <code>src_rect</code> is NULL, the entire surface is copied. If <code>dst_rect</code> is NULL, then the destination position (upper left corner) is (0, 0).
 710 The final blit rectangle is saved in <code>dst_rect</code> after all clipping is performed (<code>src_rect</code> is not modified).
 711 The blit function should not be called on a locked surface. I.e. when you use your own drawing functions you may need to lock a surface,
 712 but this is not the case with <code>SDL::Video::blit_surface</code>. Like most surface manipulation functions in SDL, it should not be used together
 713 with OpenGL.</p>
 714 <p>The results of blitting operations vary greatly depending on whether <code>SDL_SRCALPHA</code> is set or not. See <code>SDL::Video::set_alpha</code> for an
 715 explanation of how this affects your results. Colorkeying and alpha attributes also interact with surface blitting.
 716 <code>SDL::Video::blit_surface</code> doesn't returns anything.</p>
 717 <p>For an example see <a href="#load_BMP_filename">load_BMP</a>.</p>
 718
 719 </div>
 720 <h2 id="update_rect_surface_x_y_width_height">update_rect(surface,x,y,width,height)</h2>
 721 <div id="update_rect_surface_x_y_width_height-2">
 722 <pre> update_rect( $surface, $left, $top, $width, $height );
 723
 724 </pre>
 725 <p>Makes sure the given area is updated on the given screen.
 726 The rectangle must be confined within the screen boundaries because there's no clipping.
 727 update_rect doesn't returns any value.</p>
 728 <p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a></p>
 729 <p><strong>Note2</strong>: If <code>x</code>, <code>y</code>, <code>width</code> and <code>height</code> are all equal to 0, <code>update_rect</code> will update the entire screen. </p>
 730 <p>For an example see <a href="#SYNOPSIS">SYNOPSIS</a></p>
 731
 732 </div>
 733 <h2 id="update_rects_surface_rects">update_rects(surface,rects) </h2>
 734 <div id="update_rects_surface_rects_CONTENT">
 735 <pre> update_rects( $surface, @rects );
 736
 737 </pre>
 738 <p>Makes sure the given list of rectangles is updated on the given screen.
 739 The rectangle must be confined within the screen boundaries because there's no clipping.
 740 <code>update_rects</code> doesn't returns any value.</p>
 741 <p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a>.</p>
 742 <p>Example:</p>
 743 <pre> use SDL;
 744  use SDL::Video;
 745  use SDL::Surface;
 746  use SDL::Rect;
 747
 748  # the size of the window box or the screen resolution if fullscreen
 749  my $screen_width   = 800;
 750  my $screen_height  = 600;
 751
 752  SDL::init(SDL_INIT_VIDEO);
 753
 754  # setting video mode
 755  my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
 756
 757  # drawing the whole screen blue
 758  my $mapped_color   = SDL::Video::map_RGB($screen_surface-&gt;format(), 0, 0, 255); # blue
 759  SDL::Video::fill_rect($screen_surface,
 760                        SDL::Rect-&gt;new(0, 0, $screen_width, $screen_height),
 761                        $mapped_color);
 762
 763  my @rects = ();
 764  push(@rects, SDL::Rect-&gt;new(200,   0, 400, 600));
 765  push(@rects, SDL::Rect-&gt;new(  0, 150, 800, 300));
 766
 767  # updating parts of the screen (should look like a cross)
 768  SDL::Video::update_rects($screen_surface, @rects);
 769
 770  sleep(2);
 771
 772  SDL::quit();
 773
 774 </pre>
 775
 776 </div>
 777 <h2 id="flip_surface">flip(surface)</h2>
 778 <div id="flip_surface_CONTENT">
 779 <pre> $flip = SDL::Video::flip( $screen_surface );
 780
 781 </pre>
 782 <p>On hardware that supports double-buffering, this function sets up a flip and returns.
 783 The hardware will wait for vertical retrace, and then swap video buffers before the next video surface blit or lock will return.
 784 On hardware that doesn't support double-buffering or if <code>SDL_SWSURFACE</code> was set, this is equivalent to calling
 785 <code>SDL::Video::update_rect( $screen, 0, 0, 0, 0 )</code>.</p>
 786 <p>A software screen surface is also updated automatically when parts of a SDL window are redrawn, caused by overlapping windows or by
 787 restoring from an iconified state. As a result there is no proper double buffer behavior in windowed mode for a software screen, in
 788 contrast to a full screen software mode.</p>
 789 <p>The <code>SDL_DOUBLEBUF</code> flag must have been passed to <code>SDL::Video::set_video_mode</code>, when setting the video mode for this function to
 790 perform hardware flipping.</p>
 791 <p><code>flip</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
 792 <p><strong>Note</strong>: If you want to swap the buffers of an initialized OpenGL context, use the function <code>SDL::Video::GL_swap_buffers</code> instead. </p>
 793 <p>Example:</p>
 794 <pre> use SDL;
 795  use SDL::Video;
 796  use SDL::Surface;
 797
 798  # the size of the window box or the screen resolution if fullscreen
 799  my $screen_width   = 800;
 800  my $screen_height  = 600;
 801
 802  SDL::init(SDL_INIT_VIDEO);
 803
 804  # setting video mode
 805  my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_DOUBLEBUF|SDL_FULLSCREEN);
 806
 807  # do some video operations here
 808
 809  # doing page flipping
 810  unless( SDL::Video::flip($screen_surface) == 0 )
 811  {
 812      printf( STDERR &quot;failed to swap buffers: %s\n&quot;, SDL::get_error() );
 813  }
 814
 815  SDL::quit();
 816
 817 </pre>
 818
 819 </div>
 820 <h1 id="Palette_Color_and_Pixel_Functions">Palette, Color and Pixel Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
 821 <div id="Palette_Color_and_Pixel_Functions_CO">
 822
 823 </div>
 824 <h2 id="set_colors_surface_start_colors">set_colors(surface,start,colors)</h2>
 825 <div id="set_colors_surface_start_colors_CONT">
 826 <pre> $set_colors = SDL::Video::set_colors( $surface, $start, $color1, $color2, ... )
 827
 828 </pre>
 829 <p>Sets a portion of the colormap for the given 8-bit surface. </p>
 830 <p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
 831 If <code>SDL_HWPALETTE</code> was set in <code>SDL::Video::set_video_mode</code> flags, <code>SDL::Video::set_colors</code> will always return 1, and the palette is
 832 guaranteed to be set the way you desire, even if the window colormap has to be warped or run under emulation.
 833 The color components of a <a href="/SDL-Color.html">SDL::Color</a> structure are 8-bits in size, giving you a total of 2563 = 16777216 colors.
 834 Palettized (8-bit) screen surfaces with the <code>SDL_HWPALETTE</code> flag have two palettes, a logical palette that is used for mapping blits to/from
 835 the surface and a physical palette (that determines how the hardware will map the colors to the display).
 836 <code>SDL::Video::set_colors</code> modifies both palettes (if present), and is equivalent to calling <code>SDL::Video::set_palette</code> with the flags set to
 837 ( <code>SDL_LOGPAL | SDL_PHYSPAL</code> ). </p>
 838 <p>If <code>surface</code> is not a palettized surface, this function does nothing, returning 0.
 839 If all of the colors were set as passed to <code>SDL::Video::set_colors</code>, it will return 1.
 840 If not all the color entries were set exactly as given, it will return 0, and you should look at the surface palette to determine the
 841 actual color palette.</p>
 842
 843 </div>
 844 <h2 id="set_palette_surface_flags_start_colo">set_palette(surface,flags,start,colors)</h2>
 845 <div id="set_palette_surface_flags_start_colo-2">
 846 <pre> $set_palette = set_palette( $surface, $flags, $start, $color1, $color2, ... );
 847
 848 </pre>
 849 <p>Sets a portion of the palette for the given 8-bit surface.</p>
 850 <p>Palettized (8-bit) screen surfaces with the <code>SDL_HWPALETTE</code> flag have two palettes, a logical palette that is used for mapping blits to/from
 851 the surface and a physical palette (that determines how the hardware will map the colors to the display).
 852 Non screen surfaces have a logical palette only. <code>SDL::Video::blit</code> always uses the logical palette when blitting surfaces (if it has to
 853 convert between surface pixel formats). Because of this, it is often useful to modify only one or the other palette to achieve various
 854 special color effects (e.g., screen fading, color flashes, screen dimming).</p>
 855 <p>This function can modify either the logical or physical palette by specifying <code>SDL_LOGPAL</code> or <code>SDL_PHYSPAL</code> the in the flags parameter.</p>
 856 <p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
 857 If <code>SDL_HWPALETTE</code> was set in <code>SDL::Video::set_video_mode</code> flags, <code>SDL::Video::set_palette</code> will always return 1, and the palette is
 858 guaranteed to be set the way you desire, even if the window colormap has to be warped or run under emulation.
 859 The color components of a <code>SDL::Color</code> structure are 8-bits in size, giving you a total of 2563 = 16777216 colors. </p>
 860 <p>If <code>surface</code> is not a palettized surface, this function does nothing, returning <code>0</code>. If all of the colors were set as passed to <code>set_palette</code>,
 861 it will return <code>1</code>. If not all the color entries were set exactly as given, it will return <code>0</code>, and you should look at the surface palette
 862 to determine the actual color palette.</p>
 863
 864 </div>
 865 <h2 id="set_gamma_r_g_b">set_gamma(r,g,b)</h2>
 866 <div id="set_gamma_r_g_b_CONTENT">
 867 <pre> $set_gamma = SDL::Video::set_gamma( $red_gamma, $green_gamma, $blue_gamma );
 868
 869 </pre>
 870 <p>Sets the &quot;gamma function&quot; for the display of each color component. Gamma controls the brightness/contrast of colors displayed on the screen.
 871 A gamma value of 1.0 is identity (i.e., no adjustment is made).</p>
 872 <p>This function adjusts the gamma based on the &quot;gamma function&quot; parameter, you can directly specify lookup tables for gamma adjustment
 873 with SDL::set_gamma_ramp.</p>
 874 <p><strong>Note</strong>: Not all display hardware is able to change gamma.</p>
 875 <p><code>SDL::Video::set_gamma</code> returns <code>-1</code> on error.</p>
 876 <p><strong>Warning</strong>: Under Linux (X.org Gnome and Xfce), gamma settings affects the entire display (including the desktop)! </p>
 877 <p>Example:</p>
 878 <pre> use SDL;
 879  use SDL::Video;
 880  use SDL::Surface;
 881  use SDL::Rect;
 882  use Time::HiRes qw( usleep );
 883
 884  # the size of the window box or the screen resolution if fullscreen
 885  my $screen_width   = 800;
 886  my $screen_height  = 600;
 887
 888  SDL::init(SDL_INIT_VIDEO);
 889
 890  # setting video mode
 891  my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
 892
 893  # drawing something somewhere
 894  my $mapped_color   = SDL::Video::map_RGB($screen_surface-&gt;format(), 128, 128, 128); # gray
 895  SDL::Video::fill_rect($screen_surface,
 896                        SDL::Rect-&gt;new($screen_width / 4, $screen_height / 4, $screen_width / 2, $screen_height / 2),
 897                        $mapped_color);
 898
 899  # update the whole screen
 900  SDL::Video::update_rect($screen_surface, 0, 0, $screen_width, $screen_height);
 901
 902  usleep(500000);
 903
 904  for(1..20)
 905  {
 906     SDL::Video::set_gamma( 1 - $_ / 20, 1, 1 );
 907         usleep(40000);
 908  }
 909
 910  for(1..20)
 911  {
 912     SDL::Video::set_gamma( $_ / 20, 1, 1 );
 913         usleep(40000);
 914  }
 915
 916  SDL::Video::set_gamma( 1, 1, 1 );
 917
 918  usleep(500000);
 919
 920  SDL::quit();
 921
 922 </pre>
 923
 924 </div>
 925 <h2 id="get_gamma_ramp_rt_gt_bt">get_gamma_ramp(rt,gt,bt)</h2>
 926 <div id="get_gamma_ramp_rt_gt_bt_CONTENT">
 927 <pre> $get_gamma_ramp = SDL::Video::get_gamma_ramp( \@red_table, \@green_table, \@blue_table );
 928
 929 </pre>
 930 <p>Gets the gamma translation lookup tables currently used by the display. Each table is an array of 256 Uint16 values.
 931 <code>SDL::Video::get_gamma_ramp</code> returns -1 on error.</p>
 932 <pre> use SDL;
 933  use SDL::Video;
 934
 935  SDL::init(SDL_INIT_VIDEO);
 936
 937  my (@red, @green, @blue);
 938
 939  my $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
 940
 941  if( -1 == $ret )
 942  {
 943      print( &quot;an error occoured&quot; );
 944  }
 945  else
 946  {
 947      printf( &quot;for gamma = 1.0: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[255], $green[255], $blue[255] );
 948      printf( &quot;for gamma = 0.5: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[127], $green[127], $blue[127] );
 949      printf( &quot;for gamma = 0.0: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[0],   $green[0],   $blue[0]   );
 950  }
 951
 952  SDL::quit();
 953
 954 </pre>
 955
 956 </div>
 957 <h2 id="set_gamma_ramp_rt_gt_bt">set_gamma_ramp(rt,gt,bt)</h2>
 958 <div id="set_gamma_ramp_rt_gt_bt_CONTENT">
 959 <pre> $set_gamma_ramp = SDL::Video::set_gamma_ramp( \@red_table, \@green_table, \@blue_table );
 960
 961 </pre>
 962 <p>Sets the gamma lookup tables for the display for each color component. Each table is an array ref of 256 Uint16 values, representing a
 963 mapping between the input and output for that channel.
 964 The input is the index into the array, and the output is the 16-bit gamma value at that index, scaled to the output color precision.
 965 You may pass NULL to any of the channels to leave them unchanged.</p>
 966 <p>This function adjusts the gamma based on lookup tables, you can also have the gamma calculated based on a &quot;gamma function&quot; parameter
 967 with <code>SDL::Video::set_gamma</code>.</p>
 968 <p>Not all display hardware is able to change gamma.
 969 <code>SDL::Video::set_gamma_ramp</code> returns <code>-1</code> on error (or if gamma adjustment is not supported).</p>
 970 <p>Example:</p>
 971 <pre> use SDL;
 972  use SDL::Video;
 973
 974  SDL::init(SDL_INIT_VIDEO);
 975
 976  my (@red, @green, @blue);
 977
 978  my $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
 979
 980  $red[127] = 0xFF00;
 981
 982     $ret = SDL::Video::set_gamma_ramp( \@red, \@green, \@blue );
 983
 984     $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
 985
 986  if( -1 == $ret )
 987  {
 988      print( &quot;an error occoured&quot; );
 989  }
 990  else
 991  {
 992      printf( &quot;for gamma = 1.0: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[255], $green[255], $blue[255] );
 993      printf( &quot;for gamma = 0.5: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[127], $green[127], $blue[127] );
 994      printf( &quot;for gamma = 0.0: red=0x%04X, green=0x%04X, blue=0x%04X\n&quot;, $red[0],   $green[0],   $blue[0]   );
 995  }
 996
 997  SDL::quit();
 998
 999 </pre>
1000
1001 </div>
1002 <h2 id="map_RGB_pixel_format_r_g_b">map_RGB(pixel_format,r,g,b)</h2>
1003 <div id="map_RGB_pixel_format_r_g_b_CONTENT">
1004 <pre> $pixel = SDL::Video::map_RGB( $pixel_format, $r, $g, $b );
1005
1006 </pre>
1007 <p>Maps the RGB color value to the specified <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a> and returns the pixel value as a 32-bit int.
1008 If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
1009 If the specified pixel format has an alpha component it will be returned as all 1 bits (fully opaque). </p>
1010 <p><code>SDL::Video::map_RGB</code> returns a pixel value best approximating the given RGB color value for a given pixel format.
1011 If the <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a>'s  bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored
1012 (e.g., with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
1013 <pre> use SDL;
1014  use SDL::Video;
1015  use SDL::PixelFormat;
1016  use SDL::Surface;
1017
1018  SDL::init(SDL_INIT_VIDEO);
1019
1020  my $screen_surface = SDL::Video::set_video_mode(640, 480, 16, SDL_SWSURFACE);
1021  #                                                          ^-- 16 bits per pixel
1022
1023  $r = 0x9C;
1024  $g = 0xDC;
1025  $b = 0x67;
1026
1027  printf( &quot;for 24bpp it is: 0x%02X 0x%02X 0x%02X\n&quot;, $r, $g, $b);
1028
1029  my $_16bit = SDL::Video::map_RGB( $screen_surface-&gt;format, $r, $g, $b );
1030
1031  # 16bpp is 5 bits red, 6 bits green and 5 bits blue
1032  # we will obtain the values for each color and calculating them back to 24/32bit color system
1033  ($r, $g, $b) = @{ SDL::Video::get_RGB( $screen_surface-&gt;format, $_16bit ) };
1034
1035  printf( &quot;for 16bpp it is: 0x%02X 0x%02X 0x%02X\n&quot;, $r, $g, $b );
1036
1037  # so color #9CDC67 becomes #9CDF63
1038
1039  SDL::quit();
1040
1041 </pre>
1042
1043 </div>
1044 <h2 id="map_RGBA_pixel_format_r_g_b_a">map_RGBA(pixel_format,r,g,b,a)</h2>
1045 <div id="map_RGBA_pixel_format_r_g_b_a_CONTEN">
1046 <pre> $pixel = SDL::Video::map_RGB( $pixel_format, $r, $g, $b, $a );
1047
1048 </pre>
1049 <p>Maps the RGBA color value to the specified <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a> and returns the pixel value as a 32-bit int.
1050 If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
1051 If the specified pixel format has no alpha component the alpha value will be ignored (as it will be in formats with a palette). </p>
1052 <p>A pixel value best approximating the given RGBA color value for a given pixel format.
1053 If the pixel format bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored (e.g.,
1054 with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
1055
1056 </div>
1057 <h2 id="get_RGB_pixel_format_pixel">get_RGB(pixel_format,pixel)</h2>
1058 <div id="get_RGB_pixel_format_pixel_CONTENT">
1059 <pre> $rgb_array_ref = SDL::Video::get_RGB( $pixel_format, $pixel );
1060
1061 </pre>
1062 <p>Returns RGB values from a pixel in the specified pixel format. The pixel is an integer (e.g. 16bit RGB565, 24/32bit RGB888).
1063 This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
1064 component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
1065 <p>For an example see <code>SDL::Video::map_RGB</code>.</p>
1066
1067 </div>
1068 <h2 id="get_RGBA_pixel_format_pixel">get_RGBA(pixel_format,pixel)</h2>
1069 <div id="get_RGBA_pixel_format_pixel_CONTENT">
1070 <pre> $rgba_array_ref = SDL::Video::get_RGBA( $pixel_format, $pixel );
1071
1072 </pre>
1073 <p>Gets RGBA values from a pixel in the specified pixel format.
1074 This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
1075 component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
1076 <p>If the surface has no alpha component, the alpha will be returned as 0xff (100% opaque). </p>
1077
1078 </div>
1079 <h1 id="GL_Methods">GL Methods</h1><p><a href="#TOP" class="toplink">Top</a></p>
1080 <div id="GL_Methods_CONTENT">
1081
1082 </div>
1083 <h2 id="GL_load_library_path">GL_load_library(path)</h2>
1084 <div id="GL_load_library_path_CONTENT">
1085 <p>If you wish, you may load the OpenGL library from the given path at runtime, this must be done before <code>SDL::Video::set_video_mode</code> is called.
1086 You must then use <code>SDL::Video::GL_get_proc_address</code> to retrieve function pointers to GL functions. </p>
1087 <p>SDL::GL_load_library returns 0 on success or -1 or error.</p>
1088
1089 </div>
1090 <h2 id="GL_get_proc_address_proc">GL_get_proc_address(proc)</h2>
1091 <div id="GL_get_proc_address_proc_CONTENT">
1092 <p>Returns the address of the GL function proc, or NULL if the function is not found. If the GL library is loaded at runtime, with
1093 SDL::GL_load_library, then all GL functions must be retrieved this way. Usually this is used to retrieve function pointers to OpenGL
1094 extensions. Note that this function needs an OpenGL context to function properly, so it should be called after SDL::set_video_mode
1095 has been called (with the SDL_OPENGL flag).</p>
1096 <p>OpenGL function pointers must be declared APIENTRY . This will ensure the proper calling convention is followed on platforms where this
1097 matters (Win32) thereby avoiding stack corruption. In a Win32 build environment, APIENTRY should be defined as __stdcall. </p>
1098 <p>it returns undef if the function is not found.</p>
1099
1100 </div>
1101 <h2 id="GL_get_attribute_attr">GL_get_attribute(attr)</h2>
1102 <div id="GL_get_attribute_attr_CONTENT">
1103 <p>It returns  SDL/OpenGL attribute attr . This is useful after a call to SDL::set_video_mode to check whether your attributes have been set
1104 as you expected.
1105 SDL::GL_get_attribute returns undef if the attribute is not found.</p>
1106
1107 </div>
1108 <h2 id="GL_set_attribute_attr_value">GL_set_attribute(attr,value)</h2>
1109 <div id="GL_set_attribute_attr_value_CONTENT">
1110 <p>This function sets the given OpenGL attribute attr to value. The requested attributes will take effect after a call to SDL::set_video_mode.
1111 You should use SDL::GL_get_attribute to check the values after a SDL::set_video_mode call, since the values obtained can differ from the
1112 requested ones.
1113 See SDL_GLattr for the full list of available attributes.
1114 SDL::GL_set_attribute returns 0 on success or -1 on error.</p>
1115 <p>Note : The SDL_DOUBLEBUF flag is not required to enable double buffering when setting an OpenGL video mode. Double buffering is enabled
1116 or disabled using the SDL_GL_DOUBLEBUFFER attribute. </p>
1117
1118 </div>
1119 <h2 id="GL_swap_buffers">GL_swap_buffers</h2>
1120 <div id="GL_swap_buffers_CONTENT">
1121 <p>Swap the OpenGL buffers, if double-buffering is supported.
1122 SDL::GL_swap_buffers doesn't returns any value.</p>
1123
1124 </div>
1125 <h2 id="GL_attr_to_be_coded">GL_attr *** to be coded</h2>
1126 <div id="GL_attr_to_be_coded_CONTENT">
1127
1128
1129
1130
1131
1132 </div>
1133 <h1 id="Video_Overlay_Functions">Video Overlay Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
1134 <div id="Video_Overlay_Functions_CONTENT">
1135 <p>see <a href="/SDL-Overlay.html">SDL::Overlay</a> </p>
1136
1137 </div>
1138 <h2 id="lock_YUV_overlay_overlay">lock_YUV_overlay(overlay)</h2>
1139 <div id="lock_YUV_overlay_overlay_CONTENT">
1140 <p>Much the same as <code>SDL::lock_surface</code>, SDL::lock_YUV_overlay locks the overlay for direct access to pixel data.
1141 It returns 0 on success or -1 on error.</p>
1142
1143 </div>
1144 <h2 id="unlock_YUV_overlay_overlay">unlock_YUV_overlay(overlay)</h2>
1145 <div id="unlock_YUV_overlay_overlay_CONTENT">
1146 <p>The opposite to <code>SDL::lock_YUV_overlay</code>. Unlocks a previously locked overlay. An overlay must be unlocked before it can be displayed.
1147 It returns 0 on success or -1 on error.</p>
1148
1149 </div>
1150 <h2 id="display_YUV_overlay_overlay_dstrect">display_YUV_overlay(overlay,dstrect)</h2>
1151 <div id="display_YUV_overlay_overlay_dstrect_">
1152 <p>Blit the overlay to the display surface specified when the overlay was created. The SDL::rect structure, dstrect, specifies a rectangle
1153 on the display where the overlay is drawn. The .x and .y fields of dstrect specify the upper left location in display coordinates.
1154 The overlay is scaled (independently in x and y dimensions) to the size specified by dstrect, and is optimized for 2x scaling</p>
1155 <p>It returns 0 on success or -1 on error.</p>
1156
1157 </div>
1158 <h1 id="Window_Management_Functions">Window Management Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
1159 <div id="Window_Management_Functions_CONTENT">
1160
1161 </div>
1162 <h2 id="wm_set_caption_title_icon">wm_set_caption(title,icon)</h2>
1163 <div id="wm_set_caption_title_icon_CONTENT">
1164 <pre> SDL::Video::wm_set_caption( $title, $icon );
1165
1166 </pre>
1167 <p>Sets the title-bar and icon name of the display window.</p>
1168 <p><code>title</code> is a UTF-8 encoded null-terminated string which will serve as the window title (the text at the top of the window). The function
1169 does not change the string. You may free the string after the function returns.</p>
1170 <p><code>icon</code> is a UTF-8 encoded null-terminated string which will serve as the iconified window title (the text which is displayed in the menu
1171 bar or desktop when the window is minimized). As with title this string may be freed after the function returns. </p>
1172 <p>Example:</p>
1173 <pre> use SDL;
1174  use SDL::Video;
1175  use SDL::Surface;
1176
1177  SDL::init(SDL_INIT_VIDEO);
1178
1179  my $screen  = SDL::Video::set_video_mode(640, 480, 32, SDL_SWSURFACE);
1180
1181  SDL::Video::wm_set_caption( 'maximized title', 'minimized title' );
1182
1183  sleep(2);
1184
1185  SDL::quit;
1186
1187 </pre>
1188
1189 </div>
1190 <h2 id="wm_get_caption">wm_get_caption()</h2>
1191 <div id="wm_get_caption_CONTENT">
1192 <pre> SDL::Video::wm_get_caption( $title, $icon );
1193
1194 </pre>
1195 <p>Retrieves the title-bar and icon name of the display window.</p>
1196 <p>Example:</p>
1197 <pre> use SDL;
1198  use SDL::Video;
1199  use SDL::Surface;
1200
1201  SDL::init(SDL_INIT_VIDEO);
1202
1203  my $screen  = SDL::Video::set_video_mode(640, 480, 32, SDL_SWSURFACE);
1204
1205  SDL::Video::wm_set_caption( 'maximized title', 'minimized title' );
1206
1207  my ($title, $icon) = @{ SDL::Video::wm_get_caption() };
1208
1209  printf( &quot;title is '%s' and icon is '%s'\n&quot;, $title, $icon );
1210
1211  SDL::quit;
1212
1213 </pre>
1214
1215 </div>
1216 <h2 id="wm_set_icon_icon">wm_set_icon(icon)</h2>
1217 <div id="wm_set_icon_icon_CONTENT">
1218 <pre> SDL::Video::wm_set_icon( $icon );
1219
1220 </pre>
1221 <p>Sets the icon for the display window. Win32 icons must be 32x32.</p>
1222 <p>This function must be called before the first call to <code>SDL::Video::set_video_mode</code>. Note that this means <code>SDL::Image</code> cannot be used.</p>
1223 <p>The shape is determined by the colorkey or alpha channel of the icon, if any. If neither of those are present, the icon is made opaque
1224 (no transparency).</p>
1225 <p>Example:</p>
1226 <pre> SDL::Video::wm_set_icon(SDL::Video::load_BMP(&quot;icon.bmp&quot;));
1227
1228 </pre>
1229 <p>Another option, if your icon image does not have a colorkey set, is to use the SDL::Video::set_color_key to set the transparency.</p>
1230 <p>Example:</p>
1231 <pre> my $image = SDL::Video::load_BMP(&quot;icon.bmp&quot;);
1232
1233  my colorkey = SDL::Video::map_RGB($image-&gt;format, 255, 0, 255); # specify the color that will be transparent
1234
1235  SDL::Video::set_color_key($image, SDL_SRCCOLORKEY, $colorkey);
1236
1237  SDL::Video::wm_set_icon($image);
1238
1239 </pre>
1240
1241 </div>
1242 <h2 id="wm_grab_input_mode">wm_grab_input(mode)</h2>
1243 <div id="wm_grab_input_mode_CONTENT">
1244 <pre> $grab_mode = SDL::Video::wm_grab_input($mode);
1245
1246 </pre>
1247 <p>Grabbing means that the mouse is confined to the application window, and nearly all keyboard input is passed directly to the application,
1248 and not interpreted by a window manager, if any.</p>
1249 <p>When mode is <code>SDL_GRAB_QUERY</code> the grab mode is not changed, but the current grab mode is returned.</p>
1250 <p><code>mode</code> and the return value of <code>wm_grab_input</code> can be one of the following:</p>
1251 <ul>
1252                 <li><code>SDL_GRAB_QUERY</code> </li>
1253                 <li><code>SDL_GRAB_OFF</code>   </li>
1254                 <li><code>SDL_GRAB_ON</code></li>
1255 </ul>
1256
1257
1258 </div>
1259 <h2 id="wm_iconify_window">wm_iconify_window()</h2>
1260 <div id="wm_iconify_window_CONTENT">
1261 <pre> $iconify_window = SDL::Video::wm_iconify_window();
1262
1263 </pre>
1264 <p>If the application is running in a window managed environment SDL attempts to iconify/minimise it. If <code>wm_iconify_window</code> is successful,
1265 the application will receive a <code>SDL_APPACTIVE</code> loss event (see Application visibility events at <a href="/SDL-Event.html">SDL::Event</a>).</p>
1266 <p>Returns non-zero on success or 0 if iconification is not supported or was refused by the window manager. </p>
1267 <p>Example:</p>
1268 <pre> use SDL;
1269  use SDL::Video;
1270  use SDL::Surface;
1271
1272  SDL::init(SDL_INIT_VIDEO);
1273
1274  my $screen  = SDL::Video::set_video_mode(640, 480, 32, SDL_SWSURFACE);
1275
1276  sleep(2);
1277
1278  SDL::Video::wm_iconify_window();
1279
1280  sleep(2);
1281
1282  SDL::quit;
1283
1284 </pre>
1285
1286 </div>
1287 <h2 id="wm_toggle_fullscreen_surface">wm_toggle_fullscreen(surface)</h2>
1288 <div id="wm_toggle_fullscreen_surface_CONTENT">
1289 <pre> $toggle = SDL::Video::wm_toggle_fullscreen( $surface );
1290
1291 </pre>
1292 <p>Toggles the application between windowed and fullscreen mode, if supported. (X11 is the only target currently supported, BeOS support
1293 is experimental).</p>
1294
1295 </div>
1296 <h1 id="SEE_ALSO">SEE ALSO</h1><p><a href="#TOP" class="toplink">Top</a></p>
1297 <div id="SEE_ALSO_CONTENT">
1298
1299 </div>
1300 <h2 id="Category_Objects">Category Objects</h2>
1301 <div id="Category_Objects_CONTENT">
1302 <p><a href="/SDL-Surface.html">SDL::Surface</a>, <a href="/SDL-Overlay.html">SDL::Overlay</a>, <a href="/SDL-Color.html">SDL::Color</a>,
1303 <a href="/SDL-Rect.html">SDL::Rect</a>, <a href="/SDL-Palette.html">SDL::Palette</a>, <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a>,
1304 <a href="/SDL-VideoInfo.html">SDL::VideoInfo</a></p>
1305
1306 </div>
1307 </div>