rubygl 0.2.1 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWE2NTJjYThmM2M2MGM0MmUwNmE5NTk1YmQxOTFiMTI5YTZkZjEzYg==
+    YjhjOWZmYTUyMDE3ZGRjYjdmYzU1MGQ5Yjk0MTcyMmIzYTY4MDgwZA==
   data.tar.gz: !binary |-
-    ZDRmMDFhZmI3MjJkZDEwZTgwMDg2N2I4NGI2YmFmOGRjOTg5MjUxYQ==
+    NjhhZTFiY2I5ZjM5OWQ2ZjEzZjY5NGZmY2E3Zjg3YzlmOTI3NzYyYw==
 SHA512:
   metadata.gz: !binary |-
-    YjA1NWMzYzI1YTZiM2E2ZWEyYWI0NDUxYmM5ZmVlY2UyYThkOGU5M2RlN2Nk
-    NDlhZjA3NGUwMWQ1ZTMzOTE4M2Q2MmI3OTg0NDM1ZWYyNTVmMzgyY2I2NjJk
-    ODUzNGU0YTE5ZjFhYzY4OTFlYWJlYzgyYzI5YjQ0NWY0N2Q2OGI=
+    NzBiNmJlZWFmNmQ5OTc2ZTEyNTkwZjk5MWRkMDIyODA0MWI5ZWU0OWQ0YWU5
+    OGQ4MjVmMGQ1MWEwMDQzYmQ4ZjczMWY1ZjZjM2RhYTEyNmIzNTA3Mzg5ZmEz
+    OTAxNWVlMTVmYWYzZTQ4N2I2NDU0MTJjNGYxNzk3NTI0YzVhMDM=
   data.tar.gz: !binary |-
-    ODNkNTRmZmUxMTVmODU4OWUxMmMwZGNiM2Q1YzBlNjE5NGJiZjc4MmRjODk1
-    NjNlMTMxYTlhNzQ3OWZkZGEzOWNjZWE1ZjE0ZDFmODk0OWYyZTFhYmYyNDcx
-    MDhmZGFhNWY1ODA5OTNhN2JkMTgyMmIyY2Y0MjMxZDllNmMzNzY=
+    MWI0YzY2ZWJlOWI2NDU2MDJiMGMyNjUxZGRiNzMwNDY3YzlkMDJkZDExNDIw
+    N2NjNmQwN2E1ZmNhNGQ5ZTYyYWJlNWE4YTI1Njc5MjMwZjQ3Y2UwODY0Nzll
+    YmIyMTI2N2QxYTNkMzJmMWFiY2U3MzM0NWY5MTVlNjVmZDY3YmM=

data/Gemfile.lock

@@ -1,10 +1,12 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    ffi (1.9.5)
     ffi (1.9.5-x86-mingw32)
     rake (0.9.6)
 
 PLATFORMS
+  ruby
   x86-mingw32
 
 DEPENDENCIES

data/README.md

@@ -4,6 +4,7 @@ A Complete Solution For Graphics Programming In Ruby.
 
 Installing - [![Gem Version](https://badge.fury.io/rb/rubygl.svg)](http://badge.fury.io/rb/rubygl)
 ----------
+Currently supports Windows and MacOSX out of the box.
 ```
 gem install rubygl
 ```
@@ -34,7 +35,6 @@ https://www.opengl.org/sdk/docs/man/ to see which functions are supported by eac
 
 Known Issues
 ------------
-- Only supports Windows at the moment (OSX support coming soon)
 - Not sure how to support Linux without requiring users to compile a shared library
 - Windows does not guarantee that OpenGL functions loaded during context creation will be valid for other contexts
  - Need to figure out how to efficiently swap these out if the user creates more than one context

data/Rakefile

@@ -3,9 +3,8 @@ require 'rake/testtask'
 require 'tmpdir'
 
 # Dependency Locations
-SDL_INCLUDE = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\include\SDL2'
-SDL_LIB = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\lib'
-SDL_BIN = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\bin'
+SDL_INCLUDE = 'ext/macosx/SDL2.framework/Headers'
+SDL_LIB = 'ext/macosx'
 
 # C File Locations
 PROJ_INCLUDE = 'lib/rubygl/native/include/'
@@ -26,7 +25,7 @@ def os
             when /solaris|bsd/
                 :unix
             else
-                raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+                raise Error::WebDriverError, "Unknown OS: #{host_os.inspect}"
         end
     )
 end
@@ -37,19 +36,28 @@ task :default => [:bindings, :build, :clean]
 
 # Builds The RubyGL Shared Library From C Source Files And SDL Library
 task :build do
-    files = ['Window', 'GLContext', 'Input', 'OpenGL']
+    files = ['Window', 'GLContext', 'Input']
+    
+    # OpenGL Function On macosx Are Already Loaded
+    files << 'OpenGL' if os == :windows || os == :linux
     
     # Build Object Files
-    obj = "gcc -I#{SDL_INCLUDE}  -I#{PROJ_INCLUDE} -c -fPIC REPLACE.c -o REPLACE.o"
+    obj = "gcc -I#{SDL_INCLUDE} -I#{PROJ_INCLUDE} -c -fPIC REPLACE.c -o REPLACE.o"
     files.each { |file|
         sh (obj.gsub(/REPLACE/, PROJ_SRC + file))
         file = file.prepend PROJ_SRC
     }
 
     # Build Shared Object File
-    bin = "gcc -L#{SDL_LIB} #{files.join('.o ') << '.o'} -lSDL2main -lSDL2 \
-           -lopengl32 -shared -o ext/#{os.to_s}/RubyGL.so"
-    sh bin 
+    if os == :windows
+        sh "gcc -o ext/windows/RubyGL.so #{files.join('.o ') << '.o'} \
+        -shared -L#{SDL_LIB} -lSDL2main -lSDL2"
+    elsif os == :macosx
+        sh "gcc -o ext/macosx/RubyGL.so #{files.join('.o ') << '.o'} \
+        -shared -Fext/macosx -framework SDL2"
+    else
+        abort("No Library Build Command For Current OS")
+    end
 end
 
 # Created The Documentation For The Library

data/bin/ffi_code_gen.rb

@@ -34,8 +34,8 @@ FFI_TYPES = { 'char' => 'char', 'signed char' => 'char',
 'uint16_t' => 'uint16', 'int' => 'int', 'unsigned int' => 'uint', 
 'int32_t' => 'int32', 'uint32_t' => 'uint32', 'long int' => 'long', 
 'unsigned long int' => 'ulong', 'int64_t' => 'int64', 'uint64_t' => 'uint64', 
-'long long int' => 'long_long', 'unsigned long long int' => 'ulong_long', 
-'float' => 'float', 'double' => 'double' }
+'long long int' => 'long_long', 'unsigned long long' => 'ulong_long', 
+'unsigned long long int' => 'ulong_long', 'float' => 'float', 'double' => 'double' }
 FFI_PTR_TYPES = { /\Aconst +(?:unsigned +)?char *\*\Z/ => 'string', /\*/ => 'pointer' }
 
 # Open Pre-Processor(ed) Source File
@@ -80,6 +80,14 @@ gl_functions = source_code.scan(/^.+?gl.+?\(.*?\);$/)
 ffi_template = "require 'ffi'
 
 module RubyGL::Native
+    def self.unsafe_attach_function(func, args, returns, options = {})
+        begin
+            attach_function func, args, returns, options
+        rescue FFI::NotFoundError
+            # Ignore Functions Not Found
+        end
+    end
+
 FUNCTIONS_GO_HERE
     
 CONSTANTS_GO_HERE
@@ -89,7 +97,7 @@ end
 # Append Functions (Param Type -> Typedefs -> Ruby Type)
 buffer = ''
 gl_functions.each { |signature|
-    buffer << ' ' * SOURCE_INDENTS + 'attach_function :' +
+    buffer << ' ' * SOURCE_INDENTS + 'unsafe_attach_function :' +
         signature[/(gl.*?)\(.*?\);/, 1] + ', ['
 
     # Get Type List

data/ext/macosx/SDL2.framework/Headers/SDL.h

@@ -0,0 +1,163 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/**
+ *  \file SDL.h
+ *
+ *  Main include header for the SDL library
+ */
+
+/**
+ *  \mainpage Simple DirectMedia Layer (SDL)
+ *
+ *  http://www.libsdl.org/
+ *
+ *  \section intro_sec Introduction
+ *
+ *  Simple DirectMedia Layer is a cross-platform development library designed
+ *  to provide low level access to audio, keyboard, mouse, joystick, and
+ *  graphics hardware via OpenGL and Direct3D. It is used by video playback
+ *  software, emulators, and popular games including Valve's award winning
+ *  catalog and many Humble Bundle games.
+ *
+ *  SDL officially supports Windows, Mac OS X, Linux, iOS, and Android.
+ *  Support for other platforms may be found in the source code.
+ *
+ *  SDL is written in C, works natively with C++, and there are bindings 
+ *  available for several other languages, including C# and Python.
+ *
+ *  This library is distributed under the zlib license, which can be found
+ *  in the file "COPYING.txt".
+ *
+ *  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 and FAQs are available online at:
+ *      http://wiki.libsdl.org/
+ *
+ *  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)
+ */
+
+#ifndef _SDL_H
+#define _SDL_H
+
+#include "SDL_main.h"
+#include "SDL_stdinc.h"
+#include "SDL_assert.h"
+#include "SDL_atomic.h"
+#include "SDL_audio.h"
+#include "SDL_clipboard.h"
+#include "SDL_cpuinfo.h"
+#include "SDL_endian.h"
+#include "SDL_error.h"
+#include "SDL_events.h"
+#include "SDL_filesystem.h"
+#include "SDL_joystick.h"
+#include "SDL_gamecontroller.h"
+#include "SDL_haptic.h"
+#include "SDL_hints.h"
+#include "SDL_loadso.h"
+#include "SDL_log.h"
+#include "SDL_messagebox.h"
+#include "SDL_mutex.h"
+#include "SDL_power.h"
+#include "SDL_render.h"
+#include "SDL_rwops.h"
+#include "SDL_system.h"
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "SDL_version.h"
+#include "SDL_video.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* As of version 0.5, SDL is loaded dynamically into the application */
+
+/**
+ *  \name SDL_INIT_*
+ *
+ *  These are the flags which may be passed to SDL_Init().  You should
+ *  specify the subsystems which you will be using in your application.
+ */
+/* @{ */
+#define SDL_INIT_TIMER          0x00000001
+#define SDL_INIT_AUDIO          0x00000010
+#define SDL_INIT_VIDEO          0x00000020  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
+#define SDL_INIT_JOYSTICK       0x00000200  /**< SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */
+#define SDL_INIT_HAPTIC         0x00001000
+#define SDL_INIT_GAMECONTROLLER 0x00002000  /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
+#define SDL_INIT_EVENTS         0x00004000
+#define SDL_INIT_NOPARACHUTE    0x00100000  /**< Don't catch fatal signals */
+#define SDL_INIT_EVERYTHING ( \
+                SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
+                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER \
+            )
+/* @} */
+
+/**
+ *  This function initializes  the subsystems specified by \c flags
+ *  Unless the ::SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
+ *  signal handlers for some commonly ignored fatal signals (like SIGSEGV).
+ */
+extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
+
+/**
+ *  This function initializes specific SDL subsystems
+ */
+extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
+
+/**
+ *  This function cleans up specific SDL subsystems
+ */
+extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
+
+/**
+ *  This function returns a mask of the specified subsystems which have
+ *  previously been initialized.
+ *
+ *  If \c flags is 0, it returns a mask of all initialized subsystems.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
+
+/**
+ *  This function cleans up all initialized subsystems. You should
+ *  call it upon all exit conditions.
+ */
+extern DECLSPEC void SDLCALL SDL_Quit(void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_H */
+
+/* vi: set ts=4 sw=4 expandtab: */

data/ext/macosx/SDL2.framework/Headers/SDL_assert.h

@@ -0,0 +1,284 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_assert_h
+#define _SDL_assert_h
+
+#include "SDL_config.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef SDL_ASSERT_LEVEL
+#ifdef SDL_DEFAULT_ASSERT_LEVEL
+#define SDL_ASSERT_LEVEL SDL_DEFAULT_ASSERT_LEVEL
+#elif defined(_DEBUG) || defined(DEBUG) || \
+      (defined(__GNUC__) && !defined(__OPTIMIZE__))
+#define SDL_ASSERT_LEVEL 2
+#else
+#define SDL_ASSERT_LEVEL 1
+#endif
+#endif /* SDL_ASSERT_LEVEL */
+
+/*
+These are macros and not first class functions so that the debugger breaks
+on the assertion line and not in some random guts of SDL, and so each
+assert can have unique static variables associated with it.
+*/
+
+#if defined(_MSC_VER)
+/* Don't include intrin.h here because it contains C++ code */
+    extern void __cdecl __debugbreak(void);
+    #define SDL_TriggerBreakpoint() __debugbreak()
+#elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
+    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
+#elif defined(HAVE_SIGNAL_H)
+    #include <signal.h>
+    #define SDL_TriggerBreakpoint() raise(SIGTRAP)
+#else
+    /* How do we trigger breakpoints on this platform? */
+    #define SDL_TriggerBreakpoint()
+#endif
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 supports __func__ as a standard. */
+#   define SDL_FUNCTION __func__
+#elif ((__GNUC__ >= 2) || defined(_MSC_VER))
+#   define SDL_FUNCTION __FUNCTION__
+#else
+#   define SDL_FUNCTION "???"
+#endif
+#define SDL_FILE    __FILE__
+#define SDL_LINE    __LINE__
+
+/*
+sizeof (x) makes the compiler still parse the expression even without
+assertions enabled, so the code is always checked at compile time, but
+doesn't actually generate code for it, so there are no side effects or
+expensive checks at run time, just the constant size of what x WOULD be,
+which presumably gets optimized out as unused.
+This also solves the problem of...
+
+    int somevalue = blah();
+    SDL_assert(somevalue == 1);
+
+...which would cause compiles to complain that somevalue is unused if we
+disable assertions.
+*/
+
+#ifdef _MSC_VER  /* stupid /W4 warnings. */
+#define SDL_NULL_WHILE_LOOP_CONDITION (-1 == __LINE__)
+#else
+#define SDL_NULL_WHILE_LOOP_CONDITION (0)
+#endif
+
+#define SDL_disabled_assert(condition) \
+    do { (void) sizeof ((condition)); } while (SDL_NULL_WHILE_LOOP_CONDITION)
+
+typedef enum
+{
+    SDL_ASSERTION_RETRY,  /**< Retry the assert immediately. */
+    SDL_ASSERTION_BREAK,  /**< Make the debugger trigger a breakpoint. */
+    SDL_ASSERTION_ABORT,  /**< Terminate the program. */
+    SDL_ASSERTION_IGNORE,  /**< Ignore the assert. */
+    SDL_ASSERTION_ALWAYS_IGNORE  /**< Ignore the assert from now on. */
+} SDL_assert_state;
+
+typedef struct SDL_assert_data
+{
+    int always_ignore;
+    unsigned int trigger_count;
+    const char *condition;
+    const char *filename;
+    int linenum;
+    const char *function;
+    const struct SDL_assert_data *next;
+} SDL_assert_data;
+
+#if (SDL_ASSERT_LEVEL > 0)
+
+/* Never call this directly. Use the SDL_assert* macros. */
+extern DECLSPEC SDL_assert_state SDLCALL SDL_ReportAssertion(SDL_assert_data *,
+                                                             const char *,
+                                                             const char *, int)
+#if defined(__clang__)
+#if __has_feature(attribute_analyzer_noreturn)
+/* this tells Clang's static analysis that we're a custom assert function,
+   and that the analyzer should assume the condition was always true past this
+   SDL_assert test. */
+   __attribute__((analyzer_noreturn))
+#endif
+#endif
+;
+
+/* the do {} while(0) avoids dangling else problems:
+    if (x) SDL_assert(y); else blah();
+       ... without the do/while, the "else" could attach to this macro's "if".
+   We try to handle just the minimum we need here in a macro...the loop,
+   the static vars, and break points. The heavy lifting is handled in
+   SDL_ReportAssertion(), in SDL_assert.c.
+*/
+#define SDL_enabled_assert(condition) \
+    do { \
+        while ( !(condition) ) { \
+            static struct SDL_assert_data assert_data = { \
+                0, 0, #condition, 0, 0, 0, 0 \
+            }; \
+            const SDL_assert_state state = SDL_ReportAssertion(&assert_data, \
+                                                               SDL_FUNCTION, \
+                                                               SDL_FILE, \
+                                                               SDL_LINE); \
+            if (state == SDL_ASSERTION_RETRY) { \
+                continue; /* go again. */ \
+            } else if (state == SDL_ASSERTION_BREAK) { \
+                SDL_TriggerBreakpoint(); \
+            } \
+            break; /* not retrying. */ \
+        } \
+    } while (SDL_NULL_WHILE_LOOP_CONDITION)
+
+#endif  /* enabled assertions support code */
+
+/* Enable various levels of assertions. */
+#if SDL_ASSERT_LEVEL == 0   /* assertions disabled */
+#   define SDL_assert(condition) SDL_disabled_assert(condition)
+#   define SDL_assert_release(condition) SDL_disabled_assert(condition)
+#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
+#elif SDL_ASSERT_LEVEL == 1  /* release settings. */
+#   define SDL_assert(condition) SDL_disabled_assert(condition)
+#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
+#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
+#elif SDL_ASSERT_LEVEL == 2  /* normal settings. */
+#   define SDL_assert(condition) SDL_enabled_assert(condition)
+#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
+#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
+#elif SDL_ASSERT_LEVEL == 3  /* paranoid settings. */
+#   define SDL_assert(condition) SDL_enabled_assert(condition)
+#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
+#   define SDL_assert_paranoid(condition) SDL_enabled_assert(condition)
+#else
+#   error Unknown assertion level.
+#endif
+
+/* this assertion is never disabled at any level. */
+#define SDL_assert_always(condition) SDL_enabled_assert(condition)
+
+
+typedef SDL_assert_state (SDLCALL *SDL_AssertionHandler)(
+                                 const SDL_assert_data* data, void* userdata);
+
+/**
+ *  \brief Set an application-defined assertion handler.
+ *
+ *  This allows an app to show its own assertion UI and/or force the
+ *  response to an assertion failure. If the app doesn't provide this, SDL
+ *  will try to do the right thing, popping up a system-specific GUI dialog,
+ *  and probably minimizing any fullscreen windows.
+ *
+ *  This callback may fire from any thread, but it runs wrapped in a mutex, so
+ *  it will only fire from one thread at a time.
+ *
+ *  Setting the callback to NULL restores SDL's original internal handler.
+ *
+ *  This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
+ *
+ *  \return SDL_assert_state value of how to handle the assertion failure.
+ *
+ *  \param handler Callback function, called when an assertion fails.
+ *  \param userdata A pointer passed to the callback as-is.
+ */
+extern DECLSPEC void SDLCALL SDL_SetAssertionHandler(
+                                            SDL_AssertionHandler handler,
+                                            void *userdata);
+
+/**
+ *  \brief Get the default assertion handler.
+ *
+ *  This returns the function pointer that is called by default when an
+ *   assertion is triggered. This is an internal function provided by SDL,
+ *   that is used for assertions when SDL_SetAssertionHandler() hasn't been
+ *   used to provide a different function.
+ *
+ *  \return The default SDL_AssertionHandler that is called when an assert triggers.
+ */
+extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetDefaultAssertionHandler(void);
+
+/**
+ *  \brief Get the current assertion handler.
+ *
+ *  This returns the function pointer that is called when an assertion is
+ *   triggered. This is either the value last passed to
+ *   SDL_SetAssertionHandler(), or if no application-specified function is
+ *   set, is equivalent to calling SDL_GetDefaultAssertionHandler().
+ *
+ *   \param puserdata Pointer to a void*, which will store the "userdata"
+ *                    pointer that was passed to SDL_SetAssertionHandler().
+ *                    This value will always be NULL for the default handler.
+ *                    If you don't care about this data, it is safe to pass
+ *                    a NULL pointer to this function to ignore it.
+ *  \return The SDL_AssertionHandler that is called when an assert triggers.
+ */
+extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetAssertionHandler(void **puserdata);
+
+/**
+ *  \brief Get a list of all assertion failures.
+ *
+ *  Get all assertions triggered since last call to SDL_ResetAssertionReport(),
+ *  or the start of the program.
+ *
+ *  The proper way to examine this data looks something like this:
+ *
+ *  <code>
+ *  const SDL_assert_data *item = SDL_GetAssertionReport();
+ *  while (item) {
+ *      printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\n",
+ *             item->condition, item->function, item->filename,
+ *             item->linenum, item->trigger_count,
+ *             item->always_ignore ? "yes" : "no");
+ *      item = item->next;
+ *  }
+ *  </code>
+ *
+ *  \return List of all assertions.
+ *  \sa SDL_ResetAssertionReport
+ */
+extern DECLSPEC const SDL_assert_data * SDLCALL SDL_GetAssertionReport(void);
+
+/**
+ *  \brief Reset the list of all assertion failures.
+ *
+ *  Reset list of all assertions triggered.
+ *
+ *  \sa SDL_GetAssertionReport
+ */
+extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_assert_h */
+
+/* vi: set ts=4 sw=4 expandtab: */