?? gamedev_net - the simple directmedia layer from a win32 perspective, part 2 sdl video.htm
字號:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0057)http://www.gamedev.net/reference/articles/article1603.asp -->
<HTML><HEAD><TITLE>GameDev.net - The Simple DirectMedia Layer from a WIN32 Perspective, Part 2: SDL Video</TITLE>
<META http-equiv=Content-Type content="text/html; charset=windows-1252">
<META content="MSHTML 6.00.2716.2200" name=GENERATOR><LINK
href="GameDev_net - The Simple DirectMedia Layer from a WIN32 Perspective, Part 2 SDL Video_files/reference.css"
type=text/css rel=STYLESHEET><LINK href="/pics/gdicon.png" type=image/png
rel=icon>
<META DESCRIPTION=""></HEAD>
<BODY text=#000000 vLink=#666699 aLink=#000000 link=#666699 bgColor=#ffffff
background="GameDev_net - The Simple DirectMedia Layer from a WIN32 Perspective, Part 2 SDL Video_files/watermark.gif">
<TABLE cellSpacing=0 cellPadding=5 width="100%" border=0>
<TBODY>
<TR>
<TD class=tblhdr>The Simple DirectMedia Layer from a WIN32 Perspective,
Part 2: SDL Video</TD>
<TD class=tblhdr align=right><IMG height=16
src="GameDev_net - The Simple DirectMedia Layer from a WIN32 Perspective, Part 2 SDL Video_files/littleg.gif"
width=16 align=absBottom> <A href="http://www.gamedev.net/"><SPAN
style="COLOR: white; TEXT-DECORATION: none">GameDev.net</A></SPAN></TD></TR>
<TR>
<TD noWrap align=right><B>See Also:</B> <BR><A
href="http://www.gamedev.net/reference/list.asp?categoryid=78#179">Featured
Articles:Featured Articles</A> <BR><A
href="http://www.gamedev.net/reference/list.asp?categoryid=45#188">Game
Programming:Simple DirectMedia Layer</A> </TD></TR></TBODY></TABLE>
<P align=center><SPAN class=title>The Simple DirectMedia Layer from a WIN32
Perspective</SPAN> <BR><SPAN class=subtitle>Part 2: SDL Video</SPAN> <BR><SPAN
class=author>by <A href="mailto:ernestpazera@hotmail.com">Ernest Pazera</A>
<BR>December 5, 2001</SPAN></P>
<H1>Mission Statement</H1>
<P>Graphics make the game/application. There is no question about this. In
WIN32, if you intend to do 2D graphics, you normally have two choices: GDI or
DirectDraw. GDI is slow as hell, and DirectDraw is MicroSoft specific. Porting
an application that uses either GDI or DirectDraw to a non-WIN32 platform can be
painful.</P>
<P>One of your other options is SDL's video component. Keep in mind that SDL can
only be used (by itself) for 2D graphics. If you want 3D graphics, though, SDL
works well with OpenGL. For the purposes of this article, we are going to talk
only about SDL's 2D graphical capabilities.</P>
<P>Here are the TGOs*(Topical Guide Objectives) for this article.</P>
<P>
<TABLE cellSpacing=0 cellPadding=2>
<TBODY>
<TR>
<TD>TGO-02-A</TD>
<TD>Know the basic structures SDL uses for doing graphics</TD></TR>
<TR>
<TD>TGO-02-B</TD>
<TD>Know how to get information from the SDL video subsystem.</TD></TR>
<TR>
<TD>TGO-02-C</TD>
<TD>Know how to create and destroy various types of SDL surfaces</TD></TR>
<TR>
<TD>TGO-02-D</TD>
<TD>Know how to work with SDL surfaces</TD></TR>
<TR>
<TD>TGO-02-D1</TD>
<TD>Know how to do filled rectangles</TD></TR>
<TR>
<TD>TGO-02-D2</TD>
<TD>Know how to get and set pixels</TD></TR>
<TR>
<TD>TGO-02-D3</TD>
<TD>Know how to blit from one surface to another</TD></TR>
<TR>
<TD>TGO-02-D4</TD>
<TD>Know how to use color keys</TD></TR>
<TR>
<TD>TGO-02-D5</TD>
<TD>Know how to clip output</TD></TR></TBODY></TABLE>
<P>*About TGOs: The concept of TGOs I borrowed from the United States Navy. In
training programs, the specific knowledge that you are responsible for having
are all listed in a book of Topical Guide Objectives. This book is referred to
as the "Topical Guide". TGOs are good for both the reader and the author, as it
lets the reader know exactly what he or she will be learning at a glance, and it
reminds the author exactly what he will be covering.</P>
<H1>Basic Structures (TGO-02-A)</H1>
<P>As of version 1.2.3 of SDL, there are seven structures in the library that
deal with the video subsystem. These are SDL_Rect, SDL_Color, SDL_Palette,
SDL_PixelFormat, SDL_Surface, SDL_VideoInfo, and SDL_Overlay. Most of them do
exactly what you'd expect them to do. We're going to cover the first six of
these (leaving out SDL_Overlay).</P>
<H2>SDL_Rect</H2>
<P>SDL_Rect is one of the simpler structures. As you probably guessed, it
abstracts a rectangular area on the screen. Here's what it looks like:</P>
<BLOCKQUOTE><PRE class=code>typedef struct{
Sint16 x, y;
Uint16 w, h;
} SDL_Rect;
</PRE></BLOCKQUOTE>
<P>This is a pretty standard rectangle structure, unless of course you are used
to working with the WIN32 RECT structure. The x and y members contain the upper
left hand corner. The w and h members contain the width and height. All of these
members measure units in pixels (and never anything but pixels).</P>
<P>A brief note about some of the odd looking types used in SDL: because it is
cross platform, the writers of SDL had to make some integral types that would be
the same size no matter what platform they were used on. Considering differences
between platforms and the size of the int type, they came up with things like
Sint16 and Uint16, there are a number of types like these. They all take the
form:</P>
<BLOCKQUOTE><PRE class=code>[S|U]int[n]
</PRE></BLOCKQUOTE>
<P>In front of the type name, you will see either an S or a U. S stands for
"signed" and U stands for "unsigned". n is a number, either 8, 16, or 32.</P>
<P>In the case of SDL_Rect, x and y are Sint16s, and so they range from -32768
to +32767, which is more than enough to deal with rectangular areas of the
screen. The w and h members are Uint16s, and so can range from 0 to 65535.
Notice that these are always non-negative, since you cannot have a rectangle
with a negative width or height (unlike in the WIN32 RECT structure).</P>
<P>A point (x,y) lies within a rectangle (rect) if the all of the following are
true:</P>
<BLOCKQUOTE><PRE class=code>x >= rect.x
y >= rect.y
x < ( rect.x + rect.w )
y < ( rect.y + rect.h )
</PRE></BLOCKQUOTE>
<P>If a rectangles w or h members are 0, it is an empty rectangle, and it
contains no points whatsoever. There are absolutely no functions whatsoever for
working with SDL_Rects (like the ones they have for WIN32 RECTs, like OffsetRect
or UnionRect or IntersectRect), so if you need them, you have to make them
yourself.</P>
<H2>SDL_Color</H2>
<P>The second structure is just as simple. SDL_Color abstracts an RGB color
value in an independent way. Here's what it looks like:</P>
<BLOCKQUOTE><PRE class=code>typedef struct{
Uint8 r;
Uint8 g;
Uint8 b;
Uint8 unused;
} SDL_Color;
</PRE></BLOCKQUOTE>
<P>SDL_Color is a lot like the WIN32 PALETTEENTRY or RGBQUAD structure. It
contains four Uint8 values (bytes), and each member can range from 0 to 255. The
r, g, and b members represent a colors red, green, and blue value. The unused
member is just that--unused. Just sort of pretend it doesn't exist.</P>
<P>No functions exist for working with the SDL_Color structure either. If you
want them, you can make your own, or just work with the members themselves. I
personally like wrapping SDL_Color into a class.</P>
<H2>SDL_Palette</H2>
<P>In theory, the use of palettes has gone the way of the dinosaur. Still, there
are times when they are useful, and so SDL has them. Palettes in SDL are
strictly 8 bit palettes, for 256 different colors. However, you can make a
palette whatever size you like, for example you could make one 256 color master
palette, and then 8 different 8 color palettes that you use for palette
animation and overwrite only a certain portion of the actual palette with those
eight colors.</P>
<P>The SDL_Palette structure is pretty simple:</P>
<BLOCKQUOTE><PRE class=code>typedef struct{
int ncolors;
SDL_Color *colors;
} SDL_Palette;
</PRE></BLOCKQUOTE>
<P>The ncolors member is the number of colors in the palette. The colors member
is a pointer to an array of SDL_Color values. You have to work with these
members manually, allocating and deallocating colors, setting them, and so on.
SDL doesn't include any functions for working with palettes, other than those
that set the palette entries for a surface.</P>
<P>SDL_Palette is roughly akin to IDirectDrawPalette, but without any of the
encapsulation. </P>
<H2>SDL_PixelFormat</H2>
<P>This structure is highly useful. It is similar in purpose to the
DDPIXELFORMAT structure of DirectDraw. It describes everything you'd ever want
to know about how pixels are represented for a particular surface. Here's what
it looks like:</P>
<BLOCKQUOTE><PRE class=code>typedef struct{
SDL_Palette *palette;
Uint8 BitsPerPixel;
Uint8 BytesPerPixel;
Uint32 Rmask, Gmask, Bmask, Amask;
Uint8 Rshift, Gshift, Bshift, Ashift;
Uint8 Rloss, Gloss, Bloss, Aloss;
Uint32 colorkey;
Uint8 alpha;
} SDL_PixelFormat;
</PRE></BLOCKQUOTE>
<P>Everything you want to know about a pixel format is right here. First, the
palette member is a pointer to an SDL_Palette, if the format has one. If not,
this member will be NULL.</P>
<P>Next, BitsPerPixel and BytesPerPixel specify how many bits and bytes are per
pixel for this format (kind of obvious from the name, no?).</P>
<P>The next group of members are Rmask, Gmask, Bmask, and Amask. These are the
bit masks in the pixel format for each of the color components, Rmask for red,
Gmask for green, Bmask for blue, and Amask for alpha. These are useful for using
the & operator to isolate certain color components.</P>
<P>The next group, Rshift, Gshift, Bshift, and Ashift specify the bit position
in the pixel that begins the color component in question. After you take a pixel
value and & with the Rmask value, you can >> by the Rshift value to
get it in the lowest bits of the variable.</P>
<P>Rloss, Gloss, Bloss, and Aloss is another group of members used for color
conversion. These members contain the number of bits that are lost when starting
from an 8 bit value. After you have & by the Rmask, and >> by the
Rshift, you can << by Rloss, and you'll have a value in the range of 0 to
255 for your red component. This makes color conversion to and from SDL_Color
values really easy.</P>
<BLOCKQUOTE><PRE class=code>//color is an SDL_Color, and format is an SDL_PixelFormat
//convert color to native format
Uint32 native = 0 ;
Uint32 red , green , blue ;
red = color.r >> format.Rloss ;
green = color.g >> format.Gloss ;
blue = color.b >> format.Bloss ;
red <<= format.Rshift ;
green <<= format.Gshift ;
blue <<= format.Bshift ;
//convert native pixel to SDL_Color
red = native & format.Rmask ;
green = native & format.Gmask ;
blue = native & format.Bmask ;
red >>= format.Rshift ;
green >>= format.Gshift ;
blue >>= format.Bshift ;
red <<= format.Rloss ;
green <<= format.Gloss ;
blue <<= format.Bloss ;
color.r = red ;
color.g = green ;
color.b = blue ;
</PRE></BLOCKQUOTE>
<P>Pretty simple, right? Don't worry too much about this code, though. SDL
provides functions that will do these things for you.</P>
<P>The colorkey member of SDL_PixelFormat stores the transparent color for the
format. This color is in the native pixel format, not as an SDL_Color.</P>
<P>Finally, the alpha member is an eight bit value that stores an overall alpha
value for the surface.</P>
<H1>SDL_Surface</H1>
<P>Just like the IDirectDrawSurface object in DirectDraw and the HDC in GDI, the
SDL_Surface is the most important structure in the SDL video subsystem. It
abstracts a rectangular area of pixel data. Here's what it looks like:</P>
<BLOCKQUOTE><PRE class=code>typedef struct SDL_Surface {
Uint32 flags;
SDL_PixelFormat *format;
int w, h;
Uint16 pitch;
void *pixels;
SDL_Rect clip_rect;
int refcount;
} SDL_Surface;
</PRE></BLOCKQUOTE>
<P>There are actually more members than this, but they should not be publicly
accessed, and so are not shown.</P>
<P>The flags member contains a combination of bit flags that describe what type
of surface this is. These flags are listed and briefly explained in table 1.</P>
<TABLE cellSpacing=0 cellPadding=3 width=590 border=1>
<TBODY>
<TR>
<TD class=tblhdr colSpan=2>Table 1: Surface Flags</TD></TR>
<TR vAlign=top>
<TD class=tblhdr width="30%">Flag</TD>
<TD class=tblhdr width="70%">Meaning</TD></TR>
<TR vAlign=top>
<TD>SDL_SWSURFACE</TD>
<TD>Surface exists in software (non-video RAM)</TD></TR>
<TR>
<TD>SDL_HWSURFACE</TD>
<TD>Surface exists in video RAM.</TD></TR>
<TR>
<TD>SDL_ASYNCBLIT</TD>
<TD>Blits occur asynchronously.</TD></TR>
<TR>
<TD>SDL_ANYFORMAT*</TD>
<TD>This flag specifies to use whatever the current display format is for
the display surface. Typically, this is used when making a windowed SDL
application.</TD></TR>
<TR>
<TD>SDL_HWPALETTE</TD>
<TD>The surface makes use of a hardware palette.</TD></TR>
<TR>
<TD>SDL_DOUBLEBUF*</TD>
<TD>The surface is double buffered (i.e. a flipping chain).</TD></TR>
<TR>
<TD>SDL_FULLSCREEN*</TD>
<TD>The surface is full screen.</TD></TR>
<TR>
<TD>SDL_OPENGL*</TD>
<TD>The surface will be used as a destination for OpenGL rendering.</TD></TR>
<TR>
<TD>SDL_OPENGLBLIT*</TD>
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -