# HG changeset patch # User Sam Lantinga # Date 1149696628 0 # Node ID eef792d31de8c1a163f3c0ead92cecfa2b5bffae # Parent 9857d21967bb9def16e7c501981552a048e51d5f Work in progress. :) diff -r 9857d21967bb -r eef792d31de8 Makefile.in --- a/Makefile.in Mon May 29 05:08:33 2006 +0000 +++ b/Makefile.in Wed Jun 07 16:10:28 2006 +0000 @@ -125,14 +125,6 @@ rm -f $(mandir)/man3/$$file; \ done -indent: - cd $(srcdir) && \ - find . \( \ - -name '*.h' -o \ - -name '*.c' -o \ - -name '*.cc' \) \ - -exec indent {} \; - clean: rm -rf $(objects) if test -f test/Makefile; then (cd test; $(MAKE) $@); fi @@ -173,6 +165,29 @@ rpm: $(distfile) rpmbuild -ta $? +# Run indent on the source to standardize coding style +indent: + @echo "Running indent... modified files:" + @cd $(srcdir) && \ + find . \( \ + -name '*.h' -o \ + -name '*.c' -o \ + -name '*.cc' \) \ + -print | \ + while read file; do \ + indent "$$file" -o "$$file.indent"; \ + if cmp "$$file" "$$file.indent" >/dev/null; then \ + rm -f "$$file.indent"; \ + else \ + echo "$$file"; \ + mv -f "$$file.indent" "$$file"; \ + fi; \ + done + +# Run indent and then commit modified files +commit: indent + svn commit + # Create a SVN snapshot that people can run update on snapshot: svn co svn://libsdl.org/trunk/SDL diff -r 9857d21967bb -r eef792d31de8 include/SDL_compat.h --- a/include/SDL_compat.h Mon May 29 05:08:33 2006 +0000 +++ b/include/SDL_compat.h Wed Jun 07 16:10:28 2006 +0000 @@ -36,22 +36,18 @@ /* *INDENT-ON* */ #endif -#define SDL_SWSURFACE 0x00000000 -#define SDL_HWSURFACE 0x00000001 -#define SDL_ASYNCBLIT 0x00000004 -#define SDL_ANYFORMAT 0x10000000 -#define SDL_HWPALETTE 0x20000000 -#define SDL_DOUBLEBUF 0x40000000 -#define SDL_FULLSCREEN 0x80000000 -#define SDL_OPENGL 0x00000002 -#define SDL_INTERNALOPENGL 0x00000008 -#define SDL_RESIZABLE 0x00000010 -#define SDL_NOFRAME 0x00000020 -#define SDL_HWACCEL 0x00000100 -#define SDL_SRCCOLORKEY 0x00001000 -#define SDL_RLEACCELOK 0x00002000 -#define SDL_RLEACCEL 0x00004000 -#define SDL_SRCALPHA 0x00010000 +#define SDL_SWSURFACE 0x00000000 +#define SDL_ANYFORMAT 0x00100000 +#define SDL_HWPALETTE 0x00200000 +#define SDL_DOUBLEBUF 0x00400000 +#define SDL_FULLSCREEN 0x00800000 +#define SDL_RESIZABLE 0x01000000 +#define SDL_NOFRAME 0x02000000 +#define SDL_OPENGL 0x04000000 +#define SDL_ASYNCBLIT 0x00000000 +#define SDL_HWACCEL 0x00000000 +#define SDL_SCREEN_SURFACE 0x10000000 /* Surface is a window screen surface */ +#define SDL_SHADOW_SURFACE 0x20000000 /* Surface is a window shadow surface */ #define SDL_APPMOUSEFOCUS 0x01 #define SDL_APPINPUTFOCUS 0x02 @@ -64,6 +60,25 @@ #define SDL_VIDEORESIZE SDL_EVENT_RESERVED2 #define SDL_VIDEOEXPOSE SDL_EVENT_RESERVED3 +typedef struct SDL_VideoInfo +{ + Uint32 hw_available:1; + Uint32 wm_available:1; + Uint32 UnusedBits1:6; + Uint32 UnusedBits2:1; + Uint32 blit_hw:1; + Uint32 blit_hw_CC:1; + Uint32 blit_hw_A:1; + Uint32 blit_sw:1; + Uint32 blit_sw_CC:1; + Uint32 blit_sw_A:1; + Uint32 blit_fill:1; + Uint32 UnusedBits3:16; + Uint32 video_mem; + + SDL_PixelFormat *vfmt; +} SDL_VideoInfo; + typedef enum { SDL_GRAB_QUERY = -1, @@ -71,9 +86,12 @@ SDL_GRAB_ON = 1 } SDL_GrabMode; +#define SDL_AllocSurface SDL_CreateRGBSurface + extern DECLSPEC const SDL_version *SDLCALL SDL_Linked_Version(void); extern DECLSPEC char *SDLCALL SDL_AudioDriverName(char *namebuf, int maxlen); extern DECLSPEC char *SDLCALL SDL_VideoDriverName(char *namebuf, int maxlen); +extern DECLSPEC const SDL_VideoInfo *SDLCALL SDL_GetVideoInfo(void); extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags); extern DECLSPEC SDL_Rect **SDLCALL SDL_ListModes(SDL_PixelFormat * format, @@ -81,6 +99,14 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags); extern DECLSPEC SDL_Surface *SDLCALL SDL_GetVideoSurface(void); +extern DECLSPEC void SDLCALL SDL_UpdateRects(SDL_Surface * screen, + int numrects, SDL_Rect * rects); +extern DECLSPEC void SDLCALL SDL_UpdateRect(SDL_Surface * screen, Sint32 x, + Sint32 y, Uint32 w, Uint32 h); +extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface * screen); +extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormat(SDL_Surface * surface); +extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormatAlpha(SDL_Surface * + surface); extern DECLSPEC void SDLCALL SDL_WM_SetCaption(const char *title, const char *icon); extern DECLSPEC void SDLCALL SDL_WM_GetCaption(char **title, char **icon); @@ -92,6 +118,9 @@ extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface * surface, int flags, SDL_Color * colors, int firstcolor, int ncolors); +extern DECLSPEC int SDLCALL SDL_SetScreenColors(SDL_Surface * screen, + SDL_Color * colors, + int firstcolor, int ncolors); extern DECLSPEC int SDLCALL SDL_GetWMInfo(SDL_SysWMinfo * info); /* Ends C function definitions when using C++ */ @@ -103,3 +132,6 @@ #include "close_code.h" #endif /* _SDL_compat_h */ + +/* vi: set ts=4 sw=4 expandtab: */ +extern DECLSPEC void SDLCALL SDL_WarpMouse(Uint16 x, Uint16 y); diff -r 9857d21967bb -r eef792d31de8 include/SDL_mouse.h --- a/include/SDL_mouse.h Mon May 29 05:08:33 2006 +0000 +++ b/include/SDL_mouse.h Wed Jun 07 16:10:28 2006 +0000 @@ -41,28 +41,53 @@ /* *INDENT-ON* */ #endif -typedef struct WMcursor WMcursor; /* Implementation dependent */ -typedef struct SDL_Cursor -{ - SDL_Rect area; /* The area of the mouse cursor */ - Sint16 hot_x, hot_y; /* The "tip" of the cursor */ - Uint8 *data; /* B/W cursor data */ - Uint8 *mask; /* B/W cursor mask */ - Uint8 *save[2]; /* Place to save cursor area */ - WMcursor *wm_cursor; /* Window-manager cursor */ -} SDL_Cursor; +typedef struct SDL_Cursor SDL_Cursor; /* Implementation dependent */ /* Function prototypes */ + +/* \fn int SDL_GetNumMice(void) + * + * \brief Get the number of mouse input devices available. + * + * \sa SDL_SelectMouse() + */ +extern DECLSPEC int SDLCALL SDL_GetNumMice(void); + +/* \fn int SDL_SelectMouse(int index) + * + * \brief Set the index of the currently selected mouse. + * + * \return The index of the currently selected mouse. + * + * \note You can query the currently selected mouse by passing an index of -1. + * + * \sa SDL_GetNumMice() + */ +extern DECLSPEC int SDLCALL SDL_SelectMouse(int index); + +/* \fn SDL_WindowID SDL_GetMouseFocusWindow(void) + * + * \brief Get the window which currently has focus for the currently selected mouse. + */ +extern DECLSPEC SDL_WindowID SDLCALL SDL_GetMouseFocusWindow(void); + /* - * Retrieve the current state of the mouse. + * \fn Uint8 SDL_GetMouseState(int *x, int *y) + * + * \brief Retrieve the current state of the mouse. + * * The current button state is returned as a button bitmask, which can * be tested using the SDL_BUTTON(X) macros, and x and y are set to the - * current mouse cursor position. You can pass NULL for either x or y. + * mouse cursor position relative to the focus window for the currently + * selected mouse. You can pass NULL for either x or y. */ extern DECLSPEC Uint8 SDLCALL SDL_GetMouseState(int *x, int *y); /* - * Retrieve the current state of the mouse. + * \fn Uint8 SDL_GetRelativeMouseState(int *x, int *y) + * + * \brief Retrieve the current state of the mouse. + * * The current button state is returned as a button bitmask, which can * be tested using the SDL_BUTTON(X) macros, and x and y are set to the * mouse deltas since the last call to SDL_GetRelativeMouseState(). @@ -70,9 +95,18 @@ extern DECLSPEC Uint8 SDLCALL SDL_GetRelativeMouseState(int *x, int *y); /* - * Set the position of the mouse cursor (generates a mouse motion event) + * \fn void SDL_WarpMouseInWindow(SDL_WindowID windowID, int x, int y) + * + * \brief Moves the currently selected mouse to the given position within the window. + * + * \param windowID The window to move the mouse into, or 0 for the current mouse focus + * \param x The x coordinate within the window + * \param y The y coordinate within the window + * + * \note This function generates a mouse motion event */ -extern DECLSPEC void SDLCALL SDL_WarpMouse(Uint16 x, Uint16 y); +extern DECLSPEC void SDLCALL SDL_WarpMouseInWindow(SDL_WindowID windowID, + int x, int y); /* * Create a cursor using the specified data and mask (in MSB format). diff -r 9857d21967bb -r eef792d31de8 include/SDL_video.h --- a/include/SDL_video.h Mon May 29 05:08:33 2006 +0000 +++ b/include/SDL_video.h Wed Jun 07 16:10:28 2006 +0000 @@ -46,111 +46,17 @@ #define SDL_ALPHA_OPAQUE 255 #define SDL_ALPHA_TRANSPARENT 0 -/* Useful data types */ +/** + * \struct SDL_Rect + * + * \brief A rectangle, with the origin at the upper left. + */ typedef struct SDL_Rect { Sint16 x, y; Uint16 w, h; } SDL_Rect; -/* This structure should be treated as read-only, except for 'pixels', - which, if not NULL, contains the raw pixel data for the surface. -*/ -typedef struct SDL_Surface -{ - Uint32 flags; /* Read-only */ - SDL_PixelFormat *format; /* Read-only */ - int w, h; /* Read-only */ - Uint16 pitch; /* Read-only */ - void *pixels; /* Read-write */ - int offset; /* Private */ - - /* Hardware-specific surface info */ - struct private_hwdata *hwdata; - - /* clipping information */ - SDL_Rect clip_rect; /* Read-only */ - Uint32 unused1; /* for binary compatibility */ - - /* Allow recursive locks */ - Uint32 locked; /* Private */ - - /* info for fast blit mapping to other surfaces */ - struct SDL_BlitMap *map; /* Private */ - - /* format version, bumped at every change to invalidate blit maps */ - unsigned int format_version; /* Private */ - - /* Reference count -- used when freeing surface */ - int refcount; /* Read-mostly */ -} SDL_Surface; - -/* The most common video overlay formats. - For an explanation of these pixel formats, see: - http://www.webartz.com/fourcc/indexyuv.htm - - For information on the relationship between color spaces, see: - http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html - */ -#define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U (3 planes) */ -#define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V (3 planes) */ -#define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 (1 plane) */ -#define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 (1 plane) */ -#define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 (1 plane) */ - -/* The YUV hardware video overlay */ -typedef struct SDL_Overlay -{ - Uint32 format; /* Read-only */ - int w, h; /* Read-only */ - int planes; /* Read-only */ - Uint16 *pitches; /* Read-only */ - Uint8 **pixels; /* Read-write */ - - /* Hardware-specific surface info */ - struct private_yuvhwfuncs *hwfuncs; - struct private_yuvhwdata *hwdata; - - /* Special flags */ - Uint32 hw_overlay:1; /* Flag: This overlay hardware accelerated? */ - Uint32 UnusedBits:31; -} SDL_Overlay; - -/* Evaluates to true if the surface needs to be locked before access */ -#define SDL_MUSTLOCK(surface) \ - (surface->offset || \ - ((surface->flags & (SDL_HWSURFACE|SDL_RLEACCEL)) != 0)) - -/* typedef for private surface blitting functions */ -typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect, - struct SDL_Surface * dst, SDL_Rect * dstrect); - - -/** - * \struct SDL_VideoInfo - * - * \brief Useful for determining the video hardware capabilities - */ -typedef struct SDL_VideoInfo -{ - Uint32 hw_available:1; /**< Flag: Can you create hardware surfaces? */ - Uint32 wm_available:1; /**< Flag: Can you talk to a window manager? */ - Uint32 UnusedBits1:6; - Uint32 UnusedBits2:1; - Uint32 blit_hw:1; /**< Flag: Accelerated blits HW --> HW */ - Uint32 blit_hw_CC:1; /**< Flag: Accelerated blits with Colorkey */ - Uint32 blit_hw_A:1; /**< Flag: Accelerated blits with Alpha */ - Uint32 blit_sw:1; /**< Flag: Accelerated blits SW --> HW */ - Uint32 blit_sw_CC:1; /**< Flag: Accelerated blits with Colorkey */ - Uint32 blit_sw_A:1; /**< Flag: Accelerated blits with Alpha */ - Uint32 blit_fill:1; /**< Flag: Accelerated color fill */ - Uint32 UnusedBits3:16; - Uint32 video_mem; /* The total amount of video memory (in K) */ - - /* Here for backwards compatibility */ - SDL_PixelFormat *vfmt; -} SDL_VideoInfo; - /** * \struct SDL_DisplayMode * @@ -204,6 +110,8 @@ * \enum SDL_WindowFlags * * \brief The flags on a window + * + * \sa SDL_GetWindowFlags() */ typedef enum { @@ -241,6 +149,163 @@ } SDL_WindowEventID; /** + * \enum SDL_RendererFlags + * + * \brief Flags used when initializing a render manager. + */ +typedef enum +{ + SDL_Renderer_PresentDiscard = 0x00000001, /**< Present leaves the contents of the backbuffer undefined */ + SDL_Renderer_PresentCopy = 0x00000002, /**< Present uses a copy from back buffer to the front buffer */ + SDL_Renderer_PresentFlip2 = 0x00000004, /**< Present uses a flip, swapping back buffer and front buffer */ + SDL_Renderer_PresentFlip3 = 0x00000008, /**< Present uses a flip, rotating between two back buffers and a front buffer */ + SDL_Renderer_PresentVSync = 0x00000010, /**< Present is synchronized with the refresh rate */ + SDL_Renderer_RenderTarget = 0x00000020, /**< The renderer can create texture render targets */ + SDL_Renderer_Accelerated = 0x00000040, /**< The renderer uses hardware acceleration */ + SDL_Renderer_Minimal = 0x00000080, /**< The renderer only supports the read/write pixel and present functions */ +} SDL_RendererFlags; + +/** + * \struct SDL_RendererInfo + * + * \brief Information on the capabilities of a render manager. + */ +typedef struct SDL_RendererInfo +{ + const char *name; /**< The name of the renderer */ + Uint32 flags; /**< Supported SDL_RendererFlags */ + Uint32 blend_modes; /**< A mask of supported blend modes */ + Uint32 scale_modes; /**< A mask of supported scale modes */ + Uint32 num_texture_formats; /**< The number of available texture formats */ + Uint32 texture_formats[32]; /**< The available texture formats */ + int max_texture_width; /**< The maximimum texture width */ + int max_texture_height; /**< The maximimum texture height */ +} SDL_RendererInfo; + +/** + * \enum SDL_TextureAccess + * + * \brief The access pattern allowed for a texture + */ +typedef enum +{ + SDL_TextureAccess_Render, /**< Unlockable video memory, rendering allowed */ + SDL_TextureAccess_Remote, /**< Unlockable video memory */ + SDL_TextureAccess_Local, /**< Lockable system memory */ +} SDL_TextureAccess; + +/** + * \enum SDL_TextureBlendMode + * + * \brief The blend mode used in SDL_RenderCopy() + */ +typedef enum +{ + SDL_TextureBlendMode_None, /**< No blending */ + SDL_TextureBlendMode_Mask, /**< dst = A ? src : dst (alpha is mask) */ + SDL_TextureBlendMode_Blend, /**< dst = (src * A) + (dst * (1-A)) */ + SDL_TextureBlendMode_Add, /**< dst = (src * A) + dst */ + SDL_TextureBlendMode_Mod, /**< dst = src * dst */ +} SDL_TextureBlendMode; + +/** + * \enum SDL_TextureScaleMode + * + * \brief The scale mode used in SDL_RenderCopy() + */ +typedef enum +{ + SDL_TextureScaleMode_None, /**< No scaling, rectangles must match dimensions */ + SDL_TextureScaleMode_Fast, /**< Point sampling or equivalent algorithm */ + SDL_TextureScaleMode_Slow, /**< Linear filtering or equivalent algorithm */ + SDL_TextureScaleMode_Best, /**< Bicubic filtering or equivalent algorithm */ +} SDL_TextureScaleMode; + +/** + * \typedef SDL_TextureID + * + * \brief An efficient driver-specific representation of pixel data + */ +typedef Uint32 SDL_TextureID; + + +/* These are the currently supported flags for the SDL_surface */ +/* Used internally (read-only) */ +#define SDL_HWSURFACE 0x00000001 /* Surface represents a texture */ +#define SDL_PREALLOC 0x00000002 /* Surface uses preallocated memory */ +#define SDL_SRCALPHA 0x00000004 /* Blit uses source alpha blending */ +#define SDL_SRCCOLORKEY 0x00000008 /* Blit uses a source color key */ +#define SDL_RLEACCELOK 0x00000010 /* Private flag */ +#define SDL_RLEACCEL 0x00000020 /* Surface is RLE encoded */ + +/* Evaluates to true if the surface needs to be locked before access */ +#define SDL_MUSTLOCK(S) (((S)->flags & (SDL_HWSURFACE|SDL_RLEACCEL)) != 0) + +/* This structure should be treated as read-only, except for 'pixels', + which, if not NULL, contains the raw pixel data for the surface. +*/ +typedef struct SDL_Surface +{ + Uint32 flags; /* Read-only */ + SDL_PixelFormat *format; /* Read-only */ + int w, h; /* Read-only */ + int pitch; /* Read-only */ + void *pixels; /* Read-write */ + + /* information needed for surfaces requiring locks */ + int locked; + void *lock_data; + + /* clipping information */ + SDL_Rect clip_rect; /* Read-only */ + + /* info for fast blit mapping to other surfaces */ + struct SDL_BlitMap *map; /* Private */ + + /* format version, bumped at every change to invalidate blit maps */ + unsigned int format_version; /* Private */ + + /* Reference count -- used when freeing surface */ + int refcount; /* Read-mostly */ +} SDL_Surface; + +/* typedef for private surface blitting functions */ +typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect, + struct SDL_Surface * dst, SDL_Rect * dstrect); + + +/* The most common video overlay formats. + For an explanation of these pixel formats, see: + http://www.webartz.com/fourcc/indexyuv.htm + + For information on the relationship between color spaces, see: + http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html + */ +#define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U (3 planes) */ +#define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V (3 planes) */ +#define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 (1 plane) */ +#define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 (1 plane) */ +#define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 (1 plane) */ + +/* The YUV hardware video overlay */ +typedef struct SDL_Overlay +{ + Uint32 format; /* Read-only */ + int w, h; /* Read-only */ + int planes; /* Read-only */ + Uint16 *pitches; /* Read-only */ + Uint8 **pixels; /* Read-write */ + + /* Hardware-specific surface info */ + struct private_yuvhwfuncs *hwfuncs; + struct private_yuvhwdata *hwdata; + + /* Special flags */ + Uint32 hw_overlay:1; /* Flag: This overlay hardware accelerated? */ + Uint32 UnusedBits:31; +} SDL_Overlay; + +/** * \enum SDL_GLattr * * \brief OpenGL configuration attributes @@ -266,22 +331,6 @@ SDL_GL_SWAP_CONTROL } SDL_GLattr; -/* These are the currently supported flags for the SDL_surface */ -#define SDL_SWSURFACE 0x00000000 /* Surface is in system memory */ -#define SDL_HWSURFACE 0x00000001 /* Surface is in video memory */ -/* Available for SDL_CreateWindowSurface() */ -#define SDL_ANYFORMAT 0x10000000 /* Allow any video depth/pixel-format */ -#define SDL_HWPALETTE 0x20000000 /* Surface has exclusive palette */ -#define SDL_DOUBLEBUF 0x40000000 /* Set up double-buffered surface */ -/* Used internally (read-only) */ -#define SDL_HWACCEL 0x00000100 /* Blit uses hardware acceleration */ -#define SDL_SRCCOLORKEY 0x00001000 /* Blit uses a source color key */ -#define SDL_RLEACCELOK 0x00002000 /* Private flag */ -#define SDL_RLEACCEL 0x00004000 /* Surface is RLE encoded */ -#define SDL_SRCALPHA 0x00010000 /* Blit uses source alpha blending */ -#define SDL_PREALLOC 0x00100000 /* Surface uses preallocated memory */ -#define SDL_SCREEN_SURFACE 0x01000000 /* Surface is a window screen surface */ -#define SDL_SHADOW_SURFACE 0x02000000 /* Surface is a window shadow surface */ /* Function prototypes */ @@ -350,16 +399,6 @@ extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver(void); /** - * \fn const SDL_VideoInfo *SDL_GetVideoInfo(void) - * - * \brief Returns information about the currently initialized video driver. - * - * \return A read-only pointer to information about the video hardware, - * or NULL if no video driver has been initialized. - */ -extern DECLSPEC const SDL_VideoInfo *SDLCALL SDL_GetVideoInfo(void); - -/** * \fn int SDL_GetNumVideoDisplays(void) * * \brief Returns the number of available video displays. @@ -373,6 +412,8 @@ * * \brief Set the index of the currently selected display. * + * \return The index of the currently selected display. + * * \note You can query the currently selected display by passing an index of -1. * * \sa SDL_GetNumVideoDisplays() @@ -452,6 +493,16 @@ extern DECLSPEC int SDLCALL SDL_SetDisplayMode(const SDL_DisplayMode * mode); /** + * \fn int SDL_SetDisplayColormap(SDL_Color *colors, int firstcolor, int ncolors) + * + * \brief Set the colormap for indexed display modes. + * + * \return 0 on success, or -1 if not all the colors could be set. + */ +extern DECLSPEC int SDLCALL SDL_SetDisplayColors(SDL_Color * colors, + int firstcolor, int ncolors); + +/** * \fn SDL_WindowID SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags) * * \brief Create a window with the specified position, dimensions, and flags. @@ -673,37 +724,294 @@ extern DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_WindowID windowID); /** - * \fn SDL_Surface *SDL_CreateWindowSurface (SDL_WindowID windowID, Uint32 format, Uint32 flags) + * \fn int SDL_GetNumRenderers(void) + * + * \brief Get the number of render managers on the current display. + * + * A render manager is a set of code that handles rendering and texture + * management on a particular display. Normally there is only one, but + * some drivers may have several available with different capabilities. + * + * \sa SDL_GetRendererInfo() + * \sa SDL_CreateRenderer() + */ +extern DECLSPEC int SDLCALL SDL_GetNumRenderers(void); + +/** + * \fn SDL_RendererInfo *SDL_GetRendererInfo(int index) + * + * \brief Get information about a specific render manager on the current + * display. + * + * \sa SDL_CreateRenderer() + */ +extern DECLSPEC int SDLCALL SDL_GetRendererInfo(int index, + SDL_RendererInfo * info); + +/** + * \fn int SDL_CreateRenderer(SDL_WindowID window, int index, Uint32 flags) + * + * \brief Create and make active a 2D rendering context for a window. + * + * \param windowID The window used for rendering. + * \param index The index of the render manager to initialize, or -1 to initialize the first one supporting the requested flags. + * \param flags SDL_RendererFlags * - * \brief Create an SDL_Surface representing the drawing area of the window. + * \return 0 on success, -1 if the flags were not supported, or -2 if + * there isn't enough memory to support the requested flags + * + * \sa SDL_SelectRenderer() + * \sa SDL_DestroyRenderer() + */ +extern DECLSPEC int SDLCALL SDL_CreateRenderer(SDL_WindowID windowID, + int index, Uint32 flags); + +/** + * \fn int SDL_SelectRenderer(SDL_WindowID windowID) + * + * \brief Select the rendering context for a particular window. + * + * \return 0 on success, -1 if the selected window doesn't have a + * rendering context. + */ +extern DECLSPEC int SDLCALL SDL_SelectRenderer(SDL_WindowID windowID); + +/** + * \fn SDL_TextureID SDL_CreateTexture(Uint32 format, int access, int w, int h) + * + * \brief Create a texture + * + * \param format The format of the texture + * \param access One of the enumerated values in SDL_TextureAccess + * \param w The width of the texture in pixels + * \param h The height of the texture in pixels + * + * \return The created texture is returned, or 0 if no render manager was active, the format was unsupported, or the width or height were out of range. + * + * \sa SDL_QueryTexture() + * \sa SDL_DestroyTexture() */ -extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateWindowSurface(SDL_WindowID - windowID, - Uint32 format, - Uint32 flags); +extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTexture(Uint32 format, + int access, int w, + int h); + +/** + * \fn SDL_TextureID SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface *surface) + * + * \brief Create a texture from an existing surface + * + * \param format The format of the texture, or 0 to pick an appropriate format + * \param access One of the enumerated values in SDL_TextureAccess + * \param surface The surface containing pixel data used to fill the texture + * + * \return The created texture is returned, or 0 if no render manager was active, the format was unsupported, or the surface width or height were out of range. + * + * \note The surface is not modified or freed by this function. + * + * \sa SDL_QueryTexture() + * \sa SDL_DestroyTexture() + */ +extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTextureFromSurface(Uint32 + format, + int access, + SDL_Surface + * surface); -/* - * Makes sure the given list of rectangles is updated on the given screen. - * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire - * screen. - * These functions should not be called while 'screen' is locked. +/** + * \fn int SDL_QueryTexture(SDL_TextureID textureID, Uint32 *format, int *access, int *w, int *h) + * + * \brief Query the attributes of a texture + * + * \param texture A texture to be queried + * \param format A pointer filled in with the raw format of the texture. The actual format may differ, but pixel transfers will use this format. + * \param access A pointer filled in with the actual access to the texture. + * \param w A pointer filled in with the width of the texture in pixels + * \param h A pointer filled in with the height of the texture in pixels + * + * \return 0 on success, or -1 if the texture is not valid + */ +extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_TextureID textureID, + Uint32 * format, int *access, + int *w, int *h); + +/** + * \fn int SDL_SetTexturePalette(SDL_TextureID textureID, SDL_Color * colors, int firstcolor, int ncolors) + * + * \brief Update an indexed texture with a color palette + * + * \param texture The texture to update + * \param colors The array of RGB color data + * \param firstcolor The first index to update + * \param ncolors The number of palette entries to fill with the color data + * + * \return 0 on success, or -1 if the texture is not valid or not an indexed texture + */ +extern DECLSPEC int SDLCALL SDL_SetTexturePalette(SDL_TextureID textureID, + SDL_Color * colors, + int firstcolor, + int ncolors); + +/** + * \fn int SDL_UpdateTexture(SDL_TextureID textureID, SDL_Rect *rect, const void *pixels, int pitch) + * + * \brief Update the given texture rectangle with new pixel data. + * + * \param texture The texture to update + * \param rect A pointer to the rectangle of pixels to update, or NULL to update the entire texture. + * \param pixels The raw pixel data + * \param pitch The number of bytes between rows of pixel data + * + * \return 0 on success, or -1 if the texture is not valid + * + * \note This is a very slow function for textures not created with SDL_TextureAccess_Local. */ -extern DECLSPEC void SDLCALL SDL_UpdateRects - (SDL_Surface * screen, int numrects, SDL_Rect * rects); -extern DECLSPEC void SDLCALL SDL_UpdateRect - (SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h); +extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_TextureID textureID, + SDL_Rect * rect, + const void *pixels, int pitch); + +/** + * \fn void SDL_LockTexture(SDL_TextureID textureID, SDL_Rect *rect, int markDirty, void **pixels, int *pitch) + * + * \brief Lock a portion of the texture for pixel access. + * + * \param texture The texture to lock for access, which must have been created with SDL_TextureAccess_Local. + * \param rect A pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked. + * \param markDirty If this is nonzero, the locked area will be marked dirty when the texture is unlocked. + * \param pixels This is filled in with a pointer to the locked pixels, appropriately offset by the locked area. + * \param pitch This is filled in with the pitch of the locked pixels. + * + * \return 0 on success, or -1 if the texture is not valid or was created with SDL_TextureAccess_Remote + * + * \sa SDL_DirtyTexture() + * \sa SDL_UnlockTexture() + */ +extern DECLSPEC int SDLCALL SDL_LockTexture(SDL_TextureID textureID, + SDL_Rect * rect, int markDirty, + void **pixels, int *pitch); + +/** + * \fn void SDL_UnlockTexture(SDL_TextureID textureID) + * + * \brief Unlock a texture, uploading the changes to video memory, if needed. + * + * \sa SDL_LockTexture() + * \sa SDL_DirtyTexture() + */ +extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_TextureID textureID); + +/** + * \fn void SDL_DirtyTexture(SDL_TextureID textureID, int numrects, SDL_Rect * rects) + * + * \brief Mark the specified rectangles of the texture as dirty. + * + * \note The texture must have been created with SDL_TextureAccess_Local. + * + * \sa SDL_LockTexture() + * \sa SDL_UnlockTexture() + */ +extern DECLSPEC void SDLCALL SDL_DirtyTexture(SDL_TextureID textureID, + int numrects, SDL_Rect * rects); + +/** + * \fn void SDL_SelectRenderTexture(SDL_TextureID textureID) + * + * \brief Select a texture as the rendering target, or 0 to reselect the current window. + * + * \note The texture must have been created with SDL_TextureAccess_Render. + */ +extern DECLSPEC void SDLCALL SDL_SelectRenderTexture(SDL_TextureID textureID); + +/** + * \fn void SDL_RenderFill(SDL_Rect *rect, Uint32 color) + * + * \brief Fill the current rendering target with the specified color. + * + * \param rect A pointer to the destination rectangle, or NULL for the entire rendering target. + * \param color An ARGB color value. + * + * \return 0 on success, or -1 if there is no renderer current + */ +extern DECLSPEC int SDLCALL SDL_RenderFill(SDL_Rect * rect, Uint32 color); -/* - * On hardware that supports double-buffering, this function sets up a flip - * and returns. The hardware will wait for vertical retrace, and then swap - * video buffers before the next video surface blit or lock will return. - * On hardware that doesn not support double-buffering, this is equivalent - * to calling SDL_UpdateRect(screen, 0, 0, 0, 0); - * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when - * setting the video mode for this function to perform hardware flipping. - * This function returns 0 if successful, or -1 if there was an error. +/** + * \fn int SDL_RenderCopy(SDL_TextureID textureID, SDL_Rect *srcrect, SDL_Rect *dstrect, Uint32 blendMode, Uint32 scaleMode) + * + * \brief Copy a portion of the texture to the current rendering target. + * + * \param texture The source texture. + * \param srcrect A pointer to the source rectangle, or NULL for the entire texture. + * \param dstrect A pointer to the destination rectangle, or NULL for the entire rendering target. + * \param blendMode SDL_TextureBlendMode to be used if the source texture has an alpha channel. + * \param scaleMode SDL_TextureScaleMode to be used if the source and destination rectangles don't have the same width and height. + * + * \return 0 on success, or -1 if there is no renderer current, or the driver doesn't support the requested operation. + * + * \note You can check the video driver info to see what operations are supported. + */ +extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_TextureID textureID, + SDL_Rect * srcrect, + SDL_Rect * dstrect, int blendMode, + int scaleMode); + +/** + * \fn int SDL_RenderReadPixels(SDL_Rect *rect, void *pixels, int pitch) + * + * \brief Read pixels from the current rendering target. + * + * \param rect A pointer to the rectangle to read, or NULL for the entire render target + * \param pixels A pointer to be filled in with the pixel data + * \param pitch The pitch of the pixels parameter + * + * \return 0 on success, or -1 if pixel reading is not supported. + * + * \warning This is a very slow operation, and should not be used frequently. */ -extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface * screen); +extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Rect * rect, + void *pixels, int pitch); + +/** + * \fn int SDL_RenderWritePixels(SDL_Rect *rect, const void *pixels, int pitch) + * + * \brief Write pixels to the current rendering target. + * + * \param rect A pointer to the rectangle to write, or NULL for the entire render target + * \param pixels A pointer to the pixel data to write + * \param pitch The pitch of the pixels parameter + * + * \return 0 on success, or -1 if pixel writing is not supported. + * + * \warning This is a very slow operation, and should not be used frequently. + */ +extern DECLSPEC int SDLCALL SDL_RenderWritePixels(SDL_Rect * rect, + const void *pixels, + int pitch); + +/** + * \fn void SDL_RenderPresent(void) + * + * \brief Update the screen with rendering performed. + */ +extern DECLSPEC void SDLCALL SDL_RenderPresent(void); + +/** + * \fn void SDL_DestroyTexture(SDL_TextureID textureID); + * + * \brief Destroy the specified texture. + * + * \sa SDL_CreateTexture() + * \sa SDL_CreateTextureFromSurface() + */ +extern DECLSPEC void SDLCALL SDL_DestroyTexture(SDL_TextureID textureID); + +/** + * \fn void SDL_DestroyRenderer(SDL_WindowID windowID); + * + * \brief Destroy the rendering context for a window and free associated + * textures. + * + * \sa SDL_CreateRenderer() + */ +extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_WindowID windowID); /* * Set the gamma correction for each of the color channels. @@ -796,33 +1104,9 @@ * If the function runs out of memory, it will return NULL. * * The 'flags' tell what kind of surface to create. - * SDL_SWSURFACE means that the surface should be created in system memory. - * SDL_HWSURFACE means that the surface should be created in video memory, - * with the same format as the display surface. This is useful for surfaces - * that will not change much, to take advantage of hardware acceleration - * when being blitted to the display surface. - * SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with - * this surface, but you must always lock it before accessing the pixels. - * SDL will wait for current blits to finish before returning from the lock. * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits. - * If the hardware supports acceleration of colorkey blits between - * two surfaces in video memory, SDL will try to place the surface in - * video memory. If this isn't possible or if there is no hardware - * acceleration available, the surface will be placed in system memory. - * SDL_SRCALPHA means that the surface will be used for alpha blits and - * if the hardware supports hardware acceleration of alpha blits between - * two surfaces in video memory, to place the surface in video memory - * if possible, otherwise it will be placed in system memory. - * If the surface is created in video memory, blits will be _much_ faster, - * but the surface format must be identical to the video surface format, - * and the only way to access the pixels member of the surface is to use - * the SDL_LockSurface() and SDL_UnlockSurface() calls. - * If the requested surface actually resides in video memory, SDL_HWSURFACE - * will be set in the flags member of the returned surface. If for some - * reason the surface could not be placed in video memory, it will not have - * the SDL_HWSURFACE flag set, and will be created in system memory instead. + * SDL_SRCALPHA means that the surface will be used for alpha blits. */ -#define SDL_AllocSurface SDL_CreateRGBSurface extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface (Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask); @@ -835,6 +1119,8 @@ Uint32 Gmask, Uint32 Bmask, Uint32 Amask); +extern DECLSPEC SDL_Surface *SDLCALL +SDL_CreateRGBSurfaceFromTexture(SDL_TextureID textureID); extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface); /* @@ -846,9 +1132,7 @@ * * Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates * to 0, then you can read and write to the surface at any time, and the - * pixel format of the surface will not change. In particular, if the - * SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you - * will not need to lock the display surface before accessing it. + * pixel format of the surface will not change. * * No operating system or library calls should be made between lock/unlock * pairs, as critical system locks may be held during this time. @@ -951,6 +1235,18 @@ (SDL_Surface * src, SDL_PixelFormat * fmt, Uint32 flags); /* + * This function performs a fast fill of the given rectangle with 'color' + * The given rectangle is clipped to the destination surface clip area + * and the final fill rectangle is saved in the passed in pointer. + * If 'dstrect' is NULL, the whole surface will be filled with 'color' + * The color should be a pixel of the format used by the surface, and + * can be generated by the SDL_MapRGB() function. + * This function returns 0 on success, or -1 on error. + */ +extern DECLSPEC int SDLCALL SDL_FillRect + (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color); + +/* * This performs a fast blit from the source surface to the destination * surface. It assumes that the source and destination rectangles are * the same size. If either 'srcrect' or 'dstrect' are NULL, the entire @@ -1034,45 +1330,16 @@ (SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect); -/* - * This function performs a fast fill of the given rectangle with 'color' - * The given rectangle is clipped to the destination surface clip area - * and the final fill rectangle is saved in the passed in pointer. - * If 'dstrect' is NULL, the whole surface will be filled with 'color' - * The color should be a pixel of the format used by the surface, and - * can be generated by the SDL_MapRGB() function. - * This function returns 0 on success, or -1 on error. - */ -extern DECLSPEC int SDLCALL SDL_FillRect - (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color); - -/* - * 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 - * blitting onto the display surface. It calls SDL_ConvertSurface() +/** + * \fn int SDL_SoftStretch(SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect) * - * If you want to take advantage of hardware colorkey or alpha blit - * acceleration, you should set the colorkey and alpha value before - * calling this function. - * - * If the conversion fails or runs out of memory, it returns NULL + * \brief Perform a fast, low quality, stretch blit between two surfaces of the same pixel format. + * \note This function uses a static buffer, and is not thread-safe. */ -extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormat(SDL_Surface * surface); - -/* - * This function takes a surface and copies it to a new surface of the - * pixel format and colors of the video framebuffer (if possible), - * suitable for fast alpha blitting onto the display surface. - * The new surface will always have an alpha channel. - * - * If you want to take advantage of hardware colorkey or alpha blit - * acceleration, you should set the colorkey and alpha value before - * calling this function. - * - * If the conversion fails or runs out of memory, it returns NULL - */ -extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormatAlpha(SDL_Surface * - surface); +extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src, + SDL_Rect * srcrect, + SDL_Surface * dst, + SDL_Rect * dstrect); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -1145,12 +1412,6 @@ */ extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers(void); -/* Not in public API at the moment - do not use! */ -extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src, - SDL_Rect * srcrect, - SDL_Surface * dst, - SDL_Rect * dstrect); - /* Ends C function definitions when using C++ */ #ifdef __cplusplus /* *INDENT-OFF* */ diff -r 9857d21967bb -r eef792d31de8 src/SDL_compat.c --- a/src/SDL_compat.c Mon May 29 05:08:33 2006 +0000 +++ b/src/SDL_compat.c Wed Jun 07 16:10:28 2006 +0000 @@ -53,6 +53,23 @@ return NULL; } +const SDL_VideoInfo * +SDL_GetVideoInfo(void) +{ + static SDL_VideoInfo info; + + /* Memory leak, compatibility code, who cares? */ + if (!info.vfmt && SDL_GetDesktopDisplayMode()) { + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + SDL_PixelFormatEnumToMasks(SDL_GetDesktopDisplayMode()->format, &bpp, + &Rmask, &Gmask, &Bmask, &Amask); + info.vfmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); + } + return &info; +} + int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags) { @@ -296,6 +313,91 @@ } SDL_Surface * +SDL_CreateWindowSurface(SDL_WindowID windowID, Uint32 format, Uint32 flags) +{ + SDL_Window *window = SDL_GetWindowFromID(windowID); + Uint32 black; + SDL_Surface *surface; + + if (!window) { + return NULL; + } + + if (!_this->CreateWindowSurface) { + return NULL; + } + + if (!window->surface) { + _this->CreateWindowSurface(_this, window, flags); + if (!window->surface) { + return NULL; + } + window->surface->flags |= SDL_SCREEN_SURFACE; + + /* If we have a palettized surface, create a default palette */ + if (window->surface->format->palette) { + SDL_Color colors[256]; + SDL_PixelFormat *vf = window->surface->format; + SDL_DitherColors(colors, vf->BitsPerPixel); + SDL_SetColors(window->surface, colors, 0, vf->palette->ncolors); + } + } + surface = window->surface; + + if (window->shadow) { + SDL_FreeSurface(window->shadow); + window->shadow = NULL; + } + + /* Create a shadow surface if necessary */ + if ((!(flags & SDL_ANYFORMAT) + && (format != SDL_GetCurrentDisplayMode()->format)) + || ((flags & SDL_HWPALETTE) + && !(window->surface->flags & SDL_HWPALETTE))) { + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + SDL_PixelFormatEnumToMasks(format, &bpp, &Amask, &Gmask, &Bmask, + &Amask); + window->shadow = + SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, bpp, + Rmask, Gmask, Bmask, Amask); + if (window->shadow == NULL) { + return NULL; + } + window->shadow->flags |= SDL_SHADOW_SURFACE; + + surface = window->shadow; + + /* 8-bit shadow surfaces report that they have exclusive palette */ + if (surface->format->palette) { + surface->flags |= SDL_HWPALETTE; + if (format == SDL_GetCurrentDisplayMode()->format) { + SDL_memcpy(surface->format->palette->colors, + window->surface->format->palette->colors, + window->surface->format->palette->ncolors * + sizeof(SDL_Color)); + } else { + SDL_DitherColors(surface->format->palette->colors, bpp); + } + } + } + + /* Clear the surface for display */ + { + Uint32 black = SDL_MapRGB(surface->format, 0, 0, 0); + SDL_FillRect(surface, NULL, black); + if (surface->flags & SDL_DOUBLEBUF) { + SDL_Flip(surface); + SDL_FillRect(surface, NULL, black); + } + SDL_Flip(surface); + } + + return surface; +} + +SDL_Surface * SDL_GetVideoSurface(void) { SDL_VideoDevice *_this = SDL_GetVideoDevice(); @@ -303,6 +405,201 @@ return SDL_VideoSurface; } +SDL_Surface * +SDL_DisplayFormat(SDL_Surface * surface) +{ + Uint32 flags; + + if (!SDL_PublicSurface) { + SDL_SetError("No video mode has been set"); + return (NULL); + } + /* Set the flags appropriate for copying to display surface */ + if (((SDL_PublicSurface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) + && _this->info.blit_hw) + flags = SDL_HWSURFACE; + else + flags = SDL_SWSURFACE; +#ifdef AUTORLE_DISPLAYFORMAT + flags |= (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA)); + flags |= SDL_RLEACCELOK; +#else + flags |= + surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCELOK); +#endif + return (SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags)); +} + +SDL_Surface * +SDL_DisplayFormatAlpha(SDL_Surface * surface) +{ + SDL_PixelFormat *vf; + SDL_PixelFormat *format; + SDL_Surface *converted; + Uint32 flags; + /* default to ARGB8888 */ + Uint32 amask = 0xff000000; + Uint32 rmask = 0x00ff0000; + Uint32 gmask = 0x0000ff00; + Uint32 bmask = 0x000000ff; + + if (!SDL_PublicSurface) { + SDL_SetError("No video mode has been set"); + return (NULL); + } + vf = SDL_PublicSurface->format; + + switch (vf->BytesPerPixel) { + case 2: + /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}. + For anything else (like ARGB4444) it doesn't matter + since we have no special code for it anyway */ + if ((vf->Rmask == 0x1f) && + (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) { + rmask = 0xff; + bmask = 0xff0000; + } + break; + + case 3: + case 4: + /* Keep the video format, as long as the high 8 bits are + unused or alpha */ + if ((vf->Rmask == 0xff) && (vf->Bmask == 0xff0000)) { + rmask = 0xff; + bmask = 0xff0000; + } + break; + + default: + /* We have no other optimised formats right now. When/if a new + optimised alpha format is written, add the converter here */ + break; + } + format = SDL_AllocFormat(32, rmask, gmask, bmask, amask); + flags = SDL_PublicSurface->flags & SDL_HWSURFACE; + flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK); + converted = SDL_ConvertSurface(surface, format, flags); + SDL_FreeFormat(format); + return (converted); +} + +void +SDL_UpdateRect(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h) +{ + if (screen) { + SDL_Rect rect; + + /* Perform some checking */ + if (w == 0) + w = screen->w; + if (h == 0) + h = screen->h; + if ((int) (x + w) > screen->w) + return; + if ((int) (y + h) > screen->h) + return; + + /* Fill the rectangle */ + rect.x = (Sint16) x; + rect.y = (Sint16) y; + rect.w = (Uint16) w; + rect.h = (Uint16) h; + SDL_UpdateRects(screen, 1, &rect); + } +} +void +SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) +{ + int i; + SDL_Window *window; + + /* Find the window corresponding to this surface */ + window = SDL_GetWindowFromSurface(screen); + if (!window) { + SDL_SetError("Couldn't find window associated with surface"); + return; + } + + if (screen->flags & SDL_SHADOW_SURFACE) { + if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { + SDL_LockCursor(); + SDL_DrawCursor(screen); + for (i = 0; i < numrects; ++i) { + SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); + } + SDL_EraseCursor(screen); + SDL_UnlockCursor(); + } else { + for (i = 0; i < numrects; ++i) { + SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); + } + } + + /* Fall through to video surface update */ + screen = window->surface; + } + if ((screen->flags & SDL_SCREEN_SURFACE) && _this->UpdateWindowSurface) { + /* Update the video surface */ + if (screen->offset) { + int offset_y = screen->offset / screen->pitch; + int offset_x = screen->offset % screen->pitch; + for (i = 0; i < numrects; ++i) { + rects[i].x += offset_x; + rects[i].y += offset_y; + } + _this->UpdateWindowSurface(_this, window, numrects, rects); + for (i = 0; i < numrects; ++i) { + rects[i].x -= offset_x; + rects[i].y -= offset_y; + } + } else { + _this->UpdateWindowSurface(_this, window, numrects, rects); + } + } +} + +int +SDL_Flip(SDL_Surface * screen) +{ + SDL_Window *window; + + /* Find the window corresponding to this surface */ + window = SDL_GetWindowFromSurface(screen); + if (!window) { + SDL_SetError("Couldn't find window associated with surface"); + return; + } + + /* Copy the shadow surface to the video surface */ + if (screen->flags & SDL_SHADOW_SURFACE) { + SDL_Rect rect; + + rect.x = 0; + rect.y = 0; + rect.w = screen->w; + rect.h = screen->h; + if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { + SDL_LockCursor(); + SDL_DrawCursor(screen); + SDL_LowerBlit(screen, &rect, window->surface, &rect); + SDL_EraseCursor(screen); + SDL_UnlockCursor(); + } else { + SDL_LowerBlit(screen, &rect, window->surface, &rect); + } + + /* Fall through to video surface update */ + screen = window->surface; + } + if (screen->flags & SDL_DOUBLEBUF) { + _this->FlipWindowSurface(_this, window); + } else { + SDL_UpdateRect(screen, 0, 0, 0, 0); + } + return (0); +} + void SDL_WM_SetCaption(const char *title, const char *icon) { @@ -387,9 +684,555 @@ } int +SDL_SetScreenColors(SDL_Surface * screen, SDL_Color * colors, int firstcolor, + int ncolors) +{ + SDL_Window *window = NULL; + SDL_Palette *pal; + int gotall; + int palsize; + + /* Verify the parameters */ + pal = screen->format->palette; + if (!pal) { + return 0; /* not a palettized surface */ + } + gotall = 1; + palsize = 1 << screen->format->BitsPerPixel; + if (ncolors > (palsize - firstcolor)) { + ncolors = (palsize - firstcolor); + gotall = 0; + } + + if (screen->flags & (SDL_SHADOW_SURFACE | SDL_SCREEN_SURFACE)) { + window = SDL_GetWindowFromSurface(screen); + if (!window) { + return 0; + } + } + + if (screen->flags & SDL_SHADOW_SURFACE) { + SDL_Palette *vidpal; + + vidpal = window->surface->format->palette; + if (vidpal && vidpal->ncolors == pal->ncolors) { + /* This is a shadow surface, and the physical + * framebuffer is also indexed. Propagate the + * changes to its logical palette so that + * updates are always identity blits + */ + SDL_memcpy(vidpal->colors + firstcolor, colors, + ncolors * sizeof(*colors)); + } + if (window->surface->flags & SDL_HWPALETTE) { + /* Set the physical palette */ + screen = window->surface; + } else { + SDL_UpdateRect(screen, 0, 0, 0, 0); + } + } + + if (screen->flags & SDL_SCREEN_SURFACE) { + if (_this->SetWindowColors) { + gotall = + _this->SetWindowColors(_this, window, firstcolor, ncolors, + colors); + if (!gotall) { + /* The video flags shouldn't have SDL_HWPALETTE, and + the video driver is responsible for copying back the + correct colors into the video surface palette. + */ + ; + } + } + SDL_CursorPaletteChanged(); + } + + return gotall; +} + +int SDL_GetWMInfo(SDL_SysWMinfo * info) { return SDL_GetWindowWMInfo(window, info); } +void +SDL_MoveCursor(int x, int y) +{ + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + + /* Erase and update the current mouse position */ + if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { + /* Erase and redraw mouse cursor in new position */ + SDL_LockCursor(); + SDL_EraseCursor(SDL_VideoSurface); + SDL_cursor->area.x = (x - SDL_cursor->hot_x); + SDL_cursor->area.y = (y - SDL_cursor->hot_y); + SDL_DrawCursor(SDL_VideoSurface); + SDL_UnlockCursor(); + } else if (_this->MoveWMCursor) { + _this->MoveWMCursor(_this, x, y); + } +} + +/* Keep track of the current cursor colors */ +static int palette_changed = 1; +static Uint8 pixels8[2]; + +void +SDL_CursorPaletteChanged(void) +{ + palette_changed = 1; +} + +void +SDL_MouseRect(SDL_Rect * area) +{ + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + int clip_diff; + + *area = SDL_cursor->area; + if (area->x < 0) { + area->w += area->x; + area->x = 0; + } + if (area->y < 0) { + area->h += area->y; + area->y = 0; + } + clip_diff = (area->x + area->w) - SDL_VideoSurface->w; + if (clip_diff > 0) { + area->w = area->w < clip_diff ? 0 : area->w - clip_diff; + } + clip_diff = (area->y + area->h) - SDL_VideoSurface->h; + if (clip_diff > 0) { + area->h = area->h < clip_diff ? 0 : area->h - clip_diff; + } +} + +static void +SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area) +{ + const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 }; + int i, w, h; + Uint8 *data, datab; + Uint8 *mask, maskb; + + data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; + mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; + switch (screen->format->BytesPerPixel) { + + case 1: + { + Uint8 *dst; + int dstskip; + + if (palette_changed) { + pixels8[0] = + (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); + pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); + palette_changed = 0; + } + dst = (Uint8 *) screen->pixels + + (SDL_cursor->area.y + area->y) * screen->pitch + + SDL_cursor->area.x; + dstskip = screen->pitch - area->w; + + for (h = area->h; h; h--) { + for (w = area->w / 8; w; w--) { + maskb = *mask++; + datab = *data++; + for (i = 0; i < 8; ++i) { + if (maskb & 0x80) { + *dst = pixels8[datab >> 7]; + } + maskb <<= 1; + datab <<= 1; + dst++; + } + } + dst += dstskip; + } + } + break; + + case 2: + { + Uint16 *dst; + int dstskip; + + dst = (Uint16 *) screen->pixels + + (SDL_cursor->area.y + area->y) * screen->pitch / 2 + + SDL_cursor->area.x; + dstskip = (screen->pitch / 2) - area->w; + + for (h = area->h; h; h--) { + for (w = area->w / 8; w; w--) { + maskb = *mask++; + datab = *data++; + for (i = 0; i < 8; ++i) { + if (maskb & 0x80) { + *dst = (Uint16) pixels[datab >> 7]; + } + maskb <<= 1; + datab <<= 1; + dst++; + } + } + dst += dstskip; + } + } + break; + + case 3: + { + Uint8 *dst; + int dstskip; + + dst = (Uint8 *) screen->pixels + + (SDL_cursor->area.y + area->y) * screen->pitch + + SDL_cursor->area.x * 3; + dstskip = screen->pitch - area->w * 3; + + for (h = area->h; h; h--) { + for (w = area->w / 8; w; w--) { + maskb = *mask++; + datab = *data++; + for (i = 0; i < 8; ++i) { + if (maskb & 0x80) { + SDL_memset(dst, pixels[datab >> 7], 3); + } + maskb <<= 1; + datab <<= 1; + dst += 3; + } + } + dst += dstskip; + } + } + break; + + case 4: + { + Uint32 *dst; + int dstskip; + + dst = (Uint32 *) screen->pixels + + (SDL_cursor->area.y + area->y) * screen->pitch / 4 + + SDL_cursor->area.x; + dstskip = (screen->pitch / 4) - area->w; + + for (h = area->h; h; h--) { + for (w = area->w / 8; w; w--) { + maskb = *mask++; + datab = *data++; + for (i = 0; i < 8; ++i) { + if (maskb & 0x80) { + *dst = pixels[datab >> 7]; + } + maskb <<= 1; + datab <<= 1; + dst++; + } + } + dst += dstskip; + } + } + break; + } +} + +static void +SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area) +{ + const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 }; + int h; + int x, minx, maxx; + Uint8 *data, datab = 0; + Uint8 *mask, maskb = 0; + Uint8 *dst; + int dstbpp, dstskip; + + data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; + mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; + dstbpp = screen->format->BytesPerPixel; + dst = (Uint8 *) screen->pixels + + (SDL_cursor->area.y + area->y) * screen->pitch + + SDL_cursor->area.x * dstbpp; + dstskip = screen->pitch - SDL_cursor->area.w * dstbpp; + + minx = area->x; + maxx = area->x + area->w; + if (screen->format->BytesPerPixel == 1) { + if (palette_changed) { + pixels8[0] = (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); + pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); + palette_changed = 0; + } + for (h = area->h; h; h--) { + for (x = 0; x < SDL_cursor->area.w; ++x) { + if ((x % 8) == 0) { + maskb = *mask++; + datab = *data++; + } + if ((x >= minx) && (x < maxx)) { + if (maskb & 0x80) { + SDL_memset(dst, pixels8[datab >> 7], dstbpp); + } + } + maskb <<= 1; + datab <<= 1; + dst += dstbpp; + } + dst += dstskip; + } + } else { + for (h = area->h; h; h--) { + for (x = 0; x < SDL_cursor->area.w; ++x) { + if ((x % 8) == 0) { + maskb = *mask++; + datab = *data++; + } + if ((x >= minx) && (x < maxx)) { + if (maskb & 0x80) { + SDL_memset(dst, pixels[datab >> 7], dstbpp); + } + } + maskb <<= 1; + datab <<= 1; + dst += dstbpp; + } + dst += dstskip; + } + } +} + +/* This handles the ugly work of converting the saved cursor background from + the pixel format of the shadow surface to that of the video surface. + This is only necessary when blitting from a shadow surface of a different + pixel format than the video surface, and using a software rendered cursor. +*/ +static void +SDL_ConvertCursorSave(SDL_Surface * screen, int w, int h) +{ + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_BlitInfo info; + SDL_loblit RunBlit; + + /* Make sure we can steal the blit mapping */ + if (screen->map->dst != SDL_VideoSurface) { + return; + } + + /* Set up the blit information */ + info.s_pixels = SDL_cursor->save[1]; + info.s_width = w; + info.s_height = h; + info.s_skip = 0; + info.d_pixels = SDL_cursor->save[0]; + info.d_width = w; + info.d_height = h; + info.d_skip = 0; + info.aux_data = screen->map->sw_data->aux_data; + info.src = screen->format; + info.table = screen->map->table; + info.dst = SDL_VideoSurface->format; + RunBlit = screen->map->sw_data->blit; + + /* Run the actual software blit */ + RunBlit(&info); +} + +void +SDL_DrawCursorNoLock(SDL_Surface * screen) +{ + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_Rect area; + + /* Get the mouse rectangle, clipped to the screen */ + SDL_MouseRect(&area); + if ((area.w == 0) || (area.h == 0)) { + return; + } + + /* Copy mouse background */ + { + int w, h, screenbpp; + Uint8 *src, *dst; + + /* Set up the copy pointers */ + screenbpp = screen->format->BytesPerPixel; + if ((screen == SDL_VideoSurface) || + FORMAT_EQUAL(screen->format, SDL_VideoSurface->format)) { + dst = SDL_cursor->save[0]; + } else { + dst = SDL_cursor->save[1]; + } + src = (Uint8 *) screen->pixels + area.y * screen->pitch + + area.x * screenbpp; + + /* Perform the copy */ + w = area.w * screenbpp; + h = area.h; + while (h--) { + SDL_memcpy(dst, src, w); + dst += w; + src += screen->pitch; + } + } + + /* Draw the mouse cursor */ + area.x -= SDL_cursor->area.x; + area.y -= SDL_cursor->area.y; + if ((area.x == 0) && (area.w == SDL_cursor->area.w)) { + SDL_DrawCursorFast(screen, &area); + } else { + SDL_DrawCursorSlow(screen, &area); + } +} + +void +SDL_DrawCursor(SDL_Surface * screen) +{ + /* Lock the screen if necessary */ + if (screen == NULL) { + return; + } + if (SDL_MUSTLOCK(screen)) { + if (SDL_LockSurface(screen) < 0) { + return; + } + } + + SDL_DrawCursorNoLock(screen); + + /* Unlock the screen and update if necessary */ + if (SDL_MUSTLOCK(screen)) { + SDL_UnlockSurface(screen); + } + if ((screen->flags & SDL_SCREEN_SURFACE) && + !(screen->flags & SDL_HWSURFACE)) { + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_Window *window; + SDL_Rect area; + + window = SDL_GetWindowFromSurface(screen); + if (!window) { + return; + } + + SDL_MouseRect(&area); + + if (_this->UpdateWindowSurface) { + _this->UpdateWindowSurface(_this, window, 1, &area); + } + } +} + +void +SDL_EraseCursorNoLock(SDL_Surface * screen) +{ + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_Window *window; + SDL_Rect area; + + /* Get the window associated with the surface */ + window = SDL_GetWindowFromSurface(screen); + if (!window || !window->surface) { + return; + } + + /* Get the mouse rectangle, clipped to the screen */ + SDL_MouseRect(&area); + if ((area.w == 0) || (area.h == 0)) { + return; + } + + /* Copy mouse background */ + { + int w, h, screenbpp; + Uint8 *src, *dst; + + /* Set up the copy pointers */ + screenbpp = screen->format->BytesPerPixel; + if ((screen->flags & SDL_SCREEN_SURFACE) || + FORMAT_EQUAL(screen->format, window->surface->format)) { + src = SDL_cursor->save[0]; + } else { + src = SDL_cursor->save[1]; + } + dst = (Uint8 *) screen->pixels + area.y * screen->pitch + + area.x * screenbpp; + + /* Perform the copy */ + w = area.w * screenbpp; + h = area.h; + while (h--) { + SDL_memcpy(dst, src, w); + src += w; + dst += screen->pitch; + } + + /* Perform pixel conversion on cursor background */ + if (src > SDL_cursor->save[1]) { + SDL_ConvertCursorSave(screen, area.w, area.h); + } + } +} + +void +SDL_EraseCursor(SDL_Surface * screen) +{ + /* Lock the screen if necessary */ + if (screen == NULL) { + return; + } + if (SDL_MUSTLOCK(screen)) { + if (SDL_LockSurface(screen) < 0) { + return; + } + } + + SDL_EraseCursorNoLock(screen); + + /* Unlock the screen and update if necessary */ + if (SDL_MUSTLOCK(screen)) { + SDL_UnlockSurface(screen); + } + if ((screen->flags & SDL_SCREEN_SURFACE) && + !(screen->flags & SDL_HWSURFACE)) { + SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_Window *window; + SDL_Rect area; + + window = SDL_GetWindowFromSurface(screen); + if (!window) { + return; + } + + SDL_MouseRect(&area); + + if (_this->UpdateWindowSurface) { + _this->UpdateWindowSurface(_this, window, 1, &area); + } + } +} + +/* Reset the cursor on video mode change + FIXME: Keep track of all cursors, and reset them all. + */ +void +SDL_ResetCursor(void) +{ + int savelen; + + if (SDL_cursor) { + savelen = SDL_cursor->area.w * 4 * SDL_cursor->area.h; + SDL_cursor->area.x = 0; + SDL_cursor->area.y = 0; + SDL_memset(SDL_cursor->save[0], 0, savelen); + } +} + /* vi: set ts=4 sw=4 expandtab: */ diff -r 9857d21967bb -r eef792d31de8 src/events/SDL_events_c.h --- a/src/events/SDL_events_c.h Mon May 29 05:08:33 2006 +0000 +++ b/src/events/SDL_events_c.h Wed Jun 07 16:10:28 2006 +0000 @@ -23,6 +23,7 @@ /* Useful functions and variables from SDL_events.c */ #include "SDL_events.h" +#include "SDL_mouse_c.h" /* Start and stop the event processing loop */ extern int SDL_StartEventLoop(Uint32 flags); @@ -33,41 +34,25 @@ extern void SDL_Unlock_EventThread(void); extern Uint32 SDL_EventThreadID(void); -/* Event handler init routines */ extern int SDL_KeyboardInit(void); -extern int SDL_MouseInit(void); -extern int SDL_QuitInit(void); +extern int SDL_SendKeyboard(Uint8 state, SDL_keysym * key); +extern void SDL_KeyboardQuit(void); -/* Event handler quit routines */ -extern void SDL_KeyboardQuit(void); -extern void SDL_MouseQuit(void); +extern int SDL_QuitInit(void); +extern int SDL_SendQuit(void); extern void SDL_QuitQuit(void); +extern int SDL_SendWindowEvent(SDL_WindowID windowID, Uint8 windowevent, + int data1, int data2); + +extern int SDL_SendSysWMEvent(SDL_SysWMmsg * message); + /* The event filter function */ extern SDL_EventFilter SDL_EventOK; /* The array of event processing states */ extern Uint8 SDL_ProcessEvents[SDL_NUMEVENTS]; -/* Internal event queueing functions - (from SDL_mouse.c, SDL_keyboard.c, SDL_quit.c, SDL_events.c, SDL_windowevents.c) - */ -extern int SDL_PrivateWindowEvent(SDL_WindowID windowID, Uint8 windowevent, - int data1, int data2); -extern int SDL_PrivateMouseMotion(Uint8 buttonstate, int relative, Sint16 x, - Sint16 y); -extern int SDL_PrivateMouseButton(Uint8 state, Uint8 button, Sint16 x, - Sint16 y); -extern int SDL_PrivateKeyboard(Uint8 state, SDL_keysym * key); -extern int SDL_PrivateQuit(void); -extern int SDL_PrivateSysWMEvent(SDL_SysWMmsg * message); - -/* Used by the activity event handler to remove mouse focus */ -extern void SDL_ResetMouse(void); - -/* Used by the activity event handler to remove keyboard focus */ -extern void SDL_ResetKeyboard(void); - /* Used by the event loop to queue pending keyboard repeat events */ extern void SDL_CheckKeyRepeat(void); diff -r 9857d21967bb -r eef792d31de8 src/events/SDL_keyboard.c --- a/src/events/SDL_keyboard.c Mon May 29 05:08:33 2006 +0000 +++ b/src/events/SDL_keyboard.c Wed Jun 07 16:10:28 2006 +0000 @@ -326,7 +326,7 @@ for (key = SDLK_FIRST; key < SDLK_LAST; ++key) { if (SDL_KeyState[key] == SDL_PRESSED) { keysym.sym = key; - SDL_PrivateKeyboard(SDL_RELEASED, &keysym); + SDL_SendKeyboard(SDL_RELEASED, &keysym); } } SDL_KeyRepeat.timestamp = 0; @@ -382,7 +382,7 @@ /* These are global for SDL_eventloop.c */ int -SDL_PrivateKeyboard(Uint8 state, SDL_keysym * keysym) +SDL_SendKeyboard(Uint8 state, SDL_keysym * keysym) { SDL_Event event; int posted, repeatable; diff -r 9857d21967bb -r eef792d31de8 src/events/SDL_mouse.c --- a/src/events/SDL_mouse.c Mon May 29 05:08:33 2006 +0000 +++ b/src/events/SDL_mouse.c Wed Jun 07 16:10:28 2006 +0000 @@ -25,249 +25,261 @@ #include "SDL_events.h" #include "SDL_events_c.h" -#include "../video/SDL_cursor_c.h" -#include "../video/SDL_sysvideo.h" +#include "SDL_mouse_c.h" -/* These are static for our mouse handling code */ -static Sint16 SDL_MouseX = 0; -static Sint16 SDL_MouseY = 0; -static Sint16 SDL_DeltaX = 0; -static Sint16 SDL_DeltaY = 0; -static Uint8 SDL_ButtonState = 0; +static int SDL_num_mice; +static int SDL_current_mouse; +static SDL_Mouse *SDL_mice; /* Public functions */ int SDL_MouseInit(void) { - /* The mouse is at (0,0) */ - SDL_MouseX = 0; - SDL_MouseY = 0; - SDL_DeltaX = 0; - SDL_DeltaY = 0; - SDL_ButtonState = 0; + return (0); +} + +int +SDL_AddMouse(SDL_WindowID focus, int x, int y, Uint8 buttonstate) +{ + SDL_Mouse *new_mice; + int index; + SDL_Mouse *mouse; + + new_mice = + (SDL_Mouse *) SDL_realloc(SDL_mice, + (SDL_num_mice + 1) * sizeof(*new_mice)); + if (!new_mice) { + SDL_OutOfMemory(); + return -1; + } - /* That's it! */ - return (0); + index = SDL_num_mice++; + mouse = &SDL_mice[index]; + mouse->focus = focus; + mouse->x = x; + mouse->y = y; + mouse->xdelta = 0; + mouse->ydelta = 0; + mouse->buttonstate = buttonstate; + + return index; +} + +SDL_Mouse * +SDL_GetMouse(int index) +{ + if (index < 0 || index >= SDL_num_mice) { + return NULL; + } + return &SDL_mice[index]; } void SDL_MouseQuit(void) { + SDL_num_mice = 0; + SDL_current_mouse = 0; + + if (SDL_mice) { + SDL_free(SDL_mice); + SDL_mice = NULL; + } +} + +int +SDL_GetNumMice(void) +{ + return SDL_num_mice; } -/* We lost the mouse, so post button up messages for all pressed buttons */ -void -SDL_ResetMouse(void) +int +SDL_SelectMouse(int index) { - Uint8 i; - for (i = 0; i < sizeof(SDL_ButtonState) * 8; ++i) { - if (SDL_ButtonState & SDL_BUTTON(i)) { - SDL_PrivateMouseButton(SDL_RELEASED, i, 0, 0); - } + if (index >= 0 && index < SDL_num_mice) { + SDL_current_mouse = index; } + return SDL_current_mouse; +} + +SDL_WindowID +SDL_GetMouseFocusWindow() +{ + SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse); + + if (!mouse) { + return 0; + } + return mouse->focus; } Uint8 SDL_GetMouseState(int *x, int *y) { + SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse); + + if (!mouse) { + if (x) { + *x = 0; + } + if (y) { + *y = 0; + } + return 0; + } + if (x) { - *x = SDL_MouseX; + *x = mouse->x; } if (y) { - *y = SDL_MouseY; + *y = mouse->y; } - return (SDL_ButtonState); + return mouse->buttonstate; } Uint8 SDL_GetRelativeMouseState(int *x, int *y) { - if (x) - *x = SDL_DeltaX; - if (y) - *y = SDL_DeltaY; - SDL_DeltaX = 0; - SDL_DeltaY = 0; - return (SDL_ButtonState); -} - -static void -ClipOffset(Sint16 * x, Sint16 * y) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); + SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse); - /* This clips absolute mouse coordinates when the apparent - display surface is smaller than the real display surface. - */ - if (SDL_VideoSurface->offset) { - *y -= SDL_VideoSurface->offset / SDL_VideoSurface->pitch; - *x -= (SDL_VideoSurface->offset % SDL_VideoSurface->pitch) / - SDL_VideoSurface->format->BytesPerPixel; - } -} - -/* These are global for SDL_eventloop.c */ -int -SDL_PrivateMouseMotion(Uint8 buttonstate, int relative, Sint16 x, Sint16 y) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - int posted; - Uint16 X, Y; - Sint16 Xrel; - Sint16 Yrel; - - /* Don't handle mouse motion if there's no cursor surface */ - if (SDL_VideoSurface == NULL) { - return (0); + if (!mouse) { + if (x) { + *x = 0; + } + if (y) { + *y = 0; + } + return 0; } - /* Default buttonstate is the current one */ - if (!buttonstate) { - buttonstate = SDL_ButtonState; + if (x) { + *x = mouse->xdelta; } + if (y) { + *y = mouse->ydelta; + } + mouse->xdelta = 0; + mouse->ydelta = 0; + return mouse->buttonstate; +} - Xrel = x; - Yrel = y; - if (relative) { - /* Push the cursor around */ - x = (SDL_MouseX + x); - y = (SDL_MouseY + y); - } else { - /* Do we need to clip {x,y} ? */ - ClipOffset(&x, &y); +int +SDL_SendMouseMotion(int index, SDL_WindowID windowID, int relative, int x, + int y) +{ + SDL_Mouse *mouse = SDL_GetMouse(index); + int posted; + int xrel; + int yrel; + + if (!mouse) { + return 0; } - /* Mouse coordinates range from 0 - width-1 and 0 - height-1 */ - if (x < 0) - X = 0; - else if (x >= SDL_VideoSurface->w) - X = SDL_VideoSurface->w - 1; - else - X = (Uint16) x; + if (windowID) { + mouse->focus = windowID; + } - if (y < 0) - Y = 0; - else if (y >= SDL_VideoSurface->h) - Y = SDL_VideoSurface->h - 1; - else - Y = (Uint16) y; - - /* If not relative mode, generate relative motion from clamped X/Y. - This prevents lots of extraneous large delta relative motion when - the screen is windowed mode and the mouse is outside the window. - */ - if (!relative) { - Xrel = X - SDL_MouseX; - Yrel = Y - SDL_MouseY; + if (relative) { + /* Push the cursor around */ + xrel = x; + yrel = y; + x = (mouse->x + xrel); + y = (mouse->y + yrel); + } else { + xrel = x - mouse->x; + yrel = y - mouse->y; } /* Drop events that don't change state */ - if (!Xrel && !Yrel) { + if (!xrel && !yrel) { #if 0 printf("Mouse event didn't change state - dropped!\n"); #endif - return (0); + return 0; } /* Update internal mouse state */ - SDL_ButtonState = buttonstate; - SDL_MouseX = X; - SDL_MouseY = Y; - SDL_DeltaX += Xrel; - SDL_DeltaY += Yrel; - SDL_MoveCursor(SDL_MouseX, SDL_MouseY); + mouse->xdelta += xrel; + mouse->ydelta += yrel; /* Post the event, if desired */ posted = 0; if (SDL_ProcessEvents[SDL_MOUSEMOTION] == SDL_ENABLE) { SDL_Event event; - SDL_memset(&event, 0, sizeof(event)); - event.type = SDL_MOUSEMOTION; - event.motion.state = buttonstate; - event.motion.x = X; - event.motion.y = Y; - event.motion.xrel = Xrel; - event.motion.yrel = Yrel; + event.motion.type = SDL_MOUSEMOTION; + event.motion.which = (Uint8) index; + event.motion.state = mouse->buttonstate; + event.motion.x = mouse->x; + event.motion.y = mouse->y; + event.motion.xrel = xrel; + event.motion.yrel = yrel; + event.motion.windowID = mouse->focus; if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) { posted = 1; SDL_PushEvent(&event); } } - return (posted); + return posted; } int -SDL_PrivateMouseButton(Uint8 state, Uint8 button, Sint16 x, Sint16 y) +SDL_PrivateMouseButton(int index, SDL_WindowID windowID, Uint8 state, + Uint8 button) { - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_Event event; + SDL_Mouse *mouse = SDL_GetMouse(index); int posted; - int move_mouse; - Uint8 buttonstate; - - SDL_memset(&event, 0, sizeof(event)); + Uint8 type; - /* Check parameters */ - if (x || y) { - ClipOffset(&x, &y); - move_mouse = 1; - /* Mouse coordinates range from 0 - width-1 and 0 - height-1 */ - if (x < 0) - x = 0; - else if (x >= SDL_VideoSurface->w) - x = SDL_VideoSurface->w - 1; + if (!mouse) { + return 0; + } - if (y < 0) - y = 0; - else if (y >= SDL_VideoSurface->h) - y = SDL_VideoSurface->h - 1; - } else { - move_mouse = 0; + if (windowID) { + mouse->focus = windowID; } - if (!x) - x = SDL_MouseX; - if (!y) - y = SDL_MouseY; /* Figure out which event to perform */ - buttonstate = SDL_ButtonState; switch (state) { case SDL_PRESSED: - event.type = SDL_MOUSEBUTTONDOWN; - buttonstate |= SDL_BUTTON(button); + if (mouse->buttonstate & SDL_BUTTON(button)) { + /* Ignore this event, no state change */ + return 0; + } + type = SDL_MOUSEBUTTONDOWN; + mouse->buttonstate |= SDL_BUTTON(button); break; case SDL_RELEASED: - event.type = SDL_MOUSEBUTTONUP; - buttonstate &= ~SDL_BUTTON(button); + if (!(mouse->buttonstate & SDL_BUTTON(button))) { + /* Ignore this event, no state change */ + return 0; + } + type = SDL_MOUSEBUTTONUP; + mouse->buttonstate &= ~SDL_BUTTON(button); break; default: /* Invalid state -- bail */ - return (0); - } - - /* Update internal mouse state */ - SDL_ButtonState = buttonstate; - if (move_mouse) { - SDL_MouseX = x; - SDL_MouseY = y; - SDL_MoveCursor(SDL_MouseX, SDL_MouseY); + return 0; } /* Post the event, if desired */ posted = 0; - if (SDL_ProcessEvents[event.type] == SDL_ENABLE) { + if (SDL_ProcessEvents[type] == SDL_ENABLE) { + SDL_Event event; + event.type = type; + event.button.which = (Uint8) index; event.button.state = state; event.button.button = button; - event.button.x = x; - event.button.y = y; + event.button.x = mouse->x; + event.button.y = mouse->y; + event.button.windowID = windowID; if ((SDL_EventOK == NULL) || (*SDL_EventOK) (&event)) { posted = 1; SDL_PushEvent(&event); } } - return (posted); + return posted; } /* vi: set ts=4 sw=4 expandtab: */ diff -r 9857d21967bb -r eef792d31de8 src/events/SDL_mouse_c.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/events/SDL_mouse_c.h Wed Jun 07 16:10:28 2006 +0000 @@ -0,0 +1,48 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#ifndef _SDL_mouse_c_h +#define _SDL_mouse_c_h + +typedef struct +{ + SDL_WindowID focus; + int x; + int y; + int xdelta; + int ydelta; + Uint8 buttonstate; +} SDL_Mouse; + +extern int SDL_MouseInit(void); +extern int SDL_AddMouse(SDL_WindowID focus, int x, int y, Uint8 buttonstate); +extern SDL_Mouse *SDL_GetMouse(int index); +extern int SDL_SendMouseMotion(int index, SDL_WindowID windowID, int relative, + int x, int y); +extern int SDL_SendMouseButton(int index, SDL_WindowID windowID, Uint8 state, + Uint8 button); +extern void SDL_MouseQuit(void); + +#endif /* _SDL_mouse_c_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff -r 9857d21967bb -r eef792d31de8 src/events/SDL_quit.c --- a/src/events/SDL_quit.c Mon May 29 05:08:33 2006 +0000 +++ b/src/events/SDL_quit.c Wed Jun 07 16:10:28 2006 +0000 @@ -39,7 +39,7 @@ signal(sig, SDL_HandleSIG); /* Signal a quit interrupt */ - SDL_PrivateQuit(); + SDL_SendQuit(); } #endif /* HAVE_SIGNAL_H */ @@ -80,7 +80,7 @@ /* This function returns 1 if it's okay to close the application window */ int -SDL_PrivateQuit(void) +SDL_SendQuit(void) { int posted; diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_blit.c --- a/src/video/SDL_blit.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_blit.c Wed Jun 07 16:10:28 2006 +0000 @@ -217,8 +217,6 @@ int SDL_CalculateBlit(SDL_Surface * surface) { - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - const SDL_VideoInfo *info = SDL_GetVideoInfo(); int blit_index; /* Clean everything out to start */ @@ -227,52 +225,6 @@ } surface->map->sw_blit = NULL; - /* Figure out if an accelerated hardware blit is possible */ - surface->flags &= ~SDL_HWACCEL; - if (surface->map->identity) { - int hw_blit_ok; - - if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) { - /* We only support accelerated blitting to hardware */ - if (surface->map->dst->flags & SDL_HWSURFACE) { - hw_blit_ok = info->blit_hw; - } else { - hw_blit_ok = 0; - } - if (hw_blit_ok && (surface->flags & SDL_SRCCOLORKEY)) { - hw_blit_ok = info->blit_hw_CC; - } - if (hw_blit_ok && (surface->flags & SDL_SRCALPHA)) { - hw_blit_ok = info->blit_hw_A; - } - } else { - /* We only support accelerated blitting to hardware */ - if (surface->map->dst->flags & SDL_HWSURFACE) { - hw_blit_ok = info->blit_sw; - } else { - hw_blit_ok = 0; - } - if (hw_blit_ok && (surface->flags & SDL_SRCCOLORKEY)) { - hw_blit_ok = info->blit_sw_CC; - } - if (hw_blit_ok && (surface->flags & SDL_SRCALPHA)) { - hw_blit_ok = info->blit_sw_A; - } - } - if (hw_blit_ok) { - _this->CheckHWBlit(_this, surface, surface->map->dst); - } - } - - /* if an alpha pixel format is specified, we can accelerate alpha blits */ - if (((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) - && (_this->displayformatalphapixel)) { - if ((surface->flags & SDL_SRCALPHA)) - if (info->blit_hw_A) { - _this->CheckHWBlit(_this, surface, surface->map->dst); - } - } - /* Get the blit function index, based on surface mode */ /* { 0 = nothing, 1 = colorkey, 2 = alpha, 3 = colorkey+alpha } */ blit_index = 0; @@ -321,9 +273,7 @@ } /* Choose software blitting function */ - if (surface->flags & SDL_RLEACCELOK - && (surface->flags & SDL_HWACCEL) != SDL_HWACCEL) { - + if (surface->flags & SDL_RLEACCELOK) { if (surface->map->identity && (blit_index == 1 || (blit_index == 3 && !surface->format->Amask))) { diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_bmp.c --- a/src/video/SDL_bmp.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_bmp.c Wed Jun 07 16:10:28 2006 +0000 @@ -203,9 +203,9 @@ } /* Create a compatible surface, note that the colors are RGB ordered */ - surface = SDL_CreateRGBSurface(SDL_SWSURFACE, - biWidth, biHeight, biBitCount, Rmask, - Gmask, Bmask, 0); + surface = + SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask, + Bmask, 0); if (surface == NULL) { was_error = 1; goto done; @@ -386,8 +386,7 @@ SDL_Rect bounds; /* Convert to 24 bits per pixel */ - surface = SDL_CreateRGBSurface(SDL_SWSURFACE, - saveme->w, saveme->h, 24, + surface = SDL_CreateRGBSurface(0, saveme->w, saveme->h, 24, #if SDL_BYTEORDER == SDL_LIL_ENDIAN 0x00FF0000, 0x0000FF00, 0x000000FF, #else diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_cursor.c --- a/src/video/SDL_cursor.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_cursor.c Wed Jun 07 16:10:28 2006 +0000 @@ -23,22 +23,17 @@ /* General cursor handling code for SDL */ -#include "SDL_mutex.h" #include "SDL_video.h" #include "SDL_mouse.h" -#include "SDL_blit.h" #include "SDL_sysvideo.h" #include "SDL_cursor_c.h" -#include "SDL_pixels_c.h" #include "default_cursor.h" -#include "../events/SDL_sysevents.h" -#include "../events/SDL_events_c.h" /* These are static for our cursor handling code */ +/* FIXME: Add support for multiple simultaneous cursors */ volatile int SDL_cursorstate = CURSOR_VISIBLE; SDL_Cursor *SDL_cursor = NULL; static SDL_Cursor *SDL_defcursor = NULL; -SDL_mutex *SDL_cursorlock = NULL; /* Public functions */ void @@ -58,13 +53,10 @@ SDL_FreeCursor(cursor); } } - if (SDL_cursorlock != NULL) { - SDL_DestroyMutex(SDL_cursorlock); - SDL_cursorlock = NULL; - } } + int -SDL_CursorInit(Uint32 multithreaded) +SDL_CursorInit(void) { /* We don't have mouse focus, and the cursor isn't drawn yet */ #ifndef IPOD @@ -79,43 +71,15 @@ SDL_SetCursor(SDL_defcursor); } - /* Create a lock if necessary */ - if (multithreaded) { - SDL_cursorlock = SDL_CreateMutex(); - } - /* That's it! */ return (0); } -/* Multi-thread support for cursors */ -#ifndef SDL_LockCursor -void -SDL_LockCursor(void) -{ - if (SDL_cursorlock) { - SDL_mutexP(SDL_cursorlock); - } -} -#endif -#ifndef SDL_UnlockCursor -void -SDL_UnlockCursor(void) -{ - if (SDL_cursorlock) { - SDL_mutexV(SDL_cursorlock); - } -} -#endif - -/* Software cursor drawing support */ SDL_Cursor * SDL_CreateCursor(Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y) { SDL_VideoDevice *_this = SDL_GetVideoDevice(); - int savelen; - int i; SDL_Cursor *cursor; /* Make sure the width is a multiple of 8 */ @@ -127,41 +91,10 @@ return (NULL); } - /* Allocate memory for the cursor */ - cursor = (SDL_Cursor *) SDL_malloc(sizeof *cursor); - if (cursor == NULL) { - SDL_OutOfMemory(); - return (NULL); - } - savelen = (w * 4) * h; - cursor->area.x = 0; - cursor->area.y = 0; - cursor->area.w = w; - cursor->area.h = h; - cursor->hot_x = hot_x; - cursor->hot_y = hot_y; - cursor->data = (Uint8 *) SDL_malloc((w / 8) * h * 2); - cursor->mask = cursor->data + ((w / 8) * h); - cursor->save[0] = (Uint8 *) SDL_malloc(savelen * 2); - cursor->save[1] = cursor->save[0] + savelen; - cursor->wm_cursor = NULL; - if (!cursor->data || !cursor->save[0]) { - SDL_FreeCursor(cursor); - SDL_OutOfMemory(); - return (NULL); - } - for (i = ((w / 8) * h) - 1; i >= 0; --i) { - cursor->data[i] = data[i]; - cursor->mask[i] = mask[i] | data[i]; - } - SDL_memset(cursor->save[0], 0, savelen * 2); - - /* If the window manager gives us a good cursor, we're done! */ if (_this->CreateWMCursor) { - cursor->wm_cursor = _this->CreateWMCursor(_this, data, mask, - w, h, hot_x, hot_y); + cursor = _this->CreateWMCursor(_this, data, mask, w, h, hot_x, hot_y); } else { - cursor->wm_cursor = NULL; + cursor = NULL; } return (cursor); } @@ -180,56 +113,22 @@ return; } - /* Prevent the event thread from moving the mouse */ - SDL_LockCursor(); - /* Set the new cursor */ if (cursor && (cursor != SDL_cursor)) { - /* Erase the current mouse position */ - if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { - SDL_EraseCursor(SDL_VideoSurface); - } else if (_this->MoveWMCursor) { - /* If the video driver is moving the cursor directly, - it needs to hide the old cursor before (possibly) - showing the new one. (But don't erase NULL cursor) - */ - if (SDL_cursor) { - _this->ShowWMCursor(_this, NULL); - } - } SDL_cursor = cursor; } /* Draw the new mouse cursor */ if (SDL_cursor && (SDL_cursorstate & CURSOR_VISIBLE)) { - /* Use window manager cursor if possible */ - if (SDL_cursor->wm_cursor && - _this->ShowWMCursor(_this, SDL_cursor->wm_cursor)) { - SDL_cursorstate &= ~CURSOR_USINGSW; - } else { - SDL_cursorstate |= CURSOR_USINGSW; - if (_this->ShowWMCursor) { - _this->ShowWMCursor(_this, NULL); - } - { - int x, y; - SDL_GetMouseState(&x, &y); - SDL_cursor->area.x = (x - SDL_cursor->hot_x); - SDL_cursor->area.y = (y - SDL_cursor->hot_y); - } - SDL_DrawCursor(SDL_VideoSurface); + if (_this->ShowWMCursor) { + _this->ShowWMCursor(_this, SDL_cursor); } } else { /* Erase window manager mouse (cursor not visible) */ - if (SDL_cursor && (SDL_cursorstate & CURSOR_USINGSW)) { - SDL_EraseCursor(SDL_VideoSurface); - } else { - if (_this) { - _this->ShowWMCursor(_this, NULL); - } + if (_this->ShowWMCursor) { + _this->ShowWMCursor(_this, NULL); } } - SDL_UnlockCursor(); } SDL_Cursor * @@ -248,16 +147,9 @@ if (cursor != SDL_defcursor) { SDL_VideoDevice *_this = SDL_GetVideoDevice(); - if (cursor->data) { - SDL_free(cursor->data); + if (_this && _this->FreeWMCursor) { + _this->FreeWMCursor(_this, cursor); } - if (cursor->save[0]) { - SDL_free(cursor->save[0]); - } - if (_this && cursor->wm_cursor) { - _this->FreeWMCursor(_this, cursor->wm_cursor); - } - SDL_free(cursor); } } } @@ -269,13 +161,11 @@ showing = (SDL_cursorstate & CURSOR_VISIBLE); if (toggle >= 0) { - SDL_LockCursor(); if (toggle) { SDL_cursorstate |= CURSOR_VISIBLE; } else { SDL_cursorstate &= ~CURSOR_VISIBLE; } - SDL_UnlockCursor(); if ((SDL_cursorstate & CURSOR_VISIBLE) != showing) { SDL_VideoDevice *_this = SDL_GetVideoDevice(); @@ -291,509 +181,23 @@ } void -SDL_WarpMouse(Uint16 x, Uint16 y) +SDL_WarpMouseInWindow(SDL_WindowID windowID, int x, int y) { SDL_VideoDevice *_this = SDL_GetVideoDevice(); - if (!_this || !SDL_PublicSurface) { - SDL_SetError("A video mode must be set before warping mouse"); + /* FIXME: This should specify the target window */ + if (!_this || !SDL_CurrentDisplay.num_windows) { + SDL_SetError("A window must be created before warping mouse"); return; } - /* If we have an offset video mode, offset the mouse coordinates */ - if (SDL_VideoSurface->pitch == 0) { - x += SDL_VideoSurface->offset / - SDL_VideoSurface->format->BytesPerPixel; - y += SDL_VideoSurface->offset; - } else { - x += (SDL_VideoSurface->offset % SDL_VideoSurface->pitch) / - SDL_VideoSurface->format->BytesPerPixel; - y += (SDL_VideoSurface->offset / SDL_VideoSurface->pitch); + if (!windowID) { + windowID = SDL_CurrentWindow; } /* This generates a mouse motion event */ if (_this->WarpWMCursor) { - _this->WarpWMCursor(_this, x, y); - } else { - SDL_PrivateMouseMotion(0, 0, x, y); - } -} - -void -SDL_MoveCursor(int x, int y) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - - /* Erase and update the current mouse position */ - if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { - /* Erase and redraw mouse cursor in new position */ - SDL_LockCursor(); - SDL_EraseCursor(SDL_VideoSurface); - SDL_cursor->area.x = (x - SDL_cursor->hot_x); - SDL_cursor->area.y = (y - SDL_cursor->hot_y); - SDL_DrawCursor(SDL_VideoSurface); - SDL_UnlockCursor(); - } else if (_this->MoveWMCursor) { - _this->MoveWMCursor(_this, x, y); - } -} - -/* Keep track of the current cursor colors */ -static int palette_changed = 1; -static Uint8 pixels8[2]; - -void -SDL_CursorPaletteChanged(void) -{ - palette_changed = 1; -} - -void -SDL_MouseRect(SDL_Rect * area) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - int clip_diff; - - *area = SDL_cursor->area; - if (area->x < 0) { - area->w += area->x; - area->x = 0; - } - if (area->y < 0) { - area->h += area->y; - area->y = 0; - } - clip_diff = (area->x + area->w) - SDL_VideoSurface->w; - if (clip_diff > 0) { - area->w = area->w < clip_diff ? 0 : area->w - clip_diff; - } - clip_diff = (area->y + area->h) - SDL_VideoSurface->h; - if (clip_diff > 0) { - area->h = area->h < clip_diff ? 0 : area->h - clip_diff; - } -} - -static void -SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area) -{ - const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 }; - int i, w, h; - Uint8 *data, datab; - Uint8 *mask, maskb; - - data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; - mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; - switch (screen->format->BytesPerPixel) { - - case 1: - { - Uint8 *dst; - int dstskip; - - if (palette_changed) { - pixels8[0] = - (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); - pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); - palette_changed = 0; - } - dst = (Uint8 *) screen->pixels + - (SDL_cursor->area.y + area->y) * screen->pitch + - SDL_cursor->area.x; - dstskip = screen->pitch - area->w; - - for (h = area->h; h; h--) { - for (w = area->w / 8; w; w--) { - maskb = *mask++; - datab = *data++; - for (i = 0; i < 8; ++i) { - if (maskb & 0x80) { - *dst = pixels8[datab >> 7]; - } - maskb <<= 1; - datab <<= 1; - dst++; - } - } - dst += dstskip; - } - } - break; - - case 2: - { - Uint16 *dst; - int dstskip; - - dst = (Uint16 *) screen->pixels + - (SDL_cursor->area.y + area->y) * screen->pitch / 2 + - SDL_cursor->area.x; - dstskip = (screen->pitch / 2) - area->w; - - for (h = area->h; h; h--) { - for (w = area->w / 8; w; w--) { - maskb = *mask++; - datab = *data++; - for (i = 0; i < 8; ++i) { - if (maskb & 0x80) { - *dst = (Uint16) pixels[datab >> 7]; - } - maskb <<= 1; - datab <<= 1; - dst++; - } - } - dst += dstskip; - } - } - break; - - case 3: - { - Uint8 *dst; - int dstskip; - - dst = (Uint8 *) screen->pixels + - (SDL_cursor->area.y + area->y) * screen->pitch + - SDL_cursor->area.x * 3; - dstskip = screen->pitch - area->w * 3; - - for (h = area->h; h; h--) { - for (w = area->w / 8; w; w--) { - maskb = *mask++; - datab = *data++; - for (i = 0; i < 8; ++i) { - if (maskb & 0x80) { - SDL_memset(dst, pixels[datab >> 7], 3); - } - maskb <<= 1; - datab <<= 1; - dst += 3; - } - } - dst += dstskip; - } - } - break; - - case 4: - { - Uint32 *dst; - int dstskip; - - dst = (Uint32 *) screen->pixels + - (SDL_cursor->area.y + area->y) * screen->pitch / 4 + - SDL_cursor->area.x; - dstskip = (screen->pitch / 4) - area->w; - - for (h = area->h; h; h--) { - for (w = area->w / 8; w; w--) { - maskb = *mask++; - datab = *data++; - for (i = 0; i < 8; ++i) { - if (maskb & 0x80) { - *dst = pixels[datab >> 7]; - } - maskb <<= 1; - datab <<= 1; - dst++; - } - } - dst += dstskip; - } - } - break; - } -} - -static void -SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area) -{ - const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 }; - int h; - int x, minx, maxx; - Uint8 *data, datab = 0; - Uint8 *mask, maskb = 0; - Uint8 *dst; - int dstbpp, dstskip; - - data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; - mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; - dstbpp = screen->format->BytesPerPixel; - dst = (Uint8 *) screen->pixels + - (SDL_cursor->area.y + area->y) * screen->pitch + - SDL_cursor->area.x * dstbpp; - dstskip = screen->pitch - SDL_cursor->area.w * dstbpp; - - minx = area->x; - maxx = area->x + area->w; - if (screen->format->BytesPerPixel == 1) { - if (palette_changed) { - pixels8[0] = (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); - pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); - palette_changed = 0; - } - for (h = area->h; h; h--) { - for (x = 0; x < SDL_cursor->area.w; ++x) { - if ((x % 8) == 0) { - maskb = *mask++; - datab = *data++; - } - if ((x >= minx) && (x < maxx)) { - if (maskb & 0x80) { - SDL_memset(dst, pixels8[datab >> 7], dstbpp); - } - } - maskb <<= 1; - datab <<= 1; - dst += dstbpp; - } - dst += dstskip; - } - } else { - for (h = area->h; h; h--) { - for (x = 0; x < SDL_cursor->area.w; ++x) { - if ((x % 8) == 0) { - maskb = *mask++; - datab = *data++; - } - if ((x >= minx) && (x < maxx)) { - if (maskb & 0x80) { - SDL_memset(dst, pixels[datab >> 7], dstbpp); - } - } - maskb <<= 1; - datab <<= 1; - dst += dstbpp; - } - dst += dstskip; - } - } -} - -/* This handles the ugly work of converting the saved cursor background from - the pixel format of the shadow surface to that of the video surface. - This is only necessary when blitting from a shadow surface of a different - pixel format than the video surface, and using a software rendered cursor. -*/ -static void -SDL_ConvertCursorSave(SDL_Surface * screen, int w, int h) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_BlitInfo info; - SDL_loblit RunBlit; - - /* Make sure we can steal the blit mapping */ - if (screen->map->dst != SDL_VideoSurface) { - return; - } - - /* Set up the blit information */ - info.s_pixels = SDL_cursor->save[1]; - info.s_width = w; - info.s_height = h; - info.s_skip = 0; - info.d_pixels = SDL_cursor->save[0]; - info.d_width = w; - info.d_height = h; - info.d_skip = 0; - info.aux_data = screen->map->sw_data->aux_data; - info.src = screen->format; - info.table = screen->map->table; - info.dst = SDL_VideoSurface->format; - RunBlit = screen->map->sw_data->blit; - - /* Run the actual software blit */ - RunBlit(&info); -} - -void -SDL_DrawCursorNoLock(SDL_Surface * screen) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_Rect area; - - /* Get the mouse rectangle, clipped to the screen */ - SDL_MouseRect(&area); - if ((area.w == 0) || (area.h == 0)) { - return; - } - - /* Copy mouse background */ - { - int w, h, screenbpp; - Uint8 *src, *dst; - - /* Set up the copy pointers */ - screenbpp = screen->format->BytesPerPixel; - if ((screen == SDL_VideoSurface) || - FORMAT_EQUAL(screen->format, SDL_VideoSurface->format)) { - dst = SDL_cursor->save[0]; - } else { - dst = SDL_cursor->save[1]; - } - src = (Uint8 *) screen->pixels + area.y * screen->pitch + - area.x * screenbpp; - - /* Perform the copy */ - w = area.w * screenbpp; - h = area.h; - while (h--) { - SDL_memcpy(dst, src, w); - dst += w; - src += screen->pitch; - } - } - - /* Draw the mouse cursor */ - area.x -= SDL_cursor->area.x; - area.y -= SDL_cursor->area.y; - if ((area.x == 0) && (area.w == SDL_cursor->area.w)) { - SDL_DrawCursorFast(screen, &area); - } else { - SDL_DrawCursorSlow(screen, &area); - } -} - -void -SDL_DrawCursor(SDL_Surface * screen) -{ - /* Lock the screen if necessary */ - if (screen == NULL) { - return; - } - if (SDL_MUSTLOCK(screen)) { - if (SDL_LockSurface(screen) < 0) { - return; - } - } - - SDL_DrawCursorNoLock(screen); - - /* Unlock the screen and update if necessary */ - if (SDL_MUSTLOCK(screen)) { - SDL_UnlockSurface(screen); - } - if ((screen->flags & SDL_SCREEN_SURFACE) && - !(screen->flags & SDL_HWSURFACE)) { - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_Window *window; - SDL_Rect area; - - window = SDL_GetWindowFromSurface(screen); - if (!window) { - return; - } - - SDL_MouseRect(&area); - - if (_this->UpdateWindowSurface) { - _this->UpdateWindowSurface(_this, window, 1, &area); - } - } -} - -void -SDL_EraseCursorNoLock(SDL_Surface * screen) -{ - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_Window *window; - SDL_Rect area; - - /* Get the window associated with the surface */ - window = SDL_GetWindowFromSurface(screen); - if (!window || !window->surface) { - return; - } - - /* Get the mouse rectangle, clipped to the screen */ - SDL_MouseRect(&area); - if ((area.w == 0) || (area.h == 0)) { - return; - } - - /* Copy mouse background */ - { - int w, h, screenbpp; - Uint8 *src, *dst; - - /* Set up the copy pointers */ - screenbpp = screen->format->BytesPerPixel; - if ((screen->flags & SDL_SCREEN_SURFACE) || - FORMAT_EQUAL(screen->format, window->surface->format)) { - src = SDL_cursor->save[0]; - } else { - src = SDL_cursor->save[1]; - } - dst = (Uint8 *) screen->pixels + area.y * screen->pitch + - area.x * screenbpp; - - /* Perform the copy */ - w = area.w * screenbpp; - h = area.h; - while (h--) { - SDL_memcpy(dst, src, w); - src += w; - dst += screen->pitch; - } - - /* Perform pixel conversion on cursor background */ - if (src > SDL_cursor->save[1]) { - SDL_ConvertCursorSave(screen, area.w, area.h); - } - } -} - -void -SDL_EraseCursor(SDL_Surface * screen) -{ - /* Lock the screen if necessary */ - if (screen == NULL) { - return; - } - if (SDL_MUSTLOCK(screen)) { - if (SDL_LockSurface(screen) < 0) { - return; - } - } - - SDL_EraseCursorNoLock(screen); - - /* Unlock the screen and update if necessary */ - if (SDL_MUSTLOCK(screen)) { - SDL_UnlockSurface(screen); - } - if ((screen->flags & SDL_SCREEN_SURFACE) && - !(screen->flags & SDL_HWSURFACE)) { - SDL_VideoDevice *_this = SDL_GetVideoDevice(); - SDL_Window *window; - SDL_Rect area; - - window = SDL_GetWindowFromSurface(screen); - if (!window) { - return; - } - - SDL_MouseRect(&area); - - if (_this->UpdateWindowSurface) { - _this->UpdateWindowSurface(_this, window, 1, &area); - } - } -} - -/* Reset the cursor on video mode change - FIXME: Keep track of all cursors, and reset them all. - */ -void -SDL_ResetCursor(void) -{ - int savelen; - - if (SDL_cursor) { - savelen = SDL_cursor->area.w * 4 * SDL_cursor->area.h; - SDL_cursor->area.x = 0; - SDL_cursor->area.y = 0; - SDL_memset(SDL_cursor->save[0], 0, savelen); + _this->WarpWMCursor(_this, windowID, x, y); } } diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_cursor_c.h --- a/src/video/SDL_cursor_c.h Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_cursor_c.h Wed Jun 07 16:10:28 2006 +0000 @@ -24,51 +24,12 @@ /* Useful variables and functions from SDL_cursor.c */ #include "SDL_mouse.h" -extern int SDL_CursorInit(Uint32 flags); -extern void SDL_CursorPaletteChanged(void); -extern void SDL_DrawCursor(SDL_Surface * screen); -extern void SDL_DrawCursorNoLock(SDL_Surface * screen); -extern void SDL_EraseCursor(SDL_Surface * screen); -extern void SDL_EraseCursorNoLock(SDL_Surface * screen); -extern void SDL_UpdateCursor(SDL_Surface * screen); -extern void SDL_ResetCursor(void); -extern void SDL_MoveCursor(int x, int y); +extern int SDL_CursorInit(void); extern void SDL_CursorQuit(void); -#define INLINE_MOUSELOCK -#ifdef INLINE_MOUSELOCK -/* Inline (macro) versions of the mouse lock functions */ -#include "SDL_mutex.h" - -extern SDL_mutex *SDL_cursorlock; - -#define SDL_LockCursor() \ - do { \ - if ( SDL_cursorlock ) { \ - SDL_mutexP(SDL_cursorlock); \ - } \ - } while ( 0 ) -#define SDL_UnlockCursor() \ - do { \ - if ( SDL_cursorlock ) { \ - SDL_mutexV(SDL_cursorlock); \ - } \ - } while ( 0 ) -#else -extern void SDL_LockCursor(void); -extern void SDL_UnlockCursor(void); -#endif /* INLINE_MOUSELOCK */ - -/* Only for low-level mouse cursor drawing */ -extern SDL_Cursor *SDL_cursor; -extern void SDL_MouseRect(SDL_Rect * area); - /* State definitions for the SDL cursor */ #define CURSOR_VISIBLE 0x01 -#define CURSOR_USINGSW 0x10 -#define SHOULD_DRAWCURSOR(X) \ - (((X)&(CURSOR_VISIBLE|CURSOR_USINGSW)) == \ - (CURSOR_VISIBLE|CURSOR_USINGSW)) extern volatile int SDL_cursorstate; + /* vi: set ts=4 sw=4 expandtab: */ diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_pixels.c --- a/src/video/SDL_pixels.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_pixels.c Wed Jun 07 16:10:28 2006 +0000 @@ -480,10 +480,10 @@ /* * Calculate the pad-aligned scanline width of a surface */ -Uint16 +int SDL_CalculatePitch(SDL_Surface * surface) { - Uint16 pitch; + int pitch; /* Surface should be 4-byte aligned for speed */ pitch = surface->w * surface->format->BytesPerPixel; diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_pixels_c.h --- a/src/video/SDL_pixels_c.h Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_pixels_c.h Wed Jun 07 16:10:28 2006 +0000 @@ -42,7 +42,7 @@ extern void SDL_FreeBlitMap(SDL_BlitMap * map); /* Miscellaneous functions */ -extern Uint16 SDL_CalculatePitch(SDL_Surface * surface); +extern int SDL_CalculatePitch(SDL_Surface * surface); extern void SDL_DitherColors(SDL_Color * colors, int bpp); extern Uint8 SDL_FindColor(SDL_Palette * pal, Uint8 r, Uint8 g, Uint8 b); extern void SDL_ApplyGamma(Uint16 * gamma, SDL_Color * colors, diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_surface.c --- a/src/video/SDL_surface.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_surface.c Wed Jun 07 16:10:28 2006 +0000 @@ -43,6 +43,7 @@ SDL_Surface *screen; SDL_Surface *surface; + /* FIXME!! */ /* Make sure the size requested doesn't overflow our datatypes */ /* Next time I write a library like SDL, I'll use int for size. :) */ if (width >= 16384 || height >= 65536) { @@ -50,52 +51,13 @@ return (NULL); } - /* Check to see if we desire the surface in video memory */ - if (_this) { - screen = SDL_PublicSurface; - } else { - screen = NULL; - } - if (screen && ((screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE)) { - if ((flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA)) != 0) { - flags |= SDL_HWSURFACE; - } - if ((flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) { - if (!_this->info.blit_hw_CC) { - flags &= ~SDL_HWSURFACE; - } - } - if ((flags & SDL_SRCALPHA) == SDL_SRCALPHA) { - if (!_this->info.blit_hw_A) { - flags &= ~SDL_HWSURFACE; - } - } - } else { - flags &= ~SDL_HWSURFACE; - } - /* Allocate the surface */ surface = (SDL_Surface *) SDL_malloc(sizeof(*surface)); if (surface == NULL) { SDL_OutOfMemory(); return (NULL); } - surface->flags = SDL_SWSURFACE; - if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) { - if ((Amask) && (_this->displayformatalphapixel)) { - depth = _this->displayformatalphapixel->BitsPerPixel; - Rmask = _this->displayformatalphapixel->Rmask; - Gmask = _this->displayformatalphapixel->Gmask; - Bmask = _this->displayformatalphapixel->Bmask; - Amask = _this->displayformatalphapixel->Amask; - } else { - depth = screen->format->BitsPerPixel; - Rmask = screen->format->Rmask; - Gmask = screen->format->Gmask; - Bmask = screen->format->Bmask; - Amask = screen->format->Amask; - } - } + surface->flags = 0; surface->format = SDL_AllocFormat(depth, Rmask, Gmask, Bmask, Amask); if (surface->format == NULL) { SDL_free(surface); @@ -108,27 +70,22 @@ surface->h = height; surface->pitch = SDL_CalculatePitch(surface); surface->pixels = NULL; - surface->offset = 0; surface->hwdata = NULL; surface->locked = 0; surface->map = NULL; - surface->unused1 = 0; SDL_SetClipRect(surface, NULL); SDL_FormatChanged(surface); /* Get the pixels */ - if (((flags & SDL_HWSURFACE) == SDL_SWSURFACE) || - (_this->AllocHWSurface(_this, surface) < 0)) { - if (surface->w && surface->h) { - surface->pixels = SDL_malloc(surface->h * surface->pitch); - if (surface->pixels == NULL) { - SDL_FreeSurface(surface); - SDL_OutOfMemory(); - return (NULL); - } - /* This is important for bitmaps */ - SDL_memset(surface->pixels, 0, surface->h * surface->pitch); + if (surface->w && surface->h) { + surface->pixels = SDL_malloc(surface->h * surface->pitch); + if (surface->pixels == NULL) { + SDL_FreeSurface(surface); + SDL_OutOfMemory(); + return NULL; } + /* This is important for bitmaps */ + SDL_memset(surface->pixels, 0, surface->h * surface->pitch); } /* Allocate an empty mapping */ @@ -167,7 +124,72 @@ surface->pitch = pitch; SDL_SetClipRect(surface, NULL); } - return (surface); + return surface; +} + +SDL_Surface * +SDL_CreateRGBSurfaceFromTexture(SDL_TextureID textureID) +{ + SDL_Surface *surface; + Uint32 format; + int w, h; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + if (SDL_QueryTexture(textureID, &format, NULL, &w, &h) < 0) { + return NULL; + } + + if (!SDL_PixelFormatEnumToMasks + (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { + SDL_SetError("Unknown texture format"); + return NULL; + } + + surface = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp, + Rmask, Gmask, Bmask, Amask); + if (surface != NULL) { + surface->flags |= (SDL_HWSURFACE | SDL_PREALLOC); + surface->w = width; + surface->h = height; + SDL_SetClipRect(surface, NULL); + } + return surface; +} + +/* + * Set the palette in a blittable surface + */ +int +SDL_SetColors(SDL_Surface * surface, SDL_Color * colors, int firstcolor, + int ncolors) +{ + SDL_Palette *pal; + int gotall; + int palsize; + + /* Verify the parameters */ + pal = surface->format->palette; + if (!pal) { + return 0; /* not a palettized surface */ + } + gotall = 1; + palsize = 1 << surface->format->BitsPerPixel; + if (ncolors > (palsize - firstcolor)) { + ncolors = (palsize - firstcolor); + gotall = 0; + } + + if (colors != (pal->colors + firstcolor)) { + SDL_memcpy(pal->colors + firstcolor, colors, + ncolors * sizeof(*colors)); + } + SDL_FormatChanged(surface); + + if (surface->flags & (SDL_SHADOW_SURFACE | SDL_SCREEN_SURFACE)) { + gotall &= SDL_SetScreenColors(surface, colors, firstcolor, ncolors); + } + return gotall; } /* diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_sysvideo.h --- a/src/video/SDL_sysvideo.h Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_sysvideo.h Wed Jun 07 16:10:28 2006 +0000 @@ -39,9 +39,71 @@ /* The SDL video driver */ +typedef struct SDL_Window SDL_Window; +typedef struct SDL_Texture SDL_Texture; +typedef struct SDL_Renderer SDL_Renderer; +typedef struct SDL_RenderDriver SDL_RenderDriver; +typedef struct SDL_VideoDisplay SDL_VideoDisplay; +typedef struct SDL_VideoDevice SDL_VideoDevice; + +/* Define the SDL texture structure */ +struct SDL_Texture +{ + Uint32 id; + + Uint32 format; /**< The pixel format of the texture */ + int access; /**< SDL_TextureAccess */ + int w; /**< The width of the texture */ + int h; /**< The height of the texture */ + + SDL_Renderer *renderer; + + void *driverdata; /**< Driver specific texture representation */ + + SDL_Texture *next; +}; + +/* Define the SDL renderer structure */ +struct SDL_Renderer +{ + int (*CreateTexture) (SDL_Texture * texture); + int (*UpdateTexture) (SDL_Texture * texture, SDL_Rect * rect, + const void *pixels, int pitch); + int (*LockTexture) (SDL_Texture * texture, SDL_Rect * rect, int markDirty, + void **pixels, int *pitch); + void (*UnlockTexture) (SDL_Texture * texture); + void (*DirtyTexture) (SDL_Texture * texture, int numrects, + SDL_Rect * rects); + void (*SelectRenderTexture) (SDL_Texture * texture); + void (*RenderFill) (SDL_Rect * rect, Uint32 color); + int (*RenderCopy) (SDL_Texture * texture, SDL_Rect * srcrect, + SDL_Rect * dstrect, int blendMode, int scaleMode); + int (*RenderReadPixels) (SDL_Rect * rect, void *pixels, int pitch); + int (*RenderWritePixels) (SDL_Rect * rect, const void *pixels, int pitch); + void (*RenderPresent) (void); + void (*DestroyTexture) (SDL_Texture * texture); + + void (*DestroyRenderer) (SDL_Renderer * renderer); + + /* The current renderer info */ + SDL_RendererInfo info; + + /* The window associated with the renderer */ + SDL_Window *window; + + void *driverdata; +}; + +/* Define the SDL render driver structure */ +struct SDL_RenderDriver +{ + SDL_Renderer *(*CreateRenderer) (SDL_Window * window, Uint32 flags); + + /* Info about the renderer capabilities */ + SDL_RendererInfo info; +}; + /* Define the SDL window structure, corresponding to toplevel windows */ -typedef struct SDL_Window SDL_Window; - struct SDL_Window { Uint32 id; @@ -51,10 +113,10 @@ int w, h; Uint32 flags; - SDL_Surface *surface; - SDL_Surface *shadow; Uint16 *gamma; + SDL_Renderer *renderer; + void *userdata; void *driverdata; }; @@ -62,21 +124,26 @@ /* Define the SDL display structure This corresponds to physical monitors attached to the system. */ -typedef struct SDL_VideoDisplay +struct SDL_VideoDisplay { int num_display_modes; SDL_DisplayMode *display_modes; SDL_DisplayMode desktop_mode; SDL_DisplayMode current_mode; - int max_windows; + int num_render_drivers; + SDL_RenderDriver *render_drivers; + int num_windows; SDL_Window *windows; + SDL_Renderer *current_renderer; + + /* The hash list of textures */ + SDL_Texture *textures[64]; + void *driverdata; -} SDL_VideoDisplay; - -typedef struct SDL_VideoDevice SDL_VideoDevice; +}; /* Define the SDL video driver structure */ #define _THIS SDL_VideoDevice *_this @@ -105,6 +172,13 @@ */ int (*SetDisplayMode) (_THIS, const SDL_DisplayMode * mode); + /* Sets the color entries { firstcolor .. (firstcolor+ncolors-1) } + of the physical palette to those in 'colors'. The return value + is 0 if all entries could be set properly or -1 otherwise. + */ + int (*SetDisplayColors) (_THIS, int firstcolor, int ncolors, + SDL_Color * colors); + /* * * */ /* Window functions */ @@ -122,22 +196,6 @@ void (*SetWindowGrab) (_THIS, SDL_Window * window); void (*DestroyWindow) (_THIS, SDL_Window * window); - void (*CreateWindowSurface) (_THIS, SDL_Window * window, Uint32 flags); - void (*UpdateWindowSurface) (_THIS, SDL_Window * window, int numrects, - SDL_Rect * rects); - void (*FlipWindowSurface) (_THIS, SDL_Window * window); - - /* Sets the color entries { firstcolor .. (firstcolor+ncolors-1) } - of the physical palette to those in 'colors'. If the device is - using a software palette (SDL_HWPALETTE not set), then the - changes are reflected in the logical palette of the screen - as well. - The return value is 1 if all entries could be set properly - or 0 otherwise. - */ - int (*SetWindowColors) (_THIS, SDL_Window * window, - int firstcolor, int ncolors, SDL_Color * colors); - /* Get some platform dependent window information */ SDL_bool(*GetWindowWMInfo) (_THIS, SDL_Window * window, SDL_SysWMinfo * info); @@ -157,9 +215,6 @@ /* * * */ /* Hardware acceleration functions */ - /* Information about the video hardware */ - SDL_VideoInfo info; - /* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */ SDL_PixelFormat *displayformatalphapixel; @@ -242,23 +297,23 @@ /* Free a window manager cursor This function can be NULL if CreateWMCursor is also NULL. */ - void (*FreeWMCursor) (_THIS, WMcursor * cursor); + void (*FreeCursor) (_THIS, SDL_Cursor * cursor); /* If not NULL, create a black/white window manager cursor */ - WMcursor *(*CreateWMCursor) (_THIS, + SDL_Cursor *(*CreateCursor) (_THIS, Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y); /* Show the specified cursor, or hide if cursor is NULL */ - int (*ShowWMCursor) (_THIS, WMcursor * cursor); + int (*ShowCursor) (_THIS, SDL_Cursor * cursor); /* Warp the window manager cursor to (x,y) If NULL, a mouse motion event is posted internally. */ - void (*WarpWMCursor) (_THIS, Uint16 x, Uint16 y); + void (*WarpCursor) (_THIS, SDL_WindowID windowID, int x, int y); /* If not NULL, this is called when a mouse motion event occurs */ - void (*MoveWMCursor) (_THIS, int x, int y); + void (*MoveCursor) (_THIS, int x, int y); /* Determine whether the mouse should be in relative mode or not. This function is called when the input grab state or cursor @@ -283,7 +338,7 @@ int num_displays; SDL_VideoDisplay *displays; int current_display; - Uint32 next_window_id; + Uint32 next_object_id; /* Driver information flags */ @@ -428,15 +483,14 @@ #define SDL_CurrentDisplay (_this->displays[_this->current_display]) #define SDL_CurrentWindow (SDL_CurrentDisplay.windows[0]) -#define SDL_VideoSurface ((_this && SDL_CurrentDisplay.num_windows > 0) ? SDL_CurrentWindow.surface : NULL) -#define SDL_ShadowSurface ((_this && SDL_CurrentDisplay.num_windows > 0) ? SDL_CurrentWindow.shadow : NULL) -#define SDL_PublicSurface (SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface) extern SDL_VideoDevice *SDL_GetVideoDevice(); extern void SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode); extern void SDL_AddVideoDisplay(const SDL_VideoDisplay * display); -extern void SDL_AddDisplayMode(int display, const SDL_DisplayMode * mode); -extern SDL_Window *SDL_GetWindowFromSurface(SDL_Surface * surface); +extern void SDL_AddDisplayMode(int displayIndex, + const SDL_DisplayMode * mode); +extern void SDL_AddRenderDriver(int displayIndex, + const SDL_RenderDriver * driver); #endif /* _SDL_sysvideo_h */ diff -r 9857d21967bb -r eef792d31de8 src/video/SDL_video.c --- a/src/video/SDL_video.c Mon May 29 05:08:33 2006 +0000 +++ b/src/video/SDL_video.c Wed Jun 07 16:10:28 2006 +0000 @@ -231,7 +231,7 @@ } _this = video; _this->name = bootstrap[i]->name; - _this->next_window_id = 1; + _this->next_object_id = 1; /* Set some very sane GL defaults */ @@ -268,16 +268,6 @@ return (-1); } - /* Temporarily here for backwards compatibility */ - { - int bpp; - Uint32 Rmask, Gmask, Bmask, Amask; - - SDL_PixelFormatEnumToMasks(SDL_GetDesktopDisplayMode()->format, &bpp, - &Rmask, &Gmask, &Bmask, &Amask); - _this->info.vfmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); - } - /* Sort the video modes */ for (i = 0; i < _this->num_displays; ++i) { SDL_qsort(_this->displays[i].display_modes, @@ -311,15 +301,6 @@ return _this; } -const SDL_VideoInfo * -SDL_GetVideoInfo(void) -{ - if (!_this) { - return NULL; - } - return &_this->info; -} - void SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode) { @@ -330,7 +311,6 @@ display.desktop_mode = *desktop_mode; } display.current_mode = display.desktop_mode; - display.max_windows = 1; SDL_AddVideoDisplay(&display); } @@ -378,14 +358,15 @@ } void -SDL_AddDisplayMode(int display, const SDL_DisplayMode * mode) +SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode) { + SDL_VideoDisplay *display = &_this->displays[displayIndex]; SDL_DisplayMode *modes; int i, nmodes; /* Make sure we don't already have the mode in the list */ - modes = SDL_CurrentDisplay.display_modes; - nmodes = SDL_CurrentDisplay.num_display_modes; + modes = display->display_modes; + nmodes = display->num_display_modes; for (i = 0; i < nmodes; ++i) { if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) { return; @@ -395,9 +376,9 @@ /* Go ahead and add the new mode */ modes = SDL_realloc(modes, (nmodes + 1) * sizeof(*mode)); if (modes) { - SDL_CurrentDisplay.display_modes = modes; + display->display_modes = modes; modes[nmodes] = *mode; - SDL_CurrentDisplay.num_display_modes++; + display->num_display_modes++; } } @@ -415,7 +396,7 @@ { if (index < 0 || index >= SDL_GetNumDisplayModes()) { SDL_SetError("index must be in the range of 0 - %d", - SDL_GetNumDisplayModes()); + SDL_GetNumDisplayModes() - 1); return NULL; } return &SDL_CurrentDisplay.display_modes[index]; @@ -568,19 +549,6 @@ return 0; } - /* Free any previous window surfaces */ - for (i = 0; i < display->num_windows; ++i) { - SDL_Window *window = &display->windows[i]; - if (window->shadow) { - SDL_FreeSurface(window->shadow); - window->shadow = NULL; - } - if (window->surface) { - SDL_FreeSurface(window->surface); - window->surface = NULL; - } - } - return _this->SetDisplayMode(_this, &display_mode); } @@ -605,7 +573,7 @@ } SDL_zero(window); - window.id = _this->next_window_id++; + window.id = _this->next_object_id++; window.title = title ? SDL_strdup(title) : NULL; window.x = x; window.y = y; @@ -653,7 +621,7 @@ } SDL_zero(window); - window.id = _this->next_window_id++; + window.id = _this->next_object_id++; if (!_this->CreateWindowFrom || _this->CreateWindowFrom(_this, &window, data) < 0) { @@ -701,28 +669,6 @@ return NULL; } -SDL_Window * -SDL_GetWindowFromSurface(SDL_Surface * surface) -{ - int i, j; - - if (!_this || !surface) { - return NULL; - } - - for (i = 0; i < _this->num_displays; ++i) { - SDL_VideoDisplay *display = &_this->displays[i]; - for (j = 0; j < display->num_windows; ++j) { - SDL_Window *window = &display->windows[j]; - if (surface == window->surface || surface == window->shadow) { - return window; - } - } - } - return NULL; -} - - Uint32 SDL_GetWindowFlags(SDL_WindowID windowID) { @@ -998,11 +944,8 @@ window->flags &= ~SDL_WINDOW_INPUT_GRABBED; _this->SetWindowGrab(_this, window); } - if (window->shadow) { - SDL_FreeSurface(window->shadow); - } - if (window->surface) { - SDL_FreeSurface(window->surface); + if (window->renderer) { + SDL_DestroyRenderer(window->id); } if (_this->DestroyWindow) { _this->DestroyWindow(_this, window); @@ -1024,371 +967,569 @@ } } -SDL_Surface * -SDL_CreateWindowSurface(SDL_WindowID windowID, Uint32 format, Uint32 flags) +void +SDL_AddRenderDriver(int displayIndex, const SDL_RenderDriver * driver) +{ + SDL_VideoDisplay *display = &_this->displays[displayIndex]; + SDL_RenderDriver *render_drivers; + + render_drivers = + SDL_realloc(display->render_drivers, + (display->num_render_drivers + + 1) * sizeof(*render_drivers)); + if (render_drivers) { + render_drivers[display->num_render_drivers] = *driver; + display->render_drivers = render_drivers; + display->num_render_drivers++; + } +} + +int +SDL_GetNumRenderers(void) +{ + if (_this) { + return SDL_CurrentDisplay.num_render_drivers; + } + return 0; +} + +int +SDL_GetRendererInfo(int index, SDL_RendererInfo * info) +{ + if (index < 0 || index >= SDL_GetNumRenderers()) { + SDL_SetError("index must be in the range of 0 - %d", + SDL_GetNumRenderers() - 1); + return -1; + } + *info = SDL_CurrentDisplay.render_drivers[index].info; + return 0; +} + +int +SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags) +{ + SDL_Window *window = SDL_GetWindowFromID(windowID); + + if (!window) { + return 0; + } + + if (index < 0) { + int n = SDL_GetNumRenderers(); + for (index = 0; index < n; ++index) { + if ((SDL_CurrentDisplay.render_drivers[index].info. + flags & flags) == flags) { + break; + } + } + if (index == n) { + SDL_SetError("Couldn't find matching render driver"); + return -1; + } + } + + if (index >= SDL_GetNumRenderers()) { + SDL_SetError("index must be -1 or in the range of 0 - %d", + SDL_GetNumRenderers() - 1); + return -1; + } + + /* Free any existing renderer */ + SDL_DestroyRenderer(windowID); + + /* Create a new renderer instance */ + window->renderer = + SDL_CurrentDisplay.render_drivers[index].CreateRenderer(window, + flags); + if (!window->renderer) { + return -1; + } + SDL_CurrentDisplay.current_renderer = window->renderer; + + return 0; +} + +int +SDL_SelectRenderer(SDL_WindowID windowID) { SDL_Window *window = SDL_GetWindowFromID(windowID); - Uint32 black; - SDL_Surface *surface; + + if (!window || !window->renderer) { + return -1; + } + SDL_CurrentDisplay.current_renderer = window->renderer; + return 0; +} + +SDL_TextureID +SDL_CreateTexture(Uint32 format, int access, int w, int h) +{ + SDL_Renderer *renderer; + SDL_Texture *texture; + + if (!_this) { + return 0; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->CreateTexture) { + return 0; + } + + texture = (SDL_Texture *) SDL_malloc(sizeof(*texture)); + if (!texture) { + SDL_OutOfMemory(); + return 0; + } + + SDL_zerop(texture); + texture->id = _this->next_object_id++; + texture->format = format; + texture->access = access; + texture->w = w; + texture->h = h; + texture->renderer = renderer; - if (!window) { - return NULL; + if (renderer->CreateTexture(texture) < 0) { + SDL_free(texture); + return 0; + } +} + +SDL_TextureID +SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface) +{ + SDL_TextureID textureID; + Uint32 surface_flags = surface->flags; + SDL_PixelFormat *fmt = surface->format; + Uint32 colorkey; + Uint8 alpha; + SDL_Rect bounds; + SDL_Surface dst; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + if (!surface) { + SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface"); + return 0; + } + + if (format) { + if (!SDL_PixelFormatEnumToMasks + (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { + SDL_SetError("Unknown pixel format"); + return 0; + } + } else { + bpp = fmt->BitsPerPixel; + Rmask = fmt->Rmask; + Gmask = fmt->Gmask; + Bmask = fmt->Bmask; + Amask = fmt->Amask; + format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask); + if (!format) { + SDL_SetError("Unknown pixel format"); + return 0; + } + } + + textureID = SDL_CreateTexture(format, access, surface->w, surface->h); + if (!textureID) { + return 0; } - if (!_this->CreateWindowSurface) { + /* Set up a destination surface for the texture update */ + SDL_zero(dst); + dst.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); + if (!dst.format) { + SDL_DestroyTexture(textureID); + return 0; + } + dst.w = surface->w; + dst.h = surface->h; + if (SDL_LockTexture(textureID, NULL, 1, &dst.pixels, &dst.pitch) == 0) { + dst.flags |= SDL_PREALLOC; + } else { + dst.pitch = SDL_CalculatePitch(&dst); + dst.pixels = SDL_malloc(dst.h * dst.pitch); + if (!dst.pixels) { + SDL_DestroyTexture(textureID); + SDL_FreeFormat(dst.format); + SDL_OutOfMemory(); + return 0; + } + } + + /* Copy the palette if any */ + if (fmt->palette && dst.format->palette) { + SDL_SetTexturePalette(textureID, fmt->palette->colors, 0, + fmt->palette->ncolors); + + SDL_memcpy(dst.format->palette->colors, + fmt->palette->colors, + fmt->palette->ncolors * sizeof(SDL_Color)); + dst.format->palette->ncolors = fmt->palette->ncolors; + } + + /* Make the texture transparent if the surface has colorkey */ + if (surface_flags & SDL_SRCCOLORKEY) { + int row; + int length = dst.w * dst.format->BytesPerPixel; + Uint8 *p = (Uint8 *) dst.pixels; + for (row = 0; row < dst.h; ++row) { + SDL_memset(p, 0, length); + p += dst.pitch; + } + } + + /* Copy over the alpha channel */ + if (surface_flags & SDL_SRCALPHA) { + if (fmt->Amask) { + surface->flags &= ~SDL_SRCALPHA; + } else { + /* FIXME: Need to make sure the texture has an alpha channel + * and copy 'alpha' into the texture alpha channel. + */ + alpha = surface->format->alpha; + SDL_SetAlpha(surface, 0, 0); + } + } + + /* Copy over the image data */ + bounds.x = 0; + bounds.y = 0; + bounds.w = surface->w; + bounds.h = surface->h; + SDL_LowerBlit(surface, &bounds, &dst, &bounds); + + /* Clean up the original surface */ + if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) { + Uint32 cflags = surface_flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK); + SDL_SetColorKey(surface, cflags, colorkey); + } + if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) { + Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK); + if (fmt->Amask) { + surface->flags |= SDL_SRCALPHA; + } else { + SDL_SetAlpha(surface, aflags, alpha); + } + } + + /* Update the texture */ + if (dst.flags & SDL_PREALLOC) { + SDL_UnlockTexture(textureID); + } else { + SDL_UpdateTexture(textureID, NULL, dst.pixels, dst.pitch); + SDL_free(dst.pixels); + } + SDL_FreeFormat(dst.format); + + return textureID; +} + +static __inline__ SDL_Texture * +SDL_GetTextureFromID(SDL_TextureID textureID) +{ + int hash; + SDL_Texture *texture; + + if (!_this) { return NULL; } - if (!window->surface) { - _this->CreateWindowSurface(_this, window, flags); - if (!window->surface) { - return NULL; - } - window->surface->flags |= SDL_SCREEN_SURFACE; - - /* If we have a palettized surface, create a default palette */ - if (window->surface->format->palette) { - SDL_Color colors[256]; - SDL_PixelFormat *vf = window->surface->format; - SDL_DitherColors(colors, vf->BitsPerPixel); - SDL_SetColors(window->surface, colors, 0, vf->palette->ncolors); + hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures)); + for (texture = SDL_CurrentDisplay.textures[hash]; texture; + texture = texture->next) { + if (texture->id == textureID) { + return texture; } } - surface = window->surface; + return NULL; +} + +int +SDL_QueryTexture(SDL_TextureID textureID, Uint32 * format, int *access, + int *w, int *h) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + + if (!texture) { + return -1; + } + + if (format) { + *format = texture->format; + } + if (access) { + *access = texture->access; + } + if (w) { + *w = texture->w; + } + if (h) { + *h = texture->h; + } + return 0; +} + +int +SDL_UpdateTexture(SDL_TextureID textureID, SDL_Rect * rect, + const void *pixels, int pitch) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture) { + return -1; + } + + renderer = texture->renderer; + if (!renderer->UpdateTexture) { + return -1; + } + return renderer->UpdateTexture(texture, rect, pixels, pitch); +} + +int +SDL_LockTexture(SDL_TextureID textureID, SDL_Rect * rect, int markDirty, + void **pixels, int *pitch) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture) { + return -1; + } - if (window->shadow) { - SDL_FreeSurface(window->shadow); - window->shadow = NULL; + renderer = texture->renderer; + if (!renderer->LockTexture) { + return -1; + } + return renderer->LockTexture(texture, rect, markDirty, pixels, pitch); +} + +void +SDL_UnlockTexture(SDL_TextureID textureID) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture) { + return; + } + + renderer = texture->renderer; + if (!renderer->UnlockTexture) { + return; + } + return renderer->UnlockTexture(texture); +} + +void +SDL_DirtyTexture(SDL_TextureID textureID, int numrects, SDL_Rect * rects) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture) { + return; + } + + renderer = texture->renderer; + if (!renderer->DirtyTexture) { + return; + } + renderer->DirtyTexture(texture, numrects, rects); +} + +void +SDL_SelectRenderTexture(SDL_TextureID textureID) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture || texture->access != SDL_TextureAccess_Render) { + return; + } + renderer = texture->renderer; + if (!renderer->SelectRenderTexture) { + return; + } + renderer->SelectRenderTexture(texture); +} + +int +SDL_RenderFill(SDL_Rect * rect, Uint32 color) +{ + SDL_Renderer *renderer; + + if (!_this) { + return -1; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->RenderFill) { + return -1; } - /* Create a shadow surface if necessary */ - if ((!(flags & SDL_ANYFORMAT) - && (format != SDL_GetCurrentDisplayMode()->format)) - || ((flags & SDL_HWPALETTE) - && !(window->surface->flags & SDL_HWPALETTE))) { - int bpp; - Uint32 Rmask, Gmask, Bmask, Amask; + renderer->RenderFill(rect, color); +} + +int +SDL_RenderCopy(SDL_TextureID textureID, SDL_Rect * srcrect, + SDL_Rect * dstrect, int blendMode, int scaleMode) +{ + SDL_Texture *texture = SDL_GetTextureFromID(textureID); + SDL_Renderer *renderer; + + if (!texture || texture->renderer != SDL_CurrentDisplay.current_renderer) { + return; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->RenderCopy) { + return -1; + } + + return renderer->RenderCopy(texture, srcrect, dstrect, blendMode, + scaleMode); +} + +int +SDL_RenderReadPixels(SDL_Rect * rect, void *pixels, int pitch) +{ + SDL_Renderer *renderer; + + if (!_this) { + return -1; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->RenderReadPixels) { + return -1; + } + + return renderer->RenderReadPixels(rect, pixels, pitch); +} + +int +SDL_RenderWritePixels(SDL_Rect * rect, const void *pixels, int pitch) +{ + SDL_Renderer *renderer; + + if (!_this) { + return -1; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->RenderWritePixels) { + return -1; + } + + return renderer->RenderWritePixels(rect, pixels, pitch); +} + +void +SDL_RenderPresent(void) +{ + SDL_Renderer *renderer; + + if (!_this) { + return; + } + + renderer = SDL_CurrentDisplay.current_renderer; + if (!renderer || !renderer->RenderPresent) { + return; + } - SDL_PixelFormatEnumToMasks(format, &bpp, &Amask, &Gmask, &Bmask, - &Amask); - window->shadow = - SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, bpp, - Rmask, Gmask, Bmask, Amask); - if (window->shadow == NULL) { - return NULL; + renderer->RenderPresent(); +} + +void +SDL_DestroyTexture(SDL_TextureID textureID) +{ + int hash; + SDL_Texture *prev, *texture; + SDL_Renderer *renderer; + + if (!_this) { + return; + } + + /* Look up the texture in the hash table */ + hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures)); + prev = NULL; + for (texture = SDL_CurrentDisplay.textures[hash]; texture; + prev = texture, texture = texture->next) { + if (texture->id == textureID) { + break; } - window->shadow->flags |= SDL_SHADOW_SURFACE; + } + if (!texture) { + return; + } + + /* Unlink the texture from the list */ + if (prev) { + prev->next = texture->next; + } else { + SDL_CurrentDisplay.textures[hash] = texture->next; + } - surface = window->shadow; + /* Free the texture */ + renderer = texture->renderer; + renderer->DestroyTexture(texture); + SDL_free(texture); +} + +void +SDL_DestroyRenderer(SDL_WindowID windowID) +{ + SDL_Window *window = SDL_GetWindowFromID(windowID); + SDL_Renderer *renderer; + int i; + + if (!window) { + return; + } - /* 8-bit shadow surfaces report that they have exclusive palette */ - if (surface->format->palette) { - surface->flags |= SDL_HWPALETTE; - if (format == SDL_GetCurrentDisplayMode()->format) { - SDL_memcpy(surface->format->palette->colors, - window->surface->format->palette->colors, - window->surface->format->palette->ncolors * - sizeof(SDL_Color)); + renderer = window->renderer; + if (!renderer) { + return; + } + + /* Free existing textures for this renderer */ + for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) { + SDL_Texture *texture; + SDL_Texture *prev = NULL; + SDL_Texture *next; + for (texture = SDL_CurrentDisplay.textures[i]; texture; + texture = next) { + next = texture->next; + if (texture->renderer == renderer) { + if (prev) { + prev->next = next; + } else { + SDL_CurrentDisplay.textures[i] = next; + } + renderer->DestroyTexture(texture); + SDL_free(texture); } else { - SDL_DitherColors(surface->format->palette->colors, bpp); + prev = texture; } } } - /* Clear the surface for display */ - { - Uint32 black = SDL_MapRGB(surface->format, 0, 0, 0); - SDL_FillRect(surface, NULL, black); - if (surface->flags & SDL_DOUBLEBUF) { - SDL_Flip(surface); - SDL_FillRect(surface, NULL, black); - } - SDL_Flip(surface); - } - - return surface; -} - -/* - * Convert a surface into the video pixel format. - */ -SDL_Surface * -SDL_DisplayFormat(SDL_Surface * surface) -{ - Uint32 flags; - - if (!SDL_PublicSurface) { - SDL_SetError("No video mode has been set"); - return (NULL); - } - /* Set the flags appropriate for copying to display surface */ - if (((SDL_PublicSurface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) - && _this->info.blit_hw) - flags = SDL_HWSURFACE; - else - flags = SDL_SWSURFACE; -#ifdef AUTORLE_DISPLAYFORMAT - flags |= (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA)); - flags |= SDL_RLEACCELOK; -#else - flags |= - surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCELOK); -#endif - return (SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags)); -} - -/* - * Convert a surface into a format that's suitable for blitting to - * the screen, but including an alpha channel. - */ -SDL_Surface * -SDL_DisplayFormatAlpha(SDL_Surface * surface) -{ - SDL_PixelFormat *vf; - SDL_PixelFormat *format; - SDL_Surface *converted; - Uint32 flags; - /* default to ARGB8888 */ - Uint32 amask = 0xff000000; - Uint32 rmask = 0x00ff0000; - Uint32 gmask = 0x0000ff00; - Uint32 bmask = 0x000000ff; - - if (!SDL_PublicSurface) { - SDL_SetError("No video mode has been set"); - return (NULL); - } - vf = SDL_PublicSurface->format; - - switch (vf->BytesPerPixel) { - case 2: - /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}. - For anything else (like ARGB4444) it doesn't matter - since we have no special code for it anyway */ - if ((vf->Rmask == 0x1f) && - (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) { - rmask = 0xff; - bmask = 0xff0000; - } - break; - - case 3: - case 4: - /* Keep the video format, as long as the high 8 bits are - unused or alpha */ - if ((vf->Rmask == 0xff) && (vf->Bmask == 0xff0000)) { - rmask = 0xff; - bmask = 0xff0000; - } - break; - - default: - /* We have no other optimised formats right now. When/if a new - optimised alpha format is written, add the converter here */ - break; - } - format = SDL_AllocFormat(32, rmask, gmask, bmask, amask); - flags = SDL_PublicSurface->flags & SDL_HWSURFACE; - flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK); - converted = SDL_ConvertSurface(surface, format, flags); - SDL_FreeFormat(format); - return (converted); -} - -/* - * Update a specific portion of the physical screen - */ -void -SDL_UpdateRect(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h) -{ - if (screen) { - SDL_Rect rect; - - /* Perform some checking */ - if (w == 0) - w = screen->w; - if (h == 0) - h = screen->h; - if ((int) (x + w) > screen->w) - return; - if ((int) (y + h) > screen->h) - return; - - /* Fill the rectangle */ - rect.x = (Sint16) x; - rect.y = (Sint16) y; - rect.w = (Uint16) w; - rect.h = (Uint16) h; - SDL_UpdateRects(screen, 1, &rect); - } -} -void -SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) -{ - int i; - SDL_Window *window; - - /* Find the window corresponding to this surface */ - window = SDL_GetWindowFromSurface(screen); - if (!window) { - SDL_SetError("Couldn't find window associated with surface"); - return; - } + /* Free the renderer instance */ + renderer->DestroyRenderer(renderer); - if (screen->flags & SDL_SHADOW_SURFACE) { - if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { - SDL_LockCursor(); - SDL_DrawCursor(screen); - for (i = 0; i < numrects; ++i) { - SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); - } - SDL_EraseCursor(screen); - SDL_UnlockCursor(); - } else { - for (i = 0; i < numrects; ++i) { - SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); - } - } - - /* Fall through to video surface update */ - screen = window->surface; - } - if ((screen->flags & SDL_SCREEN_SURFACE) && _this->UpdateWindowSurface) { - /* Update the video surface */ - if (screen->offset) { - int offset_y = screen->offset / screen->pitch; - int offset_x = screen->offset % screen->pitch; - for (i = 0; i < numrects; ++i) { - rects[i].x += offset_x; - rects[i].y += offset_y; - } - _this->UpdateWindowSurface(_this, window, numrects, rects); - for (i = 0; i < numrects; ++i) { - rects[i].x -= offset_x; - rects[i].y -= offset_y; - } - } else { - _this->UpdateWindowSurface(_this, window, numrects, rects); - } - } -} - -/* - * Performs hardware double buffering, if possible, or a full update if not. - */ -int -SDL_Flip(SDL_Surface * screen) -{ - SDL_Window *window; - - /* Find the window corresponding to this surface */ - window = SDL_GetWindowFromSurface(screen); - if (!window) { - SDL_SetError("Couldn't find window associated with surface"); - return; - } - - /* Copy the shadow surface to the video surface */ - if (screen->flags & SDL_SHADOW_SURFACE) { - SDL_Rect rect; - - rect.x = 0; - rect.y = 0; - rect.w = screen->w; - rect.h = screen->h; - if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { - SDL_LockCursor(); - SDL_DrawCursor(screen); - SDL_LowerBlit(screen, &rect, window->surface, &rect); - SDL_EraseCursor(screen); - SDL_UnlockCursor(); - } else { - SDL_LowerBlit(screen, &rect, window->surface, &rect); - } - - /* Fall through to video surface update */ - screen = window->surface; + /* Clear references */ + window->renderer = NULL; + if (SDL_CurrentDisplay.current_renderer == renderer) { + SDL_CurrentDisplay.current_renderer = NULL; } - if (screen->flags & SDL_DOUBLEBUF) { - _this->FlipWindowSurface(_this, window); - } else { - SDL_UpdateRect(screen, 0, 0, 0, 0); - } - return (0); -} - -int -SDL_SetColors(SDL_Surface * screen, SDL_Color * colors, int firstcolor, - int ncolors) -{ - SDL_Window *window = NULL; - SDL_Palette *pal; - int gotall; - int palsize; - - /* Verify the parameters */ - pal = screen->format->palette; - if (!pal) { - return 0; /* not a palettized surface */ - } - gotall = 1; - palsize = 1 << screen->format->BitsPerPixel; - if (ncolors > (palsize - firstcolor)) { - ncolors = (palsize - firstcolor); - gotall = 0; - } - - if (colors != (pal->colors + firstcolor)) { - SDL_memcpy(pal->colors + firstcolor, colors, - ncolors * sizeof(*colors)); - } - SDL_FormatChanged(screen); - - if (screen->flags & (SDL_SHADOW_SURFACE | SDL_SCREEN_SURFACE)) { - window = SDL_GetWindowFromSurface(screen); - if (!window) { - return 0; - } - } - - if (screen->flags & SDL_SHADOW_SURFACE) { - SDL_Palette *vidpal; - - vidpal = window->surface->format->palette; - if (vidpal && vidpal->ncolors == pal->ncolors) { - /* This is a shadow surface, and the physical - * framebuffer is also indexed. Propagate the - * changes to its logical palette so that - * updates are always identity blits - */ - SDL_memcpy(vidpal->colors + firstcolor, colors, - ncolors * sizeof(*colors)); - } - if (window->surface->flags & SDL_HWPALETTE) { - /* Set the physical palette */ - screen = window->surface; - } else { - SDL_UpdateRect(screen, 0, 0, 0, 0); - } - } - - if (screen->flags & SDL_SCREEN_SURFACE) { - if (_this->SetWindowColors) { - gotall = - _this->SetWindowColors(_this, window, firstcolor, ncolors, - colors); - if (!gotall) { - /* The video flags shouldn't have SDL_HWPALETTE, and - the video driver is responsible for copying back the - correct colors into the video surface palette. - */ - ; - } - } - SDL_CursorPaletteChanged(); - } - - return gotall; } void @@ -1416,12 +1557,12 @@ SDL_free(display->windows); display->windows = NULL; } + SDL_free(display->info.vfmt); } _this->VideoQuit(_this); if (_this->displays) { SDL_free(_this->displays); } - SDL_free(_this->info.vfmt); _this->free(_this); _this = NULL; } @@ -1549,11 +1690,8 @@ void SDL_GL_SwapBuffers(void) { - if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) { - _this->GL_SwapBuffers(_this); - } else { - SDL_SetError("OpenGL video mode has not been set"); - } + // FIXME: Track the current window context - do we provide N contexts, and match them to M windows, or is there a one-to-one mapping? + _this->GL_SwapBuffers(_this); } #if 0 // FIXME