diff --git a/data/yahoo_aerial.earth b/data/yahoo_aerial.earth
new file mode 100644
index 0000000000000000000000000000000000000000..679c01f5b2347cbec8af1b15af16da8ab54a9c89
--- /dev/null
+++ b/data/yahoo_aerial.earth
@@ -0,0 +1,23 @@
+
+
+
diff --git a/data/yahoo_heightfield.earth b/data/yahoo_heightfield.earth
new file mode 100644
index 0000000000000000000000000000000000000000..4fe6133adb6fccaa37240d8d433ee01810f0087e
--- /dev/null
+++ b/data/yahoo_heightfield.earth
@@ -0,0 +1,33 @@
+
+
+
diff --git a/data/yahoo_maps.earth b/data/yahoo_maps.earth
new file mode 100644
index 0000000000000000000000000000000000000000..871a114b0d35a248fd7ccd9c32c413a094aef91d
--- /dev/null
+++ b/data/yahoo_maps.earth
@@ -0,0 +1,19 @@
+
+
+
diff --git a/map.earth b/data/zurich.earth
similarity index 100%
rename from map.earth
rename to data/zurich.earth
diff --git a/images/style-mission.css b/images/style-mission.css
index ee1f1635f07a018dc5de440b2380374abcc950c3..5831e88853c9a6d8cd922d936800b7b87686907d 100644
--- a/images/style-mission.css
+++ b/images/style-mission.css
@@ -77,10 +77,43 @@ border: 1px solid #777777;
color: #DDDDDF;
}
+ QMainWindow::separator {
+ background: #090909;
+ width: 2px; /* when vertical */
+ height: 2px; /* when horizontal */
+ }
+
+ QMainWindow::separator:hover {
+ background: white;
+ }
+
QDockWidget {
- font: bold;
- border: 1px solid #32345E;
-}
+ border: 1px solid #32345E;
+ /* titlebar-close-icon: url(close.png);
+ titlebar-normal-icon: url(undock.png);*/
+ }
+
+ QDockWidget::title {
+ text-align: left; /* align the text to the left */
+ background: lightgray;
+ padding-left: 5px;
+ }
+
+ QDockWidget::close-button, QDockWidget::float-button {
+ border: 1px solid transparent;
+ background: darkgray;
+ padding: 0px;
+ }
+
+ QDockWidget::close-button:hover, QDockWidget::float-button:hover {
+ background: gray;
+ }
+
+ QDockWidget::close-button:pressed, QDockWidget::float-button:pressed {
+ padding: 1px -1px -1px 1px;
+ }
+
+
QDockWidget::close-button, QDockWidget::float-button {
background-color: #181820;
diff --git a/lib/QMapControl/src/emptymapadapter.cpp b/lib/QMapControl/src/emptymapadapter.cpp
index 93cf3c99b7792dcaa5cfe123407d1920421205fa..0de9cc47378574b07d57aa1660372d354d12082d 100644
--- a/lib/QMapControl/src/emptymapadapter.cpp
+++ b/lib/QMapControl/src/emptymapadapter.cpp
@@ -98,8 +98,8 @@ namespace qmapcontrol
z= min_zoom - z;
}
- if (x<0 || x>pow(2,z)-1 ||
- y<0 || y>pow(2,z)-1)
+ if (x<0 || x>pow(2.0,z)-1 ||
+ y<0 || y>pow(2.0,z)-1)
{
return false;
}
@@ -108,7 +108,7 @@ namespace qmapcontrol
}
int EmptyMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel));
+ return int(pow(2.0, zoomlevel));
}
int EmptyMapAdapter::xoffset(int x) const
{
diff --git a/lib/QMapControl/src/mapcontrol.cpp b/lib/QMapControl/src/mapcontrol.cpp
index 2f4c6d6094fdf9de1d68a75dadf982d759d5ed11..2872765dab8b14751d843c93fccfce9b839bcdca 100644
--- a/lib/QMapControl/src/mapcontrol.cpp
+++ b/lib/QMapControl/src/mapcontrol.cpp
@@ -157,7 +157,7 @@ namespace qmapcontrol
{
if (currentZoom() >= 0 && distanceList.size() > currentZoom())
{
- line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
+ line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
// draw the scale
painter.setPen(Qt::black);
@@ -210,7 +210,7 @@ namespace qmapcontrol
// Draw the Lat and Lon if needed
if (cursorPosVisible) {
- line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
+ line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
QString str;
str = QString(tr(" Lat: %1")).arg(currentWorldCoordinate.y());
diff --git a/lib/QMapControl/src/point.cpp b/lib/QMapControl/src/point.cpp
index e1831befa6ac1d0c23270fefd8d9ec032a4fa526..45793a628996d3f310c0424cb0b2760ed4f4894e 100644
--- a/lib/QMapControl/src/point.cpp
+++ b/lib/QMapControl/src/point.cpp
@@ -144,8 +144,8 @@ namespace qmapcontrol
int diffzoom = homelevel-currentzoom;
int viewheight = size.height();
int viewwidth = size.width();
- viewheight = int(viewheight / pow(2, diffzoom));
- viewwidth = int(viewwidth / pow(2, diffzoom));
+ viewheight = int(viewheight / pow(2.0, diffzoom));
+ viewwidth = int(viewwidth / pow(2.0, diffzoom));
if (minsize.height()!= -1 && viewheight < minsize.height())
viewheight = minsize.height();
diff --git a/lib/QMapControl/src/tilemapadapter.cpp b/lib/QMapControl/src/tilemapadapter.cpp
index e61cbc90814fa45f7704d94067974abc4cc6e506..17d0e3b52ab19af9d0ea2af9f71bf5c6fec9277c 100644
--- a/lib/QMapControl/src/tilemapadapter.cpp
+++ b/lib/QMapControl/src/tilemapadapter.cpp
@@ -162,8 +162,8 @@ namespace qmapcontrol
z= min_zoom - z;
}
- if (x<0 || x>pow(2,z)-1 ||
- y<0 || y>pow(2,z)-1)
+ if (x<0 || x>pow(2.0,z)-1 ||
+ y<0 || y>pow(2.0,z)-1)
{
return false;
}
@@ -172,7 +172,7 @@ namespace qmapcontrol
}
int TileMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel));
+ return int(pow(2.0, zoomlevel));
}
int TileMapAdapter::xoffset(int x) const
{
diff --git a/lib/QMapControl/src/wmsmapadapter.cpp b/lib/QMapControl/src/wmsmapadapter.cpp
index 96fa4fe60da9bf36d626d4679540720ff4f72acf..c6441a9bdb05f88bedd7a8374d4201786f4c37e6 100644
--- a/lib/QMapControl/src/wmsmapadapter.cpp
+++ b/lib/QMapControl/src/wmsmapadapter.cpp
@@ -47,7 +47,7 @@ namespace qmapcontrol
this->serverPath.append("&WIDTH=").append(loc.toString(tilesize))
.append("&HEIGHT=").append(loc.toString(tilesize))
.append("&BBOX=");
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
@@ -72,14 +72,14 @@ namespace qmapcontrol
void WMSMapAdapter::zoom_in()
{
current_zoom+=1;
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
void WMSMapAdapter::zoom_out()
{
current_zoom-=1;
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
diff --git a/lib/QMapControl/src/yahoomapadapter.cpp b/lib/QMapControl/src/yahoomapadapter.cpp
index 863d7c2089a246f1c8eee9e820f3c157e84adbfd..b264080552e2ab7832494322debbf8b8e6da351d 100644
--- a/lib/QMapControl/src/yahoomapadapter.cpp
+++ b/lib/QMapControl/src/yahoomapadapter.cpp
@@ -30,13 +30,13 @@ namespace qmapcontrol
: TileMapAdapter("png.maps.yimg.com", "/png?v=3.1.0&x=%2&y=%3&z=%1", 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- numberOfTiles = pow(2, zoom+1);
+ numberOfTiles = pow(2.0, zoom+1);
}
YahooMapAdapter::YahooMapAdapter(QString host, QString url)
: TileMapAdapter(host, url, 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- numberOfTiles = pow(2, zoom+1);
+ numberOfTiles = pow(2.0, zoom+1);
}
YahooMapAdapter::~YahooMapAdapter()
{
@@ -49,14 +49,14 @@ namespace qmapcontrol
int YahooMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel+1));
+ return int(pow(2.0, zoomlevel+1));
}
int YahooMapAdapter::yoffset(int y) const
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- int tiles = int(pow(2, zoom));
+ int tiles = int(pow(2.0, zoom));
y = y*(-1)+tiles-1;
return int(y);
}
diff --git a/lib/msinttypes/inttypes.h b/lib/msinttypes/inttypes.h
new file mode 100644
index 0000000000000000000000000000000000000000..25542771f591c3b2161df8171f18bf7a2b66a530
--- /dev/null
+++ b/lib/msinttypes/inttypes.h
@@ -0,0 +1,305 @@
+// ISO C9x compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+// Copyright (c) 2006 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. The name of the author may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+ intmax_t quot;
+ intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8 "d"
+#define PRIi8 "i"
+#define PRIdLEAST8 "d"
+#define PRIiLEAST8 "i"
+#define PRIdFAST8 "d"
+#define PRIiFAST8 "i"
+
+#define PRId16 "hd"
+#define PRIi16 "hi"
+#define PRIdLEAST16 "hd"
+#define PRIiLEAST16 "hi"
+#define PRIdFAST16 "hd"
+#define PRIiFAST16 "hi"
+
+#define PRId32 "I32d"
+#define PRIi32 "I32i"
+#define PRIdLEAST32 "I32d"
+#define PRIiLEAST32 "I32i"
+#define PRIdFAST32 "I32d"
+#define PRIiFAST32 "I32i"
+
+#define PRId64 "I64d"
+#define PRIi64 "I64i"
+#define PRIdLEAST64 "I64d"
+#define PRIiLEAST64 "I64i"
+#define PRIdFAST64 "I64d"
+#define PRIiFAST64 "I64i"
+
+#define PRIdMAX "I64d"
+#define PRIiMAX "I64i"
+
+#define PRIdPTR "Id"
+#define PRIiPTR "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8 "o"
+#define PRIu8 "u"
+#define PRIx8 "x"
+#define PRIX8 "X"
+#define PRIoLEAST8 "o"
+#define PRIuLEAST8 "u"
+#define PRIxLEAST8 "x"
+#define PRIXLEAST8 "X"
+#define PRIoFAST8 "o"
+#define PRIuFAST8 "u"
+#define PRIxFAST8 "x"
+#define PRIXFAST8 "X"
+
+#define PRIo16 "ho"
+#define PRIu16 "hu"
+#define PRIx16 "hx"
+#define PRIX16 "hX"
+#define PRIoLEAST16 "ho"
+#define PRIuLEAST16 "hu"
+#define PRIxLEAST16 "hx"
+#define PRIXLEAST16 "hX"
+#define PRIoFAST16 "ho"
+#define PRIuFAST16 "hu"
+#define PRIxFAST16 "hx"
+#define PRIXFAST16 "hX"
+
+#define PRIo32 "I32o"
+#define PRIu32 "I32u"
+#define PRIx32 "I32x"
+#define PRIX32 "I32X"
+#define PRIoLEAST32 "I32o"
+#define PRIuLEAST32 "I32u"
+#define PRIxLEAST32 "I32x"
+#define PRIXLEAST32 "I32X"
+#define PRIoFAST32 "I32o"
+#define PRIuFAST32 "I32u"
+#define PRIxFAST32 "I32x"
+#define PRIXFAST32 "I32X"
+
+#define PRIo64 "I64o"
+#define PRIu64 "I64u"
+#define PRIx64 "I64x"
+#define PRIX64 "I64X"
+#define PRIoLEAST64 "I64o"
+#define PRIuLEAST64 "I64u"
+#define PRIxLEAST64 "I64x"
+#define PRIXLEAST64 "I64X"
+#define PRIoFAST64 "I64o"
+#define PRIuFAST64 "I64u"
+#define PRIxFAST64 "I64x"
+#define PRIXFAST64 "I64X"
+
+#define PRIoMAX "I64o"
+#define PRIuMAX "I64u"
+#define PRIxMAX "I64x"
+#define PRIXMAX "I64X"
+
+#define PRIoPTR "Io"
+#define PRIuPTR "Iu"
+#define PRIxPTR "Ix"
+#define PRIXPTR "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8 "d"
+#define SCNi8 "i"
+#define SCNdLEAST8 "d"
+#define SCNiLEAST8 "i"
+#define SCNdFAST8 "d"
+#define SCNiFAST8 "i"
+
+#define SCNd16 "hd"
+#define SCNi16 "hi"
+#define SCNdLEAST16 "hd"
+#define SCNiLEAST16 "hi"
+#define SCNdFAST16 "hd"
+#define SCNiFAST16 "hi"
+
+#define SCNd32 "ld"
+#define SCNi32 "li"
+#define SCNdLEAST32 "ld"
+#define SCNiLEAST32 "li"
+#define SCNdFAST32 "ld"
+#define SCNiFAST32 "li"
+
+#define SCNd64 "I64d"
+#define SCNi64 "I64i"
+#define SCNdLEAST64 "I64d"
+#define SCNiLEAST64 "I64i"
+#define SCNdFAST64 "I64d"
+#define SCNiFAST64 "I64i"
+
+#define SCNdMAX "I64d"
+#define SCNiMAX "I64i"
+
+#ifdef _WIN64 // [
+# define SCNdPTR "I64d"
+# define SCNiPTR "I64i"
+#else // _WIN64 ][
+# define SCNdPTR "ld"
+# define SCNiPTR "li"
+#endif // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8 "o"
+#define SCNu8 "u"
+#define SCNx8 "x"
+#define SCNX8 "X"
+#define SCNoLEAST8 "o"
+#define SCNuLEAST8 "u"
+#define SCNxLEAST8 "x"
+#define SCNXLEAST8 "X"
+#define SCNoFAST8 "o"
+#define SCNuFAST8 "u"
+#define SCNxFAST8 "x"
+#define SCNXFAST8 "X"
+
+#define SCNo16 "ho"
+#define SCNu16 "hu"
+#define SCNx16 "hx"
+#define SCNX16 "hX"
+#define SCNoLEAST16 "ho"
+#define SCNuLEAST16 "hu"
+#define SCNxLEAST16 "hx"
+#define SCNXLEAST16 "hX"
+#define SCNoFAST16 "ho"
+#define SCNuFAST16 "hu"
+#define SCNxFAST16 "hx"
+#define SCNXFAST16 "hX"
+
+#define SCNo32 "lo"
+#define SCNu32 "lu"
+#define SCNx32 "lx"
+#define SCNX32 "lX"
+#define SCNoLEAST32 "lo"
+#define SCNuLEAST32 "lu"
+#define SCNxLEAST32 "lx"
+#define SCNXLEAST32 "lX"
+#define SCNoFAST32 "lo"
+#define SCNuFAST32 "lu"
+#define SCNxFAST32 "lx"
+#define SCNXFAST32 "lX"
+
+#define SCNo64 "I64o"
+#define SCNu64 "I64u"
+#define SCNx64 "I64x"
+#define SCNX64 "I64X"
+#define SCNoLEAST64 "I64o"
+#define SCNuLEAST64 "I64u"
+#define SCNxLEAST64 "I64x"
+#define SCNXLEAST64 "I64X"
+#define SCNoFAST64 "I64o"
+#define SCNuFAST64 "I64u"
+#define SCNxFAST64 "I64x"
+#define SCNXFAST64 "I64X"
+
+#define SCNoMAX "I64o"
+#define SCNuMAX "I64u"
+#define SCNxMAX "I64x"
+#define SCNXMAX "I64X"
+
+#ifdef _WIN64 // [
+# define SCNoPTR "I64o"
+# define SCNuPTR "I64u"
+# define SCNxPTR "I64x"
+# define SCNXPTR "I64X"
+#else // _WIN64 ][
+# define SCNoPTR "lo"
+# define SCNuPTR "lu"
+# define SCNxPTR "lx"
+# define SCNXPTR "lX"
+#endif // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+ imaxdiv_t result;
+
+ result.quot = numer / denom;
+ result.rem = numer % denom;
+
+ if (numer < 0 && result.rem > 0) {
+ // did division wrong; must fix up
+ ++result.quot;
+ result.rem -= denom;
+ }
+
+ return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+
+#endif // _MSC_INTTYPES_H_ ]
diff --git a/lib/msinttypes/stdint.h b/lib/msinttypes/stdint.h
new file mode 100644
index 0000000000000000000000000000000000000000..59d067302fcfe1f5ec82cd7534f89c18167dd895
--- /dev/null
+++ b/lib/msinttypes/stdint.h
@@ -0,0 +1,247 @@
+// ISO C9x compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+// Copyright (c) 2006-2008 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. The name of the author may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap include with 'extern "C++" {}'
+// or compiler give many errors like this:
+// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+# include
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+# define _W64 __w64
+# else
+# define _W64
+# endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+ typedef signed char int8_t;
+ typedef signed short int16_t;
+ typedef signed int int32_t;
+ typedef unsigned char uint8_t;
+ typedef unsigned short uint16_t;
+ typedef unsigned int uint32_t;
+#else
+ typedef signed __int8 int8_t;
+ typedef signed __int16 int16_t;
+ typedef signed __int32 int32_t;
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int16 uint16_t;
+ typedef unsigned __int32 uint32_t;
+#endif
+typedef signed __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t int_least8_t;
+typedef int16_t int_least16_t;
+typedef int32_t int_least32_t;
+typedef int64_t int_least64_t;
+typedef uint8_t uint_least8_t;
+typedef uint16_t uint_least16_t;
+typedef uint32_t uint_least32_t;
+typedef uint64_t uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t int_fast8_t;
+typedef int16_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef int64_t int_fast64_t;
+typedef uint8_t uint_fast8_t;
+typedef uint16_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+typedef uint64_t uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+ typedef signed __int64 intptr_t;
+ typedef unsigned __int64 uintptr_t;
+#else // _WIN64 ][
+ typedef _W64 signed int intptr_t;
+ typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t intmax_t;
+typedef uint64_t uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN ((int8_t)_I8_MIN)
+#define INT8_MAX _I8_MAX
+#define INT16_MIN ((int16_t)_I16_MIN)
+#define INT16_MAX _I16_MAX
+#define INT32_MIN ((int32_t)_I32_MIN)
+#define INT32_MAX _I32_MAX
+#define INT64_MIN ((int64_t)_I64_MIN)
+#define INT64_MAX _I64_MAX
+#define UINT8_MAX _UI8_MAX
+#define UINT16_MAX _UI16_MAX
+#define UINT32_MAX _UI32_MAX
+#define UINT64_MAX _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN INT8_MIN
+#define INT_LEAST8_MAX INT8_MAX
+#define INT_LEAST16_MIN INT16_MIN
+#define INT_LEAST16_MAX INT16_MAX
+#define INT_LEAST32_MIN INT32_MIN
+#define INT_LEAST32_MAX INT32_MAX
+#define INT_LEAST64_MIN INT64_MIN
+#define INT_LEAST64_MAX INT64_MAX
+#define UINT_LEAST8_MAX UINT8_MAX
+#define UINT_LEAST16_MAX UINT16_MAX
+#define UINT_LEAST32_MAX UINT32_MAX
+#define UINT_LEAST64_MAX UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN INT8_MIN
+#define INT_FAST8_MAX INT8_MAX
+#define INT_FAST16_MIN INT16_MIN
+#define INT_FAST16_MAX INT16_MAX
+#define INT_FAST32_MIN INT32_MIN
+#define INT_FAST32_MAX INT32_MAX
+#define INT_FAST64_MIN INT64_MIN
+#define INT_FAST64_MAX INT64_MAX
+#define UINT_FAST8_MAX UINT8_MAX
+#define UINT_FAST16_MAX UINT16_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+#define UINT_FAST64_MAX UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+# define INTPTR_MIN INT64_MIN
+# define INTPTR_MAX INT64_MAX
+# define UINTPTR_MAX UINT64_MAX
+#else // _WIN64 ][
+# define INTPTR_MIN INT32_MIN
+# define INTPTR_MAX INT32_MAX
+# define UINTPTR_MAX UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN INT64_MIN
+#define INTMAX_MAX INT64_MAX
+#define UINTMAX_MAX UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+# define PTRDIFF_MIN _I64_MIN
+# define PTRDIFF_MAX _I64_MAX
+#else // _WIN64 ][
+# define PTRDIFF_MIN _I32_MIN
+# define PTRDIFF_MAX _I32_MAX
+#endif // _WIN64 ]
+
+#define SIG_ATOMIC_MIN INT_MIN
+#define SIG_ATOMIC_MAX INT_MAX
+
+#ifndef SIZE_MAX // [
+# ifdef _WIN64 // [
+# define SIZE_MAX _UI64_MAX
+# else // _WIN64 ][
+# define SIZE_MAX _UI32_MAX
+# endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in
+#ifndef WCHAR_MIN // [
+# define WCHAR_MIN 0
+#endif // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+# define WCHAR_MAX _UI16_MAX
+#endif // WCHAR_MAX ]
+
+#define WINT_MIN 0
+#define WINT_MAX _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val) val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val) val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C INT64_C
+#define UINTMAX_C UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]
diff --git a/lib/sdl/msvc/BUGS b/lib/sdl/msvc/BUGS
new file mode 100644
index 0000000000000000000000000000000000000000..d7058f6209652e755278c634d441965bca2b51e8
--- /dev/null
+++ b/lib/sdl/msvc/BUGS
@@ -0,0 +1,18 @@
+
+Bugs are now managed in the SDL bug tracker, here:
+
+ http://bugzilla.libsdl.org/
+
+You may report bugs there, and search to see if a given issue has already
+ been reported, discussed, and maybe even fixed.
+
+
+
+You may also find help at the SDL mailing list. Subscription information:
+
+ http://lists.libsdl.org/listinfo.cgi/sdl-libsdl.org
+
+Bug reports are welcome here, but we really appreciate if you use Bugzilla, as
+ bugs discussed on the mailing list may be forgotten or missed.
+
+
diff --git a/lib/sdl/msvc/COPYING b/lib/sdl/msvc/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..8904ea404ee3011471006a5b6bbf6eb7e5b4ee07
--- /dev/null
+++ b/lib/sdl/msvc/COPYING
@@ -0,0 +1,458 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
diff --git a/lib/sdl/msvc/README b/lib/sdl/msvc/README
new file mode 100644
index 0000000000000000000000000000000000000000..e9e1d1a98338c3e37847eaee0d8a096bc7d40c64
--- /dev/null
+++ b/lib/sdl/msvc/README
@@ -0,0 +1,49 @@
+
+ Simple DirectMedia Layer
+
+ (SDL)
+
+ Version 1.2
+
+---
+http://www.libsdl.org/
+
+This is the Simple DirectMedia Layer, a general API that provides low
+level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL,
+and 2D framebuffer across multiple platforms.
+
+The current version supports Linux, Windows CE/95/98/ME/XP/Vista, BeOS,
+MacOS Classic, Mac OS X, FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, IRIX,
+and QNX. The code contains support for Dreamcast, Atari, AIX, OSF/Tru64,
+RISC OS, SymbianOS, Nintendo DS, and OS/2, but these are not officially
+supported.
+
+SDL is written in C, but works with C++ natively, and has bindings to
+several other languages, including Ada, C#, Eiffel, Erlang, Euphoria,
+Guile, Haskell, Java, Lisp, Lua, ML, Objective C, Pascal, Perl, PHP,
+Pike, Pliant, Python, Ruby, and Smalltalk.
+
+This library is distributed under GNU LGPL version 2, which can be
+found in the file "COPYING". This license allows you to use SDL
+freely in commercial programs as long as you link with the dynamic
+library.
+
+The best way to learn how to use SDL is to check out the header files in
+the "include" subdirectory and the programs in the "test" subdirectory.
+The header files and test programs are well commented and always up to date.
+More documentation is available in HTML format in "docs/index.html", and
+a documentation wiki is available online at:
+ http://www.libsdl.org/cgi/docwiki.cgi
+
+The test programs in the "test" subdirectory are in the public domain.
+
+Frequently asked questions are answered online:
+ http://www.libsdl.org/faq.php
+
+If you need help with the library, or just want to discuss SDL related
+issues, you can join the developers mailing list:
+ http://www.libsdl.org/mailing-list.php
+
+Enjoy!
+ Sam Lantinga (slouken@libsdl.org)
+
diff --git a/lib/sdl/msvc/README-SDL.txt b/lib/sdl/msvc/README-SDL.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1669736cb52b18cd12ab58171f18886600620b85
--- /dev/null
+++ b/lib/sdl/msvc/README-SDL.txt
@@ -0,0 +1,13 @@
+
+Please distribute this file with the SDL runtime environment:
+
+The Simple DirectMedia Layer (SDL for short) is a cross-platfrom library
+designed to make it easy to write multi-media software, such as games and
+emulators.
+
+The Simple DirectMedia Layer library source code is available from:
+http://www.libsdl.org/
+
+This library is distributed under the terms of the GNU LGPL license:
+http://www.gnu.org/copyleft/lesser.html
+
diff --git a/lib/sdl/msvc/VisualC.html b/lib/sdl/msvc/VisualC.html
new file mode 100644
index 0000000000000000000000000000000000000000..ad2ed97a603d70d21a4a15054ba333269b0111c5
--- /dev/null
+++ b/lib/sdl/msvc/VisualC.html
@@ -0,0 +1,171 @@
+
+
+ Using SDL with Microsoft Visual C++
+
+
+
+ Unzip the VisualC.zip file into the directory that contains this
+ file (VisualC.html).
+
+
+ Be certain that you unzip the zip file for your compiler into this
+ directory and not any other directory. If you are using WinZip, be careful to
+ make sure that it extracts to this folder, because it's
+ convenient feature of unzipping to a folder with the name of the file currently
+ being unzipped will get you in trouble if you use it right now. And that's all
+ I have to say about that.
+
+
+ Now that it's unzipped, go into the VisualC
+ directory that is created, and double-click on the VC++ file "SDL.dsw"
+ ("SDL.sln"). This should open up the IDE.
+
+
+ You may be prompted at this point to upgrade the workspace, should you be using
+ a more recent version of Visual C++. If so, allow the workspace to be upgraded.
+
+
+ Build the .dll and .lib files.
+
+
+ This is done by right clicking on each project in turn (Projects are listed in
+ the Workspace panel in the FileView tab), and selecting "Build".
+
+
+ If you get an error about SDL_config.h being missing, you should
+ copy include/SDL_config.h.default to include/SDL_config.h and try again.
+
+
+ You may get a few warnings, but you should not get any errors. You do have to
+ have at least the DirectX 5 SDK installed, however. The latest
+ version of DirectX can be downloaded or purchased on a cheap CD (my
+ recommendation) from Microsoft .
+
+
+ Later, we will refer to the following .lib and .dll files that have just been
+ generated:
+
+
+
SDL.dll
+
SDL.lib
+
SDLmain.lib
+
+
+ Search for these using the Windows Find (Windows-F) utility, if you don't
+ already know where they should be. For those of you with a clue, look inside
+ the Debug or Release directories of the subdirectories of the Project folder.
+ (It might be easier to just use Windows Find if this sounds confusing. And
+ don't worry about needing a clue; we all need visits from the clue fairy
+ frequently.)
+
+
+ Creating a Project with SDL
+
+
+ Create a project as a Win32 Application.
+
+
+ Create a C++ file for your project.
+
+
+ Set the C runtime to "Multi-threaded DLL" in the menu: Project|Settings|C/C++
+ tab|Code Generation|Runtime Library .
+
+
+ Add the SDL include directory to your list of includes in the
+ menu: Project|Settings|C/C++ tab|Preprocessor|Additional include directories
+ .
+
+ VC7 Specific: Instead of doing this I find it easier to
+ add the include and library directories to the list that VC7 keeps. Do this by
+ selecting Tools|Options|Projects|VC++ Directories and under the "Show
+ Directories For:" dropbox select "Include Files", and click the "New Directory
+ Icon" and add the [SDLROOT]\include directory (ex. If you installed to
+ c:\SDL-1.2.5\ add c:\SDL-1.2.5\include). Proceed to change the
+ dropbox selection to "Library Files" and add [SDLROOT]\lib.
+
+
+ The "include directory" I am referring to is the include folder
+ within the main SDL directory (the one that this HTML file located within).
+
+
+ Now we're going to use the files that we had created earlier in the Build SDL
+ step.
+
+
+ Copy the following files into your Project directory:
+
+
+
SDL.dll
+
+
+ Add the following files to your project (It is not necessary to copy them to
+ your project directory):
+
+
+
SDL.lib
+
SDLmain.lib
+
+
+ (To add them to your project, right click on your project, and select "Add
+ files to project")
+
+
Instead of adding the files to your project it is more
+ desireable to add them to the linker options: Project|Properties|Linker|Command
+ Line and type the names of the libraries to link with in the "Additional
+ Options:" box. Note: This must be done for each build
+ configuration (eg. Release,Debug).
+
+ SDL 101, First Day of Class
+
+
+ Now create the basic body of your project. The body of your program should take
+ the following form:
+
+#include "SDL.h"
+
+int main( int argc, char* argv[] )
+{
+ // Body of the program goes here.
+ return 0;
+}
+
+
+
+
+ That's it!
+
+
+ I hope that this document has helped you get through the most difficult part of
+ using the SDL: installing it. Suggestions for improvements to this document
+ should be sent to the writers of this document.
+
+
+ Thanks to Paulus Esterhazy (pesterhazy@gmx.net), for the work on VC++ port.
+
+
+ This document was originally called "VisualC.txt", and was written by
+ Sam Lantinga.
+
+
+ Later, it was converted to HTML and expanded into the document that you see
+ today by Lion Kimbro.
+
+
Minor Fixes and Visual C++ 7 Information (In Green) was added by James Turk
+
+
+
diff --git a/lib/sdl/msvc/WhatsNew b/lib/sdl/msvc/WhatsNew
new file mode 100644
index 0000000000000000000000000000000000000000..7fae760f7ca43a2f86129ec8573daa2ae17877ef
--- /dev/null
+++ b/lib/sdl/msvc/WhatsNew
@@ -0,0 +1,727 @@
+
+This is a list of API changes in SDL's version history.
+
+Version 1.0:
+
+1.2.14:
+ Added cast macros for correct usage with C++:
+ SDL_reinterpret_cast(type, expression)
+ SDL_static_cast(type, expression)
+
+ Added SDL_VIDEO_FULLSCREEN_DISPLAY as a preferred synonym for
+ SDL_VIDEO_FULLSCREEN_HEAD on X11.
+
+ Added SDL_DISABLE_LOCK_KEYS environment variable to enable normal
+ up/down events for Caps-Lock and Num-Lock keys.
+
+1.2.13:
+ Added SDL_BUTTON_X1 and SDL_BUTTON_X2 constants.
+
+1.2.12:
+ Added SDL_VIDEO_ALLOW_SCREENSAVER to override SDL's disabling
+ of the screensaver on Mac OS X and X11.
+
+1.2.10:
+ If SDL_OpenAudio() is passed zero for the desired format
+ fields, the following environment variables will be used
+ to fill them in:
+ SDL_AUDIO_FREQUENCY
+ SDL_AUDIO_FORMAT
+ SDL_AUDIO_CHANNELS
+ SDL_AUDIO_SAMPLES
+ If an environment variable is not specified, it will be set
+ to a reasonable default value.
+
+ Added support for the SDL_VIDEO_FULLSCREEN_HEAD environment
+ variable, currently supported on X11 Xinerama configurations.
+
+ Added SDL_GL_SWAP_CONTROL to wait for vsync in OpenGL applications.
+
+ Added SDL_GL_ACCELERATED_VISUAL to guarantee hardware acceleration.
+
+ Added current_w and current_h to the SDL_VideoInfo structure,
+ which is set to the desktop resolution during video intialization,
+ and then set to the current resolution when a video mode is set.
+
+ SDL_SetVideoMode() now accepts 0 for width or height and will use
+ the current video mode (or the desktop mode if no mode has been set.)
+
+ Added SDL_GetKeyRepeat()
+
+ Added SDL_config.h, with defaults for various build environments.
+
+1.2.7:
+ Added CPU feature detection functions to SDL_cpuinfo.h:
+ SDL_HasRDTSC(), SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE(),
+ SDL_HasAltiVec()
+ Added function to create RWops from const memory: SDL_RWFromConstMem()
+
+1.2.6:
+ Added SDL_LoadObject(), SDL_LoadFunction(), and SDL_UnloadObject()
+
+ Added SDL_GL_MULTISAMPLEBUFFERS and SDL_GL_MULTISAMPLESAMPLES for FSAA
+
+1.2.5:
+ Added SDL_BUTTON_WHEELUP (4) and SDL_BUTTON_WHEELDOWN (5)
+
+ Added SDL_GL_STEREO for stereoscopic OpenGL contexts
+
+1.2.0:
+ Added SDL_VIDEOEXPOSE event to signal that the screen needs to
+ be redrawn. This is currently only delivered to OpenGL windows
+ on X11, though it may be delivered in the future when the video
+ memory is lost under DirectX.
+
+1.1.8:
+ You can pass SDL_NOFRAME to SDL_VideoMode() to create a window
+ that has no title bar or frame decoration. Fullscreen video
+ modes automatically have this flag set.
+
+ Added a function to query the clipping rectangle for a surface:
+ void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
+
+ Added a function to query the current event filter:
+ SDL_EventFilter SDL_GetEventFilter(void)
+
+ If you pass -1 to SDL_ShowCursor(), it won't change the current
+ cursor visibility state, but will still return it.
+
+ SDL_LockSurface() and SDL_UnlockSurface() are recursive, meaning
+ you can nest them as deep as you want, as long as each lock call
+ has a matching unlock call. The surface remains locked until the
+ last matching unlock call.
+
+ Note that you may not blit to or from a locked surface.
+
+1.1.7:
+ The SDL_SetGammaRamp() and SDL_GetGammaRamp() functions now take
+ arrays of Uint16 values instead of Uint8 values. For the most part,
+ you can just take your old values and shift them up 8 bits to get
+ new correct values for your gamma ramps.
+
+ You can pass SDL_RLEACCEL in flags passed to SDL_ConvertSurface()
+ and SDL will try to RLE accelerate colorkey and alpha blits in the
+ resulting surface.
+
+1.1.6:
+ Added a function to return the thread ID of a specific thread:
+ Uint32 SDL_GetThreadID(SDL_Thread *thread)
+ If 'thread' is NULL, this function returns the id for this thread.
+
+1.1.5:
+ The YUV overlay structure has been changed to use an array of
+ pitches and pixels representing the planes of a YUV image, to
+ better enable hardware acceleration. The YV12 and IYUV formats
+ each have three planes, corresponding to the Y, U, and V portions
+ of the image, while packed pixel YUV formats just have one plane.
+
+ For palettized mode (8bpp), the screen colormap is now split in
+ a physical and a logical palette. The physical palette determines
+ what colours the screen pixels will get when displayed, and the
+ logical palette controls the mapping from blits to/from the screen.
+ A new function, SDL_SetPalette() has been added to change
+ logical and physical palettes separately. SDL_SetColors() works
+ just as before, and is equivalent to calling SDL_SetPalette() with
+ a flag argument of (SDL_LOGPAL|SDL_PHYSPAL).
+
+ SDL_BlitSurface() no longer modifies the source rectangle, only the
+ destination rectangle. The width/height members of the destination
+ rectangle are ignored, only the position is used.
+
+ The old source clipping function SDL_SetClipping() has been replaced
+ with a more useful function to set the destination clipping rectangle:
+ SDL_bool SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect)
+
+ Added a function to see what subsystems have been initialized:
+ Uint32 SDL_WasInit(Uint32 flags)
+
+ The Big Alpha Flip: SDL now treats alpha as opacity like everybody
+ else, and not as transparency:
+
+ A new cpp symbol: SDL_ALPHA_OPAQUE is defined as 255
+ A new cpp symbol: SDL_ALPHA_TRANSPARENT is defined as 0
+ Values between 0 and 255 vary from fully transparent to fully opaque.
+
+ New functions:
+ SDL_DisplayFormatAlpha()
+ Returns a surface converted to a format with alpha-channel
+ that can be blit efficiently to the screen. (In other words,
+ like SDL_DisplayFormat() but the resulting surface has
+ an alpha channel.) This is useful for surfaces with alpha.
+ SDL_MapRGBA()
+ Works as SDL_MapRGB() but takes an additional alpha parameter.
+ SDL_GetRGBA()
+ Works as SDL_GetRGB() but also returns the alpha value
+ (SDL_ALPHA_OPAQUE for formats without an alpha channel)
+
+ Both SDL_GetRGB() and SDL_GetRGBA() now always return values in
+ the [0..255] interval. Previously, SDL_GetRGB() would return
+ (0xf8, 0xfc, 0xf8) for a completely white pixel in RGB565 format.
+ (N.B.: This is broken for bit fields < 3 bits.)
+
+ SDL_MapRGB() returns pixels in which the alpha channel is set opaque.
+
+ SDL_SetAlpha() can now be used for both setting the per-surface
+ alpha, using the new way of thinking of alpha, and also to enable
+ and disable per-pixel alpha blending for surfaces with an alpha
+ channel:
+ To disable alpha blending:
+ SDL_SetAlpha(surface, 0, 0);
+ To re-enable alpha blending:
+ SDL_SetAlpha(surface, SDL_SRCALPHA, 0);
+ Surfaces with an alpha channel have blending enabled by default.
+
+ SDL_SetAlpha() now accepts SDL_RLEACCEL as a flag, which requests
+ RLE acceleration of blits, just as like with SDL_SetColorKey().
+ This flag can be set for both surfaces with an alpha channel
+ and surfaces with an alpha value set by SDL_SetAlpha().
+ As always, RLE surfaces must be locked before pixel access is
+ allowed, and unlocked before any other SDL operations are done
+ on it.
+
+ The blit semantics for surfaces with and without alpha and colorkey
+ have now been defined:
+
+ RGBA->RGB:
+ SDL_SRCALPHA set:
+ alpha-blend (using alpha-channel).
+ SDL_SRCCOLORKEY ignored.
+ SDL_SRCALPHA not set:
+ copy RGB.
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ RGB values of the source colour key, ignoring alpha in the
+ comparison.
+
+ RGB->RGBA:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source per-surface alpha value);
+ set destination alpha to opaque.
+ SDL_SRCALPHA not set:
+ copy RGB, set destination alpha to opaque.
+ both:
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ source colour key.
+
+ RGBA->RGBA:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source alpha channel) the RGB values;
+ leave destination alpha untouched. [Note: is this correct?]
+ SDL_SRCCOLORKEY ignored.
+ SDL_SRCALPHA not set:
+ copy all of RGBA to the destination.
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ RGB values of the source colour key, ignoring alpha in the
+ comparison.
+
+ RGB->RGB:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source per-surface alpha value).
+ SDL_SRCALPHA not set:
+ copy RGB.
+ both:
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ source colour key.
+
+ As a special case, blits from surfaces with per-surface alpha
+ value of 128 (50% transparency) are optimised and much faster
+ than other alpha values. This does not apply to surfaces with
+ alpha channels (per-pixel alpha).
+
+ New functions for manipulating the gamma of the display have
+ been added:
+ int SDL_SetGamma(float red, float green, float blue);
+ int SDL_SetGammaRamp(Uint8 *red, Uint8 *green, Uint8 *blue);
+ int SDL_GetGammaRamp(Uint8 *red, Uint8 *green, Uint8 *blue);
+ Gamma ramps are tables with 256 entries which map the screen color
+ components into actually displayed colors. For an example of
+ implementing gamma correction and gamma fades, see test/testgamma.c
+ Gamma control is not supported on all hardware.
+
+1.1.4:
+ The size of the SDL_CDtrack structure changed from 8 to 12 bytes
+ as the size of the length member was extended to 32 bits.
+
+ You can now use SDL for 2D blitting with a GL mode by passing the
+ SDL_OPENGLBLIT flag to SDL_SetVideoMode(). You can specify 16 or
+ 32 bpp, and the data in the framebuffer is put into the GL scene
+ when you call SDL_UpdateRects(), and the scene will be visible
+ when you call SDL_GL_SwapBuffers().
+
+ Run the "testgl" test program with the -logo command line option
+ to see an example of this blending of 2D and 3D in SDL.
+
+1.1.3:
+ Added SDL_FreeRW() to the API, to complement SDL_AllocRW()
+
+ Added resizable window support - just add SDL_RESIZABLE to the
+ SDL_SetVideoMode() flags, and then wait for SDL_VIDEORESIZE events.
+ See SDL_events.h for details on the new SDL_ResizeEvent structure.
+
+ Added condition variable support, based on mutexes and semaphores.
+ SDL_CreateCond()
+ SDL_DestroyCond()
+ SDL_CondSignal()
+ SDL_CondBroadcast()
+ SDL_CondWait()
+ SDL_CondTimedWait()
+ The new function prototypes are in SDL_mutex.h
+
+ Added counting semaphore support, based on the mutex primitive.
+ SDL_CreateSemaphore()
+ SDL_DestroySemaphore()
+ SDL_SemWait()
+ SDL_SemTryWait()
+ SDL_SemWaitTimeout()
+ SDL_SemPost()
+ SDL_SemValue()
+ The new function prototypes are in SDL_mutex.h
+
+ Added support for asynchronous blitting. To take advantage of this,
+ you must set the SDL_ASYNCBLIT flag when setting the video mode and
+ creating surfaces that you want accelerated in this way. You must
+ lock surfaces that have this flag set, and the lock will block until
+ any queued blits have completed.
+
+ Added YUV video overlay support.
+ The supported YUV formats are: YV12, IYUV, YUY2, UYVY, and YVYU.
+ This function creates an overlay surface:
+ SDL_CreateYUVOverlay()
+ You must lock and unlock the overlay to get access to the data:
+ SDL_LockYUVOverlay() SDL_UnlockYUVOverlay()
+ You can then display the overlay:
+ SDL_DisplayYUVOverlay()
+ You must free the overlay when you are done using it:
+ SDL_FreeYUVOverlay()
+ See SDL_video.h for the full function prototypes.
+
+ The joystick hat position constants have been changed:
+ Old constant New constant
+ ------------ ------------
+ 0 SDL_HAT_CENTERED
+ 1 SDL_HAT_UP
+ 2 SDL_HAT_RIGHTUP
+ 3 SDL_HAT_RIGHT
+ 4 SDL_HAT_RIGHTDOWN
+ 5 SDL_HAT_DOWN
+ 6 SDL_HAT_LEFTDOWN
+ 7 SDL_HAT_LEFT
+ 8 SDL_HAT_LEFTUP
+ The new constants are bitmasks, so you can check for the
+ individual axes like this:
+ if ( hat_position & SDL_HAT_UP ) {
+ }
+ and you'll catch left-up, up, and right-up.
+
+1.1.2:
+ Added multiple timer support:
+ SDL_AddTimer() and SDL_RemoveTimer()
+
+ SDL_WM_SetIcon() now respects the icon colorkey if mask is NULL.
+
+1.1.0:
+ Added initial OpenGL support.
+ First set GL attributes (such as RGB depth, alpha depth, etc.)
+ SDL_GL_SetAttribute()
+ Then call SDL_SetVideoMode() with the SDL_OPENGL flag.
+ Perform all of your normal GL drawing.
+ Finally swap the buffers with the new SDL function:
+ SDL_GL_SwapBuffers()
+ See the new 'testgl' test program for an example of using GL with SDL.
+
+ You can load GL extension functions by using the function:
+ SDL_GL_LoadProcAddress()
+
+ Added functions to initialize and cleanup specific SDL subsystems:
+ SDL_InitSubSystem() and SDL_QuitSubSystem()
+
+ Added user-defined event type:
+ typedef struct {
+ Uint8 type;
+ int code;
+ void *data1;
+ void *data2;
+ } SDL_UserEvent;
+ This structure is in the "user" member of an SDL_Event.
+
+ Added a function to push events into the event queue:
+ SDL_PushEvent()
+
+ Example of using the new SDL user-defined events:
+ {
+ SDL_Event event;
+
+ event.type = SDL_USEREVENT;
+ event.user.code = my_event_code;
+ event.user.data1 = significant_data;
+ event.user.data2 = 0;
+ SDL_PushEvent(&event);
+ }
+
+ Added a function to get mouse deltas since last query:
+ SDL_GetRelativeMouseState()
+
+ Added a boolean datatype to SDL_types.h:
+ SDL_bool = { SDL_TRUE, SDL_FALSE }
+
+ Added a function to get the current audio status:
+ SDL_GetAudioState();
+ It returns one of:
+ SDL_AUDIO_STOPPED,
+ SDL_AUDIO_PLAYING,
+ SDL_AUDIO_PAUSED
+
+ Added an AAlib driver (ASCII Art) - by Stephane Peter.
+
+1.0.6:
+ The input grab state is reset after each call to SDL_SetVideoMode().
+ The input is grabbed by default in fullscreen mode, and ungrabbed in
+ windowed mode. If you want to set input grab to a particular value,
+ you should set it after each call to SDL_SetVideoMode().
+
+1.0.5:
+ Exposed SDL_AudioInit(), SDL_VideoInit()
+ Added SDL_AudioDriverName() and SDL_VideoDriverName()
+
+ Added new window manager function:
+ SDL_WM_ToggleFullScreen()
+ This is currently implemented only on Linux
+
+ The ALT-ENTER code has been removed - it's not appropriate for a
+ lib to bind keys when they aren't even emergency escape sequences.
+
+ ALT-ENTER functionality can be implemented with the following code:
+
+ int Handle_AltEnter(const SDL_Event *event)
+ {
+ if ( event->type == SDL_KEYDOWN ) {
+ if ( (event->key.keysym.sym == SDLK_RETURN) &&
+ (event->key.keysym.mod & KMOD_ALT) ) {
+ SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
+ return(0);
+ }
+ }
+ return(1);
+ }
+ SDL_SetEventFilter(Handle_AltEnter);
+
+1.0.3:
+ Under X11, if you grab the input and hide the mouse cursor,
+ the mouse will go into a "relative motion" mode where you
+ will always get relative motion events no matter how far in
+ each direction you move the mouse - relative motion is not
+ bounded by the edges of the window (though the absolute values
+ of the mouse positions are clamped by the size of the window).
+ The SVGAlib, framebuffer console, and DirectInput drivers all
+ have this behavior naturally, and the GDI and BWindow drivers
+ never go into "relative motion" mode.
+
+1.0.2:
+ Added a function to enable keyboard repeat:
+ SDL_EnableKeyRepeat()
+
+ Added a function to grab the mouse and keyboard input
+ SDL_WM_GrabInput()
+
+ Added a function to iconify the window.
+ SDL_WM_IconifyWindow()
+ If this function succeeds, the application will receive an event
+ signaling SDL_APPACTIVE event
+
+1.0.1:
+ Added constants to SDL_audio.h for 16-bit native byte ordering:
+ AUDIO_U16SYS, AUDIO_S16SYS
+
+1.0.0:
+ New public release
+
+Version 0.11:
+
+0.11.5:
+ A new function SDL_GetVideoSurface() has been added, and returns
+ a pointer to the current display surface.
+
+ SDL_AllocSurface() has been renamed SDL_CreateRGBSurface(), and
+ a new function SDL_CreateRGBSurfaceFrom() has been added to allow
+ creating an SDL surface from an existing pixel data buffer.
+
+ Added SDL_GetRGB() to the headers and documentation.
+
+0.11.4:
+ SDL_SetLibraryPath() is no longer meaningful, and has been removed.
+
+0.11.3:
+ A new flag for SDL_Init(), SDL_INIT_NOPARACHUTE, prevents SDL from
+ installing fatal signal handlers on operating systems that support
+ them.
+
+Version 0.9:
+
+0.9.15:
+ SDL_CreateColorCursor() has been removed. Color cursors should
+ be implemented as sprites, blitted by the application when the
+ cursor moves. To get smooth color cursor updates when the app
+ is busy, pass the SDL_INIT_EVENTTHREAD flag to SDL_Init(). This
+ allows you to handle the mouse motion in another thread from an
+ event filter function, but is currently only supported by Linux
+ and BeOS. Note that you'll have to protect the display surface
+ from multi-threaded access by using mutexes if you do this.
+
+ Thread-safe surface support has been removed from SDL.
+ This makes blitting somewhat faster, by removing SDL_MiddleBlit().
+ Code that used SDL_MiddleBlit() should use SDL_LowerBlit() instead.
+ You can make your surfaces thread-safe by allocating your own
+ mutex and making lock/unlock calls around accesses to your surface.
+
+0.9.14:
+ SDL_GetMouseState() now takes pointers to int rather than Uint16.
+
+ If you set the SDL_WINDOWID environment variable under UNIX X11,
+ SDL will use that as the main window instead of creating it's own.
+ This is an unsupported extension to SDL, and not portable at all.
+
+0.9.13:
+ Added a function SDL_SetLibraryPath() which can be used to specify
+ the directory containing the SDL dynamic libraries. This is useful
+ for commercial applications which ship with particular versions
+ of the libraries, and for security on multi-user systems.
+ If this function is not used, the default system directories are
+ searched using the native dynamic object loading mechanism.
+
+ In order to support C linkage under Visual C++, you must declare
+ main() without any return type:
+ main(int argc, char *argv[]) {
+ /* Do the program... */
+ return(0);
+ }
+ C++ programs should also return a value if compiled under VC++.
+
+ The blit_endian member of the SDL_VideoInfo struct has been removed.
+
+ SDL_SymToASCII() has been replaced with SDL_GetKeyName(), so there
+ is now no longer any function to translate a keysym to a character.
+
+ The SDL_keysym structure has been extended with a 'scancode' and
+ 'unicode' member. The 'scancode' is a hardware specific scancode
+ for the key that was pressed, and may be 0. The 'unicode' member
+ is a 16-bit UNICODE translation of the key that was pressed along
+ with any modifiers or compose keys that have been pressed.
+ If no UNICODE translation exists for the key, 'unicode' will be 0.
+
+ Added a function SDL_EnableUNICODE() to enable/disable UNICODE
+ translation of character keypresses. Translation defaults off.
+
+ To convert existing code to use the new API, change code which
+ uses SDL_SymToASCII() to get the keyname to use SDL_GetKeyName(),
+ and change code which uses it to get the ASCII value of a sym to
+ use the 'unicode' member of the event keysym.
+
+0.9.12:
+ There is partial support for 64-bit datatypes. I don't recommend
+ you use this if you have a choice, because 64-bit datatypes are not
+ supported on many platforms. On platforms for which it is supported,
+ the SDL_HAS_64BIT_TYPE C preprocessor define will be enabled, and
+ you can use the Uint64 and Sint64 datatypes.
+
+ Added functions to SDL_endian.h to support 64-bit datatypes:
+ SDL_SwapLE64(), SDL_SwapBE64(),
+ SDL_ReadLE64(), SDL_ReadBE64(), SDL_WriteLE64(), SDL_WriteBE64()
+
+ A new member "len_ratio" has been added to the SDL_AudioCVT structure,
+ and allows you to determine either the original buffer length or the
+ converted buffer length, given the other.
+
+ A new function SDL_FreeWAV() has been added to the API to free data
+ allocated by SDL_LoadWAV_RW(). This is necessary under Win32 since
+ the gcc compiled DLL uses a different heap than VC++ compiled apps.
+
+ SDL now has initial support for international keyboards using the
+ Latin character set.
+ If a particular mapping is desired, you can set the DEFAULT_KEYBOARD
+ compile-time variable, or you can set the environment variable
+ "SDL_KEYBOARD" to a string identifying the keyboard mapping you desire.
+ The valid values for these variables can be found in SDL_keyboard.c
+
+ Full support for German and French keyboards under X11 is implemented.
+
+0.9.11:
+ The THREADED_EVENTS compile-time define has been replaced with the
+ SDL_INIT_EVENTTHREAD flag. If this flag is passed to SDL_Init(),
+ SDL will create a separate thread to perform input event handling.
+ If this flag is passed to SDL_Init(), and the OS doesn't support
+ event handling in a separate thread, SDL_Init() will fail.
+ Be sure to add calls to SDL_Delay() in your main thread to allow
+ the OS to schedule your event thread, or it may starve, leading
+ to slow event delivery and/or dropped events.
+ Currently MacOS and Win32 do not support this flag, while BeOS
+ and Linux do support it. I recommend that your application only
+ use this flag if absolutely necessary.
+
+ The SDL thread function passed to SDL_CreateThread() now returns a
+ status. This status can be retrieved by passing a non-NULL pointer
+ as the 'status' argument to SDL_WaitThread().
+
+ The volume parameter to SDL_MixAudio() has been increased in range
+ from (0-8) to (0-128)
+
+ SDL now has a data source abstraction which can encompass a file,
+ an area of memory, or any custom object you can envision. It uses
+ these abstractions, SDL_RWops, in the endian read/write functions,
+ and the built-in WAV and BMP file loaders. This means you can load
+ WAV chunks from memory mapped files, compressed archives, network
+ pipes, or anything else that has a data read abstraction.
+
+ There are three built-in data source abstractions:
+ SDL_RWFromFile(), SDL_RWFromFP(), SDL_RWFromMem()
+ along with a generic data source allocation function:
+ SDL_AllocRW()
+ These data sources can be used like stdio file pointers with the
+ following convenience functions:
+ SDL_RWseek(), SDL_RWread(), SDL_RWwrite(), SDL_RWclose()
+ These functions are defined in the new header file "SDL_rwops.h"
+
+ The endian swapping functions have been turned into macros for speed
+ and SDL_CalculateEndian() has been removed. SDL_endian.h now defines
+ SDL_BYTEORDER as either SDL_BIG_ENDIAN or SDL_LIL_ENDIAN depending on
+ the endianness of the host system.
+
+ The endian read/write functions now take an SDL_RWops pointer
+ instead of a stdio FILE pointer, to support the new data source
+ abstraction.
+
+ The SDL_*LoadWAV() functions have been replaced with a single
+ SDL_LoadWAV_RW() function that takes a SDL_RWops pointer as it's
+ first parameter, and a flag whether or not to automatically
+ free it as the second parameter. SDL_LoadWAV() is a macro for
+ backward compatibility and convenience:
+ SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+
+ The SDL_*LoadBMP()/SDL_*SaveBMP() functions have each been replaced
+ with a single function that takes a SDL_RWops pointer as it's
+ first parameter, and a flag whether or not to automatically
+ free it as the second parameter. SDL_LoadBMP() and SDL_SaveBMP()
+ are macros for backward compatibility and convenience:
+ SDL_LoadBMP_RW(SDL_RWFromFile("sample.bmp", "rb"), 1, ...);
+ SDL_SaveBMP_RW(SDL_RWFromFile("sample.bmp", "wb"), 1, ...);
+ Note that these functions use SDL_RWseek() extensively, and should
+ not be used on pipes or other non-seekable data sources.
+
+0.9.10:
+ The Linux SDL_SysWMInfo and SDL_SysWMMsg structures have been
+ extended to support multiple types of display drivers, as well as
+ safe access to the X11 display when THREADED_EVENTS is enabled.
+ The new structures are documented in the SDL_syswm.h header file.
+
+ Thanks to John Elliott , the UK keyboard
+ should now work properly, as well as the "Windows" keys on US
+ keyboards.
+
+ The Linux CD-ROM code now reads the CD-ROM devices from /etc/fstab
+ instead of trying to open each block device on the system.
+ The CD must be listed in /etc/fstab as using the iso9660 filesystem.
+
+ On Linux, if you define THREADED_EVENTS at compile time, a separate
+ thread will be spawned to gather X events asynchronously from the
+ graphics updates. This hasn't been extensively tested, but it does
+ provide a means of handling keyboard and mouse input in a separate
+ thread from the graphics thread. (This is now enabled by default.)
+
+ A special access function SDL_PeepEvents() allows you to manipulate
+ the event queue in a thread-safe manner, including peeking at events,
+ removing events of a specified type, and adding new events of arbitrary
+ type to the queue (use the new 'user' member of the SDL_Event type).
+
+ If you use SDL_PeepEvents() to gather events, then the main graphics
+ thread needs to call SDL_PumpEvents() periodically to drive the event
+ loop and generate input events. This is not necessary if SDL has been
+ compiled with THREADED_EVENTS defined, but doesn't hurt.
+
+ A new function SDL_ThreadID() returns the identifier associated with
+ the current thread.
+
+0.9.9:
+ The AUDIO_STEREO format flag has been replaced with a new 'channels'
+ member of the SDL_AudioSpec structure. The channels are 1 for mono
+ audio, and 2 for stereo audio. In the future more channels may be
+ supported for 3D surround sound.
+
+ The SDL_MixAudio() function now takes an additional volume parameter,
+ which should be set to SDL_MIX_MAXVOLUME for compatibility with the
+ original function.
+
+ The CD-ROM functions which take a 'cdrom' parameter can now be
+ passed NULL, and will act on the last successfully opened CD-ROM.
+
+0.9.8:
+ No changes, bugfixes only.
+
+0.9.7:
+ No changes, bugfixes only.
+
+0.9.6:
+ Added a fast rectangle fill function: SDL_FillRect()
+
+ Addition of a useful function for getting info on the video hardware:
+ const SDL_VideoInfo *SDL_GetVideoInfo(void)
+ This function replaces SDL_GetDisplayFormat().
+
+ Initial support for double-buffering:
+ Use the SDL_DOUBLEBUF flag in SDL_SetVideoMode()
+ Update the screen with a new function: SDL_Flip()
+
+ SDL_AllocSurface() takes two new flags:
+ SDL_SRCCOLORKEY means that the surface will be used for colorkey blits
+ and if the hardware supports hardware acceleration of colorkey blits
+ between two surfaces in video memory, to place the surface in video
+ memory if possible, otherwise it 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.
+ SDL_HWSURFACE now means that the surface will be created with the
+ same format as the display surface, since having surfaces in video
+ memory is only useful for fast blitting to the screen, and you can't
+ blit surfaces with different surface formats in video memory.
+
+0.9.5:
+ You can now pass a NULL mask to SDL_WM_SetIcon(), and it will assume
+ that the icon consists of the entire image.
+
+ SDL_LowerBlit() is back -- but don't use it on the display surface.
+ It is exactly the same as SDL_MiddleBlit(), but doesn't check for
+ thread safety.
+
+ Added SDL_FPLoadBMP(), SDL_FPSaveBMP(), SDL_FPLoadWAV(), which take
+ a FILE pointer instead of a file name.
+
+ Added CD-ROM audio control API:
+ SDL_CDNumDrives()
+ SDL_CDName()
+ SDL_CDOpen()
+ SDL_CDStatus()
+ SDL_CDPlayTracks()
+ SDL_CDPlay()
+ SDL_CDPause()
+ SDL_CDResume()
+ SDL_CDStop()
+ SDL_CDEject()
+ SDL_CDClose()
+
+0.9.4:
+ No changes, bugfixes only.
+
+0.9.3:
+ Mouse motion event now includes relative motion information:
+ Sint16 event->motion.xrel, Sint16 event->motion.yrel
+
+ X11 keyrepeat handling can be disabled by defining IGNORE_X_KEYREPEAT
+ (Add -DIGNORE_X_KEYREPEAT to CFLAGS line in obj/x11Makefile)
+
+0.9.2:
+ No changes, bugfixes only.
+
+0.9.1:
+ Removed SDL_MapSurface() and SDL_UnmapSurface() -- surfaces are now
+ automatically mapped on blit.
+
+0.8.0:
+ SDL stable release
diff --git a/lib/sdl/msvc/docs.html b/lib/sdl/msvc/docs.html
new file mode 100644
index 0000000000000000000000000000000000000000..66ca9235ab9719efb2df64ac424665e8c3deffc3
--- /dev/null
+++ b/lib/sdl/msvc/docs.html
@@ -0,0 +1,629 @@
+
+SDL Stable Release
+
+
+
+
+This source is stable, and is fully tested on all supported platforms.
+Please send bug reports or questions to the SDL mailing list:
+http://www.libsdl.org/mailing-list.php
+The latest stable release may be found on the
+ SDL website.
+
+ Fixed SDL_VIDEO_WINDOW_POS environment variable for Quartz target.
+
+
+ Fixed setting the starting working directory in release builds.
+
+
+
+
+
+
SDL 1.2.13 Release Notes
+
+SDL 1.2.13 is a minor bug fix release.
+
+
+
General Notes
+
+
+
+ Fixed link error when building with Intel Compiler 10.
+
+
+ Removed stray C++ comment from public headers.
+
+
+
+
Unix Notes
+
+
+
+ Fixed crash in SDL_SoftStretch() on secure operating systems.
+
+
+ Fixed undefined symbol on X11 implementations without UTF-8 support.
+
+
+ Worked around BadAlloc error when using XVideo on the XFree86 Intel Integrated Graphics driver.
+
+
+ Scan for all joysticks on Linux instead of stopping at one that was removed.
+
+
+ Fixed use of sdl-config arguments in sdl.m4
+
+
+
+
Windows Notes
+
+
+
+ Fixed crash when a video driver reports higher than 32 bpp video modes.
+
+
+ Fixed restoring the desktop after setting a 24-bit OpenGL video mode.
+
+
+ Fixed window titles on Windows 95/98/ME.
+
+
+ Added SDL_BUTTON_X1 and SDL_BUTTON_X2 constants for extended mouse buttons.
+
+
+ Added support for quoted command line arguments.
+
+
+
+
Mac OS X Notes
+
+
+
+ SDL now builds on Mac OS X 10.5 (Leopard).
+
+
+ Fixed high frequency crash involving text input.
+
+
+ Fixed beeping when the escape key is pressed and UNICODE translation is enabled.
+
+
+ Improved trackpad scrolling support.
+
+
+ Fixed joystick hat reporting for certain joysticks.
+
+
+
+
+
+
SDL 1.2.12 Release Notes
+
+SDL 1.2.12 is a minor bug fix release.
+
+
+
General Notes
+
+
+
+ Added support for the PulseAudio sound server: http://www.pulseaudio.org/
+
+
+ Added SDL_VIDEO_ALLOW_SCREENSAVER to override SDL's disabling of the screensaver on Mac OS X, Windows, and X11.
+
+
+ Fixed buffer overrun crash when resampling audio rates.
+
+
+ Fixed audio bug where converting to mono was doubling the volume.
+
+
+ Fixed off-by-one error in the C implementation of SDL_revcpy()
+
+
+ Fixed compiling with Sun Studio.
+
+
+ Support for AmigaOS has been removed from the main SDL code.
+
+
+ Support for Nokia 9210 "EPOC" driver has been removed from the main SDL code.
+
+
+ Unofficial support for the S60/SymbianOS platform has been added.
+
+
+ Unofficial support for the Nintendo DS platform has been added.
+
+
+ Reenabled MMX assembly for YUV overlay processing (GNU C Compiler only).
+
+
+
+
Unix Notes
+
+
+
+ Fixed detection of X11 DGA mouse support.
+
+
+ Improved XIM support for asian character sets.
+
+
+ The GFX_Display has been added to the X11 window information in SDL_syswm.h.
+
+
+ Fixed PAGE_SIZE compile error in the fbcon video driver on newer Linux kernels.
+
+
+ Fixed hang or crash at startup if aRts can't access the hardware.
+
+
+ Fixed relative mouse mode when the cursor starts outside the X11 window.
+
+
+ Fixed accidental free of stack memory in X11 mouse acceleration code.
+
+
+ Closed minor memory leak in XME code.
+
+
+ Fixed TEXTRELs in the library to resolve some PIC issues.
+
+
+
+
Windows Notes
+
+
+
+ The GDI video driver makes better use of the palette in 8-bit modes.
+
+
+ The windib driver now supports more mouse buttons with WM_XBUTTON events.
+
+
+ On Windows, SDL_SetVideoMode() will re-create the window instead of failing if the multisample settings are changed.
+
+
+ Added support for UTF-8 window titles on Windows.
+
+
+ Fixed joystick detection on Windows.
+
+
+ Improved performance with Win32 file I/O.
+
+
+ Fixed HBITMAP leak in GAPI driver.
+
+
+
+
Mac OS X Notes
+
+
+
+ Added support for multi-axis controllers like 3Dconnxion's SpaceNavigator on Mac OS X.
+
+
+ Fixed YUV overlay crash inside Quicktime on Intel Mac OS X.
+
+
+ Fixed blitting alignment in Altivec alpha blit functions.
+
+
+ Keys F13, F14, and F15 are now usable on Apple keyboards under Mac OS X.
+
+
+ Fixed joystick calibration code on Mac OS X.
+
+
+ Fixed mouse jitter when multiple motion events are queued up in Mac OS X.
+
+
+ Fixed changing the cursor in fullscreen mode on Mac OS X.
+
+
+
+
Mac OS Classic Notes
+
+
+
+ Added support for gamma ramps to both toolbox and DrawSprocket video drivers.
+
+
+
+
BeOS Notes
+
+
+
+ Implemented mouse grabbing and mouse relative mode on BeOS.
+
+
+
+
+
+
SDL 1.2.11 Release Notes
+
+SDL 1.2.11 is a minor bug fix release.
+
+
+
Unix Notes
+
+
+
+ Dynamic X11 loading is only enabled with gcc 4 supporting -fvisibility=hidden. This fixes crashes related to symbol collisions, and allows building on Solaris and IRIX.
+
+
+ Fixed building SDL with Xinerama disabled.
+
+
+ Fixed DRI OpenGL library loading, using RTLD_GLOBAL in dlopen().
+
+
+ Added pkgconfig configuration support.
+
+
+
+
Windows Notes
+
+
+
+ Setting SDL_GL_SWAP_CONTROL now works with Windows OpenGL.
+
+
+ The Win32 window positioning code works properly for windows with menus.
+
+
+ DirectSound audio quality has been improved on certain sound cards.
+
+
+ Fixed 5.1 audio channel ordering on Windows and Mac OS X.
+
+
+ Plugged a couple of minor memory leaks in the windib video driver.
+
+
+ Fixed type collision with stdint.h when building with gcc on Win32.
+
+
+ Fixed building with the Digital Mars Compiler on Win32.
+
+
+
+
Mac OS X Notes
+
+
+
+ The Quartz video driver supports 32x32 cursors on Mac OS X 10.3 and above.
+
+
+
+
+
+
SDL 1.2.10 Release Notes
+
+SDL 1.2.10 is a major release, featuring a revamp of the build system and many API improvements and bug fixes.
+
+
API enhancements
+
+
+ If SDL_OpenAudio() is passed zero for the desired format
+ fields, the following environment variables will be used
+ to fill them in:
+
+ If an environment variable is not specified, it will be set
+ to a reasonable default value.
+
+ SDL_SetVideoMode() now accepts 0 for width or height and will use
+ the current video mode (or the desktop mode if no mode has been set.)
+
+ Added current_w and current_h to the SDL_VideoInfo structure,
+ which is set to the desktop resolution during video intialization,
+ and then set to the current resolution when a video mode is set.
+
+ SDL_GL_LoadLibrary() will load the system default OpenGL library
+ if it is passed NULL as a parameter.
+
+ Added SDL_GL_SWAP_CONTROL to wait for vsync in OpenGL applications.
+
+ Added SDL_GL_ACCELERATED_VISUAL to guarantee hardware acceleration.
+
+ SDL_WM_SetCaption() now officially takes UTF-8 title and icon strings, and displays international characters on supported platforms.
+
+ Added SDL_GetKeyRepeat() to query the key repeat settings.
+
+ Added the "dummy" audio driver, which can be used to emulate audio
+ output without a sound card.
+
+ Added SDL_config.h, with defaults for various build environments.
+
+ SDL is licensed under version 2.1 of the GNU Lesser General Public License.
+
+ The entire build system has been revamped to make it much more portable, including versions of C library functions to make it possible to run SDL on a minimal embedded environment. See README.Porting in the SDL source distribution for information on how to port SDL to a new platform.
+
+ The X11 libraries are dynamically loaded at runtime by default. This allows the distributed version of SDL to run on systems without X11 libraries installed.
+
+ The XiG XME extension code is now included in the X11 video driver by default.
+
+ XRandR support for video mode switching has been added to the X11 driver, but is disabled because of undesired interactions with window managers. You can enable this by setting the environment variable SDL_VIDEO_X11_XRANDR to 1.
+
+ Xinerama multi-head displays are properly handled now, and the SDL_VIDEO_FULLSCREEN_HEAD environment variable can be used to select the screen used for fullscreen video modes. Note that changing the video modes only works on screen 0.
+
+ XVidMode video modes are now sorted so they maintain the refresh rates specified in the X11 configuration file.
+
+ SDL windows are no longer transparent in X11 compositing systems like XGL.
+
+ The mouse is properly released by the X11 video driver if the fullscreen window loses focus.
+
+ The X11 input driver now uses XIM to handle international input.
+
+ The screensaver and DPMS monitor blanking are disabled while SDL games are running under the X11 and DGA video drivers. This behavior will be formalized and selectable in SDL 1.3.
+
+ Fixed a bug preventing stereo OpenGL contexts from being selected on the X11 driver.
+
+ The DGA video driver now waits for pending blits involving surfaces before they are freed. This prevents display oddities when using SDL_DisplayFormat() to convert many images.
+
+ The framebuffer console video driver now has a parser for /etc/fb.modes for improved video mode handling.
+
+ The framebuffer console video driver now allows asynchronous VT switching, and restores the full contents of the screen when switched back.
+
+ The framebuffer console now uses CTRL-ALT-FN to switch virtual terminals, to avoid collisions with application key bindings.
+
+ The framebuffer console input driver correctly sets IMPS/2 mode for wheel mice. It also properly detects when gpm is in IMPS/2 protocol mode, or passing raw protocol from an IMPS/2 mouse.
+
+ The SVGAlib video driver now has support for banked (non-linear) video modes.
+
+ A video driver for OpenBSD on the Sharp Zaurus has been contributed by Staffan Ulfberg. See the file README.wscons in the SDL source distribution for details.
+
+ Many patches have been incorporated from *BSD ports.
+
+
+
Windows Notes
+
+
+
+ The "windib" video driver is the default now, to prevent problems with certain laptops, 64-bit Windows, and Windows Vista. The DirectX driver is still available, and can be selected by setting the environment variable SDL_VIDEODRIVER to "directx".
+
+ SDL has been ported to 64-bit Windows.
+
+ Dmitry Yakimov contributed a GAPI video driver for Windows CE.
+
+ The default fullscreen refresh rate has been increased to match the desktop refresh rate, when using equivalent resolutions. A full API for querying and selecting refresh rates is planned for SDL 1.3.
+
+ Dialog boxes are now shown when SDL is in windowed OpenGL mode.
+
+ The SDL window is recreated when necessary to maintain OpenGL context attributes, when switching between windowed and fullscreen modes.
+
+ An SDL_VIDEORESIZE event is properly sent when the SDL window is maximized and restored.
+
+ Window positions are retained when switching between fullscreen and windowed modes.
+
+ ToUnicode() is used, when available, for improved handling of international keyboard input.
+
+ The PrtScrn is now treated normally with both key down and key up events.
+
+ Pressing ALT-F4 now delivers an SDL_QUIT event to SDL applications.
+
+ Joystick names are now correct for joysticks which have been unplugged and then plugged back in since booting.
+
+ An MCI error when playing the last track on a CD-ROM has been fixed.
+
+ OpenWatcom projects for building SDL have been provided by Marc Peter.
+
+
+
Mac OS X Notes
+
+
+
+ SDL now supports building Universal binaries, both through Xcode projects and when using configure/make. See README.MacOSX in the SDL source archive for details.
+
+ The X11 video driver with GLX support can be built on Mac OS X, if the X11 development SDK is installed.
+
+ Transitions between fullscreen resolutions and windowed mode now use a much faster asynchronous fade to hide desktop flicker.
+
+ Icons set with SDL_WM_SetIcon() now have the proper colors on Intel Macs.
+
+
+
OS/2 Notes
+
+
+
+ Projects for building SDL on OS/2 with OpenWatcom have been contributed by Doodle. See the file README.OS2 in the SDL source distribution for details.
+
SDL_CloseAudio -- Shuts down audio processing and closes the audio device.
Sound on the computer is translated from waves that you hear into a series of
+values, or samples, each representing the amplitude of the wave. When these
+samples are sent in a stream to a sound card, an approximation of the original
+wave can be recreated. The more bits used to represent the amplitude, and the
+greater frequency these samples are gathered, the closer the approximated
+sound is to the original, and the better the quality of sound.
This library supports both 8 and 16 bit signed and unsigned sound samples,
+at frequencies ranging from 11025 Hz to 44100 Hz, depending on the
+underlying hardware. If the hardware doesn't support the desired audio
+format or frequency, it can be emulated if desired (See
+SDL_OpenAudio())
A commonly supported audio format is 16 bits per sample at 22050 Hz.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/cdrom.html b/lib/sdl/msvc/docs/html/cdrom.html
new file mode 100644
index 0000000000000000000000000000000000000000..bdd6bfd827252c479bb6af20b2bb9e5c1d89e96e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/cdrom.html
@@ -0,0 +1,260 @@
+CD-ROM
SDL supports audio control of up to 32 local CD-ROM drives at once.
You use this API to perform all the basic functions of a CD player,
+including listing the tracks, playing, stopping, and ejecting the CD-ROM.
+(Currently, multi-changer CD drives are not supported.)
Before you call any of the SDL CD-ROM functions, you must first call
+"SDL_Init(SDL_INIT_CDROM)", which scans the system for
+CD-ROM drives, and sets the program up for audio control. Check the
+return code, which should be 0, to see if there
+were any errors in starting up.
After you have initialized the library, you can find out how many drives
+are available using the SDL_CDNumDrives() function.
+The first drive listed is the system default CD-ROM drive. After you have
+chosen a drive, and have opened it with SDL_CDOpen(),
+you can check the status and start playing if there's a CD in the drive.
A CD-ROM is organized into one or more tracks, each consisting of a certain
+number of "frames". Each frame is ~2K in size, and at normal playing speed,
+a CD plays 75 frames per second. SDL works with the number of frames on a
+CD, but this can easily be converted to the more familiar minutes/seconds
+format by using the FRAMES_TO_MSF() macro.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/event.html b/lib/sdl/msvc/docs/html/event.html
new file mode 100644
index 0000000000000000000000000000000000000000..f2bddb2c0ab67b02b750f51d4cb26ac9e74d8e9f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/event.html
@@ -0,0 +1,216 @@
+Events
Event handling allows your application to receive input from the user. Event handling is initalised (along with video) with a call to:
+
SDL_Init(SDL_INIT_VIDEO);
+Internally, SDL stores all the events waiting to be handled in an event queue. Using functions like SDL_PollEvent and SDL_PeepEvents you can observe and handle waiting input events.
The key to event handling in SDL is the SDL_Event union. The event queue itself is composed of a series of SDL_Event unions, one for each waiting event. SDL_Event unions are read from the queue with the SDL_PollEvent function and it is then up to the application to process the information stored with them.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/eventfunctions.html b/lib/sdl/msvc/docs/html/eventfunctions.html
new file mode 100644
index 0000000000000000000000000000000000000000..f68a29a3bf174bc37ee7e94a6ad398688f553a8b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/eventfunctions.html
@@ -0,0 +1,481 @@
+Event Functions.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/eventstructures.html b/lib/sdl/msvc/docs/html/eventstructures.html
new file mode 100644
index 0000000000000000000000000000000000000000..c95929622039acd86961fe3d766deec5018a2bb2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/eventstructures.html
@@ -0,0 +1,233 @@
+SDL Event Structures.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/general.html b/lib/sdl/msvc/docs/html/general.html
new file mode 100644
index 0000000000000000000000000000000000000000..0beb5919f8b3d02aa6eee04b4fccbc93c0564b1d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/general.html
@@ -0,0 +1,225 @@
+General
Before SDL can be used in a program it must be initialized with SDL_Init. SDL_Init initializes all the subsystems that the user requests (video, audio, joystick, timers and/or cdrom). Once SDL is initialized with SDL_Init subsystems can be shut down and initialized as needed using SDL_InitSubSystem and SDL_QuitSubSystem.
SDL must also be shut down before the program exits to make sure it cleans up correctly. Calling SDL_Quit shuts down all subsystems and frees any resources allocated to SDL.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guide.html b/lib/sdl/msvc/docs/html/guide.html
new file mode 100644
index 0000000000000000000000000000000000000000..2c1297ee2bd2c35715324e0339a28513a7f9790c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guide.html
@@ -0,0 +1,174 @@
+SDL Guide
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideaboutsdldoc.html b/lib/sdl/msvc/docs/html/guideaboutsdldoc.html
new file mode 100644
index 0000000000000000000000000000000000000000..cdb0d783c2bc3307040d7764865fb297484af0ae
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideaboutsdldoc.html
@@ -0,0 +1,148 @@
+About SDLdoc
SDLdoc (The SDL Documentation Project) was formed to completely rewrite the SDL documentation and to keep it continually up to date. The team consists completely of volunteers ranging from people working with SDL in their spare time to people who use SDL in their everyday working lives.
The latest version of this documentation can always be found here: http://sdldoc.csn.ul.ie Downloadable PS, man pages and html tarballs are available at http://sdldoc.csn.ul.ie/pub/
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideaudioexamples.html b/lib/sdl/msvc/docs/html/guideaudioexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..afb7522be7d2367b1b47a5cc90392bab68bc3a3b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideaudioexamples.html
@@ -0,0 +1,228 @@
+Audio Examples
SDL_AudioSpec wanted;
+ extern void fill_audio(void *udata, Uint8 *stream, int len);
+
+ /* Set the audio format */
+ wanted.freq = 22050;
+ wanted.format = AUDIO_S16;
+ wanted.channels = 2; /* 1 = mono, 2 = stereo */
+ wanted.samples = 1024; /* Good low-latency value for callback */
+ wanted.callback = fill_audio;
+ wanted.userdata = NULL;
+
+ /* Open the audio device, forcing the desired format */
+ if ( SDL_OpenAudio(&wanted, NULL) < 0 ) {
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ return(-1);
+ }
+ return(0);
Playing audio
static Uint8 *audio_chunk;
+ static Uint32 audio_len;
+ static Uint8 *audio_pos;
+
+ /* The audio function callback takes the following parameters:
+ stream: A pointer to the audio buffer to be filled
+ len: The length (in bytes) of the audio buffer
+ */
+ void fill_audio(void *udata, Uint8 *stream, int len)
+ {
+ /* Only play if we have data left */
+ if ( audio_len == 0 )
+ return;
+
+ /* Mix as much data as possible */
+ len = ( len > audio_len ? audio_len : len );
+ SDL_MixAudio(stream, audio_pos, len, SDL_MIX_MAXVOLUME);
+ audio_pos += len;
+ audio_len -= len;
+ }
+
+ /* Load the audio data ... */
+
+ ;;;;;
+
+ audio_pos = audio_chunk;
+
+ /* Let the callback function play the audio chunk */
+ SDL_PauseAudio(0);
+
+ /* Do some processing */
+
+ ;;;;;
+
+ /* Wait for sound to complete */
+ while ( audio_len > 0 ) {
+ SDL_Delay(100); /* Sleep 1/10 second */
+ }
+ SDL_CloseAudio();
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidebasicsinit.html b/lib/sdl/msvc/docs/html/guidebasicsinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..faafdbd9204ab3a3070f2f2d5daa1af0c9e1a8f3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidebasicsinit.html
@@ -0,0 +1,240 @@
+Initializing SDL
SDL is composed of eight subsystems - Audio, CDROM, Event Handling, File I/O, Joystick Handling, Threading, Timers and Video. Before you can use any of these subsystems they must be initialized by calling SDL_Init (or SDL_InitSubSystem). SDL_Init must be called before any other SDL function. It automatically initializes the Event Handling, File I/O and Threading subsystems and it takes a parameter specifying which other subsystems to initialize. So, to initialize the default subsystems and the Video subsystems you would call:
+
SDL_Init ( SDL_INIT_VIDEO );
+To initialize the default subsystems, the Video subsystem and the Timers subsystem you would call:
+
SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_TIMER );
SDL_Init is complemented by SDL_Quit (and SDL_QuitSubSystem). SDL_Quit shuts down all subsystems, including the default ones. It should always be called before a SDL application exits.
With SDL_Init and SDL_Quit firmly embedded in your programmers toolkit you can write your first and most basic SDL application. However, we must be prepare to handle errors. Many SDL functions return a value and indicates whether the function has succeeded or failed, SDL_Init, for instance, returns -1 if it could not initialize a subsystem. SDL provides a useful facility that allows you to determine exactly what the problem was, every time an error occurs within SDL an error message is stored which can be retrieved using SDL_GetError. Use this often, you can never know too much about an error.
Example 1-1. Initializing SDL
#include "SDL.h" /* All SDL App's need this */
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+
+ printf("Initializing SDL.\n");
+
+ /* Initialize defaults, Video and Audio */
+ if((SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO)==-1)) {
+ printf("Could not initialize SDL: %s.\n", SDL_GetError());
+ exit(-1);
+ }
+
+ printf("SDL initialized.\n");
+
+ printf("Quiting SDL.\n");
+
+ /* Shutdown all subsystems */
+ SDL_Quit();
+
+ printf("Quiting....\n");
+
+ exit(0);
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidecdromexamples.html b/lib/sdl/msvc/docs/html/guidecdromexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..2bc5a16cb53f20d54e26436d00f46f5a53f68434
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidecdromexamples.html
@@ -0,0 +1,275 @@
+CDROM Examples
#include "SDL.h"
+
+ /* Initialize SDL first */
+ if ( SDL_Init(SDL_INIT_CDROM) < 0 ) {
+ fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
+ exit(1);
+ }
+ atexit(SDL_Quit);
+
+ /* Find out how many CD-ROM drives are connected to the system */
+ printf("Drives available: %d\n", SDL_CDNumDrives());
+ for ( i=0; i<SDL_CDNumDrives(); ++i ) {
+ printf("Drive %d: \"%s\"\n", i, SDL_CDName(i));
+ }
Opening the default drive
SDL_CD *cdrom;
+ CDstatus status;
+ char *status_str;
+
+ cdrom = SDL_CDOpen(0);
+ if ( cdrom == NULL ) {
+ fprintf(stderr, "Couldn't open default CD-ROM drive: %s\n",
+ SDL_GetError());
+ exit(2);
+ }
+
+ status = SDL_CDStatus(cdrom);
+ switch (status) {
+ case CD_TRAYEMPTY:
+ status_str = "tray empty";
+ break;
+ case CD_STOPPED:
+ status_str = "stopped";
+ break;
+ case CD_PLAYING:
+ status_str = "playing";
+ break;
+ case CD_PAUSED:
+ status_str = "paused";
+ break;
+ case CD_ERROR:
+ status_str = "error state";
+ break;
+ }
+ printf("Drive status: %s\n", status_str);
+ if ( status >= CD_PLAYING ) {
+ int m, s, f;
+ FRAMES_TO_MSF(cdrom->cur_frame, &m, &s, &f);
+ printf("Currently playing track %d, %d:%2.2d\n",
+ cdrom->track[cdrom->cur_track].id, m, s);
+ }
Listing the tracks on a CD
SDL_CD *cdrom; /* Assuming this has already been set.. */
+ int i;
+ int m, s, f;
+
+ SDL_CDStatus(cdrom);
+ printf("Drive tracks: %d\n", cdrom->numtracks);
+ for ( i=0; i<cdrom->numtracks; ++i ) {
+ FRAMES_TO_MSF(cdrom->track[i].length, &m, &s, &f);
+ if ( f > 0 )
+ ++s;
+ printf("\tTrack (index %d) %d: %d:%2.2d\n", i,
+ cdrom->track[i].id, m, s);
+ }
Play an entire CD
SDL_CD *cdrom; /* Assuming this has already been set.. */
+
+ // Play entire CD:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+ SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
+
+ // Play last track:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
+ SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
+ }
+
+ // Play first and second track and 10 seconds of third track:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+ SDL_CDPlayTracks(cdrom, 0, 0, 2, CD_FPS * 10);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidecredits.html b/lib/sdl/msvc/docs/html/guidecredits.html
new file mode 100644
index 0000000000000000000000000000000000000000..b66b28f54dbcad18dcaad6d8f783ebc7621789f2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidecredits.html
@@ -0,0 +1,195 @@
+Credits
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideeventexamples.html b/lib/sdl/msvc/docs/html/guideeventexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..300136947cb7286820691982296bd70b171f2a16
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideeventexamples.html
@@ -0,0 +1,247 @@
+Event Examples
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideexamples.html b/lib/sdl/msvc/docs/html/guideexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..5b9a8471df853828c8c48f22145cc43ae69b9106
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideexamples.html
@@ -0,0 +1,188 @@
+Examples
For the moment these examples are taken directly from the old SDL documentation. By the 1.2 release these examples should hopefully deal with most common SDL programming problems.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideinput.html b/lib/sdl/msvc/docs/html/guideinput.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a82b6761abdcebce1b4c165337d60967dff1224
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideinput.html
@@ -0,0 +1,739 @@
+Input handling
The first step in using a joystick in a SDL program is to initialize the Joystick subsystems of SDL. This done by passing the SDL_INIT_JOYSTICK flag to SDL_Init. The joystick flag will usually be used in conjunction with other flags (like the video flag) because the joystick is usually used to control something.
Example 3-1. Initializing SDL with Joystick Support
This will attempt to start SDL with both the video and the joystick subsystems activated.
Querying
If we have reached this point then we can safely assume that the SDL library has been initialized and that the Joystick subsystem is active. We can now call some video and/or sound functions to get things going before we need the joystick. Eventually we have to make sure that there is actually a joystick to work with. It's wise to always check even if you know a joystick will be present on the system because it can also help detect when the joystick is unplugged. The function used to check for joysticks is SDL_NumJoysticks.
This function simply returns the number of joysticks available on the system. If it is at least one then we are in good shape. The next step is to determine which joystick the user wants to use. If the number of joysticks available is only one then it is safe to assume that one joystick is the one the user wants to use. SDL has a function to get the name of the joysticks as assigned by the operations system and that function is SDL_JoystickName. The joystick is specified by an index where 0 is the first joystick and the last joystick is the number returned by SDL_NumJoysticks - 1. In the demonstration a list of all available joysticks is printed to stdout.
Example 3-2. Querying the Number of Available Joysticks
printf("%i joysticks were found.\n\n", SDL_NumJoysticks() );
+ printf("The names of the joysticks are:\n");
+
+ for( i=0; i < SDL_NumJoysticks(); i++ )
+ {
+ printf(" %s\n", SDL_JoystickName(i));
+ }
Opening a Joystick and Receiving Joystick Events
SDL's event driven architecture makes working with joysticks a snap. Joysticks can trigger 4 different types of events:
+
Events are received from all joysticks opened. The first thing that needs to be done in order to receive joystick events is to call SDL_JoystickEventState with the SDL_ENABLE flag. Next you must open the joysticks that you want to receive envents from. This is done with the SDL_JoystickOpen function. For the example we are only interested in events from the first joystick on the system, regardless of what it may be. To receive events from it we would do this:
If we wanted to receive events for other joysticks we would open them with calls to SDL_JoystickOpen just like we opened joystick 0, except we would store the SDL_Joystick structure they return in a different pointer. We only need the joystick pointer when we are querying the joysticks or when we are closing the joystick.
Up to this point all the code we have is used just to initialize the joysticks in order to read values at run time. All we need now is an event loop, which is something that all SDL programs should have anyway to receive the systems quit events. We must now add code to check the event loop for at least some of the above mentioned events. Let's assume our event loop looks like this:
+
SDL_Event event;
+ /* Other initializtion code goes here */
+
+ /* Start main game loop here */
+
+ while(SDL_PollEvent(&event))
+ {
+ switch(event.type)
+ {
+ case SDL_KEYDOWN:
+ /* handle keyboard stuff here */
+ break;
+
+ case SDL_QUIT:
+ /* Set whatever flags are necessary to */
+ /* end the main game loop here */
+ break;
+ }
+ }
+
+ /* End loop here */
+To handle Joystick events we merely add cases for them, first we'll add axis handling code. Axis checks can get kinda of tricky because alot of the joystick events received are junk. Joystick axis have a tendency to vary just a little between polling due to the way they are designed. To compensate for this you have to set a threshold for changes and ignore the events that have'nt exceeded the threshold. 10% is usually a good threshold value. This sounds a lot more complicated than it is. Here is the Axis event handler:
Another trick with axis events is that up-down and left-right movement are two different sets of axes. The most important axis is axis 0 (left-right) and axis 1 (up-down). To handle them seperatly in the code we do the following:
Ideally the code here should use event.jaxis.value to scale something. For example lets assume you are using the joystick to control the movement of a spaceship. If the user is using an analog joystick and they push the stick a little bit they expect to move less than if they pushed it a lot. Designing your code for this situation is preferred because it makes the experience for users of analog controls better and remains the same for users of digital controls.
If your joystick has any additional axis then they may be used for other sticks or throttle controls and those axis return values too just with different event.jaxis.axis values.
Button handling is simple compared to the axis checking.
Example 3-6. Joystick Button Events
case SDL_JOYBUTTONDOWN: /* Handle Joystick Button Presses */
+ if ( event.jbutton.button == 0 )
+ {
+ /* code goes here */
+ }
+ break;
Button checks are simpler than axis checks because a button can only be pressed or not pressed. The SDL_JOYBUTTONDOWN event is triggered when a button is pressed and the SDL_JOYBUTTONUP event is fired when a button is released. We do have to know what button was pressed though, that is done by reading the event.jbutton.button field.
Lastly when we are through using our joysticks we should close them with a call to SDL_JoystickClose. To close our opened joystick 0 we would do this at the end of our program:
+
SDL_JoystickClose(joystick);
Advanced Joystick Functions
That takes care of the controls that you can count on being on every joystick under the sun, but there are a few extra things that SDL can support. Joyballs are next on our list, they are alot like axis with a few minor differences. Joyballs store relative changes unlike the the absolute postion stored in a axis event. Also one trackball event contains both the change in x and they change in y. Our case for it is as follows:
The above checks the first joyball on the joystick. The change in position will be stored in event.jball.xrel and event.jball.yrel.
Finally we have the hat event. Hats report only the direction they are pushed in. We check hat's position with the bitmasks:
+
+
SDL_HAT_CENTERED
SDL_HAT_UP
SDL_HAT_RIGHT
SDL_HAT_DOWN
SDL_HAT_LEFT
+
+Also there are some predefined combinations of the above:
+
SDL_HAT_RIGHTUP
SDL_HAT_RIGHTDOWN
SDL_HAT_LEFTUP
SDL_HAT_LEFTDOWN
+
+Our case for the hat may resemble the following:
Example 3-8. Joystick Hat Events
case SDL_JOYHATMOTION: /* Handle Hat Motion */
+ if ( event.jhat.value & SDL_HAT_UP )
+ {
+ /* Do up stuff here */
+ }
+
+ if ( event.jhat.value & SDL_HAT_LEFT )
+ {
+ /* Do left stuff here */
+ }
+
+ if ( event.jhat.value & SDL_HAT_RIGHTDOWN )
+ {
+ /* Do right and down together stuff here */
+ }
+ break;
In addition to the queries for number of joysticks on the system and their names there are additional functions to query the capabilities of attached joysticks:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideinputkeyboard.html b/lib/sdl/msvc/docs/html/guideinputkeyboard.html
new file mode 100644
index 0000000000000000000000000000000000000000..787036c7f2ad3b8e35dfb6dd578d2b9e5085b4c8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideinputkeyboard.html
@@ -0,0 +1,746 @@
+Handling the Keyboard
It should make it a lot easier to understand this tutorial is you are familiar with the data types involved in keyboard access, so I'll explain them first.
SDLKey
SDLKey is an enumerated type defined in SDL/include/SDL_keysym.h and detailed here. Each SDLKey symbol represents a key, SDLK_a corresponds to the 'a' key on a keyboard, SDLK_SPACE corresponds to the space bar, and so on.
SDLMod
SDLMod is an enumerated type, similar to SDLKey, however it enumerates keyboard modifiers (Control, Alt, Shift). The full list of modifier symbols is here. SDLMod values can be AND'd together to represent several modifiers.
The SDL_keysym structure describes a key press or a key release. The scancode field is hardware specific and should be ignored unless you know what your doing. The sym field is the SDLKey value of the key being pressed or released. The mod field describes the state of the keyboard modifiers at the time the key press or release occurred. So a value of KMOD_NUM | KMOD_CAPS | KMOD_LSHIFT would mean that Numlock, Capslock and the left shift key were all press (or enabled in the case of the lock keys). Finally, the unicode field stores the 16-bit unicode value of the key.
Note: It should be noted and understood that this field is only valid when the SDL_keysym is describing a key press, not a key release. Unicode values only make sense on a key press because the unicode value describes an international character and only key presses produce characters. More information on Unicode can be found at www.unicode.org
Note: Unicode translation must be enabled using the SDL_EnableUNICODE function.
The SDL_KeyboardEvent describes a keyboard event (obviously). The key member of the SDL_Event union is a SDL_KeyboardEvent structure. The type field specifies whether the event is a key release (SDL_KEYUP) or a key press (SDL_KEYDOWN) event. The state is largely redundant, it reports the same information as the type field but uses different values (SDL_RELEASED and SDL_PRESSED). The keysym contains information of the key press or release that this event represents (see above).
Reading Keyboard Events
Reading keybaord events from the event queue is quite simple (the event queue and using it is described here). We read events using SDL_PollEvent in a while() loop and check for SDL_KEYUP and SDL_KEYDOWN events using a switch statement, like so:
Example 3-10. Reading Keyboard Events
SDL_Event event;
+ .
+ .
+ /* Poll for events. SDL_PollEvent() returns 0 when there are no */
+ /* more events on the event queue, our while loop will exit when */
+ /* that occurs. */
+ while( SDL_PollEvent( &event ) ){
+ /* We are only worried about SDL_KEYDOWN and SDL_KEYUP events */
+ switch( event.type ){
+ case SDL_KEYDOWN:
+ printf( "Key press detected\n" );
+ break;
+
+ case SDL_KEYUP:
+ printf( "Key release detected\n" );
+ break;
+
+ default:
+ break;
+ }
+ }
+ .
+ .
This is a very basic example. No information about the key press or release is interpreted. We will explore the other extreme out our first full example below - reporting all available information about a keyboard event.
A More Detailed Look
Before we can read events SDL must be initialised with SDL_Init and a video mode must be set using SDL_SetVideoMode. There are, however, two other functions we must use to obtain all the information required. We must enable unicode translation by calling SDL_EnableUNICODE(1) and we must convert SDLKey values into something printable, using SDL_GetKeyName
Note: It is useful to note that unicode values < 0x80 translate directly a characters ASCII value. THis is used in the example below
Example 3-11. Interpreting Key Event Information
#include "SDL.h"
+
+ /* Function Prototypes */
+ void PrintKeyInfo( SDL_KeyboardEvent *key );
+ void PrintModifiers( SDLMod mod );
+
+ /* main */
+ int main( int argc, char *argv[] ){
+
+ SDL_Event event;
+ int quit = 0;
+
+ /* Initialise SDL */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0){
+ fprintf( stderr, "Could not initialise SDL: %s\n", SDL_GetError() );
+ exit( -1 );
+ }
+
+ /* Set a video mode */
+ if( !SDL_SetVideoMode( 320, 200, 0, 0 ) ){
+ fprintf( stderr, "Could not set video mode: %s\n", SDL_GetError() );
+ SDL_Quit();
+ exit( -1 );
+ }
+
+ /* Enable Unicode translation */
+ SDL_EnableUNICODE( 1 );
+
+ /* Loop until an SDL_QUIT event is found */
+ while( !quit ){
+
+ /* Poll for events */
+ while( SDL_PollEvent( &event ) ){
+
+ switch( event.type ){
+ /* Keyboard event */
+ /* Pass the event data onto PrintKeyInfo() */
+ case SDL_KEYDOWN:
+ case SDL_KEYUP:
+ PrintKeyInfo( &event.key );
+ break;
+
+ /* SDL_QUIT event (window close) */
+ case SDL_QUIT:
+ quit = 1;
+ break;
+
+ default:
+ break;
+ }
+
+ }
+
+ }
+
+ /* Clean up */
+ SDL_Quit();
+ exit( 0 );
+ }
+
+ /* Print all information about a key event */
+ void PrintKeyInfo( SDL_KeyboardEvent *key ){
+ /* Is it a release or a press? */
+ if( key->type == SDL_KEYUP )
+ printf( "Release:- " );
+ else
+ printf( "Press:- " );
+
+ /* Print the hardware scancode first */
+ printf( "Scancode: 0x%02X", key->keysym.scancode );
+ /* Print the name of the key */
+ printf( ", Name: %s", SDL_GetKeyName( key->keysym.sym ) );
+ /* We want to print the unicode info, but we need to make */
+ /* sure its a press event first (remember, release events */
+ /* don't have unicode info */
+ if( key->type == SDL_KEYDOWN ){
+ /* If the Unicode value is less than 0x80 then the */
+ /* unicode value can be used to get a printable */
+ /* representation of the key, using (char)unicode. */
+ printf(", Unicode: " );
+ if( key->keysym.unicode < 0x80 && key->keysym.unicode > 0 ){
+ printf( "%c (0x%04X)", (char)key->keysym.unicode,
+ key->keysym.unicode );
+ }
+ else{
+ printf( "? (0x%04X)", key->keysym.unicode );
+ }
+ }
+ printf( "\n" );
+ /* Print modifier info */
+ PrintModifiers( key->keysym.mod );
+ }
+
+ /* Print modifier info */
+ void PrintModifiers( SDLMod mod ){
+ printf( "Modifers: " );
+
+ /* If there are none then say so and return */
+ if( mod == KMOD_NONE ){
+ printf( "None\n" );
+ return;
+ }
+
+ /* Check for the presence of each SDLMod value */
+ /* This looks messy, but there really isn't */
+ /* a clearer way. */
+ if( mod & KMOD_NUM ) printf( "NUMLOCK " );
+ if( mod & KMOD_CAPS ) printf( "CAPSLOCK " );
+ if( mod & KMOD_LCTRL ) printf( "LCTRL " );
+ if( mod & KMOD_RCTRL ) printf( "RCTRL " );
+ if( mod & KMOD_RSHIFT ) printf( "RSHIFT " );
+ if( mod & KMOD_LSHIFT ) printf( "LSHIFT " );
+ if( mod & KMOD_RALT ) printf( "RALT " );
+ if( mod & KMOD_LALT ) printf( "LALT " );
+ if( mod & KMOD_CTRL ) printf( "CTRL " );
+ if( mod & KMOD_SHIFT ) printf( "SHIFT " );
+ if( mod & KMOD_ALT ) printf( "ALT " );
+ printf( "\n" );
+ }
Game-type Input
I have found that people using keyboard events for games and other interactive applications don't always understand one fundemental point.
Keyboard events only take place when a keys state changes from being unpressed to pressed, and vice versa.
Imagine you have an image of an alien that you wish to move around using the cursor keys: when you pressed the left arrow key you want him to slide over to the left, and when you press the down key you want him to slide down the screen. Examine the following code; it highlights an error that many people have made.
+
/* Alien screen coordinates */
+ int alien_x=0, alien_y=0;
+ .
+ .
+ /* Initialise SDL and video modes and all that */
+ .
+ /* Main game loop */
+ /* Check for events */
+ while( SDL_PollEvent( &event ) ){
+ switch( event.type ){
+ /* Look for a keypress */
+ case SDL_KEYDOWN:
+ /* Check the SDLKey values and move change the coords */
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ alien_x -= 1;
+ break;
+ case SDLK_RIGHT:
+ alien_x += 1;
+ break;
+ case SDLK_UP:
+ alien_y -= 1;
+ break;
+ case SDLK_DOWN:
+ alien_y += 1;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ .
+ .
+At first glance you may think this is a perfectly reasonable piece of code for the task, but it isn't. Like I said keyboard events only occur when a key changes state, so the user would have to press and release the left cursor key 100 times to move the alien 100 pixels to the left.
To get around this problem we must not use the events to change the position of the alien, we use the events to set flags which are then used in a seperate section of code to move the alien. Something like this:
Example 3-12. Proper Game Movement
/* Alien screen coordinates */
+ int alien_x=0, alien_y=0;
+ int alien_xvel=0, alien_yvel=0;
+ .
+ .
+ /* Initialise SDL and video modes and all that */
+ .
+ /* Main game loop */
+ /* Check for events */
+ while( SDL_PollEvent( &event ) ){
+ switch( event.type ){
+ /* Look for a keypress */
+ case SDL_KEYDOWN:
+ /* Check the SDLKey values and move change the coords */
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ alien_xvel = -1;
+ break;
+ case SDLK_RIGHT:
+ alien_xvel = 1;
+ break;
+ case SDLK_UP:
+ alien_yvel = -1;
+ break;
+ case SDLK_DOWN:
+ alien_yvel = 1;
+ break;
+ default:
+ break;
+ }
+ break;
+ /* We must also use the SDL_KEYUP events to zero the x */
+ /* and y velocity variables. But we must also be */
+ /* careful not to zero the velocities when we shouldn't*/
+ case SDL_KEYUP:
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ /* We check to make sure the alien is moving */
+ /* to the left. If it is then we zero the */
+ /* velocity. If the alien is moving to the */
+ /* right then the right key is still press */
+ /* so we don't tocuh the velocity */
+ if( alien_xvel < 0 )
+ alien_xvel = 0;
+ break;
+ case SDLK_RIGHT:
+ if( alien_xvel > 0 )
+ alien_xvel = 0;
+ break;
+ case SDLK_UP:
+ if( alien_yvel < 0 )
+ alien_yvel = 0;
+ break;
+ case SDLK_DOWN:
+ if( alien_yvel > 0 )
+ alien_yvel = 0;
+ break;
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ .
+ .
+ /* Update the alien position */
+ alien_x += alien_xvel;
+ alien_y += alien_yvel;
As can be seen, we use two extra variables, alien_xvel and alien_yvel, which represent the motion of the ship, it is these variables that we update when we detect keypresses and releases.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidepreface.html b/lib/sdl/msvc/docs/html/guidepreface.html
new file mode 100644
index 0000000000000000000000000000000000000000..9986fc6b75392c35a7975476c1dfa10f75a3ec02
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidepreface.html
@@ -0,0 +1,178 @@
+Preface
The SDL library is designed to make it easy to write games that run on Linux, *BSD, MacOS, Win32 and BeOS using the various native high-performance media interfaces, (for video, audio, etc) and presenting a single source-code level API to your application. SDL is a fairly low level API, but using it, completely portable applications can be written with a great deal of flexibility.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidethebasics.html b/lib/sdl/msvc/docs/html/guidethebasics.html
new file mode 100644
index 0000000000000000000000000000000000000000..4f32363f38a08821678f115e7c5e7a6c10ea92b9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidethebasics.html
@@ -0,0 +1,173 @@
+The Basics
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidetimeexamples.html b/lib/sdl/msvc/docs/html/guidetimeexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..42b5019ebf0443e3f91e5f4475eb6d2589031b72
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidetimeexamples.html
@@ -0,0 +1,183 @@
+Time Examples
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidevideo.html b/lib/sdl/msvc/docs/html/guidevideo.html
new file mode 100644
index 0000000000000000000000000000000000000000..85da77d1fd162c4f420f1f41b2f98ad0577e0740
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidevideo.html
@@ -0,0 +1,463 @@
+Graphics and Video
Video is probably the most common thing that SDL is used for, and
+so it has the most complete subsystem. Here are a few
+examples to demonstrate the basics.
Initializing the Video Display
This is what almost all SDL programs have to do in one way or
+another.
Example 2-1. Initializing the Video Display
SDL_Surface *screen;
+
+ /* Initialize the SDL library */
+ if( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
+ fprintf(stderr,
+ "Couldn't initialize SDL: %s\n", SDL_GetError());
+ exit(1);
+ }
+
+ /* Clean up on exit */
+ atexit(SDL_Quit);
+
+ /*
+ * Initialize the display in a 640x480 8-bit palettized mode,
+ * requesting a software surface
+ */
+ screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE);
+ if ( screen == NULL ) {
+ fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
+ SDL_GetError());
+ exit(1);
+ }
Initializing the Best Video Mode
If you have a preference for a certain pixel depth but will accept any
+other, use SDL_SetVideoMode with SDL_ANYFORMAT as below. You can also
+use SDL_VideoModeOK() to find the native video mode that is closest to
+the mode you request.
Example 2-2. Initializing the Best Video Mode
/* Have a preference for 8-bit, but accept any depth */
+ screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE|SDL_ANYFORMAT);
+ if ( screen == NULL ) {
+ fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
+ SDL_GetError());
+ exit(1);
+ }
+ printf("Set 640x480 at %d bits-per-pixel mode\n",
+ screen->format->BitsPerPixel);
Loading and Displaying a BMP File
The following function loads and displays a BMP file given as
+argument, once SDL is initialised and a video mode has been set.
Example 2-3. Loading and Displaying a BMP File
void display_bmp(char *file_name)
+{
+ SDL_Surface *image;
+
+ /* Load the BMP file into a surface */
+ image = SDL_LoadBMP(file_name);
+ if (image == NULL) {
+ fprintf(stderr, "Couldn't load %s: %s\n", file_name, SDL_GetError());
+ return;
+ }
+
+ /*
+ * Palettized screen modes will have a default palette (a standard
+ * 8*8*4 colour cube), but if the image is palettized as well we can
+ * use that palette for a nicer colour matching
+ */
+ if (image->format->palette && screen->format->palette) {
+ SDL_SetColors(screen, image->format->palette->colors, 0,
+ image->format->palette->ncolors);
+ }
+
+ /* Blit onto the screen surface */
+ if(SDL_BlitSurface(image, NULL, screen, NULL) < 0)
+ fprintf(stderr, "BlitSurface error: %s\n", SDL_GetError());
+
+ SDL_UpdateRect(screen, 0, 0, image->w, image->h);
+
+ /* Free the allocated BMP surface */
+ SDL_FreeSurface(image);
+}
Drawing Directly to the Display
The following two functions can be used to get and set single
+pixels of a surface. They are carefully written to work with any depth
+currently supported by SDL. Remember to lock the surface before
+calling them, and to unlock it before calling any other SDL
+functions.
To convert between pixel values and their red, green, blue
+components, use SDL_GetRGB() and SDL_MapRGB().
Example 2-4. getpixel()
/*
+ * Return the pixel value at (x, y)
+ * NOTE: The surface must be locked before calling this!
+ */
+Uint32 getpixel(SDL_Surface *surface, int x, int y)
+{
+ int bpp = surface->format->BytesPerPixel;
+ /* Here p is the address to the pixel we want to retrieve */
+ Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+ switch(bpp) {
+ case 1:
+ return *p;
+
+ case 2:
+ return *(Uint16 *)p;
+
+ case 3:
+ if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+ return p[0] << 16 | p[1] << 8 | p[2];
+ else
+ return p[0] | p[1] << 8 | p[2] << 16;
+
+ case 4:
+ return *(Uint32 *)p;
+
+ default:
+ return 0; /* shouldn't happen, but avoids warnings */
+ }
+}
Example 2-5. putpixel()
/*
+ * Set the pixel at (x, y) to the given value
+ * NOTE: The surface must be locked before calling this!
+ */
+void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+{
+ int bpp = surface->format->BytesPerPixel;
+ /* Here p is the address to the pixel we want to set */
+ Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+ switch(bpp) {
+ case 1:
+ *p = pixel;
+ break;
+
+ case 2:
+ *(Uint16 *)p = pixel;
+ break;
+
+ case 3:
+ if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+ p[0] = (pixel >> 16) & 0xff;
+ p[1] = (pixel >> 8) & 0xff;
+ p[2] = pixel & 0xff;
+ } else {
+ p[0] = pixel & 0xff;
+ p[1] = (pixel >> 8) & 0xff;
+ p[2] = (pixel >> 16) & 0xff;
+ }
+ break;
+
+ case 4:
+ *(Uint32 *)p = pixel;
+ break;
+ }
+}
The following code uses the putpixel() function above to set a
+yellow pixel in the middle of the screen.
Example 2-6. Using putpixel()
/* Code to set a yellow pixel at the center of the screen */
+
+ int x, y;
+ Uint32 yellow;
+
+ /* Map the color yellow to this display (R=0xff, G=0xFF, B=0x00)
+ Note: If the display is palettized, you must set the palette first.
+ */
+ yellow = SDL_MapRGB(screen->format, 0xff, 0xff, 0x00);
+
+ x = screen->w / 2;
+ y = screen->h / 2;
+
+ /* Lock the screen for direct access to the pixels */
+ if ( SDL_MUSTLOCK(screen) ) {
+ if ( SDL_LockSurface(screen) < 0 ) {
+ fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
+ return;
+ }
+ }
+
+ putpixel(screen, x, y, yellow);
+
+ if ( SDL_MUSTLOCK(screen) ) {
+ SDL_UnlockSurface(screen);
+ }
+ /* Update just the part of the display that we've changed */
+ SDL_UpdateRect(screen, x, y, 1, 1);
+
+ return;
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidevideoopengl.html b/lib/sdl/msvc/docs/html/guidevideoopengl.html
new file mode 100644
index 0000000000000000000000000000000000000000..0abd5671861a5ac85167e532550c7ae60b43a0fc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidevideoopengl.html
@@ -0,0 +1,730 @@
+Using OpenGL With SDL
SDL has the ability to create and use OpenGL contexts on several platforms(Linux/X11, Win32, BeOS, MacOS Classic/Toolbox, Mac OS X, FreeBSD/X11 and Solaris/X11). This allows you to use SDL's audio, event handling, threads and times in your OpenGL applications (a function often performed by GLUT).
Initialisation
Initialising SDL to use OpenGL is not very different to initialising SDL normally. There are three differences; you must pass SDL_OPENGL to SDL_SetVideoMode, you must specify several GL attributes (depth buffer size, framebuffer sizes) using SDL_GL_SetAttribute and finally, if you wish to use double buffering you must specify it as a GL attribute, not by passing the SDL_DOUBLEBUF flag to SDL_SetVideoMode.
Example 2-7. Initializing SDL with OpenGL
/* Information about the current video settings. */
+ const SDL_VideoInfo* info = NULL;
+ /* Dimensions of our window. */
+ int width = 0;
+ int height = 0;
+ /* Color depth in bits of our window. */
+ int bpp = 0;
+ /* Flags we will pass into SDL_SetVideoMode. */
+ int flags = 0;
+
+ /* First, initialize SDL's video subsystem. */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+ /* Failed, exit. */
+ fprintf( stderr, "Video initialization failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /* Let's get some video information. */
+ info = SDL_GetVideoInfo( );
+
+ if( !info ) {
+ /* This should probably never happen. */
+ fprintf( stderr, "Video query failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * Set our width/height to 640/480 (you would
+ * of course let the user decide this in a normal
+ * app). We get the bpp we will request from
+ * the display. On X11, VidMode can't change
+ * resolution, so this is probably being overly
+ * safe. Under Win32, ChangeDisplaySettings
+ * can change the bpp.
+ */
+ width = 640;
+ height = 480;
+ bpp = info->vfmt->BitsPerPixel;
+
+ /*
+ * Now, we want to setup our requested
+ * window attributes for our OpenGL window.
+ * We want *at least* 5 bits of red, green
+ * and blue. We also want at least a 16-bit
+ * depth buffer.
+ *
+ * The last thing we do is request a double
+ * buffered window. '1' turns on double
+ * buffering, '0' turns it off.
+ *
+ * Note that we do not use SDL_DOUBLEBUF in
+ * the flags to SDL_SetVideoMode. That does
+ * not affect the GL attribute state, only
+ * the standard 2D blitting setup.
+ */
+ SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+ /*
+ * We want to request that SDL provide us
+ * with an OpenGL window, in a fullscreen
+ * video mode.
+ *
+ * EXERCISE:
+ * Make starting windowed an option, and
+ * handle the resize events properly with
+ * glViewport.
+ */
+ flags = SDL_OPENGL | SDL_FULLSCREEN;
+
+ /*
+ * Set the video mode
+ */
+ if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
+ /*
+ * This could happen for a variety of reasons,
+ * including DISPLAY not being set, the specified
+ * resolution not being available, etc.
+ */
+ fprintf( stderr, "Video mode set failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
Drawing
Apart from initialisation, using OpenGL within SDL is the same as using OpenGL
+with any other API, e.g. GLUT. You still use all the same function calls and
+data types. However if you are using a double-buffered display, then you must
+use
+SDL_GL_SwapBuffers()
+to swap the buffers and update the display. To request double-buffering
+with OpenGL, use
+SDL_GL_SetAttribute
+with SDL_GL_DOUBLEBUFFER, and use
+SDL_GL_GetAttribute
+to see if you actually got it.
A full example code listing is now presented below.
Example 2-8. SDL and OpenGL
/*
+ * SDL OpenGL Tutorial.
+ * (c) Michael Vance, 2000
+ * briareos@lokigames.com
+ *
+ * Distributed under terms of the LGPL.
+ */
+
+#include <SDL/SDL.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static GLboolean should_rotate = GL_TRUE;
+
+static void quit_tutorial( int code )
+{
+ /*
+ * Quit SDL so we can release the fullscreen
+ * mode and restore the previous video settings,
+ * etc.
+ */
+ SDL_Quit( );
+
+ /* Exit program. */
+ exit( code );
+}
+
+static void handle_key_down( SDL_keysym* keysym )
+{
+
+ /*
+ * We're only interested if 'Esc' has
+ * been presssed.
+ *
+ * EXERCISE:
+ * Handle the arrow keys and have that change the
+ * viewing position/angle.
+ */
+ switch( keysym->sym ) {
+ case SDLK_ESCAPE:
+ quit_tutorial( 0 );
+ break;
+ case SDLK_SPACE:
+ should_rotate = !should_rotate;
+ break;
+ default:
+ break;
+ }
+
+}
+
+static void process_events( void )
+{
+ /* Our SDL event placeholder. */
+ SDL_Event event;
+
+ /* Grab all the events off the queue. */
+ while( SDL_PollEvent( &event ) ) {
+
+ switch( event.type ) {
+ case SDL_KEYDOWN:
+ /* Handle key presses. */
+ handle_key_down( &event.key.keysym );
+ break;
+ case SDL_QUIT:
+ /* Handle quit requests (like Ctrl-c). */
+ quit_tutorial( 0 );
+ break;
+ }
+
+ }
+
+}
+
+static void draw_screen( void )
+{
+ /* Our angle of rotation. */
+ static float angle = 0.0f;
+
+ /*
+ * EXERCISE:
+ * Replace this awful mess with vertex
+ * arrays and a call to glDrawElements.
+ *
+ * EXERCISE:
+ * After completing the above, change
+ * it to use compiled vertex arrays.
+ *
+ * EXERCISE:
+ * Verify my windings are correct here ;).
+ */
+ static GLfloat v0[] = { -1.0f, -1.0f, 1.0f };
+ static GLfloat v1[] = { 1.0f, -1.0f, 1.0f };
+ static GLfloat v2[] = { 1.0f, 1.0f, 1.0f };
+ static GLfloat v3[] = { -1.0f, 1.0f, 1.0f };
+ static GLfloat v4[] = { -1.0f, -1.0f, -1.0f };
+ static GLfloat v5[] = { 1.0f, -1.0f, -1.0f };
+ static GLfloat v6[] = { 1.0f, 1.0f, -1.0f };
+ static GLfloat v7[] = { -1.0f, 1.0f, -1.0f };
+ static GLubyte red[] = { 255, 0, 0, 255 };
+ static GLubyte green[] = { 0, 255, 0, 255 };
+ static GLubyte blue[] = { 0, 0, 255, 255 };
+ static GLubyte white[] = { 255, 255, 255, 255 };
+ static GLubyte yellow[] = { 0, 255, 255, 255 };
+ static GLubyte black[] = { 0, 0, 0, 255 };
+ static GLubyte orange[] = { 255, 255, 0, 255 };
+ static GLubyte purple[] = { 255, 0, 255, 0 };
+
+ /* Clear the color and depth buffers. */
+ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+ /* We don't want to modify the projection matrix. */
+ glMatrixMode( GL_MODELVIEW );
+ glLoadIdentity( );
+
+ /* Move down the z-axis. */
+ glTranslatef( 0.0, 0.0, -5.0 );
+
+ /* Rotate. */
+ glRotatef( angle, 0.0, 1.0, 0.0 );
+
+ if( should_rotate ) {
+
+ if( ++angle > 360.0f ) {
+ angle = 0.0f;
+ }
+
+ }
+
+ /* Send our triangle data to the pipeline. */
+ glBegin( GL_TRIANGLES );
+
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+
+ glEnd( );
+
+ /*
+ * EXERCISE:
+ * Draw text telling the user that 'Spc'
+ * pauses the rotation and 'Esc' quits.
+ * Do it using vetors and textured quads.
+ */
+
+ /*
+ * Swap the buffers. This this tells the driver to
+ * render the next frame from the contents of the
+ * back-buffer, and to set all rendering operations
+ * to occur on what was the front-buffer.
+ *
+ * Double buffering prevents nasty visual tearing
+ * from the application drawing on areas of the
+ * screen that are being updated at the same time.
+ */
+ SDL_GL_SwapBuffers( );
+}
+
+static void setup_opengl( int width, int height )
+{
+ float ratio = (float) width / (float) height;
+
+ /* Our shading model--Gouraud (smooth). */
+ glShadeModel( GL_SMOOTH );
+
+ /* Culling. */
+ glCullFace( GL_BACK );
+ glFrontFace( GL_CCW );
+ glEnable( GL_CULL_FACE );
+
+ /* Set the clear color. */
+ glClearColor( 0, 0, 0, 0 );
+
+ /* Setup our viewport. */
+ glViewport( 0, 0, width, height );
+
+ /*
+ * Change to the projection matrix and set
+ * our viewing volume.
+ */
+ glMatrixMode( GL_PROJECTION );
+ glLoadIdentity( );
+ /*
+ * EXERCISE:
+ * Replace this with a call to glFrustum.
+ */
+ gluPerspective( 60.0, ratio, 1.0, 1024.0 );
+}
+
+int main( int argc, char* argv[] )
+{
+ /* Information about the current video settings. */
+ const SDL_VideoInfo* info = NULL;
+ /* Dimensions of our window. */
+ int width = 0;
+ int height = 0;
+ /* Color depth in bits of our window. */
+ int bpp = 0;
+ /* Flags we will pass into SDL_SetVideoMode. */
+ int flags = 0;
+
+ /* First, initialize SDL's video subsystem. */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+ /* Failed, exit. */
+ fprintf( stderr, "Video initialization failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /* Let's get some video information. */
+ info = SDL_GetVideoInfo( );
+
+ if( !info ) {
+ /* This should probably never happen. */
+ fprintf( stderr, "Video query failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * Set our width/height to 640/480 (you would
+ * of course let the user decide this in a normal
+ * app). We get the bpp we will request from
+ * the display. On X11, VidMode can't change
+ * resolution, so this is probably being overly
+ * safe. Under Win32, ChangeDisplaySettings
+ * can change the bpp.
+ */
+ width = 640;
+ height = 480;
+ bpp = info->vfmt->BitsPerPixel;
+
+ /*
+ * Now, we want to setup our requested
+ * window attributes for our OpenGL window.
+ * We want *at least* 5 bits of red, green
+ * and blue. We also want at least a 16-bit
+ * depth buffer.
+ *
+ * The last thing we do is request a double
+ * buffered window. '1' turns on double
+ * buffering, '0' turns it off.
+ *
+ * Note that we do not use SDL_DOUBLEBUF in
+ * the flags to SDL_SetVideoMode. That does
+ * not affect the GL attribute state, only
+ * the standard 2D blitting setup.
+ */
+ SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+ /*
+ * We want to request that SDL provide us
+ * with an OpenGL window, in a fullscreen
+ * video mode.
+ *
+ * EXERCISE:
+ * Make starting windowed an option, and
+ * handle the resize events properly with
+ * glViewport.
+ */
+ flags = SDL_OPENGL | SDL_FULLSCREEN;
+
+ /*
+ * Set the video mode
+ */
+ if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
+ /*
+ * This could happen for a variety of reasons,
+ * including DISPLAY not being set, the specified
+ * resolution not being available, etc.
+ */
+ fprintf( stderr, "Video mode set failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * At this point, we should have a properly setup
+ * double-buffered window for use with OpenGL.
+ */
+ setup_opengl( width, height );
+
+ /*
+ * Now we want to begin our normal app process--
+ * an event loop with a lot of redrawing.
+ */
+ while( 1 ) {
+ /* Process incoming events. */
+ process_events( );
+ /* Draw the screen. */
+ draw_screen( );
+ }
+
+ /*
+ * EXERCISE:
+ * Record timings using SDL_GetTicks() and
+ * and print out frames per second at program
+ * end.
+ */
+
+ /* Never reached. */
+ return 0;
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/index.html b/lib/sdl/msvc/docs/html/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f86ff191d3208669e4d33384164ccb09d0a73cc9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/index.html
@@ -0,0 +1,1156 @@
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/joystick.html b/lib/sdl/msvc/docs/html/joystick.html
new file mode 100644
index 0000000000000000000000000000000000000000..abdb28c1979d9166801529ae6ef1cc1f95daac15
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/joystick.html
@@ -0,0 +1,296 @@
+Joystick
Joysticks, and other similar input devices, have a very strong role in game playing and SDL provides comprehensive support for them. Axes, Buttons, POV Hats and trackballs are all supported.
Joystick support is initialized by passed the SDL_INIT_JOYSTICK flag to SDL_Init. Once initilized joysticks must be opened using SDL_JoystickOpen.
While using the functions describe in this secton may seem like the best way to access and read from joysticks, in most cases they aren't. Ideally joysticks should be read using the event system. To enable this, you must set the joystick event processing state with SDL_JoystickEventState. Joysticks must be opened before they can be used of course.
Note: If you are not handling the joystick via the event queue then you must explicitly request a joystick update by calling SDL_JoystickUpdate.
Note: Force Feedback is not yet support. Sam (slouken@libsdl.org) is soliciting suggestions from people with force-feedback experience on the best wat to desgin the API.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/reference.html b/lib/sdl/msvc/docs/html/reference.html
new file mode 100644
index 0000000000000000000000000000000000000000..e7707a7504f9b348279fa1e492c1bac8421386be
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/reference.html
@@ -0,0 +1,194 @@
+SDL Reference
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlactiveevent.html b/lib/sdl/msvc/docs/html/sdlactiveevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d3f2821e728de69d2219c945cdd3ed61687b3360
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlactiveevent.html
@@ -0,0 +1,335 @@
+SDL_ActiveEvent
SDL_APPMOUSEFOCUS if mouse focus was gained or lost, SDL_APPINPUTFOCUS if input focus was gained or lost, or SDL_APPACTIVE if the application was iconified (gain=0) or restored(gain=1).
Description
SDL_ActiveEvent is a member of the SDL_Event union and is used when an event of type SDL_ACTIVEEVENT is reported.
When the mouse leaves or enters the window area a SDL_APPMOUSEFOCUS type activation event occurs, if the mouse entered the window then gain will be 1, otherwise gain will be 0. A SDL_APPINPUTFOCUS type activation event occurs when the application loses or gains keyboard focus. This usually occurs when another application is made active. Finally, a SDL_APPACTIVE type event occurs when the application is either minimised/iconified (gain=0) or restored.
Note: This event does not occur when an application window is first created.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdladdtimer.html b/lib/sdl/msvc/docs/html/sdladdtimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..81c49e56d655d3b33bae4a1bda9510656cc25de3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdladdtimer.html
@@ -0,0 +1,296 @@
+SDL_AddTimer
/* type definition for the "new" timer callback function */
+typedef Uint32 (*SDL_NewTimerCallback)(Uint32 interval, void *param);
Description
Adds a callback function to be run after the specified number of
+milliseconds has elapsed. The callback function is passed the current
+timer interval and the user supplied parameter from the
+SDL_AddTimer call and returns the next timer
+interval. If the returned value from the callback is the same as the one
+passed in, the periodic alarm continues, otherwise a new alarm is
+scheduled.
To cancel a currently running timer call
+SDL_RemoveTimer with the
+timer ID returned from
+SDL_AddTimer.
The timer callback function may run in a different thread than your
+main program, and so shouldn't call any functions from within itself.
+You may always call SDL_PushEvent, however.
The granularity of the timer is platform-dependent, but you should count
+on it being at least 10 ms as this is the most common number.
+This means that if
+you request a 16 ms timer, your callback will run approximately 20 ms
+later on an unloaded system. If you wanted to set a flag signaling
+a frame update at 30 frames per second (every 33 ms), you might set a
+timer for 30 ms (see example below).
+
+If you use this function, you need to pass SDL_INIT_TIMER
+to SDL_Init.
Return Value
Returns an ID value for the added timer or
+NULL if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlaudiocvt.html b/lib/sdl/msvc/docs/html/sdlaudiocvt.html
new file mode 100644
index 0000000000000000000000000000000000000000..ff39209080e8a8e4de91fdfaa490189516e26675
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlaudiocvt.html
@@ -0,0 +1,556 @@
+SDL_AudioCVT
typedef struct{
+ int needed;
+ Uint16 src_format;
+ Uint16 dest_format;
+ double rate_incr;
+ Uint8 *buf;
+ int len;
+ int len_cvt;
+ int len_mult;
+ double len_ratio;
+ void (*filters[10])(struct SDL_AudioCVT *cvt, Uint16 format);
+ int filter_index;
+} SDL_AudioCVT;
Structure Data
needed
Set to one if the conversion is possible
src_format
Audio format of the source
dest_format
Audio format of the destination
rate_incr
Rate conversion increment
buf
Audio buffer
len
Length of the original audio buffer in bytes
len_cvt
Length of converted audio buffer in bytes (calculated)
len_mult
buf must be len*len_mult bytes in size(calculated)
len_ratio
Final audio size is len*len_ratio
filters[10](..)
Pointers to functions needed for this conversion
filter_index
Current conversion function
Description
The SDL_AudioCVT is used to convert audio data between different formats. A SDL_AudioCVT structure is created with the SDL_BuildAudioCVT function, while the actual conversion is done by the SDL_ConvertAudio function.
Many of the fields in the SDL_AudioCVT structure should be considered private and their function will not be discussed here.
Uint8 *buf
This points to the audio data that will be used in the conversion. It is both the source and the destination, which means the converted audio data overwrites the original data. It also means that the converted data may be larger than the original data (if you were converting from 8-bit to 16-bit, for instance), so you must ensure buf is large enough. See below.
intlen
This is the length of the original audio data in bytes.
intlen_mult
As explained above, the audio buffer needs to be big enough to store the converted data, which may be bigger than the original audio data. The length of buf should be len*len_mult.
doublelen_ratio
When you have finished converting your audio data, you need to know how much of your audio buffer is valid. len*len_ratio is the size of the converted audio data in bytes. This is very similar to len_mult, however when the convert audio data is shorter than the original len_mult would be 1. len_ratio, on the other hand, would be a fractional number between 0 and 1.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlaudiospec.html b/lib/sdl/msvc/docs/html/sdlaudiospec.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc6fa75035d89162989141d22a06148dbcfc5e97
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlaudiospec.html
@@ -0,0 +1,589 @@
+SDL_AudioSpec
Pointer the user data which is passed to the callback function
Description
The SDL_AudioSpec structure is used to describe the format of some audio data. This structure is used by SDL_OpenAudio and SDL_LoadWAV. While all fields are used by SDL_OpenAudio only freq, format, samples and channels are used by SDL_LoadWAV. We will detail these common members here.
freq
The number of samples sent to the sound device every second. Common values are 11025, 22050 and 44100. The higher the better.
format
Specifies the size and type of each sample element
+
AUDIO_U8
Unsigned 8-bit samples
AUDIO_S8
Signed 8-bit samples
AUDIO_U16 or AUDIO_U16LSB
Unsigned 16-bit little-endian samples
AUDIO_S16 or AUDIO_S16LSB
Signed 16-bit little-endian samples
AUDIO_U16MSB
Unsigned 16-bit big-endian samples
AUDIO_S16MSB
Signed 16-bit big-endian samples
AUDIO_U16SYS
Either AUDIO_U16LSB or AUDIO_U16MSB depending on you systems endianness
AUDIO_S16SYS
Either AUDIO_S16LSB or AUDIO_S16MSB depending on you systems endianness
channels
The number of seperate sound channels. 1 is mono (single channel), 2 is stereo (dual channel).
samples
When used with SDL_OpenAudio this refers to the size of the audio buffer in samples. A sample a chunk of audio data of the size specified in format mulitplied by the number of channels. When the SDL_AudioSpec is used with SDL_LoadWAVsamples is set to 4096.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlblitsurface.html b/lib/sdl/msvc/docs/html/sdlblitsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..3123ff5dde119aa773125906a13c19957b7a19f6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlblitsurface.html
@@ -0,0 +1,339 @@
+SDL_BlitSurface
SDL_BlitSurface -- This performs a fast blit from the source surface to the destination surface.
Synopsis
#include "SDL.h"
int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
Description
This performs a fast blit from the source surface to the destination surface.
The width and height in srcrect determine the
+size of the copied rectangle. Only the position is used in the
+dstrect (the width and height are ignored).
If srcrect is NULL, the
+entire surface is copied. If dstrect is
+NULL, then the destination position (upper left
+corner) is (0, 0).
The final blit rectangle is saved in
+dstrect after all clipping is performed
+(srcrect is not modified).
The blit function should not be called on a locked surface.
The results of blitting operations vary greatly depending on whether SDL_SRCAPLHA is set or not. See SDL_SetAlpha for an explaination of how this affects your results. Colorkeying and alpha attributes also interact with surface blitting, as the following pseudo-code should hopefully explain.
+
if (source surface has SDL_SRCALPHA set) {
+ if (source surface has alpha channel (that is, format->Amask != 0))
+ blit using per-pixel alpha, ignoring any colour key
+ else {
+ if (source surface has SDL_SRCCOLORKEY set)
+ blit using the colour key AND the per-surface alpha value
+ else
+ blit using the per-surface alpha value
+ }
+} else {
+ if (source surface has SDL_SRCCOLORKEY set)
+ blit using the colour key
+ else
+ ordinary opaque rectangular blit
+}
Return Value
If the blit is successful, it returns 0,
+otherwise it returns -1.
If either of the surfaces were in video memory, and the blit returns
+-2, the video memory was lost, so it should be
+reloaded with artwork and re-blitted:
+
+This happens under DirectX 5.0 when the system switches away from your
+fullscreen application. Locking the surface will also fail until you
+have access to the video memory again.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html b/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html
new file mode 100644
index 0000000000000000000000000000000000000000..2e8420e8a9ce962189600e17bed60d4479964ee3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html
@@ -0,0 +1,291 @@
+SDL_BuildAudioCVT
SDL_BuildAudioCVT -- Initializes a SDL_AudioCVT structure for conversion
Synopsis
#include "SDL.h"
int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, Uint16 src_format, Uint8 src_channels, int src_rate, Uint16 dst_format, Uint8 dst_channels, int dst_rate);
Description
Before an SDL_AudioCVT structure can be used to convert audio data it must be initialized with source and destination information.
src_format and dst_format are the source and destination format of the conversion. (For information on audio formats see SDL_AudioSpec). src_channels and dst_channels are the number of channels in the source and destination formats. Finally, src_rate and dst_rate are the frequency or samples-per-second of the source and destination formats. Once again, see SDL_AudioSpec.
Return Values
Returns -1 if the filter could not be built or 1 if it could.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcd.html b/lib/sdl/msvc/docs/html/sdlcd.html
new file mode 100644
index 0000000000000000000000000000000000000000..6f8a7cdf60d7b329b8d36d831ab6e0f075886664
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcd.html
@@ -0,0 +1,359 @@
+SDL_CD
An SDL_CD structure is returned by SDL_CDOpen. It represents an opened CDROM device and stores information on the layout of the tracks on the disc.
A frame is the base data unit of a CD. CD_FPS frames is equal to 1 second of music. SDL provides two macros for converting between time and frames: FRAMES_TO_MSF(f, M,S,F) and MSF_TO_FRAMES.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdclose.html b/lib/sdl/msvc/docs/html/sdlcdclose.html
new file mode 100644
index 0000000000000000000000000000000000000000..2a984a8b47495587de7ea2169ba4ef37ab353d65
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdclose.html
@@ -0,0 +1,217 @@
+SDL_CDClose
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdeject.html b/lib/sdl/msvc/docs/html/sdlcdeject.html
new file mode 100644
index 0000000000000000000000000000000000000000..03a3b780b5bae2da1dcb4d23731cfdcc5c7499c1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdeject.html
@@ -0,0 +1,226 @@
+SDL_CDEject
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdname.html b/lib/sdl/msvc/docs/html/sdlcdname.html
new file mode 100644
index 0000000000000000000000000000000000000000..55a18e26e3aef1d981721c53e3eb537119e029e6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdname.html
@@ -0,0 +1,239 @@
+SDL_CDName
SDL_CDName -- Returns a human-readable, system-dependent identifier for the CD-ROM.
Synopsis
#include "SDL.h"
const char *SDL_CDName(int drive);
Description
Returns a human-readable, system-dependent identifier for the CD-ROM. drive is the index of the drive. Drive indices start to 0 and end at SDL_CDNumDrives()-1.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdnumdrives.html b/lib/sdl/msvc/docs/html/sdlcdnumdrives.html
new file mode 100644
index 0000000000000000000000000000000000000000..9816a739bbcd598b0bac166092426119e1b15b93
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdnumdrives.html
@@ -0,0 +1,205 @@
+SDL_CDNumDrives
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdopen.html b/lib/sdl/msvc/docs/html/sdlcdopen.html
new file mode 100644
index 0000000000000000000000000000000000000000..09a6bd9f7840b095c78c769354ed2eae34ee56ca
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdopen.html
@@ -0,0 +1,275 @@
+SDL_CDOpen
Opens a CD-ROM drive for access. It returns a SDL_CD structure on success, or NULL if the drive was invalid or busy. This newly opened CD-ROM becomes the default CD used when other CD functions are passed a NULL CD-ROM handle.
Drives are numbered starting with 0.
+Drive 0 is the system default CD-ROM.
Examples
SDL_CD *cdrom;
+int cur_track;
+int min, sec, frame;
+SDL_Init(SDL_INIT_CDROM);
+atexit(SDL_Quit);
+
+/* Check for CD drives */
+if(!SDL_CDNumDrives()){
+ /* None found */
+ fprintf(stderr, "No CDROM devices available\n");
+ exit(-1);
+}
+
+/* Open the default drive */
+cdrom=SDL_CDOpen(0);
+
+/* Did if open? Check if cdrom is NULL */
+if(!cdrom){
+ fprintf(stderr, "Couldn't open drive: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+/* Print Volume info */
+printf("Name: %s\n", SDL_CDName(0));
+printf("Tracks: %d\n", cdrom->numtracks);
+for(cur_track=0;cur_track < cdrom->numtracks; cur_track++){
+ FRAMES_TO_MSF(cdrom->track[cur_track].length, &min, &sec, &frame);
+ printf("\tTrack %d: Length %d:%d\n", cur_track, min, sec);
+}
+
+SDL_CDClose(cdrom);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdpause.html b/lib/sdl/msvc/docs/html/sdlcdpause.html
new file mode 100644
index 0000000000000000000000000000000000000000..4def8e362e8b8a347c862c88c600bfe44a5217cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdpause.html
@@ -0,0 +1,233 @@
+SDL_CDPause
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdplay.html b/lib/sdl/msvc/docs/html/sdlcdplay.html
new file mode 100644
index 0000000000000000000000000000000000000000..dc6489cc8dc6f1d1249b31e6b0052b9c35104adc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdplay.html
@@ -0,0 +1,243 @@
+SDL_CDPlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdplaytracks.html b/lib/sdl/msvc/docs/html/sdlcdplaytracks.html
new file mode 100644
index 0000000000000000000000000000000000000000..75461819045b61394d9bb9992da82d9391aed512
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdplaytracks.html
@@ -0,0 +1,325 @@
+SDL_CDPlayTracks
int SDL_CDPlayTracks(SDL_CD *cdrom, int start_track, int start_frame, int ntracks, int nframes));
Description
SDL_CDPlayTracks plays the given CD starting at track
+start_track, for ntracks tracks.
start_frame is the frame offset, from the beginning of the start_track, at which to start. nframes is the frame offset, from the beginning of the last track (start_track+ntracks), at which to end playing.
SDL_CDPlayTracks should only be called after calling
+SDL_CDStatus
+to get track information about the CD.
Note: Data tracks are ignored.
Return Value
Returns 0, or -1
+if there was an error.
Examples
/* assuming cdrom is a previously opened device */
+/* Play the entire CD */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
+
+/* Play the first track */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 0, 0, 1, 0);
+
+/* Play first 15 seconds of the 2nd track */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 1, 0, 0, CD_FPS*15);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdresume.html b/lib/sdl/msvc/docs/html/sdlcdresume.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a25ab69b6e3b957302de1df5388934a0f395236
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdresume.html
@@ -0,0 +1,233 @@
+SDL_CDResume
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdstatus.html b/lib/sdl/msvc/docs/html/sdlcdstatus.html
new file mode 100644
index 0000000000000000000000000000000000000000..3ebf9657e654c48be1a2d05647fa5ae979d65f78
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdstatus.html
@@ -0,0 +1,273 @@
+SDL_CDStatus
If the drive has a CD in it, the table of contents of the CD and current
+play position of the CD will be stored in the SDL_CD structure.
The macro CD_INDRIVE is provided for convenience,
+and given a status returns true if there's a disk in the drive.
Note: SDL_CDStatus also updates the SDL_CD structure passed to it.
Example
int playTrack(int track)
+{
+ int playing = 0;
+
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
+ /* clamp to the actual number of tracks on the CD */
+ if (track >= cdrom->numtracks) {
+ track = cdrom->numtracks-1;
+ }
+
+ if ( SDL_CDPlayTracks(cdrom, track, 0, 1, 0) == 0 ) {
+ playing = 1;
+ }
+ }
+ return playing;
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdstop.html b/lib/sdl/msvc/docs/html/sdlcdstop.html
new file mode 100644
index 0000000000000000000000000000000000000000..68f8d81bed55af4f45a0b3553be0b11c149d2524
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdstop.html
@@ -0,0 +1,226 @@
+SDL_CDStop
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdtrack.html b/lib/sdl/msvc/docs/html/sdlcdtrack.html
new file mode 100644
index 0000000000000000000000000000000000000000..bbb04bbd252383d72c2bf17db12072f30bb3eb13
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdtrack.html
@@ -0,0 +1,313 @@
+SDL_CDtrack
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcloseaudio.html b/lib/sdl/msvc/docs/html/sdlcloseaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..599f058e4438c78f78649bed7a87f26f75433be5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcloseaudio.html
@@ -0,0 +1,205 @@
+SDL_CloseAudio
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcolor.html b/lib/sdl/msvc/docs/html/sdlcolor.html
new file mode 100644
index 0000000000000000000000000000000000000000..c8b7d44fc99b169641bc8ae072968ee85de54184
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcolor.html
@@ -0,0 +1,300 @@
+SDL_Color
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondbroadcast.html b/lib/sdl/msvc/docs/html/sdlcondbroadcast.html
new file mode 100644
index 0000000000000000000000000000000000000000..9b0fc83e0f1e42df2962a67e2afee56393eb25df
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondbroadcast.html
@@ -0,0 +1,224 @@
+SDL_CondBroadcast
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondsignal.html b/lib/sdl/msvc/docs/html/sdlcondsignal.html
new file mode 100644
index 0000000000000000000000000000000000000000..24e9175994ec461a93f7856c52371e00161608b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondsignal.html
@@ -0,0 +1,224 @@
+SDL_CondSignal
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondwait.html b/lib/sdl/msvc/docs/html/sdlcondwait.html
new file mode 100644
index 0000000000000000000000000000000000000000..8f15452589e62e3910b8ab131e7ab88586ab3214
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondwait.html
@@ -0,0 +1,231 @@
+SDL_CondWait
Wait on the condition variable cond and unlock the provided mutex. The mutex must the locked before entering this function. Returns 0 when it is signalled, or -1 on an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html b/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html
new file mode 100644
index 0000000000000000000000000000000000000000..deed50bfe21293c06b67f2d8e98f4309e5f622f2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html
@@ -0,0 +1,230 @@
+SDL_CondWaitTimeout
SDL_CondWaitTimeout -- Wait on a condition variable, with timeout
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms);
Description
Wait on the condition variable cond for, at most, ms milliseconds. mut is unlocked so it must be locked when the function is called. Returns SDL_MUTEX_TIMEDOUT if the condition is not signalled in the allotted time, 0 if it was signalled or -1 on an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlconvertaudio.html b/lib/sdl/msvc/docs/html/sdlconvertaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..52f122968a07cb93ecbfad0a8552649648dcf146
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlconvertaudio.html
@@ -0,0 +1,407 @@
+SDL_ConvertAudio
SDL_ConvertAudio -- Convert audio data to a desired audio format.
Synopsis
#include "SDL.h"
int SDL_ConvertAudio(SDL_AudioCVT *cvt);
Description
SDL_ConvertAudio takes one parameter, cvt, which was previously initilized. Initilizing a SDL_AudioCVT is a two step process. First of all, the structure must be passed to SDL_BuildAudioCVT along with source and destination format parameters. Secondly, the cvt->buf and cvt->len fields must be setup. cvt->buf should point to the audio data and cvt->len should be set to the length of the audio data in bytes. Remember, the length of the buffer pointed to by buf show be len*len_mult bytes in length.
Once the SDL_AudioCVTstructure is initilized then we can pass it to SDL_ConvertAudio, which will convert the audio data pointer to by cvt->buf. If SDL_ConvertAudio returned 0 then the conversion was completed successfully, otherwise -1 is returned.
If the conversion completed successfully then the converted audio data can be read from cvt->buf. The amount of valid, converted, audio data in the buffer is equal to cvt->len*cvt->len_ratio.
Examples
/* Converting some WAV data to hardware format */
+void my_audio_callback(void *userdata, Uint8 *stream, int len);
+
+SDL_AudioSpec *desired, *obtained;
+SDL_AudioSpec wav_spec;
+SDL_AudioCVT wav_cvt;
+Uint32 wav_len;
+Uint8 *wav_buf;
+int ret;
+
+/* Allocated audio specs */
+desired = malloc(sizeof(SDL_AudioSpec));
+obtained = malloc(sizeof(SDL_AudioSpec));
+
+/* Set desired format */
+desired->freq=22050;
+desired->format=AUDIO_S16LSB;
+desired->samples=8192;
+desired->callback=my_audio_callback;
+desired->userdata=NULL;
+
+/* Open the audio device */
+if ( SDL_OpenAudio(desired, obtained) < 0 ){
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+free(desired);
+
+/* Load the test.wav */
+if( SDL_LoadWAV("test.wav", &wav_spec, &wav_buf, &wav_len) == NULL ){
+ fprintf(stderr, "Could not open test.wav: %s\n", SDL_GetError());
+ SDL_CloseAudio();
+ free(obtained);
+ exit(-1);
+}
+
+/* Build AudioCVT */
+ret = SDL_BuildAudioCVT(&wav_cvt,
+ wav_spec.format, wav_spec.channels, wav_spec.freq,
+ obtained->format, obtained->channels, obtained->freq);
+
+/* Check that the convert was built */
+if(ret==-1){
+ fprintf(stderr, "Couldn't build converter!\n");
+ SDL_CloseAudio();
+ free(obtained);
+ SDL_FreeWAV(wav_buf);
+}
+
+/* Setup for conversion */
+wav_cvt.buf = malloc(wav_len * wav_cvt.len_mult);
+wav_cvt.len = wav_len;
+memcpy(wav_cvt.buf, wav_buf, wav_len);
+
+/* We can delete to original WAV data now */
+SDL_FreeWAV(wav_buf);
+
+/* And now we're ready to convert */
+SDL_ConvertAudio(&wav_cvt);
+
+/* do whatever */
+.
+.
+.
+.
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlconvertsurface.html b/lib/sdl/msvc/docs/html/sdlconvertsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..cc21f7833ebd7373ae61766e1e47213ce1d9ebc7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlconvertsurface.html
@@ -0,0 +1,271 @@
+SDL_ConvertSurface
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatecond.html b/lib/sdl/msvc/docs/html/sdlcreatecond.html
new file mode 100644
index 0000000000000000000000000000000000000000..02fcdb2b3e57f43526a7c746682d85219c3f4574
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatecond.html
@@ -0,0 +1,240 @@
+SDL_CreateCond
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatecursor.html b/lib/sdl/msvc/docs/html/sdlcreatecursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..a444165ff096d1ceb44e08318e233cc05d343775
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatecursor.html
@@ -0,0 +1,398 @@
+SDL_CreateCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatemutex.html b/lib/sdl/msvc/docs/html/sdlcreatemutex.html
new file mode 100644
index 0000000000000000000000000000000000000000..53ed48bb20ee6f1db76ec5b0d94f782e837638b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatemutex.html
@@ -0,0 +1,249 @@
+SDL_CreateMutex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html b/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..736ec8f96fff639e2bf0e8e9523c4133f2a0a389
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html
@@ -0,0 +1,458 @@
+SDL_CreateRGBSurface
SDL_CreateRGBSurface -- Create an empty SDL_Surface
Synopsis
#include "SDL.h"
SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
Description
Allocate an empty surface (must be called after SDL_SetVideoMode)
If depth is 8 bits an empty palette is allocated for the surface, otherwise a 'packed-pixel' SDL_PixelFormat is created using the [RGBA]mask's provided (see SDL_PixelFormat). The flags specifies the type of surface that should be created, it is an OR'd combination of the following possible values.
SDL_SWSURFACE
SDL will create the surface in system memory. This improves the performance of pixel level access, however you may not be able to take advantage of some types of hardware blitting.
SDL_HWSURFACE
SDL will attempt to create the surface in video memory. This will allow SDL to take advantage of Video->Video blits (which are often accelerated).
SDL_SRCCOLORKEY
This flag turns on colourkeying for blits from this surface. If
+SDL_HWSURFACE is also specified and colourkeyed blits
+are hardware-accelerated, then SDL will attempt to place the surface in
+video memory.
+Use SDL_SetColorKey
+to set or clear this flag after surface creation.
SDL_SRCALPHA
This flag turns on alpha-blending for blits from this surface. If
+SDL_HWSURFACE is also specified and alpha-blending blits
+are hardware-accelerated, then the surface will be placed in video memory if
+possible.
+Use SDL_SetAlpha to
+set or clear this flag after surface creation.
Note: If an alpha-channel is specified (that is, if Amask is
+nonzero), then the SDL_SRCALPHA flag is automatically
+set. You may remove this flag by calling
+SDL_SetAlpha
+after surface creation.
Return Value
Returns the created surface, or NULL upon error.
Example
/* Create a 32-bit surface with the bytes of each pixel in R,G,B,A order,
+ as expected by OpenGL for textures */
+ SDL_Surface *surface;
+ Uint32 rmask, gmask, bmask, amask;
+
+ /* SDL interprets each pixel as a 32-bit number, so our masks must depend
+ on the endianness (byte order) of the machine */
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ rmask = 0xff000000;
+ gmask = 0x00ff0000;
+ bmask = 0x0000ff00;
+ amask = 0x000000ff;
+#else
+ rmask = 0x000000ff;
+ gmask = 0x0000ff00;
+ bmask = 0x00ff0000;
+ amask = 0xff000000;
+#endif
+
+ surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32,
+ rmask, gmask, bmask, amask);
+ if(surface == NULL) {
+ fprintf(stderr, "CreateRGBSurface failed: %s\n", SDL_GetError());
+ exit(1);
+ }
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html b/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html
new file mode 100644
index 0000000000000000000000000000000000000000..6acfdccae8b4e16f5fa05aecd1dd6af70cb7bcb9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html
@@ -0,0 +1,256 @@
+SDL_CreateRGBSurfaceFrom
SDL_CreateRGBSurfaceFrom -- Create an SDL_Surface from pixel data
Synopsis
#include "SDL.h"
SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
Description
Creates an SDL_Surface from the provided pixel data.
The data stored in pixels is assumed to be of the depth specified in the parameter list. The pixel data is not copied into the SDL_Surface structure so it should not be freed until the surface has been freed with a called to SDL_FreeSurface. pitch is the length of each scanline in bytes.
See SDL_CreateRGBSurface for a more detailed description of the other parameters.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html b/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html
new file mode 100644
index 0000000000000000000000000000000000000000..43dcbf5bff23dc8000afdcabb19fb0fa6bb2674e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html
@@ -0,0 +1,303 @@
+SDL_CreateSemaphore
SDL_CreateSemaphore() creates a new semaphore and
+initializes it with the value initial_value.
+Each locking operation on the semaphore by
+SDL_SemWait,
+SDL_SemTryWait or
+SDL_SemWaitTimeout
+will atomically decrement the semaphore value. The locking operation will be blocked
+if the semaphore value is not positive (greater than zero). Each unlock operation by
+SDL_SemPost
+will atomically increment the semaphore value.
Return Value
Returns a pointer to an initialized semaphore or
+NULL if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatethread.html b/lib/sdl/msvc/docs/html/sdlcreatethread.html
new file mode 100644
index 0000000000000000000000000000000000000000..ca3c2d9201caafb525c6bb3c27e06312c57cf199
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatethread.html
@@ -0,0 +1,223 @@
+SDL_CreateThread
SDL_CreateThread creates a new thread of execution
+that shares all of its parent's global memory, signal handlers,
+file descriptors, etc, and runs the function fn
+passed the void pointer data
+The thread quits when this function returns.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..c24ef6ee2e0a0b4f57744454030602b6aac73bdb
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html
@@ -0,0 +1,256 @@
+SDL_CreateYUVOverlay
SDL_CreateYUVOverlay -- Create a YUV video overlay
Synopsis
#include "SDL.h"
SDL_Overlay *SDL_CreateYUVOverlay(int width, int height, Uint32 format, SDL_Surface *display);
Description
SDL_CreateYUVOverlay creates a YUV overlay of the specified width, height and format (see SDL_Overlay for a list of available formats), for the provided display. A SDL_Overlay structure is returned.
The term 'overlay' is a misnomer since, unless the overlay is created in hardware, the contents for the display surface underneath the area where the overlay is shown will be overwritten when the overlay is displayed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldelay.html b/lib/sdl/msvc/docs/html/sdldelay.html
new file mode 100644
index 0000000000000000000000000000000000000000..a5417fa66f369db4d37a59f9b6c0ac3533dd2d07
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldelay.html
@@ -0,0 +1,231 @@
+SDL_Delay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroycond.html b/lib/sdl/msvc/docs/html/sdldestroycond.html
new file mode 100644
index 0000000000000000000000000000000000000000..ac0804286a91955601c628facea50a0cda21784f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroycond.html
@@ -0,0 +1,206 @@
+SDL_DestroyCond
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroymutex.html b/lib/sdl/msvc/docs/html/sdldestroymutex.html
new file mode 100644
index 0000000000000000000000000000000000000000..949bfc5d5407e3e45e9ea296a8087ad05bee22e1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroymutex.html
@@ -0,0 +1,209 @@
+SDL_DestroyMutex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroysemaphore.html b/lib/sdl/msvc/docs/html/sdldestroysemaphore.html
new file mode 100644
index 0000000000000000000000000000000000000000..d32bdfaf578007f6e6e91ab512a812a60a8a6df8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroysemaphore.html
@@ -0,0 +1,278 @@
+SDL_DestroySemaphore
SDL_DestroySemaphore -- Destroys a semaphore that was created by SDL_CreateSemaphore.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
void SDL_DestroySemaphore(SDL_sem *sem);
Description
SDL_DestroySemaphore destroys the semaphore pointed to
+by sem that was created by
+SDL_CreateSemaphore.
+It is not safe to destroy a semaphore if there are threads currently blocked
+waiting on it.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayformat.html b/lib/sdl/msvc/docs/html/sdldisplayformat.html
new file mode 100644
index 0000000000000000000000000000000000000000..c91adfe50aa890608eeb3fc62781c4a72ede7d81
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayformat.html
@@ -0,0 +1,262 @@
+SDL_DisplayFormat
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
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.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html b/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html
new file mode 100644
index 0000000000000000000000000000000000000000..6e88604d0210f87f5241ae1a1798883fb0267db4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html
@@ -0,0 +1,250 @@
+SDL_DisplayFormatAlpha
This function takes a surface and copies it to a new surface of the
+pixel format and colors of the video framebuffer plus an alpha channel,
+suitable for fast blitting onto the display surface. It calls
+SDL_ConvertSurface
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.
This function can be used to convert a colourkey to an alpha channel,
+if the SDL_SRCCOLORKEY flag is set on the surface.
+The generated surface will then be transparent (alpha=0) where the
+pixels match the colourkey, and opaque (alpha=255) elsewhere.
Return Value
If the conversion fails or runs out of memory, it returns
+NULL
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html b/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..456c9985dfb471f888fe8ca8c4439f1a8946e144
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html
@@ -0,0 +1,246 @@
+SDL_DisplayYUVOverlay
SDL_DisplayYUVOverlay -- Blit the overlay to the display
Synopsis
#include "SDL.h"
int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
Description
Blit the overlay to the surface specified when it was created. The SDL_Rect structure, dstrect, specifies the position and size of the destination. If the dstrect is a larger or smaller than the overlay then the overlay will be scaled, this is optimized for 2x scaling.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html b/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html
new file mode 100644
index 0000000000000000000000000000000000000000..878feb14f33155202131c6eb1cc13354be8b3f77
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html
@@ -0,0 +1,238 @@
+SDL_EnableKeyRepeat
Enables or disables the keyboard repeat rate. delay specifies how long the key must be pressed before it begins repeating, it then repeats at the speed specified by interval. Both delay and interval are expressed in milliseconds.
Setting delay to 0 disables key repeating completely. Good default values are SDL_DEFAULT_REPEAT_DELAY and SDL_DEFAULT_REPEAT_INTERVAL.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenableunicode.html b/lib/sdl/msvc/docs/html/sdlenableunicode.html
new file mode 100644
index 0000000000000000000000000000000000000000..855debbc996035b562e1583c7c68c6b155b086f1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenableunicode.html
@@ -0,0 +1,252 @@
+SDL_EnableUNICODE
To obtain the character codes corresponding to received keyboard events,
+Unicode translation must first be turned on using this function. The
+translation incurs a slight overhead for each keyboard event and is therefore
+disabled by default. For each subsequently received key down event, the
+unicode member of the
+SDL_keysym structure
+will then contain the corresponding character code, or zero for keysyms that do
+not correspond to any character code.
A value of 1 for enable enables Unicode translation;
+0 disables it, and -1 leaves it unchanged (useful for querying the current
+translation mode).
Note that only key press events will be translated, not release events.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenvvars.html b/lib/sdl/msvc/docs/html/sdlenvvars.html
new file mode 100644
index 0000000000000000000000000000000000000000..8999ed1f1f999569b57ae6cc52cdf08d54803e37
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenvvars.html
@@ -0,0 +1,1227 @@
+SDL_envvars
Several environment variables are available to modify the
+behaviour of SDL. Using these variables isn't recommened and the names
+and presence of these variables aren't guaranteed from one release to
+the next. However, they can be very useful for debugging
+purposes.
Video
SDL_FBACCEL
If set to 0, disable hardware acceleration in the linux fbcon driver.
SDL_FBDEV
Frame buffer device to use in the linux fbcon driver, instead of /dev/fb0
SDL_FULLSCREEN_UPDATE
In the ps2gs driver, sets the SDL_ASYNCBLIT flag on the
+display surface.
SDL_VIDEODRIVER
Selectes the video driver for SDL to use. Possible values, in the
+order they are tried if this variable is not set:
x11
dga
(the XFree86 DGA2)
nanox
(Linux)
fbcon
(Linux)
directfb
(Linux)
ps2gs
(Playstation 2)
ggi
vgl
(BSD)
svgalib
(Linux)
aalib
directx
(Win32)
windib
(Win32)
bwindow
(BeOS)
toolbox
(MacOS Classic)
DSp
(MacOS Classic)
Quartz
(Mac OS X)
CGX
(Amiga)
photon
(QNX)
dummy
SDL_VIDEO_CENTERED
If set, tries to center the SDL window when running in X11 windowed
+mode, or using the CyberGrafix driver.
SDL_VIDEO_GL_DRIVER
The openGL driver (shared library) to use for X11. Default is libGL.so.1
SDL_VIDEO_X11_DGAMOUSE
With XFree86, enables use of DGA mouse if set.
SDL_VIDEO_X11_MOUSEACCEL
For X11, sets the mouse acceleration. The value should be a string
+on the form:
"n/d/t"
where n and d are the
+acceleration numerator/denumerators (so mouse movement is accelerated by
+n/d), and
+t is the threshold above which acceleration applies
+(counted as number of pixels the mouse moves at once).
SDL_VIDEO_X11_NODIRECTCOLOR
If set, don't attempt to use DirectColor visuals even if they are
+present. (SDL will use them otherwise for gamma correction).
+This is needed with older X servers when using the XVideo extension.
SDL_VIDEO_X11_VISUALID
ID of an X11 visual to use, overriding SDL's default visual selection
+algorithm. It can be in decimal or in hex (prefixed by 0x).
SDL_VIDEO_YUV_DIRECT
If set, display YUV overlay directly on the video surface if possible,
+instead of on the surface passed to
+SDL_CreateYUVOverlay.
SDL_VIDEO_YUV_HWACCEL
If not set or set to a nonzero value, SDL will attempt to use
+hardware YUV acceleration for video playback.
SDL_WINDOWID
For X11 or Win32, contains the ID number of the window to be used by
+SDL instead of creating its own window. Either in decimal or
+in hex (prefixed by 0x).
Events/Input
SDL_MOUSE_RELATIVE
If set to 0, do not use mouse relative mode in X11. The default is
+to use it if the mouse is hidden and input is grabbed.
SDL_MOUSEDEV
The mouse device to use for the linux fbcon driver. If not set,
+SDL first tries to use GPM in repeater mode, then various other
+devices (/dev/pcaux, /dev/adbmouse, /dev/mouse etc).
SDL_MOUSEDEV_IMPS2
If set, SDL will not try to auto-detect the IMPS/2 protocol of
+a PS/2 mouse but use it right away. For the fbcon and ps2gs drivers.
SDL_MOUSEDRV
For the linux fbcon driver: if set to ELO, use the ELO touchscreen
+controller as a pointer device
SDL_NO_RAWKBD
For the libvga driver: If set, do not attempt to put the keyboard in raw mode.
SDL_NOMOUSE
If set, the linux fbcon driver will not use a mouse at all.
SDL_NO_LOCK_KEYS
Disable CAPS-LOCK and NUM-LOCK suppression of down+up key events,
+suitable for games where the player needs these keys to do more than just toggle.
+A value of 1 will effect both CAPS-LOCK and NUM-LOCK.
+A value of 2 will effect only CAPS-LOCK.
+A value of 3 will effect only NUM-LOCK.
+All other values have no effect.
+
Audio
AUDIODEV
The audio device to use, if SDL_PATH_DSP isn't set.
SDL_AUDIODRIVER
Selects the audio driver for SDL to use. Possible values, in the
+order they are tried if this variable is not set:
openbsd
(OpenBSD)
dsp
(OSS /dev/dsp: Linux, Solaris, BSD etc)
alsa
(Linux)
pulse
(PulseAudio daemon)
audio
(Unix style /dev/audio: SunOS, Solaris etc)
AL
(Irix)
artsc
(ARTS audio daemon)
esd
(esound audio daemon)
nas
(NAS audio daemon)
dma
(OSS /dev/dsp, using DMA)
dsound
(Win32 DirectX)
waveout
(Win32 WaveOut)
baudio
(BeOS)
sndmgr
(MacOS SoundManager)
paud
(AIX)
AHI
(Amiga)
disk
(all; output to file)
SDL_DISKAUDIOFILE
The name of the output file for the "disk" audio driver. If not
+set, the name sdlaudio.raw is used.
SDL_DISKAUDIODELAY
For the "disk" audio driver, how long to wait (in ms) before writing
+a full sound buffer. The default is 150 ms.
SDL_DSP_NOSELECT
For some audio drivers (alsa, paud, dma and dsp), don't use select()
+but a timed method instead. May cure some audio problems, or cause
+others.
SDL_PATH_DSP
The audio device to use. If not set, SDL tries AUDIODEV and then
+a platform-dependent default value (/dev/audio on Solaris,
+/dev/dsp on Linux etc).
CD-ROM
SDL_CDROM
A colon-separated list of CD-ROM devices to use, in addition to
+the standard devices (typically /dev/cdrom, platform-dependent).
Debugging
SDL_DEBUG
If set, causes every call to SDL_SetError (that
+is, every time SDL signals an error) to also print an error message on
+stderr.
Joystick
SDL_JOYSTICK_DEVICE
Joystick device to use in the linux joystick driver, in addition
+to the usual: /dev/js*, /dev/input/event*, /dev/input/js*
SDL_LINUX_JOYSTICK
Special joystick configuration string for linux. The format is
"namenumaxesnumhatsnumballs"
where name is the name string of the joystick
+(possibly in single quotes), and the rest are the number of axes, hats
+and balls respectively.
The SDL_Event union is the core to all event handling is SDL, its probably the most important structure after SDL_Surface. SDL_Event is a union of all event structures used in SDL, using it is a simple matter of knowing which union member relates to which event type.
Reading events from the event queue is done with either SDL_PollEvent or SDL_PeepEvents. We'll use SDL_PollEvent and step through an example.
First off, we create an empty SDL_Event structure.
+
SDL_Event test_event;
+SDL_PollEvent removes the next event from the event queue, if there are no events on the queue it returns 0 otherwise it returns 1. We use a while loop to process each event in turn.
+
while(SDL_PollEvent(&test_event)) {
+The SDL_PollEvent function take a pointer to an SDL_Event structure that is to be filled with event information. We know that if SDL_PollEvent removes an event from the queue then the event information will be placed in our test_event structure, but we also know that the type of event will be placed in the type member of test_event. So to handle each event type seperately we use a switch statement.
+
switch(test_event.type) {
+We need to know what kind of events we're looking for and the event type's of those events. So lets assume we want to detect where the user is moving the mouse pointer within our application. We look through our event types and notice that SDL_MOUSEMOTION is, more than likely, the event we're looking for. A little more research tells use that SDL_MOUSEMOTION events are handled within the SDL_MouseMotionEvent structure which is the motion member of SDL_Event. We can check for the SDL_MOUSEMOTION event type within our switch statement like so:
+
case SDL_MOUSEMOTION:
+All we need do now is read the information out of the motion member of test_event.
+
printf("We got a motion event.\n");
+ printf("Current mouse position is: (%d, %d)\n", test_event.motion.x, test_event.motion.y);
+ break;
+ default:
+ printf("Unhandled Event!\n");
+ break;
+ }
+}
+printf("Event queue empty.\n");
It is also possible to push events onto the event queue and so use it as a two-way communication path. Both SDL_PushEvent and SDL_PeepEvents allow you to place events onto the event queue. This is usually used to place a SDL_USEREVENT on the event queue, however you could use it to post fake input events if you wished. Creating your own events is a simple matter of choosing the event type you want, setting the type member and filling the appropriate member structure with information.
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlexposeevent.html b/lib/sdl/msvc/docs/html/sdlexposeevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..82c2a3e7e29ad8ca87a910550bcced5936e9f3c1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlexposeevent.html
@@ -0,0 +1,252 @@
+SDL_ExposeEvent
SDL_ExposeEvent is a member of the SDL_Event union and is used whan an event of type SDL_VIDEOEXPOSE is reported.
A VIDEOEXPOSE event is triggered when the screen has been modified
+outside of the application, usually by the window manager and needs to
+be redrawn.
SDL_FillRect -- This function performs a fast fill of the given rectangle with some color
Synopsis
#include "SDL.h"
int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
Description
This function performs a fast fill of the given rectangle with
+color. 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 or SDL_MapRGBA
+functions. If the color value contains an alpha value then the
+destination is simply "filled" with that alpha information, no blending
+takes place.
If there is a clip rectangle set on the destination (set via
+SDL_SetClipRect) then this
+function will clip based on the intersection of the clip rectangle and
+the dstrect rectangle and the dstrect rectangle
+will be modified to represent the area actually filled.
Return Value
This function returns 0 on success, or
+-1 on error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlflip.html b/lib/sdl/msvc/docs/html/sdlflip.html
new file mode 100644
index 0000000000000000000000000000000000000000..b480f99aa8c9b7f87018d0bfc8cbd81ef2e5c9c3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlflip.html
@@ -0,0 +1,259 @@
+SDL_Flip
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't 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.
Return Value
This function returns 0 if successful, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreecursor.html b/lib/sdl/msvc/docs/html/sdlfreecursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..01a4f7c257219c8beef56bbbed0a427e358da033
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreecursor.html
@@ -0,0 +1,209 @@
+SDL_FreeCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreesurface.html b/lib/sdl/msvc/docs/html/sdlfreesurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..84b60481095ec700edb8eca64ed7da44768fea46
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreesurface.html
@@ -0,0 +1,219 @@
+SDL_FreeSurface
Frees the resources used by a previously created SDL_Surface. If the surface was created using
+SDL_CreateRGBSurfaceFrom then the pixel data is not freed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreewav.html b/lib/sdl/msvc/docs/html/sdlfreewav.html
new file mode 100644
index 0000000000000000000000000000000000000000..24242c4b0fe486d837c63b0e5615d724f6f9085e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreewav.html
@@ -0,0 +1,222 @@
+SDL_FreeWAV
After a WAVE file has been opened with SDL_LoadWAV its data can eventually be freed with SDL_FreeWAV. audio_buf is a pointer to the buffer created by SDL_LoadWAV.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..e82340d9e2e0f5fb34a60f26a35f2df063bb6cb7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html
@@ -0,0 +1,233 @@
+SDL_FreeYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetappstate.html b/lib/sdl/msvc/docs/html/sdlgetappstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..d09e2e0f08b406eefea2f56c41eab616d147ce87
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetappstate.html
@@ -0,0 +1,263 @@
+SDL_GetAppState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html b/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html
new file mode 100644
index 0000000000000000000000000000000000000000..3fc3a09119cd3e6813975f82b76356f8f023b0cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html
@@ -0,0 +1,221 @@
+SDL_GetAudioStatus
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetcliprect.html b/lib/sdl/msvc/docs/html/sdlgetcliprect.html
new file mode 100644
index 0000000000000000000000000000000000000000..f00ac77f8f6a2d4fe15f5957d933f37a9eab6901
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetcliprect.html
@@ -0,0 +1,229 @@
+SDL_GetClipRect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetcursor.html b/lib/sdl/msvc/docs/html/sdlgetcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..72ecbc7c0975aa4fa7eb9c2bee43fe3d91db5855
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetcursor.html
@@ -0,0 +1,219 @@
+SDL_GetCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgeterror.html b/lib/sdl/msvc/docs/html/sdlgeterror.html
new file mode 100644
index 0000000000000000000000000000000000000000..cdf57924a9f2f08e98b368f2a178d82e13639f39
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgeterror.html
@@ -0,0 +1,205 @@
+SDL_GetError
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgeteventfilter.html b/lib/sdl/msvc/docs/html/sdlgeteventfilter.html
new file mode 100644
index 0000000000000000000000000000000000000000..d254d34a52d8405504c182b340abbc21098eded4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgeteventfilter.html
@@ -0,0 +1,235 @@
+SDL_GetEventFilter
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetgammaramp.html b/lib/sdl/msvc/docs/html/sdlgetgammaramp.html
new file mode 100644
index 0000000000000000000000000000000000000000..bfcc03c4d3334cc3ca370205fa36946f54c3f395
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetgammaramp.html
@@ -0,0 +1,219 @@
+SDL_GetGammaRamp
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetkeyname.html b/lib/sdl/msvc/docs/html/sdlgetkeyname.html
new file mode 100644
index 0000000000000000000000000000000000000000..6c51c9497a0ad272a5ff634e8e4911729cc7c17f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetkeyname.html
@@ -0,0 +1,216 @@
+SDL_GetKeyName
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetkeystate.html b/lib/sdl/msvc/docs/html/sdlgetkeystate.html
new file mode 100644
index 0000000000000000000000000000000000000000..1c16f2e50c295fa498b70669e44d92148b4ec067
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetkeystate.html
@@ -0,0 +1,253 @@
+SDL_GetKeyState
SDL_GetKeyState -- Get a snapshot of the current keyboard state
Synopsis
#include "SDL.h"
Uint8 *SDL_GetKeyState(int *numkeys);
Description
Gets a snapshot of the current keyboard state. The current state is return as a pointer to an array, the size of this array is stored in numkeys. The array is indexed by the SDLK_* symbols. A value of 1 means the key is pressed and a value of 0 means its not. The pointer returned is a pointer to an internal SDL array and should not be freed by the caller.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetmodstate.html b/lib/sdl/msvc/docs/html/sdlgetmodstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..64d2f35621f9870a93b2d7edc12b3a1d63e65c33
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetmodstate.html
@@ -0,0 +1,257 @@
+SDL_GetModState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetmousestate.html b/lib/sdl/msvc/docs/html/sdlgetmousestate.html
new file mode 100644
index 0000000000000000000000000000000000000000..d96a55b8d1b74fd56a03484f8ec9223bb532352a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetmousestate.html
@@ -0,0 +1,253 @@
+SDL_GetMouseState
SDL_GetMouseState -- Retrieve the current state of the mouse
Synopsis
#include "SDL.h"
Uint8 SDL_GetMouseState(int *x, int *y);
Description
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.
Example
SDL_PumpEvents();
+if(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1))
+ printf("Mouse Button 1(left) is pressed.\n");
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html b/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html
new file mode 100644
index 0000000000000000000000000000000000000000..52a51066b588a10846fdadc0b2f15e83140a336d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html
@@ -0,0 +1,235 @@
+SDL_GetRelativeMouseState
SDL_GetRelativeMouseState -- Retrieve the current state of the mouse
Synopsis
#include "SDL.h"
Uint8 SDL_GetRelativeMouseState(int *x, int *y);
Description
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 change in the mouse position since the last call to SDL_GetRelativeMouseState or since event initialization. You can pass NULL for either x or y.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrgb.html b/lib/sdl/msvc/docs/html/sdlgetrgb.html
new file mode 100644
index 0000000000000000000000000000000000000000..47774dc2ed88c805402940bb11ae5ccdf7753b74
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrgb.html
@@ -0,0 +1,231 @@
+SDL_GetRGB
Get RGB component values from a pixel stored in the specified pixel format.
This function uses the entire 8-bit [0..255] range when converting color
+components from pixel formats with less than 8-bits per RGB component
+(e.g., a completely white pixel in 16-bit RGB565 format would return
+[0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrgba.html b/lib/sdl/msvc/docs/html/sdlgetrgba.html
new file mode 100644
index 0000000000000000000000000000000000000000..a9e1093ad5a37d7e64d756b085b0270f518d0e56
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrgba.html
@@ -0,0 +1,222 @@
+SDL_GetRGBA
Get RGBA component values from a pixel stored in the specified pixel format.
This function uses the entire 8-bit [0..255] range when converting color
+components from pixel formats with less than 8-bits per RGB component
+(e.g., a completely white pixel in 16-bit RGB565 format would return
+[0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
If the surface has no alpha component, the alpha will be returned as 0xff
+(100% opaque).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetthreadid.html b/lib/sdl/msvc/docs/html/sdlgetthreadid.html
new file mode 100644
index 0000000000000000000000000000000000000000..4bc59cb69c16baf753c480af054f69449c1c5a37
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetthreadid.html
@@ -0,0 +1,209 @@
+SDL_GetThreadID
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetticks.html b/lib/sdl/msvc/docs/html/sdlgetticks.html
new file mode 100644
index 0000000000000000000000000000000000000000..0911aae1a5557d35b1d019c6652c5683dc928e03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetticks.html
@@ -0,0 +1,206 @@
+SDL_GetTicks
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html b/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html
new file mode 100644
index 0000000000000000000000000000000000000000..25c4b458aa0101158bc950edcfbb60ea0bd81131
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html
@@ -0,0 +1,226 @@
+SDL_GetVideoInfo
SDL_GetVideoInfo -- returns a pointer to information about the video hardware
Synopsis
#include "SDL.h"
SDL_VideoInfo *SDL_GetVideoInfo(void);
Description
This function returns a read-only pointer to information about the video
+hardware. If this is called before SDL_SetVideoMode, the
+vfmt member of the returned structure will contain the
+pixel format of the "best" video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetvideosurface.html b/lib/sdl/msvc/docs/html/sdlgetvideosurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..905b1f6ac4b9eff8bb0e9a77a7aa3aceaeec7213
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetvideosurface.html
@@ -0,0 +1,208 @@
+SDL_GetVideoSurface
SDL_GetVideoSurface -- returns a pointer to the current display surface
Synopsis
#include "SDL.h"
SDL_Surface *SDL_GetVideoSurface(void);
Description
This function returns a pointer to the current display surface.
+If SDL is doing format conversion on the display surface, this
+function returns the publicly visible surface, not the real video
+surface.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglattr.html b/lib/sdl/msvc/docs/html/sdlglattr.html
new file mode 100644
index 0000000000000000000000000000000000000000..0ae01272a4570c2170782e64ca74c2f68f4ce6ea
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglattr.html
@@ -0,0 +1,379 @@
+SDL_GLattr
Size of the accumulation buffer red component, in bits
SDL_GL_ACCUM_GREEN_SIZE
Size of the accumulation buffer green component, in bits
SDL_GL_ACCUM_BLUE_SIZE
Size of the accumulation buffer blue component, in bits
SDL_GL_ACCUM_ALPHA_SIZE
Size of the accumulation buffer alpha component, in bits
Description
While you can set most OpenGL attributes normally, the attributes list above must be known before SDL sets the video mode. These attributes a set and read with SDL_GL_SetAttribute and SDL_GL_GetAttribute.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglgetattribute.html b/lib/sdl/msvc/docs/html/sdlglgetattribute.html
new file mode 100644
index 0000000000000000000000000000000000000000..26c8913bd24e69678470a11891fb35728e417b10
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglgetattribute.html
@@ -0,0 +1,247 @@
+SDL_GL_GetAttribute
SDL_GL_GetAttribute -- Get the value of a special SDL/OpenGL attribute
Synopsis
#include "SDL.h"
int SDL_GL_GetAttribute(SDLGLattr attr, int *value);
Description
Places the value of the SDL/OpenGL attributeattr into value. This is useful after a call to SDL_SetVideoMode to check whether your attributes have been set as you expected.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html b/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html
new file mode 100644
index 0000000000000000000000000000000000000000..a6cf6e4c1198c3e54391b337c6eb092d5d879780
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html
@@ -0,0 +1,262 @@
+SDL_GL_GetProcAddress
SDL_GL_GetProcAddress -- Get the address of a GL function
Synopsis
#include "SDL.h"
void *SDL_GL_GetProcAddress(const char* proc);
Description
Returns the address of the GL function proc, or NULL if the function is not found. If the GL library is loaded at runtime, with SDL_GL_LoadLibrary, then all GL functions must be retrieved this way. Usually this is used to retrieve function pointers to OpenGL extensions.
Example
typedef void (*GL_ActiveTextureARB_Func)(unsigned int);
+GL_ActiveTextureARB_Func glActiveTextureARB_ptr = 0;
+int has_multitexture=1;
+.
+.
+.
+/* Get function pointer */
+glActiveTextureARB_ptr=(GL_ActiveTextureARB_Func) SDL_GL_GetProcAddress("glActiveTextureARB");
+
+/* Check for a valid function ptr */
+if(!glActiveTextureARB_ptr){
+ fprintf(stderr, "Multitexture Extensions not present.\n");
+ has_multitexture=0;
+}
+.
+.
+.
+.
+if(has_multitexture){
+ glActiveTextureARB_ptr(GL_TEXTURE0_ARB);
+ .
+ .
+}
+else{
+ .
+ .
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglloadlibrary.html b/lib/sdl/msvc/docs/html/sdlglloadlibrary.html
new file mode 100644
index 0000000000000000000000000000000000000000..d3c4c6d79dd3099b70d8c4ec2a8c63fa1b705fb2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglloadlibrary.html
@@ -0,0 +1,231 @@
+SDL_GL_LoadLibrary
If you wish, you may load the OpenGL library at runtime, this must be done before SDL_SetVideoMode is called. The path of the GL library is passed to SDL_GL_LoadLibrary and it returns 0 on success, or -1 on an error. You must then use SDL_GL_GetProcAddress to retrieve function pointers to GL functions.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglsetattribute.html b/lib/sdl/msvc/docs/html/sdlglsetattribute.html
new file mode 100644
index 0000000000000000000000000000000000000000..ffb1204b0e005fe6cd59cd872449c62fda5c379d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglsetattribute.html
@@ -0,0 +1,286 @@
+SDL_GL_SetAttribute
SDL_GL_SetAttribute -- Set a special SDL/OpenGL attribute
Synopsis
#include "SDL.h"
int SDL_GL_SetAttribute(SDL_GLattr attr, int value);
Description
Sets the OpenGL attributeattr to value. The attributes you set don't take effect until after a call to SDL_SetVideoMode. You should use SDL_GL_GetAttribute to check the values after a SDL_SetVideoMode call.
Note: The SDL_DOUBLEBUF flag is not required to enable double buffering when setting an OpenGL video mode. Double buffering is enabled or disabled using the SDL_GL_DOUBLEBUFFER attribute.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglswapbuffers.html b/lib/sdl/msvc/docs/html/sdlglswapbuffers.html
new file mode 100644
index 0000000000000000000000000000000000000000..fa383414d4d07705fc7d2f1726d2e51a58d93c9b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglswapbuffers.html
@@ -0,0 +1,212 @@
+SDL_GL_SwapBuffers
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlinit.html b/lib/sdl/msvc/docs/html/sdlinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..11f27b81d1652fd907d3e07d3a44c9c94fb4c887
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlinit.html
@@ -0,0 +1,368 @@
+SDL_Init
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlinitsubsystem.html b/lib/sdl/msvc/docs/html/sdlinitsubsystem.html
new file mode 100644
index 0000000000000000000000000000000000000000..917fd1068e0f59bab51264b9113c45f3b106c7ab
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlinitsubsystem.html
@@ -0,0 +1,283 @@
+SDL_InitSubSystem
After SDL has been initialized with SDL_Init you may initialize uninitialized subsystems with SDL_InitSubSystem. The flags parameter is the same as that used in SDL_Init.
Examples
/* Seperating Joystick and Video initialization. */
+SDL_Init(SDL_INIT_VIDEO);
+.
+.
+SDL_SetVideoMode(640, 480, 16, SDL_DOUBLEBUF|SDL_FULLSCREEN);
+.
+/* Do Some Video stuff */
+.
+.
+/* Initialize the joystick subsystem */
+SDL_InitSubSystem(SDL_INIT_JOYSTICK);
+
+/* Do some stuff with video and joystick */
+.
+.
+.
+/* Shut them both down */
+SDL_Quit();
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyaxisevent.html b/lib/sdl/msvc/docs/html/sdljoyaxisevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..9f0166959f0ed40852089614e1dd58e3a0abf9d3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyaxisevent.html
@@ -0,0 +1,330 @@
+SDL_JoyAxisEvent
SDL_JoyAxisEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYAXISMOTION is reported.
A SDL_JOYAXISMOTION event occurs when ever a user moves an axis on the joystick. The field which is the index of the joystick that reported the event and axis is the index of the axis (for a more detailed explaination see the Joystick section). value is the current position of the axis.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyballevent.html b/lib/sdl/msvc/docs/html/sdljoyballevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..4ab96fe0e83393f66c5469959366c13ef4140d8d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyballevent.html
@@ -0,0 +1,340 @@
+SDL_JoyBallEvent
SDL_JoyBallEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYBALLMOTION is reported.
A SDL_JOYBALLMOTION event occurs when a user moves a trackball on the joystick. The field which is the index of the joystick that reported the event and ball is the index of the trackball (for a more detailed explaination see the Joystick section). Trackballs only return relative motion, this is the change in position on the ball since it was last polled (last cycle of the event loop) and it is stored in xrel and yrel.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoybuttonevent.html b/lib/sdl/msvc/docs/html/sdljoybuttonevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d1d9c1ef638d0dc9fbcd2a3c16cbecccba7ddbc2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoybuttonevent.html
@@ -0,0 +1,351 @@
+SDL_JoyButtonEvent
SDL_JoyButtonEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP is reported.
A SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP event occurs when ever a user presses or releases a button on a joystick. The field which is the index of the joystick that reported the event and button is the index of the button (for a more detailed explaination see the Joystick section). state is the current state or the button which is either SDL_PRESSED or SDL_RELEASED.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyhatevent.html b/lib/sdl/msvc/docs/html/sdljoyhatevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e115be2316b524d7bae33ccbff8336a8065ac93
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyhatevent.html
@@ -0,0 +1,413 @@
+SDL_JoyHatEvent
SDL_JoyHatEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYHATMOTION is reported.
A SDL_JOYHATMOTION event occurs when ever a user moves a hat on the joystick. The field which is the index of the joystick that reported the event and hat is the index of the hat (for a more detailed exlaination see the Joystick section). value is the current position of the hat. It is a logically OR'd combination of the following values (whose meanings should be pretty obvious:) :
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickclose.html b/lib/sdl/msvc/docs/html/sdljoystickclose.html
new file mode 100644
index 0000000000000000000000000000000000000000..efb44e0fe6ca9a09df7ef324f3e851317438d46d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickclose.html
@@ -0,0 +1,223 @@
+SDL_JoystickClose
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickeventstate.html b/lib/sdl/msvc/docs/html/sdljoystickeventstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..11b148a126047f2a2a263b4d5c0690d8bbd80e6f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickeventstate.html
@@ -0,0 +1,290 @@
+SDL_JoystickEventState
This function is used to enable or disable joystick event processing. With joystick event processing disabled you will have to update joystick states with SDL_JoystickUpdate and read the joystick information manually. state is either SDL_QUERY, SDL_ENABLE or SDL_IGNORE.
Note: Joystick event handling is prefered
Return Value
If state is SDL_QUERY then the current state is returned, otherwise the new processing state is returned.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html b/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html
new file mode 100644
index 0000000000000000000000000000000000000000..40a17b4cc2d4e46bd66cd549440a8df0b678cd7f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html
@@ -0,0 +1,271 @@
+SDL_JoystickGetAxis
SDL_JoystickGetAxis -- Get the current state of an axis
Synopsis
#include "SDL.h"
Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis);
Description
SDL_JoystickGetAxis returns the current state of the given axis on the given joystick.
On most modern joysticks the X axis is usually represented by axis 0 and the Y axis by axis 1. The value returned by SDL_JoystickGetAxis is a signed integer (-32768 to 32768) representing the current position of the axis, it maybe necessary to impose certain tolerances on these values to account for jitter. It is worth noting that some joysticks use axes 2 and 3 for extra buttons.
Return Value
Returns a 16-bit signed integer representing the current position of the axis.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetball.html b/lib/sdl/msvc/docs/html/sdljoystickgetball.html
new file mode 100644
index 0000000000000000000000000000000000000000..0da252ab1a5cd52e7e89236e46f6869980a986e8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetball.html
@@ -0,0 +1,262 @@
+SDL_JoystickGetBall
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html b/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html
new file mode 100644
index 0000000000000000000000000000000000000000..680e3569d05a3081c89d68c7aa6da7e6b29f81a0
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html
@@ -0,0 +1,231 @@
+SDL_JoystickGetButton
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgethat.html b/lib/sdl/msvc/docs/html/sdljoystickgethat.html
new file mode 100644
index 0000000000000000000000000000000000000000..c638abb7c235c7436561d40633ddb9171af36992
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgethat.html
@@ -0,0 +1,297 @@
+SDL_JoystickGetHat
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickindex.html b/lib/sdl/msvc/docs/html/sdljoystickindex.html
new file mode 100644
index 0000000000000000000000000000000000000000..868a75addb6b033ead51735caca43cba7097b8cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickindex.html
@@ -0,0 +1,218 @@
+SDL_JoystickIndex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickname.html b/lib/sdl/msvc/docs/html/sdljoystickname.html
new file mode 100644
index 0000000000000000000000000000000000000000..0add817dc5e9d8a791f5e2bb53b4146a3d57af9d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickname.html
@@ -0,0 +1,238 @@
+SDL_JoystickName
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html b/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html
new file mode 100644
index 0000000000000000000000000000000000000000..53b67f52394d0496fdefd561e332580d029d796c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumAxes
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumballs.html b/lib/sdl/msvc/docs/html/sdljoysticknumballs.html
new file mode 100644
index 0000000000000000000000000000000000000000..0a8405dc930423c23013371b6a5c51cb07a776b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumballs.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumBalls
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html b/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html
new file mode 100644
index 0000000000000000000000000000000000000000..625b893a6a2301d184ae888bde281544c5f96396
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumButtons
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumhats.html b/lib/sdl/msvc/docs/html/sdljoysticknumhats.html
new file mode 100644
index 0000000000000000000000000000000000000000..ed53235854766bdbddfb0264ece1ae0756bcaa85
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumhats.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumHats
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickopen.html b/lib/sdl/msvc/docs/html/sdljoystickopen.html
new file mode 100644
index 0000000000000000000000000000000000000000..e608c4370f7a2db71891cd34bd3edf159a696c03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickopen.html
@@ -0,0 +1,259 @@
+SDL_JoystickOpen
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickopened.html b/lib/sdl/msvc/docs/html/sdljoystickopened.html
new file mode 100644
index 0000000000000000000000000000000000000000..5275a099de81d5fcc06be314f717d38b87f935b3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickopened.html
@@ -0,0 +1,233 @@
+SDL_JoystickOpened
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickupdate.html b/lib/sdl/msvc/docs/html/sdljoystickupdate.html
new file mode 100644
index 0000000000000000000000000000000000000000..0cb37dc2261dc99e93489491c7f951a021334e6e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickupdate.html
@@ -0,0 +1,211 @@
+SDL_JoystickUpdate
SDL_JoystickUpdate -- Updates the state of all joysticks
Synopsis
#include "SDL.h"
void SDL_JoystickUpdate(void);
Description
Updates the state(position, buttons, etc.) of all open joysticks. If joystick events have been enabled with SDL_JoystickEventState then this is called automatically in the event loop.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkey.html b/lib/sdl/msvc/docs/html/sdlkey.html
new file mode 100644
index 0000000000000000000000000000000000000000..6591884d1e34b038474222b4e06087e8f72d9d0b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkey.html
@@ -0,0 +1,2630 @@
+SDLKey
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkeyboardevent.html b/lib/sdl/msvc/docs/html/sdlkeyboardevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..1a6962c74a5a95152f8dc4761f2dcafca620641c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkeyboardevent.html
@@ -0,0 +1,375 @@
+SDL_KeyboardEvent
SDL_KeyboardEvent is a member of the SDL_Event union and is used when an event of type SDL_KEYDOWN or SDL_KEYUP is reported.
The type and state actually report the same information, they just use different values to do it! A keyboard event occurs when a key is released (type=SDK_KEYUP or state=SDL_RELEASED) and when a key is pressed (type=SDL_KEYDOWN or state=SDL_PRESSED). The information on what key was pressed or released is in the keysym structure.
Note: Repeating SDL_KEYDOWN events will occur if key repeat is enabled (see SDL_EnableKeyRepeat).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkeysym.html b/lib/sdl/msvc/docs/html/sdlkeysym.html
new file mode 100644
index 0000000000000000000000000000000000000000..7a22f795136dc8a3f1dbbe309d5a57d86544fa2e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkeysym.html
@@ -0,0 +1,355 @@
+SDL_keysym
The SDL_keysym structure is used by reporting key presses and releases since it is a part of the SDL_KeyboardEvent.
The scancode field should generally be left alone, it is the hardware dependent scancode returned by the keyboard. The sym field is extremely useful. It is the SDL-defined value of the key (see SDL Key Syms. This field is very useful when you are checking for certain key presses, like so:
+
+mod stores the current state of the keyboard modifiers as explained in SDL_GetModState. The unicode is only used when UNICODE translation is enabled with SDL_EnableUNICODE. If unicode is non-zero then this a the UNICODE character corresponding to the keypress. If the high 9 bits of the character are 0, then this maps to the equivalent ASCII character:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkillthread.html b/lib/sdl/msvc/docs/html/sdlkillthread.html
new file mode 100644
index 0000000000000000000000000000000000000000..2ce7b9b58f84ae3b0fe9d64f1c1825ead1290d7b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkillthread.html
@@ -0,0 +1,223 @@
+SDL_KillThread
SDL_KillThread -- Gracelessly terminates the thread.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
void SDL_KillThread(SDL_Thread *thread);
Description
SDL_KillThread gracelessly terminates the thread
+associated with thread. If possible, you should
+use some other form of IPC to signal the thread to quit.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllistmodes.html b/lib/sdl/msvc/docs/html/sdllistmodes.html
new file mode 100644
index 0000000000000000000000000000000000000000..ee7bc0eeecf0ad9d37f5f35b3328fa9cb61898a2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllistmodes.html
@@ -0,0 +1,310 @@
+SDL_ListModes
Return a pointer to an array of available screen dimensions for the given
+format and video flags, sorted largest to smallest. Returns
+NULL if there are no dimensions available for a particular
+format, or -1 if any dimension is okay for
+the given format.
If format is NULL, the mode list
+will be for the format returned by SDL_GetVideoInfo()->vfmt. The flag parameter is an OR'd combination of surface flags. The flags are the same as those used SDL_SetVideoMode and they play a strong role in deciding what modes are valid. For instance, if you pass SDL_HWSURFACE as a flag only modes that support hardware video surfaces will be returned.
Example
SDL_Rect **modes;
+int i;
+.
+.
+.
+
+/* Get available fullscreen/hardware modes */
+modes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
+
+/* Check is there are any modes available */
+if(modes == (SDL_Rect **)0){
+ printf("No modes available!\n");
+ exit(-1);
+}
+
+/* Check if our resolution is restricted */
+if(modes == (SDL_Rect **)-1){
+ printf("All resolutions available.\n");
+}
+else{
+ /* Print valid modes */
+ printf("Available Modes\n");
+ for(i=0;modes[i];++i)
+ printf(" %d x %d\n", modes[i]->w, modes[i]->h);
+}
+.
+.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlloadbmp.html b/lib/sdl/msvc/docs/html/sdlloadbmp.html
new file mode 100644
index 0000000000000000000000000000000000000000..41556e34ae87fabf050fe72860d592b381deb275
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlloadbmp.html
@@ -0,0 +1,219 @@
+SDL_LoadBMP
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlloadwav.html b/lib/sdl/msvc/docs/html/sdlloadwav.html
new file mode 100644
index 0000000000000000000000000000000000000000..8abb73ec366f3038b4d61264a971bff327d74104
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlloadwav.html
@@ -0,0 +1,296 @@
+SDL_LoadWAV
SDL_LoadWAV
+This function loads a WAVE file into memory.
If this function succeeds, it returns the given
+SDL_AudioSpec,
+filled with the audio data format of the wave data, and sets
+audio_buf to a malloc'd
+buffer containing the audio data, and sets audio_len
+to the length of that audio buffer, in bytes. You need to free the audio
+buffer with SDL_FreeWAV when you are
+done with it.
This function returns NULL and sets the SDL
+error message if the wave file cannot be opened, uses an unknown data format,
+or is corrupt. Currently raw, MS-ADPCM and IMA-ADPCM WAVE files are supported.
Example
SDL_AudioSpec wav_spec;
+Uint32 wav_length;
+Uint8 *wav_buffer;
+
+/* Load the WAV */
+if( SDL_LoadWAV("test.wav", &wav_spec, &wav_buffer, &wav_length) == NULL ){
+ fprintf(stderr, "Could not open test.wav: %s\n", SDL_GetError());
+ exit(-1);
+}
+.
+.
+.
+/* Do stuff with the WAV */
+.
+.
+/* Free It */
+SDL_FreeWAV(wav_buffer);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllockaudio.html b/lib/sdl/msvc/docs/html/sdllockaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..0e6fc292b4db8c10c143a834c1e722f48eca4f89
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllockaudio.html
@@ -0,0 +1,208 @@
+SDL_LockAudio
The lock manipulated by these functions protects the callback function.
+During a LockAudio period, you can be guaranteed that the
+callback function is not running. Do not call these from the callback
+function or you will cause deadlock.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllocksurface.html b/lib/sdl/msvc/docs/html/sdllocksurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..40c8959ea025ce28b2898e3a10e818d4bd548e9f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllocksurface.html
@@ -0,0 +1,306 @@
+SDL_LockSurface
SDL_LockSurface -- Lock a surface for directly access.
Synopsis
#include "SDL.h"
int SDL_LockSurface(SDL_Surface *surface);
Description
SDL_LockSurface sets up a surface for directly
+accessing the pixels. Between calls to SDL_LockSurface
+and SDL_UnlockSurface, you can write to and read from
+surface->pixels, using the pixel format stored in
+surface->format. Once you are done accessing the
+surface, you should use SDL_UnlockSurface to release it.
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.
No operating system or library calls should be made between lock/unlock
+pairs, as critical system locks may be held during this time.
It should be noted, that since SDL 1.1.8 surface locks are recursive. This means that you can lock a surface multiple times, but each lock must have a match unlock.
+
.
+ .
+ SDL_LockSurface( surface );
+ .
+ /* Surface is locked */
+ /* Direct pixel access on surface here */
+ .
+ SDL_LockSurface( surface );
+ .
+ /* More direct pixel access on surface */
+ .
+ SDL_UnlockSurface( surface );
+ /* Surface is still locked */
+ /* Note: Is versions < 1.1.8, the surface would have been */
+ /* no longer locked at this stage */
+ .
+ SDL_UnlockSurface( surface );
+ /* Surface is now unlocked */
+ .
+ .
Return Value
SDL_LockSurface returns 0,
+or -1 if the surface couldn't be locked.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html b/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..74e6ce673dba1e186746e1613f77878e98a1caa0
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html
@@ -0,0 +1,252 @@
+SDL_LockYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmaprgb.html b/lib/sdl/msvc/docs/html/sdlmaprgb.html
new file mode 100644
index 0000000000000000000000000000000000000000..5086d0c7dca8b7b700cde9c60ef06c11870e2af1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmaprgb.html
@@ -0,0 +1,254 @@
+SDL_MapRGB
Maps the RGB color value to the specified pixel format and returns the
+pixel value as a 32-bit int.
If the format has a palette (8-bit) the index of the closest matching
+color in the palette will be returned.
If the specified pixel format has an alpha component it will be returned
+as all 1 bits (fully opaque).
Return Value
A pixel value best approximating the given RGB color value for a given
+pixel format. If the pixel format bpp (color depth) is less than 32-bpp
+then the unused upper bits of the return value can safely be ignored
+(e.g., with a 16-bpp format the return value can be assigned to a
+Uint16, and similarly a Uint8 for an 8-bpp
+format).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmaprgba.html b/lib/sdl/msvc/docs/html/sdlmaprgba.html
new file mode 100644
index 0000000000000000000000000000000000000000..e6bff276f770f121e1009482c4339f039aa96036
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmaprgba.html
@@ -0,0 +1,242 @@
+SDL_MapRGBA
Maps the RGBA color value to the specified pixel format and returns the
+pixel value as a 32-bit int.
If the format has a palette (8-bit) the index of the closest matching
+color in the palette will be returned.
If the specified pixel format has no alpha component the alpha value
+will be ignored (as it will be in formats with a palette).
Return Value
A pixel value best approximating the given RGBA color value for a given
+pixel format. If the pixel format bpp (color depth) is less than 32-bpp
+then the unused upper bits of the return value can safely be ignored
+(e.g., with a 16-bpp format the return value can be assigned to a
+Uint16, and similarly a Uint8 for an 8-bpp
+format).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmixaudio.html b/lib/sdl/msvc/docs/html/sdlmixaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..6cbf0f0dbd4baa642bf9aadfd6dd21938965402d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmixaudio.html
@@ -0,0 +1,237 @@
+SDL_MixAudio
void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume);
Description
This function takes two audio buffers of len bytes each
+of the playing audio format and mixes them, performing addition, volume
+adjustment, and overflow clipping. The volume ranges
+from 0 to SDL_MIX_MAXVOLUME and should be set to the maximum
+value for full audio volume. Note this does not change hardware volume. This is
+provided for convenience -- you can mix your own audio data.
Note: Do not use this function for mixing together more than two streams of sample
+data. The output from repeated application of this function may be distorted
+by clipping, because there is no accumulator with greater range than the
+input (not to mention this being an inefficient way of doing it).
+Use mixing functions from SDL_mixer, OpenAL, or write your own mixer instead.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html b/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..b0b40df97a7ef890a0400bb466809be717757c0c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html
@@ -0,0 +1,346 @@
+SDL_MouseButtonEvent
The mouse button index (SDL_BUTTON_LEFT, SDL_BUTTON_MIDDLE, SDL_BUTTON_RIGHT)
state
SDL_PRESSED or SDL_RELEASED
x, y
The X/Y coordinates of the mouse at press/release time
Description
SDL_MouseButtonEvent is a member of the SDL_Event union and is used when an event of type SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP is reported.
When a mouse button press or release is detected then number of the button pressed (from 1 to 255, with 1 usually being the left button and 2 the right) is placed into button, the position of the mouse when this event occured is stored in the x and the y fields. Like SDL_KeyboardEvent, information on whether the event was a press or a release event is stored in both the type and state fields, but this should be obvious.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmousemotionevent.html b/lib/sdl/msvc/docs/html/sdlmousemotionevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..3cc7cb5c6adf74472fbd7ec31af6c1462b3a0b58
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmousemotionevent.html
@@ -0,0 +1,365 @@
+SDL_MouseMotionEvent
SDL_MouseMotionEvent is a member of the SDL_Event union and is used when an event of type SDL_MOUSEMOTION is reported.
Simply put, a SDL_MOUSEMOTION type event occurs when a user moves the mouse within the application window or when SDL_WarpMouse is called. Both the absolute (x and y) and relative (xrel and yrel) coordinates are reported along with the current button states (state). The button state can be interpreted using the SDL_BUTTON macro (see SDL_GetMouseState).
If the cursor is hidden (SDL_ShowCursor(0)) and the input is grabbed (SDL_WM_GrabInput(SDL_GRAB_ON)), then the mouse will give relative motion events even when the cursor reaches the edge fo the screen. This is currently only implemented on Windows and Linux/Unix-a-likes.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmutexp.html b/lib/sdl/msvc/docs/html/sdlmutexp.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc32ca59961d2492620ea615420296c67665b8fe
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmutexp.html
@@ -0,0 +1,241 @@
+SDL_mutexP
Locks the mutex, which was previously created with SDL_CreateMutex. If the mutex is already locked then SDL_mutexP will not return until it is unlocked. Returns 0 on success, or -1 on an error.
SDL also defines a macro #define SDL_LockMutex(m) SDL_mutexP(m).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmutexv.html b/lib/sdl/msvc/docs/html/sdlmutexv.html
new file mode 100644
index 0000000000000000000000000000000000000000..06a68bdc5ebe5135213fd933dc999c9789abce7c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmutexv.html
@@ -0,0 +1,235 @@
+SDL_mutexV
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlnumjoysticks.html b/lib/sdl/msvc/docs/html/sdlnumjoysticks.html
new file mode 100644
index 0000000000000000000000000000000000000000..68e3e3a72ee587bed9f098f50f192f02d63c255f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlnumjoysticks.html
@@ -0,0 +1,222 @@
+SDL_NumJoysticks
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlopenaudio.html b/lib/sdl/msvc/docs/html/sdlopenaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..bcfed54a7f4ba0906aa9d9953d3c22a2e8dea9e7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlopenaudio.html
@@ -0,0 +1,578 @@
+SDL_OpenAudio
SDL_OpenAudio -- Opens the audio device with the desired parameters.
Synopsis
#include "SDL.h"
int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
Description
This function opens the audio device with the desired parameters, and
+returns 0 if successful, placing the actual hardware parameters in the
+structure pointed to by obtained. If obtained is NULL, the audio
+data passed to the callback function will be guaranteed to be in the
+requested format, and will be automatically converted to the hardware
+audio format if necessary. This function returns -1 if it failed
+to open the audio device, or couldn't set up the audio thread.
To open the audio device a desiredSDL_AudioSpec must be created.
+
The desired size of the audio buffer in samples. This number should be a power of two, and may be adjusted by the audio driver to a value more suitable for the hardware. Good values seem to range between 512 and 8192 inclusive, depending on the application and CPU speed. Smaller values yield faster response time, but can lead to underflow if the application is doing heavy processing and cannot fill the audio buffer in time. A stereo sample consists of both right and left channels in LR ordering. Note that the number of samples is directly related to time by the following formula: ms = (samples*1000)/freq
desired->callback
This should be set to a function that will be called when the audio device is ready for more data. It is passed a pointer to the audio buffer, and the length in bytes of the audio buffer. This function usually runs in a separate thread, and so you should protect data structures that it accesses by calling SDL_LockAudio and SDL_UnlockAudio in your code. The callback prototype is:
+
void callback(void *userdata, Uint8 *stream, int len);
+userdata is the pointer stored in userdata field of the SDL_AudioSpec. stream is a pointer to the audio buffer you want to fill with information and len is the length of the audio buffer in bytes.
desired->userdata
This pointer is passed as the first parameter to the callback function.
SDL_OpenAudio reads these fields from the desiredSDL_AudioSpec structure pass to the function and attempts to find an audio configuration matching your desired. As mentioned above, if the obtained parameter is NULL then SDL with convert from your desired audio settings to the hardware settings as it plays.
If obtained is NULL then the desiredSDL_AudioSpec is your working specification, otherwise the obtainedSDL_AudioSpec becomes the working specification and the desirec specification can be deleted. The data in the working specification is used when building SDL_AudioCVT's for converting loaded data to the hardware format.
SDL_OpenAudio calculates the size and silence fields for both the desired and obtained specifications. The size field stores the total size of the audio buffer in bytes, while the silence stores the value used to represent silence in the audio buffer
The audio device starts out playing silence when it's opened, and should be enabled for playing by calling SDL_PauseAudio(0) when you are ready for your audio callback function to be called. Since the audio driver may modify the requested size of the audio buffer, you should allocate any local mixing buffers after you open the audio device.
Examples
/* Prototype of our callback function */
+void my_audio_callback(void *userdata, Uint8 *stream, int len);
+
+/* Open the audio device */
+SDL_AudioSpec *desired, *obtained;
+SDL_AudioSpec *hardware_spec;
+
+/* Allocate a desired SDL_AudioSpec */
+desired = malloc(sizeof(SDL_AudioSpec));
+
+/* Allocate space for the obtained SDL_AudioSpec */
+obtained = malloc(sizeof(SDL_AudioSpec));
+
+/* 22050Hz - FM Radio quality */
+desired->freq=22050;
+
+/* 16-bit signed audio */
+desired->format=AUDIO_S16LSB;
+
+/* Mono */
+desired->channels=0;
+
+/* Large audio buffer reduces risk of dropouts but increases response time */
+desired->samples=8192;
+
+/* Our callback function */
+desired->callback=my_audio_callback;
+
+desired->userdata=NULL;
+
+/* Open the audio device */
+if ( SDL_OpenAudio(desired, obtained) < 0 ){
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ exit(-1);
+}
+/* desired spec is no longer needed */
+free(desired);
+hardware_spec=obtained;
+.
+.
+/* Prepare callback for playing */
+.
+.
+.
+/* Start playing */
+SDL_PauseAudio(0);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdloverlay.html b/lib/sdl/msvc/docs/html/sdloverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..422919edc90d03be4408c9bc63861093ad06b047
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdloverlay.html
@@ -0,0 +1,362 @@
+SDL_Overlay
Number of planes in the overlay. Usually either 1 or 3
pitches
An array of pitches, one for each plane. Pitch is the length of a row in bytes.
pixels
An array of pointers to teh data of each plane. The overlay should be locked before these pointers are used.
hw_overlay
This will be set to 1 if the overlay is hardware accelerated.
Description
A SDL_Overlay is similar to a SDL_Surface except it stores a YUV overlay. All the fields are read only, except for pixels which should be locked before use. The format field stores the format of the overlay which is one of the following:
+
#define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U */
+#define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V */
+#define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 */
+#define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 */
+#define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 */
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpalette.html b/lib/sdl/msvc/docs/html/sdlpalette.html
new file mode 100644
index 0000000000000000000000000000000000000000..6498ac40ba206e4baf37547b12787d94cba1536c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpalette.html
@@ -0,0 +1,301 @@
+SDL_Palette
SDL_Palette -- Color palette for 8-bit pixel formats
Structure Definition
typedef struct{
+ int ncolors;
+ SDL_Color *colors;
+} SDL_Palette;
Structure Data
ncolors
Number of colors used in this palette
colors
Pointer to SDL_Color structures that make up the palette.
Description
Each pixel in an 8-bit surface is an index into the colors field of the SDL_Palette structure store in SDL_PixelFormat. A SDL_Palette should never need to be created manually. It is automatically created when SDL allocates a SDL_PixelFormat for a surface. The colors values of a SDL_Surfaces palette can be set with the SDL_SetColors.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpauseaudio.html b/lib/sdl/msvc/docs/html/sdlpauseaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..39d5a0f0f91e01f5343f3c8887c3355987ae8a03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpauseaudio.html
@@ -0,0 +1,221 @@
+SDL_PauseAudio
SDL_PauseAudio -- Pauses and unpauses the audio callback processing
Synopsis
#include "SDL.h"
void SDL_PauseAudio(int pause_on);
Description
This function pauses and unpauses the audio callback processing.
+It should be called with pause_on=0 after opening the audio
+device to start playing sound. This is so you can safely initialize
+data for your callback function after opening the audio device.
+Silence will be written to the audio device during the pause.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpeepevents.html b/lib/sdl/msvc/docs/html/sdlpeepevents.html
new file mode 100644
index 0000000000000000000000000000000000000000..d5a0ff6f9fe11184af66f51b485cab9b312227c7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpeepevents.html
@@ -0,0 +1,321 @@
+SDL_PeepEvents
SDL_PeepEvents -- Checks the event queue for messages and optionally returns them.
Synopsis
#include "SDL.h"
int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action, Uint32 mask);
Description
Checks the event queue for messages and optionally returns them.
If action is SDL_ADDEVENT, up to
+numevents events will be added to the back of the event
+ queue.
If action is SDL_PEEKEVENT, up to
+numevents events at the front of the event queue,
+matching mask,
+will be returned and will not be removed from the queue.
If action is SDL_GETEVENT, up to
+numevents events at the front of the event queue,
+matching mask,
+will be returned and will be removed from the queue.
The mask parameter is an bitwise OR of
+SDL_EVENTMASK(event_type), for all
+event types you are interested in.
This function is thread-safe.
Return Value
This function returns the number of events actually stored, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpixelformat.html b/lib/sdl/msvc/docs/html/sdlpixelformat.html
new file mode 100644
index 0000000000000000000000000000000000000000..000ddc08b163564736cb4c9c6462f6ffc8414c8a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpixelformat.html
@@ -0,0 +1,528 @@
+SDL_PixelFormat
Pointer to the palette, or NULL if the BitsPerPixel>8
BitsPerPixel
The number of bits used to represent each pixel in a surface. Usually 8, 16, 24 or 32.
BytesPerPixel
The number of bytes used to represent each pixel in a surface. Usually one to four.
[RGBA]mask
Binary mask used to retrieve individual color values
[RGBA]loss
Precision loss of each color component (2[RGBA]loss)
[RGBA]shift
Binary left shift of each color component in the pixel value
colorkey
Pixel value of transparent pixels
alpha
Overall surface alpha value
Description
A SDL_PixelFormat describes the format of the pixel data stored at the pixels field of a SDL_Surface. Every surface stores a SDL_PixelFormat in the format field.
If you wish to do pixel level modifications on a surface, then understanding how SDL stores its color information is essential.
8-bit pixel formats are the easiest to understand. Since its an 8-bit format, we have 8 BitsPerPixel and 1 BytesPerPixel. Since BytesPerPixel is 1, all pixels are represented by a Uint8 which contains an index into palette->colors. So, to determine the color of a pixel in a 8-bit surface: we read the color index from surface->pixels and we use that index to read the SDL_Color structure from surface->format->palette->colors. Like so:
+
SDL_Surface *surface;
+SDL_PixelFormat *fmt;
+SDL_Color *color;
+Uint8 index;
+
+.
+.
+
+/* Create surface */
+.
+.
+fmt=surface->format;
+
+/* Check the bitdepth of the surface */
+if(fmt->BitsPerPixel!=8){
+ fprintf(stderr, "Not an 8-bit surface.\n");
+ return(-1);
+}
+
+/* Lock the surface */
+SDL_LockSurface(surface);
+
+/* Get the topleft pixel */
+index=*(Uint8 *)surface->pixels;
+color=fmt->palette->colors[index];
+
+/* Unlock the surface */
+SDL_UnlockSurface(surface);
+printf("Pixel Color-> Red: %d, Green: %d, Blue: %d. Index: %d\n",
+ color->r, color->g, color->b, index);
+.
+.
Pixel formats above 8-bit are an entirely different experience. They are
+considered to be "TrueColor" formats and the color information is stored in the
+pixels themselves, not in a palette. The mask, shift and loss fields tell us
+how the color information is encoded. The mask fields allow us to isolate each
+color component, the shift fields tell us the number of bits to the right of
+each component in the pixel value and the loss fields tell us the number of
+bits lost from each component when packing 8-bit color component in a pixel.
+
/* Extracting color components from a 32-bit color value */
+SDL_PixelFormat *fmt;
+SDL_Surface *surface;
+Uint32 temp, pixel;
+Uint8 red, green, blue, alpha;
+.
+.
+.
+fmt=surface->format;
+SDL_LockSurface(surface);
+pixel=*((Uint32*)surface->pixels);
+SDL_UnlockSurface(surface);
+
+/* Get Red component */
+temp=pixel&fmt->Rmask; /* Isolate red component */
+temp=temp>>fmt->Rshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Rloss; /* Expand to a full 8-bit number */
+red=(Uint8)temp;
+
+/* Get Green component */
+temp=pixel&fmt->Gmask; /* Isolate green component */
+temp=temp>>fmt->Gshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Gloss; /* Expand to a full 8-bit number */
+green=(Uint8)temp;
+
+/* Get Blue component */
+temp=pixel&fmt->Bmask; /* Isolate blue component */
+temp=temp>>fmt->Bshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Bloss; /* Expand to a full 8-bit number */
+blue=(Uint8)temp;
+
+/* Get Alpha component */
+temp=pixel&fmt->Amask; /* Isolate alpha component */
+temp=temp>>fmt->Ashift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Aloss; /* Expand to a full 8-bit number */
+alpha=(Uint8)temp;
+
+printf("Pixel Color -> R: %d, G: %d, B: %d, A: %d\n", red, green, blue, alpha);
+.
+.
+.
SDL_PollEvent -- Polls for currently pending events.
Synopsis
#include "SDL.h"
int SDL_PollEvent(SDL_Event *event);
Description
Polls for currently pending events, and returns 1
+if there are any pending events, or 0 if there
+are none available.
If event is not NULL, the next
+event is removed from the queue and stored in that area.
Examples
SDL_Event event; /* Event structure */
+
+.
+.
+.
+/* Check for events */
+while(SDL_PollEvent(&event)){ /* Loop until there are no events left on the queue */
+ switch(event.type){ /* Process the appropiate event type */
+ case SDL_KEYDOWN: /* Handle a KEYDOWN event */
+ printf("Oh! Key press\n");
+ break;
+ case SDL_MOUSEMOTION:
+ .
+ .
+ .
+ default: /* Report an unhandled event */
+ printf("I don't know what this event is!\n");
+ }
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpumpevents.html b/lib/sdl/msvc/docs/html/sdlpumpevents.html
new file mode 100644
index 0000000000000000000000000000000000000000..a7e528f19ac4b428212d41996ff631044f6e2762
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpumpevents.html
@@ -0,0 +1,244 @@
+SDL_PumpEvents
SDL_PumpEvents -- Pumps the event loop, gathering events from the input devices.
Synopsis
#include "SDL.h"
void SDL_PumpEvents(void);
Description
Pumps the event loop, gathering events from the input devices.
SDL_PumpEvents gathers all the pending input information from devices and places it on the event queue. Without calls to SDL_PumpEvents no events would ever be placed on the queue. Often calls the need for SDL_PumpEvents is hidden from the user since SDL_PollEvent and SDL_WaitEvent implicitly call SDL_PumpEvents. However, if you are not polling or waiting for events (e.g. you are filtering them), then you must call SDL_PumpEvents to force an event queue update.
Note: You can only call this function in the thread that set the video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpushevent.html b/lib/sdl/msvc/docs/html/sdlpushevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..6905385c32d40bb7a32aa22ebe13abe1ce1cb47c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpushevent.html
@@ -0,0 +1,266 @@
+SDL_PushEvent
SDL_PushEvent -- Pushes an event onto the event queue
Synopsis
#include "SDL.h"
int SDL_PushEvent(SDL_Event *event);
Description
The event queue can actually be used as a two way communication channel. Not only can events be read from the queue, but the user can also push their own events onto it. event is a pointer to the event structure you wish to push onto the queue.
Note: Pushing device input events onto the queue doesn't modify the state of the device within SDL.
Return Value
Returns 0 on success or -1 if the event couldn't be pushed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquit.html b/lib/sdl/msvc/docs/html/sdlquit.html
new file mode 100644
index 0000000000000000000000000000000000000000..1f31c82558ae9fb430d16b8d65148471e7cc90da
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquit.html
@@ -0,0 +1,244 @@
+SDL_Quit
SDL_Quit shuts down all SDL subsystems and frees the resources allocated to them. This should always be called before you exit. For the sake of simplicity you can set SDL_Quit as your atexit call, like:
+
Note: While using atexit maybe be fine for small programs, more advanced users should shut down SDL in their own cleanup code. Plus, using atexit in a library is a sure way to crash dynamically loaded code
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquitevent.html b/lib/sdl/msvc/docs/html/sdlquitevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d575f38b7b703a6c9a588a443d39184ec8347be4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquitevent.html
@@ -0,0 +1,263 @@
+SDL_QuitEvent
SDL_QuitEvent is a member of the SDL_Event union and is used whan an event of type SDL_QUIT is reported.
As can be seen, the SDL_QuitEvent structure serves no useful purpose. The event itself, on the other hand, is very important. If you filter out or ignore a quit event then it is impossible for the user to close the window. On the other hand, if you do accept a quit event then the application window will be closed, and screen updates will still report success event though the application will no longer be visible.
Note: The macro SDL_QuitRequested will return non-zero if a quit event is pending
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquitsubsystem.html b/lib/sdl/msvc/docs/html/sdlquitsubsystem.html
new file mode 100644
index 0000000000000000000000000000000000000000..877e3ce1181fe10145a0c7fa537813217aab19de
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquitsubsystem.html
@@ -0,0 +1,248 @@
+SDL_QuitSubSystem
SDL_QuitSubSystem allows you to shut down a subsystem that has been previously initialized by SDL_Init or SDL_InitSubSystem. The flags tells SDL_QuitSubSystem which subsystems to shut down, it uses the same values that are passed to SDL_Init.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlrect.html b/lib/sdl/msvc/docs/html/sdlrect.html
new file mode 100644
index 0000000000000000000000000000000000000000..ba4a80be69ceb897c407a1411e9fac7ea1d7514a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlrect.html
@@ -0,0 +1,258 @@
+SDL_Rect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlremovetimer.html b/lib/sdl/msvc/docs/html/sdlremovetimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..26a3d11f7b8cf7b1965f58345a4e1a9c62070863
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlremovetimer.html
@@ -0,0 +1,236 @@
+SDL_RemoveTimer
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlresizeevent.html b/lib/sdl/msvc/docs/html/sdlresizeevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..1d446a54cd140f502bad788e7457aec15638c93e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlresizeevent.html
@@ -0,0 +1,307 @@
+SDL_ResizeEvent
SDL_ResizeEvent is a member of the SDL_Event union and is used when an event of type SDL_VIDEORESIZE is reported.
When SDL_RESIZABLE is passed as a flag to SDL_SetVideoMode the user is allowed to resize the applications window. When the window is resized an SDL_VIDEORESIZE is report, with the new window width and height values stored in w and h, respectively. When an SDL_VIDEORESIZE is recieved the window should be resized to the new dimensions using SDL_SetVideoMode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsavebmp.html b/lib/sdl/msvc/docs/html/sdlsavebmp.html
new file mode 100644
index 0000000000000000000000000000000000000000..4c318ed756e4fa74a135b1302568db8b8c8bf713
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsavebmp.html
@@ -0,0 +1,236 @@
+SDL_SaveBMP
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsempost.html b/lib/sdl/msvc/docs/html/sdlsempost.html
new file mode 100644
index 0000000000000000000000000000000000000000..18fb01ab2f7717868d7736f1a838fbebd0dc1953
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsempost.html
@@ -0,0 +1,299 @@
+SDL_SemPost
SDL_SemPost unlocks the semaphore pointed to by
+sem and atomically increments the semaphores value.
+Threads that were blocking on the semaphore may be scheduled after this call
+succeeds.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemtrywait.html b/lib/sdl/msvc/docs/html/sdlsemtrywait.html
new file mode 100644
index 0000000000000000000000000000000000000000..86f47a1c83afce734bc83cdd1c966268c467ed99
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemtrywait.html
@@ -0,0 +1,319 @@
+SDL_SemTryWait
SDL_SemTryWait -- Attempt to lock a semaphore but don't suspend the thread.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemTryWait(SDL_sem *sem);
Description
SDL_SemTryWait is a non-blocking varient of
+SDL_SemWait. If the value of the semaphore
+pointed to by sem is positive it will atomically
+decrement the semaphore value and return 0, otherwise it will return
+SDL_MUTEX_TIMEDOUT instead of suspending the thread.
After SDL_SemTryWait is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if the semaphore was successfully locked or
+either SDL_MUTEX_TIMEDOUT or -1
+if the thread would have suspended or there was an error, respectivly.
If the semaphore was not successfully locked, the semaphore will be unchanged.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemvalue.html b/lib/sdl/msvc/docs/html/sdlsemvalue.html
new file mode 100644
index 0000000000000000000000000000000000000000..7867369b1b496e0de3c26969fa7e29b413a57ac8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemvalue.html
@@ -0,0 +1,273 @@
+SDL_SemValue
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemwait.html b/lib/sdl/msvc/docs/html/sdlsemwait.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e98d552ee60e0155213a7b064b1519f671b7329
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemwait.html
@@ -0,0 +1,298 @@
+SDL_SemWait
SDL_SemWait -- Lock a semaphore and suspend the thread if the semaphore value is zero.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemWait(SDL_sem *sem);
Description
SDL_SemWait() suspends the calling thread until either
+the semaphore pointed to by sem has a positive value,
+the call is interrupted by a signal or error. If the call is successful it
+will atomically decrement the semaphore value.
After SDL_SemWait() is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if successful or
+-1 if there was an error (leaving the semaphore unchanged).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html b/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html
new file mode 100644
index 0000000000000000000000000000000000000000..788f5b7250645a14e763af26d61a228b4cc29520
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html
@@ -0,0 +1,322 @@
+SDL_SemWaitTimeout
SDL_SemWaitTimeout -- Lock a semaphore, but only wait up to a specified maximum time.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout);
Description
SDL_SemWaitTimeout() is a varient of
+SDL_SemWait
+with a maximum timeout value.
+If the value of the semaphore pointed to by sem is
+positive (greater than zero) it will atomically decrement the semaphore value
+and return 0, otherwise it will wait up to timeout
+milliseconds trying to lock the semaphore. This function is to be avoided if
+possible since on some platforms it is implemented by polling the semaphore
+every millisecond in a busy loop.
After SDL_SemWaitTimeout() is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if the semaphore was successfully locked or
+either SDL_MUTEX_TIMEDOUT or -1
+if the timeout period was exceeded or there was an error, respectivly.
If the semaphore was not successfully locked, the semaphore will be unchanged.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetalpha.html b/lib/sdl/msvc/docs/html/sdlsetalpha.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc844981f14fd8bb3cd4ed62dc648847faf494a3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetalpha.html
@@ -0,0 +1,500 @@
+SDL_SetAlpha
SDL_SetAlpha -- Adjust the alpha properties of a surface
Synopsis
#include "SDL.h"
int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
Description
Note: This function and the semantics of SDL alpha blending have changed since version 1.1.4. Up until version 1.1.5, an alpha value of 0 was considered opaque and a value of 255 was considered transparent. This has now been inverted: 0 (SDL_ALPHA_TRANSPARENT) is now considered transparent and 255 (SDL_ALPHA_OPAQUE) is now considered opaque.
SDL_SetAlpha is used for setting the per-surface alpha
+value and/or enabling and disabling alpha blending.
Thesurface parameter specifies which surface whose alpha
+attributes you wish to adjust. flags is used to specify
+whether alpha blending should be used (SDL_SRCALPHA) and
+whether the surface should use RLE acceleration for blitting
+(SDL_RLEACCEL). flags can be an OR'd
+combination of these two options, one of these options or 0. If
+SDL_SRCALPHA is not passed as a flag then all alpha
+information is ignored when blitting the surface. The
+alpha parameter is the per-surface alpha value; a
+surface need not have an alpha channel to use per-surface alpha and blitting
+can still be accelerated with SDL_RLEACCEL.
Note: The per-surface alpha value of 128 is considered a special case and
+is optimised, so it's much faster than other per-surface values.
Alpha effects surface blitting in the following ways:
RGBA->RGB with SDL_SRCALPHA
The source is alpha-blended with the destination, using the alpha channel. SDL_SRCCOLORKEY and the per-surface alpha are ignored.
RGBA->RGB without SDL_SRCALPHA
The RGB data is copied from the source. The source alpha channel and the per-surface alpha value are ignored.
RGB->RGBA with SDL_SRCALPHA
The source is alpha-blended with the destination using the per-surface alpha
+value. If SDL_SRCCOLORKEY is set, only the pixels not
+matching the colorkey value are copied. The alpha channel of the copied pixels
+is set to opaque.
RGB->RGBA without SDL_SRCALPHA
The RGB data is copied from the source and the alpha value of the copied pixels
+is set to opaque. If SDL_SRCCOLORKEY is set, only the pixels
+not matching the colorkey value are copied.
RGBA->RGBA with SDL_SRCALPHA
The source is alpha-blended with the destination using the source alpha
+channel. The alpha channel in the destination surface is left untouched.
+SDL_SRCCOLORKEY is ignored.
RGBA->RGBA without SDL_SRCALPHA
The RGBA data is copied to the destination surface. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
RGB->RGB with SDL_SRCALPHA
The source is alpha-blended with the destination using the per-surface alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
RGB->RGB without SDL_SRCALPHA
The RGB data is copied from the source. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
Note: Note that RGBA->RGBA blits (with SDL_SRCALPHA set) keep the alpha
+of the destination surface. This means that you cannot compose two arbitrary
+RGBA surfaces this way and get the result you would expect from "overlaying"
+them; the destination alpha will work as a mask.
Also note that per-pixel and per-surface alpha cannot be combined;
+the per-pixel alpha is always used if available
Return Value
This function returns 0, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcliprect.html b/lib/sdl/msvc/docs/html/sdlsetcliprect.html
new file mode 100644
index 0000000000000000000000000000000000000000..03898d55ace6cde337e4481443001b1c5ee67513
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcliprect.html
@@ -0,0 +1,241 @@
+SDL_SetClipRect
Sets the clipping rectangle for a surface. When this surface is the
+destination of a blit, only the area within the clip rectangle will be
+drawn into.
The rectangle pointed to by rect will be
+clipped to the edges of the surface so that the clip rectangle for a
+surface can never fall outside the edges of the surface.
If rect is NULL the clipping
+rectangle will be set to the full size of the surface.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcolorkey.html b/lib/sdl/msvc/docs/html/sdlsetcolorkey.html
new file mode 100644
index 0000000000000000000000000000000000000000..0cb6695791539b6004b87c972323cb65175ea3dd
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcolorkey.html
@@ -0,0 +1,321 @@
+SDL_SetColorKey
SDL_SetColorKey -- Sets the color key (transparent pixel) in a blittable surface and
+RLE acceleration.
Synopsis
#include "SDL.h"
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
Description
Sets the color key (transparent pixel) in a blittable surface and enables or
+ disables RLE blit acceleration.
RLE acceleration can substantially speed up blitting of images with large
+horizontal runs of transparent pixels (i.e., pixels that match the
+key value). The key must be of the same pixel format as the surface, SDL_MapRGB is often useful for obtaining an acceptable value.
If flag is SDL_SRCCOLORKEY then
+key is the transparent pixel value in the source image of a
+blit.
If flag is OR'd with
+SDL_RLEACCEL then the surface will be draw using RLE
+acceleration when drawn with
+SDL_BlitSurface. The surface will
+actually be encoded for RLE acceleration the first time
+SDL_BlitSurface or
+SDL_DisplayFormat is called on the
+surface.
If flag is 0, this function clears
+any current color key.
Return Value
This function returns 0, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcolors.html b/lib/sdl/msvc/docs/html/sdlsetcolors.html
new file mode 100644
index 0000000000000000000000000000000000000000..569564598ba819d7de1415d9e2278ef4c5deec6f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcolors.html
@@ -0,0 +1,358 @@
+SDL_SetColors
SDL_SetColors -- Sets a portion of the colormap for the given 8-bit surface.
Synopsis
#include "SDL.h"
int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors);
Description
Sets a portion of the colormap for the given 8-bit surface.
When surface is the surface associated with the current
+display, the display colormap will be updated with the requested colors. If
+SDL_HWPALETTE was set in SDL_SetVideoMode flags,
+SDL_SetColors will always return 1,
+and the palette is guaranteed to be set the way you desire, even if the window
+colormap has to be warped or run under emulation.
The color components of a
+SDL_Color
+structure are 8-bits in size, giving you a total of 2563
+=16777216 colors.
Palettized (8-bit) screen surfaces with the SDL_HWPALETTE
+flag have two palettes, a logical palette that is used for mapping blits
+to/from the surface and a physical palette (that determines how the
+hardware will map the colors to the display). SDL_SetColors
+modifies both palettes (if present), and is equivalent to calling
+SDL_SetPalette with the
+flags set to
+(SDL_LOGPAL | SDL_PHYSPAL).
Return Value
If surface is not a palettized surface, this function
+does nothing, returning 0. If all of the colors were set
+as passed to SDL_SetColors, it will return
+1. If not all the color entries were set exactly as
+given, it will return 0, and you should look at the
+surface palette to determine the actual color palette.
Example
/* Create a display surface with a grayscale palette */
+SDL_Surface *screen;
+SDL_Color colors[256];
+int i;
+.
+.
+.
+/* Fill colors with color information */
+for(i=0;i<256;i++){
+ colors[i].r=i;
+ colors[i].g=i;
+ colors[i].b=i;
+}
+
+/* Create display */
+screen=SDL_SetVideoMode(640, 480, 8, SDL_HWPALETTE);
+if(!screen){
+ printf("Couldn't set video mode: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+/* Set palette */
+SDL_SetColors(screen, colors, 0, 256);
+.
+.
+.
+.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcursor.html b/lib/sdl/msvc/docs/html/sdlsetcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..9c5443e53e7f16a94039166cbb15b62cedb45d7b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcursor.html
@@ -0,0 +1,222 @@
+SDL_SetCursor
SDL_SetCursor -- Set the currently active mouse cursor.
Synopsis
#include "SDL.h"
void SDL_SetCursor(SDL_Cursor *cursor);
Description
Sets the currently active cursor to
+the specified one.
+If the cursor is currently visible, the change will be immediately
+represented on the display.
SDL_SetEventFilter -- Sets up a filter to process all events before they are posted
+to the event queue.
Synopsis
#include "SDL.h"
void SDL_SetEventFilter(SDL_EventFilter filter);
Description
This function sets up a filter to process all events before they are posted
+to the event queue. This is a very powerful and flexible feature. The filter
+is prototyped as:
+
typedef int (*SDL_EventFilter)(const SDL_Event *event);
+If the filter returns 1, then the event will be
+added to the internal queue. If it returns 0,
+then the event will be dropped from the queue. This allows selective
+filtering of dynamically.
There is one caveat when dealing with the SDL_QUITEVENT event type. The
+event filter is only called when the window manager desires to close the
+application window. If the event filter returns 1, then the window will
+be closed, otherwise the window will remain open if possible.
+If the quit event is generated by an interrupt signal, it will bypass the
+internal queue and be delivered to the application at the next event poll.
Note: Events pushed onto the queue with SDL_PushEvent or SDL_PeepEvents do not get passed through the event filter.
Note: Be Careful! The event filter function may run in a different thread so be careful what you do within it.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetgamma.html b/lib/sdl/msvc/docs/html/sdlsetgamma.html
new file mode 100644
index 0000000000000000000000000000000000000000..6443a966a2bad65dc5e5606b57c7687a083663ea
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetgamma.html
@@ -0,0 +1,231 @@
+SDL_SetGamma
SDL_SetGamma -- Sets the color gamma function for the display
Synopsis
#include "SDL.h"
int SDL_SetGamma(float redgamma, float greengamma, float bluegamma);
Description
Sets the "gamma function" for the display of each color component. Gamma
+controls the brightness/contrast of colors displayed on the screen.
+A gamma value of 1.0 is identity (i.e., no adjustment
+is made).
This function adjusts the gamma based on the "gamma function" parameter,
+you can directly specify lookup tables for gamma adjustment with
+SDL_SetGammaRamp.
Not all display hardware is able to change gamma.
Return Value
Returns -1 on error (or if gamma adjustment is not supported).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetgammaramp.html b/lib/sdl/msvc/docs/html/sdlsetgammaramp.html
new file mode 100644
index 0000000000000000000000000000000000000000..79599c8d5163d23aca459656b38a17bda2252dce
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetgammaramp.html
@@ -0,0 +1,230 @@
+SDL_SetGammaRamp
SDL_SetGammaRamp -- Sets the color gamma lookup tables for the display
Synopsis
#include "SDL.h"
int SDL_SetGammaRamp(Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable);
Description
Sets the gamma lookup tables for the display for each color component.
+Each table is an array of 256 Uint16 values, representing a mapping
+between the input and output for that channel. The input is the index
+into the array, and the output is the 16-bit gamma value at that index,
+scaled to the output color precision. You may pass NULL to any of the
+channels to leave them unchanged.
This function adjusts the gamma based on lookup tables, you can also
+have the gamma calculated based on a "gamma function" parameter with
+SDL_SetGamma.
Not all display hardware is able to change gamma.
Return Value
Returns -1 on error (or if gamma adjustment is not supported).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetmodstate.html b/lib/sdl/msvc/docs/html/sdlsetmodstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..ee69a3f5dfeb5a82e4ec382de8f36e1ba0bd661b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetmodstate.html
@@ -0,0 +1,237 @@
+SDL_SetModState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetpalette.html b/lib/sdl/msvc/docs/html/sdlsetpalette.html
new file mode 100644
index 0000000000000000000000000000000000000000..1622f1590fb71c118ad5082ba37e0f571316672d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetpalette.html
@@ -0,0 +1,352 @@
+SDL_SetPalette
SDL_SetPalette -- Sets the colors in the palette of an 8-bit surface.
Synopsis
#include "SDL.h"
int SDL_SetPalette(SDL_Surface *surface, int flags, SDL_Color *colors, int firstcolor, int ncolors);
Description
Sets a portion of the palette for the given 8-bit surface.
Palettized (8-bit) screen surfaces with the
+SDL_HWPALETTE flag have two palettes, a logical
+palette that is used for mapping blits to/from the surface and a
+physical palette (that determines how the hardware will map the colors
+to the display). SDL_BlitSurface
+always uses the logical palette when blitting surfaces (if it has to
+convert between surface pixel formats). Because of this, it is often
+useful to modify only one or the other palette to achieve various
+special color effects (e.g., screen fading, color flashes, screen dimming).
This function can modify either the logical or physical palette by
+specifing SDL_LOGPAL or
+SDL_PHYSPALthe in the flags
+parameter.
When surface is the surface associated with the current
+display, the display colormap will be updated with the requested colors. If
+SDL_HWPALETTE was set in SDL_SetVideoMode flags,
+SDL_SetPalette will always return 1,
+and the palette is guaranteed to be set the way you desire, even if the window
+colormap has to be warped or run under emulation.
The color components of a
+SDL_Color structure
+are 8-bits in size, giving you a total of
+2563=16777216 colors.
Return Value
If surface is not a palettized surface, this function
+does nothing, returning 0. If all of the colors were set
+as passed to SDL_SetPalette, it will return
+1. If not all the color entries were set exactly as
+given, it will return 0, and you should look at the
+surface palette to determine the actual color palette.
Example
/* Create a display surface with a grayscale palette */
+ SDL_Surface *screen;
+ SDL_Color colors[256];
+ int i;
+ .
+ .
+ .
+ /* Fill colors with color information */
+ for(i=0;i<256;i++){
+ colors[i].r=i;
+ colors[i].g=i;
+ colors[i].b=i;
+ }
+
+ /* Create display */
+ screen=SDL_SetVideoMode(640, 480, 8, SDL_HWPALETTE);
+ if(!screen){
+ printf("Couldn't set video mode: %s\n", SDL_GetError());
+ exit(-1);
+ }
+
+ /* Set palette */
+ SDL_SetPalette(screen, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256);
+ .
+ .
+ .
+ .
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsettimer.html b/lib/sdl/msvc/docs/html/sdlsettimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..40b737ce85345f466591d5c0978d162b274d9601
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsettimer.html
@@ -0,0 +1,267 @@
+SDL_SetTimer
SDL_SetTimer -- Set a callback to run after the specified number of milliseconds has
+elapsed.
Synopsis
#include "SDL.h"
int SDL_SetTimer(Uint32 interval, SDL_TimerCallback callback);
Callback
/* Function prototype for the timer callback function */
+typedef Uint32 (*SDL_TimerCallback)(Uint32 interval);
Description
Set a callback to run after the specified number of milliseconds has
+elapsed. The callback function is passed the current timer interval
+and returns the next timer interval. If the returned value is the
+same as the one passed in, the periodic alarm continues, otherwise a
+new alarm is scheduled.
To cancel a currently running timer, call
+SDL_SetTimer(0, NULL);
The timer callback function may run in a different thread than your
+main constant, and so shouldn't call any functions from within itself.
The maximum resolution of this timer is 10 ms, which means that if
+you request a 16 ms timer, your callback will run approximately 20 ms
+later on an unloaded system. If you wanted to set a flag signaling
+a frame update at 30 frames per second (every 33 ms), you might set a
+timer for 30 ms (see example below).
If you use this function, you need to pass SDL_INIT_TIMER
+to SDL_Init().
Note: This function is kept for compatibility but has been superseded
+by the new timer functions
+SDL_AddTimer and
+SDL_RemoveTimer which support
+multiple timers.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetvideomode.html b/lib/sdl/msvc/docs/html/sdlsetvideomode.html
new file mode 100644
index 0000000000000000000000000000000000000000..8b309b048f70c7c66bce0ddb4f817e8c1c93cbd6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetvideomode.html
@@ -0,0 +1,558 @@
+SDL_SetVideoMode
SDL_SetVideoMode -- Set up a video mode with the specified width, height and bits-per-pixel.
Synopsis
#include "SDL.h"
SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags);
Description
Set up a video mode with the specified width, height and bits-per-pixel.
If bpp is 0, it is treated as the
+current display bits per pixel.
The flags parameter is the same as the flags field of the SDL_Surface structure. OR'd combinations of the following values are valid.
SDL_SWSURFACE
Create the video surface in system memory
SDL_HWSURFACE
Create the video surface in video memory
SDL_ASYNCBLIT
Enables the use of asynchronous updates of the display surface. This will
+usually slow down blitting on single CPU machines, but may provide a speed
+increase on SMP systems.
SDL_ANYFORMAT
Normally, if a video surface of the requested bits-per-pixel (bpp) is not available, SDL will emulate one with a shadow surface. Passing SDL_ANYFORMAT prevents this and causes SDL to use the video surface, regardless of its pixel depth.
SDL_HWPALETTE
Give SDL exclusive palette access. Without this flag you may not always get the the colors you request with SDL_SetColors or SDL_SetPalette.
SDL_DOUBLEBUF
Enable hardware double buffering; only valid with SDL_HWSURFACE. Calling
+SDL_Flip will flip the
+buffers and update the screen. All drawing will take place on the surface
+that is not displayed at the moment. If double buffering could not be enabled
+then SDL_Flip will just perform a
+SDL_UpdateRect
+on the entire screen.
SDL_FULLSCREEN
SDL will attempt to use a fullscreen mode. If a hardware resolution change is
+not possible (for whatever reason), the next higher resolution will be used and
+the display window centered on a black background.
SDL_OPENGL
Create an OpenGL rendering context. You should have previously set OpenGL video attributes with SDL_GL_SetAttribute.
SDL_OPENGLBLIT
Create an OpenGL rendering context, like above, but allow normal blitting
+operations. The screen (2D) surface may have an alpha channel, and
+SDL_UpdateRects
+must be used for updating changes to the screen surface. NOTE: This option
+is kept for compatibility only, and is not recommended for
+new code.
SDL_RESIZABLE
Create a resizable window. When the window is resized by the user a SDL_VIDEORESIZE event is generated and SDL_SetVideoMode can be called again with the new size.
SDL_NOFRAME
If possible, SDL_NOFRAME causes SDL to create a window with no title bar or frame decoration. Fullscreen modes automatically have this flag set.
Note: Whatever flagsSDL_SetVideoMode could satisfy are set in the flags member of the returned surface.
Note: The bpp parameter is the number of bits per pixel,
+so a bpp of 24 uses the packed representation of
+3 bytes/pixel. For the more common 4 bytes/pixel mode, use a
+bpp of 32. Somewhat oddly, both 15 and 16 will
+request a 2 bytes/pixel mode, but different pixel formats.
Return Value
The framebuffer surface, or NULL if it fails.
+The surface returned is freed by SDL_Quit() and should nt be freed by
+the caller.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlshowcursor.html b/lib/sdl/msvc/docs/html/sdlshowcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..5a8f19da228eec679077943cb2e65bfc3c9ae13c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlshowcursor.html
@@ -0,0 +1,239 @@
+SDL_ShowCursor
SDL_ShowCursor -- Toggle whether or not the cursor is shown on the screen.
Synopsis
#include "SDL.h"
int SDL_ShowCursor(int toggle);
Description
Toggle whether or not the cursor is shown on the screen. Passing SDL_ENABLE displays the cursor and passing SDL_DISABLE hides it. The current state of the mouse cursor can be queried by passing SDL_QUERY, either SDL_DISABLE or SDL_ENABLE will be returned.
The cursor starts off displayed, but can be turned off.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsurface.html b/lib/sdl/msvc/docs/html/sdlsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..fda55f173fd01a0bcc6338d8f1b9252a7a758ef6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsurface.html
@@ -0,0 +1,597 @@
+SDL_Surface
SDL_Surface's represent areas of "graphical"
+memory, memory that can be drawn to. The video framebuffer is returned
+as a SDL_Surface by
+SDL_SetVideoMode
+and SDL_GetVideoSurface.
+Most of the fields should be pretty obvious.
+w and h are the
+width and height of the surface in pixels.
+pixels is a pointer to the actual pixel data,
+the surface should be locked
+before accessing this field. The clip_rect field
+is the clipping rectangle as set by
+SDL_SetClipRect.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsyswmevent.html b/lib/sdl/msvc/docs/html/sdlsyswmevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..fd7180ee218dd425cbd3a9384b69cfddbf708d70
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsyswmevent.html
@@ -0,0 +1,233 @@
+SDL_SysWMEvent
The system window manager event contains a pointer to system-specific
+information about unknown window manager events. If you enable this event
+using
+SDL_EventState(),
+it will be generated whenever unhandled events are received from the window
+manager. This can be used, for example, to implement cut-and-paste in your
+application.
+
+
+
+If you want to obtain system-specific information about the window manager,
+you can fill the version member of a SDL_SysWMinfo
+structure (details can be found in SDL_syswm.h, which must be included) using the SDL_VERSION() macro found in
+SDL_version.h, and pass it to the
+function:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlthreadid.html b/lib/sdl/msvc/docs/html/sdlthreadid.html
new file mode 100644
index 0000000000000000000000000000000000000000..e0bde2e2a3598786acf965f78d728bbc64a9c95c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlthreadid.html
@@ -0,0 +1,190 @@
+SDL_ThreadID
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlockaudio.html b/lib/sdl/msvc/docs/html/sdlunlockaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..0019bd692a0c956b558fb3ab7743e4485cad20d7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlockaudio.html
@@ -0,0 +1,211 @@
+SDL_UnlockAudio
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlocksurface.html b/lib/sdl/msvc/docs/html/sdlunlocksurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..13ba5fc8e2b0e63c316761e6ad038bfbab3e4e7e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlocksurface.html
@@ -0,0 +1,219 @@
+SDL_UnlockSurface
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..936ed9eaf7e100ca60d97ffb888e76183718428a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html
@@ -0,0 +1,225 @@
+SDL_UnlockYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlupdaterect.html b/lib/sdl/msvc/docs/html/sdlupdaterect.html
new file mode 100644
index 0000000000000000000000000000000000000000..f54d9f5e24366ba24e4ebdf4626a2b2edc95c763
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlupdaterect.html
@@ -0,0 +1,266 @@
+SDL_UpdateRect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlupdaterects.html b/lib/sdl/msvc/docs/html/sdlupdaterects.html
new file mode 100644
index 0000000000000000000000000000000000000000..0553a7a9d06f35e745e63bb5de3d5e46b6175d19
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlupdaterects.html
@@ -0,0 +1,255 @@
+SDL_UpdateRects
SDL_UpdateRects -- Makes sure the given list of rectangles is updated on the given screen.
Synopsis
#include "SDL.h"
void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects);
Description
Makes sure the given list of rectangles is updated on the given screen.
+The rectangles must all be confined within the screen boundaries (no
+clipping is done).
This function should not be called while screen is
+locked.
Note: It is adviced to call this function only once per frame, since each
+call has some processing overhead. This is no restriction since you
+can pass any number of rectangles each time.
The rectangles are not automatically merged or checked for overlap. In
+general, the programmer can use his knowledge about his particular
+rectangles to merge them in an efficient way, to avoid overdraw.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdluserevent.html b/lib/sdl/msvc/docs/html/sdluserevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..178769c51db324e05967f7c5d9987dcb4895ed5c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdluserevent.html
@@ -0,0 +1,337 @@
+SDL_UserEvent
SDL_UserEvent is in the user member of the structure SDL_Event. This event is unique, it is never created by SDL but only by the user. The event can be pushed onto the event queue using SDL_PushEvent. The contents of the structure members or completely up to the programmer, the only requirement is that type is a value from SDL_USEREVENT to SDL_NUMEVENTS-1 (inclusive).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideodrivername.html b/lib/sdl/msvc/docs/html/sdlvideodrivername.html
new file mode 100644
index 0000000000000000000000000000000000000000..141965623f19c9741cd73c9016d076aec76542cc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideodrivername.html
@@ -0,0 +1,243 @@
+SDL_VideoDriverName
SDL_VideoDriverName -- Obtain the name of the video driver
Synopsis
#include "SDL.h"
char *SDL_VideoDriverName(char *namebuf, int maxlen);
Description
The buffer pointed to by namebuf is filled up to a maximum of maxlen characters (include the NULL terminator) with the name of the initialised video driver. The driver name is a simple one word identifier like "x11" or "windib".
Return Value
Returns NULL if video has not been initialised with SDL_Init or a pointer to namebuf otherwise.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideoinfo.html b/lib/sdl/msvc/docs/html/sdlvideoinfo.html
new file mode 100644
index 0000000000000000000000000000000000000000..3a0da31dadb79a487229e24d6996d4cbc1045c89
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideoinfo.html
@@ -0,0 +1,408 @@
+SDL_VideoInfo
This (read-only) structure is returned by SDL_GetVideoInfo. It contains information on either the 'best' available mode (if called before SDL_SetVideoMode) or the current video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideomodeok.html b/lib/sdl/msvc/docs/html/sdlvideomodeok.html
new file mode 100644
index 0000000000000000000000000000000000000000..5d2d6c4eb956e9fa3374a1ebfcab5978b6a76a06
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideomodeok.html
@@ -0,0 +1,270 @@
+SDL_VideoModeOK
SDL_VideoModeOK -- Check to see if a particular video mode is supported.
Synopsis
#include "SDL.h"
int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
Description
SDL_VideoModeOK returns 0
+if the requested mode is not supported under any bit depth, or returns the
+bits-per-pixel of the closest available mode with the given width, height and requested surface flags (see SDL_SetVideoMode).
The bits-per-pixel value returned is only a suggested mode. You can usually request and bpp you want when setting the video mode and SDL will emulate that color depth with a shadow video surface.
The arguments to SDL_VideoModeOK are the same ones you
+would pass to SDL_SetVideoMode
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwaitevent.html b/lib/sdl/msvc/docs/html/sdlwaitevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..b473d3b06e35cb29b2990a8312822ec97ab75c29
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwaitevent.html
@@ -0,0 +1,231 @@
+SDL_WaitEvent
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwaitthread.html b/lib/sdl/msvc/docs/html/sdlwaitthread.html
new file mode 100644
index 0000000000000000000000000000000000000000..2becfbc47f1ee64b8e8710b403bc29b517253768
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwaitthread.html
@@ -0,0 +1,231 @@
+SDL_WaitThread
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwarpmouse.html b/lib/sdl/msvc/docs/html/sdlwarpmouse.html
new file mode 100644
index 0000000000000000000000000000000000000000..e7b2d8d79f6f5be220afdfaf9dd0dbfe7976ddca
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwarpmouse.html
@@ -0,0 +1,205 @@
+SDL_WarpMouse
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwasinit.html b/lib/sdl/msvc/docs/html/sdlwasinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..b4effeb6800c2a461478863d4dd7ec143e0e92ff
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwasinit.html
@@ -0,0 +1,284 @@
+SDL_WasInit
SDL_WasInit -- Check which subsystems are initialized
Synopsis
#include "SDL.h"
Uint32 SDL_WasInit(Uint32 flags);
Description
SDL_WasInit allows you to see which SDL subsytems have been initialized. flags is a bitwise OR'd combination of the subsystems you wish to check (see SDL_Init for a list of subsystem flags).
Return Value
SDL_WasInit returns a bitwised OR'd combination of the initialized subsystems.
Examples
/* Here are several ways you can use SDL_WasInit() */
+
+/* Get init data on all the subsystems */
+Uint32 subsystem_init;
+
+subsystem_init=SDL_WasInit(SDL_INIT_EVERYTHING);
+
+if(subsystem_init&SDL_INIT_VIDEO)
+ printf("Video is initialized.\n");
+else
+ printf("Video is not initialized.\n");
+
+
+
+/* Just check for one specfic subsystem */
+
+if(SDL_WasInit(SDL_INIT_VIDEO)!=0)
+ printf("Video is initialized.\n");
+else
+ printf("Video is not initialized.\n");
+
+
+
+
+/* Check for two subsystems */
+
+Uint32 subsystem_mask=SDL_INIT_VIDEO|SDL_INIT_AUDIO;
+
+if(SDL_WasInit(subsystem_mask)==subsystem_mask)
+ printf("Video and Audio initialized.\n");
+else
+ printf("Video and Audio not initialized.\n");
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmgetcaption.html b/lib/sdl/msvc/docs/html/sdlwmgetcaption.html
new file mode 100644
index 0000000000000000000000000000000000000000..829c68aaa1632b0dad9cf753f10ee63d6a6ca2bf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmgetcaption.html
@@ -0,0 +1,222 @@
+SDL_WM_GetCaption
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmgrabinput.html b/lib/sdl/msvc/docs/html/sdlwmgrabinput.html
new file mode 100644
index 0000000000000000000000000000000000000000..740dcd6b29a103573f97f05d6d00a9bdd52f8140
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmgrabinput.html
@@ -0,0 +1,224 @@
+SDL_WM_GrabInput
SDL_WM_GrabInput -- Grabs mouse and keyboard input.
Synopsis
#include "SDL.h"
SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode);
Description
Grabbing means that the mouse is confined to the application window,
+and nearly all keyboard input is passed directly to the application,
+and not interpreted by a window manager, if any.
When mode is SDL_GRAB_QUERY the grab mode is not changed, but the current grab mode is returned.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html b/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html
new file mode 100644
index 0000000000000000000000000000000000000000..11136568628006e9aa0c5a64b25b1d57b1825f71
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html
@@ -0,0 +1,211 @@
+SDL_WM_IconifyWindow
SDL_WM_IconifyWindow -- Iconify/Minimise the window
Synopsis
#include "SDL.h"
int SDL_WM_IconifyWindow(void);
Description
If the application is running in a window managed environment SDL attempts to iconify/minimise it. If SDL_WM_IconifyWindow is successful, the application will receive a SDL_APPACTIVE loss event.
Return Value
Returns non-zero on success or 0 if iconification is not support or was refused by the window manager.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmsetcaption.html b/lib/sdl/msvc/docs/html/sdlwmsetcaption.html
new file mode 100644
index 0000000000000000000000000000000000000000..bc47c278bdbd8a5c151a3f3a8037e5b90bc82186
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmsetcaption.html
@@ -0,0 +1,212 @@
+SDL_WM_SetCaption
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmseticon.html b/lib/sdl/msvc/docs/html/sdlwmseticon.html
new file mode 100644
index 0000000000000000000000000000000000000000..12eb207c69bd71540a296f1d6dbddedbf2898e57
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmseticon.html
@@ -0,0 +1,260 @@
+SDL_WM_SetIcon
Sets the icon for the display window. Win32 icons must be 32x32.
This function must be called before the first call to
+SDL_SetVideoMode.
The mask is a bitmask that describes the shape of the
+icon. If mask is NULL, then the shape is determined by
+the colorkey of icon, if any, or makes the icon
+rectangular (no transparency) otherwise.
If mask is non-NULL, it points to a bitmap with bits set
+where the corresponding pixel should be visible. The format of the bitmap is as
+follows: Scanlines come in the usual top-down order. Each scanline consists of
+(width / 8) bytes, rounded up. The most significant bit of each byte represents
+the leftmost pixel.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html b/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html
new file mode 100644
index 0000000000000000000000000000000000000000..b7973de551d585884f2ad57d38802b4919991bbc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html
@@ -0,0 +1,205 @@
+SDL_WM_ToggleFullScreen
int SDL_WM_ToggleFullScreen(SDL_Surface *surface);
Description
Toggles the application between windowed and fullscreen mode, if supported. (X11 is the only target currently supported, BeOS support is experimental).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/thread.html b/lib/sdl/msvc/docs/html/thread.html
new file mode 100644
index 0000000000000000000000000000000000000000..c66018eff237ff05b063bf28a4b4403d527277a6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/thread.html
@@ -0,0 +1,313 @@
+Multi-threaded Programming
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/time.html b/lib/sdl/msvc/docs/html/time.html
new file mode 100644
index 0000000000000000000000000000000000000000..854b7cb57e9d1764d41166777ceea8e28e1bc121
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/time.html
@@ -0,0 +1,206 @@
+Time
SDL_SetTimer -- Set a callback to run after the specified number of milliseconds has
+elapsed.
SDL provides several cross-platform functions for dealing with time.
+It provides a way to get the current time, a way to wait a little while,
+and a simple timer mechanism. These functions give you two ways of moving an
+object every x milliseconds:
+
+
Use a timer callback function. This may have the bad effect that it runs in a seperate thread or uses alarm signals, but it's easier to implement.
Or you can get the number of milliseconds passed, and move the object if, for example, 30 ms passed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/video.html b/lib/sdl/msvc/docs/html/video.html
new file mode 100644
index 0000000000000000000000000000000000000000..9b1434e62da948dda0dc5ba808e969ba316ff09d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/video.html
@@ -0,0 +1,507 @@
+Video
SDL presents a very simple interface to the display framebuffer. The
+framebuffer is represented as an offscreen surface to which you can write
+directly. If you want the screen to show what you have written, call the update function which will
+guarantee that the desired portion of the screen is updated.
Before you call any of the SDL video functions, you must first call
+SDL_Init(SDL_INIT_VIDEO), which initializes the video
+and events in the SDL library. Check the return code, which should be
+0, to see if there were any errors in starting up.
If you use both sound and video in your application, you need to call
+SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) before opening the
+sound device, otherwise under Win32 DirectX, you won't be able to set
+full-screen display modes.
After you have initialized the library, you can start up the video display in a
+number of ways. The easiest way is to pick a common screen resolution and
+depth and just initialize the video, checking for errors. You will probably
+get what you want, but SDL may be emulating your requested mode and converting
+the display on update. The best way is to
+query, for the best
+video mode closest to the desired one, and then
+convert
+your images to that pixel format.
SDL currently supports any bit depth >= 8 bits per pixel. 8 bpp formats are
+considered 8-bit palettized modes, while 12, 15, 16, 24, and 32 bits per pixel
+are considered "packed pixel" modes, meaning each pixel contains the RGB color
+components packed in the bits of the pixel.
After you have initialized your video mode, you can take the surface that was
+returned, and write to it like any other framebuffer, calling the update
+routine as you go.
When you have finished your video access and are ready to quit your
+application, you should call "SDL_Quit()" to shutdown the
+video and events.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/wm.html b/lib/sdl/msvc/docs/html/wm.html
new file mode 100644
index 0000000000000000000000000000000000000000..f53a349c1658adb84fa13245387303caf4459b32
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/wm.html
@@ -0,0 +1,188 @@
+Window Management
SDL provides a small set of window management functions which allow applications to change their title and toggle from windowed mode to fullscreen (if available)
+This library is designed to make it easy to write games that run on many
+different platforms using the various native high-performance media interfaces,
+(for video, audio, etc) and presenting a single source-code level API to
+your application. This is a fairly low level API, but using this, completely
+portable applications can be written with a great deal of flexibility.
+
![[separator]](docs/images/rainbow.gif)
+