model viewer: include SDL2 headers

.hgignore

@@ -15,6 +15,8 @@ syntax: glob
 *.hmt
 *.HOB
 *.HMT
+*_HOB
+*_HMT
 *.text
 *.tex
 *.pgm
@@ -22,4 +24,8 @@ syntax: glob
 *.pnm
 *.tga
 *.raw
+*.dat
+*.hdr
+*.DAT
+*.HDR
 imgui.ini

model_viewer/sdl2/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

model_viewer/sdl2/README.md

@@ -0,0 +1,4 @@
+Pascal-SDL-2-Headers
+====================
+
+This are the Pascal SDL 2 Headers.

model_viewer/sdl2/SDL2_gfx.pas

@@ -0,0 +1,559 @@
+unit SDL2_gfx;
+
+(*
+
+SDL2_framerate.h: framerate manager
+SDL2_gfxPrimitives.h: graphics primitives for SDL
+SDL2_imageFilter.h: byte-image "filter" routines 
+SDL2_rotozoom.h: rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces
+
+Copyright (C) 2001-2012  Andreas Schiffler
+
+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.
+
+Andreas Schiffler -- aschiffler at ferzkopp dot net
+
+*)
+
+{$INCLUDE jedi.inc}
+
+interface
+   uses SDL2;
+
+const
+  {$IFDEF WINDOWS}
+    GFX_LibName = 'SDL2_gfx.dll';
+  {$ENDIF}
+
+  {$IFDEF UNIX}
+    {$IFDEF DARWIN}
+      GFX_LibName = 'libSDL2_gfx.dylib';
+    {$ELSE}
+      {$IFDEF FPC}
+        GFX_LibName = 'libSDL2_gfx.so';
+      {$ELSE}
+        GFX_LibName = 'libSDL2_gfx.so.0';
+      {$ENDIF}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IFDEF MACOS}
+    GFX_LibName = 'SDL2_gfx';
+    {$IFDEF FPC}
+      {$linklib libSDL2_gfx}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IF DEFINED(DELPHI) AND DEFINED(MACOS)}
+     {$DEFINE DELMAC}
+  {$ENDIF}
+
+Procedure SDL_GFX_VERSION(Out X: TSDL_Version);
+
+{---< SDL2_framerate.h >---}
+
+Const
+   {*!
+    \brief Highest possible rate supported by framerate controller in Hz (1/s).
+    *}
+   FPS_UPPER_LIMIT = 200;
+
+   {*!
+    \brief Lowest possible rate supported by framerate controller in Hz (1/s).
+    *}
+   FPS_LOWER_LIMIT = 1;
+
+   {*!
+    \brief Default rate of framerate controller in Hz (1/s).
+    *}
+   FPS_DEFAULT = 30;
+
+Type
+   {*! 
+    \brief Structure holding the state and timing information of the framerate controller. 
+    *}
+   
+   TFPSManager = record
+      framecount : uInt32;
+      rateticks : Single; // float rateticks;
+      baseticks : uInt32;
+      lastticks : uInt32;
+      rate : uInt32;
+   end;
+   
+   PFPSManager = ^TFPSManager;
+
+Procedure SDL_initFramerate(manager: PFPSManager);
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_initFramerate' {$ENDIF};
+
+Function SDL_setFramerate(manager: PFPSManager; rate: uInt32):sInt32;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_setFramerate' {$ENDIF};
+   
+Function SDL_getFramerate(manager: PFPSManager):sInt32;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_getFramerate' {$ENDIF};
+   
+Function SDL_getFramecount(manager: PFPSManager):sInt32;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_getFramecount' {$ENDIF};
+
+Function SDL_framerateDelay(manager: PFPSManager):uInt32;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_framerateDelay' {$ENDIF};
+
+
+{---< SDL2_gfxPrimitives.h >---}
+
+Const
+   SDL2_GFXPRIMITIVES_MAJOR = 1;
+   SDL2_GFXPRIMITIVES_MINOR = 0;
+   SDL2_GFXPRIMITIVES_MICRO = 1;
+
+(* Note: all ___Color routines expect the colour to be in format 0xRRGGBBAA *)
+
+
+{* Pixel *}
+
+Function pixelColor(renderer: PSDL_Renderer; x, y: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_pixelColor' {$ENDIF};
+      
+Function pixelRGBA(renderer: PSDL_Renderer; x, y: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_pixelRGBA' {$ENDIF};
+
+{ Horizontal line }
+
+Function hlineColor(renderer: PSDL_Renderer; x1, x2, y: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_hlineColor' {$ENDIF};
+   
+Function hlineRGBA(renderer: PSDL_Renderer; x1, x2, y:sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_hlineRGBA' {$ENDIF};
+
+{ Vertical line }
+
+Function vlineColor(renderer: PSDL_Renderer; x, y1, y2: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_vlineColor' {$ENDIF};
+   
+Function vlineRGBA(renderer: PSDL_Renderer; x, y1, y2: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_vlineRGBA' {$ENDIF};
+
+{ Rectangle }
+
+Function rectangleColor(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rectangleColor' {$ENDIF};
+   
+Function rectangleRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rectangleRGBA' {$ENDIF};
+
+{ Rounded-Corner Rectangle }
+
+Function roundedRectangleColor(renderer: PSDL_Renderer; x1, y1, x2, y2, rad: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_roundedRectangleColor' {$ENDIF};
+   
+Function roundedRectangleRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2, rad: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_roundedRectangleRGBA' {$ENDIF};
+
+{ Filled rectangle (Box) }
+
+Function boxColor(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_boxColor' {$ENDIF};
+   
+Function boxRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_boxRGBA' {$ENDIF};
+
+{ Rounded-Corner Filled rectangle (Box) }
+
+Function roundedBoxColor(renderer: PSDL_Renderer; x1, y1, x2, y2, rad: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_roundedBoxColor' {$ENDIF};
+   
+Function roundedBoxRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2, rad: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_roundedBoxRGBA' {$ENDIF};
+
+{ Line }
+
+Function lineColor(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_lineColor' {$ENDIF};
+   
+Function lineRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_lineRGBA' {$ENDIF};
+
+{ AA Line }
+
+Function aalineColor(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aalineColor' {$ENDIF};
+   
+Function aalineRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aalineRGBA' {$ENDIF};
+
+{ Thick Line }
+Function thickLineColor(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; width: uInt8; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_thickLineColor' {$ENDIF};
+   
+Function thickLineRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2: sInt16; width, r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_thickLineRGBA' {$ENDIF};
+
+{ Circle }
+
+Function circleColor(renderer: PSDL_Renderer; x, y, rad: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_circleColor' {$ENDIF};
+   
+Function circleRGBA(renderer: PSDL_Renderer; x, y, rad: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_circleRGBA' {$ENDIF};
+
+{ Arc }
+
+Function arcColor(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_arcColor' {$ENDIF};
+   
+Function arcRGBA(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_arcRGBA' {$ENDIF};
+
+{ AA Circle }
+
+Function aacircleColor(renderer: PSDL_Renderer; x, y, rad: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aacircleColor' {$ENDIF};
+   
+Function aacircleRGBA(renderer: PSDL_Renderer; x, y, rad: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aacircleRGBA' {$ENDIF};
+
+{ Filled Circle }
+
+Function filledCircleColor(renderer: PSDL_Renderer; x, y, rad: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledCircleColor' {$ENDIF};
+   
+Function filledCircleRGBA(renderer: PSDL_Renderer; x, y, rad: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledCircleRGBA' {$ENDIF};
+
+{ Ellipse }
+
+Function ellipseColor(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_ellipseColor' {$ENDIF};
+   
+Function ellipseRGBA(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_ellipseRGBA' {$ENDIF};
+
+{ AA Ellipse }
+
+Function aaellipseColor(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aaellipseColor' {$ENDIF};
+   
+Function aaellipseRGBA(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aaellipseRGBA' {$ENDIF};
+
+{ Filled Ellipse }
+
+Function filledEllipseColor(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledEllipseColor' {$ENDIF};
+   
+Function filledEllipseRGBA(renderer: PSDL_Renderer; x, y, rx, ry: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledEllipseRGBA' {$ENDIF};
+
+{ Pie }
+
+Function pieColor(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_pieColor' {$ENDIF};
+   
+Function pieRGBA(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_pieRGBA' {$ENDIF};
+
+{ Filled Pie }
+
+Function filledPieColor(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledPieColor' {$ENDIF};
+   
+Function filledPieRGBA(renderer: PSDL_Renderer; x, y, rad, start, finish: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledPieRGBA' {$ENDIF};
+
+{ Trigon }
+
+Function trigonColor(renderer: PSDL_Renderer; x1, y1, x2, y2, x3, y3: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_trigonColor' {$ENDIF};
+   
+Function trigonRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2, x3, y3: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_trigonRGBA' {$ENDIF};
+
+{ AA-Trigon }
+
+Function aatrigonColor(renderer: PSDL_Renderer; x1, y1, x2, y2, x3, y3: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aatrigonColor' {$ENDIF};
+   
+Function aatrigonRGBA(renderer: PSDL_Renderer;  x1, y1, x2, y2, x3, y3: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aatrigonRGBA' {$ENDIF};
+
+{ Filled Trigon }
+
+Function filledTrigonColor(renderer: PSDL_Renderer; x1, y1, x2, y2, x3, y3: sInt16; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledTrigonColor' {$ENDIF};
+   
+Function filledTrigonRGBA(renderer: PSDL_Renderer; x1, y1, x2, y2, x3, y3: sInt16; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledTrigonRGBA' {$ENDIF};
+
+{ Polygon }
+
+Function polygonColor(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_polygonColor' {$ENDIF};
+   
+Function polygonRGBA(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_polugonRGBA' {$ENDIF};
+
+{ AA-Polygon }
+
+Function aapolygonColor(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aapolygonColor' {$ENDIF};
+   
+Function aapolygonRGBA(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_aapolygonRGBA' {$ENDIF};
+
+{ Filled Polygon }
+
+Function filledPolygonColor(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledPolygonColor' {$ENDIF};
+   
+Function filledPolygonRGBA(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_filledPolygonRGBA' {$ENDIF};
+
+{ Textured Polygon }
+
+Function texturedPolygon(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n: sInt32; texture: PSDL_Surface; texture_dx, texture_dy: sInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_texturedPolygon' {$ENDIF};
+
+{ Bezier }
+
+Function bezierColor(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n, s: sInt32; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_bezierColor' {$ENDIF};
+   
+Function bezierRGBA(renderer: PSDL_Renderer; Const vx, vy: PsInt16; n, s: sInt32; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_bezierRGBA' {$ENDIF};
+
+{ Characters/Strings }
+
+Procedure gfxPrimitivesSetFont(Const fontdata: Pointer; cw, ch: uInt32); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_gfxPrimitivesSetFont' {$ENDIF};
+
+Procedure gfxPrimitivesSetFontRotation(rotation: uInt32); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_gfxPrimitivesSetFontRotation' {$ENDIF};
+
+
+Function characterColor(renderer: PSDL_Renderer; x, y: sInt16; c: Char; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_characterColor' {$ENDIF};
+   
+Function characterRGBA(renderer: PSDL_Renderer; x, y: sInt16; c: Char; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_characterRGBA' {$ENDIF};
+   
+   
+Function stringColor(renderer: PSDL_Renderer; x, y: sInt16; Const str: PChar; colour: uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_stringColor' {$ENDIF};
+   
+Function stringRGBA(renderer: PSDL_Renderer; x, y: sInt16; Const syt: PChar; r, g, b, a: uInt8):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_stringRGBA' {$ENDIF};
+
+
+
+{---< SDL2_imageFilter.h >---}
+
+(* Comments:                                                                           *
+ *  1.) MMX functions work best if all data blocks are aligned on a 32 bytes boundary. *
+ *  2.) Data that is not within an 8 byte boundary is processed using the C routine.   *
+ *  3.) Convolution routines do not have C routines at this time.                      *)
+
+// Detect MMX capability in CPU
+Function SDL_imageFilterMMXdetect():sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMMXdetect' {$ENDIF};
+
+// Force use of MMX off (or turn possible use back on)
+Procedure SDL_imageFilterMMXoff(); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMMXoff' {$ENDIF};
+   
+Procedure SDL_imageFilterMMXon(); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMMXon' {$ENDIF};
+
+
+//  SDL_imageFilterAdd: D = saturation255(S1 + S2)
+Function SDL_imageFilterAdd(Src1, Src2, Dest : PuInt8; Length : uInt32):sInt32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterAdd' {$ENDIF};
+
+//  SDL_imageFilterMean: D = S1/2 + S2/2
+Function SDL_imageFilterMean(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMean' {$ENDIF};
+
+//  SDL_imageFilterSub: D = saturation0(S1 - S2)
+Function SDL_imageFilterSub(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterSub' {$ENDIF};
+
+//  SDL_imageFilterAbsDiff: D = | S1 - S2 |
+Function SDL_imageFilterAbsDiff(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterAbsDiff' {$ENDIF};
+
+
+//  SDL_imageFilterMult: D = saturation(S1 * S2)
+Function SDL_imageFilterMult(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMult' {$ENDIF};
+
+//  SDL_imageFilterMultNor: D = S1 * S2   (non-MMX)
+Function SDL_imageFilterMultNor(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMultNor' {$ENDIF};
+
+//  SDL_imageFilterMultDivby2: D = saturation255(S1/2 * S2)
+Function SDL_imageFilterMultDivby2(Src1, Src2, Dest : PuInt8; Length: uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMultDivby2' {$ENDIF};
+
+//  SDL_imageFilterMultDivby4: D = saturation255(S1/2 * S2/2)
+Function SDL_imageFilterMultDivby4(Src1, Src2, Dest : PuInt8; Length : uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMultDivby4' {$ENDIF};
+
+
+//  SDL_imageFilterBitAnd: D = S1 & S2
+Function SDL_imageFilterBitAnd(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterBitAnd' {$ENDIF};
+
+//  SDL_imageFilterBitOr: D = S1 | S2
+Function SDL_imageFilterBitOr(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterBitOr' {$ENDIF};
+
+
+//  SDL_imageFilterDiv: D = S1 / S2   (non-MMX)
+Function SDL_imageFilterDiv(Src1, Src2, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterDiv' {$ENDIF};
+
+//  SDL_imageFilterBitNegation: D = !S
+Function SDL_imageFilterBitNegation(Src1, Dest : PuInt8; Length:uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterBitNegation' {$ENDIF};
+
+
+//  SDL_imageFilterAddByte: D = saturation255(S + C)
+Function SDL_imageFilterAddByte(Src1, Dest : PuInt8; Length:uInt32; C : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterAddByte' {$ENDIF};
+
+//  SDL_imageFilterAddUsInt32: D = saturation255(S + (usInt32)C)
+Function SDL_imageFilterAddUsInt32(Src1, Dest : PuInt8; Length:uInt32; C : uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterAddUsInt32' {$ENDIF};
+
+//  SDL_imageFilterAddByteToHalf: D = saturation255(S/2 + C)
+Function SDL_imageFilterAddByteToHalf(Src1, Dest : PuInt8; Length:uInt32; C : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterAddByteToHalf' {$ENDIF};
+
+
+//  SDL_imageFilterSubByte: D = saturation0(S - C)
+Function SDL_imageFilterSubByte(Src1, Dest : PuInt8; Length:uInt32; C : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterSubByte' {$ENDIF};
+
+//  SDL_imageFilterSubUsInt32: D = saturation0(S - (usInt32)C)
+Function SDL_imageFilterSubUsInt32(Src1, Dest : PuInt8; Length:uInt32; C : uInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterSubUsInt32' {$ENDIF};
+
+
+//  SDL_imageFilterShiftRight: D = saturation0(S >> N)
+Function SDL_imageFilterShiftRight(Src1, Dest : PuInt8; Length:uInt32; N : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftRight' {$ENDIF};
+
+//  SDL_imageFilterShiftRightUsInt32: D = saturation0((usInt32)S >> N)
+Function SDL_imageFilterShiftRightUsInt32(Src1, Dest : PuInt8; Length:uInt32; N : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftRightUsInt32' {$ENDIF};
+
+
+//  SDL_imageFilterMultByByte: D = saturation255(S * C)
+Function SDL_imageFilterMultByByte(Src1, Dest : PuInt8; Length:uInt32; C : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterMultByByte' {$ENDIF};
+
+//  SDL_imageFilterShiftRightAndMultByByte: D = saturation255((S >> N) * C)
+Function SDL_imageFilterShiftRightAndMultByByte(Src1, Dest : PuInt8; Length:uInt32; N, C : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftRightAndMultByByte' {$ENDIF};
+
+
+//  SDL_imageFilterShiftLeftByte: D = (S << N)
+Function SDL_imageFilterShiftLeftByte(Src1, Dest : PuInt8; Length:uInt32; N: uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftLeftByte' {$ENDIF};
+
+//  SDL_imageFilterShiftLeftUsInt32: D = ((usInt32)S << N)
+Function SDL_imageFilterShiftLeftUsInt32(Src1, Dest : PuInt8; Length:uInt32; N:uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftLeftUsInt32' {$ENDIF};
+
+//  SDL_imageFilterShiftLeft: D = saturation255(S << N)
+Function SDL_imageFilterShiftLeft(Src1, Dest : PuInt8; Length:uInt32; N : uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterShiftLeft' {$ENDIF};
+
+
+//  SDL_imageFilterBinarizeUsingThreshold: D = S >= T ? 255:0
+Function SDL_imageFilterBinarizeUsingThreshold(Src1, Dest : PuInt8; Length:uInt32; T: uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterBinarizeUsingThreshold' {$ENDIF};
+
+//  SDL_imageFilterClipToRange: D = (S >= Tmin) & (S <= Tmax) 255:0
+Function SDL_imageFilterClipToRange(Src1, Dest : PuInt8; Length:uInt32; Tmin, Tmax: uInt8):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterClipToRange' {$ENDIF};
+
+//  SDL_imageFilterNormalizeLinear: D = saturation255((Nmax - Nmin)/(Cmax - Cmin)*(S - Cmin) + Nmin)
+Function SDL_imageFilterNormalizeLinear(Src, Dest: PuInt8; Length, Cmin, Cmax, Nmin, Nmax: sInt32):Sint32; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_SDL_imageFilterNormalizeLinear' {$ENDIF};
+
+
+{---< SDL2_rotozoom.h >---}
+
+Const
+   {*!
+    \brief Disable anti-aliasing (no smoothing).
+   *}
+   SMOOTHING_OFF = 0;
+
+   {*!
+    \brief Enable anti-aliasing (smoothing).
+   *}
+   SMOOTHING_ON = 1;
+
+{ Rotozoom functions }
+
+Function rotozoomSurface(src: PSDL_Surface; angle, zoom: Double; smooth: sInt32):PSDL_Surface; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rotozoomSurface' {$ENDIF};
+
+Function rotozoomSurfaceXY(src: PSDL_Surface; angle, zoomx, zoomy: Double; smooth: sInt32):PSDL_Surface; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rotozoomSurfaceXY' {$ENDIF};
+
+
+Procedure rotozoomSurfaceSize(width, height: sInt32; angle, zoom: Double; dstwidth, dstheight: PuInt32); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rotozoomSurfaceSize' {$ENDIF};
+
+Procedure rotozoomSurfaceSizeXY(width, height: sInt32; angle, zoomx, zoomy: Double; dstwidth, dstheight:PuInt32); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rotozoomSurfaceSizeXY' {$ENDIF};
+
+
+{ Zooming functions }
+
+Function zoomSurface(src: PSDL_Surface; zoomx, zoomy: Double; smooth: sInt32):PSDL_Surface; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_zoomSurface' {$ENDIF};
+
+Procedure zoomSurfaceSize(width, height: sInt32; zoomx, zoomy: Double; dstwidth, dstheight: PuInt32); cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_zoomSurfaceSize' {$ENDIF};
+
+{ Shrinking functions }
+
+Function shrinkSurface(src: PSDL_Surface; factorx, factory: sInt32):PSDL_Surface; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_shrinkSurface' {$ENDIF};
+
+{ Specialized rotation functions }
+
+Function rotateSurface90Degrees(src: PSDL_Surface; numClockwiseTurns: sInt32):PSDL_Surface; cdecl;
+   external GFX_LibName {$IFDEF DELMAC} name '_rotateSurface90Degrees' {$ENDIF};
+
+
+implementation
+
+Procedure SDL_GFX_VERSION(Out X: TSDL_Version);
+begin
+   X.Major := SDL2_GFXPRIMITIVES_MAJOR;
+   X.Minor := SDL2_GFXPRIMITIVES_MINOR;
+   X.Patch := SDL2_GFXPRIMITIVES_MICRO
+end;
+
+end.

model_viewer/sdl2/SDL2_image.pas

@@ -0,0 +1,188 @@
+unit sdl2_image;
+
+{*
+  SDL_image:  An example image loading library for use with SDL
+  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+  Pascal-Header-Translation 2013 by Tim Blume
+
+  Both, header translation and sdl_image, under following license:
+
+  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.
+
+  ChangeLog (Header-Translation):
+  -------------------------------
+
+  v.1.72-stable; 29.09.2013: fixed bug with procedure without parameters 
+                             (they must have brackets)
+  v.1.70-stable; 11.09.2013: MacOS compatibility (with Delphi)
+  v.1.33-Alpha; 31.07.2013: Initial Commit
+
+*}
+
+{$DEFINE SDL_IMAGE}
+
+{$I jedi.inc}
+
+interface
+
+uses
+  SDL2;
+
+const
+  {$IFDEF WINDOWS}
+    IMG_LibName = 'SDL2_image.dll';
+  {$ENDIF}
+
+  {$IFDEF UNIX}
+    {$IFDEF DARWIN}
+      IMG_LibName = 'libSDL2_image.dylib';
+    {$ELSE}
+      {$IFDEF FPC}
+        IMG_LibName = 'libSDL2_image.so';
+      {$ELSE}
+        IMG_LibName = 'libSDL2_image.so.0';
+      {$ENDIF}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IFDEF MACOS}
+    IMG_LibName = 'SDL2_image';
+    {$IFDEF FPC}
+      {$linklib libSDL2_image}
+    {$ENDIF}
+  {$ENDIF}
+
+  {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+  SDL_IMAGE_MAJOR_VERSION = 2;
+  SDL_IMAGE_MINOR_VERSION = 0;
+  SDL_IMAGE_PATCHLEVEL    = 0;
+
+  {* This macro can be used to fill a version structure with the compile-time
+   * version of the SDL_image library.
+   *}
+
+procedure SDL_IMAGE_VERSION(Out X: TSDL_Version);
+
+  {* This function gets the version of the dynamically linked SDL_image library.
+   * 
+   * Note that this function does NOT allocate a new TSDL_Version and fill it with info,
+   * but returns a pointer to a TSDL_Version residing inside dynlinked file.
+   * 
+   * As such, attempting to Dispose() of this memory will result in access violation.
+   *}
+function IMG_Linked_Version: PSDL_Version cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Linked_Version' {$ENDIF} {$ENDIF};
+
+const
+  IMG_INIT_JPG  = $00000001;
+  IMG_INIT_PNG  = $00000002;
+  IMG_INIT_TIF  = $00000004;
+  IMG_INIT_WEBP = $00000008;
+
+type
+  TIMG_InitFlags = DWord;
+
+  {* Loads dynamic libraries and prepares them for use.  Flags should be
+     one or more flags from IMG_InitFlags OR'd together.
+     It returns the flags successfully initialized, or 0 on failure.
+   *}
+function IMG_Init(flags: SInt32): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Init' {$ENDIF} {$ENDIF};
+
+  {* Unloads libraries loaded with IMG_Init *}
+procedure IMG_Quit() cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Quit' {$ENDIF} {$ENDIF};
+
+  {* Load an image from an SDL data source.
+     The 'type' may be one of: "BMP", "GIF", "PNG", etc.
+
+     If the image format supports a transparent pixel, SDL will set the
+     colorkey for the surface.  You can enable RLE acceleration on the
+     surface afterwards by calling:
+      SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+   *}
+function IMG_LoadTyped_RW(src: PSDL_RWops; freesrc: SInt32; _type: PAnsiChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTyped_RW' {$ENDIF} {$ENDIF};
+  {* Convenience functions *}
+function IMG_Load(_file: PAnsiChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load' {$ENDIF} {$ENDIF};
+function IMG_Load_RW(src: PSDL_RWops; freesrc: SInt32): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load_RW' {$ENDIF} {$ENDIF};
+
+  {* Load an image directly into a render texture. *}
+function IMG_LoadTexture(renderer: PSDL_Renderer; _file: PAnsiChar): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture' {$ENDIF} {$ENDIF};
+function IMG_LoadTexture_RW(renderer: PSDL_Renderer; src: PSDL_RWops; freesrc: SInt32): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTextureTyped_RW(renderer: PSDL_Renderer; src: PSDL_RWops; freesrc: SInt32; _type: PAnsiChar): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTextureTyped_RW' {$ENDIF} {$ENDIF};
+
+  {* Functions to detect a file type, given a seekable source *}
+function IMG_isICO(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isICO' {$ENDIF} {$ENDIF};
+function IMG_isCUR(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isCUR' {$ENDIF} {$ENDIF};
+function IMG_isBMP(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isBMP' {$ENDIF} {$ENDIF};
+function IMG_isGIF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isGIF' {$ENDIF} {$ENDIF};
+function IMG_isJPG(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isJPG' {$ENDIF} {$ENDIF};
+function IMG_isLBM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isLBM' {$ENDIF} {$ENDIF};
+function IMG_isPCX(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPCX' {$ENDIF} {$ENDIF};
+function IMG_isPNG(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNG' {$ENDIF} {$ENDIF};
+function IMG_isPNM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNM' {$ENDIF} {$ENDIF};
+function IMG_isTIF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isTIF' {$ENDIF} {$ENDIF};
+function IMG_isXCF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '-IMG_isXCF' {$ENDIF} {$ENDIF};
+function IMG_isXPM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXPM' {$ENDIF} {$ENDIF};
+function IMG_isXV(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXV' {$ENDIF} {$ENDIF};
+function IMG_isWEBP(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isWEBP' {$ENDIF} {$ENDIF};
+
+  {* Individual loading functions *}
+function IMG_LoadICO_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadICO_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadCUR_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadCUR_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadBMP_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadBMP_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadGIF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadGIF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadJPG_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadJPG_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadLBM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadLBM_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPCX_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPCX_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPNG_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNG_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPNM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNM_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTGA_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTGA_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTIF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTIF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXCF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXCF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXPM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXMP_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXV_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXV_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadWEBP_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadWEBP_RW' {$ENDIF} {$ENDIF};
+
+function IMG_ReadXPMFromArray(xpm: PPChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_ReadXPMFromArray' {$ENDIF} {$ENDIF};
+
+  {* Individual saving functions *}
+function IMG_SavePNG(surface: PSDL_Surface; const _file: PAnsiChar): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG' {$ENDIF} {$ENDIF};
+function IMG_SavePNG_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: SInt32): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG_RW' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function IMG_SetError(fmt: PAnsiChar): SInt32; cdecl;
+function IMG_GetError: PAnsiChar; cdecl;
+
+implementation
+
+procedure SDL_IMAGE_VERSION(Out X: TSDL_Version);
+begin
+  X.major := SDL_IMAGE_MAJOR_VERSION;
+  X.minor := SDL_IMAGE_MINOR_VERSION;
+  X.patch := SDL_IMAGE_PATCHLEVEL;
+end;
+
+function IMG_SetError(fmt: PAnsiChar): SInt32; cdecl;
+begin
+  Result := SDL_SetError(fmt);
+end;
+
+function IMG_GetError: PAnsiChar; cdecl;
+begin
+  Result := SDL_GetError();
+end;
+
+end.

model_viewer/sdl2/SDL2_mixer.pas

@@ -0,0 +1,696 @@
+unit SDL2_mixer;
+
+{*
+  SDL_mixer:  An audio mixer library based on the SDL library
+  Copyright (C) 1997-2013 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.
+*}
+
+{* ChangeLog: (Header Translation)
+   ----------
+
+   v.1.72-stable; 29.09.2013: fixed bug with procedures without parameters
+                              (they must have brackets)  
+   v.1.70-stable; 16.09.2013: Initial Commit
+
+*}
+
+interface
+
+{$I jedi.inc}
+
+uses
+  SDL2;
+
+const
+  {$IFDEF WINDOWS}
+    MIX_LibName = 'SDL2_mixer.dll';
+  {$ENDIF}
+
+  {$IFDEF UNIX}
+    {$IFDEF DARWIN}
+      MIX_LibName = 'libSDL2_mixer.dylib';
+    {$ELSE}
+      {$IFDEF FPC}
+        MIX_LibName = 'libSDL2_mixer.so';
+      {$ELSE}
+        MIX_LibName = 'libSDL2_mixer.so.0';
+      {$ENDIF}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IFDEF MACOS}
+    MIX_LibName = 'SDL2_mixer';
+    {$IFDEF FPC}
+      {$linklib libSDL2_mixer}
+    {$ENDIF}
+  {$ENDIF}
+
+  {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+const
+  SDL_MIXER_MAJOR_VERSION = 2;
+  SDL_MIXER_MINOR_VERSION = 0;
+  SDL_MIXER_PATCHLEVEL    = 0;
+
+  {* This macro can be used to fill a version structure with the compile-time
+   * version of the SDL_mixer library.
+   *}
+procedure SDL_MIXER_VERSION(Out X: TSDL_Version);
+
+  {* Backwards compatibility *}
+const
+  MIX_MAJOR_VERSION = SDL_MIXER_MAJOR_VERSION;
+  MIX_MINOR_VERSION = SDL_MIXER_MINOR_VERSION;
+  MIX_PATCHLEVEL    = SDL_MIXER_PATCHLEVEL;
+
+procedure MIX_VERSION(Out X: TSDL_Version);
+
+  {* This function gets the version of the dynamically linked SDL_mixer library.
+     it should NOT be used to fill a version structure, instead you should
+     use the SDL_MIXER_VERSION() macro.
+   *}
+function Mix_Linked_Version: PSDL_Version cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Linked_Version' {$ENDIF} {$ENDIF};
+
+const
+  MIX_INIT_FLAC        = $00000001;
+  MIX_INIT_MOD         = $00000002;
+  MIX_INIT_MODPLUG     = $00000004;
+  MIX_INIT_MP3         = $00000008;
+  MIX_INIT_OGG         = $00000010;
+  MIX_INIT_FLUIDSYNTH  = $00000020;
+type
+  TMIX_InitFlags = Byte;
+
+  {* Loads dynamic libraries and prepares them for use.  Flags should be
+     one or more flags from MIX_InitFlags OR'd together.
+     It returns the flags successfully initialized, or 0 on failure.
+   *}
+function Mix_Init(flags: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Init' {$ENDIF} {$ENDIF};
+
+  {* Unloads libraries loaded with Mix_Init *}
+procedure Mix_Quit() cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Quit' {$ENDIF} {$ENDIF};
+
+
+  {* The default mixer has 8 simultaneous mixing channels *}
+{$IFNDEF MIX_CHANNELS}
+const
+  MIX_CHANNELS = 8;
+{$ENDIF}
+
+  {* Good default values for a PC soundcard *}
+const
+  MIX_DEFAULT_FREQUENCY = 22050;
+  MIX_DEFAULT_CHANNELS = 2;
+  MIX_MAX_VOLUME       = 128; {* Volume of a chunk *}
+
+{$IFDEF FPC}
+   {$IF DEFINED(ENDIAN_LITTLE)}
+      MIX_DEFAULT_FORMAT = AUDIO_S16LSB;
+   {$ELSEIF DEFINED(ENDIAN_BIG)}
+      MIX_DEFAULT_FORMAT = AUDIO_S16MSB;
+   {$ELSE}
+      {$FATAL Unable to determine endianness.}
+   {$IFEND}
+{$ENDIF}
+
+  {* The internal format for an audio chunk *}
+type
+  PMix_Chunk = ^TMix_Chunk;
+  TMix_Chunk = record
+    allocated: Integer;
+    abuf: PUInt8;
+    alen: UInt32;
+    volume: UInt8;       {* Per-sample volume, 0-128 *}
+  end;
+
+  {* The different fading types supported *}
+type
+  TMix_Fading = (MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN);
+
+  TMix_MusicType = (MUS_NONE,
+                    MUS_CMD,
+                    MUS_WAV,
+                    MUS_MOD,
+                    MUS_MID,
+                    MUS_OGG,
+                    MUS_MP3,
+                    MUS_MP3_MAD,
+                    MUS_FLAC,
+                    MUS_MODPLUG);
+
+  {* The internal format for a music chunk interpreted via mikmod *}
+  PMix_Music = ^TMix_Music;
+  TMix_Music = record end;
+
+  {* Open the mixer with a certain audio format *}
+function Mix_OpenAudio(frequency: Integer; format: UInt16; channels: Integer; chunksize: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_OpenAudio' {$ENDIF} {$ENDIF};
+
+  {* Dynamically change the number of channels managed by the mixer.
+     If decreasing the number of channels, the upper channels are
+     stopped.
+     This function returns the new number of allocated channels.
+   *}
+function Mix_AllocateChannels(numchans: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_AllocateChannels' {$ENDIF} {$ENDIF};
+
+  {* Find out what the actual audio device parameters are.
+     This function returns 1 if the audio has been opened, 0 otherwise.
+   *}
+function Mix_QuerySpec(frequency: PInt; format: PUInt16; channels: PInt): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuerySpec' {$ENDIF} {$ENDIF};
+
+  {* Load a wave file or a music (.mod .s3m .it .xm) file *}
+function Mix_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadWAV_RW' {$ENDIF} {$ENDIF};
+function Mix_LoadWAV(_file: PAnsiChar): PMix_Chunk;
+function Mix_LoadMUS(_file: PAnsiChar): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUS' {$ENDIF} {$ENDIF};
+
+  {* Load a music file from an SDL_RWop object (Ogg and MikMod specific currently)
+     Matt Campbell (matt@campbellhome.dhs.org) April 2000 *}
+function Mix_LoadMUS_RW(src: PSDL_RWops; freesrc: Integer): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUS_RW' {$ENDIF} {$ENDIF};
+
+  {* Load a music file from an SDL_RWop object assuming a specific format *}
+function Mix_LoadMUSType_RW(src: PSDL_RWops; _type: TMix_MusicType; freesrc: Integer): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUSType_RW' {$ENDIF} {$ENDIF};
+
+  {* Load a wave file of the mixer format from a memory buffer *}
+function Mix_QuickLoad_WAV(mem: PUInt8): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuickLoad_WAV' {$ENDIF} {$ENDIF};
+
+  {* Load raw audio data of the mixer format from a memory buffer *}
+function Mix_QuickLoad_RAW(mem: PUInt8; len: UInt32): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuickLoad_RAW' {$ENDIF} {$ENDIF};
+
+  {* Free an audio chunk previously loaded *}
+procedure Mix_FreeChunk(chunk: PMix_Chunk) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FreeChunk' {$ENDIF} {$ENDIF};
+procedure Mix_FreeMusic(music: PMix_Music) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FreeMusic' {$ENDIF} {$ENDIF};
+
+  {* Get a list of chunk/music decoders that this build of SDL_mixer provides.
+     This list can change between builds AND runs of the program, if external
+     libraries that add functionality become available.
+     You must successfully call Mix_OpenAudio() before calling these functions.
+     This API is only available in SDL_mixer 1.2.9 and later.
+
+     // usage...
+     int i;
+     const int total = Mix_GetNumChunkDecoders();
+     for (i = 0; i < total; i++)
+         printf("Supported chunk decoder: [%s]\n", Mix_GetChunkDecoder(i));
+
+     Appearing in this list doesn't promise your specific audio file will
+     decode...but it's handy to know if you have, say, a functioning Timidity
+     install.
+
+     These return values are static, read-only data; do not modify or free it.
+     The pointers remain valid until you call Mix_CloseAudio().
+  *}
+function Mix_GetNumChunkDecoders: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetNumChunkDecoders' {$ENDIF} {$ENDIF};
+function Mix_GetChunkDecoder(index: Integer): PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetChunkDecoder' {$ENDIF} {$ENDIF};
+function Mix_GetNumMusicDecoders: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetNumMusicDecoders' {$ENDIF} {$ENDIF};
+function Mix_GetMusicDecoder(index: Integer): PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicDecoder' {$ENDIF} {$ENDIF};
+
+  {* Find out the music format of a mixer music, or the currently playing
+     music, if 'music' is NULL.
+  *}
+function Mix_GetMusicType(music: TMix_Music): TMix_MusicType cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicType' {$ENDIF} {$ENDIF};
+
+  {* Set a function that is called after all mixing is performed.
+     This can be used to provide real-time visual display of the audio stream
+     or add a custom mixer filter for the stream data.
+  *}
+type
+  TMix_Func = procedure(udata: Pointer; stream: PUInt8; len: Integer);
+
+procedure Mix_SetPostMix(func: TMix_Func; arg: Pointer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPostMix' {$ENDIF} {$ENDIF};
+
+  {* Add your own music player or additional mixer function.
+     If 'mix_func' is NULL, the default music player is re-enabled.
+   *}
+procedure Mix_HookMusic(func: TMix_Func; arg: Pointer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HookMusic' {$ENDIF} {$ENDIF};
+
+  {* Add your own callback when the music has finished playing.
+     This callback is only called if the music finishes naturally.
+   *}
+type
+  PMix_Music_Finished = ^TMix_Music_Finished;
+  TMix_Music_Finished = procedure();
+procedure Mix_HookMusicFinished(music_finished: PMix_Music_Finished) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HookMusicFinished' {$ENDIF} {$ENDIF};
+
+  {* Get a pointer to the user data for the current music hook *}
+function Mix_GetMusicHookData: Pointer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicHookData' {$ENDIF} {$ENDIF};
+
+  {*
+   * Add your own callback when a channel has finished playing. NULL
+   *  to disable callback. The callback may be called from the mixer's audio
+   *  callback or it could be called as a result of Mix_HaltChannel(), etc.
+   *  do not call SDL_LockAudio() from this callback; you will either be
+   *  inside the audio callback, or SDL_mixer will explicitly lock the audio
+   *  before calling your callback.
+   *}
+type
+  TMix_Channel_Finished = procedure(channel: Integer);
+procedure Mix_ChannelFinished(channel_finished: TMix_Channel_Finished) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ChannelFinished' {$ENDIF} {$ENDIF};
+
+  {* Special Effects API by ryan c. gordon. (icculus@icculus.org) *}
+const
+  MIX_CHANNEL_POST = -2;
+
+  {* This is the format of a special effect callback:
+   *
+   *   myeffect(int chan, void *stream, int len, void *udata);
+   *
+   * (chan) is the channel number that your effect is affecting. (stream) is
+   *  the buffer of data to work upon. (len) is the size of (stream), and
+   *  (udata) is a user-defined bit of data, which you pass as the last arg of
+   *  Mix_RegisterEffect(), and is passed back unmolested to your callback.
+   *  Your effect changes the contents of (stream) based on whatever parameters
+   *  are significant, or just leaves it be, if you prefer. You can do whatever
+   *  you like to the buffer, though, and it will continue in its changed state
+   *  down the mixing pipeline, through any other effect functions, then finally
+   *  to be mixed with the rest of the channels and music for the final output
+   *  stream.
+   *
+   * DO NOT EVER call SDL_LockAudio() from your callback function!
+   *}
+type
+  TMix_EffectFunc_t = procedure(chan: Integer; stream: Pointer; len: Integer; udata: Pointer);
+
+  {*
+   * This is a callback that signifies that a channel has finished all its
+   *  loops and has completed playback. This gets called if the buffer
+   *  plays out normally, or if you call Mix_HaltChannel(), implicitly stop
+   *  a channel via Mix_AllocateChannels(), or unregister a callback while
+   *  it's still playing.
+   *
+   * DO NOT EVER call SDL_LockAudio() from your callback function!
+   *}
+type
+  TMix_EffectDone_t = procedure(chan: Integer; udata: Pointer);
+
+  {* Register a special effect function. At mixing time, the channel data is
+   *  copied into a buffer and passed through each registered effect function.
+   *  After it passes through all the functions, it is mixed into the final
+   *  output stream. The copy to buffer is performed once, then each effect
+   *  function performs on the output of the previous effect. Understand that
+   *  this extra copy to a buffer is not performed if there are no effects
+   *  registered for a given chunk, which saves CPU cycles, and any given
+   *  effect will be extra cycles, too, so it is crucial that your code run
+   *  fast. Also note that the data that your function is given is in the
+   *  format of the sound device, and not the format you gave to Mix_OpenAudio(),
+   *  although they may in reality be the same. This is an unfortunate but
+   *  necessary speed concern. Use Mix_QuerySpec() to determine if you can
+   *  handle the data before you register your effect, and take appropriate
+   *  actions.
+   * You may also specify a callback (Mix_EffectDone_t) that is called when
+   *  the channel finishes playing. This gives you a more fine-grained control
+   *  than Mix_ChannelFinished(), in case you need to free effect-specific
+   *  resources, etc. If you don't need this, you can specify NULL.
+   * You may set the callbacks before or after calling Mix_PlayChannel().
+   * Things like Mix_SetPanning() are just internal special effect functions,
+   *  so if you are using that, you've already incurred the overhead of a copy
+   *  to a separate buffer, and that these effects will be in the queue with
+   *  any functions you've registered. The list of registered effects for a
+   *  channel is reset when a chunk finishes playing, so you need to explicitly
+   *  set them with each call to Mix_PlayChannel*().
+   * You may also register a special effect function that is to be run after
+   *  final mixing occurs. The rules for these callbacks are identical to those
+   *  in Mix_RegisterEffect, but they are run after all the channels and the
+   *  music have been mixed into a single stream, whereas channel-specific
+   *  effects run on a given channel before any other mixing occurs. These
+   *  global effect callbacks are call "posteffects". Posteffects only have
+   *  their Mix_EffectDone_t function called when they are unregistered (since
+   *  the main output stream is never "done" in the same sense as a channel).
+   *  You must unregister them manually when you've had enough. Your callback
+   *  will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
+   *  processing is considered a posteffect.
+   *
+   * After all these effects have finished processing, the callback registered
+   *  through Mix_SetPostMix() runs, and then the stream goes to the audio
+   *  device.
+   *
+   * DO NOT EVER call SDL_LockAudio() from your callback function!
+   *
+   * returns zero if error (no such channel), nonzero if added.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_RegisterEffect(chan: Integer; f: TMix_EffectFunc_t; d: TMix_EffectDone_t; arg: Pointer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_RegisterEffect' {$ENDIF} {$ENDIF};
+
+  {* You may not need to call this explicitly, unless you need to stop an
+   *  effect from processing in the middle of a chunk's playback.
+   * Posteffects are never implicitly unregistered as they are for channels,
+   *  but they may be explicitly unregistered through this function by
+   *  specifying MIX_CHANNEL_POST for a channel.
+   * returns zero if error (no such channel or effect), nonzero if removed.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_UnregisterEffect(channel: Integer; f: TMix_EffectFunc_t): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_UnregisterEffect' {$ENDIF} {$ENDIF};
+
+  {* You may not need to call this explicitly, unless you need to stop all
+   *  effects from processing in the middle of a chunk's playback. Note that
+   *  this will also shut off some internal effect processing, since
+   *  Mix_SetPanning() and others may use this API under the hood. This is
+   *  called internally when a channel completes playback.
+   * Posteffects are never implicitly unregistered as they are for channels,
+   *  but they may be explicitly unregistered through this function by
+   *  specifying MIX_CHANNEL_POST for a channel.
+   * returns zero if error (no such channel), nonzero if all effects removed.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_UnregisterAllEffects(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_UnregisterEffects' {$ENDIF} {$ENDIF};
+
+const
+  MIX_EFFECTSMAXSPEED = 'MIX_EFFECTSMAXSPEED';
+
+  {*
+   * These are the internally-defined mixing effects. They use the same API that
+   *  effects defined in the application use, but are provided here as a
+   *  convenience. Some effects can reduce their quality or use more memory in
+   *  the name of speed; to enable this, make sure the environment variable
+   *  MIX_EFFECTSMAXSPEED (see above) is defined before you call
+   *  Mix_OpenAudio().
+   *}
+
+  {* Set the panning of a channel. The left and right channels are specified
+   *  as integers between 0 and 255, quietest to loudest, respectively.
+   *
+   * Technically, this is just individual volume control for a sample with
+   *  two (stereo) channels, so it can be used for more than just panning.
+   *  If you want real panning, call it like this:
+   *
+   *   Mix_SetPanning(channel, left, 255 - left);
+   *
+   * ...which isn't so hard.
+   *
+   * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+   *  the panning will be done to the final mixed stream before passing it on
+   *  to the audio device.
+   *
+   * This uses the Mix_RegisterEffect() API internally, and returns without
+   *  registering the effect function if the audio device is not configured
+   *  for stereo output. Setting both (left) and (right) to 255 causes this
+   *  effect to be unregistered, since that is the data's normal state.
+   *
+   * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+   *  nonzero if panning effect enabled. Note that an audio device in mono
+   *  mode is a no-op, but this call will return successful in that case.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_SetPanning(channel: Integer; left: UInt8; right: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPanning' {$ENDIF} {$ENDIF};
+
+  {* Set the position of a channel. (angle) is an integer from 0 to 360, that
+   *  specifies the location of the sound in relation to the listener. (angle)
+   *  will be reduced as neccesary (540 becomes 180 degrees, -100 becomes 260).
+   *  Angle 0 is due north, and rotates clockwise as the value increases.
+   *  For efficiency, the precision of this effect may be limited (angles 1
+   *  through 7 might all produce the same effect, 8 through 15 are equal, etc).
+   *  (distance) is an integer between 0 and 255 that specifies the space
+   *  between the sound and the listener. The larger the number, the further
+   *  away the sound is. Using 255 does not guarantee that the channel will be
+   *  culled from the mixing process or be completely silent. For efficiency,
+   *  the precision of this effect may be limited (distance 0 through 5 might
+   *  all produce the same effect, 6 through 10 are equal, etc). Setting (angle)
+   *  and (distance) to 0 unregisters this effect, since the data would be
+   *  unchanged.
+   *
+   * If you need more precise positional audio, consider using OpenAL for
+   *  spatialized effects instead of SDL_mixer. This is only meant to be a
+   *  basic effect for simple "3D" games.
+   *
+   * If the audio device is configured for mono output, then you won't get
+   *  any effectiveness from the angle; however, distance attenuation on the
+   *  channel will still occur. While this effect will function with stereo
+   *  voices, it makes more sense to use voices with only one channel of sound,
+   *  so when they are mixed through this effect, the positioning will sound
+   *  correct. You can convert them to mono through SDL before giving them to
+   *  the mixer in the first place if you like.
+   *
+   * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+   *  the positioning will be done to the final mixed stream before passing it
+   *  on to the audio device.
+   *
+   * This is a convenience wrapper over Mix_SetDistance() and Mix_SetPanning().
+   *
+   * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+   *  nonzero if position effect is enabled.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_SetPosition(channel: Integer; angle: SInt16; distance: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPosition' {$ENDIF} {$ENDIF};
+
+  {* Set the "distance" of a channel. (distance) is an integer from 0 to 255
+   *  that specifies the location of the sound in relation to the listener.
+   *  Distance 0 is overlapping the listener, and 255 is as far away as possible
+   *  A distance of 255 does not guarantee silence; in such a case, you might
+   *  want to try changing the chunk's volume, or just cull the sample from the
+   *  mixing process with Mix_HaltChannel().
+   * For efficiency, the precision of this effect may be limited (distances 1
+   *  through 7 might all produce the same effect, 8 through 15 are equal, etc).
+   *  (distance) is an integer between 0 and 255 that specifies the space
+   *  between the sound and the listener. The larger the number, the further
+   *  away the sound is.
+   * Setting (distance) to 0 unregisters this effect, since the data would be
+   *  unchanged.
+   * If you need more precise positional audio, consider using OpenAL for
+   *  spatialized effects instead of SDL_mixer. This is only meant to be a
+   *  basic effect for simple "3D" games.
+   *
+   * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+   *  the distance attenuation will be done to the final mixed stream before
+   *  passing it on to the audio device.
+   *
+   * This uses the Mix_RegisterEffect() API internally.
+   *
+   * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+   *  nonzero if position effect is enabled.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_SetDistance(channel: Integer; distance: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetDistance' {$ENDIF} {$ENDIF};
+
+{*
+ * !!! FIXME : Haven't implemented, since the effect goes past the
+ *              end of the sound buffer. Will have to think about this.
+ *               --ryan.
+ *}
+//#if 0
+{* Causes an echo effect to be mixed into a sound. (echo) is the amount
+ *  of echo to mix. 0 is no echo, 255 is infinite (and probably not
+ *  what you want).
+ *
+ * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+ *  the reverbing will be done to the final mixed stream before passing it on
+ *  to the audio device.
+ *
+ * This uses the Mix_RegisterEffect() API internally. If you specify an echo
+ *  of zero, the effect is unregistered, as the data is already in that state.
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ *  nonzero if reversing effect is enabled.
+ *  Error messages can be retrieved from Mix_GetError().
+ *}
+//extern no_parse_DECLSPEC int SDLCALL Mix_SetReverb(int channel, Uint8 echo);
+//#endif
+
+  {* Causes a channel to reverse its stereo. This is handy if the user has his
+   *  speakers hooked up backwards, or you would like to have a minor bit of
+   *  psychedelia in your sound code.  :)  Calling this function with (flip)
+   *  set to non-zero reverses the chunks's usual channels. If (flip) is zero,
+   *  the effect is unregistered.
+   *
+   * This uses the Mix_RegisterEffect() API internally, and thus is probably
+   *  more CPU intensive than having the user just plug in his speakers
+   *  correctly. Mix_SetReverseStereo() returns without registering the effect
+   *  function if the audio device is not configured for stereo output.
+   *
+   * If you specify MIX_CHANNEL_POST for (channel), then this the effect is used
+   *  on the final mixed stream before sending it on to the audio device (a
+   *  posteffect).
+   *
+   * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+   *  nonzero if reversing effect is enabled. Note that an audio device in mono
+   *  mode is a no-op, but this call will return successful in that case.
+   *  Error messages can be retrieved from Mix_GetError().
+   *}
+function Mix_SetReverseStereo(channel: Integer; flip: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetReverseStereo' {$ENDIF} {$ENDIF};
+
+  {* end of effects API. --ryan. *}
+
+  {* Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+     them dynamically to the next sample if requested with a -1 value below.
+     Returns the number of reserved channels.
+   *}
+function Mix_ReserveChannels(num: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ReverseChannels' {$ENDIF} {$ENDIF};
+
+  {* Channel grouping functions *}
+
+  {* Attach a tag to a channel. A tag can be assigned to several mixer
+     channels, to form groups of channels.
+     If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+     represent the group of all the channels).
+     Returns true if everything was OK.
+   *}
+function Mix_GroupChannel(which: Integer; tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupChannel' {$ENDIF} {$ENDIF};
+  {* Assign several consecutive channels to a group *}
+function Mix_GroupChannels(from: Integer; _to: Integer; tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupChannels' {$ENDIF} {$ENDIF};
+  {* Finds the first available channel in a group of channels,
+     returning -1 if none are available.
+   *}
+function Mix_GroupAvailable(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupAvailable' {$ENDIF} {$ENDIF};
+  {* Returns the number of channels in a group. This is also a subtle
+     way to get the total number of channels when 'tag' is -1
+   *}
+function Mix_GroupCount(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupCount' {$ENDIF} {$ENDIF};
+  {* Finds the "oldest" sample playing in a group of channels *}
+function Mix_GroupOldest(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupOldest' {$ENDIF} {$ENDIF};
+  {* Finds the "most recent" (i.e. last) sample playing in a group of channels *}
+function Mix_GroupNewer(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupNewer' {$ENDIF} {$ENDIF};
+
+  {* Play an audio chunk on a specific channel.
+     If the specified channel is -1, play on the first free channel.
+     If 'loops' is greater than zero, loop the sound that many times.
+     If 'loops' is -1, loop inifinitely (~65000 times).
+     Returns which channel was used to play the sound.
+  *}
+function Mix_PlayChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer): Integer;
+  {* The same as above, but the sound is played at most 'ticks' milliseconds *}
+function Mix_PlayChannelTimed(channel: Integer; chunk: PMix_Chunk; loops: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayChannelTimed' {$ENDIF} {$ENDIF};
+function Mix_PlayMusic(music: PMix_Music; loops: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayMusic' {$ENDIF} {$ENDIF};
+
+  {* Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions *}
+function Mix_FadeInMusic(music: PMix_Music; loops: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInMusic' {$ENDIF} {$ENDIF};
+function Mix_FadeInMusicPos(music: PMix_Music; loops: Integer; ms: Integer; position: Double): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInMusicPos' {$ENDIF} {$ENDIF};
+function Mix_FadeInChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer): Integer;
+function Mix_FadeInChannelTimed(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInChannelTimed' {$ENDIF} {$ENDIF};
+
+  {* Set the volume in the range of 0-128 of a specific channel or chunk.
+     If the specified channel is -1, set volume for all channels.
+     Returns the original volume.
+     If the specified volume is -1, just return the current volume.
+  *}
+function Mix_Volume(channel: Integer; volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Volume' {$ENDIF} {$ENDIF};
+function Mix_VolumeChunk(chunk: PMix_Chunk; volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_VolumeChunk' {$ENDIF} {$ENDIF};
+function Mix_VolumeMusic(volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_VolumeMusic' {$ENDIF} {$ENDIF};
+
+  {* Halt playing of a particular channel *}
+function Mix_HaltChannel(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltChannel' {$ENDIF} {$ENDIF};
+function Mix_HaltGroup(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltGroup' {$ENDIF} {$ENDIF};
+function Mix_HaltMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltMusic' {$ENDIF} {$ENDIF};
+
+  {* Change the expiration delay for a particular channel.
+     The sample will stop playing after the 'ticks' milliseconds have elapsed,
+     or remove the expiration if 'ticks' is -1
+  *}
+function Mix_ExpireChannel(channel: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ExpireChannel' {$ENDIF} {$ENDIF};
+
+  {* Halt a channel, fading it out progressively till it's silent
+     The ms parameter indicates the number of milliseconds the fading
+     will take.
+   *}
+function Mix_FadeOutChannel(which: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutChannel' {$ENDIF} {$ENDIF};
+function Mix_FadeOutGroup(tag: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutGroup' {$ENDIF} {$ENDIF};
+function Mix_FadeOutMusic(ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutMusic' {$ENDIF} {$ENDIF};
+
+  {* Query the fading status of a channel *}
+function Mix_FadingMusic: TMix_Fading cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadingMusic' {$ENDIF} {$ENDIF};
+function Mix_FadingChannel(which: Integer): TMix_Fading cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadingChannel' {$ENDIF} {$ENDIF};
+
+  {* Pause/Resume a particular channel *}
+procedure Mix_Pause(channel: Integer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Pause' {$ENDIF} {$ENDIF};
+procedure Mix_Resume(channel: Integer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Resume' {$ENDIF} {$ENDIF};
+function Mix_Paused(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Paused' {$ENDIF} {$ENDIF};
+
+  {* Pause/Resume the music stream *}
+procedure Mix_PauseMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PauseMusic' {$ENDIF} {$ENDIF};
+procedure Mix_ResumeMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ResumeMusic' {$ENDIF} {$ENDIF};
+procedure Mix_RewindMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_RewindMusic' {$ENDIF} {$ENDIF};
+function Mix_PausedMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PausedMusic' {$ENDIF} {$ENDIF};
+
+  {* Set the current position in the music stream.
+     This returns 0 if successful, or -1 if it failed or isn't implemented.
+     This function is only implemented for MOD music formats (set pattern
+     order number) and for OGG, FLAC, MP3_MAD, and MODPLUG music (set
+     position in seconds), at the moment.
+  *}
+function Mix_SetMusicPosition(position: Double): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetMusicPosition' {$ENDIF} {$ENDIF};
+
+  {* Check the status of a specific channel.
+     If the specified channel is -1, check all channels.
+  *}
+function Mix_Playing(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Playing' {$ENDIF} {$ENDIF};
+function Mix_PlayingMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayingMusic' {$ENDIF} {$ENDIF};
+
+  {* Stop music and set external music playback command *}
+function Mix_SetMusicCMD(command: PAnsiChar): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetMusicCMD' {$ENDIF} {$ENDIF};
+
+  {* Synchro value is set by MikMod from modules while playing *}
+function Mix_SetSynchroValue(value: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetSynchroValue' {$ENDIF} {$ENDIF};
+function Mix_GetSynchroValue: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetSynchroValue' {$ENDIF} {$ENDIF};
+
+  {* Set/Get/Iterate SoundFonts paths to use by supported MIDI backends *}
+function Mix_SetSoundFonts(paths: PAnsiChar): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetSoundFonts' {$ENDIF} {$ENDIF};
+function Mix_GetSoundFonts: PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetSoundFonts' {$ENDIF} {$ENDIF};
+
+type
+  TMix_SoundFunc = function(c: PAnsiChar; p: Pointer): Integer;
+
+function Mix_EachSoundFont(func: TMix_SoundFunc; data: Pointer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_EachSoundFont' {$ENDIF} {$ENDIF};
+
+  {* Get the Mix_Chunk currently associated with a mixer channel
+      Returns NULL if it's an invalid channel, or there's no chunk associated.
+  *}
+function Mix_GetChunk(channel: Integer): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetChunk' {$ENDIF} {$ENDIF};
+
+  {* Close the mixer, halting all playing audio *}
+procedure Mix_CloseAudio cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_CloseAudio' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function Mix_SetError(const fmt: PAnsiChar): SInt32; cdecl;
+function Mix_GetError: PAnsiChar; cdecl;
+
+implementation
+
+procedure SDL_MIXER_VERSION(Out X: TSDL_Version);
+begin
+  X.major := SDL_MIXER_MAJOR_VERSION;
+  X.minor := SDL_MIXER_MINOR_VERSION;
+  X.patch := SDL_MIXER_PATCHLEVEL;
+end;
+
+procedure MIX_VERSION(Out X: TSDL_Version);
+begin
+  SDL_MIXER_VERSION(X);
+end;
+
+function Mix_FadeInChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer): Integer;
+begin
+  Result := Mix_FadeInChannelTimed(channel, chunk, loops, ms, -1);
+end;
+
+function Mix_PlayChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer): Integer;
+begin
+  Result := Mix_PlayChannelTimed(channel, chunk, loops, -1);
+end;
+
+function Mix_LoadWAV(_file: PAnsiChar): PMix_Chunk;
+begin
+  Result := Mix_LoadWAV_RW(SDL_RWFromFile(_file, 'rb'), 1);
+end;
+
+function Mix_SetError(const fmt: PAnsiChar): SInt32; cdecl;
+begin
+  Result := SDL_SetError(fmt);
+end;
+
+function Mix_GetError: PAnsiChar; cdecl;
+begin
+  Result := SDL_GetError();
+end;
+
+end.

model_viewer/sdl2/SDL2_net.pas

@@ -0,0 +1,429 @@
+	
+
+    {*
+      SDL_net:  An example cross-platform network library for use with SDL
+      Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+      Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>
+     
+      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.
+    *}
+    unit SDL2_net;
+    
+    {$INCLUDE jedi.inc}
+     
+    interface
+     
+    uses SDL2;
+     
+    const
+      {$IFDEF WINDOWS}
+        SDLNet_LibName = 'SDL2_net.dll';
+      {$ENDIF}
+     
+      {$IFDEF UNIX}
+        {$IFDEF DARWIN}
+          SDLNet_LibName = 'libSDL2_net.dylib';
+        {$ELSE}
+          {$IFDEF FPC}
+            SDLNet_LibName = 'libSDL2_net.so';
+          {$ELSE}
+            SDLNet_LibName = 'libSDL2_net-2.0.so.0';
+          {$ENDIF}
+        {$ENDIF}
+      {$ENDIF}
+     
+      {$IFDEF MACOS}
+        SDLNet_LibName = 'SDL2_net';
+        {$IFDEF FPC}
+          {$linklib libSDL2_net}
+        {$ENDIF}
+      {$ENDIF}
+     
+     
+    type
+      TSDLNet_Version = TSDL_Version;
+     
+    const
+      {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+      SDL_NET_MAJOR_VERSION = 2;
+      SDL_NET_MINOR_VERSION = 0;
+      SDL_NET_PATCHLEVEL    = 0;
+     
+      {* This macro can be used to fill a version structure with the compile-time
+       * version of the SDL_net library.
+       *}
+    procedure SDL_NET_VERSION(Out X: TSDL_Version);
+     
+      {* This function gets the version of the dynamically linked SDL_net library.
+         it should NOT be used to fill a version structure, instead you should
+         use the SDL_NET_VERSION() macro.
+       *}
+    procedure SDLNet_Linked_Version() cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Linked_Version' {$ENDIF} {$ENDIF};
+     
+      {* Initialize/Cleanup the network API
+         SDL must be initialized before calls to functions in this library,
+         because this library uses utility functions from the SDL library.
+      *}
+    function SDLNet_Init(): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Init' {$ENDIF} {$ENDIF};
+    procedure SDLNet_Quit() cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Quit' {$ENDIF} {$ENDIF};
+     
+    type
+      {***********************************************************************}
+      {* IPv4 hostname resolution API                                        *}
+      {***********************************************************************}
+      TIPaddress = record
+        host: UInt32;            {* 32-bit IPv4 host address *}
+        port: UInt16;            {* 16-bit protocol port *}  
+      end;
+      PIPaddress = ^TIPaddress;
+     
+      {* Resolve a host name and port to an IP address in network form.
+         If the function succeeds, it will return 0.
+         If the host couldn't be resolved, the host portion of the returned
+         address will be INADDR_NONE, and the function will return -1.
+         If 'host' is NULL, the resolved host will be set to INADDR_ANY.
+       *}
+    const
+      INADDR_ANY       = $00000000;
+      INADDR_NONE      = $FFFFFFFF;
+      INADDR_LOOPBACK  = $7f000001;
+      INADDR_BROADCAST = $FFFFFFFF;
+     
+    function SDLNet_ResolveHost(address: PIPaddress; const host: PAnsiChar; port: UInt16): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResolveHost' {$ENDIF} {$ENDIF};
+     
+      {* Resolve an ip address to a host name in canonical form.
+         If the ip couldn't be resolved, this function returns NULL,
+         otherwise a pointer to a static buffer containing the hostname
+         is returned.  Note that this function is not thread-safe.
+      *}
+    function SDLNet_ResolveIP(const ip: PIPaddress): PAnsiChar cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResolveIP' {$ENDIF} {$ENDIF};
+     
+      {* Get the addresses of network interfaces on this system.
+         This returns the number of addresses saved in 'addresses'
+       *}
+    function SDLNet_GetLocalAddresses(addresses: PIPaddress; maxcount: Integer): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_GetLocalAddresses' {$ENDIF} {$ENDIF};
+     
+    {***********************************************************************}
+    {* TCP network API                                                     *}
+    {***********************************************************************}
+    type
+      _TCPSocket = record
+      end;
+      TTCPSocket = ^_TCPSocket;
+     
+      {* Open a TCP network socket
+         If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server
+         socket on the given port, otherwise a TCP connection to the remote
+         host and port is attempted. The address passed in should already be
+         swapped to network byte order (addresses returned from
+         SDLNet_ResolveHost() are already in the correct form).
+         The newly created socket is returned, or NULL if there was an error.
+      *}
+    function SDLNet_TCP_Open(ip: PIPaddress): TTCPSocket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Open' {$ENDIF} {$ENDIF};
+     
+      {* Accept an incoming connection on the given server socket.
+         The newly created socket is returned, or NULL if there was an error.
+      *}
+    function SDLNet_TCP_Accept(server: TTCPSocket): TTCPSocket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Accept' {$ENDIF} {$ENDIF};
+     
+      {* Get the IP address of the remote system associated with the socket.
+         If the socket is a server socket, this function returns NULL.
+      *}
+    function SDLNet_TCP_GetPeerAddress(sock: TTCPSocket): PIPaddress cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_GetPeerAddress' {$ENDIF} {$ENDIF};
+     
+      {* Send 'len' bytes of 'data' over the non-server socket 'sock'
+         This function returns the actual amount of data sent.  If the return value
+         is less than the amount of data sent, then either the remote connection was
+         closed, or an unknown socket error occurred.
+      *}
+    function SDLNet_TCP_Send(sock: TTCPSocket; const data: Pointer; len: Integer): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Send' {$ENDIF} {$ENDIF};
+     
+      {* Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
+         and store them in the buffer pointed to by 'data'.
+         This function returns the actual amount of data received.  If the return
+         value is less than or equal to zero, then either the remote connection was
+         closed, or an unknown socket error occurred.
+      *}
+    function SDLNet_TCP_Recv(sock: TTCPSocket; data: Pointer; maxlen: Integer): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Recv' {$ENDIF} {$ENDIF};
+     
+      {* Close a TCP network socket *}
+    procedure SDLNet_TCP_Close(sock: TTCPSocket) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Close' {$ENDIF} {$ENDIF};
+     
+    {***********************************************************************}
+    {* UDP network API                                                     *}
+    {***********************************************************************}
+     
+    const
+      {* The maximum channels on a a UDP socket *}
+       SDLNET_MAX_UDPCHANNELS = 32;
+      {* The maximum addresses bound to a single UDP socket channel *}
+      SDLNET_MAX_UDPADDRESSES = 4;
+     
+    type
+      TUDPSocket = record
+      end;
+      PUDPSocket = ^TUDPSocket;
+     
+      TUDPPacket = record
+        channel: Integer;     {* The src/dst channel of the packet *}
+        data: PUInt8;         {* The packet data *}
+        len: Integer;         {* The length of the packet data *}
+        maxlen: Integer;      {* The size of the data buffer *}
+        status: Integer;      {* packet status after sending *}
+        address: TIPaddress;  {* The source/dest address of an incoming/outgoing packet *}
+      end;
+      PUDPPacket = ^TUDPPacket;
+      PPUDPPacket = ^PUDPPacket;
+     
+      {* Allocate/resize/free a single UDP packet 'size' bytes long.
+         The new packet is returned, or NULL if the function ran out of memory.
+       *}
+    function SDLNet_AllocPacket(size: Integer): PUDPPacket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocPacket' {$ENDIF} {$ENDIF};
+    function SDLNet_ResizePacket(packet: PUDPPacket; newsize: Integer): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResizePacket' {$ENDIF} {$ENDIF};
+    procedure SDLNet_FreePacket(packet: PUDPPacket) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreePacket' {$ENDIF} {$ENDIF};
+     
+      {* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets,
+         each 'size' bytes long.
+         A pointer to the first packet in the array is returned, or NULL if the
+         function ran out of memory.
+       *}
+    function SDLNet_AllocPacketV(howmany: Integer; size: Integer): PPUDPPacket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocPacketV' {$ENDIF} {$ENDIF};
+    procedure SDLNet_FreePacketV(packetV: PPUDPPacket) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreePacketV' {$ENDIF} {$ENDIF};
+     
+      {* Open a UDP network socket
+         If 'port' is non-zero, the UDP socket is bound to a local port.
+         The 'port' should be given in native byte order, but is used
+         internally in network (big endian) byte order, in addresses, etc.
+         This allows other systems to send to this socket via a known port.
+      *}
+    function SDLNet_UDP_Open(port: UInt16): TUDPSocket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Open' {$ENDIF} {$ENDIF};
+     
+      {* Set the percentage of simulated packet loss for packets sent on the socket. *}
+    procedure SDLNet_UDP_SetPacketLoss(sock: TUDPSocket; percent: Integer) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_SetPacketLoss' {$ENDIF} {$ENDIF};
+     
+      {* Bind the address 'address' to the requested channel on the UDP socket.
+         If the channel is -1, then the first unbound channel that has not yet
+         been bound to the maximum number of addresses will be bound with
+         the given address as it's primary address.
+         If the channel is already bound, this new address will be added to the
+         list of valid source addresses for packets arriving on the channel.
+         If the channel is not already bound, then the address becomes the primary
+         address, to which all outbound packets on the channel are sent.
+         This function returns the channel which was bound, or -1 on error.
+      *}
+    function SDLNet_UDP_Bind(sock: TUDPSocket; channel: Integer; const address: PIPaddress): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Bind' {$ENDIF} {$ENDIF};
+     
+      {* Unbind all addresses from the given channel *}
+    procedure SDLNet_UDP_Unbind(sock: TUDPSocket; channel: Integer) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Unbind' {$ENDIF} {$ENDIF};
+     
+      {* Get the primary IP address of the remote system associated with the
+         socket and channel.  If the channel is -1, then the primary IP port
+         of the UDP socket is returned -- this is only meaningful for sockets
+         opened with a specific port.
+         If the channel is not bound and not -1, this function returns NULL.
+       *}
+    function SDLNet_UDP_GetPeerAddress(sock: TUDPSocket; channel: Integer): PIPaddress cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_GetPeerAddress' {$ENDIF} {$ENDIF};
+     
+      {* Send a vector of packets to the the channels specified within the packet.
+         If the channel specified in the packet is -1, the packet will be sent to
+         the address in the 'src' member of the packet.
+         Each packet will be updated with the status of the packet after it has
+         been sent, -1 if the packet send failed.
+         This function returns the number of packets sent.
+      *}
+    function SDLNet_UDP_SendV(sock: TUDPSocket; packets: PPUDPPacket; npackets: Integer): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_SendV' {$ENDIF} {$ENDIF};
+     
+      {* Send a single packet to the specified channel.
+         If the channel specified in the packet is -1, the packet will be sent to
+         the address in the 'src' member of the packet.
+         The packet will be updated with the status of the packet after it has
+         been sent.
+         This function returns 1 if the packet was sent, or 0 on error.
+     
+         NOTE:
+         The maximum size of the packet is limited by the MTU (Maximum Transfer Unit)
+         of the transport medium.  It can be as low as 250 bytes for some PPP links,
+         and as high as 1500 bytes for ethernet.
+      *}
+    function SDLNet_UDP_Send(sock: TUDPSocket; channel: Integer; packet: PUDPPacket): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Send' {$ENDIF} {$ENDIF};
+     
+      {* Receive a vector of pending packets from the UDP socket.
+         The returned packets contain the source address and the channel they arrived
+         on.  If they did not arrive on a bound channel, the the channel will be set
+         to -1.
+         The channels are checked in highest to lowest order, so if an address is
+         bound to multiple channels, the highest channel with the source address
+         bound will be returned.
+         This function returns the number of packets read from the network, or -1
+         on error.  This function does not block, so can return 0 packets pending.
+      *}
+    function SDLNet_UDP_RecvV(sock: TUDPSocket; packets: PPUDPPacket): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_RecvV' {$ENDIF} {$ENDIF};
+     
+      {* Receive a single packet from the UDP socket.
+         The returned packet contains the source address and the channel it arrived
+         on.  If it did not arrive on a bound channel, the the channel will be set
+         to -1.
+         The channels are checked in highest to lowest order, so if an address is
+         bound to multiple channels, the highest channel with the source address
+         bound will be returned.
+         This function returns the number of packets read from the network, or -1
+         on error.  This function does not block, so can return 0 packets pending.
+      *}
+    function SDLNet_UDP_Recv(sock: TUDPSocket; packet: PUDPPacket): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Recv' {$ENDIF} {$ENDIF};
+     
+      {* Close a UDP network socket *}
+    procedure SDLNet_UDP_Close(sock: TUDPSocket) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Close' {$ENDIF} {$ENDIF};
+     
+    {***********************************************************************}
+    {* Hooks for checking sockets for available data                       *}
+    {***********************************************************************}
+     
+    type
+      TSDLNet_SocketSet = record
+      end;
+      PSDLNet_SocketSet = ^TSDLNet_SocketSet;
+     
+      {* Any network socket can be safely cast to this socket type *}
+      TSDLNet_GenericSocket = record
+        ready: Integer;
+      end;
+      PSDLNet_GenericSocket = ^TSDLNet_GenericSocket;
+     
+      {* Allocate a socket set for use with SDLNet_CheckSockets()
+         This returns a socket set for up to 'maxsockets' sockets, or NULL if
+         the function ran out of memory.
+       *}
+    function SDLNet_AllocSocketSet(maxsockets: Integer): TSDLNet_GenericSocket cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocSocketSet' {$ENDIF} {$ENDIF};
+     
+      {* Add a socket to a set of sockets to be checked for available data *}
+    function SDLNet_AddSocket(set_: TSDLNet_SocketSet; sock: TSDLNet_GenericSocket): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AddSocket' {$ENDIF} {$ENDIF};
+    //function SDLNet_TCP_AddSocket(set_: TSDLNet_SocketSet; sock: TTCPSocket): Integer; inline;
+    //function SDLNet_UDP_AddSocket(set_: TSDLNet_SocketSet; sock: TUDPSocket): Integer; inline;
+     
+      {* Remove a socket from a set of sockets to be checked for available data *}
+    function SDLNet_DelSocket(set_: TSDLNet_SocketSet; sock: TSDLNet_GenericSocket): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_DelSocket' {$ENDIF} {$ENDIF};
+    //function SDLNet_TCP_DelSocket(set_: TSDLNet_SocketSet; sock: TTCPSocket): Integer; inline;
+    //function SDLNet_UDP_DelSocket(set_: TSDLNet_SocketSet; sock: TUDPSocket): Integer; inline;
+     
+      {* This function checks to see if data is available for reading on the
+         given set of sockets.  If 'timeout' is 0, it performs a quick poll,
+         otherwise the function returns when either data is available for
+         reading, or the timeout in milliseconds has elapsed, which ever occurs
+         first.  This function returns the number of sockets ready for reading,
+         or -1 if there was an error with the select() system call.
+      *}
+    function SDLNet_CheckSockets(set_: TSDLNet_SocketSet; timeout: UInt32): Integer cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_CheckSockets' {$ENDIF} {$ENDIF};
+     
+      {* After calling SDLNet_CheckSockets(), you can use this function on a
+         socket that was in the socket set, to find out if data is available
+         for reading.
+       *}
+    function SDLNet_SocketReady(sock: TSDLNet_GenericSocket): Integer; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+     
+      {* Free a set of sockets allocated by SDL_NetAllocSocketSet() *}
+    procedure SDLNet_FreeSocketSet(set_: TSDLNet_SocketSet) cdecl; external SDLNet_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreeSocketSet' {$ENDIF} {$ENDIF};
+     
+    {***********************************************************************}
+    {* Error reporting functions                                           *}
+    {***********************************************************************}
+     
+    procedure SDLNet_SetError(const fmt: PAnsiChar); cdecl;
+    function SDLNet_GetError(): PAnsiChar; cdecl;
+     
+    {***********************************************************************}
+    {* Inline functions to read/write network data                         *}
+    {***********************************************************************}
+     
+    {* Write a 16/32-bit value to network packet buffer *}
+     
+    //procedure SDLNet_Write16(value: UInt16; areap: Pointer); inline;
+    //procedure SDLNet_Write32(value: UInt32; areap: Pointer); inline;
+     
+    {* Read a 16/32-bit value from network packet buffer *}
+    //function SDLNet_Read16(const areap: Pointer): UInt16; inline;
+    //function SDLNet_Read32(const areap: Pointer): UInt32; inline;
+     
+    implementation
+     
+    procedure SDL_NET_VERSION(Out X: TSDL_Version);
+    begin
+      X.major := SDL_NET_MAJOR_VERSION;
+      X.minor := SDL_NET_MINOR_VERSION;
+      X.patch := SDL_NET_PATCHLEVEL;
+    end;
+     
+    (*
+    function SDLNet_TCP_AddSocket(set_: TSDLNet_SocketSet; sock: TTCPSocket): Integer;
+    begin
+      Result := SDLNet_AddSocket(set_, TSDLNet_GenericSocket(sock));
+    end;
+     
+    function SDLNet_UDP_AddSocket(set_: TSDLNet_SocketSet; sock: TUDPSocket): Integer;
+    begin
+      Result := SDLNet_AddSocket(set_, TSDLNet_GenericSocket(sock));
+    end;
+     
+    function SDLNet_TCP_DelSocket(set_: TSDLNet_SocketSet; sock: TTCPSocket): Integer;
+    begin
+      Result := SDLNet_DelSocket(set_, TSDLNet_GenericSocket(sock));
+    end;
+     
+    function SDLNet_UDP_DelSocket(set_: TSDLNet_SocketSet; sock: TUDPSocket): Integer;
+    begin
+      Result := SDLNet_DelSocket(set_, TSDLNet_GenericSocket(sock));
+    end;
+    *)
+     
+    function SDLNet_SocketReady(sock: TSDLNet_GenericSocket): Integer;
+    begin
+      Result := sock.ready;
+    end;
+     
+    procedure SDLNet_SetError(const fmt: PAnsiChar); cdecl;
+    begin
+      SDL_SetError(fmt);
+    end;
+     
+    function SDLNet_GetError(): PAnsiChar; cdecl;
+    begin
+      Result := SDL_GetError();
+    end;
+     
+    (*
+    procedure SDLNet_Write16(value: UInt16; areap: Pointer);
+    begin
+      PUInt16(areap) := SDL_SwapBE16(value);
+    end;
+     
+    procedure SDLNet_Write32(value: UInt32; areap: Pointer);
+    begin
+      PUInt32(areap) := SDL_SwapBE32(value);
+    end;
+     
+    {* Read a 16/32-bit value from network packet buffer *}
+    function SDLNet_Read16(const areap: Pointer): UInt16;
+    begin
+      Result := SDL_SwapBE16(PUInt16(areap));
+    end;
+     
+    function SDLNet_Read32(const areap: Pointer): UInt32;
+    begin
+      Result := SDL_SwapBE32(PUInt32(areap));
+    end;
+    *)
+    end.
+

model_viewer/sdl2/SDL2_ttf.pas

@@ -0,0 +1,306 @@
+unit sdl2_ttf;
+
+{*
+  SDL_ttf:  A companion library to SDL for working with TrueType (tm) fonts
+  Copyright (C) 2001-2013 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 acknowledgement 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.
+*}
+
+{* This library is a wrapper around the excellent FreeType 2.0 library,
+   available at:
+    http://www.freetype.org/
+*}
+
+{* ChangeLog: (Header Translation)
+   ----------
+
+   v.1.72-stable; 29.09.2013: fixed bug with procedures without parameters
+                              (they must have brackets)
+   v.1.70-stable; 11.09.2013: Initial Commit
+
+*}
+
+interface
+
+{$I jedi.inc}
+
+uses
+  SDL2;
+
+const
+  {$IFDEF WINDOWS}
+    TTF_LibName = 'SDL2_ttf.dll';
+  {$ENDIF}
+
+  {$IFDEF UNIX}
+    {$IFDEF DARWIN}
+      TTF_LibName = 'libSDL2_tff.dylib';
+    {$ELSE}
+      {$IFDEF FPC}
+        TTF_LibName = 'libSDL2_ttf.so';
+      {$ELSE}
+        TTF_LibName = 'libSDL2_ttf.so.0';
+      {$ENDIF}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IFDEF MACOS}
+    TTF_LibName = 'SDL2_ttf';
+    {$IFDEF FPC}
+      {$linklib libSDL2_ttf}
+    {$ENDIF}
+  {$ENDIF}
+
+{* Set up for C function definitions, even when using C++ *}
+
+{* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+const
+  SDL_TTF_MAJOR_VERSION = 2;
+  SDL_TTF_MINOR_VERSION = 0;
+  SDL_TTF_PATCHLEVEL    = 12;
+
+Procedure SDL_TTF_VERSION(Out X:TSDL_Version);
+
+{* Backwards compatibility *}
+const
+  TTF_MAJOR_VERSION = SDL_TTF_MAJOR_VERSION;
+  TTF_MINOR_VERSION = SDL_TTF_MINOR_VERSION;
+  TTF_PATCHLEVEL    = SDL_TTF_PATCHLEVEL;
+  //TTF_VERSION(X)    = SDL_TTF_VERSION(X);
+
+ {* This function gets the version of the dynamically linked SDL_ttf library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_TTF_VERSION() macro.
+ *}
+function TTF_Linked_Version: TSDL_Version cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Linked_Version' {$ENDIF} {$ENDIF};
+
+{* ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark) *}
+const
+  UNICODE_BOM_NATIVE  = $FEFF;
+  UNICODE_BOM_SWAPPED = $FFFE;
+
+{* This function tells the library whether UNICODE text is generally
+   byteswapped.  A UNICODE BOM character in a string will override
+   this setting for the remainder of that string.
+*}
+procedure TTF_ByteSwappedUNICODE(swapped: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_ByteSwappedUNICODE' {$ENDIF} {$ENDIF};
+
+{* The internal structure containing font information *}
+type
+  PTTF_Font = ^TTTF_Font;
+  TTTF_Font = record  end; //todo?
+
+{* Initialize the TTF engine - returns 0 if successful, -1 on error *}
+function TTF_Init(): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Init' {$ENDIF} {$ENDIF};
+
+{* Open a font file and create a font of the specified point size.
+ * Some .fon fonts will have several sizes embedded in the file, so the
+ * point size becomes the index of choosing which size.  If the value
+ * is too high, the last indexed size will be the default. *}
+function TTF_OpenFont(_file: PAnsiChar; ptsize: Integer): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFont' {$ENDIF} {$ENDIF};
+function TTF_OpenFontIndex(_file: PAnsiChar; ptsize: Integer; index: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontIndex' {$ENDIF} {$ENDIF};
+function TTF_OpenFontRW(src: PSDL_RWops; freesrc: Integer; ptsize: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontRW' {$ENDIF} {$ENDIF};
+function TTF_OpenFontIndexRW(src: PSDL_RWops; freesrc: Integer; ptsize: Integer; index: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontIndexRW' {$ENDIF} {$ENDIF};
+
+{* Set and retrieve the font style *}
+const
+  TTF_STYLE_NORMAL        = $00;
+  TTF_STYLE_BOLD          = $01;
+  TTF_STYLE_ITALIC        = $02;
+  TTF_STYLE_UNDERLINE     = $04;
+  TTF_STYLE_STRIKETHROUGH = $08;
+
+function TTF_GetFontStyle(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontStyle' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontStyle(font: PTTF_Font; style: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontStyle' {$ENDIF} {$ENDIF};
+function TTF_GetFontOutline(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontOutline' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontOutline(font: PTTF_Font; outline: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontOutline' {$ENDIF} {$ENDIF};
+
+{* Set and retrieve FreeType hinter settings *}
+const
+  TTF_HINTING_NORMAL  = 0;
+  TTF_HINTING_LIGHT   = 1;
+  TTF_HINTING_MONO    = 2;
+  TTF_HINTING_NONE    = 3;
+
+function TTF_GetFontHinting(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontHinting' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontHinting(font: PTTF_Font; hinting: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontHinting' {$ENDIF} {$ENDIF};
+
+{* Get the total height of the font - usually equal to point size *}
+function TTF_FontHeight(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontHeight' {$ENDIF} {$ENDIF};
+
+{* Get the offset from the baseline to the top of the font
+   This is a positive value, relative to the baseline.
+ *}
+function TTF_FontAscent(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontAscent' {$ENDIF} {$ENDIF};
+
+{* Get the offset from the baseline to the bottom of the font
+   This is a negative value, relative to the baseline.
+ *}
+function TTF_FontDescent(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontDescent' {$ENDIF} {$ENDIF};
+
+{* Get the recommended spacing between lines of text for this font *}
+function TTF_FontLineSkip(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontLineSkip' {$ENDIF} {$ENDIF};
+
+{* Get/Set whether or not kerning is allowed for this font *}
+function TTF_GetFontKerning(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontKerning' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontKerning(font: PTTF_Font; allowed: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontKerning' {$ENDIF} {$ENDIF};
+
+{* Get the number of faces of the font *}
+function TTF_FontFaces(font: PTTF_Font): LongInt cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaces' {$ENDIF} {$ENDIF};
+
+{* Get the font face attributes, if any *}
+function TTF_FontFaceIsFixedWidth(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceIsFixedWidth' {$ENDIF} {$ENDIF};
+function TTF_FontFaceFamilyName(font: PTTF_Font): PAnsiChar cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceFamilyName' {$ENDIF} {$ENDIF};
+function TTF_FontFaceStyleName(font: PTTF_Font): PAnsiChar cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceStyleName' {$ENDIF} {$ENDIF};
+
+{* Check wether a glyph is provided by the font or not *}
+function TTF_GlyphIsProvided(font: PTTF_Font; ch: UInt16): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GlyphIsProvided' {$ENDIF} {$ENDIF};
+
+{* Get the metrics (dimensions) of a glyph
+   To understand what these metrics mean, here is a useful link:
+    http://freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
+ *}
+function TTF_GlyphMetrics(font: PTTF_Font; ch: UInt16;
+                          minx, maxx: PInt;
+                          miny, maxy: PInt; advance: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GlyphMetrics' {$ENDIF} {$ENDIF};
+
+{* Get the dimensions of a rendered string of text *}
+function TTF_SizeText(font: PTTF_Font; text: PAnsiChar; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeText' {$ENDIF} {$ENDIF};
+function TTF_SizeUTF8(font: PTTF_Font; text: PAnsiChar; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeUTF8' {$ENDIF} {$ENDIF};
+function TTF_SizeUNICODE(font: PTTF_Font; text: PUInt16; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeUNICODE' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given text at
+   fast quality with the given font and color.  The 0 pixel is the
+   colorkey, giving a transparent background, and the 1 pixel is set
+   to the text color.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Solid(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Solid' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Solid(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Solid' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Solid(font: PTTF_Font; text: PUInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Solid' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given glyph at
+   fast quality with the given font and color.  The 0 pixel is the
+   colorkey, giving a transparent background, and the 1 pixel is set
+   to the text color.  The glyph is rendered without any padding or
+   centering in the X direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Solid(font: PTTF_Font; ch: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Solid' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given text at
+   high quality with the given font and colors.  The 0 pixel is background,
+   while other pixels have varying degrees of the foreground color.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Shaded(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Shaded' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Shaded(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Shaded' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Shaded(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Shaded' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given glyph at
+   high quality with the given font and colors.  The 0 pixel is background,
+   while other pixels have varying degrees of the foreground color.
+   The glyph is rendered without any padding or centering in the X
+   direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Shaded(font: PTTF_Font; ch: UInt16; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Shaded' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given text at high quality,
+   using alpha blending to dither the font with the given color.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Blended(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Blended' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Blended(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Blended' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Blended(font: PTTF_Font; text: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Blended' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given text at high quality,
+   using alpha blending to dither the font with the given color.
+   Text is wrapped to multiple lines on line endings and on word boundaries
+   if it extends beyond wrapLength in pixels.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Blended_Wrapped(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Blended_Wrapped' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Blended_Wrapped(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Blended_Wrapped' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Blended_Wrapped(font: PTTF_Font; text: PUInt16; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Blended_Wrapped' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given glyph at high quality,
+   using alpha blending to dither the font with the given color.
+   The glyph is rendered without any padding or centering in the X
+   direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Blended(font: PTTF_Font; ch: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Blended' {$ENDIF} {$ENDIF};
+
+{* For compatibility with previous versions, here are the old functions *}
+function TTF_RenderText(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+function TTF_RenderUTF8(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+function TTF_RenderUNICODE(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface;
+
+{* Close an opened font file *}
+procedure TTF_CloseFont(font: PTTF_Font) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_CloseFont' {$ENDIF} {$ENDIF};
+
+{* De-initialize the TTF engine *}
+procedure TTF_Quit() cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Quit' {$ENDIF} {$ENDIF};
+
+{* Check if the TTF engine is initialized *}
+function TTF_WasInit: Boolean cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_WasInit' {$ENDIF} {$ENDIF};
+
+{* Get the kerning size of two glyphs *}
+function TTF_GetFontKerningSize(font: PTTF_Font; prev_index, index: Integer): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontKerningSize' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function TTF_SetError(const fmt: PAnsiChar): SInt32; cdecl;
+function TTF_GetError: PAnsiChar; cdecl;
+
+implementation
+
+Procedure SDL_TTF_VERSION(Out X:TSDL_Version);
+begin
+  x.major := SDL_TTF_MAJOR_VERSION;
+  x.minor := SDL_TTF_MINOR_VERSION;
+  x.patch := SDL_TTF_PATCHLEVEL;
+end;
+
+function TTF_SetError(const fmt: PAnsiChar): SInt32; cdecl;
+begin
+  Result := SDL_SetError(fmt);
+end;
+
+function TTF_GetError: PAnsiChar; cdecl;
+begin
+  Result := SDL_GetError();
+end;
+
+function TTF_RenderText(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+  Result := TTF_RenderText_Shaded(font, text, fg, bg);
+end;
+
+function TTF_RenderUTF8(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+  Result := TTF_RenderUTF8_Shaded(font, text, fg, bg);
+end;
+
+function TTF_RenderUNICODE(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+  Result := TTF_RenderUNICODE_Shaded(font, text, fg, bg);
+end;
+
+end.
+

model_viewer/sdl2/jedi.inc

@@ -0,0 +1,526 @@
+{
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+  Pascal-Header-Conversion
+  Copyright (c) 2012/13 Tim Blume aka End
+
+  sdl.inc is based on the files:
+    "begin_code.h",
+    "close_code.h",
+	  "sdl_config.h",
+	  "sdl_config_windows.h",
+   	...
+  it defines some variables for several Pascal-Compilers and OS-versions.
+
+  It is based on mine updated version of jedi-sdl.inc from the SDL 1.2 Headers,
+  they can be found at delphigl.com or on my github-repository:
+
+  https://github.com/ev1313/
+
+  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.
+}
+
+{
+  Changelog:
+  ----------
+  v. 1.63-stable; 16.09.13: since GPC isn't supported anymore, i've deleted it from here, too.
+  v. 1.22-alpha; 24.07.13: fixed some bugs. special thanks to kotai from pascalgamedevelopment.com
+  v. 1.00-alpha; 05.07.13: Initial Alpha-Release
+}
+
+{.$define Debug}           { uncomment for debugging }
+
+{$IFNDEF FPC}
+  {$IFDEF Debug}
+    {$F+,D+,Q-,L+,R+,I-,S+,Y+,A+}
+  {$ELSE}
+    {$F+,Q-,R-,S-,I-,A+}
+  {$ENDIF}
+{$ELSE}
+  {$MODE DELPHI}
+{$ENDIF}
+
+{$IFDEF LINUX}
+{$DEFINE UNIX}
+{$ENDIF}
+
+{$IFDEF ver70}
+   {$IFDEF Windows}
+     {$DEFINE Win16}
+   {$ENDIF Windows}
+   {$IFDEF MSDOS}
+     {$DEFINE NO_EXPORTS}
+   {$ENDIF MSDOS}
+   {$IFDEF DPMI}
+     {$DEFINE BP_DPMI}
+   {$ENDIF}
+   {$DEFINE OS_16_BIT}
+   {$DEFINE __OS_DOS__}
+{$ENDIF ver70}
+
+{$IFDEF ver80}
+   {$DEFINE Delphi}      {Delphi 1.x}
+   {$DEFINE Delphi16}
+   {$DEFINE Win16}
+   {$DEFINE OS_16_BIT}
+   {$DEFINE __OS_DOS__}
+{$ENDIF ver80}
+
+{$IFDEF ver90}
+   {$DEFINE Delphi}      {Delphi 2.x}
+   {$DEFINE WIN32}
+   {$DEFINE WINDOWS}
+{$ENDIF ver90}
+
+{$IFDEF ver100}
+   {$DEFINE Delphi}      {Delphi 3.x}
+   {$DEFINE WIN32}
+   {$DEFINE WINDOWS}
+{$ENDIF ver100}
+
+{$IFDEF ver93}
+   {$DEFINE Delphi}      {C++ Builder 1.x}
+   {$DEFINE WINDOWS}
+{$ENDIF ver93}
+
+{$IFDEF ver110}
+   {$DEFINE Delphi}      {C++ Builder 3.x}
+   {$DEFINE WINDOWS}
+{$ENDIF ver110}
+
+{$IFDEF ver120}
+   {$DEFINE Delphi}      {Delphi 4.x}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Has_Int64}
+   {$DEFINE WINDOWS}
+{$ENDIF ver120}
+
+{$IFDEF ver130}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 5.x}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Has_Int64}
+   {$DEFINE WINDOWS}
+{$ENDIF ver130}
+
+{$IFDEF ver140}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 6.x}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Has_Int64}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver140}
+
+{$IFDEF ver150}
+   {$DEFINE Delphi}      {Delphi 7.x}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver150}
+
+{$IFDEF ver160}
+   {$DEFINE Delphi}      {Delphi 8.x}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver160}
+
+{$IFDEF ver170}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2005}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver170}
+
+{$IFDEF ver180}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2006 / 2007}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver180}
+
+{$IFDEF ver185}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2007}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver185}
+
+{$IFDEF ver190}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2007 }
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver190}
+
+{$IFDEF ver200}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2009 }
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver200}
+
+{$IFDEF ver210}
+   {$DEFINE Delphi}      {Delphi / C++ Builder 2010}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver210}
+
+{$IFDEF ver220}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver220}
+
+{$IFDEF ver230}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE2}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver230}
+
+{$IFDEF ver240}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE4}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$DEFINE Delphi17UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver240}
+
+{$IFDEF ver250}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE5}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$DEFINE Delphi17UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver250}
+
+{$IFDEF ver260}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE6}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$DEFINE Delphi17UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver260}
+
+{$IFDEF ver270}
+   {$DEFINE Delphi}      {Delphi / C++ Builder XE7}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$DEFINE Delphi17UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$ENDIF ver270}
+
+{$IFNDEF FPC}	  
+{$IF CompilerVersion > 27}
+   {$DEFINE Delphi}      {Delphi / C++ Builder}
+   {$DEFINE Delphi4UP}
+   {$DEFINE Delphi5UP}
+   {$DEFINE Delphi6UP}
+   {$DEFINE Delphi7UP}
+   {$DEFINE Delphi8UP}
+   {$DEFINE Delphi9UP}
+   {$DEFINE Delphi10UP}
+   {$DEFINE Delphi11UP}
+   {$DEFINE Delphi12UP}
+   {$DEFINE Delphi13UP}
+   {$DEFINE Delphi14UP}
+   {$DEFINE Delphi15UP}
+   {$DEFINE Delphi16UP}
+   {$DEFINE Delphi17UP}
+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+   {$DEFINE Has_Int64}
+   {$DEFINE Has_UInt64}
+   {$DEFINE Has_Native}
+   {$DEFINE HAS_TYPES}
+{$IFEND}
+{$ENDIF}
+	  
+{*************** define 16/32/64 Bit ********************}
+
+{$IFDEF WIN16}
+  {$DEFINE 16BIT}
+  {$DEFINE WINDOWS}
+{$ELSE}
+  {$IFDEF WIN32}
+    {$DEFINE 32BIT}
+    {$DEFINE WINDOWS}
+  {$ELSE}
+    {$IFDEF WIN64}
+      {$DEFINE 64BIT}
+      {$DEFINE WINDOWS}
+    {$ELSE}
+      //TODO!!
+      {$DEFINE 32BIT}
+    {$ENDIF}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF Delphi}
+  {$DEFINE USE_STDCALL}
+  {$IFDEF 32Bit}
+    {$DEFINE DELPHI32}
+  {$ELSE}
+    {$IFDEF 64Bit}
+	  {$DEFINE DELPHI64}
+	{$ELSE}
+	  {$DEFINE DELPHI16}
+	{$ENDIF}
+  {$ENDIF}
+  //{$ALIGN ON}
+{$ENDIF Delphi}
+
+{$IFDEF FPC}
+  {$H+}
+  {$PACKRECORDS C}        // Added for record
+  {$MACRO ON}             // Added For OpenGL
+  {$DEFINE Delphi}
+  {$DEFINE UseAT}
+  {$UNDEF USE_STDCALL}
+  {$DEFINE OS_BigMem}
+  {$DEFINE NO_EXPORTS}
+  {$DEFINE Has_UInt64}
+  {$DEFINE Has_Int64}
+  {$DEFINE Has_Native}
+  {$DEFINE NOCRT}
+  {$IFDEF UNIX}
+     {$DEFINE fpc_unix}
+  {$ELSE}
+     {$DEFINE __OS_DOS__}
+  {$ENDIF}
+  {$IFDEF WIN32}
+   {$DEFINE UseWin}
+  {$ENDIF}
+  {$DEFINE HAS_TYPES}
+{$ENDIF FPC}
+
+{$IFDEF Win16}
+  {$K+}   {smart callbacks}
+{$ENDIF Win16}
+
+{$IFDEF Win32}
+  {$DEFINE OS_BigMem}
+{$ENDIF Win32}
+
+{ ************************** dos/dos-like platforms **************}
+{$IFDEF Windows}
+   {$DEFINE __OS_DOS__}
+   {$DEFINE UseWin}
+   {$DEFINE MSWINDOWS}
+{$ENDIF Delphi}
+
+{$IFDEF OS2}
+   {$DEFINE __OS_DOS__}
+   {$DEFINE Can_Use_DLL}
+{$ENDIF Delphi}
+
+{$IFDEF UseWin}
+   {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF Win16}
+   {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF BP_DPMI}
+   {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF USE_STDCALL}
+  {$DEFINE BY_NAME}
+{$ENDIF}
+
+{*************** define LITTLE ENDIAN platforms ********************}
+
+
+{$IFDEF Delphi}
+  {$DEFINE IA32}
+{$ENDIF}
+
+{$IFDEF FPC}
+  {$IFDEF FPC_LITTLE_ENDIAN}
+    {$DEFINE IA32}
+  {$ENDIF}
+{$ENDIF}

model_viewer/sdl2/sdl.inc

@@ -0,0 +1,62 @@
+//from "sdl.h"
+
+const
+
+  SDL_INIT_TIMER          = $00000001;
+  {$EXTERNALSYM SDL_INIT_TIMER}
+  SDL_INIT_AUDIO          = $00000010;
+  {$EXTERNALSYM SDL_INIT_AUDIO}
+  SDL_INIT_VIDEO          = $00000020;
+  {$EXTERNALSYM SDL_INIT_VIDEO}
+  SDL_INIT_JOYSTICK       = $00000200;
+  {$EXTERNALSYM SDL_INIT_JOYSTICK}
+  SDL_INIT_HAPTIC         = $00001000;
+  {$EXTERNALSYM SDL_INIT_HAPTIC}
+  SDL_INIT_GAMECONTROLLER = $00002000;  //turn on game controller also implicitly does JOYSTICK
+  {$EXTERNALSYM SDL_INIT_GAMECONTROLLER}
+  SDL_INIT_NOPARACHUTE    = $00100000;  //Don't catch fatal signals
+  {$EXTERNALSYM SDL_INIT_NOPARACHUTE}
+  SDL_INIT_EVERYTHING     = SDL_INIT_TIMER    or
+							SDL_INIT_AUDIO    or
+							SDL_INIT_VIDEO    or
+							SDL_INIT_JOYSTICK or
+							SDL_INIT_HAPTIC   or
+							SDL_INIT_GAMECONTROLLER;
+  {$EXTERNALSYM SDL_INIT_EVERYTHING}
+
+{**
+ *  This function initializes  the subsystems specified by flags
+ *  Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
+ *  signal handlers for some commonly ignored fatal signals (like SIGSEGV).
+ *}
+
+function SDL_Init(flags: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Init' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function initializes specific SDL subsystems
+ *}
+
+function SDL_InitSubSystem(flags: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_InitSubSystem' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function cleans up specific SDL subsystems
+ *}
+ 
+procedure SDL_QuitSubSystem(flags: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QuitSubSystem' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns a mask of the specified subsystems which have
+ *  previously been initialized.
+ *  
+ *  If flags is 0, it returns a mask of all initialized subsystems.
+ *}
+ 
+function SDL_WasInit(flags: UInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WasInit' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function cleans up all initialized subsystems. You should
+ *  call it upon all exit conditions.
+ *}
+ 
+procedure SDL_Quit() cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Quit' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdl2.pas

@@ -0,0 +1,435 @@
+unit SDL2;
+
+{
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+  Pascal-Header-Conversion
+  Copyright (C) 2012-2014 Tim Blume aka End/EV1313
+
+  SDL.pas is based on the files:
+  "sdl.h",
+  "sdl_audio.h",
+  "sdl_blendmode.h",
+  "sdl_clipboard.h",
+  "sdl_cpuinfo.h",
+  "sdl_events.h",
+  "sdl_error.h",
+  "sdl_filesystem.h",
+  "sdl_gamecontroller.h",
+  "sdl_gesture.h",
+  "sdl_haptic.h",
+  "sdl_hints.h",
+  "sdl_joystick.h",
+  "sdl_keyboard.h",
+  "sdl_keycode.h",
+  "sdl_loadso.h",
+  "sdl_log.h",
+  "sdl_pixels.h",
+  "sdl_power.h",
+  "sdl_main.h",
+  "sdl_messagebox.h",
+  "sdl_mouse.h",
+  "sdl_mutex.h",
+  "sdl_rect.h",
+  "sdl_render.h",
+  "sdl_rwops.h",
+  "sdl_scancode.h",
+  "sdl_shape.h",
+  "sdl_stdinc.h",
+  "sdl_surface.h",
+  "sdl_system.h",
+  "sdl_syswm.h",
+  "sdl_thread.h",
+  "sdl_timer.h",
+  "sdl_touch.h",
+  "sdl_version.h",
+  "sdl_video.h",
+  "sdl_types.h"
+
+  I will not translate:
+  "sdl_opengl.h",
+  "sdl_opengles.h"
+  "sdl_opengles2.h"
+
+  cause there's a much better OpenGL-Header avaible at delphigl.com:
+
+  the dglopengl.pas
+
+  Parts of the SDL.pas are from the SDL-1.2-Headerconversion from the JEDI-Team,
+  written by Domenique Louis and others.
+
+  I've changed the names of the dll for 32 & 64-Bit, so theres no conflict
+  between 32 & 64 bit Libraries.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no case 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.
+
+  Special Thanks to:
+
+   - DelphiGL.com - Community
+   - Domenique Louis and everyone else from the JEDI-Team
+   - Sam Latinga and everyone else from the SDL-Team
+}
+
+{
+  Changelog:
+  ----------
+               ? 31.01.2016: updated sdlevents.inc to SDL2 2.0.4, adressing issue #24 (thx to imantsg)
+               ? 16.01.2016: Delphi 6+ bugfixes/compatibility. Thx to Peter Karpov for identifiying and testing.
+  v.1.80-stable; 09.10.2014: added sdl_cpuinfo.h and sdl_clipboard.h
+  v.1.74-stable; 10.11.2013: added sdl_gamecontroller.h
+  v.1.73-stable; 08.11.2013: added sdl_hints.h and some keystate helpers
+                             thx to Cybermonkey!
+  v.1.72-stable; 23.09.2013: fixed bug with procedures without parameters
+                             (they must have brakets)
+  v.1.70-stable; 17.09.2013: added "sdl_messagebox.h" and "sdl_haptic.h"
+  v.1.63-stable; 16.09.2013: added libs sdl2_image and sdl2_ttf and added sdl_audio.h
+  v.1.62-stable; 03.09.2013: fixed.
+  v.1.61-stable; 02.09.2013: now it should REALLY work with Mac...
+  v.1.60-stable; 01.09.2013: now it should work with Delphi XE4 for Windows and
+                            MacOS and of course Lazarus. thx to kotai :D
+  v.1.55-Alpha; 24.08.2013: fixed bug with SDL_GetEventState thx to d.l.i.w.
+  v.1.54-Alpha; 24.08.2013: added sdl_loadso.h
+  v.1.53-Alpha; 24.08.2013: renamed *really* and fixed linux comp.
+  v.1.52-Alpha; 24.08.2013: renamed sdl.pas to sdl2.pas
+  v.1.51-Alpha; 24.08.2013: added sdl_platform.h
+  v.1.50-Alpha; 24.08.2013: the header is now modular. thx for the hint from d.l.i.w.
+  v.1.40-Alpha; 13.08.2013: Added MacOS compatibility (thx to stoney-fd)
+  v.1.34-Alpha; 05.08.2013: Added missing functions from sdl_thread.h
+  v.1.33-Alpha; 31.07.2013: Added missing units for Linux. thx to Cybermonkey
+  v.1.32-Alpha; 31.07.2013: Fixed three bugs, thx to grieferatwork
+  v.1.31-Alpha; 30.07.2013: Added "sdl_power.h"
+  v.1.30-Alpha; 26.07.2013: Added "sdl_thread.h" and "sdl_mutex.h"
+  v.1.25-Alpha; 29.07.2013: Added Makros for SDL_RWops
+  v.1.24-Alpha; 28.07.2013: Fixed bug with RWops and size_t
+  v.1.23-Alpha; 27.07.2013: Fixed two bugs, thx to GrieferAtWork
+  v.1.22-Alpha; 24.07.2013: Added "sdl_shape.h" and TSDL_Window
+                            (and ordered the translated header list ^^)
+  v.1.21-Alpha; 23.07.2013: Added TSDL_Error
+  v.1.20-Alpha; 19.07.2013: Added "sdl_timer.h"
+  v.1.10-Alpha; 09.07.2013: Added "sdl_render.h"
+  v.1.00-Alpha; 05.07.2013: Initial Alpha-Release.
+}
+
+{$DEFINE SDL}
+
+{$I jedi.inc}
+
+interface
+
+  {$IFDEF WINDOWS}
+    uses
+      Windows;
+  {$ENDIF}
+
+  {$IFDEF LINUX}
+    uses
+      X,
+      XLib;
+  {$ENDIF}
+  
+  {$IFDEF DARWIN}
+    uses
+      X,
+      XLib,
+      CocoaAll;
+  {$ENDIF}
+
+const
+
+  {$IFDEF WINDOWS}
+    SDL_LibName = 'SDL2.dll';
+  {$ENDIF}
+
+  {$IFDEF UNIX}
+    {$IFDEF DARWIN}
+      SDL_LibName = 'libSDL2.dylib';
+    {$ELSE}
+      {$IFDEF FPC}
+        SDL_LibName = 'libSDL2.so';
+      {$ELSE}
+        SDL_LibName = 'libSDL2.so.0';
+      {$ENDIF}
+    {$ENDIF}
+  {$ENDIF}
+
+  {$IFDEF MACOS}
+    SDL_LibName = 'SDL2';
+    {$IFDEF FPC}
+      {$linklib libSDL2}
+    {$ENDIF}
+  {$ENDIF}
+
+{$I sdltype.inc}
+{$I sdlversion.inc}
+{$I sdlerror.inc}
+{$I sdlplatform.inc}
+{$I sdlpower.inc}
+{$I sdlthread.inc}
+{$I sdlmutex.inc}
+{$I sdltimer.inc}
+{$I sdlpixels.inc}
+{$I sdlrect.inc}
+{$I sdlrwops.inc}
+{$I sdlaudio.inc}
+{$I sdlblendmode.inc}
+{$I sdlsurface.inc}
+{$I sdlshape.inc}
+{$I sdlvideo.inc}
+{$I sdlhints.inc}
+{$I sdlloadso.inc}
+{$I sdlmessagebox.inc}
+{$I sdlrenderer.inc}
+{$I sdlscancode.inc}
+{$I sdlkeyboard.inc}
+{$I sdlmouse.inc}
+{$I sdljoystick.inc}
+{$I sdlgamecontroller.inc}
+{$I sdlhaptic.inc}
+{$I sdltouch.inc}
+{$I sdlgesture.inc}
+{$I sdlsyswm.inc}
+{$I sdlevents.inc}
+{$I sdlclipboard.inc}
+{$I sdlcpuinfo.inc}
+{$I sdlfilesystem.inc}
+{$I sdllog.inc}
+{$I sdlsystem.inc}
+{$I sdl.inc}
+
+implementation
+
+//from "sdl_version.h"
+procedure SDL_VERSION(Out x: TSDL_Version);
+begin
+  x.major := SDL_MAJOR_VERSION;
+  x.minor := SDL_MINOR_VERSION;
+  x.patch := SDL_PATCHLEVEL;
+end;
+
+function SDL_VERSIONNUM(X,Y,Z: UInt32): Cardinal;
+begin
+  Result := X*1000 + Y*100 + Z;
+end;
+
+function SDL_COMPILEDVERSION: Cardinal;
+begin
+  Result := SDL_VERSIONNUM(SDL_MAJOR_VERSION,
+                           SDL_MINOR_VERSION,
+                           SDL_PATCHLEVEL);
+end;
+
+function SDL_VERSION_ATLEAST(X,Y,Z: Cardinal): Boolean;
+begin
+  Result := SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X,Y,Z);
+end;
+
+//from "sdl_mouse.h"
+function SDL_Button(button: SInt32): SInt32;
+begin
+  Result := 1 shl (button - 1); 
+end;
+
+{$IFDEF WINDOWS}
+//from "sdl_thread.h"
+
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; overload;
+begin
+  Result := SDL_CreateThread(fn,name,data,nil,nil);
+end;
+
+{$ENDIF}
+
+//from "sdl_rect.h"
+function SDL_RectEmpty(X: TSDL_Rect): Boolean;
+begin
+  Result := (X.w <= 0) or (X.h <= 0);
+end;
+
+function SDL_RectEquals(A: TSDL_Rect; B: TSDL_Rect): Boolean;
+begin
+  Result := (A.x = B.x) and (A.y = B.y) and (A.w = B.w) and (A.h = B.h);
+end;
+
+function SDL_PointInRect(const p: PSDL_Point; const r: PSDL_Rect): Boolean; Inline;
+begin
+  Result := 
+    (p^.x >= r^.x) and (p^.x < (r^.x + r^.w)) 
+    and 
+    (p^.y >= r^.y) and (p^.y < (r^.y + r^.h))
+end;
+
+//from "sdl_rwops.h"
+
+function SDL_RWsize(ctx: PSDL_RWops): SInt64;
+begin
+  Result := ctx^.size(ctx);
+end;
+
+function SDL_RWseek(ctx: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64;
+begin
+  Result := ctx^.seek(ctx,offset,whence);
+end;
+
+function SDL_RWtell(ctx: PSDL_RWops): SInt64;
+begin
+  Result := ctx^.seek(ctx, 0, RW_SEEK_CUR);
+end;
+
+function SDL_RWread(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+begin
+  Result := ctx^.read(ctx, ptr, size, n);
+end;
+
+function SDL_RWwrite(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+begin
+  Result := ctx^.write(ctx, ptr, size, n);
+end;
+
+function SDL_RWclose(ctx: PSDL_RWops): SInt32;
+begin
+  Result := ctx^.close(ctx);
+end;
+
+//from "sdl_audio.h"
+
+function SDL_LoadWAV(_file: PAnsiChar; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec;
+begin
+  Result := SDL_LoadWAV_RW(SDL_RWFromFile(_file, 'rb'), 1, spec, audio_buf, audio_len);
+end;
+  
+function SDL_AUDIO_BITSIZE(x: Cardinal): Cardinal;
+begin
+  Result := x and SDL_AUDIO_MASK_BITSIZE;
+end;
+
+function SDL_AUDIO_ISFLOAT(x: Cardinal): Cardinal;
+begin
+  Result := x and SDL_AUDIO_MASK_DATATYPE;
+end;
+
+function SDL_AUDIO_ISBIGENDIAN(x: Cardinal): Cardinal;
+begin
+  Result := x and SDL_AUDIO_MASK_ENDIAN;
+end;
+
+function SDL_AUDIO_ISSIGNED(x: Cardinal): Cardinal;
+begin
+  Result := x and SDL_AUDIO_MASK_SIGNED;
+end;
+
+function SDL_AUDIO_ISINT(x: Cardinal): Cardinal;
+begin
+  Result := not SDL_AUDIO_ISFLOAT(x);
+end;
+
+function SDL_AUDIO_ISLITTLEENDIAN(x: Cardinal): Cardinal;
+begin
+  Result := not SDL_AUDIO_ISLITTLEENDIAN(x);
+end;
+
+function SDL_AUDIO_ISUNSIGNED(x: Cardinal): Cardinal;
+begin
+  Result := not SDL_AUDIO_ISSIGNED(x);
+end;
+
+//from "sdl_pixels.h"
+
+function SDL_PIXELFLAG(X: Cardinal): Cardinal;
+begin
+  Result := (X shr 28) and $0F;
+end;
+
+function SDL_PIXELTYPE(X: Cardinal): Cardinal;
+begin
+  Result := (X shr 24) and $0F;
+end;
+
+function SDL_PIXELORDER(X: Cardinal): Cardinal;
+begin
+  Result := (X shr 20) and $0F;
+end;
+
+function SDL_PIXELLAYOUT(X: Cardinal): Cardinal;
+begin
+  Result := (X shr 16) and $0F;
+end;
+
+function SDL_BITSPERPIXEL(X: Cardinal): Cardinal;
+begin
+  Result := (X shr 8) and $FF;
+end;
+
+function SDL_IsPixelFormat_FOURCC(format: Variant): Boolean;
+begin
+  {* The flag is set to 1 because 0x1? is not in the printable ASCII range *}
+  Result := format and SDL_PIXELFLAG(format) <> 1;
+end;
+
+//from "sdl_surface.h"
+function SDL_LoadBMP(_file: PAnsiChar): PSDL_Surface;
+begin
+  Result := SDL_LoadBMP_RW(SDL_RWFromFile(_file, 'rb'), 1);
+end;
+
+function SDL_SaveBMP(Const surface:PSDL_Surface; Const filename:AnsiString):sInt32;
+begin
+   Result := SDL_SaveBMP_RW(surface, SDL_RWFromFile(PAnsiChar(filename), 'wb'), 1)
+end;
+
+{**
+ *  Evaluates to true if the surface needs to be locked before access.
+ *}
+function SDL_MUSTLOCK(Const S:PSDL_Surface):Boolean;
+begin
+  Result := ((S^.flags and SDL_RLEACCEL) <> 0)
+end;
+
+//from "sdl_video.h"
+function SDL_WindowPos_IsUndefined(X: Variant): Variant;
+begin
+  Result := (X and $FFFF0000) = SDL_WINDOWPOS_UNDEFINED_MASK;
+end;
+
+function SDL_WindowPos_IsCentered(X: Variant): Variant;
+begin
+  Result := (X and $FFFF0000) = SDL_WINDOWPOS_CENTERED_MASK;
+end;
+
+//from "sdl_events.h"
+
+function SDL_GetEventState(type_: UInt32): UInt8;
+begin
+  Result := SDL_EventState(type_, SDL_QUERY);
+end;
+
+// from "sdl_timer.h"
+function SDL_TICKS_PASSED(Const A, B:UInt32):Boolean;
+begin
+   Result := ((Int64(B) - Int64(A)) <= 0)
+end;
+
+// from "sdl_gamecontroller.h"
+  {**
+   *  Load a set of mappings from a file, filtered by the current SDL_GetPlatform()
+   *}
+function SDL_GameControllerAddMappingsFromFile(Const FilePath:PAnsiChar):SInt32;
+begin
+  Result := SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(FilePath, 'rb'), 1)
+end;
+
+end.

model_viewer/sdl2/sdlaudio.inc

@@ -0,0 +1,568 @@
+//from sdl_audio.h
+ {**
+   *   Audio format flags.
+   *
+   *  These are what the 16 bits in SDL_AudioFormat currently mean...
+   *  (Unspecified bits are always zero).
+   *
+   *
+      ++-----------------------sample is signed if set
+      ||
+      ||       ++-----------sample is bigendian if set
+      ||       ||
+      ||       ||          ++---sample is float if set
+      ||       ||          ||
+      ||       ||          || +---sample bit size---+
+      ||       ||          || |                     |
+      15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
+   *
+   *  There are macros in SDL 2.0 and later to query these bits.
+   *}
+type
+  TSDL_AudioFormat = UInt16;
+
+  {**
+   *   Audio flags
+   *}
+const
+  SDL_AUDIO_MASK_BITSIZE      = ($FF);
+  SDL_AUDIO_MASK_DATATYPE     = (1 shl 8);
+  SDL_AUDIO_MASK_ENDIAN       = (1 shl 12);
+  SDL_AUDIO_MASK_SIGNED       = (1 shl 15);
+
+function SDL_AUDIO_BITSIZE(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISFLOAT(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISBIGENDIAN(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISSIGNED(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISINT(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISLITTLEENDIAN(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISUNSIGNED(x: Cardinal): Cardinal;
+
+  {**
+   *   Audio format flags
+   *
+   *  Defaults to LSB byte order.
+   *}
+const
+  AUDIO_U8      = $0008;  {**< Unsigned 8-bit samples *}
+  AUDIO_S8      = $8008;  {**< Signed 8-bit samples *}
+  AUDIO_U16LSB  = $0010;  {**< Unsigned 16-bit samples *}
+  AUDIO_S16LSB  = $8010;  {**< Signed 16-bit samples *}
+  AUDIO_U16MSB  = $1010;  {**< As above, but big-endian byte order *}
+  AUDIO_S16MSB  = $9010;  {**< As above, but big-endian byte order *}
+  AUDIO_U16     = AUDIO_U16LSB;
+  AUDIO_S16     = AUDIO_S16LSB;
+
+  {**
+   *   int32 support
+   *}
+const
+  AUDIO_S32LSB  = $8020;  {**< 32-bit integer samples *}
+  AUDIO_S32MSB  = $9020;  {**< As above, but big-endian byte order *}
+  AUDIO_S32     = AUDIO_S32LSB;
+
+  {**
+   *   float32 support
+   *}
+const
+  AUDIO_F32LSB  = $8120;  {**< 32-bit floating point samples *}
+  AUDIO_F32MSB  = $9120;  {**< As above, but big-endian byte order *}
+  AUDIO_F32     = AUDIO_F32LSB;
+
+  {**
+   *   Native audio byte ordering
+   *}
+{$IFDEF FPC}
+   {$IF DEFINED(ENDIAN_LITTLE)}
+      AUDIO_U16SYS = AUDIO_U16LSB;
+      AUDIO_S16SYS = AUDIO_S16LSB;
+      AUDIO_S32SYS = AUDIO_S32LSB;
+      AUDIO_F32SYS = AUDIO_F32LSB;
+   {$ELSEIF DEFINED(ENDIAN_BIG)}
+      AUDIO_U16SYS = AUDIO_U16MSB;
+      AUDIO_S16SYS = AUDIO_S16MSB;
+      AUDIO_S32SYS = AUDIO_S32MSB;
+      AUDIO_F32SYS = AUDIO_F32MSB;
+   {$ELSE}
+      {$FATAL Cannot determine endianness.}
+   {$IFEND}
+{$ENDIF}
+
+  {**
+   *   Allow change flags
+   *
+   *  Which audio format changes are allowed when opening a device.
+   *}
+const
+  SDL_AUDIO_ALLOW_FREQUENCY_CHANGE  = $00000001;
+  SDL_AUDIO_ALLOW_FORMAT_CHANGE     = $00000002;
+  SDL_AUDIO_ALLOW_CHANNELS_CHANGE   = $00000004;
+  SDL_AUDIO_ALLOW_ANY_CHANGE        = (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE or
+                                       SDL_AUDIO_ALLOW_FORMAT_CHANGE or
+                                                SDL_AUDIO_ALLOW_CHANNELS_CHANGE);
+
+  {*Audio flags*}
+
+  {**
+   *  This function is called when the audio device needs more data.
+   *
+   *   userdata An application-specific parameter saved in
+   *                  the SDL_AudioSpec structure
+   *   stream A pointer to the audio data buffer.
+   *   len    The length of that buffer in bytes.
+   *
+   *  Once the callback returns, the buffer will no longer be valid.
+   *  Stereo samples are stored in a LRLRLR ordering.
+   *}
+type
+  TSDL_AudioCallback = procedure(userdata: Pointer; stream: PUInt8; len: Integer) cdecl;
+
+  {**
+   *  The calculated values in this structure are calculated by SDL_OpenAudio().
+   *}
+type
+  PSDL_AudioSpec = ^TSDL_AudioSpec;
+  TSDL_AudioSpec = record
+    freq: Integer;                {**< DSP frequency -- samples per second *}
+    format: TSDL_AudioFormat;     {**< Audio data format *}
+    channels: UInt8;              {**< Number of channels: 1 mono, 2 stereo *}
+    silence: UInt8;               {**< Audio buffer silence value (calculated) *}
+    samples: UInt16;              {**< Audio buffer size in samples (power of 2) *}
+    padding: UInt16;              {**< Necessary for some compile environments *}
+    size: UInt32;                 {**< Audio buffer size in bytes (calculated) *}
+    callback: TSDL_AudioCallback;
+    userdata: Pointer;
+  end;
+
+  PSDL_AudioCVT = ^TSDL_AudioCVT;
+  TSDL_AudioFilter = procedure(cvt: PSDL_AudioCVT; format: TSDL_AudioFormat) cdecl;
+
+  {**
+   *  A structure to hold a set of audio conversion filters and buffers.
+   *}
+  TSDL_AudioCVT = record
+    needed: Integer;                           {**< Set to 1 if conversion possible *}
+    src_format: TSDL_AudioFormat;              {**< Source audio format *}
+    dst_format: TSDL_AudioFormat;                {**< Target audio format *}
+    rate_incr: Double;                        {**< Rate conversion increment *}
+    buf: PUInt8;                             {**< Buffer to hold entire audio data *}
+    len: Integer;                               {**< Length of original audio buffer *}
+    len_cvt: Integer;                           {**< Length of converted audio buffer *}
+    len_mult: Integer;                          {**< buffer must be len*len_mult big *}
+    len_ratio: Double;                        {**< Given len, final size is len*len_ratio *}
+    filters: array[0..9] of TSDL_AudioFilter; {**< Filter list *}
+    filter_index: Integer;                      {**< Current audio conversion function *}
+  end;
+
+
+  {* Function prototypes *}
+
+  {**
+   *   Driver discovery functions
+   *
+   *  These functions return the list of built in audio drivers, in the
+   *  order that they are normally initialized by default.
+   *}
+
+function SDL_GetNumAudioDrivers: Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumAudioDrivers' {$ENDIF} {$ENDIF};
+function SDL_GetAudioDriver(index: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDriver' {$ENDIF} {$ENDIF};
+
+  {**
+   *   Initialization and cleanup
+   *
+   *  These functions are used internally, and should not be used unless
+   *  you have a specific need to specify the audio driver you want to
+   *  use.  You should normally use SDL_Init() or SDL_InitSubSystem().
+   *}
+ 
+function SDL_AudioInit(driver_name: PAnsiChar): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioInit' {$ENDIF} {$ENDIF};
+procedure SDL_AudioQuit cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioQuit' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This function returns the name of the current audio driver, or NULL
+   *  if no driver has been initialized.
+   *}
+function SDL_GetCurrentAudioDriver: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCurrentAudioDriver' {$ENDIF} {$ENDIF};
+
+  {**
+   *  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.
+   *
+   *  When filling in the desired audio spec structure,
+   *    - desired->freq should be the desired audio frequency in samples-per-
+   *      second.
+   *    - desired->format should be the desired audio format.
+   *    - desired->samples is 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 8096 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->size is the size in bytes of the audio buffer, and is
+   *      calculated by SDL_OpenAudio().
+   *    - desired->silence is the value used to set the buffer to silence,
+   *      and is calculated by SDL_OpenAudio().
+   *    - desired->callback 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.
+   *    - desired->userdata is passed as the first parameter to your callback
+   *      function.
+   *
+   *  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.
+   *}
+function SDL_OpenAudio(desired: PSDL_AudioSpec; obtained: PSDL_AudioSpec): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_OpenAudio' {$ENDIF} {$ENDIF};
+
+  {**
+   *  SDL Audio Device IDs.
+   *
+   *  A successful call to SDL_OpenAudio() is always device id 1, and legacy
+   *  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
+   *  always returns devices >= 2 on success. The legacy calls are good both
+   *  for backwards compatibility and when you don't care about multiple,
+   *  specific, or capture devices.
+   *}
+type
+  TSDL_AudioDeviceID = UInt32;
+
+  {**
+   *  Get the number of available devices exposed by the current driver.
+   *  Only valid after a successfully initializing the audio subsystem.
+   *  Returns -1 if an explicit list of devices can't be determined; this is
+   *  not an error. For example, if SDL is set up to talk to a remote audio
+   *  server, it can't list every one available on the Internet, but it will
+   *  still allow a specific host to be specified to SDL_OpenAudioDevice().
+   *
+   *  In many common cases, when this function returns a value <= 0, it can still
+   *  successfully open the default device (NULL for first argument of
+   *  SDL_OpenAudioDevice()).
+   *}
+function SDL_GetNumAudioDevices(iscapture: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumAudioDevices' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the human-readable name of a specific audio device.
+   *  Must be a value between 0 and (number of audio devices-1).
+   *  Only valid after a successfully initializing the audio subsystem.
+   *  The values returned by this function reflect the latest call to
+   *  SDL_GetNumAudioDevices(); recall that function to redetect available
+   *  hardware.
+   *
+   *  The string returned by this function is UTF-8 encoded, read-only, and
+   *  managed internally. You are not to free it. If you need to keep the
+   *  string for any length of time, you should make your own copy of it, as it
+   *  will be invalid next time any of several other SDL functions is called.
+   *}
+function SDL_GetAudioDeviceName(index: Integer; iscapture: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDeviceName' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Open a specific audio device. Passing in a device name of NULL requests
+   *  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+   *
+   *  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+   *  some drivers allow arbitrary and driver-specific strings, such as a
+   *  hostname/IP address for a remote audio server, or a filename in the
+   *  diskaudio driver.
+   *
+   *   0 on error, a valid device ID that is >= 2 on success.
+   *
+   *  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+   *}
+function SDL_OpenAudioDevice(device: PAnsiChar;
+                             iscapture: Integer;
+                             desired: PSDL_AudioSpec;
+                             obtained: PSDL_AudioSpec;
+                                  allowed_changes: Integer): TSDL_AudioDeviceID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_OpenAudioDevice' {$ENDIF} {$ENDIF};
+
+  {**
+   *   Audio state
+   *
+   *  Get the current audio state.
+   *}
+
+type
+  TSDL_AudioStatus = (SDL_AUDIO_STOPPED,SDL_AUDIO_PLAYING,SDL_AUDIO_PAUSED);
+
+function SDL_GetAudioStatus: TSDL_AudioStatus cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioStatus' {$ENDIF} {$ENDIF};
+
+function SDL_GetAudioDeviceStatus(dev: TSDL_AudioDeviceID): TSDL_AudioStatus cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDeviceStatus' {$ENDIF} {$ENDIF};
+  {*Audio State*}
+
+  {**
+   *   Pause audio functions
+   *
+   *  These functions pause and unpause the audio callback processing.
+   *  They should be called with a parameter of 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.
+   *}
+
+procedure SDL_PauseAudio(pause_on: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PauseAudio' {$ENDIF} {$ENDIF};
+procedure SDL_PauseAudioDevice(dev: TSDL_AudioDeviceID; pause_on: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PauseAudioDevice' {$ENDIF} {$ENDIF};
+  {*Pause audio functions*}
+
+  {**
+   *  This function loads a WAVE from the data source, automatically freeing
+   *  that source if freesrc is non-zero.  For example, to load a WAVE file,
+   *  you could do:
+   *
+   *      SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+   *
+   *
+   *  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 and MS-ADPCM WAVE files are supported.
+   *}
+function SDL_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadWAV_RW' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Loads a WAV from a file.
+   *  Compatibility convenience function.
+   *}
+
+   function SDL_LoadWAV(_file: PAnsiChar; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec;
+
+  {**
+   *  This function frees data previously allocated with SDL_LoadWAV_RW()
+   *}
+  procedure SDL_FreeWAV(audio_buf: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeWAV' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This function takes a source format and rate and a destination format
+   *  and rate, and initializes the cvt structure with information needed
+   *  by SDL_ConvertAudio() to convert a buffer of audio data from one format
+   *  to the other.
+   *
+   *   -1 if the format conversion is not supported, 0 if there's
+   *  no conversion needed, or 1 if the audio filter is set up.
+   *}
+function SDL_BuildAudioCVT(cvt: PSDL_AudioCVT;
+                           src_format: TSDL_AudioFormat;
+                           src_channels: UInt8;
+                           src_rate: Integer;
+                           dst_format: TSDL_AudioFormat;
+                           dst_channels: UInt8;
+                           dst_rate: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_BuildAudioCVT' {$ENDIF} {$ENDIF};
+
+{**
+ *  Once you have initialized the cvt structure using SDL_BuildAudioCVT(),
+ *  created an audio buffer cvt->buf, and filled it with cvt->len bytes of
+ *  audio data in the source format, this function will convert it in-place
+ *  to the desired format.
+ *
+ *  The data conversion may expand the size of the audio data, so the buffer
+ *  cvt->buf should be allocated after the cvt structure is initialized by
+ *  SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
+ *}
+function SDL_ConvertAudio(cvt: PSDL_AudioCVT): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertAudio' {$ENDIF} {$ENDIF};
+
+const
+  SDL_MIX_MAXVOLUME = 128;
+
+  {**
+   *  This takes two audio buffers of the playing audio format and mixes
+   *  them, performing addition, volume adjustment, and overflow clipping.
+   *  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
+   *  for full audio volume.  Note this does not change hardware volume.
+   *  This is provided for convenience -- you can mix your own audio data.
+   *}
+procedure SDL_MixAudio(dst: PUInt8; src: PUInt8; len: UInt32; volume: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MixAudio' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This works like SDL_MixAudio(), but you specify the audio format instead of
+   *  using the format of audio device 1. Thus it can be used when no audio
+   *  device is open at all.
+   *}
+procedure SDL_MixAudioFormat(dst: PUInt8; src: PUInt8; format: TSDL_AudioFormat; len: UInt32; volume: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MixAudioFormat' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Queue more audio on non-callback devices.
+   *
+   *  SDL offers two ways to feed audio to the device: you can either supply a
+   *  callback that SDL triggers with some frequency to obtain more audio
+   *  (pull method), or you can supply no callback, and then SDL will expect
+   *  you to supply data at regular intervals (push method) with this function.
+   *
+   *  There are no limits on the amount of data you can queue, short of
+   *  exhaustion of address space. Queued data will drain to the device as
+   *  necessary without further intervention from you. If the device needs
+   *  audio but there is not enough queued, it will play silence to make up
+   *  the difference. This means you will have skips in your audio playback
+   *  if you aren't routinely queueing sufficient data.
+   *
+   *  This function copies the supplied data, so you are safe to free it when
+   *  the function returns. This function is thread-safe, but queueing to the
+   *  same device from two threads at once does not promise which buffer will
+   *  be queued first.
+   *
+   *  You may not queue audio on a device that is using an application-supplied
+   *  callback; doing so returns an error. You have to use the audio callback
+   *  or queue audio with this function, but not both.
+   *
+   *  You should not call SDL_LockAudio() on the device before queueing; SDL
+   *  handles locking internally for this function.
+   *
+   *  \param dev The device ID to which we will queue audio.
+   *  \param data The data to queue to the device for later playback.
+   *  \param len The number of bytes (not samples!) to which (data) points.
+   *  \return zero on success, -1 on error.
+   *
+   *  \sa SDL_GetQueuedAudioSize
+   *  \sa SDL_ClearQueuedAudio
+   *}
+function SDL_QueueAudio(dev: TSDL_AudioDeviceID; data: Pointer; len: UInt32): SInt32; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QueueAudio' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Dequeue more audio on non-callback devices.
+   *
+   *  (If you are looking to queue audio for output on a non-callback playback
+   *  device, you want SDL_QueueAudio() instead. This will always return 0
+   *  if you use it with playback devices.)
+   *
+   *  SDL offers two ways to retrieve audio from a capture device: you can
+   *  either supply a callback that SDL triggers with some frequency as the
+   *  device records more audio data, (push method), or you can supply no
+   *  callback, and then SDL will expect you to retrieve data at regular
+   *  intervals (pull method) with this function.
+   *
+   *  There are no limits on the amount of data you can queue, short of
+   *  exhaustion of address space. Data from the device will keep queuing as
+   *  necessary without further intervention from you. This means you will
+   *  eventually run out of memory if you aren't routinely dequeueing data.
+   *
+   *  Capture devices will not queue data when paused; if you are expecting
+   *  to not need captured audio for some length of time, use
+   *  SDL_PauseAudioDevice() to stop the capture device from queueing more
+   *  data. This can be useful during, say, level loading times. When
+   *  unpaused, capture devices will start queueing data from that point,
+   *  having flushed any capturable data available while paused.
+   *
+   *  This function is thread-safe, but dequeueing from the same device from
+   *  two threads at once does not promise which thread will dequeued data
+   *  first.
+   *
+   *  You may not dequeue audio from a device that is using an
+   *  application-supplied callback; doing so returns an error. You have to use
+   *  the audio callback, or dequeue audio with this function, but not both.
+   *
+   *  You should not call SDL_LockAudio() on the device before queueing; SDL
+   *  handles locking internally for this function.
+   *
+   *  \param dev The device ID from which we will dequeue audio.
+   *  \param data A pointer into where audio data should be copied.
+   *  \param len The number of bytes (not samples!) to which (data) points.
+   *  \return number of bytes dequeued, which could be less than requested.
+   *
+   *  \sa SDL_GetQueuedAudioSize
+   *  \sa SDL_ClearQueuedAudio
+   *}
+function SDL_DequeueAudio(dev: TSDL_AudioDeviceID; data: Pointer; len:Uint32):Uint32; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DequeueAudio' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of bytes of still-queued audio.
+   *
+   *  This is the number of bytes that have been queued for playback with
+   *  SDL_QueueAudio(), but have not yet been sent to the hardware.
+   *
+   *  Once we've sent it to the hardware, this function can not decide the exact
+   *  byte boundary of what has been played. It's possible that we just gave the
+   *  hardware several kilobytes right before you called this function, but it
+   *  hasn't played any of it yet, or maybe half of it, etc.
+   *
+   *  You may not queue audio on a device that is using an application-supplied
+   *  callback; calling this function on such a device always returns 0.
+   *  You have to use the audio callback or queue audio with SDL_QueueAudio(),
+   *  but not both.
+   *
+   *  You should not call SDL_LockAudio() on the device before querying; SDL
+   *  handles locking internally for this function.
+   *
+   *  \param dev The device ID of which we will query queued audio size.
+   *  \return Number of bytes (not samples!) of queued audio.
+   *
+   *  \sa SDL_QueueAudio
+   *  \sa SDL_ClearQueuedAudio
+   *}
+function SDL_GetQueuedAudioSize(dev: TSDL_AudioDeviceID): UInt32; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetQueuedAudioSize' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Drop any queued audio data waiting to be sent to the hardware.
+   *
+   *  Immediately after this call, SDL_GetQueuedAudioSize() will return 0 and
+   *  the hardware will start playing silence if more audio isn't queued.
+   *
+   *  This will not prevent playback of queued audio that's already been sent
+   *  to the hardware, as we can not undo that, so expect there to be some
+   *  fraction of a second of audio that might still be heard. This can be
+   *  useful if you want to, say, drop any pending music during a level change
+   *  in your game.
+   *
+   *  You may not queue audio on a device that is using an application-supplied
+   *  callback; calling this function on such a device is always a no-op.
+   *  You have to use the audio callback or queue audio with SDL_QueueAudio(),
+   *  but not both.
+   *
+   *  You should not call SDL_LockAudio() on the device before clearing the
+   *  queue; SDL handles locking internally for this function.
+   *
+   *  This function always succeeds and thus returns void.
+   *
+   *  \param dev The device ID of which to clear the audio queue.
+   *
+   *  \sa SDL_QueueAudio
+   *  \sa SDL_GetQueuedAudioSize
+   *}
+procedure SDL_ClearQueuedAudio(dev: TSDL_AudioDeviceID); cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ClearQueuedAudio' {$ENDIF} {$ENDIF};
+
+  {**
+   *   Audio lock functions
+   *
+   *  The lock manipulated by these functions protects the callback function.
+   *  During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that
+   *  the callback function is not running.  Do not call these from the callback
+   *  function or you will cause deadlock.
+   *}
+
+procedure SDL_LockAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockAudio' {$ENDIF} {$ENDIF};
+procedure SDL_LockAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockAudioDevice' {$ENDIF} {$ENDIF};
+procedure SDL_UnlockAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Unlock' {$ENDIF} {$ENDIF};
+procedure SDL_UnlockAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockAudioDevice' {$ENDIF} {$ENDIF};
+  {*Audio lock functions*}
+
+  {**
+   *  This function shuts down audio processing and closes the audio device.
+   *}
+procedure SDL_CloseAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CloseAudio' {$ENDIF} {$ENDIF};
+procedure SDL_CloseAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CloseAudioDevice' {$ENDIF} {$ENDIF};
+
+  {**
+   *  1 if audio device is still functioning, zero if not, -1 on error.
+   *}
+function SDL_AudioDeviceConnected(dev: TSDL_AudioDeviceID): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioDeviceConnected' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdlblendmode.inc

@@ -0,0 +1,15 @@
+//from "sdl_blendmode.h"
+
+{**
+ *  The blend mode used in SDL_RenderCopy() and drawing operations.
+ *}
+
+type
+  PSDL_BlendMode = ^TSDL_BlendMode;
+  TSDL_BlendMode = DWord;
+
+const
+  SDL_BLENDMODE_NONE  = $00000000;    {**< No blending *}
+  SDL_BLENDMODE_BLEND = $00000001;    {**< dst = (src * A) + (dst * (1-A)) *}
+  SDL_BLENDMODE_ADD   = $00000002;    {**< dst = (src * A) + dst *}
+  SDL_BLENDMODE_MOD   = $00000004;    {**< dst = src * dst *}

model_viewer/sdl2/sdlclipboard.inc

@@ -0,0 +1,24 @@
+
+{* Function prototypes *}
+
+{**
+ * \brief Put UTF-8 text into the clipboard
+ *
+ * \sa SDL_GetClipboardText()
+ *}
+function SDL_SetClipboardText(const text: PAnsiChar): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetClipboardText' {$ENDIF} {$ENDIF};
+
+{**
+ * \brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()
+ *
+ * \sa SDL_SetClipboardText()
+ *}
+function SDL_GetClipboardText(): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetClipboardText' {$ENDIF} {$ENDIF};
+
+{**
+ * \brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty
+ *
+ * \sa SDL_GetClipboardText()
+ *}
+function SDL_HasClipboardText(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasClipboardText' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdlcpuinfo.inc

@@ -0,0 +1,82 @@
+
+{* This is a guess for the cacheline size used for padding.
+ * Most x86 processors have a 64 byte cache line.
+ * The 64-bit PowerPC processors have a 128 byte cache line.
+ * We'll use the larger value to be generally safe.
+ *}
+const
+  SDL_CACHELINE_SIZE = 128;
+
+{**
+ *  This function returns the number of CPU cores available.
+ *}
+function SDL_GetCPUCount(): Integer; cdecl external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCPUCount' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns the L1 cache line size of the CPU
+ *
+ *  This is useful for determining multi-threaded structure padding
+ *  or SIMD prefetch sizes.
+ *}
+function SDL_GetCPUCacheLineSize(): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCPUCacheLineSize' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has the RDTSC instruction.
+ *}
+function SDL_HasRDTSC(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasRDTSC' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has AltiVec features.
+ *}
+function SDL_HasAltiVec(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasAltiVec' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has MMX features.
+ *}
+function SDL_HasMMX(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasMMX' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has 3DNow! features.
+ *}
+function SDL_Has3DNow(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Has3DNow' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has SSE features.
+ *}
+function SDL_HasSSE(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasSSE' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has SSE2 features.
+ *}
+function SDL_HasSSE2(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasSSE2' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has SSE3 features.
+ *}
+function SDL_HasSSE3(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasSSE3' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has SSE4.1 features.
+ *}
+function SDL_HasSSE41(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasSSE41' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has SSE4.2 features.
+ *}
+function SDL_HasSSE42(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasSSE42' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has AVX features.
+ *}
+function SDL_HasAVX(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasAVX' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns true if the CPU has AVX2 features.
+ *}
+function SDL_HasAVX2(): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasAVX2' {$ENDIF} {$ENDIF};
+
+{**
+ *  This function returns the amount of RAM configured in the system, in MB.
+ *}
+function SDL_GetSystemRAM(): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSystemRAM' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdlerror.inc

@@ -0,0 +1,55 @@
+//from "sdl_error.h"
+const
+  ERR_MAX_STRLEN = 128;
+  ERR_MAX_ARGS   = 5;
+
+  {* Public functions *}
+
+  {* SDL_SetError() unconditionally returns -1. *}
+function SDL_SetError(const fmt: PAnsiChar): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetError' {$ENDIF} {$ENDIF};
+function SDL_GetError: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetError' {$ENDIF} {$ENDIF};
+procedure SDL_ClearError cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ClearError' {$ENDIF} {$ENDIF};
+  {*Internal error functions*}
+  {**
+   *  Internal error functions
+   *
+   *  Private error reporting function - used internally.
+   *}
+
+    {
+#define SDL_OutOfMemory()   SDL_Error(SDL_ENOMEM)
+#define SDL_Unsupported()   SDL_Error(SDL_UNSUPPORTED)
+#define SDL_InvalidParamError(param)    SDL_SetError("Parameter '%s' is invalid", (param))
+   }
+type
+  TSDL_ErrorCode = (SDL_ENOMEM,
+                    SDL_EFREAD,
+                    SDL_EFWRITE,
+                    SDL_EFSEEK,
+                    SDL_UNSUPPORTED,
+                    SDL_LASTERROR);
+
+  TSDL_Error = record
+    {* This is a numeric value corresponding to the current error *}
+    error: SInt32;
+
+    {* This is a key used to index into a language hashtable containing
+       internationalized versions of the SDL error messages.  If the key
+       is not in the hashtable, or no hashtable is available, the key is
+       used directly as an error message format string.
+     *}
+    key: String[ERR_MAX_STRLEN];
+
+    {* These are the arguments for the error functions *}
+    argc: SInt32;
+    case SInt32 of
+         {* What is a character anyway?  (UNICODE issues) *}
+      0: (value_c: Byte;);
+      1: (value_ptr: Pointer;);
+      2: (value_i: SInt32;);
+      3: (value_f: Double;);
+      4: (buf: String[ERR_MAX_STRLEN];);
+  end;
+
+  {* SDL_Error() unconditionally returns -1. *}
+function SDL_Error(code: TSDL_ErrorCode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Error' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlevents.inc

@@ -0,0 +1,705 @@
+//from "sdl_events.h"
+
+  {**
+   *  The types of events that can be delivered.
+   *}
+
+const
+
+  SDL_FIRSTEVENT       = 0;     // Unused (do not remove) (needed in pascal?)
+
+  SDL_COMMONEVENT      = 1;     //added for pascal-compatibility
+
+  { Application events }
+  SDL_QUITEV           = $100;  // User-requested quit (originally SDL_QUIT, but changed, cause theres a method called SDL_QUIT)
+
+
+  {* These application events have special meaning on iOS, see README.iOS for details *}
+  SDL_APP_TERMINATING  = $101;   {**< The application is being terminated by the OS
+                                      Called on iOS in applicationWillTerminate()
+                                      Called on Android in onDestroy()
+                                  *}
+  SDL_APP_LOWMEMORY    = $102;   {**< The application is low on memory, free memory if possible.
+                                      Called on iOS in applicationDidReceiveMemoryWarning()
+                                      Called on Android in onLowMemory()
+                                  *}
+  SDL_APP_WILLENTERBACKGROUND = $103; {**< The application is about to enter the background
+                                           Called on iOS in applicationWillResignActive()
+                                           Called on Android in onPause()
+                                       *}
+  SDL_APP_DIDENTERBACKGROUND = $104;  {**< The application did enter the background and may not get CPU for some time
+                                           Called on iOS in applicationDidEnterBackground()
+                                           Called on Android in onPause()
+                                       *}
+  SDL_APP_WILLENTERFOREGROUND = $105; {**< The application is about to enter the foreground
+                                           Called on iOS in applicationWillEnterForeground()
+                                           Called on Android in onResume()
+                                       *}
+  SDL_APP_DIDENTERFOREGROUND = $106;  {**< The application is now interactive
+                                           Called on iOS in applicationDidBecomeActive()
+                                           Called on Android in onResume()
+                                       *}
+
+  { Window events }
+  SDL_WINDOWEVENT      = $200;  // Window state change
+  SDL_SYSWMEVENT       = $201;  // System specific event
+
+  { Keyboard events }
+  SDL_KEYDOWN          = $300;  // Key pressed
+  SDL_KEYUP            = $301;  // Key released
+  SDL_TEXTEDITING      = $302;  // Keyboard text editing (composition)
+  SDL_TEXTINPUT        = $303;  // Keyboard text input
+  SDL_KEYMAPCHANGED    = $304;  // Keymap changed due to a system event such as an
+                                // input language or keyboard layout change.
+
+  { Mouse events }
+  SDL_MOUSEMOTION      = $400;  // Mouse moved
+  SDL_MOUSEBUTTONDOWN  = $401;  // Mouse button pressed
+  SDL_MOUSEBUTTONUP    = $402;  // Mouse button released
+  SDL_MOUSEWHEEL       = $403;  // Mouse wheel motion
+
+  { Joystick events }
+  SDL_JOYAXISMOTION    = $600;  // Joystick axis motion
+  SDL_JOYBALLMOTION    = $601;  // Joystick trackball motion
+  SDL_JOYHATMOTION     = $602;  // Joystick hat position change
+  SDL_JOYBUTTONDOWN    = $603;  // Joystick button pressed
+  SDL_JOYBUTTONUP      = $604;  // Joystick button released
+  SDL_JOYDEVICEADDED   = $605;  // A new joystick has been inserted into the system 
+  SDL_JOYDEVICEREMOVED = $606;  // An opened joystick has been removed 
+
+  { Game controller events }
+  SDL_CONTROLLERAXISMOTION     = $650;  // Game controller axis motion
+  SDL_CONTROLLERBUTTONDOWN     = $651;  // Game controller button pressed 
+  SDL_CONTROLLERBUTTONUP       = $652;  // Game controller button released
+  SDL_CONTROLLERDEVICEADDED    = $653;  // A new Game controller has been inserted into the system 
+  SDL_CONTROLLERDEVICEREMOVED  = $654;  // An opened Game controller has been removed 
+  SDL_CONTROLLERDEVICEREMAPPED = $655;  // The controller mapping was updated 
+   
+  { Touch events }
+  SDL_FINGERDOWN      = $700;
+  SDL_FINGERUP        = $701;
+  SDL_FINGERMOTION    = $702;
+
+  { Gesture events }
+  SDL_DOLLARGESTURE   = $800;
+  SDL_DOLLARRECORD    = $801;
+  SDL_MULTIGESTURE    = $802;
+
+  { Clipboard events }
+  SDL_CLIPBOARDUPDATE = $900; // The clipboard changed
+
+  { Drag and drop events }
+  SDL_DROPFILE        = $1000; // The system requests a file open
+  SDL_DROPTEXT        = $1001; // text/plain drag-and-drop event
+  SDL_DROPBEGIN       = $1002; // A new set of drops is beginning (NULL filename)
+  SDL_DROPCOMPLETE    = $1003; // Current set of drops is now complete (NULL filename)
+
+  { Audio hotplug events }
+  SDL_AUDIODEVICEADDED     = $1100; // A new audio device is available
+  SDL_AUDIODEVICEREMOVED   = $1101; // An audio device has been removed.
+
+  { Render events }
+  SDL_RENDER_TARGETS_RESET = $2000; // The render targets have been reset
+  SDL_RENDER_DEVICE_RESET  = $2001; // The device has been reset and all textures need to be recreated
+  
+  {** Events SDL_USEREVENT through SDL_LASTEVENT are for your use,
+   *  and should be allocated with SDL_RegisterEvents()
+   *}
+  SDL_USEREVENT    = $8000;
+
+  {**
+   *  This last event is only for bounding internal arrays (needed in pascal ??)
+   *}
+  SDL_LASTEVENT    = $FFFF;
+
+type
+
+  TSDL_EventType = Word;
+
+  {**
+   *  Fields shared by every event
+   *}
+
+  TSDL_CommonEvent = record
+    type_: UInt32;
+    timestamp: UInt32;
+  end;
+
+  {**
+   *  Window state change event data (event.window.*)
+   *}
+
+  TSDL_WindowEvent = record
+    type_: UInt32;       // SDL_WINDOWEVENT
+    timestamp: UInt32;
+    windowID: UInt32;    // The associated window
+    event: UInt8;        // SDL_WindowEventID
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+    data1: SInt32;       // event dependent data
+    data2: SInt32;       // event dependent data 
+  end;
+
+  {**
+   *  Keyboard button event structure (event.key.*)
+   *}
+  TSDL_KeyboardEvent = record
+    type_: UInt32;        // SDL_KEYDOWN or SDL_KEYUP
+    timestamp: UInt32;
+    windowID: UInt32;     // The window with keyboard focus, if any
+    state: UInt8;         // SDL_PRESSED or SDL_RELEASED 
+    _repeat: UInt8;       // Non-zero if this is a key repeat
+    padding2: UInt8;
+    padding3: UInt8;
+    keysym: TSDL_KeySym;  // The key that was pressed or released
+  end;
+
+const
+  SDL_TEXTEDITINGEVENT_TEXT_SIZE = 32;
+
+type
+ 
+  {**
+   *  Keyboard text editing event structure (event.edit.*)
+   *}
+
+  TSDL_TextEditingEvent = record
+    type_: UInt32;                               // SDL_TEXTEDITING 
+    timestamp: UInt32;
+    windowID: UInt32;                            // The window with keyboard focus, if any
+    text: array[0..SDL_TEXTEDITINGEVENT_TEXT_SIZE] of Char;  // The editing text 
+    start: SInt32;                               // The start cursor of selected editing text
+    length: SInt32;                              // The length of selected editing text
+  end;
+
+const
+  SDL_TEXTINPUTEVENT_TEXT_SIZE = 32;
+
+type
+
+  {**
+   *  Keyboard text input event structure (event.text.*)
+   *}
+
+  TSDL_TextInputEvent = record
+    type_: UInt32;                                          // SDL_TEXTINPUT 
+    timestamp: UInt32;
+    windowID: UInt32;                                       // The window with keyboard focus, if any
+    text: array[0..SDL_TEXTINPUTEVENT_TEXT_SIZE] of Char;   // The input text 
+  end;
+
+  {**
+   *  Mouse motion event structure (event.motion.*)
+   *}
+ 
+  TSDL_MouseMotionEvent = record
+    type_: UInt32;       // SDL_MOUSEMOTION
+    timestamp: UInt32;
+    windowID: UInt32;    // The window with mouse focus, if any
+    which: UInt32;       // The mouse instance id, or SDL_TOUCH_MOUSEID
+    state: UInt8;        // The current button state 
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+    x: SInt32;           // X coordinate, relative to window
+    y: SInt32;           // Y coordinate, relative to window
+    xrel: SInt32;        // The relative motion in the X direction 
+    yrel: SInt32;        // The relative motion in the Y direction
+  end;
+
+  {**
+   *  Mouse button event structure (event.button.*)
+   *}
+
+  TSDL_MouseButtonEvent = record
+    type_: UInt32;       // SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP 
+    timestamp: UInt32;
+    windowID: UInt32;    // The window with mouse focus, if any
+    which: UInt32;       // The mouse instance id, or SDL_TOUCH_MOUSEID 
+    button: UInt8;       // The mouse button index
+    state: UInt8;        // SDL_PRESSED or SDL_RELEASED
+    clicks: UInt8;       // 1 for single-click, 2 for double-click, etc.
+    padding1: UInt8;
+    x: SInt32;           // X coordinate, relative to window
+    y: SInt32;           // Y coordinate, relative to window 
+  end;
+
+  {**
+   *  Mouse wheel event structure (event.wheel.*)
+   *}
+ 
+  TSDL_MouseWheelEvent = record
+    type_: UInt32;        // SDL_MOUSEWHEEL
+    timestamp: UInt32;
+    windowID: UInt32;    // The window with mouse focus, if any
+    which: UInt32;       // The mouse instance id, or SDL_TOUCH_MOUSEID
+    x: SInt32;           // The amount scrolled horizontally 
+    y: SInt32;           // The amount scrolled vertically
+    direction: UInt32;   // Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back
+  end;
+
+  {**
+   *  Joystick axis motion event structure (event.jaxis.*)
+   *}
+
+  TSDL_JoyAxisEvent = record
+    type_: UInt32;         // SDL_JOYAXISMOTION 
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id
+    axis: UInt8;           // The joystick axis index 
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+    value: SInt16;         // The axis value (range: -32768 to 32767)
+    padding4: UInt16;
+  end;
+
+  {**
+   *  Joystick trackball motion event structure (event.jball.*)
+   *}
+
+  TSDL_JoyBallEvent = record
+    type_: UInt32;         // SDL_JOYBALLMOTION
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id
+    ball: UInt8;           // The joystick trackball index
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+    xrel: SInt16;          // The relative motion in the X direction
+    yrel: SInt16;          // The relative motion in the Y direction
+  end;
+
+  {**
+   *  Joystick hat position change event structure (event.jhat.*)
+   *}
+
+  TSDL_JoyHatEvent = record
+    type_: UInt32;         // SDL_JOYHATMOTION
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id
+    hat: UInt8;            // The joystick hat index
+    value: UInt8;         {*  The hat position value.
+                           *  SDL_HAT_LEFTUP   SDL_HAT_UP       SDL_HAT_RIGHTUP
+                           *  SDL_HAT_LEFT     SDL_HAT_CENTERED SDL_HAT_RIGHT
+                           *  SDL_HAT_LEFTDOWN SDL_HAT_DOWN     SDL_HAT_RIGHTDOWN
+                           *
+                           *  Note that zero means the POV is centered.
+                           *}
+    padding1: UInt8;
+    padding2: UInt8;
+  end;
+
+  {**
+   *  Joystick button event structure (event.jbutton.*)
+   *}
+
+  TSDL_JoyButtonEvent = record
+    type_: UInt32;        // SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id 
+    button: UInt8;         // The joystick button index
+    state: UInt8;          // SDL_PRESSED or SDL_RELEASED
+    padding1: UInt8;
+    padding2: UInt8;
+  end;
+
+  {**
+   *  Joystick device event structure (event.jdevice.*)
+   *}
+
+  TSDL_JoyDeviceEvent = record
+    type_: UInt32;      // SDL_JOYDEVICEADDED or SDL_JOYDEVICEREMOVED
+    timestamp: UInt32;
+    which: SInt32;      // The joystick device index for the ADDED event, instance id for the REMOVED event
+  end;
+
+  {**
+   *  Game controller axis motion event structure (event.caxis.*)
+   *}
+
+  TSDL_ControllerAxisEvent = record
+    type_: UInt32;         // SDL_CONTROLLERAXISMOTION
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id
+    axis: UInt8;           // The controller axis (SDL_GameControllerAxis)
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+    value: SInt16;         // The axis value (range: -32768 to 32767)
+    padding4: UInt16;
+  end;
+
+  {**
+   *  Game controller button event structure (event.cbutton.*)
+   *}
+
+  TSDL_ControllerButtonEvent = record
+    type_: UInt32;         // SDL_CONTROLLERBUTTONDOWN or SDL_CONTROLLERBUTTONUP
+    timestamp: UInt32;
+    which: TSDL_JoystickID; // The joystick instance id
+    button: UInt8;         // The controller button (SDL_GameControllerButton)
+    state: UInt8;          // SDL_PRESSED or SDL_RELEASED
+    padding1: UInt8;
+    padding2: UInt8;
+  end;
+
+
+  {**
+   *  Controller device event structure (event.cdevice.*)
+   *}
+
+  TSDL_ControllerDeviceEvent = record
+    type_: UInt32;       // SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, or SDL_CONTROLLERDEVICEREMAPPED
+    timestamp: UInt32;
+    which: SInt32;       // The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event
+  end;
+
+  {**
+   *  Audio device event structure (event.adevice.*)
+   *}
+
+  TSDL_AudioDeviceEvent = record
+    type_: UInt32;        // ::SDL_AUDIODEVICEADDED, or ::SDL_AUDIODEVICEREMOVED
+    timestamp: UInt32;
+    which: UInt32;        // The audio device index for the ADDED event (valid until next SDL_GetNumAudioDevices() call), SDL_AudioDeviceID for the REMOVED event
+    iscapture: UInt8;     // zero if an output device, non-zero if a capture device.
+    padding1: UInt8;
+    padding2: UInt8;
+    padding3: UInt8;
+  end;
+
+
+  {**
+   *  Touch finger event structure (event.tfinger.*)
+   *}
+
+  TSDL_TouchFingerEvent = record
+    type_: UInt32;         // SDL_FINGERMOTION or SDL_FINGERDOWN or SDL_FINGERUP
+    timestamp: UInt32;
+    touchId: TSDL_TouchID;  // The touch device id
+    fingerId: TSDL_FingerID;
+    x: Float;              // Normalized in the range 0...1
+    y: Float;              // Normalized in the range 0...1
+    dx: Float;             // Normalized in the range 0...1
+    dy: Float;             // Normalized in the range 0...1
+    pressure: Float;       // Normalized in the range 0...1
+  end;
+
+  {**
+   *  Multiple Finger Gesture Event (event.mgesture.*)
+   *}
+  TSDL_MultiGestureEvent = record
+    type_: UInt32;        // SDL_MULTIGESTURE
+    timestamp: UInt32;
+    touchId: TSDL_TouchID; // The touch device index
+    dTheta: Float;
+    dDist: Float;
+    x: Float;
+    y: Float;
+    numFingers: UInt16;
+    padding: UInt16;
+  end;
+
+
+  {* (event.dgesture.*) *}
+  TSDL_DollarGestureEvent = record
+    type_: UInt32;         // SDL_DOLLARGESTURE
+    timestamp: UInt32;
+    touchId: TSDL_TouchID;  // The touch device id
+    gestureId: TSDL_GestureID;
+    numFingers: UInt32;
+    error: Float;
+    x: Float;              // Normalized center of gesture
+    y: Float;              // Normalized center of gesture
+  end;
+
+
+  {**
+   *  An event used to request a file open by the system (event.drop.*)
+   *  This event is disabled by default, you can enable it with SDL_EventState()
+   *  If you enable this event, you must free the filename in the event.
+   *}
+
+  TSDL_DropEvent = record
+    type_: UInt32;      // SDL_DROPFILE
+    timestamp: UInt32;
+    _file: PAnsiChar;   // The file name, which should be freed with SDL_free()
+  end;
+
+  {**
+   *  The "quit requested" event
+   *}
+
+  TSDL_QuitEvent = record
+    type_: UInt32;        // SDL_QUIT
+    timestamp: UInt32;
+  end;
+
+  {**
+   *  A user-defined event type (event.user.*)
+   *}
+
+  TSDL_UserEvent = record
+    type_: UInt32;       // SDL_USEREVENT through SDL_NUMEVENTS-1
+    timestamp: UInt32;
+    windowID: UInt32;    // The associated window if any
+    code: SInt32;        // User defined event code
+    data1: Pointer;      // User defined data pointer
+    data2: Pointer;      // User defined data pointer
+  end;
+
+  {**
+   *  A video driver dependent system event (event.syswm.*)
+   *  This event is disabled by default, you can enable it with SDL_EventState()
+   *
+   *  If you want to use this event, you should include SDL_syswm.h.
+   *}
+
+  PSDL_SysWMEvent = ^TSDL_SysWMEvent;
+  TSDL_SysWMEvent = record
+    type_: UInt32;       // SDL_SYSWMEVENT
+    timestamp: UInt32;
+    msg: PSDL_SysWMmsg;  // driver dependent data (defined in SDL_syswm.h)
+  end;
+
+  {**
+   *  General event structure
+   *}
+
+  PSDL_Event = ^TSDL_Event;
+  TSDL_Event = record
+    case Integer of
+      0:  (type_: UInt32);
+
+      SDL_COMMONEVENT:  (common: TSDL_CommonEvent);
+      SDL_WINDOWEVENT:  (window: TSDL_WindowEvent);
+
+      SDL_KEYUP,
+      SDL_KEYDOWN:  (key: TSDL_KeyboardEvent);
+      SDL_TEXTEDITING:  (edit: TSDL_TextEditingEvent);
+      SDL_TEXTINPUT:  (text: TSDL_TextInputEvent);
+
+      SDL_MOUSEMOTION:  (motion: TSDL_MouseMotionEvent);
+      SDL_MOUSEBUTTONUP,
+      SDL_MOUSEBUTTONDOWN:  (button: TSDL_MouseButtonEvent);
+      SDL_MOUSEWHEEL:  (wheel: TSDL_MouseWheelEvent);
+     
+      SDL_JOYAXISMOTION:  (jaxis: TSDL_JoyAxisEvent);
+      SDL_JOYBALLMOTION: (jball: TSDL_JoyBallEvent);
+      SDL_JOYHATMOTION: (jhat: TSDL_JoyHatEvent);
+      SDL_JOYBUTTONDOWN,
+      SDL_JOYBUTTONUP: (jbutton: TSDL_JoyButtonEvent);
+      SDL_JOYDEVICEADDED,
+      SDL_JOYDEVICEREMOVED: (jdevice: TSDL_JoyDeviceEvent);
+
+      SDL_CONTROLLERAXISMOTION: (caxis: TSDL_ControllerAxisEvent);
+      SDL_CONTROLLERBUTTONUP,
+      SDL_CONTROLLERBUTTONDOWN: (cbutton: TSDL_ControllerButtonEvent);
+      SDL_CONTROLLERDEVICEADDED,
+      SDL_CONTROLLERDEVICEREMOVED,
+      SDL_CONTROLLERDEVICEREMAPPED: (cdevice: TSDL_ControllerDeviceEvent);
+
+      SDL_AUDIODEVICEADDED,
+      SDL_AUDIODEVICEREMOVED: (adevice: TSDL_AudioDeviceEvent);
+
+      SDL_QUITEV: (quit: TSDL_QuitEvent);
+
+      SDL_USEREVENT: (user: TSDL_UserEvent);
+      SDL_SYSWMEVENT: (syswm: TSDL_SysWMEvent);
+
+      SDL_FINGERDOWN,
+      SDL_FINGERUP,
+      SDL_FINGERMOTION: (tfinger: TSDL_TouchFingerEvent);
+      SDL_MULTIGESTURE: (mgesture: TSDL_MultiGestureEvent);
+      SDL_DOLLARGESTURE,SDL_DOLLARRECORD: (dgesture: TSDL_DollarGestureEvent);
+
+      SDL_DROPFILE: (drop: TSDL_DropEvent);
+  end;
+
+
+  {* Function prototypes *}
+
+  {**
+   *  Pumps the event loop, gathering events from the input devices.
+   *  
+   *  This function updates the event queue and internal input device state.
+   *  
+   *  This should only be run in the thread that sets the video mode.
+   *}
+  procedure SDL_PumpEvents cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PumpEvents' {$ENDIF} {$ENDIF};
+
+const
+  SDL_ADDEVENT = 0;
+  SDL_PEEKEVENT = 1;
+  SDL_GETEVENT = 2;
+
+type
+  TSDL_EventAction = Word;
+
+  {**
+   *  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, within the specified minimum and maximum type,
+   *  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, within the specified minimum and maximum type,
+   *  will be returned and will be removed from the queue.
+   *
+   *  Result: The number of events actually stored, or -1 if there was an error.
+   *
+   *  This function is thread-safe.
+   *}
+
+  function SDL_PeepEvents(events: PSDL_Event; numevents: SInt32; action: TSDL_EventAction; minType: UInt32; maxType: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PeepEvents' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Checks to see if certain event types are in the event queue.
+   *}
+
+  function SDL_HasEvent(type_: UInt32): TSDL_Bool  cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasEvent' {$ENDIF} {$ENDIF};
+  function SDL_HasEvents(minType: UInt32; maxType: UInt32): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasEvents' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This function clears events from the event queue
+   *}
+
+  procedure SDL_FlushEvent(type_: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FlushEvent' {$ENDIF} {$ENDIF};
+  procedure SDL_FlushEvents(minType: UInt32; maxType: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FlushEvents' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Polls for currently pending events.
+   *
+   *  1 if there are any pending events, or 0 if there are none available.
+   *
+   *  event - If not nil, the next event is removed from the queue and
+   *               stored in that area.
+   *}
+
+  function SDL_PollEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PollEvent' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Waits indefinitely for the next available event.
+   *  
+   *  1, or 0 if there was an error while waiting for events.
+   *   
+   *  event - If not nil, the next event is removed from the queue and 
+   *  stored in that area.
+   *}
+
+  function SDL_WaitEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitEvent' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Waits until the specified timeout (in milliseconds) for the next
+   *  available event.
+   *  
+   *  1, or 0 if there was an error while waiting for events.
+   *  
+   *  event - If not nil, the next event is removed from the queue and
+   *  stored in that area.
+   *}
+ 
+  function SDL_WaitEventTimeout(event: PSDL_Event; timeout: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitEventTimeout' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Add an event to the event queue.
+   *  
+   *  1 on success, 0 if the event was filtered, or -1 if the event queue
+   *  was full or there was some other error.
+   *}
+
+  function SDL_PushEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PumpEvents' {$ENDIF} {$ENDIF};
+
+type
+  PSDL_EventFilter = ^TSDL_EventFilter;
+  {$IFNDEF GPC}
+    TSDL_EventFilter = function( userdata: Pointer; event: PSDL_Event ): Integer; cdecl;
+  {$ELSE}
+    TSDL_EventFilter = function( userdata: Pointer; event: PSDL_Event ): Integer;
+  {$ENDIF}
+
+  {**
+   *  Sets up a filter to process all events before they change internal state and
+   *  are posted to the internal event queue.
+   *
+   *  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, but the 
+   *  internal state will still be updated.  This allows selective filtering of
+   *  dynamically arriving events.
+   *
+   *  Be very careful of what you do in the event filter function, as 
+   *  it may run in a different thread!
+   *  
+   *  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.
+   *}
+ 
+  procedure SDL_SetEventFilter(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetEventFilter' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the current event filter - can be used to "chain" filters.
+   *  If there is no event filter set, this function returns SDL_FALSE.
+   *}
+
+  function SDL_GetEventFilter(var filter: PSDL_EventFilter; var userdata: PPointer): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetEventFilter' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Add a function which is called when an event is added to the queue.
+   *}
+ 
+  procedure SDL_AddEventWatch(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AddEventWatch' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Remove an event watch function added with SDL_AddEventWatch()
+   *}
+ 
+  procedure SDL_DelEventWatch(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DelEventWatch' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Run the filter function on the current event queue, removing any
+   *  events for which the filter returns 0.
+   *}
+
+  procedure SDL_FilterEvents(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FilterEvents' {$ENDIF} {$ENDIF};
+
+const
+
+  SDL_QUERY   =   -1;
+  SDL_IGNORE  =    0;
+  SDL_DISABLE =    0;
+  SDL_ENABLE  =  1;
+
+  {**
+   *  This function allows you to set the state of processing certain events.
+   *   - If state is set to SDL_IGNORE, that event will be automatically
+   *     dropped from the event queue and will not event be filtered.
+   *   - If state is set to SDL_ENABLE, that event will be processed
+   *     normally.
+   *   - If state is set to SDL_QUERY, SDL_EventState() will return the
+   *     current processing state of the specified event.
+   *}
+
+  function SDL_EventState(type_: UInt32; state: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_EventState' {$ENDIF} {$ENDIF};
+
+  function SDL_GetEventState(type_: UInt32): UInt8;
+
+  {**
+   *  This function allocates a set of user-defined events, and returns
+   *  the beginning event number for that set of events.
+   *
+   *  If there aren't enough user-defined events left, this function
+   *  returns (Uint32)-1
+   *}
+
+  function SDL_RegisterEvents(numevents: SInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RegisterEvents' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlfilesystem.inc

@@ -0,0 +1,88 @@
+
+{**
+ * \brief Get the path where the application resides.
+ *
+ * Get the "base path". This is the directory where the application was run
+ *  from, which is probably the installation directory, and may or may not
+ *  be the process's current working directory.
+ *
+ * This returns an absolute path in UTF-8 encoding, and is guaranteed to
+ *  end with a path separator ('\\' on Windows, '/' most other places).
+ *
+ * The pointer returned by this function is owned by you. Please call
+ *  SDL_free() on the pointer when you are done with it, or it will be a
+ *  memory leak. This is not necessarily a fast call, though, so you should
+ *  call this once near startup and save the string if you need it.
+ *
+ * Some platforms can't determine the application's path, and on other
+ *  platforms, this might be meaningless. In such cases, this function will
+ *  return NULL.
+ *
+ *  \return String of base dir in UTF-8 encoding, or NULL on error.
+ *
+ * \sa SDL_GetPrefPath
+ *}
+function SDL_GetBasePath(): PChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetBasePath' {$ENDIF} {$ENDIF};
+
+{**
+ * \brief Get the user-and-app-specific path where files can be written.
+ *
+ * Get the "pref dir". This is meant to be where users can write personal
+ *  files (preferences and save games, etc) that are specific to your
+ *  application. This directory is unique per user, per application.
+ *
+ * This function will decide the appropriate location in the native filesystem,
+ *  create the directory if necessary, and return a string of the absolute
+ *  path to the directory in UTF-8 encoding.
+ *
+ * On Windows, the string might look like:
+ *  "C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\"
+ *
+ * On Linux, the string might look like:
+ *  "/home/bob/.local/share/My Program Name/"
+ *
+ * On Mac OS X, the string might look like:
+ *  "/Users/bob/Library/Application Support/My Program Name/"
+ *
+ * (etc.)
+ *
+ * You specify the name of your organization (if it's not a real organization,
+ *  your name or an Internet domain you own might do) and the name of your
+ *  application. These should be untranslated proper names.
+ *
+ * Both the org and app strings may become part of a directory name, so
+ *  please follow these rules:
+ *
+ *    - Try to use the same org string (including case-sensitivity) for
+ *      all your applications that use this function.
+ *    - Always use a unique app string for each one, and make sure it never
+ *      changes for an app once you've decided on it.
+ *    - Unicode characters are legal, as long as it's UTF-8 encoded, but...
+ *    - ...only use letters, numbers, and spaces. Avoid punctuation like
+ *      "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
+ *
+ * This returns an absolute path in UTF-8 encoding, and is guaranteed to
+ *  end with a path separator ('\\' on Windows, '/' most other places).
+ *
+ * The pointer returned by this function is owned by you. Please call
+ *  SDL_free() on the pointer when you are done with it, or it will be a
+ *  memory leak. This is not necessarily a fast call, though, so you should
+ *  call this once near startup and save the string if you need it.
+ *
+ * You should assume the path returned by this function is the only safe
+ *  place to write files (and that SDL_GetBasePath(), while it might be
+ *  writable, or even the parent of the returned path, aren't where you
+ *  should be writing things).
+ *
+ * Some platforms can't determine the pref path, and on other
+ *  platforms, this might be meaningless. In such cases, this function will
+ *  return NULL.
+ *
+ *   \param org The name of your organization.
+ *   \param app The name of your application.
+ *  \return UTF-8 string of user dir in platform-dependent notation. NULL
+ *          if there's a problem (creating directory failed, etc).
+ *
+ * \sa SDL_GetBasePath
+ *}
+function SDL_GetPrefPath(const org: PAnsiChar; const app: PAnsiChar): PChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPrefPath' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlgamecontroller.inc

@@ -0,0 +1,255 @@
+//from sdl_gamecontroller.h
+
+{**
+ *   SDL_gamecontroller.h
+ *
+ *  In order to use these functions, SDL_Init() must have been called
+ *  with the ::SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
+ *  for game controllers, and load appropriate drivers.
+ *
+ *  If you would like to receive controller updates while the application
+ *  is in the background, you should set the following hint before calling
+ *  SDL_Init(): SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS
+ *}
+
+{* The gamecontroller structure used to identify an SDL game controller *}
+type
+  PSDL_GameController = ^TSDL_GameController;
+  TSDL_GameController = Pointer; //todo
+
+  TSDL_GameControllerBindType = (SDL_CONTROLLER_BINDTYPE_NONE,
+                                 SDL_CONTROLLER_BINDTYPE_BUTTON,
+                                 SDL_CONTROLLER_BINDTYPE_AXIS,
+                                 SDL_CONTROLLER_BINDTYPE_HAT);
+
+  {**
+   *  Get the SDL joystick layer binding for this controller button/axis mapping
+   *}
+  THat = record
+    hat: Integer;
+    hat_mask: Integer;
+  end;
+
+  TSDL_GameControllerButtonBind = record
+    bindType: TSDL_GameControllerBindType;
+    case Integer of
+      0: ( button: Integer; );
+      1: ( axis: Integer; );
+      2: ( hat: THat; );
+  end;
+
+  {**
+   *  To count the number of game controllers in the system for the following:
+   *  int nJoysticks = SDL_NumJoysticks();
+   *  int nGameControllers = 0;
+   *  for ( int i = 0; i < nJoysticks; i++ ) {
+   *      if ( SDL_IsGameController(i) ) {
+   *          nGameControllers++;
+   *
+   *
+   *
+   *  Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is:
+   *  guid,name,mappings
+   *
+   *  Where GUID is the string value from SDL_JoystickGetGUIDString(), name is the human readable string for the device and mappings are controller mappings to joystick ones.
+   *  Under Windows there is a reserved GUID of "xinput" that covers any XInput devices.
+   *  The mapping format for joystick is:
+   *      bX - a joystick button, index X
+   *      hX.Y - hat X with value Y
+   *      aX - axis X of the joystick
+   *  Buttons can be used as a controller axis and vice versa.
+   *
+   *  This string shows an example of a valid mapping for a controller
+   *  "341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7",
+   *
+   *}
+
+  {**
+   *  Add or update an existing mapping configuration
+   *
+   *  1 if mapping is added, 0 if updated, -1 on error
+   *}
+function SDL_GameControllerAddMapping( mappingString: PAnsiChar ): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerAddMapping' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform()
+   *  A community sourced database of controllers is available at https://raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+   *
+   *  If freerw is non-zero, the stream will be closed after being read.
+   * 
+   *  Returns number of mappings added, -1 on error
+   *}
+function SDL_GameControllerAddMappingsFromRW(rw: PSDL_RWops; freerw: SInt32):SInt32;
+   cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerAddMappingsFromRW' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get a mapping string for a GUID
+   *
+   *   the mapping string.  Must be freed with SDL_free.  Returns NULL if no mapping is available
+   *}
+function SDL_GameControllerMappingForGUID( guid: TSDL_JoystickGUID ): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerMappingForGUID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get a mapping string for an open GameController
+   *
+   *   the mapping string.  Must be freed with SDL_free.  Returns NULL if no mapping is available
+   *}
+function SDL_GameControllerMapping( gamecontroller: PSDL_GameController ): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerMapping' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Is the joystick on this index supported by the game controller interface?
+   *}
+function SDL_IsGameController(joystick_index: Integer): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsGameController' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the implementation dependent name of a game controller.
+   *  This can be called before any controllers are opened.
+   *  If no name can be found, this function returns NULL.
+   *}
+function SDL_GameControllerNameForIndex(joystick_index: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerNameForIndex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Open a game controller for use.
+   *  The index passed as an argument refers to the N'th game controller on the system.
+   *  This index is the value which will identify this controller in future controller
+   *  events.
+   *
+   *   A controller identifier, or NULL if an error occurred.
+   *}
+function SDL_GameControllerOpen(joystick_index: Integer): PSDL_GameController cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerOpen' {$ENDIF} {$ENDIF};
+
+  {**
+   * Return the SDL_GameController associated with an instance id.
+   *}
+function SDL_GameControllerFromInstanceID(joyid: TSDL_JoystickID): PSDL_GameController; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerFromInstanceID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the name for this currently opened controller
+   *}
+function SDL_GameControllerName(gamecontroller: PSDL_GameController): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerName' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Returns SDL_TRUE if the controller has been opened and currently connected,
+   *  or SDL_FALSE if it has not.
+   *}
+function SDL_GameControllerGetAttached(gamecontroller: PSDL_GameController): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetAttached' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the underlying joystick object used by a controller
+   *}
+function SDL_GameControllerGetJoystick(gamecontroller: PSDL_GameController): PSDL_Joystick cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetJoystick' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Enable/disable controller event polling.
+   *
+   *  If controller events are disabled, you must call SDL_GameControllerUpdate()
+   *  yourself and check the state of the controller when you want controller
+   *  information.
+   *
+   *  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+   *}
+function SDL_GameControllerEventState(state: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerEventState' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Update the current state of the open game controllers.
+   *
+   *  This is called automatically by the event loop if any game controller
+   *  events are enabled.
+   *}
+procedure SDL_GameControllerUpdate() cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerUpdate' {$ENDIF} {$ENDIF};
+
+  {**
+   *  The list of axes available from a controller
+   *}
+
+const
+  SDL_CONTROLLER_AXIS_INVALID = -1;
+  SDL_CONTROLLER_AXIS_LEFTX = 0;
+  SDL_CONTROLLER_AXIS_LEFTY = 1;
+  SDL_CONTROLLER_AXIS_RIGHTX = 2;
+  SDL_CONTROLLER_AXIS_RIGHTY = 3;
+  SDL_CONTROLLER_AXIS_TRIGGERLEFT = 4;
+  SDL_CONTROLLER_AXIS_TRIGGERRIGHT = 5;
+  SDL_CONTROLLER_AXIS_MAX = 6;
+type
+  TSDL_GameControllerAxis = Byte;
+
+  {**
+   *  turn this string into a axis mapping
+   *}
+function SDL_GameControllerGetAxisFromString(pchString: PAnsiChar): TSDL_GameControllerAxis cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetAxisFromString' {$ENDIF} {$ENDIF};
+
+  {**
+   *  turn this axis enum into a string mapping
+   *}
+function SDL_GameControllerGetStringForAxis(axis: TSDL_GameControllerAxis): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetStringForAxis' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the SDL joystick layer binding for this controller button mapping
+   *}
+function SDL_GameControllerGetBindForAxis(gamecontroller: PSDL_GameController; axis: TSDL_GameControllerAxis): TSDL_GameControllerButtonBind cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetBindForAxis' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the current state of an axis control on a game controller.
+   *
+   *  The state is a value ranging from -32768 to 32767.
+   *
+   *  The axis indices start at index 0.
+   *}
+function SDL_GameControllerGetAxis(gamecontroller: PSDL_GameController; axis: TSDL_GameControllerAxis): SInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetAxis' {$ENDIF} {$ENDIF};
+
+  {**
+   *  The list of buttons available from a controller
+   *}
+const
+  SDL_CONTROLLER_BUTTON_INVALID = -1;
+  SDL_CONTROLLER_BUTTON_A = 0;
+  SDL_CONTROLLER_BUTTON_B = 1;
+  SDL_CONTROLLER_BUTTON_X = 2;
+  SDL_CONTROLLER_BUTTON_Y = 3;
+  SDL_CONTROLLER_BUTTON_BACK = 4;
+  SDL_CONTROLLER_BUTTON_GUIDE = 5;
+  SDL_CONTROLLER_BUTTON_START = 6;
+  SDL_CONTROLLER_BUTTON_LEFTSTICK = 7;
+  SDL_CONTROLLER_BUTTON_RIGHTSTICK = 8;
+  SDL_CONTROLLER_BUTTON_LEFTSHOULDER = 9;
+  SDL_CONTROLLER_BUTTON_RIGHTSHOULDER = 10;
+  SDL_CONTROLLER_BUTTON_DPAD_UP = 11;
+  SDL_CONTROLLER_BUTTON_DPAD_DOWN = 12;
+  SDL_CONTROLLER_BUTTON_DPAD_LEFT = 13;
+  SDL_CONTROLLER_BUTTON_DPAD_RIGHT = 14;
+  SDL_CONTROLLER_BUTTON_MAX = 15;
+type
+  TSDL_GameControllerButton = Byte;
+
+  {**
+   *  turn this string into a button mapping
+   *}
+function SDL_GameControllerGetButtonFromString(pchString: PAnsiChar): TSDL_GameControllerButton cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetButtonFromString' {$ENDIF} {$ENDIF};
+
+  {**
+   *  turn this button enum into a string mapping
+   *}
+function SDL_GameControllerGetStringForButton(button: TSDL_GameControllerButton): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetStringForButton' {$ENDIF} {$ENDIF};
+
+{**
+ *  Get the SDL joystick layer binding for this controller button mapping
+ *}
+function SDL_GameControllerGetBindForButton(gamecontroller: PSDL_GameController; button: TSDL_GameControllerButton): TSDL_GameControllerButtonBind cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetBindForButton' {$ENDIF} {$ENDIF};
+
+
+{**
+ *  Get the current state of a button on a game controller.
+ *
+ *  The button indices start at index 0.
+ *}
+function SDL_GameControllerGetButton(gamecontroller: PSDL_GameController; button: TSDL_GameControllerButton): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerGetButton' {$ENDIF} {$ENDIF};
+
+{**
+ *  Close a controller previously opened with SDL_GameControllerOpen().
+ *}
+procedure SDL_GameControllerClose(gamecontroller: PSDL_GameController) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GameControllerClose' {$ENDIF} {$ENDIF};
+
+
+function SDL_GameControllerAddMappingsFromFile(Const FilePath:PAnsiChar):SInt32;

model_viewer/sdl2/sdlgesture.inc

@@ -0,0 +1,35 @@
+//from "sdl_gesture.h"
+
+type
+  TSDL_GestureID = SInt64;
+
+  {* Function prototypes *}
+
+  {**
+   *  Begin Recording a gesture on the specified touch, or all touches (-1)
+   *
+   *
+   *}
+function SDL_RecordGesture(touchId: TSDL_TouchID): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RecordGesture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Save all currently loaded Dollar Gesture templates
+   *
+   *
+   *}
+function SDL_SaveAllDollarTemplates(src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SaveAllDollarTemplates' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Save a currently loaded Dollar Gesture template
+   *
+   *
+   *}
+function SDL_SaveDollarTemplate(gestureId: TSDL_GestureID; src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SaveDollarTemplate' {$ENDIF} {$ENDIF};
+
+
+  {**
+   *  Load Dollar Gesture templates from a file
+   *
+   *
+   *}
+function SDL_LoadDollarTemplates(touchId: TSDL_TouchID; src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadDollarTemplates' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlhints.inc

@@ -0,0 +1,671 @@
+{// from "SDL_hints.h"
+ /*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2013 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_hints.h
+ *
+ *  Official documentation for SDL configuration variables
+ *
+ *  This file contains functions to set and get configuration hints,
+ *  as well as listing each of them alphabetically.
+ *
+ *  The convention for naming hints is SDL_HINT_X, where "SDL_X" is
+ *  the environment variable that can be used to override the default.
+ *
+ *  In general these hints are just that - they may or may not be
+ *  supported or applicable on any given platform, but they provide
+ *  a way for an application or user to give the library a hint as
+ *  to how they would like the library to work.
+ */
+}
+
+
+(**
+ *  \brief  A variable controlling how 3D acceleration is used to accelerate the SDL screen surface.
+ *
+ *  SDL can try to accelerate the SDL screen surface by using streaming
+ *  textures with a 3D rendering engine.  This variable controls whether and
+ *  how this is done.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable 3D acceleration
+ *    "1"       - Enable 3D acceleration, using the default renderer.
+ *    "X"       - Enable 3D acceleration, using X where X is one of the valid rendering drivers.  (e.g. "direct3d", "opengl", etc.)
+ *
+ *  By default SDL tries to make a best guess for each platform whether
+ *  to use acceleration or not.
+ *)
+const
+SDL_HINT_FRAMEBUFFER_ACCELERATION  = 'SDL_FRAMEBUFFER_ACCELERATION';
+
+{/**
+ *  \brief  A variable specifying which render driver to use.
+ *
+ *  If the application doesn't pick a specific renderer to use, this variable
+ *  specifies the name of the preferred renderer.  If the preferred renderer
+ *  can't be initialized, the normal default renderer is used.
+ *
+ *  This variable is case insensitive and can be set to the following values:
+ *    "direct3d"
+ *    "opengl"
+ *    "opengles2"
+ *    "opengles"
+ *    "software"
+ *
+ *  The default varies by platform, but it's the first one in the list that
+ *  is available on the current platform.
+ */}
+SDL_HINT_RENDER_DRIVER = 'SDL_RENDER_DRIVER';
+
+{/**
+ *  \brief  A variable controlling whether the OpenGL render driver uses shaders if they are available.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable shaders
+ *    "1"       - Enable shaders
+ *
+ *  By default shaders are used if OpenGL supports them.
+ */}
+SDL_HINT_RENDER_OPENGL_SHADERS = 'SDL_RENDER_OPENGL_SHADERS';
+
+  {**
+   *  \brief  A variable controlling whether the Direct3D device is initialized for thread-safe operations.
+   *
+   *  This variable can be set to the following values:
+   *    "0"       - Thread-safety is not enabled (faster)
+   *    "1"       - Thread-safety is enabled
+   *
+   *  By default the Direct3D device is created with thread-safety disabled.
+   *}
+SDL_HINT_RENDER_DIRECT3D_THREADSAFE = 'SDL_RENDER_DIRECT3D_THREADSAFE';
+
+  {**
+   *  \brief  A variable controlling whether to enable Direct3D 11+'s Debug Layer.
+   *
+   *  This variable does not have any effect on the Direct3D 9 based renderer.
+   *
+   *  This variable can be set to the following values:
+   *    "0"       - Disable Debug Layer use
+   *    "1"       - Enable Debug Layer use
+   *
+   *  By default, SDL does not use Direct3D Debug Layer.
+   *}
+SDL_HINT_RENDER_DIRECT3D11_DEBUG = 'SDL_HINT_RENDER_DIRECT3D11_DEBUG';
+
+{/**
+ *  \brief  A variable controlling the scaling quality
+ *
+ *  This variable can be set to the following values:
+ *    "0" or "nearest" - Nearest pixel sampling
+ *    "1" or "linear"  - Linear filtering (supported by OpenGL and Direct3D)
+ *    "2" or "best"    - Currently this is the same as "linear"
+ *
+ *  By default nearest pixel sampling is used
+ */}
+SDL_HINT_RENDER_SCALE_QUALITY = 'SDL_RENDER_SCALE_QUALITY';
+
+{/**
+ *  \brief  A variable controlling whether updates to the SDL screen surface should be synchronized with the vertical refresh, to avoid tearing.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable vsync
+ *    "1"       - Enable vsync
+ *
+ *  By default SDL does not sync screen surface updates with vertical refresh.
+ */}
+SDL_HINT_RENDER_VSYNC = 'SDL_RENDER_VSYNC';
+
+{/**
+ *  \brief  A variable controlling whether the screensaver is enabled. 
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable screensaver
+ *    "1"       - Enable screensaver
+ *
+ *  By default SDL will disable the screensaver.
+ */}
+SDL_HINT_VIDEO_ALLOW_SCREENSAVER = 'SDL_VIDEO_ALLOW_SCREENSAVER';
+
+{/**
+ *  \brief  A variable controlling whether the X11 VidMode extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable XVidMode
+ *    "1"       - Enable XVidMode
+ *
+ *  By default SDL will use XVidMode if it is available.
+ */}
+SDL_HINT_VIDEO_X11_XVIDMODE = 'SDL_VIDEO_X11_XVIDMODE';
+
+{/**
+ *  \brief  A variable controlling whether the X11 Xinerama extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable Xinerama
+ *    "1"       - Enable Xinerama
+ *
+ *  By default SDL will use Xinerama if it is available.
+ */}
+SDL_HINT_VIDEO_X11_XINERAMA = 'SDL_VIDEO_X11_XINERAMA';
+
+{/**
+ *  \brief  A variable controlling whether the X11 XRandR extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable XRandR
+ *    "1"       - Enable XRandR
+ *
+ *  By default SDL will not use XRandR because of window manager issues.
+ */}
+SDL_HINT_VIDEO_X11_XRANDR = 'SDL_VIDEO_X11_XRANDR';
+
+{/**
+ *  \brief  A variable controlling whether grabbing input grabs the keyboard
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Grab will affect only the mouse
+ *    "1"       - Grab will affect mouse and keyboard
+ *
+ *  By default SDL will not grab the keyboard so system shortcuts still work.
+ */}
+SDL_HINT_GRAB_KEYBOARD = 'SDL_GRAB_KEYBOARD';
+
+{/**
+ *  \brief  A variable controlling whether relative mouse mode is implemented using mouse warping
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Relative mouse mode uses raw input
+ *    "1"       - Relative mouse mode uses mouse warping
+ *
+ *  By default SDL will use raw input for relative mouse mode
+ */}
+SDL_HINT_MOUSE_RELATIVE_MODE_WARP = 'SDL_MOUSE_RELATIVE_MODE_WARP';
+
+{/**
+ *  \brief Minimize your SDL_Window if it loses key focus when in Fullscreen mode. Defaults to true.
+ *
+ */}
+SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = 'SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS';
+
+
+{/**
+ *  \brief  A variable controlling whether the idle timer is disabled on iOS.
+ *
+ *  When an iOS app does not receive touches for some time, the screen is
+ *  dimmed automatically. For games where the accelerometer is the only input
+ *  this is problematic. This functionality can be disabled by setting this
+ *  hint.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Enable idle timer
+ *    "1"       - Disable idle timer
+ */}
+SDL_HINT_IDLE_TIMER_DISABLED = 'SDL_IOS_IDLE_TIMER_DISABLED';
+
+{/**
+ *  \brief  A variable controlling which orientations are allowed on iOS.
+ *
+ *  In some circumstances it is necessary to be able to explicitly control
+ *  which UI orientations are allowed.
+ *
+ *  This variable is a space delimited list of the following values:
+ *    "LandscapeLeft", "LandscapeRight", "Portrait" "PortraitUpsideDown"
+ */}
+SDL_HINT_ORIENTATIONS = 'SDL_IOS_ORIENTATIONS';
+
+{/**
+ *  \brief  A variable controlling whether an Android built-in accelerometer should be
+ *  listed as a joystick device, rather than listing actual joysticks only.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - List only real joysticks and accept input from them
+ *    "1"       - List real joysticks along with the accelerometer as if it were a 3 axis joystick (the default).
+ */}
+SDL_HINT_ACCELEROMETER_AS_JOYSTICK = 'SDL_ACCELEROMETER_AS_JOYSTICK';
+
+{/**
+ *  \brief  A variable that lets you disable the detection and use of Xinput gamepad devices
+ *
+ *  The variable can be set to the following values:
+ *    "0"       - Disable XInput timer (only uses direct input)
+ *    "1"       - Enable XInput timer (the default)
+ */}
+SDL_HINT_XINPUT_ENABLED = 'SDL_XINPUT_ENABLED';
+
+{**
+ *  \brief  A hint that specifies that SDL should use the old axis and button mapping for XInput devices. 
+ *  
+ *  The variable can be set to the following values:
+ *    0  use the old axis and button mapping for XInput devices
+ *    1  do not use old axis and button mapping for XInput devices
+ *  
+ *  By default SDL does not use the old axis and button mapping for XInput devices. 
+ *}
+SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING = 'SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING';
+
+{/**
+ *  \brief  A variable that lets you manually hint extra gamecontroller db entries
+ *
+ *  The variable should be newline delimited rows of gamecontroller config data, see SDL_gamecontroller.h
+ *
+ *  This hint must be set before calling SDL_Init(SDL_INIT_GAMECONTROLLER)
+ *  You can update mappings after the system is initialized with SDL_GameControllerMappingForGUID() and SDL_GameControllerAddMapping()
+ */}
+SDL_HINT_GAMECONTROLLERCONFIG = 'SDL_GAMECONTROLLERCONFIG';
+
+
+{/**
+ *  \brief  A variable that lets you enable joystick (and gamecontroller) events even when your app is in the background.
+ *
+ *  The variable can be set to the following values:
+ *    "0"       - Disable joystick & gamecontroller input events when the
+ *                application is in the background.
+ *    "1"       - Enable joystick & gamecontroller input events when the
+ *                application is in the backgroumd.
+ *
+ *  The default value is "0".  This hint may be set at any time.
+ */}
+SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS = 'SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS';
+
+
+{/**
+ *  \brief If set to 0 then never set the top most bit on a SDL Window, even if the video mode expects it.
+ *      This is a debugging aid for developers and not expected to be used by end users. The default is "1"
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - don't allow topmost
+ *    "1"       - allow topmost
+ */}
+SDL_HINT_ALLOW_TOPMOST = 'SDL_ALLOW_TOPMOST';
+
+
+{/**
+ *  \brief A variable that controls the timer resolution, in milliseconds.
+ *
+ *  The higher resolution the timer, the more frequently the CPU services
+ *  timer interrupts, and the more precise delays are, but this takes up
+ *  power and CPU time.  This hint is only used on Windows 7 and earlier.
+ *
+ *  See this blog post for more information:
+ *  http://randomascii.wordpress.com/2013/07/08/windows-timer-resolution-megawatts-wasted/
+ *
+ *  If this variable is set to "0", the system timer resolution is not set.
+ *
+ *  The default value is "1". This hint may be set at any time.
+ */}
+SDL_HINT_TIMER_RESOLUTION = 'SDL_TIMER_RESOLUTION';
+
+{**
+ *  \brief If set to 1, then do not allow high-DPI windows. ("Retina" on Mac)
+ *}
+SDL_HINT_VIDEO_HIGHDPI_DISABLED = 'SDL_VIDEO_HIGHDPI_DISABLED';
+
+{**
+ *  \brief  A hint that specifies if the SDL app should not be forced to become a foreground process on Mac OS X. 
+ *  
+ *  Possible values:
+ *    0  force the SDL app to become a foreground process (default)
+ *    1  do not force the SDL app to become a foreground process
+ *}
+SDL_HINT_MAC_BACKGROUND_APP = 'SDL_HINT_MAC_BACKGROUND_APP';
+
+{**
+ *  \brief A variable that determines whether ctrl+click should generate a right-click event on Mac
+ *  
+ *  If present, holding ctrl while left clicking will generate a right click
+ *  event when on Mac.
+ *}
+SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK = 'SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK';
+
+{**
+ *  \brief  A variable specifying which shader compiler to preload when using the Chrome ANGLE binaries
+ *
+ *  SDL has EGL and OpenGL ES2 support on Windows via the ANGLE project. It
+ *  can use two different sets of binaries, those compiled by the user from source
+ *  or those provided by the Chrome browser. In the later case, these binaries require
+ *  that SDL loads a DLL providing the shader compiler.
+ *
+ *  This variable can be set to the following values:
+ *    "d3dcompiler_46.dll" - default, best for Vista or later.
+ *    "d3dcompiler_43.dll" - for XP support.
+ *    "none" - do not load any library, useful if you compiled ANGLE from source and included the compiler in your binaries.
+ *
+ *}
+SDL_HINT_VIDEO_WIN_D3DCOMPILER = 'SDL_VIDEO_WIN_D3DCOMPILER';
+
+{/**
+ *  \brief  A variable that is the address of another SDL_Window* (as a hex string formatted with "%p").
+ *  
+ *  If this hint is set before SDL_CreateWindowFrom() and the SDL_Window* it is set to has
+ *  SDL_WINDOW_OPENGL set (and running on WGL only, currently), then two things will occur on the newly 
+ *  created SDL_Window:
+ *
+ *  1. Its pixel format will be set to the same pixel format as this SDL_Window.  This is
+ *  needed for example when sharing an OpenGL context across multiple windows.
+ *
+ *  2. The flag SDL_WINDOW_OPENGL will be set on the new window so it can be used for
+ *  OpenGL rendering.
+ *
+ *  This variable can be set to the following values:
+ *    The address (as a string "%p") of the SDL_Window* that new windows created with SDL_CreateWindowFrom() should
+ *    share a pixel format with.
+ */}
+SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT = 'SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT';
+
+  {**
+   *  \brief A URL to a WinRT app's privacy policy
+   *
+   *  All network-enabled WinRT apps must make a privacy policy available to its
+   *  users.  On Windows 8, 8.1, and RT, Microsoft mandates that this policy be
+   *  be available in the Windows Settings charm, as accessed from within the app.
+   *  SDL provides code to add a URL-based link there, which can point to the app's
+   *  privacy policy.
+   *
+   *  To setup a URL to an app's privacy policy, set SDL_HINT_WINRT_PRIVACY_POLICY_URL
+   *  before calling any SDL_Init functions.  The contents of the hint should
+   *  be a valid URL.  For example, "http://www.example.com".
+   *
+   *  The default value is "", which will prevent SDL from adding a privacy policy
+   *  link to the Settings charm.  This hint should only be set during app init.
+   *
+   *  The label text of an app's "Privacy Policy" link may be customized via another
+   *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
+   *
+   *  Please note that on Windows Phone, Microsoft does not provide standard UI
+   *  for displaying a privacy policy link, and as such, SDL_HINT_WINRT_PRIVACY_POLICY_URL
+   *  will not get used on that platform.  Network-enabled phone apps should display
+   *  their privacy policy through some other, in-app means.
+   *}
+SDL_HINT_WINRT_PRIVACY_POLICY_URL = 'SDL_HINT_WINRT_PRIVACY_POLICY_URL';
+
+  {**
+   *  \brief Label text for a WinRT app's privacy policy link
+   *
+   *  Network-enabled WinRT apps must include a privacy policy.  On Windows 8, 8.1, and RT,
+   *  Microsoft mandates that this policy be available via the Windows Settings charm.
+   *  SDL provides code to add a link there, with it's label text being set via the
+   *  optional hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
+   *
+   *  Please note that a privacy policy's contents are not set via this hint.  A separate
+   *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_URL, is used to link to the actual text of the
+   *  policy.
+   *
+   *  The contents of this hint should be encoded as a UTF8 string.
+   *
+   *  The default value is "Privacy Policy".  This hint should only be set during app
+   *  initialization, preferably before any calls to SDL_Init.
+   *
+   *  For additional information on linking to a privacy policy, see the documentation for
+   *  SDL_HINT_WINRT_PRIVACY_POLICY_URL.
+   *}
+SDL_HINT_WINRT_PRIVACY_POLICY_LABEL = 'SDL_HINT_WINRT_PRIVACY_POLICY_LABEL';
+
+  {**
+   *  \brief If set to 1, back button press events on Windows Phone 8+ will be marked as handled.
+   *
+   *  TODO, WinRT: document SDL_HINT_WINRT_HANDLE_BACK_BUTTON need and use
+   *  For now, more details on why this is needed can be found at the
+   *  beginning of the following web page:
+   *  http://msdn.microsoft.com/en-us/library/windowsphone/develop/jj247550(v=vs.105).aspx
+   *}
+SDL_HINT_WINRT_HANDLE_BACK_BUTTON = 'SDL_HINT_WINRT_HANDLE_BACK_BUTTON';
+
+  {**
+   *  \brief  A variable that dictates policy for fullscreen Spaces on Mac OS X.
+   *
+   *  This hint only applies to Mac OS X.
+   *
+   *  The variable can be set to the following values:
+   *    "0"       - Disable Spaces support (FULLSCREEN_DESKTOP won't use them and
+   *                SDL_WINDOW_RESIZABLE windows won't offer the "fullscreen"
+   *                button on their titlebars).
+   *    "1"       - Enable Spaces support (FULLSCREEN_DESKTOP will use them and
+   *                SDL_WINDOW_RESIZABLE windows will offer the "fullscreen"
+   *                button on their titlebars.
+   *
+   *  The default value is "1". Spaces are disabled regardless of this hint if
+   *   the OS isn't at least Mac OS X Lion (10.7). This hint must be set before
+   *   any windows are created.
+   *}
+SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES = 'SDL_VIDEO_MAC_FULLSCREEN_SPACES';
+
+{**
+ *  \brief  A hint that specifies the Android APK expansion main file version. 
+ *  
+ *  The variable should specify the Android APK expansion main file version (a string number like "1", "2" etc.).
+ *  This hint must be set together with the hint SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION. 
+ *  
+ *  If both hints were set then SDL_RWFromFile() will look into expansion files 
+ *  after a given relative path was not found in the internal storage and assets.
+ *  By default this hint is not set and the APK expansion files are not searched. 
+ *} 
+SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION = 'SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION';
+
+{**
+ *  \brief  A hint that specifies the Android APK expansion patch file version. 
+ *  
+ *  The variable should specify the Android APK expansion patch file version (a string number like "1", "2" etc.).
+ *  This hint must be set together with the hint SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION. 
+ *  
+ *  If both hints were set then SDL_RWFromFile() will look into expansion files 
+ *  after a given relative path was not found in the internal storage and assets.
+ *  By default this hint is not set and the APK expansion files are not searched. 
+ *} 
+SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION = 'SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION';
+
+{**
+ *  \brief  A hint that specifies a variable to control whether mouse and touch events are to be treated together or separately.
+ *  
+ *  Possible values:
+ *    0  mouse events will be handled as touch events and touch will raise fake mouse events
+ *    1  mouse events will be handled separately from pure touch events
+ *  
+ *  By default mouse events will be handled as touch events and touch will raise fake mouse events. 
+ *  The value of this hint is used at runtime, so it can be changed at any time. 
+ *}
+SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH = 'SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH';
+
+{**
+ *  \brief A hint that specifies a value to override the binding element for keyboard inputs for Emscripten builds. 
+ *  
+ *  Possible values:
+ *    #window      the JavaScript window object (this is the default)
+ *    #document    the JavaScript document object
+ *    #screen      the JavaScript window.screen object
+ *    #canvas      the default WebGL canvas element
+ *  
+ *  Any other string without a leading # sign applies to the element on the page with that ID. 
+ *  This hint only applies to the Emscripten platform. 
+ *}
+SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT = 'SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT';
+
+{**
+ *  \brief  A hint that specifies whether certain IMEs should handle text editing internally instead of sending SDL_TEXTEDITING events.
+ *  
+ *  Possible values: 
+ *    0  SDL_TEXTEDITING events are sent, and it is the application's responsibility 
+ *       to render the text from these events and differentiate it somehow from committed text. (default)
+ *
+ *    1  If supported by the IME then SDL_TEXTEDITING events are not sent,
+ *       and text that is being composed will be rendered in its own UI.
+ *}
+SDL_HINT_IME_INTERNAL_EDITING = 'SDL_HINT_IME_INTERNAL_EDITING';
+
+{**
+ *  \brief  A hint that specifies not to catch the SIGINT or SIGTERM signals.
+ *
+ *  Possible values:
+ *    0  SDL will install a SIGINT and SIGTERM handler, and when it catches a signal, convert it into an SDL_QUIT event (default)
+ *    1  SDL will not install a signal handler at all
+ *  
+ *  This hint only applies to Unix-like platforms. 
+ *} 
+SDL_HINT_NO_SIGNAL_HANDLERS = 'SDL_HINT_NO_SIGNAL_HANDLERS';
+
+{**
+ *  \brief  A hint that specifies a variable specifying SDL's threads stack size in bytes or "0" for the backend's default size.
+ *  
+ *  Possible values for this hint are:
+ *    0  use the backend's default threads stack size (default)
+ *    X  use the provided positive threads stack size
+ *  
+ *  Use this hint in case you need to set SDL's threads stack size to other than the default.
+ *  This is specially useful if you build SDL against a non glibc libc library (such as musl) 
+ *  which provides a relatively small default thread stack size (a few kilobytes versus the default 8 MB glibc uses).
+ *
+ *  Support for this hint is currently available only in the pthread backend.
+ *}
+SDL_HINT_THREAD_STACK_SIZE = 'SDL_HINT_THREAD_STACK_SIZE';
+
+{**
+ *  \brief  A hint that specifies whether the windows message loop is processed by SDL.
+ *  
+ *  Possible values for this hint:
+ *    0  the window message loop is not run
+ *    1  the window message loop is processed in SDL_PumpEvents()  [default]
+ *}
+SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP = 'SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP';
+
+{**
+ *  \brief  A hint that specifies that SDL should not to generate SDL_WINDOWEVENT_CLOSE events for Alt+F4 on Microsoft Windows.
+ *  
+ *  Possible values for this hint:
+ *    0  generate an SDL_WINDOWEVENT_CLOSE event for Alt+F4 (default)
+ *    1  do not generate event and only do normal key handling for Alt+F4
+ *}
+SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 = 'SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4';
+
+{**
+ *  \brief Prevent SDL from using version 4 of the bitmap header when saving BMPs.
+ *
+ * The bitmap header version 4 is required for proper alpha channel support and
+ * SDL will use it when required. Should this not be desired, this hint can
+ * force the use of the 40 byte header version which is supported everywhere.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - Surfaces with a colorkey or an alpha channel are saved to a
+ *               32-bit BMP file with an alpha mask. SDL will use the bitmap
+ *               header version 4 and set the alpha mask accordingly.
+ *   "1"       - Surfaces with a colorkey or an alpha channel are saved to a
+ *               32-bit BMP file without an alpha mask. The alpha channel data
+ *               will be in the file, but applications are going to ignore it.
+ *
+ * The default value is "0".
+ *}
+SDL_HINT_BMP_SAVE_LEGACY_FORMAT = 'SDL_BMP_SAVE_LEGACY_FORMAT';
+
+{**
+ * \brief Tell SDL not to name threads on Windows.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - SDL will raise the 0x406D1388 Exception to name threads.
+ *               This is the default behavior of SDL <= 2.0.4. (default)
+ *   "1"       - SDL will not raise this exception, and threads will be unnamed.
+ *               For .NET languages this is required when running under a debugger.
+ *}
+SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING = 'SDL_WINDOWS_DISABLE_THREAD_NAMING';  
+{**
+ *  \brief  A hint that specifies whether the window frame and title bar are interactive when the cursor is hidden. 
+ *  
+ *  Possible values for this hint:
+ *    0  the window frame is not interactive when the cursor is hidden (no move, resize, etc)
+ *    1  the window frame is interactive when the cursor is hidden
+ *  
+ *  By default SDL will allow interaction with the window frame when the cursor is hidden. 
+ *}
+SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN = 'SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN';
+
+{/**
+ *  \brief  An enumeration of hint priorities
+ */}
+type
+  SDL_HintPriority = (SDL_HINT_DEFAULT, SDL_HINT_NORMAL, SDL_HINT_OVERRIDE);
+
+
+{/**
+ *  \brief Set a hint with a specific priority
+ *
+ *  The priority controls the behavior when setting a hint that already
+ *  has a value.  Hints will replace existing hints of their priority and
+ *  lower.  Environment variables are considered to have override priority.
+ *
+ *  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ */}
+function SDL_SetHintWithPriority( const name: PChar; const value: PChar; priority: SDL_HintPriority) : boolean; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetHintWithPriority' {$ENDIF} {$ENDIF};
+
+// extern DECLSPEC SDL_bool SDLCALL SDL_SetHintWithPriority(const char *name,
+//                                                         const char *value,
+//                                                         SDL_HintPriority priority);
+{/**
+ *  \brief Set a hint with normal priority
+ *
+ *  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ */}
+ function SDL_SetHint( const name: PChar; const value: PChar) : boolean; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetHint' {$ENDIF} {$ENDIF};
+
+ //extern DECLSPEC SDL_bool SDLCALL SDL_SetHint(const char *name,
+  //                                           const char *value);
+
+{/**
+ *  \brief Get a hint
+ *
+ *  \return The string value of a hint variable.
+ */}
+function SDL_GetHint( const name: PChar): PChar; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetHint' {$ENDIF} {$ENDIF};
+ //extern DECLSPEC const char * SDLCALL SDL_GetHint(const char *name);
+
+
+{/**
+ *  \brief Add a function to watch a particular hint
+ *
+ *  \param name The hint to watch
+ *  \param callback The function to call when the hint value changes
+ *  \param userdata A pointer to pass to the callback function
+ */}
+type
+TSDL_HintCallback = procedure(userdata: Pointer; const name: PChar; const oldValue: PChar; const newValue: PChar);
+procedure SDL_AddHintCallback(const name: PChar; callback: TSDL_HintCallback; userdata: Pointer); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AddHintCallback' {$ENDIF} {$ENDIF};
+ //typedef void (*SDL_HintCallback)(void *userdata, const char *name, const char *oldValue, const char *newValue);
+//extern DECLSPEC void SDLCALL SDL_AddHintCallback(const char *name,
+//                                                 SDL_HintCallback callback,
+//                                                 void *userdata);
+
+{/**
+ *  \brief Remove a function watching a particular hint
+ *
+ *  \param name The hint being watched
+ *  \param callback The function being called when the hint value changes
+ *  \param userdata A pointer being passed to the callback function
+ */}
+procedure SDL_DelHintCallback(const name: PChar; callback: TSDL_HintCallback; userdata: Pointer); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DelHintCallback' {$ENDIF} {$ENDIF};
+//extern DECLSPEC void SDLCALL SDL_DelHintCallback(const char *name,
+//                                                 SDL_HintCallback callback,
+//                                                 void *userdata);
+
+{/**
+ *  \brief  Clear all hints
+ *
+ *  This function is called during SDL_Quit() to free stored hints.
+ */}
+//extern DECLSPEC void SDLCALL SDL_ClearHints(void);
+procedure SDL_ClearHints(); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ClearHints' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdljoystick.inc

@@ -0,0 +1,208 @@
+//from "sdl_joystick.h"
+
+  {**
+   *  SDL_joystick.h
+   *
+   *  In order to use these functions, SDL_Init() must have been called
+   *  with the ::SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
+   *  for joysticks, and load appropriate drivers.
+   *}
+
+type
+
+  {* The joystick structure used to identify an SDL joystick *}
+  PSDL_Joystick = Pointer; // todo!!
+
+{* A structure that encodes the stable unique id for a joystick device *}
+
+  TSDL_JoystickGUID = record
+    data: array[0..15] of UInt8;
+  end;
+
+  TSDL_JoystickID = SInt32;
+  
+  TSDL_JoystickPowerLevel = (
+    SDL_JOYSTICK_POWER_UNKNOWN = -1,
+    SDL_JOYSTICK_POWER_EMPTY,
+    SDL_JOYSTICK_POWER_LOW,
+    SDL_JOYSTICK_POWER_MEDIUM,
+    SDL_JOYSTICK_POWER_FULL,
+    SDL_JOYSTICK_POWER_WIRED,
+    SDL_JOYSTICK_POWER_MAX
+  );
+
+  {* Function prototypes *}
+  {**
+   *  Count the number of joysticks attached to the system right now
+   *}
+function SDL_NumJoysticks: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_NumJoysticks' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the implementation dependent name of a joystick.
+   *  This can be called before any joysticks are opened.
+   *  If no name can be found, this function returns NULL.
+   *}
+function SDL_JoystickNameForIndex(device_index: SInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNameForIndex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Open a joystick for use.
+   *  The index passed as an argument refers tothe N'th joystick on the system.
+   *  This index is the value which will identify this joystick in future joystick
+   *  events.
+   *
+   *  A joystick identifier, or NULL if an error occurred.
+   *}
+function SDL_JoystickOpen(device_index: SInt32): PSDL_Joystick cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickOpen' {$ENDIF} {$ENDIF};
+
+  {**
+   * Return the SDL_Joystick associated with an instance id.
+   *}
+function SDL_JoystickFromInstanceID(joyid: TSDL_JoystickID): PSDL_Joystick; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickFromInstanceID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the name for this currently opened joystick.
+   *  If no name can be found, this function returns NULL.
+   *}
+function SDL_JoystickName(joystick: PSDL_Joystick): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickName' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the GUID for the joystick at this index
+   *}
+function SDL_JoystickGetDeviceGUID(device_index: SInt32): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetDeviceGUID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the GUID for this opened joystick
+   *}
+function SDL_JoystickGetGUID(joystick: PSDL_Joystick): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return a string representation for this guid. pszGUID must point to at least 33 bytes
+   *  (32 for the string plus a NULL terminator).
+   *}
+procedure SDL_JoystickGetGUIDString(guid: TSDL_JoystickGUID; pszGUID: PAnsiChar; cbGUID: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUIDString' {$ENDIF} {$ENDIF};
+
+  {**
+   *  convert a string into a joystick formatted guid
+   *}
+function SDL_JoystickGetGUIDFromString(const pchGUID: PAnsiChar): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUIDFromString' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not.
+   *}
+function SDL_JoystickGetAttached(joystick: PSDL_Joystick): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetAttached' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the instance ID of an opened joystick or -1 if the joystick is invalid.
+   *}
+function SDL_JoystickInstanceID(joystick: PSDL_Joystick): TSDL_JoystickID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickInstanceID' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of general axis controls on a joystick.
+   *}
+function SDL_JoystickNumAxes(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumAxes' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of trackballs on a joystick.
+   *
+   *  Joystick trackballs have only relative motion events associated
+   *  with them and their state cannot be polled.
+   *}
+function SDL_JoystickNumBalls(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumBalls' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of POV hats on a joystick.
+   *}
+function SDL_JoystickNumHats(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumHats' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of buttons on a joystick.
+   *}
+function SDL_JoystickNumButtons(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumButtons' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Update the current state of the open joysticks.
+   *
+   *  This is called automatically by the event loop if any joystick
+   *  events are enabled.
+   *}
+procedure SDL_JoystickUpdate cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickUpdate' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Enable/disable joystick event polling.
+   *
+   *  If joystick events are disabled, you must call SDL_JoystickUpdate()
+   *  yourself and check the state of the joystick when you want joystick
+   *  information.
+   *
+   *  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+   *}
+function SDL_JoystickEventState(state: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickEventState' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the current state of an axis control on a joystick.
+   *
+   *  The state is a value ranging from -32768 to 32767.
+   *
+   *  The axis indices start at index 0.
+   *}
+function SDL_JoystickGetAxis(joystick: PSDL_Joystick; axis: SInt32): SInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetAxis' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Hat positions
+   *}
+const
+  SDL_HAT_CENTERED  = $00;
+  SDL_HAT_UP        = $01;
+  SDL_HAT_RIGHT     = $02;
+  SDL_HAT_DOWN      = $04;
+  SDL_HAT_LEFT      = $08;
+  SDL_HAT_RIGHTUP   = SDL_HAT_RIGHT or SDL_HAT_UP;
+  SDL_HAT_RIGHTDOWN = SDL_HAT_RIGHT or SDL_HAT_DOWN;
+  SDL_HAT_LEFTUP    = SDL_HAT_LEFT or SDL_HAT_UP;
+  SDL_HAT_LEFTDOWN  = SDL_HAT_LEFT or SDL_HAT_DOWN;
+
+  {**
+   *  Get the current state of a POV hat on a joystick.
+   *
+   *  The hat indices start at index 0.
+   *
+   *  The return value is one of the following positions:
+   *   - SDL_HAT_CENTERED
+   *   - SDL_HAT_UP
+   *   - SDL_HAT_RIGHT
+   *   - SDL_HAT_DOWN
+   *   - SDL_HAT_LEFT
+   *   - SDL_HAT_RIGHTUP
+   *   - SDL_HAT_RIGHTDOWN
+   *   - SDL_HAT_LEFTUP
+   *   - SDL_HAT_LEFTDOWN
+   *}
+function SDL_JoystickGetHat(joystick: PSDL_Joystick; hat: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetHat' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the ball axis change since the last poll.
+   *
+   *  0, or -1 if you passed it invalid parameters.
+   *
+   *  The ball indices start at index 0.
+   *}
+function SDL_JoystickGetBall(joystick: PSDL_Joystick; ball: SInt32; dx: PInt; dy: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetBall' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the current state of a button on a joystick.
+   *
+   *  The button indices start at index 0.
+   *}
+function SDL_JoystickGetButton(joystick: PSDL_Joystick; button: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetButton' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Close a joystick previously opened with SDL_JoystickOpen().
+   *}
+procedure SDL_JoystickClose(joystick: PSDL_Joystick) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickClose' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Return the battery level of this joystick
+   *}
+function SDL_JoystickCurrentPowerLevel(joystick: PSDL_Joystick): TSDL_JoystickPowerLevel; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickCurrentPowerLevel' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlkeyboard.inc

@@ -0,0 +1,177 @@
+//from "sdl_keyboard.h"
+
+type
+  PKeyStateArr = ^TKeyStateArr;
+  TKeyStateArr = array[0..65000] of UInt8;
+
+  {**
+   *  The SDL keysym structure, used in key events.
+   *}
+  PSDL_Keysym = ^TSDL_Keysym;
+  TSDL_Keysym = record
+    scancode: TSDL_ScanCode;      // SDL physical key code - see SDL_Scancode for details
+    sym: TSDL_KeyCode;            // SDL virtual key code - see SDL_Keycode for details
+    _mod: UInt16;                 // current key modifiers
+    unicode: UInt32;              // (deprecated) use SDL_TextInputEvent instead
+  end;
+
+  {**
+   *  Get the window which currently has keyboard focus.
+   *}
+
+  function SDL_GetKeyboardFocus: PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyboardFocus' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get a snapshot of the current state of the keyboard.
+   *
+   *  numkeys if non-nil, receives the length of the returned array.
+   *  
+   *  An array of key states. Indexes into this array are obtained by using SDL_Scancode values.
+   *
+   *}
+
+  function SDL_GetKeyboardState(numkeys: PInt): PUInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyboardState' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get the current key modifier state for the keyboard.
+   *}
+
+  function SDL_GetModState: TSDL_KeyMod cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetModState' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Set the current key modifier state for the keyboard.
+   *  
+   *  This does not change the keyboard state, only the key modifier flags.
+   *}
+
+  procedure SDL_SetModState(modstate: TSDL_KeyMod) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetModState' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get the key code corresponding to the given scancode according
+   *         to the current keyboard layout.
+   *
+   *  See SDL_Keycode for details.
+   *  
+   *  SDL_GetKeyName()
+   *}
+
+  function SDL_GetKeyFromScancode(scancode: TSDL_ScanCode): TSDL_KeyCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyFromScancode' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get the scancode corresponding to the given key code according to the
+   *         current keyboard layout.
+   *
+   *  See SDL_Scancode for details.
+   *
+   *  SDL_GetScancodeName()
+   *}
+
+  function SDL_GetScancodeFromKey(key: TSDL_KeyCode): TSDL_ScanCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeFromKey' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get a human-readable name for a scancode.
+   *
+   *  A pointer to the name for the scancode.
+   *
+   *  If the scancode doesn't have a name, this function returns
+   *  an empty string ("").
+   *
+   *}
+
+  function SDL_GetScancodeName(scancode: TSDL_ScanCode): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeName' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get a scancode from a human-readable name
+   *
+   *  scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized
+   *
+   *  SDL_Scancode
+   *}
+
+  function SDL_GetScancodeFromName(const name: PAnsiChar): TSDL_ScanCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeFromName' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get a human-readable name for a key.
+   *
+   *  A pointer to a UTF-8 string that stays valid at least until the next
+   *  call to this function. If you need it around any longer, you must
+   *  copy it.  If the key doesn't have a name, this function returns an
+   *  empty string ("").
+   *  
+   *  SDL_Key
+   *}
+
+  function SDL_GetKeyName(key: TSDL_ScanCode): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyName' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get a key code from a human-readable name
+   *
+   *  key code, or SDLK_UNKNOWN if the name wasn't recognized
+   *
+   *  SDL_Keycode
+   *}
+
+  function SDL_GetKeyFromName(const name: PAnsiChar): TSDL_KeyCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyFromName' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Start accepting Unicode text input events.
+   *  This function will show the on-screen keyboard if supported.
+   *  
+   *  SDL_StopTextInput()
+   *  SDL_SetTextInputRect()
+   *  SDL_HasScreenKeyboardSupport()
+   *}
+
+  procedure SDL_StartTextInput cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_StartTextInput' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Return whether or not Unicode text input events are enabled.
+   *
+   *  SDL_StartTextInput()
+   *  SDL_StopTextInput()
+   *}
+
+  function SDL_IsTextInputActive: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsTextInputActive' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Stop receiving any text input events.
+   *  This function will hide the on-screen keyboard if supported.
+   *  
+   *  SDL_StartTextInput()
+   *  SDL_HasScreenKeyboardSupport()
+   *}
+
+  procedure SDL_StopTextInput cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_StopTextInput' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Set the rectangle used to type Unicode text inputs.
+   *  This is used as a hint for IME and on-screen keyboard placement.
+   *  
+   *  SDL_StartTextInput()
+   *}
+
+  procedure SDL_SetTextInputRect(rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextInputRect' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Returns whether the platform has some screen keyboard support.
+   *  
+   *  SDL_TRUE if some keyboard support is available else SDL_FALSE.
+   *
+   *  Not all screen keyboard functions are supported on all platforms.
+   *
+   *  SDL_IsScreenKeyboardShown()
+   *}
+
+  function SDL_HasScreenKeyboardSupport: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasScreenKeyboardSupport' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Returns whether the screen keyboard is shown for given window.
+   *
+   *  window The window for which screen keyboard should be queried.
+   *
+   *  Result - SDL_TRUE if screen keyboard is shown else SDL_FALSE.
+   *
+   *  SDL_HasScreenKeyboardSupport()
+   *}
+
+  function SDL_IsScreenKeyboardShown(window: PSDL_Window): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsScreenKeyboardShown' {$ENDIF}{$ENDIF};

model_viewer/sdl2/sdlloadso.inc

@@ -0,0 +1,23 @@
+//from sdl_loadso.h
+
+{**
+ *  This function dynamically loads a shared object and returns a pointer
+ *  to the object handle (or NULL if there was an error).
+ *  The 'sofile' parameter is a system dependent name of the object file.
+ *}
+function SDL_LoadObject(Const sofile: PAnsiChar): Pointer; cdecl;
+   external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadObject' {$ENDIF}{$ENDIF};
+
+{**
+ *  Given an object handle, this function looks up the address of the
+ *  named function in the shared object and returns it.  This address
+ *  is no longer valid after calling SDL_UnloadObject().
+ *}
+function SDL_LoadFunction(handle: Pointer; Const name: PAnsiChar): Pointer; cdecl;
+   external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadFunction' {$ENDIF}{$ENDIF};
+
+{**
+ *  Unload a shared object from memory.
+ *}
+procedure SDL_UnloadObject(handle: Pointer); cdecl;
+   external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnloadObject' {$ENDIF}{$ENDIF};

model_viewer/sdl2/sdllog.inc

@@ -0,0 +1,147 @@
+
+//since the array of const in delphi is not C compatible:
+{$IFDEF FPC}
+
+{**
+ *  \brief The maximum size of a log message
+ *
+ *  Messages longer than the maximum size will be truncated
+ *}
+const
+  SDL_MAX_LOG_MESSAGE = 4096;
+
+{**
+ *  \brief The predefined log categories
+ *
+ *  By default the application category is enabled at the INFO level,
+ *  the assert category is enabled at the WARN level, test is enabled
+ *  at the VERBOSE level and all other categories are enabled at the
+ *  CRITICAL level.
+ *}
+type
+  TSDL_LogCategory = (SDL_LOG_CATEGORY_APPLICATION,
+					  SDL_LOG_CATEGORY_ERROR,
+					  SDL_LOG_CATEGORY_ASSERT,
+					  SDL_LOG_CATEGORY_SYSTEM,
+					  SDL_LOG_CATEGORY_AUDIO,
+				      SDL_LOG_CATEGORY_VIDEO,
+					  SDL_LOG_CATEGORY_RENDER,
+					  SDL_LOG_CATEGORY_INPUT,
+					  SDL_LOG_CATEGORY_TEST,
+					
+					  {* Reserved for future SDL library use *}
+					  SDL_LOG_CATEGORY_RESERVED1,
+					  SDL_LOG_CATEGORY_RESERVED2,
+					  SDL_LOG_CATEGORY_RESERVED3,
+					  SDL_LOG_CATEGORY_RESERVED4,
+					  SDL_LOG_CATEGORY_RESERVED5,
+					  SDL_LOG_CATEGORY_RESERVED6,
+					  SDL_LOG_CATEGORY_RESERVED7,
+					  SDL_LOG_CATEGORY_RESERVED8,
+					  SDL_LOG_CATEGORY_RESERVED9,
+					  SDL_LOG_CATEGORY_RESERVED10,
+					
+					  {* Beyond this point is reserved for application use *}
+					  SDL_LOG_CATEGORY_CUSTOM);
+
+{**
+ *  \brief The predefined log priorities
+ *}
+const
+  SDL_LOG_PRIORITY_VERBOSE = 1;
+  SDL_LOG_PRIORITY_DEBUG = 2;
+  SDL_LOG_PRIORITY_INFO = 3;
+  SDL_LOG_PRIORITY_WARN = 4;
+  SDL_LOG_PRIORITY_ERROR = 5;
+  SDL_LOG_PRIORITY_CRITICAL = 6;
+  SDL_NUM_LOG_PRIORITIES = 7;
+type 
+  TSDL_LogPriority = Integer;
+
+
+{**
+ *  \brief Set the priority of all log categories
+ *}
+procedure SDL_LogSetAllPriority(priority: TSDL_LogPriority) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogSetAllPriority' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Set the priority of a particular log category
+ *}
+procedure SDL_LogSetPriority(category: Integer; priority: TSDL_LogPriority) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogSetPriority' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Get the priority of a particular log category
+ *}
+function SDL_LogGetPriority(category: Integer): TSDL_LogPriority cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogGetPriority' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Reset all priorities to default.
+ *
+ *  \note This is called in SDL_Quit().
+ *}
+procedure SDL_LogResetPriorities() cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogResetPriorities' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO
+ *}
+procedure SDL_Log(const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Log' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_VERBOSE
+ *}
+procedure SDL_LogVerbose(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogVerbose' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_DEBUG
+ *}
+procedure SDL_LogDebug(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogDebug' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_INFO
+ *}
+procedure SDL_LogInfo(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogInfo' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_WARN
+ *}
+procedure SDL_LogWarn(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogWarn' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_ERROR
+ *}
+procedure SDL_LogError(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogError' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with SDL_LOG_PRIORITY_CRITICAL
+ *}
+procedure SDL_LogCritical(category: Integer; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogCritical' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with the specified category and priority.
+ *}
+procedure SDL_LogMessage(category: Integer; priority: TSDL_LogPriority; const fmt: PAnsiChar; pars: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogMessage' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief Log a message with the specified category and priority.
+ *}
+procedure SDL_LogMessageV(category: Integer; priority: TSDL_LogPriority; const fmt: PAnsiChar; ap: array of const) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogMessageV' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief The prototype for the log output function
+ *}
+type
+  TSDL_LogOutputFunction = procedure(userdata: Pointer; category: Integer; priority: TSDL_LogPriority; const msg: PAnsiChar);
+  PSDL_LogOutputFunction = ^TSDL_LogOutputFunction;
+  
+{**
+ *  \brief Get the current log output function.
+ *}
+procedure SDL_LogGetOutputFunction(callback: PSDL_LogOutputFunction; userdata: PPointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogGetOutputFunction' {$ENDIF} {$ENDIF};
+
+{**
+ *  \brief This function allows you to replace the default log output
+ *         function with one of your own.
+ *}
+procedure SDL_LogSetOutputFunction(callback: TSDL_LogOutputFunction; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LogSetOutputFunction' {$ENDIF} {$ENDIF};
+
+{$ENDIF}

model_viewer/sdl2/sdlmessagebox.inc

@@ -0,0 +1,108 @@
+//from "sdl_messagebox.h"
+
+  {**
+   *  SDL_MessageBox flags. If supported will display warning icon, etc.
+   *}
+ 
+const
+  SDL_MESSAGEBOX_ERROR        = $00000010;   {**< error dialog *}
+  SDL_MESSAGEBOX_WARNING      = $00000020;   {**< warning dialog *}
+  SDL_MESSAGEBOX_INFORMATION  = $00000040;   {**< informational dialog *}
+
+type
+  TSDL_MessageBoxFlags = Byte;
+
+  {**
+   *  Flags for SDL_MessageBoxButtonData.
+   *}
+const
+  SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = $00000001;  {**< Marks the default button when return is hit *}
+  SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = $00000002;   {**< Marks the default button when escape is hit *}
+type
+  TSDL_MessageBoxButtonFlags = Byte;
+
+  {**
+   *   Individual button data.
+   *}
+type
+  PSDL_MessageBoxButtonData = ^TSDL_MessageBoxButtonData;
+  TSDL_MessageBoxButtonData = record
+    flags: UInt32;     {**< ::SDL_MessageBoxButtonFlags *}
+    buttonid: Integer; {**< User defined button id (value returned via SDL_ShowMessageBox) *}
+    text: PAnsiChar;   {**< The UTF-8 button text *}
+  end;
+
+  {**
+   *  RGB value used in a message box color scheme
+   *}
+type
+  PSDL_MessageBoxColor = ^TSDL_MessageBoxColor;
+  TSDL_MessageBoxColor = record
+    r, g, b: UInt8;
+  end;
+
+  PSDL_MessageBoxColorType = ^TSDL_MessageBoxColorType;
+  TSDL_MessageBoxColorType = (SDL_MESSAGEBOX_COLOR_BACKGROUND,
+                              SDL_MESSAGEBOX_COLOR_TEXT,
+                              SDL_MESSAGEBOX_COLOR_BUTTON_BORDER,
+                              SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND,
+                              SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED,
+                              SDL_MESSAGEBOX_COLOR_MAX);
+
+  {**
+   *  A set of colors to use for message box dialogs
+   *}
+type
+  PSDL_MessageBoxColorScheme = ^TSDL_MessageBoxColorScheme;
+  TSDL_MessageBoxColorScheme = record
+    //colors: array[0..SDL_MESSAGEBOX_COLOR_MAX-1] of TSDL_MessageBoxColor;
+    colors: array[0..4] of TSDL_MessageBoxColor;   //right?!
+  end;
+
+  {**
+   *   MessageBox structure containing title, text, window, etc.
+   *}
+type
+  PSDL_MessageBoxData = ^TSDL_MessageBoxData;
+  TSDL_MessageBoxData = record
+    flags: UInt32;             {**< SDL_MessageBoxFlags *}
+    window: PSDL_Window;       {**< Parent window, can be NULL *}
+    title: PAnsiChar;          {**< UTF-8 title *}
+    _message: PAnsiChar;       {**< UTF-8 message text *}
+
+    numbuttons: Integer;
+    buttons: PSDL_MessageBoxButtonData;
+
+    colorScheme: PSDL_MessageBoxColorScheme;   {**< SDL_MessageBoxColorScheme, can be NULL to use system settings *}
+  end;
+
+  {**
+   *   Create a modal message box.
+   *
+   *   messageboxdata The SDL_MessageBoxData structure with title, text, etc.
+   *   buttonid The pointer to which user id of hit button should be copied.
+   *
+   *   -1 on error, otherwise 0 and buttonid contains user id of button
+   *   hit or -1 if dialog was closed.
+   *
+   *   This function should be called on the thread that created the parent
+   *   window, or on the main thread if the messagebox has no parent.  It will
+   *   block execution of that thread until the user clicks a button or
+   *   closes the messagebox.
+   *}
+function SDL_ShowMessageBox(messageboxdata: PSDL_MessageBoxData; buttonid: PInt): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowMessageBox' {$ENDIF} {$ENDIF};
+
+  {**
+   *   Create a simple modal message box
+   *
+   *   flags    SDL_MessageBoxFlags
+   *   title    UTF-8 title text
+   *   message  UTF-8 message text
+   *   window   The parent window, or NULL for no parent
+   *
+   *   0 on success, -1 on error
+   *
+   *   SDL_ShowMessageBox
+   *}
+function SDL_ShowSimpleMessageBox(flags: UInt32; title: PAnsiChar; _message: PAnsiChar; window: PSDL_Window): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowSimpleMessageBox' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdlmouse.inc

@@ -0,0 +1,258 @@
+//from "sdl_mouse.h"
+
+type
+  PSDL_Cursor = Pointer;
+
+const
+
+  {**
+   *  Cursor types for SDL_CreateSystemCursor.
+   *}
+
+  SDL_SYSTEM_CURSOR_ARROW = 0;     // Arrow
+  SDL_SYSTEM_CURSOR_IBEAM = 1;     // I-beam
+  SDL_SYSTEM_CURSOR_WAIT = 2;      // Wait
+  SDL_SYSTEM_CURSOR_CROSSHAIR = 3; // Crosshair
+  SDL_SYSTEM_CURSOR_WAITARROW = 4; // Small wait cursor (or Wait if not available)
+  SDL_SYSTEM_CURSOR_SIZENWSE = 5;  // Double arrow pointing northwest and southeast
+  SDL_SYSTEM_CURSOR_SIZENESW = 6;  // Double arrow pointing northeast and southwest
+  SDL_SYSTEM_CURSOR_SIZEWE = 7;    // Double arrow pointing west and east
+  SDL_SYSTEM_CURSOR_SIZENS = 8;    // Double arrow pointing north and south
+  SDL_SYSTEM_CURSOR_SIZEALL = 9;   // Four pointed arrow pointing north, south, east, and west
+  SDL_SYSTEM_CURSOR_NO = 10;        // Slashed circle or crossbones
+  SDL_SYSTEM_CURSOR_HAND = 11;      // Hand
+  SDL_NUM_SYSTEM_CURSORS = 12;
+
+type
+  PSDL_SystemCursor = ^TSDL_SystemCursor;
+  TSDL_SystemCursor = Word;
+
+  {* Function prototypes *}
+
+  {**
+   *  Get the window which currently has mouse focus.
+   *}
+
+  function SDL_GetMouseFocus: PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetMouseFocus' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Retrieve the current state of the mouse.
+   *  
+   *  The current button state is returned as a button bitmask, which can
+   *  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+   *  mouse cursor position relative to the focus window for the currently
+   *  selected mouse.  You can pass nil for either x or y.
+   *
+   * SDL_Button = 1 shl ((X)-1)
+   *}
+
+  function SDL_GetMouseState(x: PInt; y: PInt): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetMouseState' {$ENDIF}{$ENDIF};
+
+
+  {**
+   *  \brief Get the current state of the mouse, in relation to the desktop
+   *
+   *  This works just like SDL_GetMouseState(), but the coordinates will be
+   *  reported relative to the top-left of the desktop. This can be useful if
+   *  you need to track the mouse outside of a specific window and
+   *  SDL_CaptureMouse() doesn't fit your needs. For example, it could be
+   *  useful if you need to track the mouse while dragging a window, where
+   *  coordinates relative to a window might not be in sync at all times.
+   *
+   *  \note SDL_GetMouseState() returns the mouse position as SDL understands
+   *        it from the last pump of the event queue. This function, however,
+   *        queries the OS for the current mouse position, and as such, might
+   *        be a slightly less efficient function. Unless you know what you're
+   *        doing and have a good reason to use this function, you probably want
+   *        SDL_GetMouseState() instead.
+   *
+   *  \param x Returns the current X coord, relative to the desktop. Can be NULL.
+   *  \param y Returns the current Y coord, relative to the desktop. Can be NULL.
+   *  \return The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros.
+   *
+   *  \sa SDL_GetMouseState
+   *}
+  function SDL_GetGlobalMouseState(x, y: PSInt32): UInt32; cdecl;
+    external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetGlobalMouseState' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Retrieve the relative state of the mouse.
+   *
+   *  The current button state is returned as a button bitmask, which can
+   *  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+   *  mouse deltas since the last call to SDL_GetRelativeMouseState().
+   *}
+
+  function SDL_GetRelativeMouseState(x: PInt; y: PInt): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRelativeMouseState' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Moves the mouse to the given position within the window.
+   *
+   *   window The window to move the mouse into, or nil for the current mouse focus
+   *   x The x coordinate within the window
+   *   y The y coordinate within the window
+   *
+   *  This function generates a mouse motion event
+   *}
+
+  procedure SDL_WarpMouseInWindow(window: PSDL_Window; x: SInt32; y: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WarpMouseInWindow' {$ENDIF}{$ENDIF};
+
+  {**
+   *  \brief Moves the mouse to the given position in global screen space.
+   *
+   *  \param x The x coordinate
+   *  \param y The y coordinate
+   *  \return 0 on success, -1 on error (usually: unsupported by a platform).
+   *
+   *  \note This function generates a mouse motion event
+   *}
+  Function SDL_WarpMouseGlobal(x, y: SInt32): SInt32; cdecl;
+    external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WarpMouseGlobal' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Set relative mouse mode.
+   *
+   *  enabled Whether or not to enable relative mode
+   *
+   *  0 on success, or -1 if relative mode is not supported.
+   *
+   *  While the mouse is in relative mode, the cursor is hidden, and the
+   *  driver will try to report continuous motion in the current window.
+   *  Only relative motion events will be delivered, the mouse position
+   *  will not change.
+   *
+   *  This function will flush any pending mouse motion.
+   *  
+   *  SDL_GetRelativeMouseMode()
+   *}
+
+  function SDL_SetRelativeMouseMode(enabled: TSDL_Bool): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRelativeMouseMode' {$ENDIF}{$ENDIF};
+
+  {**
+   *  \brief Capture the mouse, to track input outside an SDL window.
+   *
+   *  \param enabled Whether or not to enable capturing
+   *
+   *  Capturing enables your app to obtain mouse events globally, instead of
+   *  just within your window. Not all video targets support this function.
+   *  When capturing is enabled, the current window will get all mouse events,
+   *  but unlike relative mode, no change is made to the cursor and it is
+   *  not restrained to your window.
+   *
+   *  This function may also deny mouse input to other windows--both those in
+   *  your application and others on the system--so you should use this
+   *  function sparingly, and in small bursts. For example, you might want to
+   *  track the mouse while the user is dragging something, until the user
+   *  releases a mouse button. It is not recommended that you capture the mouse
+   *  for long periods of time, such as the entire time your app is running.
+   *
+   *  While captured, mouse events still report coordinates relative to the
+   *  current (foreground) window, but those coordinates may be outside the
+   *  bounds of the window (including negative values). Capturing is only
+   *  allowed for the foreground window. If the window loses focus while
+   *  capturing, the capture will be disabled automatically.
+   *
+   *  While capturing is enabled, the current window will have the
+   *  SDL_WINDOW_MOUSE_CAPTURE flag set.
+   *
+   *  \return 0 on success, or -1 if not supported.
+   *}
+   function SDL_CaptureMouse(enabled: TSDL_Bool): SInt32; cdecl;
+     external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CaptureMouse' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Query whether relative mouse mode is enabled.
+   *  
+   *  SDL_SetRelativeMouseMode()
+   *}
+
+  function SDL_GetRelativeMouseMode: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRelativeMouseMode' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Create a cursor, using the specified bitmap data and
+   *  mask (in MSB format).
+   *
+   *  The cursor width must be a multiple of 8 bits.
+   *
+   *  The cursor is created in black and white according to the following:
+   *  <table>
+   *  <tr><td> data </td><td> mask </td><td> resulting pixel on screen </td></tr>
+   *  <tr><td>  0   </td><td>  1   </td><td> White </td></tr>
+   *  <tr><td>  1   </td><td>  1   </td><td> Black </td></tr>
+   *  <tr><td>  0   </td><td>  0   </td><td> Transparent </td></tr>
+   *  <tr><td>  1   </td><td>  0   </td><td> Inverted color if possible, black 
+   *                                         if not. </td></tr>
+   *  </table>
+   *  
+   *  SDL_FreeCursor()
+   *}
+
+  function SDL_CreateCursor(const data: PUInt8; const mask: PUInt8; w: SInt32; h: SInt32; hot_x: SInt32; hot_y: SInt32): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Create a color cursor.
+   *
+   *  SDL_FreeCursor()
+   *}
+
+  function SDL_CreateColorCursor(surface: PSDL_Surface; hot_x: SInt32; hot_y: SInt32): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateColorCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Create a system cursor.
+   *
+   *  SDL_FreeCursor()
+   *}
+
+  function SDL_CreateSystemCursor(id: TSDL_SystemCursor): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSystemCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Set the active cursor.
+   *}
+
+  procedure SDL_SetCursor(cursor: PSDL_Cursor) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Return the active cursor.
+   *}
+
+  function SDL_GetCursor: PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Frees a cursor created with SDL_CreateCursor().
+   *
+   *  SDL_CreateCursor()
+   *}
+
+  procedure SDL_FreeCursor(cursor: PSDL_Cursor) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeCursor' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Toggle whether or not the cursor is shown.
+   *
+   *  toggle 1 to show the cursor, 0 to hide it, -1 to query the current
+   *                state.
+   *  
+   *  1 if the cursor is shown, or 0 if the cursor is hidden.
+   *}
+
+  function SDL_ShowCursor(toggle: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowCursor' {$ENDIF}{$ENDIF};
+
+  function SDL_Button(button: SInt32): SInt32; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+
+const
+  {**
+   *  Used as a mask when testing buttons in buttonstate.
+   *   - Button 1:  Left mouse button
+   *   - Button 2:  Middle mouse button
+   *   - Button 3:  Right mouse button
+   *}
+
+  SDL_BUTTON_LEFT	= 1;
+  SDL_BUTTON_MIDDLE	= 2;
+  SDL_BUTTON_RIGHT	= 3;
+  SDL_BUTTON_X1	    = 4;
+  SDL_BUTTON_X2	    = 5;
+  SDL_BUTTON_LMASK  = 1 shl ((SDL_BUTTON_LEFT) - 1);
+  SDL_BUTTON_MMASK  = 1 shl ((SDL_BUTTON_MIDDLE) - 1);
+  SDL_BUTTON_RMASK  = 1 shl ((SDL_BUTTON_RIGHT) - 1);
+  SDL_BUTTON_X1MASK = 1 shl ((SDL_BUTTON_X1) - 1);
+  SDL_BUTTON_X2MASK = 1 shl ((SDL_BUTTON_X2) - 1);

model_viewer/sdl2/sdlmutex.inc

@@ -0,0 +1,194 @@
+//from "sdl_mutex.h"
+
+  {**
+   *  Synchronization functions which can time out return this value
+   *  if they time out.
+   *}
+const
+  SDL_MUTEX_TIMEDOUT = 1;
+
+  {**
+   *  This is the timeout value which corresponds to never time out.
+   *}
+  //SDL_MUTEX_MAXWAIT   (~(Uint32)0)
+
+
+  {**
+   *  Mutex functions
+   *}
+type
+  {* The SDL mutex structure, defined in SDL_mutex.c *}
+  PSDL_Mutex = Pointer; //todo!
+
+  {**
+   *  Create a mutex, initialized unlocked.
+   *}
+function SDL_CreateMutex: PSDL_Mutex cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateMutex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Lock the mutex.
+   *
+   *   0, or -1 on error.
+   *}
+//#define SDL_mutexP(m)   SDL_LockMutex(m)
+function SDL_LockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockMutex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Try to lock the mutex
+   *
+   *   0, SDL_MUTEX_TIMEDOUT, or -1 on error
+   *}
+function SDL_TryLockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TryLockMutex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Unlock the mutex.
+   *
+   *   0, or -1 on error.
+   *
+   *   It is an error to unlock a mutex that has not been locked by
+   *   the current thread, and doing so results in undefined behavior.
+   *}
+//#define SDL_mutexV(m)   SDL_UnlockMutex(m)
+function SDL_UnlockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockMutex' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Destroy a mutex.
+   *}
+procedure SDL_DestroyMutex(mutex: PSDL_Mutex) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyMutex' {$ENDIF} {$ENDIF};
+
+  {*Mutex functions*}
+
+  {**
+   *   Semaphore functions
+   *}
+type
+  {* The SDL semaphore structure, defined in SDL_sem.c *}
+  PSDL_Sem = Pointer; //todo!
+
+  {**
+   *  Create a semaphore, initialized with value, returns NULL on failure.
+   *}
+function SDL_CreateSemaphore(initial_value: UInt32): PSDL_sem cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSemaphore' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Destroy a semaphore.
+   *}
+procedure SDL_DestroySemaphore(sem: PSDL_Sem) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroySemaphore' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This function suspends the calling thread until the semaphore pointed
+   *  to by sem has a positive count. It then atomically decreases the
+   *  semaphore count.
+   *}
+function SDL_SemWait(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemWait' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Non-blocking variant of SDL_SemWait().
+   *
+   *   0 if the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait would
+   *   block, and -1 on error.
+   *}
+function SDL_SemTryWait(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemTryWait' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Variant of SDL_SemWait() with a timeout in milliseconds.
+   *
+   *   0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not
+   *   succeed in the allotted time, and -1 on error.
+   *
+   *   On some platforms this function is implemented by looping with a
+   *   delay of 1 ms, and so should be avoided if possible.
+   *}
+function SDL_SemWaitTimeout(sem: PSDL_Sem; ms: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemWaitTimeout' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Atomically increases the semaphore'_S count (not blocking).
+   *
+   *   0, or -1 on error.
+   *}
+function SDL_SemPost(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemPost' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Returns the current count of the semaphore.
+   *}
+function SDL_SemValue(sem: PSDL_Sem): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemValue' {$ENDIF} {$ENDIF};
+
+  {*Semaphore functions*}
+
+  {**
+   *  Condition variable functions
+   * }
+type
+  {* The SDL condition variable structure, defined in SDL_cond.c *}
+  PSDL_Cond = Pointer; //todo!!
+
+  {**
+   *  Create a condition variable.
+   *
+   *  Typical use of condition variables:
+   *
+   *  Thread A:
+   *    SDL_LockMutex(lock);
+   *    while ( not condition )
+   *    begin
+   *      SDL_CondWait(cond, lock);
+   *    end;
+   *    SDL_UnlockMutex(lock);
+   *
+   *  Thread B:
+   *    SDL_LockMutex(lock);
+   *    ...
+   *    condition := true;
+   *    ...
+   *    SDL_CondSignal(cond);
+   *    SDL_UnlockMutex(lock);
+   *
+   *  There is some discussion whether to signal the condition variable
+   *  with the mutex locked or not.  There is some potential performance
+   *  benefit to unlocking first on some platforms, but there are some
+   *  potential race conditions depending on how your code is structured.
+   *
+   *  In general it'_S safer to signal the condition variable while the
+   *  mutex is locked.
+   *}
+function SDL_CreateCond: PSDL_Cond cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateCond' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Destroy a condition variable.
+   *}
+procedure SDL_DestroyCond(cond: PSDL_Cond) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyCond' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Restart one of the threads that are waiting on the condition variable.
+   *
+   *   0 or -1 on error.
+   *}
+function SDL_CondSignal(cond: PSDL_Cond): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondSignal' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Restart all threads that are waiting on the condition variable.
+   *
+   *   0 or -1 on error.
+   *}
+function SDL_CondBroadcast(cond: PSDL_Cond): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondBroadcast' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Wait on the condition variable, unlocking the provided mutex.
+   *
+   *   The mutex must be locked before entering this function!
+   *
+   *  The mutex is re-locked once the condition variable is signaled.
+   *
+   *   0 when it is signaled, or -1 on error.
+   *}
+function SDL_CondWait(cond: PSDL_Cond; mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondWait' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Waits for at most ms milliseconds, and returns 0 if the condition
+   *  variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
+   *  signaled in the allotted time, and -1 on error.
+   *
+   *   On some platforms this function is implemented by looping with a
+   *   delay of 1 ms, and so should be avoided if possible.
+   *}
+function SDL_CondWaitTimeout(cond: PSDL_Cond; mutex: PSDL_Mutex; ms: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondWaitTimeout' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlpixels.inc

@@ -0,0 +1,521 @@
+//from "sdl_pixels.h"
+
+  {**
+   *  Transparency definitions
+   *
+   *  These define alpha as the opacity of a surface.
+   *}
+
+  const
+    SDL_ALPHA_OPAQUE = 255;
+    SDL_ALPHA_TRANSPARENT = 0;
+
+    {** Pixel type. *}
+    SDL_PIXELTYPE_UNKNOWN = 0;
+    SDL_PIXELTYPE_INDEX1 = 1;
+    SDL_PIXELTYPE_INDEX4 = 2;
+    SDL_PIXELTYPE_INDEX8 = 3;
+    SDL_PIXELTYPE_PACKED8 = 4;
+    SDL_PIXELTYPE_PACKED16 = 5;
+    SDL_PIXELTYPE_PACKED32 = 6;
+    SDL_PIXELTYPE_ARRAYU8 = 7;
+    SDL_PIXELTYPE_ARRAYU16 = 8;
+    SDL_PIXELTYPE_ARRAYU32 = 9;
+    SDL_PIXELTYPE_ARRAYF16 = 10;
+    SDL_PIXELTYPE_ARRAYF32 = 11;
+
+    {** Bitmap pixel order, high bit -> low bit. *}
+    SDL_BITMAPORDER_NONE = 0;
+    SDL_BITMAPORDER_4321 = 1;
+    SDL_BITMAPORDER_1234 = 2;
+
+    {** Packed component order, high bit -> low bit. *}
+
+    SDL_PACKEDORDER_NONE = 0;
+    SDL_PACKEDORDER_XRGB = 1;
+    SDL_PACKEDORDER_RGBX = 2;
+    SDL_PACKEDORDER_ARGB = 3;
+    SDL_PACKEDORDER_RGBA = 4;
+    SDL_PACKEDORDER_XBGR = 5;
+    SDL_PACKEDORDER_BGRX = 6;
+    SDL_PACKEDORDER_ABGR = 7;
+    SDL_PACKEDORDER_BGRA = 8;
+
+    {** Array component order, low byte -> high byte. *}
+    SDL_ARRAYORDER_NONE = 0;
+    SDL_ARRAYORDER_RGB  = 1;
+    SDL_ARRAYORDER_RGBA = 2;
+    SDL_ARRAYORDER_ARGB = 3;
+    SDL_ARRAYORDER_BGR  = 4;
+    SDL_ARRAYORDER_BGRA = 5;
+    SDL_ARRAYORDER_ABGR = 6;
+
+    {** Packed component layout. *}
+    SDL_PACKEDLAYOUT_NONE = 0;
+    SDL_PACKEDLAYOUT_332  = 1;
+    SDL_PACKEDLAYOUT_4444 = 2;
+    SDL_PACKEDLAYOUT_1555 = 3;
+    SDL_PACKEDLAYOUT_5551 = 4;
+    SDL_PACKEDLAYOUT_565  = 5;
+    SDL_PACKEDLAYOUT_8888 = 6;
+    SDL_PACKEDLAYOUT_2101010 = 7;
+    SDL_PACKEDLAYOUT_1010102 = 8;
+
+    {
+        //todo!!
+function SDL_DEFINE_PIXELFORMAT(type, order, layour, bit, bytes: UInt32): Result;
+
+function SDL_DEFINE_PIXELFOURCC(A,B,C,D: Variant): Variant;
+
+#define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \
+    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
+     ((bits) << 8) | ((bytes) << 0))
+       }
+
+function SDL_PIXELFLAG(X: Cardinal): Cardinal;
+function SDL_PIXELTYPE(X: Cardinal): Cardinal;
+function SDL_PIXELORDER(X: Cardinal): Cardinal;
+function SDL_PIXELLAYOUT(X: Cardinal): Cardinal;
+function SDL_BITSPERPIXEL(X: Cardinal): Cardinal;
+     {
+#define SDL_BYTESPERPIXEL(X) \
+    (SDL_ISPIXELFORMAT_FOURCC(X) ? \
+        ((((X) == SDL_PIXELFORMAT_YUY2) || \
+          ((X) == SDL_PIXELFORMAT_UYVY) || \
+          ((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
+
+#define SDL_ISPIXELFORMAT_INDEXED(format)   \
+    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
+     ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \
+      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \
+      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)))
+
+#define SDL_ISPIXELFORMAT_ALPHA(format)   \
+    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
+     ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \
+      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \
+      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \
+      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA)))
+
+  function SDL_IsPixelFormat_FOURCC(format: Variant);
+
+  {* Note: If you modify this list, update SDL_GetPixelFormatName() *}
+
+const
+    SDL_PIXELFORMAT_UNKNOWN = 0;
+    SDL_PIXELFORMAT_INDEX1LSB = (1 shl 28)                    or
+                                (SDL_PIXELTYPE_INDEX1 shl 24) or
+                                (SDL_BITMAPORDER_4321 shl 20) or
+                                (0 shl 16)                    or
+                                (1 shl 8)                     or
+                                (0 shl 0);
+
+    SDL_PIXELFORMAT_INDEX1MSB = (1 shl 28)                    or
+                                (SDL_PIXELTYPE_INDEX1 shl 24) or
+                                (SDL_BITMAPORDER_1234 shl 20) or
+                                (0 shl 16)                    or
+                                (1 shl 8)                     or
+                                (0 shl 0);
+
+    SDL_PIXELFORMAT_INDEX4LSB = (1 shl 28)                    or
+                                (SDL_PIXELTYPE_INDEX4 shl 24) or
+                                (SDL_BITMAPORDER_4321 shl 20) or
+                                (0 shl 16)                    or
+                                (4 shl 8)                     or
+                                (0 shl 0);
+
+    SDL_PIXELFORMAT_INDEX4MSB = (1 shl 28)                    or
+                                (SDL_PIXELTYPE_INDEX4 shl 24) or
+                                (SDL_BITMAPORDER_1234 shl 20) or
+                                (0 shl 16)                    or
+                                (4 shl 8)                     or
+                                (0 shl 0);
+
+    SDL_PIXELFORMAT_INDEX8 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED8 shl 24)  or
+                                (0 shl 20)                      or
+                                (0 shl 16)                      or
+                                (8 shl 8)                       or
+                                (1 shl 0);
+
+    SDL_PIXELFORMAT_RGB332 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED8 shl 24)  or
+                                (SDL_PACKEDORDER_XRGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_332 shl 16)   or
+                                (8 shl 8)                       or
+                                (1 shl 0);
+
+    SDL_PIXELFORMAT_RGB444 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_XRGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_4444 shl 16)  or
+                                (12 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_RGB555 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_XRGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_1555 shl 16)  or
+                                (15 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_BGR555 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_XBGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_1555 shl 16)  or
+                                (15 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_ARGB4444 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_ARGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_4444 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_RGBA4444 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_RGBA shl 20)   or
+                                (SDL_PACKEDLAYOUT_4444 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_ABGR4444 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_ABGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_4444 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_BGRA4444 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_BGRA shl 20)   or
+                                (SDL_PACKEDLAYOUT_4444 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_ARGB1555 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_ARGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_1555 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_RGBA5551 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_RGBA shl 20)   or
+                                (SDL_PACKEDLAYOUT_5551 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_ABGR1555 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_ABGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_1555 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_BGRA5551 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_BGRA shl 20)   or
+                                (SDL_PACKEDLAYOUT_5551 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_RGB565 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_XRGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_565 shl 16)   or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_BGR565 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED16 shl 24) or
+                                (SDL_PACKEDORDER_XBGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_1555 shl 16)  or
+                                (16 shl 8)                      or
+                                (2 shl 0);
+
+    SDL_PIXELFORMAT_RGB24 =     (1 shl 28)                      or
+                                (SDL_PIXELTYPE_ARRAYU8 shl 24)  or
+                                (SDL_ARRAYORDER_RGB shl 20)     or
+                                (0 shl 16)                      or
+                                (24 shl 8)                      or
+                                (3 shl 0);
+
+    SDL_PIXELFORMAT_BGR24 =     (1 shl 28)                      or
+                                (SDL_PIXELTYPE_ARRAYU8 shl 24)  or
+                                (SDL_ARRAYORDER_BGR shl 20)     or
+                                (0 shl 16)                      or
+                                (24 shl 8)                      or
+                                (3 shl 0);
+
+    SDL_PIXELFORMAT_RGB888 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_XRGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (24 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_RGBX8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_RGBX shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (24 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_BGR888 =    (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_XBGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (24 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_BGRX8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_BGRX shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (24 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_ARGB8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_ARGB shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (32 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_RGBA8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_RGBA shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (32 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_ABGR8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_ABGR shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (32 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_BGRA8888 =  (1 shl 28)                      or
+                                (SDL_PIXELTYPE_PACKED32 shl 24) or
+                                (SDL_PACKEDORDER_RGBX shl 20)   or
+                                (SDL_PACKEDLAYOUT_8888 shl 16)  or
+                                (32 shl 8)                      or
+                                (4 shl 0);
+
+    SDL_PIXELFORMAT_ARGB2101010 = (1 shl 28)                       or
+                                  (SDL_PIXELTYPE_PACKED32 shl 24)  or
+                                  (SDL_PACKEDORDER_ARGB shl 20)    or
+                                  (SDL_PACKEDLAYOUT_2101010 shl 16)or
+                                  (32 shl 8)                       or
+                                  (4 shl 0);
+
+    (* Aliases for RGBA byte arrays of color data, for the current platform *)
+    {$IFDEF FPC}
+      {$IF DEFINED(ENDIAN_LITTLE)}
+        SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888;
+        SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888;
+        SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888;
+        SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888;
+      {$ELSEIF DEFINED(ENDIAN_BIG)}
+        SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA8888;
+        SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB8888;
+        SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA8888;
+        SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR8888;
+      {$ELSE}
+        {$FATAL Cannot determine endianness.}
+      {$IFEND}
+    {$ENDIF}
+
+    {**< Planar mode: Y + V + U  (3 planes) *}
+    SDL_PIXELFORMAT_YV12 = (Integer('Y')       ) or
+                           (Integer('V') shl  8) or
+                           (Integer('1') shl 16) or
+                           (Integer('2') shl 24);
+    {**< Planar mode: Y + U + V  (3 planes) *}
+    SDL_PIXELFORMAT_IYUV = (Integer('I')       ) or
+                           (Integer('Y') shl  8) or
+                           (Integer('U') shl 16) or
+                           (Integer('V') shl 24);
+    {**< Packed mode: Y0+U0+Y1+V0 (1 plane) *}
+    SDL_PIXELFORMAT_YUY2 = (Integer('Y')       ) or
+                           (Integer('U') shl  8) or
+                           (Integer('Y') shl 16) or
+                           (Integer('2') shl 24);
+    {**< Packed mode: U0+Y0+V0+Y1 (1 plane) *}
+    SDL_PIXELFORMAT_UYVY = (Integer('U')       ) or
+                           (Integer('Y') shl  8) or
+                           (Integer('V') shl 16) or
+                           (Integer('Y') shl 24);
+    {**< Packed mode: Y0+V0+Y1+U0 (1 plane) *}
+    SDL_PIXELFORMAT_YVYU = (Integer('Y')       ) or
+                           (Integer('V') shl  8) or
+                           (Integer('Y') shl 16) or
+                           (Integer('U') shl 24);
+
+type
+  PSDL_Color = ^TSDL_Color;
+  TSDL_Color = record
+    r: UInt8;
+    g: UInt8;
+    b: UInt8;
+    a: UInt8;
+  end;
+
+  TSDL_Colour = TSDL_Color;
+  PSDL_Colour = ^TSDL_Colour;
+
+  PSDL_Palette = ^TSDL_Palette;
+  TSDL_Palette = record
+    ncolors: SInt32;
+    colors: PSDL_Color;
+    version: UInt32;
+    refcount: SInt32;
+  end;
+
+  {**
+   *  Everything in the pixel format structure is read-only.
+   *}
+
+  PSDL_PixelFormat = ^TSDL_PixelFormat;
+  TSDL_PixelFormat = record
+    format: UInt32;
+    palette: PSDL_Palette;
+    BitsPerPixel: UInt8;
+    BytesPerPixel: UInt8;
+    padding: array[0..1] of UInt8;
+    Rmask: UInt32;
+    Gmask: UInt32;
+    Bmask: UInt32;
+    Amask: UInt32;
+    Rloss: UInt8;
+    Gloss: UInt8;
+    Bloss: UInt8;
+    Aloss: UInt8;
+    Rshift: UInt8;
+    Gshift: UInt8;
+    Bshift: UInt8;
+    Ashift: UInt8;
+    refcount: SInt32;
+    next: PSDL_PixelFormat;
+  end;
+
+  {**
+   *  Get the human readable name of a pixel format
+   *}
+
+function SDL_GetPixelFormatName(format: UInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPixelFormatName' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Convert one of the enumerated pixel formats to a bpp and RGBA masks.
+   *
+   *  SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
+   *
+   *  SDL_MasksToPixelFormatEnum()
+   *}
+
+function SDL_PixelFormatEnumToMasks(format: UInt32; bpp: PInt; Rmask: PUInt32; Gmask: PUInt32; Bmask: PUInt32; Amask: PUInt32): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PixelFormatEnumToMasks' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Convert a bpp and RGBA masks to an enumerated pixel format.
+   *
+   *  The pixel format, or SDL_PIXELFORMAT_UNKNOWN if the conversion
+   *  wasn't possible.
+   *
+   *  SDL_PixelFormatEnumToMasks()
+   *}
+
+function SDL_MasksToPixelFormatEnum(bpp: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MasksToPixelFormatEnum' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create an SDL_PixelFormat structure from a pixel format enum.
+   *}
+
+function SDL_AllocFormat(pixel_format: UInt32): PSDL_PixelFormat cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocFormat' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Free an SDL_PixelFormat structure.
+   *}
+
+procedure SDL_FreeFormat(format: PSDL_PixelFormat) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeFormat' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a palette structure with the specified number of color
+   *  entries.
+   *
+   *  A new palette, or nil if there wasn't enough memory.
+   *
+   *  The palette entries are initialized to white.
+   *
+   *  SDL_FreePalette()
+   *}
+
+function SDL_AllocPalette(ncolors: SInt32): PSDL_Palette cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocPalette' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the palette for a pixel format structure.
+   *}
+
+function SDL_SetPixelFormatPalette(format: PSDL_PixelFormat; palette: PSDL_Palette): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetPixelFormatPalette' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set a range of colors in a palette.
+   *
+   *  palette    The palette to modify.
+   *  colors     An array of colors to copy into the palette.
+   *  firstcolor The index of the first palette entry to modify.
+   *  ncolors    The number of entries to modify.
+   *
+   *  0 on success, or -1 if not all of the colors could be set.
+   *}
+
+function SDL_SetPaletteColors(palette: PSDL_Palette; const colors: PSDL_Color; firstcolor: SInt32; ncolors: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetPaletteColors' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Free a palette created with SDL_AllocPalette().
+   *
+   *  SDL_AllocPalette()
+   *}
+
+procedure SDL_FreePalette(palette: PSDL_Palette) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreePalette' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Maps an RGB triple to an opaque pixel value for a given pixel format.
+   *
+   *  SDL_MapRGBA
+   *}
+
+function SDL_MapRGB(const format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MapRGB' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Maps an RGBA quadruple to a pixel value for a given pixel format.
+   *
+   *  SDL_MapRGB
+   *}
+
+function SDL_MapRGBA(const format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8; a: UInt8): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MapRGBA' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the RGB components from a pixel of the specified format.
+   *
+   *  SDL_GetRGBA
+   *}
+
+procedure SDL_GetRGB(pixel: UInt32; const format: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRGB' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the RGBA components from a pixel of the specified format.
+   *
+   *  SDL_GetRGB
+   *}
+
+procedure SDL_GetRGBA(pixel: UInt32; const format: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRGBA' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Calculate a 256 entry gamma ramp for a gamma value.
+   *}
+
+procedure SDL_CalculateGammaRamp(gamma: Float; ramp: PUInt16) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CalculateGammaRamp' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlplatform.inc

@@ -0,0 +1,6 @@
+//from sdl_platform.h
+
+{**
+ *  Gets the name of the platform.
+ *}
+function SDL_GetPlatform: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPlatform' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlpower.inc

@@ -0,0 +1,26 @@
+//from "sdl_power.h"
+
+  {**
+   *  The basic state for the system's power supply.
+   *}
+type
+  TSDL_PowerState = (SDL_POWERSTATE_UNKNOWN,      {**< cannot determine power status *}
+                     SDL_POWERSTATE_ON_BATTERY,   {**< Not plugged in, running on the battery *}
+                     SDL_POWERSTATE_NO_BATTERY,   {**< Plugged in, no battery available *}
+                     SDL_POWERSTATE_CHARGING,     {**< Plugged in, charging battery *}
+                     SDL_POWERSTATE_CHARGED);     {**< Plugged in, battery charged *}
+
+  {**
+   *  Get the current power supply details.
+   *
+   *   secs Seconds of battery life left. You can pass a NULL here if
+   *        you don't care. Will return -1 if we can't determine a
+   *        value, or we're not running on a battery.
+   *
+   *   pct Percentage of battery life left, between 0 and 100. You can
+   *       pass a NULL here if you don't care. Will return -1 if we
+   *       can't determine a value, or we're not running on a battery.
+   *
+   *  The state of the battery (if any).
+   *}
+function SDL_GetPowerInfo(secs: PInt; pct: PInt): TSDL_PowerState cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPowerInfo' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlrect.inc

@@ -0,0 +1,88 @@
+//from "sdl_rect.h"
+
+type
+  {**
+   *  The structure that defines a point
+   *
+   *  SDL_EnclosePoints
+   *}
+
+  PSDL_Point = ^TSDL_Point;
+  TSDL_Point = record
+    x: SInt32;
+    y: SInt32;
+  end;
+
+  {**
+   *  A rectangle, with the origin at the upper left.
+   *
+   *  SDL_RectEmpty
+   *  SDL_RectEquals
+   *  SDL_HasIntersection
+   *  SDL_IntersectRect
+   *  SDL_UnionRect
+   *  SDL_EnclosePoints
+   *}
+
+  PSDL_Rect = ^TSDL_Rect;
+  TSDL_Rect = record
+    x,y: SInt32;
+    w,h: SInt32;
+  end;
+
+  {**
+   *  \brief Returns true if point resides inside a rectangle.
+   *}
+function SDL_PointInRect(const p: PSDL_Point; const r: PSDL_Rect): Boolean; Inline;
+
+  {**
+   *  Returns true if the rectangle has no area.
+   *}
+
+  //changed from variant(b<><62><EFBFBD><EFBFBD><EFBFBD>h!) to TSDL_Rect
+  //maybe PSDL_Rect?
+function SDL_RectEmpty(X: TSDL_Rect): Boolean;
+
+    {**
+     *  Returns true if the two rectangles are equal.
+     *}
+
+function SDL_RectEquals(A: TSDL_Rect; B: TSDL_Rect): Boolean;
+
+  {**
+   *  Determine whether two rectangles intersect.
+   *
+   *  SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+   *}
+
+function SDL_HasIntersection(const A: PSDL_Rect; const B: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasIntersection' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Calculate the intersection of two rectangles.
+   *
+   *  SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+   *}
+
+function SDL_IntersectRect(const A: PSDL_Rect; const B: PSDL_Rect; result: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IntersectRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Calculate the union of two rectangles.
+   *}
+
+procedure SDL_UnionRect(const A: PSDL_Rect; const B: PSDL_Rect; result: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnionRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Calculate a minimal rectangle enclosing a set of points
+   *
+   *  SDL_TRUE if any points were within the clipping rect
+   *}
+
+function SDL_EnclosePoints(const points: PSDL_Point; count: SInt32; const clip: PSDL_Rect; result: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_EnclosePoints' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Calculate the intersection of a rectangle and line segment.
+   *
+   *  SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+   *}
+
+function SDL_IntersectRectAndLine(const rect: PSDL_Rect; X1: PInt; Y1: PInt; X2: PInt; Y2: PInt): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IntersectRectAndLine' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlrenderer.inc

@@ -0,0 +1,753 @@
+//from "sdl_renderer.h"
+
+  {**
+   *  Flags used when creating a rendering context
+   *}
+const
+  SDL_RENDERER_SOFTWARE = $00000001;          {**< The renderer is a software fallback *}
+  SDL_RENDERER_ACCELERATED = $00000002;       {**< The renderer uses hardware
+                                                   acceleration *}
+  SDL_RENDERER_PRESENTVSYNC = $00000004;      {**< Present is synchronized
+                                                   with the refresh rate *}
+  SDL_RENDERER_TARGETTEXTURE = $00000008;     {**< The renderer supports
+                                                   rendering to texture *}
+
+type
+  PSDL_RendererFlags = ^TSDL_RendererFlags;
+  TSDL_RendererFlags = Word;
+
+  {**
+   *  Information on the capabilities of a render driver or context.
+   *}
+  PSDL_RendererInfo = ^TSDL_RendererInfo;
+  TSDL_RendererInfo = record  
+    name: PAnsiChar;                         {**< The name of the renderer *}
+    flags: UInt32;                           {**< Supported ::SDL_RendererFlags *}
+    num_texture_formats: UInt32;             {**< The number of available texture formats *}
+    texture_formats: array[0..15] of UInt32; {**< The available texture formats *}
+    max_texture_width: SInt32;               {**< The maximimum texture width *}
+    max_texture_height: SInt32;              {**< The maximimum texture height *}
+  end;
+
+  {**
+   *  The access pattern allowed for a texture.
+   *}
+type
+  PSDL_TextureAccess = ^TSDL_TextureAccess;
+  TSDL_TextureAccess = SInt32;
+
+const
+  SDL_TEXTUREACCESS_STATIC    = 0; {**< Changes rarely, not lockable *}
+  SDL_TEXTUREACCESS_STREAMING = 1; {**< Changes frequently, lockable *}
+  SDL_TEXTUREACCESS_TARGET    = 2; {**< Texture can be used as a render target *}
+
+type
+  {**
+   *  The texture channel modulation used in SDL_RenderCopy().
+   *}
+  PSDL_TextureModulate = ^TSDL_TextureModulate;
+  TSDL_TextureModulate = (
+                          SDL_TEXTUREMODULATE_NONE,     {**< No modulation *}
+                          SDL_TEXTUREMODULATE_COLOR,    {**< srcC = srcC * color *}
+                          SDL_TEXTUREMODULATE_ALPHA     {**< srcA = srcA * alpha *}
+                          );
+
+  {**
+   *  Flip constants for SDL_RenderCopyEx
+   *}
+type
+  PSDL_RendererFlip = ^TSDL_RendererFlip;
+  TSDL_RendererFlip = (SDL_FLIP_NONE,       {**< Do not flip *}
+                       SDL_FLIP_HORIZONTAL, {**< flip horizontally *}
+                       SDL_FLIP_VERTICAL    {**< flip vertically *}
+                       );
+
+  {**
+   *  A structure representing rendering state
+   *}
+
+  PPSDL_Renderer = ^PSDL_Renderer;
+  PSDL_Renderer = ^TSDL_Renderer;
+  TSDL_Renderer = record
+    end;
+
+  {**
+   *  An efficient driver-specific representation of pixel data
+   *}
+  PSDL_Texture = ^TSDL_Texture;
+  TSDL_Texture = record
+    end;
+
+  {* Function prototypes *}
+
+  {**
+   *  Get the number of 2D rendering drivers available for the current
+   *  display.
+   *
+   *  A render driver is a set of code that handles rendering and texture
+   *  management on a particular display.  Normally there is only one, but
+   *  some drivers may have several available with different capabilities.
+   *
+   *   SDL_GetRenderDriverInfo()
+   *   SDL_CreateRenderer()
+   *}
+function SDL_GetNumRenderDrivers: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumRenderDrivers' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get information about a specific 2D rendering driver for the current
+   *  display.
+   *
+   *   index The index of the driver to query information about.
+   *   info  A pointer to an SDL_RendererInfo struct to be filled with
+   *               information on the rendering driver.
+   *
+   *   0 on success, -1 if the index was out of range.
+   *
+   *   SDL_CreateRenderer()
+   *}
+function SDL_GetRenderDriverInfo(index: SInt32; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDriverInfo' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a window and default renderer
+   *
+   *   width    The width of the window
+   *   height   The height of the window
+   *   window_flags The flags used to create the window
+   *   window   A pointer filled with the window, or NULL on error
+   *   renderer A pointer filled with the renderer, or NULL on error
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_CreateWindowAndRenderer(width: SInt32; height: SInt32; window_flags: UInt32; window: PPSDL_Window; renderer: PPSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateWindowAndRenderer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a 2D rendering context for a window.
+   *
+   *   window The window where rendering is displayed.
+   *   index    The index of the rendering driver to initialize, or -1 to
+   *                  initialize the first one supporting the requested flags.
+   *   flags    ::SDL_RendererFlags.
+   *
+   *   A valid rendering context or NULL if there was an error.
+   *
+   *   SDL_CreateSoftwareRenderer()
+   *   SDL_GetRendererInfo()
+   *   SDL_DestroyRenderer()
+   *}
+function SDL_CreateRenderer(window: PSDL_Window; index: SInt32; flags: UInt32): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRenderer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a 2D software rendering context for a surface.
+   *
+   *   surface The surface where rendering is done.
+   *
+   *   A valid rendering context or NULL if there was an error.
+   *
+   *   SDL_CreateRenderer()
+   *   SDL_DestroyRenderer()
+   *}
+function SDL_CreateSoftwareRenderer(surface: PSDL_Surface): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSoftwareRenderer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the renderer associated with a window.
+   *}
+function SDL_GetRenderer(window: PSDL_Window): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get information about a rendering context.
+   *}
+function SDL_GetRendererInfo(renderer: PSDL_Renderer; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererInfo' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the output size of a rendering context.
+   *}
+function SDL_GetRendererOutputSize(renderer: PSDL_Renderer; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererOutputSize' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a texture for a rendering context.
+   *
+   *   renderer The renderer.
+   *   format The format of the texture.
+   *   access One of the enumerated values in ::SDL_TextureAccess.
+   *   w      The width of the texture in pixels.
+   *   h      The height of the texture in pixels.
+   *
+   *   The created texture is returned, or 0 if no rendering context was
+   *   active,  the format was unsupported, or the width or height were out
+   *   of range.
+   *
+   *  SDL_QueryTexture()
+   *  SDL_UpdateTexture()
+   *  SDL_DestroyTexture()
+   *}
+function SDL_CreateTexture(renderer: PSDL_Renderer; format: UInt32; access: SInt32; w: SInt32; h: SInt32): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a texture from an existing surface.
+   *
+   *   renderer The renderer.
+   *   surface The surface containing pixel data used to fill the texture.
+   *
+   *   The created texture is returned, or 0 on error.
+   *
+   *   The surface is not modified or freed by this function.
+   *
+   *   SDL_QueryTexture()
+   *   SDL_DestroyTexture()
+   *}
+function SDL_CreateTextureFromSurface(renderer: PSDL_Renderer; surface: PSDL_Surface): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTextureFromSurface' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Query the attributes of a texture
+   *
+   *   texture A texture to be queried.
+   *   format  A pointer filled in with the raw format of the texture.  The
+   *           actual format may differ, but pixel transfers will use this
+   *           format.
+   *   access  A pointer filled in with the actual access to the texture.
+   *   w       A pointer filled in with the width of the texture in pixels.
+   *   h       A pointer filled in with the height of the texture in pixels.
+   *
+   *   0 on success, or -1 if the texture is not valid.
+   *}
+function SDL_QueryTexture(texture: PSDL_Texture; format: PUInt32; access: PInt; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QueryTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set an additional color value used in render copy operations.
+   *
+   *   texture The texture to update.
+   *   r       The red color value multiplied into copy operations.
+   *   g       The green color value multiplied into copy operations.
+   *   b       The blue color value multiplied into copy operations.
+   *
+   *   0 on success, or -1 if the texture is not valid or color modulation
+   *   is not supported.
+   *
+   *   SDL_GetTextureColorMod()
+   *}
+function SDL_SetTextureColorMod(texture: PSDL_Texture; r: UInt8; g: UInt8; b: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureColorMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the additional color value used in render copy operations.
+   *
+   *   texture The texture to query.
+   *   r         A pointer filled in with the current red color value.
+   *   g         A pointer filled in with the current green color value.
+   *   b         A pointer filled in with the current blue color value.
+   *
+   *   0 on success, or -1 if the texture is not valid.
+   *
+   *   SDL_SetTextureColorMod()
+   *}
+function SDL_GetTextureColorMod(texture: PSDL_Texture; r: PUInt8; g: PUInt8; b: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureColorMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set an additional alpha value used in render copy operations.
+   *
+   *   texture The texture to update.
+   *   alpha     The alpha value multiplied into copy operations.
+   *
+   *   0 on success, or -1 if the texture is not valid or alpha modulation
+   *   is not supported.
+   *
+   *   SDL_GetTextureAlphaMod()
+   *}
+function SDL_SetTextureAlphaMod(texture: PSDL_Texture; alpha: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureAlphaMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the additional alpha value used in render copy operations.
+   *
+   *   texture The texture to query.
+   *   alpha     A pointer filled in with the current alpha value.
+   *
+   *   0 on success, or -1 if the texture is not valid.
+   *
+   *   SDL_SetTextureAlphaMod()
+   *}
+function SDL_GetTextureAlphaMod(texture: PSDL_Texture; alpha: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureAlphaMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *   Set the blend mode used for texture copy operations.
+   *
+   *   texture The texture to update.
+   *   blendMode ::SDL_BlendMode to use for texture blending.
+   *
+   *   0 on success, or -1 if the texture is not valid or the blend mode is
+   *   not supported.
+   *
+   *   If the blend mode is not supported, the closest supported mode is
+   *   chosen.
+   *
+   *   SDL_GetTextureBlendMode()
+   *}
+function SDL_SetTextureBlendMode(texture: PSDL_Texture; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the blend mode used for texture copy operations.
+   *
+   *   texture   The texture to query.
+   *   blendMode A pointer filled in with the current blend mode.
+   *
+   *   0 on success, or -1 if the texture is not valid.
+   *
+   *   SDL_SetTextureBlendMode()
+   *}
+function SDL_GetTextureBlendMode(texture: PSDL_Texture; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Update the given texture rectangle with new pixel data.
+   *
+   *   texture   The texture to update
+   *   rect      A pointer to the rectangle of pixels to update, or NULL to
+   *                   update the entire texture.
+   *   pixels    The raw pixel data.
+   *   pitch     The number of bytes between rows of pixel data.
+   *
+   *   0 on success, or -1 if the texture is not valid.
+   *
+   *   This is a fairly slow function.
+   *}
+function SDL_UpdateTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Lock a portion of the texture for write-only pixel access.
+   *
+   *   texture   The texture to lock for access, which was created with
+   *             SDL_TEXTUREACCESS_STREAMING.
+   *   rect      A pointer to the rectangle to lock for access. If the rect
+   *             is NULL, the entire texture will be locked.
+   *   pixels    This is filled in with a pointer to the locked pixels,
+   *             appropriately offset by the locked area.
+   *   pitch     This is filled in with the pitch of the locked pixels.
+   *
+   *   0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+   *
+   *   SDL_UnlockTexture()
+   *}
+function SDL_LockTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: PPointer; pitch: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Unlock a texture, uploading the changes to video memory, if needed.
+   *
+   *   SDL_LockTexture()
+   *}
+procedure SDL_UnlockTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Determines whether a window supports the use of render targets
+   *
+   *  renderer The renderer that will be checked
+   *
+   *  SDL_TRUE if supported, SDL_FALSE if not.
+   *}
+function SDL_RenderTargetSupported(renderer: PSDL_Renderer): Boolean cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderTargetSupported' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set a texture as the current rendering target.
+   *
+   *  renderer The renderer.
+   *  texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+   *
+   *  0 on success, or -1 on error
+   *
+   *   SDL_GetRenderTarget()
+   *}
+function SDL_SetRenderTarget(renderer: PSDL_Renderer; texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderTarget' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the current render target or NULL for the default render target.
+   *
+   *  The current render target
+   *
+   *   SDL_SetRenderTarget()
+   *}
+function SDL_GetRenderTarget(renderer: PSDL_Renderer): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderTarget' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set device independent resolution for rendering
+   *
+   *   renderer The renderer for which resolution should be set.
+   *   w      The width of the logical resolution
+   *   h      The height of the logical resolution
+   *
+   *  This function uses the viewport and scaling functionality to allow a fixed logical
+   *  resolution for rendering, regardless of the actual output resolution.  If the actual
+   *  output resolution doesn't have the same aspect ratio the output rendering will be
+   *  centered within the output display.
+   *
+   *  If the output display is a window, mouse events in the window will be filtered
+   *  and scaled so they seem to arrive within the logical resolution.
+   *
+   *   If this function results in scaling or subpixel drawing by the
+   *   rendering backend, it will be handled using the appropriate
+   *   quality hints.
+   *
+   *   SDL_RenderGetLogicalSize()
+   *   SDL_RenderSetScale()
+   *   SDL_RenderSetViewport()
+   *}
+function SDL_RenderSetLogicalSize(renderer: PSDL_Renderer; w: SInt32; h: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetLogicalSize' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get device independent resolution for rendering
+   *
+   *   renderer The renderer from which resolution should be queried.
+   *   w      A pointer filled with the width of the logical resolution
+   *   h      A pointer filled with the height of the logical resolution
+   *
+   *   SDL_RenderSetLogicalSize()
+   *}
+procedure SDL_RenderGetLogicalSize(renderer: PSDL_Renderer; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetLogicalSize' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the drawing area for rendering on the current target.
+   *
+   *   renderer The renderer for which the drawing area should be set.
+   *   rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+   *
+   *  The x,y of the viewport rect represents the origin for rendering.
+   *
+   *   0 on success, or -1 on error
+   *
+   *  If the window associated with the renderer is resized, the viewport is automatically reset.
+   *
+   *   SDL_RenderGetViewport()
+   *   SDL_RenderSetLogicalSize()
+   *}
+function SDL_RenderSetViewport(renderer: PSDL_Renderer; const rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetViewport' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the drawing area for the current target.
+   *
+   *   SDL_RenderSetViewport()
+   *}
+procedure SDL_RenderGetViewport(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetViewport' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the clip rectangle for the current target.
+   *
+   *   renderer The renderer for which clip rectangle should be set.
+   *   rect   A pointer to the rectangle to set as the clip rectangle, or
+   *          NULL to disable clipping.
+   *
+   *   0 on success, or -1 on error
+   *
+   *   SDL_RenderGetClipRect()
+   *}
+function SDL_RenderSetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetClipRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the clip rectangle for the current target.
+   *
+   *   renderer The renderer from which clip rectangle should be queried.
+   *   rect   A pointer filled in with the current clip rectangle, or
+   *          an empty rectangle if clipping is disabled.
+   *
+   *   SDL_RenderSetClipRect()
+   *}
+procedure SDL_RenderGetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetClipRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  \brief Get whether clipping is enabled on the given renderer.
+   *
+   *  \param renderer The renderer from which clip state should be queried.
+   *
+   *  \sa SDL_RenderGetClipRect()
+   *}
+function SDL_RenderIsClipEnabled(renderer: PSDL_Renderer): TSDL_Bool; cdecl;
+  external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderIsClipEnabled' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the drawing scale for rendering on the current target.
+   *
+   *   renderer The renderer for which the drawing scale should be set.
+   *   scaleX The horizontal scaling factor
+   *   scaleY The vertical scaling factor
+   *
+   *  The drawing coordinates are scaled by the x/y scaling factors
+   *  before they are used by the renderer.  This allows resolution
+   *  independent drawing with a single coordinate system.
+   *
+   *  If this results in scaling or subpixel drawing by the
+   *  rendering backend, it will be handled using the appropriate
+   *  quality hints.  For best results use integer scaling factors.
+   *
+   *   SDL_RenderGetScale()
+   *   SDL_RenderSetLogicalSize()
+   *}
+function SDL_RenderSetScale(renderer: PSDL_Renderer; scaleX: Float; scaleY: Float): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetScale' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the drawing scale for the current target.
+   *
+   *   renderer The renderer from which drawing scale should be queried.
+   *   scaleX A pointer filled in with the horizontal scaling factor
+   *   scaleY A pointer filled in with the vertical scaling factor
+   *
+   *   SDL_RenderSetScale()
+   *}
+procedure SDL_RenderGetScale(renderer: PSDL_Renderer; scaleX: PFloat; scaleY: PFloat) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetScale' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the color used for drawing operations (Rect, Line and Clear).
+   *
+   *   renderer The renderer for which drawing color should be set.
+   *   r The red value used to draw on the rendering target.
+   *   g The green value used to draw on the rendering target.
+   *   b The blue value used to draw on the rendering target.
+   *   a The alpha value used to draw on the rendering target, usually
+   *     SDL_ALPHA_OPAQUE (255).
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_SetRenderDrawColor(renderer: PSDL_Renderer; r: UInt8; g: UInt8; b: UInt8; a: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawColor' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the color used for drawing operations (Rect, Line and Clear).
+   *
+   *   renderer The renderer from which drawing color should be queried.
+   *   r A pointer to the red value used to draw on the rendering target.
+   *   g A pointer to the green value used to draw on the rendering target.
+   *   b A pointer to the blue value used to draw on the rendering target.
+   *   a A pointer to the alpha value used to draw on the rendering target,
+   *     usually SDL_ALPHA_OPAQUE (255).
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_GetRenderDrawColor(renderer: PSDL_Renderer; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawColor' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the blend mode used for drawing operations (Fill and Line).
+   *
+   *   renderer The renderer for which blend mode should be set.
+   *   blendMode SDL_BlendMode to use for blending.
+   *
+   *   0 on success, or -1 on error
+   *
+   *   If the blend mode is not supported, the closest supported mode is
+   *        chosen.
+   *
+   *   SDL_GetRenderDrawBlendMode()
+   *}
+function SDL_SetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the blend mode used for drawing operations.
+   *
+   *   renderer The renderer from which blend mode should be queried.
+   *   blendMode A pointer filled in with the current blend mode.
+   *
+   *   0 on success, or -1 on error
+   *
+   *   SDL_SetRenderDrawBlendMode()
+   *}
+function SDL_GetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Clear the current rendering target with the drawing color
+   *
+   *  This function clears the entire rendering target, ignoring the viewport.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderClear(renderer: PSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderClear' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Draw a point on the current rendering target.
+   *
+   *   renderer The renderer which should draw a point.
+   *   x The x coordinate of the point.
+   *   y The y coordinate of the point.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderDrawPoint(renderer: PSDL_Renderer; x: SInt32; y: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoint' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Draw multiple points on the current rendering target.
+   *
+   *   renderer The renderer which should draw multiple points.
+   *   points The points to draw
+   *   count The number of points to draw
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderDrawPoints(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoints' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Draw a line on the current rendering target.
+   *
+   *   renderer The renderer which should draw a line.
+   *   x1 The x coordinate of the start point.
+   *   y1 The y coordinate of the start point.
+   *   x2 The x coordinate of the end point.
+   *   y2 The y coordinate of the end point.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderDrawLine(renderer: PSDL_Renderer; x1: SInt32; y1: SInt32; x2: SInt32; y2: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLine' {$ENDIF} {$ENDIF};
+
+  {**
+   *  \brief Draw a series of connected lines on the current rendering target.
+   *
+   *  \param renderer The renderer which should draw multiple lines.
+   *  \param points The points along the lines
+   *  \param count The number of points, drawing count-1 lines
+   *
+   *  \return 0 on success, or -1 on error
+   *}
+function SDL_RenderDrawLines(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLines' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Draw a rectangle on the current rendering target.
+   *
+   *   renderer The renderer which should draw a rectangle.
+   *   rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderDrawRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Draw some number of rectangles on the current rendering target.
+   *
+   *   renderer The renderer which should draw multiple rectangles.
+   *   rects A pointer to an array of destination rectangles.
+   *   count The number of rectangles.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderDrawRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRects' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Fill a rectangle on the current rendering target with the drawing color.
+   *
+   *   renderer The renderer which should fill a rectangle.
+   *   rect A pointer to the destination rectangle, or NULL for the entire
+   *        rendering target.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderFillRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Fill some number of rectangles on the current rendering target with the drawing color.
+   *
+   *   renderer The renderer which should fill multiple rectangles.
+   *   rects A pointer to an array of destination rectangles.
+   *   count The number of rectangles.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderFillRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRects' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Copy a portion of the texture to the current rendering target.
+   *
+   *   renderer The renderer which should copy parts of a texture.
+   *   texture The source texture.
+   *   srcrect   A pointer to the source rectangle, or NULL for the entire
+   *             texture.
+   *   dstrect   A pointer to the destination rectangle, or NULL for the
+   *             entire rendering target.
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderCopy(renderer: PSDL_Renderer; texture: PSDL_Texture; srcrect: PSDL_Rect; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopy' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+   *
+   *   renderer The renderer which should copy parts of a texture.
+   *   texture The source texture.
+   *   srcrect   A pointer to the source rectangle, or NULL for the entire
+   *                   texture.
+   *   dstrect   A pointer to the destination rectangle, or NULL for the
+   *                   entire rendering target.
+   *   angle    An angle in degrees that indicates the rotation that will be applied to dstrect
+   *   center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done aroud dstrect.w/2, dstrect.h/2)
+   *   flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+   *
+   *   0 on success, or -1 on error
+   *}
+function SDL_RenderCopyEx(renderer: PSDL_Renderer; texture: PSDL_Texture; const srcrect: PSDL_Rect; dstrect: PSDL_Rect; angle: Double; center: PSDL_Point; flip: TSDL_RendererFlip): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopyEx' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Read pixels from the current rendering target.
+   *
+   *   renderer The renderer from which pixels should be read.
+   *   rect   A pointer to the rectangle to read, or NULL for the entire
+   *                render target.
+   *   format The desired format of the pixel data, or 0 to use the format
+   *                of the rendering target
+   *   pixels A pointer to be filled in with the pixel data
+   *   pitch  The pitch of the pixels parameter.
+   *
+   *   0 on success, or -1 if pixel reading is not supported.
+   *
+   *   This is a very slow operation, and should not be used frequently.
+   *}
+function SDL_RenderReadPixels(renderer: PSDL_Renderer; rect: PSDL_Rect; format: UInt32; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderReadPixels' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Update the screen with rendering performed.
+   *}
+procedure SDL_RenderPresent(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderPresent' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Destroy the specified texture.
+   *
+   *   SDL_CreateTexture()
+   *   SDL_CreateTextureFromSurface()
+   *}
+procedure SDL_DestroyTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Destroy the rendering context for a window and free associated
+   *  textures.
+   *
+   *   SDL_CreateRenderer()
+   *}
+procedure SDL_DestroyRenderer(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyRenderer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Bind the texture to the current OpenGL/ES/ES2 context for use with
+   *  OpenGL instructions.
+   *
+   *   texture  The SDL texture to bind
+   *   texw     A pointer to a float that will be filled with the texture width
+   *   texh     A pointer to a float that will be filled with the texture height
+   *
+   *   0 on success, or -1 if the operation is not supported
+   *}
+function SDL_GL_BindTexture(texture: PSDL_Texture; texw: PFloat; texh: PFloat): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_BindTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Unbind a texture from the current OpenGL/ES/ES2 context.
+   *
+   *   texture  The SDL texture to unbind
+   *
+   *   0 on success, or -1 if the operation is not supported
+   *}
+function SDL_GL_UnbindTexture(texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_UnbindTexture' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
+   *
+   *  texture   The texture to update
+   *  rect      A pointer to the rectangle of pixels to update, or NULL to update the entire texture.
+   *  Yplane    The raw pixel data for the Y plane.
+   *  Ypitch    The number of bytes between rows of pixel data for the Y plane.
+   *  Uplane    The raw pixel data for the U plane.
+   *  Upitch    The number of bytes between rows of pixel data for the U plane.
+   *  Vplane    The raw pixel data for the V plane.
+   *  Vpitch    The number of bytes between rows of pixel data for the V plane.
+   *
+   *  0 on success, or -1 if the texture is not valid.
+   *
+   *  You can use SDL_UpdateTexture() as long as your pixel data is
+   *  a contiguous block of Y and U/V planes in the proper order, but
+   *  this function is available if your pixel data is not contiguous.
+   *}
+function SDL_UpdateYUVTexture(texture: PSDL_Texture; rect: PSDL_Rect; Yplane: PUInt8; Ypitch: SInt32; Uplane: PUInt8; UPitch: SInt32; Vplane: UInt8; VPitch: SInt32):SInt32;
+   cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateYUVTexture' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlrwops.inc

@@ -0,0 +1,188 @@
+//from "sdl_rwops"
+
+const
+  {* RWops Types *}
+  SDL_RWOPS_UNKNOWN	  = 0;	{* Unknown stream type *}
+  SDL_RWOPS_WINFILE	  = 1;	{* Win32 file *}
+  SDL_RWOPS_STDFILE	  = 2;	{* Stdio file *}
+  SDL_RWOPS_JNIFILE	  = 3;	{* Android asset *}
+  SDL_RWOPS_MEMORY    =	4;	{* Memory stream *}
+  SDL_RWOPS_MEMORY_RO =	5;	{* Read-Only memory stream *}
+
+type
+  PSDL_RWops = ^TSDL_RWops;
+
+  {**
+   * This is the read/write operation structure -- very basic.
+   *}
+
+  {**
+   *  Return the size of the file in this rwops, or -1 if unknown
+   *}
+  TSize = function(context: PSDL_RWops): SInt64; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+  {**
+   *  Seek to offset relative to whence, one of stdio's whence values:
+   *  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+   *
+   *  the final offset in the data stream, or -1 on error.
+   *}
+  TSeek = function(context: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64; {$IFNDEF GPC} cdecl; {$ENDIF}
+                   
+  {**
+   *  Read up to maxnum objects each of size size from the data
+   *  stream to the area pointed at by ptr.
+   *
+   *  the number of objects read, or 0 at error or end of file.
+   *}
+
+   TRead = function(context: PSDL_RWops; ptr: Pointer; size: size_t; maxnum: size_t): size_t; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+  {**
+   *  Write exactly num objects each of size size from the area
+   *  pointed at by ptr to data stream.
+   *  
+   *  the number of objects written, or 0 at error or end of file.
+   *}
+	
+   TWrite = function(context: PSDL_RWops; const ptr: Pointer; size: size_t; num: size_t): size_t; {$IFNDEF GPC} cdecl; {$ENDIF}
+	
+  {**
+   *  Close and free an allocated SDL_RWops structure.
+   *  
+   *  0 if successful or -1 on write error when flushing data.
+   *}
+
+  TClose =  function(context: PSDL_RWops): SInt32; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+  TStdio = record
+    autoclose: TSDL_Bool;
+	fp: file;
+  end;
+  
+  TMem = record
+    base: PUInt8;
+	here: PUInt8;
+	stop: PUInt8;
+  end;
+  
+  TUnknown = record
+    data1: Pointer;
+  end;
+
+  TAndroidIO = record
+    fileNameRef: Pointer;
+    inputStreamRef: Pointer;
+    readableByteChannelRef: Pointer;
+    readMethod: Pointer;
+    assetFileDescriptorRef: Pointer;
+    position: LongInt;
+    size: LongInt;
+    offset: LongInt;
+    fd: SInt32;
+  end;
+
+  TWindowsIOBuffer = record
+    data: Pointer;
+	size: size_t;
+	left: size_t;
+  end;
+
+  TWindowsIO = record
+    append: TSDL_Bool;
+    h: Pointer;
+    buffer: TWindowsIOBuffer;
+  end;
+
+  TSDL_RWops = packed record
+    size: TSize;
+    seek: TSeek;
+    read: TRead;
+    write: TWrite;
+    close: TClose;
+
+    _type: UInt32;
+
+	case Integer of
+	  0: (stdio: TStdio);
+	  1: (mem: TMem);
+	  2: (unknown: TUnknown);
+	  {$IFDEF ANDROID}
+	  3: (androidio: TAndroidIO);
+	  {$ENDIF}
+	  {$IFDEF WINDOWS}
+	  3: (windowsio: TWindowsIO);
+	  {$ENDIF}
+  end;
+
+  {**
+   *  RWFrom functions
+   *
+   *  Functions to create SDL_RWops structures from various data streams.
+   *}
+
+function SDL_RWFromFile(const _file: PAnsiChar; const mode: PAnsiChar): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromFile' {$ENDIF} {$ENDIF};
+
+  {function SDL_RWFromFP(fp: file; autoclose: TSDL_Bool): PSDL_RWops; cdecl; external SDL_LibName;} //don't know if this works
+
+function SDL_RWFromFP(fp: Pointer; autoclose: TSDL_Bool): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromFP' {$ENDIF} {$ENDIF};
+
+function SDL_RWFromMem(mem: Pointer; size: SInt32): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromMem' {$ENDIF} {$ENDIF};
+function SDL_RWFromConstMem(const mem: Pointer; size: SInt32): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromConstMem' {$ENDIF} {$ENDIF};
+
+{*RWFrom functions*}
+
+
+function SDL_AllocRW: PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocRW' {$ENDIF} {$ENDIF};
+procedure SDL_FreeRW(area: PSDL_RWops); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeRW' {$ENDIF} {$ENDIF};
+
+const
+  RW_SEEK_SET = 0;       {**< Seek from the beginning of data *}
+  RW_SEEK_CUR = 1;       {**< Seek relative to current read point *}
+  RW_SEEK_END = 2;       {**< Seek relative to the end of data *}
+
+  {**
+   *  Read/write macros
+   *
+   *  Macros to easily read and write from an SDL_RWops structure.
+   *}
+
+  function SDL_RWsize(ctx: PSDL_RWops): SInt64; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  function SDL_RWseek(ctx: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  function SDL_RWtell(ctx: PSDL_RWops): SInt64; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  function SDL_RWread(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  function SDL_RWwrite(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  function SDL_RWclose(ctx: PSDL_RWops): SInt32; {$IFNDEF DELPHI} inline; {$ELSE} {$IFDEF DELPHI10UP} inline; {$ENDIF} {$ENDIF}
+  { Read/write macros }
+
+
+  {**
+   *  Read endian functions
+   *
+   *  Read an item of the specified endianness and return in native format.
+   *}
+
+function SDL_ReadU8(src: PSDL_RWops): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadU8' {$ENDIF} {$ENDIF};
+function SDL_ReadLE16(src: PSDL_RWops): UInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE16' {$ENDIF} {$ENDIF};
+function SDL_ReadBE16(src: PSDL_RWops): UInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE16' {$ENDIF} {$ENDIF};
+function SDL_ReadLE32(src: PSDL_RWops): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE32' {$ENDIF} {$ENDIF};
+function SDL_ReadBE32(src: PSDL_RWops): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE32' {$ENDIF} {$ENDIF};
+function SDL_ReadLE64(src: PSDL_RWops): UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE64' {$ENDIF} {$ENDIF};
+function SDL_ReadBE64(src: PSDL_RWops): UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE64' {$ENDIF} {$ENDIF};
+
+  {*Read endian functions*}
+
+  {**
+   *  Write endian functions
+   *
+   *  Write an item of native format to the specified endianness.
+   *}
+
+function SDL_WriteU8(dst: PSDL_RWops; value: UInt8): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteU8' {$ENDIF} {$ENDIF};
+function SDL_WriteLE16(dst: PSDL_RWops; value: UInt16): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE16' {$ENDIF} {$ENDIF};
+function SDL_WriteBE16(dst: PSDL_RWops; value: UInt16): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE16' {$ENDIF} {$ENDIF};
+function SDL_WriteLE32(dst: PSDL_RWops; value: UInt32): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE32' {$ENDIF} {$ENDIF};
+function SDL_WriteBE32(dst: PSDL_RWops; value: UInt32): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE32' {$ENDIF} {$ENDIF};
+function SDL_WriteLE64(dst: PSDL_RWops; value: UInt64): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE64' {$ENDIF} {$ENDIF};
+function SDL_WriteBE64(dst: PSDL_RWops; value: UInt64): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE64' {$ENDIF} {$ENDIF};
+  { Write endian functions }

model_viewer/sdl2/sdlscancode.inc

@@ -0,0 +1,662 @@
+//from "sdl_scancode.h"
+
+  {**
+   *  The SDL keyboard scancode representation.
+   *
+   *  Values of this type are used to represent keyboard keys, among other places
+   *  in the SDL_Keysym.scancode key.keysym.scancode \endlink field of the
+   *  SDL_Event structure.
+   *
+   *  The values in this enumeration are based on the USB usage page standard:
+   *  http://www.usb.org/developers/devclass_docs/Hut1_12v2.pdf
+   *}
+
+const
+  SDL_SCANCODE_UNKNOWN = 0;
+
+  {**
+   *  Usage page $07
+   *
+   *  These values are from usage page $07 (USB keyboard page).
+   *}
+
+  SDL_SCANCODE_A = 4;
+  SDL_SCANCODE_B = 5;
+  SDL_SCANCODE_C = 6;
+  SDL_SCANCODE_D = 7;
+  SDL_SCANCODE_E = 8;
+  SDL_SCANCODE_F = 9;
+  SDL_SCANCODE_G = 10;
+  SDL_SCANCODE_H = 11;
+  SDL_SCANCODE_I = 12;
+  SDL_SCANCODE_J = 13;
+  SDL_SCANCODE_K = 14;
+  SDL_SCANCODE_L = 15;
+  SDL_SCANCODE_M = 16;
+  SDL_SCANCODE_N = 17;
+  SDL_SCANCODE_O = 18;
+  SDL_SCANCODE_P = 19;
+  SDL_SCANCODE_Q = 20;
+  SDL_SCANCODE_R = 21;
+  SDL_SCANCODE_S = 22;
+  SDL_SCANCODE_T = 23;
+  SDL_SCANCODE_U = 24;
+  SDL_SCANCODE_V = 25;
+  SDL_SCANCODE_W = 26;
+  SDL_SCANCODE_X = 27;
+  SDL_SCANCODE_Y = 28;
+  SDL_SCANCODE_Z = 29;
+
+  SDL_SCANCODE_1 = 30;
+  SDL_SCANCODE_2 = 31;
+  SDL_SCANCODE_3 = 32;
+  SDL_SCANCODE_4 = 33;
+  SDL_SCANCODE_5 = 34;
+  SDL_SCANCODE_6 = 35;
+  SDL_SCANCODE_7 = 36;
+  SDL_SCANCODE_8 = 37;
+  SDL_SCANCODE_9 = 38;
+  SDL_SCANCODE_0 = 39;
+
+  SDL_SCANCODE_RETURN = 40;
+  SDL_SCANCODE_ESCAPE = 41;
+  SDL_SCANCODE_BACKSPACE = 42;
+  SDL_SCANCODE_TAB = 43;
+  SDL_SCANCODE_SPACE = 44;
+
+  SDL_SCANCODE_MINUS = 45;
+  SDL_SCANCODE_EQUALS = 46;
+  SDL_SCANCODE_LEFTBRACKET = 47;
+  SDL_SCANCODE_RIGHTBRACKET = 48;
+  SDL_SCANCODE_BACKSLASH = 49; {**< Located at the lower left of the return
+                                *   key on ISO keyboards and at the right end
+                                *   of the QWERTY row on ANSI keyboards.
+                                *   Produces REVERSE SOLIDUS (backslash) and
+                                *   VERTICAL LINE in a US layout; REVERSE 
+                                *   SOLIDUS and VERTICAL LINE in a UK Mac
+                                *   layout; NUMBER SIGN and TILDE in a UK 
+                                *   Windows layout; DOLLAR SIGN and POUND SIGN
+                                *   in a Swiss German layout; NUMBER SIGN and
+                                *   APOSTROPHE in a German layout; GRAVE
+                                *   ACCENT and POUND SIGN in a French Mac 
+                                *   layout; and ASTERISK and MICRO SIGN in a
+                                *   French Windows layout.
+                                *}
+  SDL_SCANCODE_NONUSHASH = 50; {**< ISO USB keyboards actually use this code
+                                *   instead of 49 for the same key; but all
+                                *   OSes I've seen treat the two codes 
+                                *   identically. So; as an implementor; unless
+                                *   your keyboard generates both of those 
+                                *   codes and your OS treats them differently;
+                                *   you should generate SDL_SCANCODE_BACKSLASH
+                                *   instead of this code. As a user; you
+                                *   should not rely on this code because SDL
+                                *   will never generate it with most (all?)
+                                *   keyboards.
+                                *}
+  SDL_SCANCODE_SEMICOLON = 51;
+  SDL_SCANCODE_APOSTROPHE = 52;
+  SDL_SCANCODE_GRAVE = 53;     {**< Located in the top left corner (on both ANSI
+                                *   and ISO keyboards). Produces GRAVE ACCENT and
+                                *   TILDE in a US Windows layout and in US and UK
+                                *   Mac layouts on ANSI keyboards; GRAVE ACCENT
+                                *   and NOT SIGN in a UK Windows layout; SECTION
+                                *   SIGN and PLUS-MINUS SIGN in US and UK Mac
+                                *   layouts on ISO keyboards; SECTION SIGN and
+                                *   DEGREE SIGN in a Swiss German layout (Mac:
+                                *   only on ISO keyboards); CIRCUMFLEX ACCENT and
+                                *   DEGREE SIGN in a German layout (Mac: only on
+                                *   ISO keyboards); SUPERSCRIPT TWO and TILDE in a
+                                *   French Windows layout; COMMERCIAL AT and
+                                *   NUMBER SIGN in a French Mac layout on ISO
+                                *   keyboards; and LESS-THAN SIGN and GREATER-THAN
+                                *   SIGN in a Swiss German; German; or French Mac
+                                *   layout on ANSI keyboards.
+                                *}
+  SDL_SCANCODE_COMMA = 54;
+  SDL_SCANCODE_PERIOD = 55;
+  SDL_SCANCODE_SLASH = 56;
+
+  SDL_SCANCODE_CAPSLOCK = 57;
+
+  SDL_SCANCODE_F1 = 58;
+  SDL_SCANCODE_F2 = 59;
+  SDL_SCANCODE_F3 = 60;
+  SDL_SCANCODE_F4 = 61;
+  SDL_SCANCODE_F5 = 62;
+  SDL_SCANCODE_F6 = 63;
+  SDL_SCANCODE_F7 = 64;
+  SDL_SCANCODE_F8 = 65;
+  SDL_SCANCODE_F9 = 66;
+  SDL_SCANCODE_F10 = 67;
+  SDL_SCANCODE_F11 = 68;
+  SDL_SCANCODE_F12 = 69;
+
+  SDL_SCANCODE_PRINTSCREEN = 70;
+  SDL_SCANCODE_SCROLLLOCK = 71;
+  SDL_SCANCODE_PAUSE = 72;
+  SDL_SCANCODE_INSERT = 73; {**< insert on PC; help on some Mac keyboards (but
+                                 does send code 73; not 117) *}
+  SDL_SCANCODE_HOME = 74;
+  SDL_SCANCODE_PAGEUP = 75;
+  SDL_SCANCODE_DELETE = 76;
+  SDL_SCANCODE_END = 77;
+  SDL_SCANCODE_PAGEDOWN = 78;
+  SDL_SCANCODE_RIGHT = 79;
+  SDL_SCANCODE_LEFT = 80;
+  SDL_SCANCODE_DOWN = 81;
+  SDL_SCANCODE_UP = 82;
+
+  SDL_SCANCODE_NUMLOCKCLEAR = 83; {**< num lock on PC; clear on Mac keyboards
+                                   *}
+  SDL_SCANCODE_KP_DIVIDE = 84;
+  SDL_SCANCODE_KP_MULTIPLY = 85;
+  SDL_SCANCODE_KP_MINUS = 86;
+  SDL_SCANCODE_KP_PLUS = 87;
+  SDL_SCANCODE_KP_ENTER = 88;
+  SDL_SCANCODE_KP_1 = 89;
+  SDL_SCANCODE_KP_2 = 90;
+  SDL_SCANCODE_KP_3 = 91;
+  SDL_SCANCODE_KP_4 = 92;
+  SDL_SCANCODE_KP_5 = 93;
+  SDL_SCANCODE_KP_6 = 94;
+  SDL_SCANCODE_KP_7 = 95;
+  SDL_SCANCODE_KP_8 = 96;
+  SDL_SCANCODE_KP_9 = 97;
+  SDL_SCANCODE_KP_0 = 98;
+  SDL_SCANCODE_KP_PERIOD = 99;
+
+  SDL_SCANCODE_NONUSBACKSLASH = 100; {**< This is the additional key that ISO
+                                      *   keyboards have over ANSI ones; 
+                                      *   located between left shift and Y. 
+                                      *   Produces GRAVE ACCENT and TILDE in a
+                                      *   US or UK Mac layout; REVERSE SOLIDUS
+                                      *   (backslash) and VERTICAL LINE in a 
+                                      *   US or UK Windows layout; and 
+                                      *   LESS-THAN SIGN and GREATER-THAN SIGN
+                                      *   in a Swiss German; German; or French
+                                      *   layout. *}
+  SDL_SCANCODE_APPLICATION = 101;    {**< windows contextual menu; compose *}
+  SDL_SCANCODE_POWER = 102;          {**< The USB document says this is a status flag;
+                                       *  not a physical key - but some Mac keyboards
+                                       *  do have a power key. *}
+  SDL_SCANCODE_KP_EQUALS = 103;
+  SDL_SCANCODE_F13 = 104;
+  SDL_SCANCODE_F14 = 105;
+  SDL_SCANCODE_F15 = 106;
+  SDL_SCANCODE_F16 = 107;
+  SDL_SCANCODE_F17 = 108;
+  SDL_SCANCODE_F18 = 109;
+  SDL_SCANCODE_F19 = 110;
+  SDL_SCANCODE_F20 = 111;
+  SDL_SCANCODE_F21 = 112;
+  SDL_SCANCODE_F22 = 113;
+  SDL_SCANCODE_F23 = 114;
+  SDL_SCANCODE_F24 = 115;
+  SDL_SCANCODE_EXECUTE = 116;
+  SDL_SCANCODE_HELP = 117;
+  SDL_SCANCODE_MENU = 118;
+  SDL_SCANCODE_SELECT = 119;
+  SDL_SCANCODE_STOP = 120;
+  SDL_SCANCODE_AGAIN = 121;   {**< redo *}
+  SDL_SCANCODE_UNDO = 122;
+  SDL_SCANCODE_CUT = 123;
+  SDL_SCANCODE_COPY = 124;
+  SDL_SCANCODE_PASTE = 125;
+  SDL_SCANCODE_FIND = 126;
+  SDL_SCANCODE_MUTE = 127;
+  SDL_SCANCODE_VOLUMEUP = 128;
+  SDL_SCANCODE_VOLUMEDOWN = 129;
+  {* not sure whether there's a reason to enable these *}
+  {*     SDL_SCANCODE_LOCKINGCAPSLOCK = 130;  *}
+  {*     SDL_SCANCODE_LOCKINGNUMLOCK = 131; *}
+  {*     SDL_SCANCODE_LOCKINGSCROLLLOCK = 132; *}
+  SDL_SCANCODE_KP_COMMA = 133;
+  SDL_SCANCODE_KP_EQUALSAS400 = 134;
+
+  SDL_SCANCODE_INTERNATIONAL1 = 135; {**< used on Asian keyboards; see footnotes in USB doc *}
+  SDL_SCANCODE_INTERNATIONAL2 = 136;
+  SDL_SCANCODE_INTERNATIONAL3 = 137; {**< Yen *}
+  SDL_SCANCODE_INTERNATIONAL4 = 138;
+  SDL_SCANCODE_INTERNATIONAL5 = 139;
+  SDL_SCANCODE_INTERNATIONAL6 = 140;
+  SDL_SCANCODE_INTERNATIONAL7 = 141;
+  SDL_SCANCODE_INTERNATIONAL8 = 142;
+  SDL_SCANCODE_INTERNATIONAL9 = 143;
+  SDL_SCANCODE_LANG1 = 144; {**< Hangul/English toggle *}
+  SDL_SCANCODE_LANG2 = 145; {**< Hanja conversion *}
+  SDL_SCANCODE_LANG3 = 146; {**< Katakana *}
+  SDL_SCANCODE_LANG4 = 147; {**< Hiragana *}
+  SDL_SCANCODE_LANG5 = 148; {**< Zenkaku/Hankaku *}
+  SDL_SCANCODE_LANG6 = 149; {**< reserved *}
+  SDL_SCANCODE_LANG7 = 150; {**< reserved *}
+  SDL_SCANCODE_LANG8 = 151; {**< reserved *}
+  SDL_SCANCODE_LANG9 = 152; {**< reserved *}
+
+  SDL_SCANCODE_ALTERASE = 153; {**< Erase-Eaze *}
+  SDL_SCANCODE_SYSREQ = 154;
+  SDL_SCANCODE_CANCEL = 155;
+  SDL_SCANCODE_CLEAR = 156;
+  SDL_SCANCODE_PRIOR = 157;
+  SDL_SCANCODE_RETURN2 = 158;
+  SDL_SCANCODE_SEPARATOR = 159;
+  SDL_SCANCODE_OUT = 160;
+  SDL_SCANCODE_OPER = 161;
+  SDL_SCANCODE_CLEARAGAIN = 162;
+  SDL_SCANCODE_CRSEL = 163;
+  SDL_SCANCODE_EXSEL = 164;
+
+  SDL_SCANCODE_KP_00 = 176;
+  SDL_SCANCODE_KP_000 = 177;
+  SDL_SCANCODE_THOUSANDSSEPARATOR = 178;
+  SDL_SCANCODE_DECIMALSEPARATOR = 179;
+  SDL_SCANCODE_CURRENCYUNIT = 180;
+  SDL_SCANCODE_CURRENCYSUBUNIT = 181;
+  SDL_SCANCODE_KP_LEFTPAREN = 182;
+  SDL_SCANCODE_KP_RIGHTPAREN = 183;
+  SDL_SCANCODE_KP_LEFTBRACE = 184;
+  SDL_SCANCODE_KP_RIGHTBRACE = 185;
+  SDL_SCANCODE_KP_TAB = 186;
+  SDL_SCANCODE_KP_BACKSPACE = 187;
+  SDL_SCANCODE_KP_A = 188;
+  SDL_SCANCODE_KP_B = 189;
+  SDL_SCANCODE_KP_C = 190;
+  SDL_SCANCODE_KP_D = 191;
+  SDL_SCANCODE_KP_E = 192;
+  SDL_SCANCODE_KP_F = 193;
+  SDL_SCANCODE_KP_XOR = 194;
+  SDL_SCANCODE_KP_POWER = 195;
+  SDL_SCANCODE_KP_PERCENT = 196;
+  SDL_SCANCODE_KP_LESS = 197;
+  SDL_SCANCODE_KP_GREATER = 198;
+  SDL_SCANCODE_KP_AMPERSAND = 199;
+  SDL_SCANCODE_KP_DBLAMPERSAND = 200;
+  SDL_SCANCODE_KP_VERTICALBAR = 201;
+  SDL_SCANCODE_KP_DBLVERTICALBAR = 202;
+  SDL_SCANCODE_KP_COLON = 203;
+  SDL_SCANCODE_KP_HASH = 204;
+  SDL_SCANCODE_KP_SPACE = 205;
+  SDL_SCANCODE_KP_AT = 206;
+  SDL_SCANCODE_KP_EXCLAM = 207;
+  SDL_SCANCODE_KP_MEMSTORE = 208;
+  SDL_SCANCODE_KP_MEMRECALL = 209;
+  SDL_SCANCODE_KP_MEMCLEAR = 210;
+  SDL_SCANCODE_KP_MEMADD = 211;
+  SDL_SCANCODE_KP_MEMSUBTRACT = 212;
+  SDL_SCANCODE_KP_MEMMULTIPLY = 213;
+  SDL_SCANCODE_KP_MEMDIVIDE = 214;
+  SDL_SCANCODE_KP_PLUSMINUS = 215;
+  SDL_SCANCODE_KP_CLEAR = 216;
+  SDL_SCANCODE_KP_CLEARENTRY = 217;
+  SDL_SCANCODE_KP_BINARY = 218;
+  SDL_SCANCODE_KP_OCTAL = 219;
+  SDL_SCANCODE_KP_DECIMAL = 220;
+  SDL_SCANCODE_KP_HEXADECIMAL = 221;
+
+  SDL_SCANCODE_LCTRL = 224;
+  SDL_SCANCODE_LSHIFT = 225;
+  SDL_SCANCODE_LALT = 226; {**< alt; option *}
+  SDL_SCANCODE_LGUI = 227; {**< windows; command (apple); meta *}
+  SDL_SCANCODE_RCTRL = 228;
+  SDL_SCANCODE_RSHIFT = 229;
+  SDL_SCANCODE_RALT = 230; {**< alt gr; option *}
+  SDL_SCANCODE_RGUI = 231; {**< windows; command (apple); meta *}
+
+  SDL_SCANCODE_MODE = 257;    {**< I'm not sure if this is really not covered 
+                               *   by any of the above; but since there's a 
+                               *   special KMOD_MODE for it I'm adding it here
+                               *}
+    
+  {*Usage page $07*}
+
+  {**
+   *  Usage page $0C
+   *
+   *  These values are mapped from usage page $0C (USB consumer page).
+   *}
+
+  SDL_SCANCODE_AUDIONEXT = 258;
+  SDL_SCANCODE_AUDIOPREV = 259;
+  SDL_SCANCODE_AUDIOSTOP = 260;
+  SDL_SCANCODE_AUDIOPLAY = 261;
+  SDL_SCANCODE_AUDIOMUTE = 262;
+  SDL_SCANCODE_MEDIASELECT = 263;
+  SDL_SCANCODE_WWW = 264;
+  SDL_SCANCODE_MAIL = 265;
+  SDL_SCANCODE_CALCULATOR = 266;
+  SDL_SCANCODE_COMPUTER = 267;
+  SDL_SCANCODE_AC_SEARCH = 268;
+  SDL_SCANCODE_AC_HOME = 269;
+  SDL_SCANCODE_AC_BACK = 270;
+  SDL_SCANCODE_AC_FORWARD = 271;
+  SDL_SCANCODE_AC_STOP = 272;
+  SDL_SCANCODE_AC_REFRESH = 273;
+  SDL_SCANCODE_AC_BOOKMARKS = 274;
+
+  {*Usage page $0C*}
+
+  {**
+   *  Walther keys
+   *
+   *  These are values that Christian Walther added (for mac keyboard?).
+   *}
+
+  SDL_SCANCODE_BRIGHTNESSDOWN = 275;
+  SDL_SCANCODE_BRIGHTNESSUP = 276;
+  SDL_SCANCODE_DISPLAYSWITCH = 277; {**< display mirroring/dual display
+                                         switch; video mode switch *}
+  SDL_SCANCODE_KBDILLUMTOGGLE = 278;
+  SDL_SCANCODE_KBDILLUMDOWN = 279;
+  SDL_SCANCODE_KBDILLUMUP = 280;
+  SDL_SCANCODE_EJECT = 281;
+  SDL_SCANCODE_SLEEP = 282;
+
+  SDL_SCANCODE_APP1 = 283;
+  SDL_SCANCODE_APP2 = 284;
+
+  {*Walther keys*}
+
+  {* Add any other keys here. *}
+
+  SDL_NUM_SCANCODES = 512; {**< not a key, just marks the number of scancodes
+                               for array bounds *}
+
+type
+  PSDL_ScanCode = ^TSDL_ScanCode;
+  TSDL_ScanCode = DWord;
+
+  //from "sdl_keycode.h"
+
+  {**
+   *  The SDL virtual key representation.
+   *
+   *  Values of this type are used to represent keyboard keys using the current
+   *  layout of the keyboard.  These values include Unicode values representing
+   *  the unmodified character that would be generated by pressing the key, or
+   *  an SDLK_* constant for those keys that do not generate characters.
+   *}
+  PSDL_KeyCode = ^TSDL_KeyCode;
+  TSDL_KeyCode = SInt32;
+
+const
+  SDLK_SCANCODE_MASK = 1 shl 30;
+
+  SDLK_UNKNOWN = 0;
+
+  SDLK_RETURN = SInt32(#13);   // C: '\r'
+  SDLK_ESCAPE = SInt32(#27);   // C: '\033'
+  SDLK_BACKSPACE = SInt32(#8); // C: '\b'
+  SDLK_TAB = SInt32(#9);       // C: '\t'
+  SDLK_SPACE = SInt32(' ');
+  SDLK_EXCLAIM = SInt32('!');
+  SDLK_QUOTEDBL = SInt32('"');
+  SDLK_HASH = SInt32('#');
+  SDLK_PERCENT = SInt32('%');
+  SDLK_DOLLAR = SInt32('$');
+  SDLK_AMPERSAND = SInt32('&');
+  SDLK_QUOTE = SInt32('\');
+  SDLK_LEFTPAREN = SInt32('(');
+  SDLK_RIGHTPAREN = SInt32(')');
+  SDLK_ASTERISK = SInt32('*');
+  SDLK_PLUS = SInt32('+');
+  SDLK_COMMA = SInt32(',');
+  SDLK_MINUS = SInt32('-');
+  SDLK_PERIOD = SInt32('.');
+  SDLK_SLASH = SInt32('/');
+  SDLK_0 = SInt32('0');
+  SDLK_1 = SInt32('1');
+  SDLK_2 = SInt32('2');
+  SDLK_3 = SInt32('3');
+  SDLK_4 = SInt32('4');
+  SDLK_5 = SInt32('5');
+  SDLK_6 = SInt32('6');
+  SDLK_7 = SInt32('7');
+  SDLK_8 = SInt32('8');
+  SDLK_9 = SInt32('9');
+  SDLK_COLON = SInt32(':');
+  SDLK_SEMICOLON = SInt32(';');
+  SDLK_LESS = SInt32('<');
+  SDLK_EQUALS = SInt32('=');
+  SDLK_GREATER = SInt32('>');
+  SDLK_QUESTION = SInt32('?');
+  SDLK_AT = SInt32('@');
+  {*
+     Skip uppercase letters
+   *}
+  SDLK_LEFTBRACKET = SInt32('[');
+  SDLK_BACKSLASH = SInt32('\');
+  SDLK_RIGHTBRACKET = SInt32(']');
+  SDLK_CARET = SInt32('^');
+  SDLK_UNDERSCORE = SInt32('_');
+  SDLK_BACKQUOTE = SInt32('`');
+  SDLK_a = SInt32('a');
+  SDLK_b = SInt32('b');
+  SDLK_c = SInt32('c');
+  SDLK_d = SInt32('d');
+  SDLK_e = SInt32('e');
+  SDLK_f = SInt32('f');
+  SDLK_g = SInt32('g');
+  SDLK_h = SInt32('h');
+  SDLK_i = SInt32('i');
+  SDLK_j = SInt32('j');
+  SDLK_k = SInt32('k');
+  SDLK_l = SInt32('l');
+  SDLK_m = SInt32('m');
+  SDLK_n = SInt32('n');
+  SDLK_o = SInt32('o');
+  SDLK_p = SInt32('p');
+  SDLK_q = SInt32('q');
+  SDLK_r = SInt32('r');
+  SDLK_s = SInt32('s');
+  SDLK_t = SInt32('t');
+  SDLK_u = SInt32('u');
+  SDLK_v = SInt32('v');
+  SDLK_w = SInt32('w');
+  SDLK_x = SInt32('x');
+  SDLK_y = SInt32('y');
+  SDLK_z = SInt32('z');
+
+  SDLK_CAPSLOCK = SDL_SCANCODE_CAPSLOCK or SDLK_SCANCODE_MASK;
+
+  SDLK_F1 = SDL_SCANCODE_F1 or SDLK_SCANCODE_MASK;
+  SDLK_F2 = SDL_SCANCODE_F2 or SDLK_SCANCODE_MASK;
+  SDLK_F3 = SDL_SCANCODE_F3 or SDLK_SCANCODE_MASK;
+  SDLK_F4 = SDL_SCANCODE_F4 or SDLK_SCANCODE_MASK;
+  SDLK_F5 = SDL_SCANCODE_F5 or SDLK_SCANCODE_MASK;
+  SDLK_F6 = SDL_SCANCODE_F6 or SDLK_SCANCODE_MASK;
+  SDLK_F7 = SDL_SCANCODE_F7 or SDLK_SCANCODE_MASK;
+  SDLK_F8 = SDL_SCANCODE_F8 or SDLK_SCANCODE_MASK;
+  SDLK_F9 = SDL_SCANCODE_F9 or SDLK_SCANCODE_MASK;
+  SDLK_F10 = SDL_SCANCODE_F10 or SDLK_SCANCODE_MASK;
+  SDLK_F11 = SDL_SCANCODE_F11 or SDLK_SCANCODE_MASK;
+  SDLK_F12 = SDL_SCANCODE_F12 or SDLK_SCANCODE_MASK;
+
+  SDLK_PRINTSCREEN = SDL_SCANCODE_PRINTSCREEN or SDLK_SCANCODE_MASK;
+  SDLK_SCROLLLOCK = SDL_SCANCODE_SCROLLLOCK or SDLK_SCANCODE_MASK;
+  SDLK_PAUSE = SDL_SCANCODE_PAUSE or SDLK_SCANCODE_MASK;
+  SDLK_INSERT = SDL_SCANCODE_INSERT or SDLK_SCANCODE_MASK;
+  SDLK_HOME = SDL_SCANCODE_HOME or SDLK_SCANCODE_MASK;
+  SDLK_PAGEUP = SDL_SCANCODE_PAGEUP or SDLK_SCANCODE_MASK;
+  SDLK_DELETE = SInt32(#127); // C: '\177'
+  SDLK_END = SDL_SCANCODE_END or SDLK_SCANCODE_MASK;
+  SDLK_PAGEDOWN = SDL_SCANCODE_PAGEDOWN or SDLK_SCANCODE_MASK;
+  SDLK_RIGHT = SDL_SCANCODE_RIGHT or SDLK_SCANCODE_MASK;
+  SDLK_LEFT = SDL_SCANCODE_LEFT or SDLK_SCANCODE_MASK;
+  SDLK_DOWN = SDL_SCANCODE_DOWN or SDLK_SCANCODE_MASK;
+  SDLK_UP = SDL_SCANCODE_UP or SDLK_SCANCODE_MASK;
+
+  SDLK_NUMLOCKCLEAR = SDL_SCANCODE_NUMLOCKCLEAR or SDLK_SCANCODE_MASK;
+  SDLK_KP_DIVIDE = SDL_SCANCODE_KP_DIVIDE or SDLK_SCANCODE_MASK;
+  SDLK_KP_MULTIPLY = SDL_SCANCODE_KP_MULTIPLY or SDLK_SCANCODE_MASK;
+  SDLK_KP_MINUS = SDL_SCANCODE_KP_MINUS or SDLK_SCANCODE_MASK;
+  SDLK_KP_PLUS = SDL_SCANCODE_KP_PLUS or SDLK_SCANCODE_MASK;
+  SDLK_KP_ENTER = SDL_SCANCODE_KP_ENTER or SDLK_SCANCODE_MASK;
+  SDLK_KP_1 = SDL_SCANCODE_KP_1 or SDLK_SCANCODE_MASK;
+  SDLK_KP_2 = SDL_SCANCODE_KP_2 or SDLK_SCANCODE_MASK;
+  SDLK_KP_3 = SDL_SCANCODE_KP_3 or SDLK_SCANCODE_MASK;
+  SDLK_KP_4 = SDL_SCANCODE_KP_4 or SDLK_SCANCODE_MASK;
+  SDLK_KP_5 = SDL_SCANCODE_KP_5 or SDLK_SCANCODE_MASK;
+  SDLK_KP_6 = SDL_SCANCODE_KP_6 or SDLK_SCANCODE_MASK;
+  SDLK_KP_7 = SDL_SCANCODE_KP_7 or SDLK_SCANCODE_MASK;
+  SDLK_KP_8 = SDL_SCANCODE_KP_8 or SDLK_SCANCODE_MASK;
+  SDLK_KP_9 = SDL_SCANCODE_KP_9 or SDLK_SCANCODE_MASK;
+  SDLK_KP_0 = SDL_SCANCODE_KP_0 or SDLK_SCANCODE_MASK;
+  SDLK_KP_PERIOD = SDL_SCANCODE_KP_PERIOD or SDLK_SCANCODE_MASK;
+
+  SDLK_APPLICATION = SDL_SCANCODE_APPLICATION or SDLK_SCANCODE_MASK;
+  SDLK_POWER = SDL_SCANCODE_POWER or SDLK_SCANCODE_MASK;
+  SDLK_KP_EQUALS = SDL_SCANCODE_KP_EQUALS or SDLK_SCANCODE_MASK;
+  SDLK_F13 = SDL_SCANCODE_F13 or SDLK_SCANCODE_MASK;
+  SDLK_F14 = SDL_SCANCODE_F14 or SDLK_SCANCODE_MASK;
+  SDLK_F15 = SDL_SCANCODE_F15 or SDLK_SCANCODE_MASK;
+  SDLK_F16 = SDL_SCANCODE_F16 or SDLK_SCANCODE_MASK;
+  SDLK_F17 = SDL_SCANCODE_F17 or SDLK_SCANCODE_MASK;
+  SDLK_F18 = SDL_SCANCODE_F18 or SDLK_SCANCODE_MASK;
+  SDLK_F19 = SDL_SCANCODE_F19 or SDLK_SCANCODE_MASK;
+  SDLK_F20 = SDL_SCANCODE_F20 or SDLK_SCANCODE_MASK;
+  SDLK_F21 = SDL_SCANCODE_F21 or SDLK_SCANCODE_MASK;
+  SDLK_F22 = SDL_SCANCODE_F22 or SDLK_SCANCODE_MASK;
+  SDLK_F23 = SDL_SCANCODE_F23 or SDLK_SCANCODE_MASK;
+  SDLK_F24 = SDL_SCANCODE_F24 or SDLK_SCANCODE_MASK;
+  SDLK_EXECUTE = SDL_SCANCODE_EXECUTE or SDLK_SCANCODE_MASK;
+  SDLK_HELP = SDL_SCANCODE_HELP or SDLK_SCANCODE_MASK;
+  SDLK_MENU = SDL_SCANCODE_MENU or SDLK_SCANCODE_MASK;
+  SDLK_SELECT = SDL_SCANCODE_SELECT or SDLK_SCANCODE_MASK;
+  SDLK_STOP = SDL_SCANCODE_STOP or SDLK_SCANCODE_MASK;
+  SDLK_AGAIN = SDL_SCANCODE_AGAIN or SDLK_SCANCODE_MASK;
+  SDLK_UNDO = SDL_SCANCODE_UNDO or SDLK_SCANCODE_MASK;
+  SDLK_CUT = SDL_SCANCODE_CUT or SDLK_SCANCODE_MASK;
+  SDLK_COPY = SDL_SCANCODE_COPY or SDLK_SCANCODE_MASK;
+  SDLK_PASTE = SDL_SCANCODE_PASTE or SDLK_SCANCODE_MASK;
+  SDLK_FIND = SDL_SCANCODE_FIND or SDLK_SCANCODE_MASK;
+  SDLK_MUTE = SDL_SCANCODE_MUTE or SDLK_SCANCODE_MASK;
+  SDLK_VOLUMEUP = SDL_SCANCODE_VOLUMEUP or SDLK_SCANCODE_MASK;
+  SDLK_VOLUMEDOWN = SDL_SCANCODE_VOLUMEDOWN or SDLK_SCANCODE_MASK;
+  SDLK_KP_COMMA = SDL_SCANCODE_KP_COMMA or SDLK_SCANCODE_MASK;
+  SDLK_KP_EQUALSAS400 = SDL_SCANCODE_KP_EQUALSAS400 or SDLK_SCANCODE_MASK;
+
+  SDLK_ALTERASE = SDL_SCANCODE_ALTERASE or SDLK_SCANCODE_MASK;
+  SDLK_SYSREQ = SDL_SCANCODE_SYSREQ or SDLK_SCANCODE_MASK;
+  SDLK_CANCEL = SDL_SCANCODE_CANCEL or SDLK_SCANCODE_MASK;
+  SDLK_CLEAR = SDL_SCANCODE_CLEAR or SDLK_SCANCODE_MASK;
+  SDLK_PRIOR = SDL_SCANCODE_PRIOR or SDLK_SCANCODE_MASK;
+  SDLK_RETURN2 = SDL_SCANCODE_RETURN2 or SDLK_SCANCODE_MASK;
+  SDLK_SEPARATOR = SDL_SCANCODE_SEPARATOR or SDLK_SCANCODE_MASK;
+  SDLK_OUT = SDL_SCANCODE_OUT or SDLK_SCANCODE_MASK;
+  SDLK_OPER = SDL_SCANCODE_OPER or SDLK_SCANCODE_MASK;
+  SDLK_CLEARAGAIN = SDL_SCANCODE_CLEARAGAIN or SDLK_SCANCODE_MASK;
+  SDLK_CRSEL = SDL_SCANCODE_CRSEL or SDLK_SCANCODE_MASK;
+  SDLK_EXSEL = SDL_SCANCODE_EXSEL or SDLK_SCANCODE_MASK;
+
+  SDLK_KP_00 = SDL_SCANCODE_KP_00 or SDLK_SCANCODE_MASK;
+  SDLK_KP_000 = SDL_SCANCODE_KP_000 or SDLK_SCANCODE_MASK;
+  SDLK_THOUSANDSSEPARATOR = SDL_SCANCODE_THOUSANDSSEPARATOR or SDLK_SCANCODE_MASK;
+  SDLK_DECIMALSEPARATOR = SDL_SCANCODE_DECIMALSEPARATOR or SDLK_SCANCODE_MASK;
+  SDLK_CURRENCYUNIT = SDL_SCANCODE_CURRENCYUNIT or SDLK_SCANCODE_MASK;
+  SDLK_CURRENCYSUBUNIT = SDL_SCANCODE_CURRENCYSUBUNIT or SDLK_SCANCODE_MASK;
+  SDLK_KP_LEFTPAREN = SDL_SCANCODE_KP_LEFTPAREN or SDLK_SCANCODE_MASK;
+  SDLK_KP_RIGHTPAREN = SDL_SCANCODE_KP_RIGHTPAREN or SDLK_SCANCODE_MASK;
+  SDLK_KP_LEFTBRACE = SDL_SCANCODE_KP_LEFTBRACE or SDLK_SCANCODE_MASK;
+  SDLK_KP_RIGHTBRACE = SDL_SCANCODE_KP_RIGHTBRACE or SDLK_SCANCODE_MASK;
+  SDLK_KP_TAB = SDL_SCANCODE_KP_TAB or SDLK_SCANCODE_MASK;
+  SDLK_KP_BACKSPACE = SDL_SCANCODE_KP_BACKSPACE or SDLK_SCANCODE_MASK;
+  SDLK_KP_A = SDL_SCANCODE_KP_A or SDLK_SCANCODE_MASK;
+  SDLK_KP_B = SDL_SCANCODE_KP_B or SDLK_SCANCODE_MASK;
+  SDLK_KP_C = SDL_SCANCODE_KP_C or SDLK_SCANCODE_MASK;
+  SDLK_KP_D = SDL_SCANCODE_KP_D or SDLK_SCANCODE_MASK;
+  SDLK_KP_E = SDL_SCANCODE_KP_E or SDLK_SCANCODE_MASK;
+  SDLK_KP_F = SDL_SCANCODE_KP_F or SDLK_SCANCODE_MASK;
+  SDLK_KP_XOR = SDL_SCANCODE_KP_XOR or SDLK_SCANCODE_MASK;
+  SDLK_KP_POWER = SDL_SCANCODE_KP_POWER or SDLK_SCANCODE_MASK;
+  SDLK_KP_PERCENT = SDL_SCANCODE_KP_PERCENT or SDLK_SCANCODE_MASK;
+  SDLK_KP_LESS = SDL_SCANCODE_KP_LESS or SDLK_SCANCODE_MASK;
+  SDLK_KP_GREATER = SDL_SCANCODE_KP_GREATER or SDLK_SCANCODE_MASK;
+  SDLK_KP_AMPERSAND = SDL_SCANCODE_KP_AMPERSAND or SDLK_SCANCODE_MASK;
+  SDLK_KP_DBLAMPERSAND = SDL_SCANCODE_KP_DBLAMPERSAND or SDLK_SCANCODE_MASK;
+  SDLK_KP_VERTICALBAR = SDL_SCANCODE_KP_VERTICALBAR or SDLK_SCANCODE_MASK;
+  SDLK_KP_DBLVERTICALBAR = SDL_SCANCODE_KP_DBLVERTICALBAR or SDLK_SCANCODE_MASK;
+  SDLK_KP_COLON = SDL_SCANCODE_KP_COLON or SDLK_SCANCODE_MASK;
+  SDLK_KP_HASH = SDL_SCANCODE_KP_HASH or SDLK_SCANCODE_MASK;
+  SDLK_KP_SPACE = SDL_SCANCODE_KP_SPACE or SDLK_SCANCODE_MASK;
+  SDLK_KP_AT = SDL_SCANCODE_KP_AT or SDLK_SCANCODE_MASK;
+  SDLK_KP_EXCLAM = SDL_SCANCODE_KP_EXCLAM or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMSTORE = SDL_SCANCODE_KP_MEMSTORE or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMRECALL = SDL_SCANCODE_KP_MEMRECALL or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMCLEAR = SDL_SCANCODE_KP_MEMCLEAR or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMADD = SDL_SCANCODE_KP_MEMADD or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMSUBTRACT = SDL_SCANCODE_KP_MEMSUBTRACT or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMMULTIPLY = SDL_SCANCODE_KP_MEMMULTIPLY or SDLK_SCANCODE_MASK;
+  SDLK_KP_MEMDIVIDE = SDL_SCANCODE_KP_MEMDIVIDE or SDLK_SCANCODE_MASK;
+  SDLK_KP_PLUSMINUS = SDL_SCANCODE_KP_PLUSMINUS or SDLK_SCANCODE_MASK;
+  SDLK_KP_CLEAR = SDL_SCANCODE_KP_CLEAR or SDLK_SCANCODE_MASK;
+  SDLK_KP_CLEARENTRY = SDL_SCANCODE_KP_CLEARENTRY or SDLK_SCANCODE_MASK;
+  SDLK_KP_BINARY = SDL_SCANCODE_KP_BINARY or SDLK_SCANCODE_MASK;
+  SDLK_KP_OCTAL = SDL_SCANCODE_KP_OCTAL or SDLK_SCANCODE_MASK;
+  SDLK_KP_DECIMAL = SDL_SCANCODE_KP_DECIMAL or SDLK_SCANCODE_MASK;
+  SDLK_KP_HEXADECIMAL = SDL_SCANCODE_KP_HEXADECIMAL or SDLK_SCANCODE_MASK;
+
+  SDLK_LCTRL = SDL_SCANCODE_LCTRL or SDLK_SCANCODE_MASK;
+  SDLK_LSHIFT = SDL_SCANCODE_LSHIFT or SDLK_SCANCODE_MASK;
+  SDLK_LALT = SDL_SCANCODE_LALT or SDLK_SCANCODE_MASK;
+  SDLK_LGUI = SDL_SCANCODE_LGUI or SDLK_SCANCODE_MASK;
+  SDLK_RCTRL = SDL_SCANCODE_RCTRL or SDLK_SCANCODE_MASK;
+  SDLK_RSHIFT = SDL_SCANCODE_RSHIFT or SDLK_SCANCODE_MASK;
+  SDLK_RALT = SDL_SCANCODE_RALT or SDLK_SCANCODE_MASK;
+  SDLK_RGUI = SDL_SCANCODE_RGUI or SDLK_SCANCODE_MASK;
+
+  SDLK_MODE = SDL_SCANCODE_MODE or SDLK_SCANCODE_MASK;
+
+  SDLK_AUDIONEXT = SDL_SCANCODE_AUDIONEXT or SDLK_SCANCODE_MASK;
+  SDLK_AUDIOPREV = SDL_SCANCODE_AUDIOPREV or SDLK_SCANCODE_MASK;
+  SDLK_AUDIOSTOP = SDL_SCANCODE_AUDIOSTOP or SDLK_SCANCODE_MASK;
+  SDLK_AUDIOPLAY = SDL_SCANCODE_AUDIOPLAY or SDLK_SCANCODE_MASK;
+  SDLK_AUDIOMUTE = SDL_SCANCODE_AUDIOMUTE or SDLK_SCANCODE_MASK;
+  SDLK_MEDIASELECT = SDL_SCANCODE_MEDIASELECT or SDLK_SCANCODE_MASK;
+  SDLK_WWW = SDL_SCANCODE_WWW or SDLK_SCANCODE_MASK;
+  SDLK_MAIL = SDL_SCANCODE_MAIL or SDLK_SCANCODE_MASK;
+  SDLK_CALCULATOR = SDL_SCANCODE_CALCULATOR or SDLK_SCANCODE_MASK;
+  SDLK_COMPUTER = SDL_SCANCODE_COMPUTER or SDLK_SCANCODE_MASK;
+  SDLK_AC_SEARCH = SDL_SCANCODE_AC_SEARCH or SDLK_SCANCODE_MASK;
+  SDLK_AC_HOME = SDL_SCANCODE_AC_HOME or SDLK_SCANCODE_MASK;
+  SDLK_AC_BACK = SDL_SCANCODE_AC_BACK or SDLK_SCANCODE_MASK;
+  SDLK_AC_FORWARD = SDL_SCANCODE_AC_FORWARD or SDLK_SCANCODE_MASK;
+  SDLK_AC_STOP = SDL_SCANCODE_AC_STOP or SDLK_SCANCODE_MASK;
+  SDLK_AC_REFRESH = SDL_SCANCODE_AC_REFRESH or SDLK_SCANCODE_MASK;
+  SDLK_AC_BOOKMARKS = SDL_SCANCODE_AC_BOOKMARKS or SDLK_SCANCODE_MASK;
+
+  SDLK_BRIGHTNESSDOWN = SDL_SCANCODE_BRIGHTNESSDOWN or SDLK_SCANCODE_MASK;
+  SDLK_BRIGHTNESSUP = SDL_SCANCODE_BRIGHTNESSUP or SDLK_SCANCODE_MASK;
+  SDLK_DISPLAYSWITCH = SDL_SCANCODE_DISPLAYSWITCH or SDLK_SCANCODE_MASK;
+  SDLK_KBDILLUMTOGGLE = SDL_SCANCODE_KBDILLUMTOGGLE or SDLK_SCANCODE_MASK;
+  SDLK_KBDILLUMDOWN = SDL_SCANCODE_KBDILLUMDOWN or SDLK_SCANCODE_MASK;
+  SDLK_KBDILLUMUP = SDL_SCANCODE_KBDILLUMUP or SDLK_SCANCODE_MASK;
+  SDLK_EJECT = SDL_SCANCODE_EJECT or SDLK_SCANCODE_MASK;
+  SDLK_SLEEP = SDL_SCANCODE_SLEEP or SDLK_SCANCODE_MASK;
+
+  {**
+   *  Enumeration of valid key mods (possibly OR'd together).
+   *}
+
+  KMOD_NONE = $0000;
+  KMOD_LSHIFT = $0001;
+  KMOD_RSHIFT = $0002;
+  KMOD_LCTRL = $0040;
+  KMOD_RCTRL = $0080;
+  KMOD_LALT = $0100;
+  KMOD_RALT = $0200;
+  KMOD_LGUI = $0400;
+  KMOD_RGUI = $0800;
+  KMOD_NUM = $1000;
+  KMOD_CAPS = $2000;
+  KMOD_MODE = $4000;
+  KMOD_RESERVED = $8000;
+
+type
+  PSDL_KeyMod = ^TSDL_KeyMod;
+  TSDL_KeyMod = Word;
+
+const
+  KMOD_CTRL  = KMOD_LCTRL  or KMOD_RCTRL;
+  KMOD_SHIFT = KMOD_LSHIFT or KMOD_RSHIFT;
+  KMOD_ALT   = KMOD_LALT   or KMOD_RALT;
+  KMOD_GUI   = KMOD_LGUI   or KMOD_RGUI;

model_viewer/sdl2/sdlshape.inc

@@ -0,0 +1,43 @@
+//from "sdl_shape.h"
+
+{**  SDL_shape.h
+ *
+ * Header file for the shaped window API.
+ *}
+const
+  SDL_NONSHAPEABLE_WINDOW = -1;
+  SDL_INVALID_SHAPE_ARGUMENT = -2;
+  SDL_WINDOW_LACKS_SHAPE = -3;
+
+type
+  PPSDL_Window = ^PSDL_Window;
+  PSDL_Window = ^TSDL_Window;
+
+  {** An enum denoting the specific type of contents present in an SDL_WindowShapeParams union. *}
+  TWindowShapeMode = ({** The default mode, a binarized alpha cutoff of 1. *}
+                      ShapeModeDefault,
+                      {** A binarized alpha cutoff with a given integer value. *}
+                      ShapeModeBinarizeAlpha,
+                      {** A binarized alpha cutoff with a given integer value, but with the opposite comparison. *}
+                      ShapeModeReverseBinarizeAlpha,
+                      {** A color key is applied. *}
+                      ShapeModeColorKey);
+
+//#define SDL_SHAPEMODEALPHA(mode) (mode == ShapeModeDefault || mode == ShapeModeBinarizeAlpha || mode == ShapeModeReverseBinarizeAlpha)
+
+  {** A union containing parameters for shaped windows. *}
+  TSDL_WindowShapeParams = record
+    case Integer of
+      {** a cutoff alpha value for binarization of the window shape's alpha channel. *}
+      0: (binarizationCutoff: UInt8;);
+      1: (colorKey: TSDL_Color;);
+  end;
+
+  {** A struct that tags the SDL_WindowShapeParams union with an enum describing the type of its contents. *}
+  PSDL_WindowShapeMode = ^TSDL_WindowShapeMode;
+  TSDL_WindowShapeMode = record
+    {** The mode of these window-shape parameters. *}
+    mode: TWindowShapeMode;
+    {** Window-shape parameters. *}
+    parameters: TSDL_WindowShapeParams;
+  end;

model_viewer/sdl2/sdlsurface.inc

@@ -0,0 +1,441 @@
+//from "sdl_surface.h"
+
+const
+  {**
+   *  Surface flags
+   *
+   *  These are the currently supported flags for the ::SDL_surface.
+   *
+   *  Used internally (read-only).
+   *}
+
+  SDL_SWSURFACE = 0;          {**< Just here for compatibility *}
+  SDL_PREALLOC  = $00000001;  {**< Surface uses preallocated memory *}
+  SDL_RLEACCEL  = $00000002;  {**< Surface is RLE encoded *}
+  SDL_DONTFREE  = $00000004;  {**< Surface is referenced internally *}
+
+type
+  {**
+   *  A collection of pixels used in software blitting.
+   *
+   *  This structure should be treated as read-only, except for \c pixels,
+   *  which, if not NULL, contains the raw pixel data for the surface.
+   *}
+
+  PSDL_BlitMap = ^TSDL_BlitMap;
+  TSDL_BlitMap = record
+    map: Pointer;
+  end;
+
+  PSDL_Surface = ^TSDL_Surface;
+  TSDL_Surface = record
+    flags: UInt32;              {**< Read-only *}
+    format: PSDL_PixelFormat;   {**< Read-only *}
+    w, h: SInt32;               {**< Read-only *}
+    pitch: SInt32;              {**< Read-only *}
+    pixels: Pointer;            {**< Read-write *}
+
+    {** Application data associated with the surface *}
+    userdata: Pointer;          {**< Read-write *}
+
+    {** information needed for surfaces requiring locks *}
+    locked: SInt32;             {**< Read-only *}
+    lock_data: Pointer;         {**< Read-only *}
+
+    {** clipping information *}
+    clip_rect: PSDL_Rect;       {**< Read-only *}
+
+    {** info for fast blit mapping to other surfaces *}
+    map: Pointer;               {**< Private *} //SDL_BlitMap
+
+    {** Reference count -- used when freeing surface *}
+    refcount: SInt32;           {**< Read-mostly *}
+  end;
+
+  {**
+   *  The type of function used for surface blitting functions.
+   *}
+
+   TSDL_Blit = function(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32;
+
+// Evaluates to true if the surface needs to be locked before access.
+function SDL_MUSTLOCK(Const S:PSDL_Surface):Boolean;
+
+  {**
+   *  Allocate and free an RGB surface.
+   *
+   *  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
+   *  If the depth is greater than 8 bits, the pixel format is set using the
+   *  flags '[RGB]mask'.
+   *
+   *  If the function runs out of memory, it will return NULL.
+   *
+   *  flags The flags are obsolete and should be set to 0.
+   *}
+
+function SDL_CreateRGBSurface(flags: UInt32; width: SInt32; height: SInt32; depth: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurface' {$ENDIF} {$ENDIF};
+function SDL_CreateRGBSurfaceWithFormat(flags: Uint32; width, height, depth: sInt32; format: Uint32):PSDL_Surface; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurfaceWithFormat' {$ENDIF} {$ENDIF};
+function SDL_CreateRGBSurfaceFrom(pixels: Pointer; width: SInt32; height: SInt32; depth: SInt32; pitch: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurfaceFrom' {$ENDIF} {$ENDIF};
+function SDL_CreateRGBSurfaceWithFormatFrom(pixels: Pointer; width, height, depth, pitch: sInt32; format: Uint32):PSDL_Surface; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurfaceWithFormatFrom' {$ENDIF} {$ENDIF};
+procedure SDL_FreeSurface(surface: PSDL_Surface) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeSurface' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the palette used by a surface.
+   *
+   *  0, or -1 if the surface format doesn't use a palette.
+   *
+   *  A single palette can be shared with many surfaces.
+   *}
+
+function SDL_SetSurfacePalette(surface: PSDL_Surface; palette: PSDL_Palette): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfacePalette' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Sets up a surface for directly accessing the pixels.
+   *
+   *  Between calls to SDL_LockSurface() / 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.
+   *
+   *  SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
+   *
+   *  SDL_UnlockSurface()
+   *}
+
+function SDL_LockSurface(surface: PSDL_Surface): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockSurface' {$ENDIF} {$ENDIF};
+
+  {** SDL_LockSurface() *}
+
+procedure SDL_UnlockSurface(surface: PSDL_Surface) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockSurface' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Load a surface from a seekable SDL data stream (memory or file).
+   *
+   *  If freesrc is non-zero, the stream will be closed after being read.
+   *
+   *  The new surface should be freed with SDL_FreeSurface().
+   *
+   *  the new surface, or NULL if there was an error.
+   *}
+
+function SDL_LoadBMP_RW(src: PSDL_RWops; freesrc: SInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadBMP_RW' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Load a surface from a file.
+   *
+   *  Convenience macro.
+   *}
+
+function SDL_LoadBMP(_file: PAnsiChar): PSDL_Surface;
+
+  {**
+   *  Save a surface to a seekable SDL data stream (memory or file).
+   *
+   *  If freedst is non-zero, the stream will be closed after being written.
+   *
+   *  0 if successful or -1 if there was an error.
+   *}
+
+function SDL_SaveBMP_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadBMP_RW' {$ENDIF} {$ENDIF};
+
+    {**
+     *  Save a surface to a file.
+     *
+     *  Convenience macro.
+     *}
+function SDL_SaveBMP(Const surface:PSDL_Surface; Const filename:AnsiString):sInt32;
+
+  {**
+   *  Sets the RLE acceleration hint for a surface.
+   *
+   *  0 on success, or -1 if the surface is not valid
+   *  
+   *  If RLE is enabled, colorkey and alpha blending blits are much faster,
+   *  but the surface must be locked before directly accessing the pixels.
+   *}
+
+function SDL_SetSurfaceRLE(surface: PSDL_Surface; flag: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceRLE' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Sets the color key (transparent pixel) in a blittable surface.
+   *
+   *  surface The surface to update
+   *  flag Non-zero to enable colorkey and 0 to disable colorkey
+   *  key The transparent pixel in the native surface format
+   *
+   *  0 on success, or -1 if the surface is not valid
+   *
+   *  You can pass SDL_RLEACCEL to enable RLE accelerated blits.
+   *}
+
+function SDL_SetColorKey(surface: PSDL_Surface; flag: SInt32; key: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetColorKey' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Gets the color key (transparent pixel) in a blittable surface.
+   *
+   *  surface The surface to update
+   *  key A pointer filled in with the transparent pixel in the native
+   *      surface format
+   *
+   *  0 on success, or -1 if the surface is not valid or colorkey is not
+   *  enabled.
+   *}
+
+function SDL_GetColorKey(surface: PSDL_Surface; key: PUInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetColorKey' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set an additional color value used in blit operations.
+   *
+   *  surface The surface to update.
+   *  r The red color value multiplied into blit operations.
+   *  g The green color value multiplied into blit operations.
+   *  b The blue color value multiplied into blit operations.
+   *
+   *  0 on success, or -1 if the surface is not valid.
+   *
+   *  SDL_GetSurfaceColorMod()
+   *}
+
+function SDL_SetSurfaceColorMod(surface: PSDL_Surface; r: UInt8; g: UInt8; b: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceColorMod' {$ENDIF} {$ENDIF};
+
+ {**
+   *  Get the additional color value used in blit operations.
+   *
+   *  surface The surface to query.
+   *  r A pointer filled in with the current red color value.
+   *  g A pointer filled in with the current green color value.
+   *  b A pointer filled in with the current blue color value.
+   *
+   *  0 on success, or -1 if the surface is not valid.
+   *
+   *  SDL_SetSurfaceColorMod()
+   *}
+
+function SDL_GetSurfaceColorMod(surface: PSDL_Surface; r: PUInt8; g: PUInt8; b: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceColorMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set an additional alpha value used in blit operations.
+   *
+   *  surface The surface to update.
+   *  alpha The alpha value multiplied into blit operations.
+   *
+   *  0 on success, or -1 if the surface is not valid.
+   *
+   *  SDL_GetSurfaceAlphaMod()
+   *}
+
+function SDL_SetSurfaceAlphaMod(surface: PSDL_Surface; alpha: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceAlphaMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the additional alpha value used in blit operations.
+   *
+   *  surface The surface to query.
+   *  alpha A pointer filled in with the current alpha value.
+   *
+   *  0 on success, or -1 if the surface is not valid.
+   *
+   *  SDL_SetSurfaceAlphaMod()
+   *}
+
+function SDL_GetSurfaceAlphaMod(surface: PSDL_Surface; alpha: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceAlphaMod' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the blend mode used for blit operations.
+   *
+   *  surface The surface to update.
+   *  blendMode ::SDL_BlendMode to use for blit blending.
+   *
+   *  0 on success, or -1 if the parameters are not valid.
+   *
+   *  SDL_GetSurfaceBlendMode()
+   *}
+
+function SDL_SetSurfaceBlendMode(surface: PSDL_Surface; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the blend mode used for blit operations.
+   *
+   *  surface   The surface to query.
+   *  blendMode A pointer filled in with the current blend mode.
+   *
+   *  0 on success, or -1 if the surface is not valid.
+   *
+   *  SDL_SetSurfaceBlendMode()
+   *}
+
+function SDL_GetSurfaceBlendMode(surface: PSDL_Surface; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceBlendMode' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Sets the clipping rectangle for the destination surface in a blit.
+   *
+   *  If the clip rectangle is NULL, clipping will be disabled.
+   *
+   *  If the clip rectangle doesn't intersect the surface, the function will
+   *  return SDL_FALSE and blits will be completely clipped.  Otherwise the
+   *  function returns SDL_TRUE and blits to the surface will be clipped to
+   *  the intersection of the surface area and the clipping rectangle.
+   *
+   *  Note that blits are automatically clipped to the edges of the source
+   *  and destination surfaces.
+   *}
+
+function SDL_SetClipRect(surface: PSDL_Surface; const rect: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetClipRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Gets the clipping rectangle for the destination surface in a blit.
+   *
+   *  rect must be a pointer to a valid rectangle which will be filled
+   *  with the correct values.
+   *}
+
+procedure SDL_GetClipRect(surface: PSDL_Surface; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetClipRect' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Creates a new surface of the specified format, and then copies and maps
+   *  the given surface to it so the blit of the converted surface will be as
+   *  fast as possible.  If this function fails, it returns NULL.
+   *
+   *  The flags parameter is passed to SDL_CreateRGBSurface() and has those
+   *  semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
+   *  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
+   *  surface.
+   *}
+
+function SDL_ConvertSurface(src: PSDL_Surface; fmt: PSDL_PixelFormat; flags: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertSurface' {$ENDIF} {$ENDIF};
+function SDL_ConvertSurfaceFormat(src: PSDL_Surface; pixel_format: UInt32; flags: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertSurfaceFormat' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Copy a block of pixels of one format to another format
+   *
+   *  0 on success, or -1 if there was an error
+   *}
+
+function SDL_ConvertPixels(width: SInt32; height: SInt32; src_format: UInt32; const src: Pointer; src_pitch: SInt32; dst_format: UInt32; dst: Pointer; dst_pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertPixels' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Performs a fast fill of the given rectangle with color.
+   *
+   *  If rect is NULL, the whole surface will be filled with color.
+   *
+   *  The color should be a pixel of the format used by the surface, and 
+   *  can be generated by the SDL_MapRGB() function.
+   *  
+   *  0 on success, or -1 on error.
+   *}
+
+function SDL_FillRect(dst: PSDL_Surface; const rect: PSDL_Rect; color: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FillRect' {$ENDIF} {$ENDIF};
+function SDL_FillRects(dst: PSDL_Surface; const rects: PSDL_Rect; count: SInt32; color: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FillRects' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Performs a fast blit from the source surface to the destination surface.
+   *
+   *  This assumes that the source and destination rectangles are
+   *  the same size.  If either \c srcrect or \c dstrect are NULL, the entire
+   *  surface ( src or  dst) is copied.  The final blit rectangles are saved
+   *  in srcrect and dstrect after all clipping is performed.
+   *
+   *  If the blit is successful, it returns 0, otherwise it returns -1.
+   *
+   *  The blit function should not be called on a locked surface.
+   *
+   *  The blit semantics for surfaces with and without alpha and colorkey
+   *  are defined as follows:
+   *
+      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 source per-surface alpha value.
+        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.r
+   *
+   *  You should call SDL_BlitSurface() unless you know exactly how SDL
+   *  blitting works internally and how to use the other blit functions.
+   *}
+
+(* SDL_surface.h uses #define to change all SDL_BlitSurface() calls into SDL_UpperBlit() calls.                         *
+ * Since Pascal macro support is very limited, we workaround by outright pointing SDL_BlitSurface() to SDL_UpperBlit(). *)
+function SDL_BlitSurface(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; 
+   external SDL_LibName name {$IF DEFINED(DELPHI) AND DEFINED(MACOS)} '_SDL_UpperBlit' {$ELSE} 'SDL_UpperBlit' {$IFEND};
+
+
+  {**
+   *  This is the public blit function, SDL_BlitSurface(), and it performs
+   *  rectangle validation and clipping before passing it to SDL_LowerBlit()
+   *}
+
+function SDL_UpperBlit(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpperBlit' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This is a semi-private blit function and it performs low-level surface
+   *  blitting only.
+   *}
+
+function SDL_LowerBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LowerBlit' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Perform a fast, low quality, stretch blit between two surfaces of the
+   *  same pixel format.
+   *
+   *  This function uses a static buffer, and is not thread-safe.
+   *}
+
+function SDL_SoftStretch(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; const dstrect: PSDL_Surface): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SoftStretch' {$ENDIF} {$ENDIF};
+
+(* SDL_surface.h uses #define to change all SDL_BlitSurfaceScaled() calls into SDL_UpperBlitScaled() calls.                         *
+ * Since Pascal macro support is very limited, we workaround by outright pointing SDL_BlitSurfaceScaled() to SDL_UpperBlitScaled(). *)
+function SDL_BlitSurfaceScaled(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; 
+   external SDL_LibName name {$IF DEFINED(DELPHI) AND DEFINED(MACOS)} '_SDL_UpperBlitScaled' {$ELSE} 'SDL_UpperBlitScaled' {$IFEND};
+
+  {**
+   *  This is the public scaled blit function, SDL_BlitScaled(), and it performs
+   *  rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
+   *}
+
+function SDL_UpperBlitScaled(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpperBlitScaled' {$ENDIF} {$ENDIF};
+
+  {**
+   *  This is a semi-private blit function and it performs low-level surface
+   *  scaled blitting only.
+   *}
+
+function SDL_LowerBlitScaled(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LowerBlitScaled' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlsystem.inc

@@ -0,0 +1,105 @@
+// from "SDL_system.h"
+
+(* Platform specific functions for Windows *)
+{$IF DEFINED(WIN32) OR DEFINED(WIN64)} 
+
+  {**
+   *  \brief Set a function that is called for every windows message, before TranslateMessage()
+   *}
+Type
+  TSDL_WindowsMessageHook = Procedure(userdata, hWnd: Pointer; mesage: UInt32; wParam: UInt64; lParam: SInt64); cdecl;
+
+Procedure SDL_SetWindowsMessageHook(callback: TSDL_WindowsMessageHook; userdata: Pointer); cdecl;
+  external SDL_LibName;
+
+  {* Returns the D3D9 adapter index that matches the specified display index.
+   * This adapter index can be passed to IDirect3D9::CreateDevice and controls
+   * on which monitor a full screen application will appear.
+   *}
+Function SDL_Direct3D9GetAdapterIndex(displayIndex:SInt32):SInt32;
+   cdecl; external SDL_LibName;
+
+  {* Returns the D3D device associated with a renderer, or NULL if it's not a D3D renderer.
+   * Once you are done using the device, you should release it to avoid a resource leak.
+   *}
+Type PIDirect3DDevice9 = Pointer;
+Function SDL_RenderGetD3D9Device(renderer:PSDL_Renderer):PIDirect3DDevice9;
+   cdecl; external SDL_LibName;
+
+{* Returns the DXGI Adapter and Output indices for the specified display index. 
+ * These can be passed to EnumAdapters and EnumOutputs respectively to get the objects
+ *  required to create a DX10 or DX11 device and swap chain.
+ *}
+function SDL_DXGIGetOutputInfo(displayIndex :SInt32; adapterIndex, outputIndex :PSInt32): TSDL_Bool;
+   cdecl; external SDL_LibName;
+
+{$IFEND}
+
+
+(* Platform specific functions for WinRT *)
+{$IFDEF __WINRT__}
+
+  {**
+   *  \brief WinRT / Windows Phone path types
+   *}
+Type
+  TSDL_WinRT_Path = (
+
+    {** \brief The installed app's root directory.
+        Files here are likely to be read-only. *}
+    SDL_WINRT_PATH_INSTALLED_LOCATION = 0,
+
+    {** \brief The app's local data store.  Files may be written here *}
+    SDL_WINRT_PATH_LOCAL_FOLDER = 1,
+
+    {** \brief The app's roaming data store.  Unsupported on Windows Phone.
+        Files written here may be copied to other machines via a network
+        connection.
+    *}
+    SDL_WINRT_PATH_ROAMING_FOLDER = 2,
+
+    {** \brief The app's temporary data store.  Unsupported on Windows Phone.
+        Files written here may be deleted at any time. *}
+    SDL_WINRT_PATH_TEMP_FOLDER = 3
+
+  );
+
+
+  {**
+   *  \brief Retrieves a WinRT defined path on the local file system
+   *
+   *  \note Documentation on most app-specific path types on WinRT
+   *      can be found on MSDN, at the URL:
+   *      http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+   *
+   *  \param pathType The type of path to retrieve.
+   *  \ret A UCS-2 string (16-bit, wide-char) containing the path, or NULL
+   *      if the path is not available for any reason.  Not all paths are
+   *      available on all versions of Windows.  This is especially true on
+   *      Windows Phone.  Check the documentation for the given
+   *      SDL_WinRT_Path for more information on which path types are
+   *      supported where.
+   *}
+Function SDL_WinRTGetFSPathUNICODE(pathType :TSDL_WinRT_Path):PWideChar;
+   cdecl; external SDL_LibName;
+
+
+  {**
+   *  \brief Retrieves a WinRT defined path on the local file system
+   *
+   *  \note Documentation on most app-specific path types on WinRT
+   *      can be found on MSDN, at the URL:
+   *      http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+   *
+   *  \param pathType The type of path to retrieve.
+   *  \ret A UTF-8 string (8-bit, multi-byte) containing the path, or NULL
+   *      if the path is not available for any reason.  Not all paths are
+   *      available on all versions of Windows.  This is especially true on
+   *      Windows Phone.  Check the documentation for the given
+   *      SDL_WinRT_Path for more information on which path types are
+   *      supported where.
+   *}
+Function SDL_WinRTGetFSPathUTF8(pathType :TSDL_WinRT_Path):PChar;
+   cdecl; external SDL_LibName;
+
+{$ENDIF}

model_viewer/sdl2/sdlsyswm.inc

@@ -0,0 +1,203 @@
+// from sdl_syswm.h
+
+{$IFDEF WINDOWS}
+   {$DEFINE SDL_VIDEO_DRIVER_WINDOWS}
+{$ENDIF}
+
+{$IF DEFINED (LINUX) OR DEFINED(UNIX)}
+   {$DEFINE SDL_VIDEO_DRIVER_X11}
+{$IFEND}
+
+{$IFDEF DARWIN}
+   {$DEFINE SDL_VIDEO_DRIVER_COCOA}
+{$ENDIF}
+
+{**
+ *  These are the various supported windowing subsystems
+ *}
+Type
+   TSDL_SYSWM_TYPE = (
+      SDL_SYSWM_UNKNOWN,
+      SDL_SYSWM_WINDOWS,
+      SDL_SYSWM_X11,
+      SDL_SYSWM_DIRECTFB,
+      SDL_SYSWM_COCOA,
+      SDL_SYSWM_UIKIT,
+      SDL_SYSWM_WAYLAND, // Since SDL 2.0.2
+      SDL_SYSWM_MIR,     // Since SDL 2.0.2
+      SDL_SYSWM_WINRT,   // Since SDL 2.0.3
+      SDL_SYSWM_ANDROID, // Since SDL 2.0.4
+      SDL_SYSWM_VIVANTE  // Since SDL 2.0.5
+   );
+
+/// sdl_syswm.h uses anonymous structs, declared right in SDL_SysWMmsg.
+/// Since Pascal does not allow this, we workaround by introducing named types
+/// before the proper TSDL_SysWMmsg definition.
+{$IFDEF SDL_VIDEO_DRIVER_WINDOWS}
+   __SYSWM_WINDOWS = record
+      hwnd:   HWND;   {**< The window for the message }
+      msg:     uInt;   {**< The type of message *}
+      wParam: WPARAM; {**< WORD message parameter *}
+      lParam: LPARAM; {**< WORD message parameter *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_X11}
+   __SYSWM_X11 = record
+      event: {$IFDEF FPC} TXEvent {$ELSE} XEvent {$ENDIF};
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_DIRECTFB}
+   __SYSWM_DIRECTFB = record
+      event: DFBEvent;
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_COCOA}
+   __SYSWM_COCOA = record
+      (* No Cocoa window events yet *)
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_UIKIT}
+   __SYSWM_UIKIT = record
+      (* No UIKit window events yet *)
+   end;
+{$ENDIF}
+
+{**
+ *  The custom event structure.
+ *}
+   PSDL_SysWMmsg = ^TSDL_SysWMmsg;
+   TSDL_SysWMmsg = record
+      version: TSDL_version;
+      Case subsystem: TSDL_SYSWM_TYPE of
+         (* Cannot have empty record case *)
+         SDL_SYSWM_UNKNOWN: (dummy: sInt32);
+         {$IFDEF SDL_VIDEO_DRIVER_WINDOWS}
+            SDL_SYSWM_WINDOWS: (win: __SYSWM_WINDOWS);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_X11}
+            SDL_SYSWM_X11: (x11: __SYSWM_X11);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_DIRECTFB}  
+            SDL_SYSWM_DIRECTFB: (dfb: __SYSWM_DIRECTFB); 
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_COCOA}  
+            SDL_SYSWM_COCOA: (cocoa: __SYSWM_COCOA);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_UIKIT}
+            SDL_SYSWM_UIKIT: (uikit: __SYSWM_UIKIT);
+         {$ENDIF}
+   end;
+
+/// Once again, sdl_syswm.h uses anonymous structs, declared right in SDL_SysWMinfo.
+/// We workaround by introducing named types before the proper TSDL_SysWMinfo definition.
+{$IFDEF SDL_VIDEO_DRIVER_WINDOWS}
+   __WMINFO_WINDOWS = record
+      window: HWND; {**< The window handle *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_WINRT} // Since SDL 2.0.3
+   __WMINFO_WINRT = record
+      window: IInspectable;      {**< The WinRT CoreWindow *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_X11}
+   __WMINFO_X11 = record
+      display: PDisplay;  {**< The X11 display *}
+      window: TWindow;     {**< The X11 window *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_DIRECTFB}
+   __WMINFO_DFB = record
+      dfb:     IDirectFB;         {**< The directfb main interface *}
+      window:  IDirectFBWindow;   {**< The directfb window handle *}
+      surface: IDirectFBSurface;  {**< The directfb client surface *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_COCOA}
+   __WMINFO_COCOA = record
+      window: NSWindow;           {* The Cocoa window *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_UIKIT}
+   __WMINFO_UIKIT = record
+      window: UIWindow;   {* The UIKit window *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_WAYLAND} // Since SDL 2.0.2
+   __WMINFO_WAYLAND = record
+      display: wl_display;             {**< Wayland display *}
+      surface: wl_surface;             {**< Wayland surface *}
+      shell_surface: wl_shell_surface; {**< Wayland shell_surface (window manager handle) *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_MIR} // Since SDL 2.0.2
+   __WMINFO_MIR = record
+      connection: PMirConnection; {**< Mir display server connection *}
+      surface: PMirSurface;       {**< Mir surface *}
+   end;
+{$ENDIF}
+{$IFDEF SDL_VIDEO_DRIVER_ANDROID} // Planned for SDL 2.0.4
+   __WMINFO_ANDROID = record
+      window : PANativeWindow;
+      surface: PEGLSurface;
+   end;
+{$ENDIF}
+
+{**
+ *  The custom window manager information structure.
+ *
+ *  When this structure is returned, it holds information about which
+ *  low level system it is using, and will be one of SDL_SYSWM_TYPE.
+ *}
+   PSDL_SysWMinfo = ^TSDL_SysWMinfo;
+   TSDL_SysWMinfo = record
+      version: TSDL_version;
+      Case subsystem: TSDL_SYSWM_TYPE of
+         (* Cannot have empty record case *)
+         SDL_SYSWM_UNKNOWN: (dummy: sInt32);
+         {$IFDEF SDL_VIDEO_DRIVER_WINDOWS}
+            SDL_SYSWM_WINDOWS: (win : __WMINFO_WINDOWS);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_WINRT}
+            SDL_SYSWM_WINRT: (winrt : __WMINFO_WINRT);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_X11}
+            SDL_SYSWM_X11: (x11 : __WMINFO_X11);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_DIRECTFB}
+            SDL_SYSWM_DIRECTFB: (dfb : __WMINFO_DFB);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_COCOA}
+            SDL_SYSWM_COCOA: (cocoa : __WMINFO_COCOA);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_UIKIT}
+            SDL_SYSWM_UIKIT: (uikit : __WMINFO_UIKIT);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_WAYLAND}
+            SDL_SYSWM_WAYLAND: (wl : __WMINFO_WAYLAND);
+         {$ENDIF}
+         {$IFDEF SDL_VIDEO_DRIVER_MIR}
+            SDL_SYSWM_MIR: (mir : __WMINFO_MIR);
+         {$ENDIF}
+   end;
+
+{* Function prototypes *}
+(**
+ *  \brief This function allows access to driver-dependent window information.
+ *
+ *  \param window The window about which information is being requested
+ *  \param info This structure must be initialized with the SDL version, and is
+ *              then filled in with information about the given window.
+ *
+ *  \return SDL_TRUE if the function is implemented and the version member of
+ *          the \c info struct is valid, SDL_FALSE otherwise.
+ *
+ *  You typically use this function like this:
+ *  \code
+ *  SDL_SysWMinfo info;
+ *  SDL_VERSION(&info.version);
+ *  if ( SDL_GetWindowWMInfo(window, &info) ) { ... }
+ *  \endcode
+ *)
+Function SDL_GetWindowWMInfo(window:PSDL_Window; info : PSDL_SysWMinfo):TSDL_bool; cdecl;
+   external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowWMInfo' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdlthread.inc

@@ -0,0 +1,222 @@
+//from "sdl_thread.h"
+
+{* The SDL thread structure, defined in SDL_thread.c *}
+//todo!
+type
+  {* The SDL thread priority
+   *
+   * Note: On many systems you require special privileges to set high priority.
+   *}
+
+  TSDL_ThreadPriority = (SDL_THREAD_PRIORITY_LOW,
+                         SDL_THREAD_PRIORITY_NORMAL,
+                         SDL_THREAD_PRIORITY_HIGH);
+
+  {* The function passed to SDL_CreateThread()
+     It is passed a void* user context parameter and returns an int.
+   *}
+  PSDL_ThreadFunction = ^TSDL_ThreadFunction;
+  TSDL_ThreadFunction = function(data: Pointer): Integer; cdecl;
+
+  {* The SDL thread ID *}
+  TSDL_ThreadID = LongWord;
+   {
+  PSDL_Thread = Pointer;
+     }
+
+  PSDL_Thread = ^TSDL_Thread;
+  TSDL_Thread = record
+    threadid: TSDL_ThreadID;
+    handle: THandle;
+    status: SInt32;
+    errbuf: TSDL_Error;
+    name: PAnsiChar;
+    data: Pointer;
+  end;
+
+  TSDL_TLSID = Cardinal;
+
+{$IFDEF WINDOWS}
+  {**
+   *  SDL_thread.h
+   *
+   *  We compile SDL into a DLL. This means, that it's the DLL which
+   *  creates a new thread for the calling process with the SDL_CreateThread()
+   *  API. There is a problem with this, that only the RTL of the SDL.DLL will
+   *  be initialized for those threads, and not the RTL of the calling
+   *  application!
+   *
+   *  To solve this, we make a little hack here.
+   *
+   *  We'll always use the caller's _beginthread() and _endthread() APIs to
+   *  start a new thread. This way, if it's the SDL.DLL which uses this API,
+   *  then the RTL of SDL.DLL will be used to create the new thread, and if it's
+   *  the application, then the RTL of the application will be used.
+   *
+   *  So, in short:
+   *  Always use the _beginthread() and _endthread() of the calling runtime
+   *  library!
+   *}
+{$DEFINE SDL_PASSED_BEGINTHREAD_ENDTHREAD}
+
+type
+  {$IFNDEF DELPHI16UP}
+    TThreadID = Cardinal;
+  {$ENDIF}
+
+  TpfnSDL_CurrentBeginThread = function(SecurityAttributes: Pointer; StackSize: LongWord; ThreadFunc: TThreadFunc; Parameter: Pointer; CreationFlags: LongWord; var ThreadId: TThreadID): Integer;
+
+  TpfnSDL_CurrentEndThread = procedure(ExitCode: Integer);
+
+  {**
+   *  Create a thread.
+   *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer; pfnBeginThread: TpfnSDL_CurrentBeginThread; pfnEndThread: TpfnSDL_CurrentEndThread): PSDL_Thread; cdecl; overload; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateThread' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Create a thread.
+   *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; overload;
+
+{$ELSE}
+
+  {**
+   *  Create a thread.
+   *
+   *   Thread naming is a little complicated: Most systems have very small
+   *    limits for the string length (BeOS has 32 bytes, Linux currently has 16,
+   *    Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
+   *    have to see what happens with your system's debugger. The name should be
+   *    UTF-8 (but using the naming limits of C identifiers is a better bet).
+   *   There are no requirements for thread naming conventions, so long as the
+   *    string is null-terminated UTF-8, but these guidelines are helpful in
+   *    choosing a name:
+   *
+   *    http://stackoverflow.com/questions/149932/naming-conventions-for-threads
+   *
+   *   If a system imposes requirements, SDL will try to munge the string for
+   *    it (truncate, etc), but the original string contents will be available
+   *    from SDL_GetThreadName().
+   *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateThread' {$ENDIF} {$ENDIF};
+
+{$ENDIF}
+
+  {**
+   * Get the thread name, as it was specified in SDL_CreateThread().
+   *  This function returns a pointer to a UTF-8 string that names the
+   *  specified thread, or NULL if it doesn't have a name. This is internal
+   *  memory, not to be free()'d by the caller, and remains valid until the
+   *  specified thread is cleaned up by SDL_WaitThread().
+   *}
+function SDL_GetThreadName(thread: PSDL_Thread): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetThreadName' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get the thread identifier for the current thread.
+   *}
+function SDL_ThreadID: TSDL_ThreadID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ThreadID' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Get the thread identifier for the specified thread.
+   *
+   *  Equivalent to SDL_ThreadID() if the specified thread is NULL.
+   *}
+function SDL_GetThreadID(thread: PSDL_Thread): TSDL_ThreadID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetThreadID' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Set the priority for the current thread
+   *}
+function SDL_SetThreadPriority(priority: TSDL_ThreadPriority): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetThreadPriority' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Wait for a thread to finish.
+   *
+   *  The return code for the thread function is placed in the area
+   *  pointed to by status, if status is not NULL.
+   *}
+procedure SDL_WaitThread(thread: PSDL_Thread; status: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitThread' {$ENDIF}{$ENDIF};
+
+  {**
+   *  A thread may be "detached" to signify that it should not remain until
+   *  another thread has called SDL_WaitThread() on it. Detaching a thread
+   *  is useful for long-running threads that nothing needs to synchronize
+   *  with or further manage. When a detached thread is done, it simply
+   *  goes away.
+   *
+   *  There is no way to recover the return code of a detached thread. If you
+   *  need this, don't detach the thread and instead use SDL_WaitThread().
+   *
+   *  Once a thread is detached, you should usually assume the SDL_Thread isn't
+   *  safe to reference again, as it will become invalid immediately upon
+   *  the detached thread's exit, instead of remaining until someone has called
+   *  SDL_WaitThread() to finally clean it up. As such, don't detach the same
+   *  thread more than once.
+   *
+   *  If a thread has already exited when passed to SDL_DetachThread(), it will
+   *  stop waiting for a call to SDL_WaitThread() and clean up immediately.
+   *  It is not safe to detach a thread that might be used with SDL_WaitThread().
+   *
+   *  You may not call SDL_WaitThread() on a thread that has been detached.
+   *  Use either that function or this one, but not both, or behavior is
+   *  undefined.
+   *
+   *  It is safe to pass NIL to this function; it is a no-op.
+   *}
+procedure SDL_DetachThread(thread:TSDL_Thread); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DetachThread' {$ENDIF}{$ENDIF};
+
+  {**
+   *  Create an identifier that is globally visible to all threads but refers to data that is thread-specific.
+   *
+   *   The newly created thread local storage identifier, or 0 on error
+   *
+   *  var tls_lock: TSDL_SpinLock;
+   *    thread_local_storage: TSDL_TLSID;
+   *
+   *  procedure SetMyThreadData(value: Pointer)
+   *
+   *      if not (thread_local_storage) then
+   *      begin
+   *        SDL_AtomicLock(@tls_lock);
+   *        if (!thread_local_storage)
+   *              thread_local_storage = SDL_TLSCreate();
+   *
+   *        SDL_AtomicUnLock(@tls_lock);
+   *
+   *        SDL_TLSSet(thread_local_storage, value);
+   *      end;
+   *
+   *  function GetMyThreadData(): Pointer;
+   *  begin
+   *     Result := SDL_TLSGet(thread_local_storage);
+   *  end;
+   *
+   *   SDL_TLSGet()
+   *   SDL_TLSSet()
+   *}
+function SDL_TLSCreate: TSDL_TLSID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSCreate' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the value associated with a thread local storage ID for the current thread.
+   *
+   *   id The thread local storage ID
+   *
+   *   The value associated with the ID for the current thread, or NULL if no value has been set.
+   *
+   *   SDL_TLSCreate()
+   *   SDL_TLSSet()
+   *}
+function SDL_TLSGet(id: TSDL_TLSID): Pointer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSGet' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Set the value associated with a thread local storage ID for the current thread.
+   *
+   *   id The thread local storage ID
+   *   value The value to associate with the ID for the current thread
+   *   destructor_ A function called when the thread exits, to free the value.
+   *
+   *   0 on success, -1 on error
+   *
+   *   SDL_TLSCreate()
+   *   SDL_TLSGet()
+   *}
+function SDL_TLSSet(id: TSDL_TLSID; value: Pointer; destructor_: Pointer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSSet' {$ENDIF} {$ENDIF};

model_viewer/sdl2/sdltimer.inc

@@ -0,0 +1,61 @@
+//from "sdl_timer.h"
+
+  {**
+   *  Get the number of milliseconds since the SDL library initialization.
+   *
+   *  This value wraps if the program runs for more than ~49 days.
+   *}
+function SDL_GetTicks: UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTicks' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the current value of the high resolution counter
+   *}
+function SDL_GetPerformanceCounter: UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPerformanceCounter' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the count per second of the high resolution counter
+   *}
+function SDL_GetPerformanceFrequency: UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPerformanceFrequency' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Wait a specified number of milliseconds before returning.
+   *}
+procedure SDL_Delay(ms: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Delay' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Function prototype for the timer callback function.
+   *
+   *  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.  If the callback returns 0, the periodic alarm is cancelled.
+   *}
+
+type
+  TSDL_TimerCallback = function(interval: UInt32; param: Pointer): UInt32; cdecl;
+
+  {**
+   * Definition of the timer ID type.
+   *}
+  TSDL_TimerID = SInt32;
+
+  {**
+   *  Add a new timer to the pool of timers already running.
+   *
+   *  A timer ID, or NULL when an error occurs.
+   *}
+function SDL_AddTimer(interval: UInt32; callback: TSDL_TimerCallback; param: Pointer): TSDL_TimerID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AddTimer' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Remove a timer knowing its ID.
+   *
+   *  A boolean value indicating success or failure.
+   *
+   *  It is not safe to remove a timer multiple times.
+   *}
+function SDL_RemoveTimer(id: TSDL_TimerID): Boolean cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RemoveTimer' {$ENDIF} {$ENDIF};
+
+  {**
+  *   Compare SDL ticks values, and return true if A has passed B.
+  *}
+function SDL_TICKS_PASSED(Const A, B:UInt32):Boolean;

model_viewer/sdl2/sdltouch.inc

@@ -0,0 +1,43 @@
+//from "sdl_touch.h"
+
+type
+  PSDL_TouchID  = ^TSDL_TouchID;
+  TSDL_TouchID  = SInt64;
+
+  PSDL_FingerID = ^TSDL_FingerID;
+  TSDL_FingerID = SInt64;
+
+  PSDL_Finger = ^TSDL_Finger;
+  TSDL_Finger = record
+    id: TSDL_FingerID;
+    x: Float;
+    y: Float;
+    pressure: Float;
+  end;
+
+{* Used as the device ID for mouse events simulated with touch input *}
+const
+  SDL_TOUCH_MOUSEID = UInt32(-1);
+
+  {* Function prototypes *}
+
+  {**
+   *  Get the number of registered touch devices.
+   *}
+function SDL_GetNumTouchDevices: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumTouchDevices' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the touch ID with the given index, or 0 if the index is invalid.
+   *}
+function SDL_GetTouchDevice(index: SInt32): TSDL_TouchID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTouchDevice' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the number of active fingers for a given touch device.
+   *}
+function SDL_GetNumTouchFingers(touchID: TSDL_TouchID): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumTouchFingers' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the finger object of the given touch, with the given index.
+   *}
+function SDL_GetTouchFinger(touchID: TSDL_TouchID; index: SInt32): PSDL_Finger cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTouchFinger' {$ENDIF} {$ENDIF};
+

model_viewer/sdl2/sdltype.inc

@@ -0,0 +1,71 @@
+//types from SDLtype_s.h / SDL_stdinc.h
+type
+
+  TSDL_Bool = (SDL_FALSE,SDL_TRUE);
+
+  DWord = LongWord;
+
+  PUInt8Array = ^TUInt8Array;
+  PUInt8 = ^UInt8;    
+  PPUInt8 = ^PUInt8;
+  UInt8 = Byte;
+  {$EXTERNALSYM UInt8}
+  TUInt8Array = array [0..MAXINT shr 1] of UInt8;
+
+  PUInt16 = ^UInt16;
+  UInt16 = word;
+  {$EXTERNALSYM UInt16}
+
+  PSInt8 = ^SInt8;
+  SInt8 = Shortint;
+  {$EXTERNALSYM SInt8}
+
+  PSInt16 = ^SInt16;
+  SInt16 = smallint;
+  {$EXTERNALSYM SInt16}
+
+  PUInt32 = ^UInt32;
+  UInt32 = Cardinal;
+  {$EXTERNALSYM UInt32}
+
+  PSInt32 = ^SInt32;
+  SInt32 = LongInt;
+  {$EXTERNALSYM SInt32}
+
+  PFloat = ^Float;
+  PInt = ^LongInt;
+
+  PShortInt = ^ShortInt;
+
+  {$IFNDEF Has_Int64}
+  PUInt64 = ^UInt64;
+  UInt64 = record
+    hi: UInt32;
+    lo: UInt32;
+  end;
+  {$EXTERNALSYM UInt64}
+
+  PInt64 = ^Int64;
+  Int64 = record
+    hi: UInt32;
+    lo: UInt32;
+  end;
+  {$EXTERNALSYM Int64}
+
+  PSInt64 = ^SInt64;
+  SInt64 = Int64;
+  {$EXTERNALSYM SInt64}
+  {$ELSE}
+  PSInt64 = ^SInt64;
+  SInt64 = Int64;
+  {$ENDIF}
+
+  {$IFNDEF WIN64}
+    size_t = UInt32;
+  {$ELSE}
+    size_t = UInt64;
+  {$ENDIF}
+  {$EXTERNALSYM SIZE_T}
+
+  Float = Single;
+  {$EXTERNALSYM Float}

model_viewer/sdl2/sdlversion.inc

@@ -0,0 +1,113 @@
+//from "sdl_version.h"
+
+  {**
+   *  Information the version of SDL in use.
+   *
+   *  Represents the library's version as three levels: major revision
+   *  (increments with massive changes, additions, and enhancements),
+   *  minor revision (increments with backwards-compatible changes to the
+   *  major revision), and patchlevel (increments with fixes to the minor
+   *  revision).
+   *
+   *  SDL_VERSION
+   *  SDL_GetVersion
+   *}
+type
+  PSDL_Version = ^TSDL_Version;
+  TSDL_Version = record
+    major,         {**< major version *}
+    minor,         {**< minor version *}
+    patch: UInt8;  {**< update version *}
+  end;
+
+{* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
+*}
+const
+  SDL_MAJOR_VERSION = 2;
+  SDL_MINOR_VERSION = 0;
+  SDL_PATCHLEVEL    = 4;
+
+{**
+ *  Macro to determine SDL version program was compiled against.
+ *
+ *  This macro fills in a SDL_version structure with the version of the
+ *  library you compiled against. This is determined by what header the
+ *  compiler uses. Note that if you dynamically linked the library, you might
+ *  have a slightly newer or older version at runtime. That version can be
+ *  determined with SDL_GetVersion(), which, unlike SDL_VERSION(),
+ *  is not a macro.
+ *
+ *  x   An instance on TSDL_Version to fill with version data.
+ *
+ *  SDL_version
+ *  SDL_GetVersion
+ *}
+procedure SDL_VERSION(Out x: TSDL_Version);
+
+{**
+ *  This macro turns the version numbers into a numeric value:
+ *
+ *  (1,2,3) -> (1203)
+ *
+ *
+ *  This assumes that there will never be more than 100 patchlevels.
+ *}
+function SDL_VERSIONNUM(X,Y,Z: UInt32): Cardinal;
+
+  {**
+   *  This is the version number macro for the current SDL version.
+   *}
+function SDL_COMPILEDVERSION: Cardinal;
+
+  {**
+   *  This macro will evaluate to true if compiled with SDL at least X.Y.Z.
+   *}
+function SDL_VERSION_ATLEAST(X,Y,Z: Cardinal): Boolean;
+
+  {**
+   *  Get the version of SDL that is linked against your program.
+   *
+   *  If you are linking to SDL dynamically, then it is possible that the
+   *  current version will be different than the version you compiled against.
+   *  This function returns the current version, while SDL_VERSION() is a
+   *  macro that tells you what version you compiled with.
+   *
+   *
+   *  compiled: TSDL_Version;
+   *  linked: TSDL_Version;
+   *
+   *  SDL_VERSION(@compiled);
+   *  SDL_GetVersion(@linked);
+   *  WriteLn('We compiled against SDL version: ' +
+   *           IntToStr(compiled.major) +
+   *           IntToStr(compiled.minor) +
+   *           IntToStr(compiled.patch));
+   *  WriteLn('But we linked against SDL version:' +
+   *           IntToStr(compiled.major) +
+   *           IntToStr(compiled.minor) +
+   *           IntToStr(compiled.patch));
+   *
+   *
+   *  This function may be called safely at any time, even before SDL_Init().
+   *
+   *  SDL_VERSION
+   *}
+procedure SDL_GetVersion(ver: PSDL_Version) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetVersion' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the code revision of SDL that is linked against your program.
+   *
+   *  Returns an arbitrary string (a hash value) uniquely identifying the
+   *  exact revision of the SDL library in use, and is only useful in comparing
+   *  against other revisions. It is NOT an incrementing number.
+   *}
+function SDL_GetRevision: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRevision' {$ENDIF} {$ENDIF};
+
+  {**
+   *  Get the revision number of SDL that is linked against your program.
+   *
+   *  Returns a number uniquely identifying the exact revision of the SDL
+   *  library in use. It is an incrementing number based on commits to
+   *  hg.libsdl.org.
+   *}
+function SDL_GetRevisionNumber: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRevisionNumber' {$ENDIF} {$ENDIF};