├── .gitignore ├── .vscode └── settings.json ├── Makefile ├── README.md ├── bin ├── INVADERS ├── SDL2.dll ├── file.txt └── pong.rom ├── include ├── SDL2 │ ├── SDL.h │ ├── SDL_assert.h │ ├── SDL_atomic.h │ ├── SDL_audio.h │ ├── SDL_bits.h │ ├── SDL_blendmode.h │ ├── SDL_clipboard.h │ ├── SDL_config.h │ ├── SDL_cpuinfo.h │ ├── SDL_egl.h │ ├── SDL_endian.h │ ├── SDL_error.h │ ├── SDL_events.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_main.h │ ├── SDL_messagebox.h │ ├── SDL_mouse.h │ ├── SDL_mutex.h │ ├── SDL_name.h │ ├── SDL_opengl.h │ ├── SDL_opengl_glext.h │ ├── SDL_opengles.h │ ├── SDL_opengles2.h │ ├── SDL_opengles2_gl2.h │ ├── SDL_opengles2_gl2ext.h │ ├── SDL_opengles2_gl2platform.h │ ├── SDL_opengles2_khrplatform.h │ ├── SDL_pixels.h │ ├── SDL_platform.h │ ├── SDL_power.h │ ├── SDL_quit.h │ ├── SDL_rect.h │ ├── SDL_render.h │ ├── SDL_revision.h │ ├── SDL_rwops.h │ ├── SDL_scancode.h │ ├── SDL_sensor.h │ ├── SDL_shape.h │ ├── SDL_stdinc.h │ ├── SDL_surface.h │ ├── SDL_system.h │ ├── SDL_syswm.h │ ├── SDL_test.h │ ├── SDL_test_assert.h │ ├── SDL_test_common.h │ ├── SDL_test_compare.h │ ├── SDL_test_crc32.h │ ├── SDL_test_font.h │ ├── SDL_test_fuzzer.h │ ├── SDL_test_harness.h │ ├── SDL_test_images.h │ ├── SDL_test_log.h │ ├── SDL_test_md5.h │ ├── SDL_test_memory.h │ ├── SDL_test_random.h │ ├── SDL_thread.h │ ├── SDL_timer.h │ ├── SDL_touch.h │ ├── SDL_types.h │ ├── SDL_version.h │ ├── SDL_video.h │ ├── SDL_vulkan.h │ ├── begin_code.h │ └── close_code.h ├── chip8.h ├── chip8keyboard.h ├── chip8memory.h ├── chip8registers.h ├── chip8screen.h ├── chip8stack.h └── config.h ├── lib ├── libSDL2.a ├── libSDL2.dll.a ├── libSDL2.la ├── libSDL2_test.a ├── libSDL2_test.la ├── libSDL2main.a └── libSDL2main.la └── src ├── chip8.c ├── chip8keyboard.c ├── chip8memory.c ├── chip8screen.c ├── chip8stack.c └── main.c /.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | bin/main.exe 3 | 4 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "sdl.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | INCLUDES= -I ./include 2 | FLAGS= -g 3 | 4 | OBJECTS=./build/chip8memory.o ./build/chip8stack.o ./build/chip8keyboard.o ./build/chip8.o ./build/chip8screen.o 5 | 6 | all: ${OBJECTS} 7 | gcc ${FLAGS} ${INCLUDES} ./src/main.c ${OBJECTS} -L ./lib -lmingw32 -lSDL2main -lSDL2 -o ./bin/main 8 | 9 | ./build/chip8memory.o:src/chip8memory.c 10 | gcc ${FLAGS} ${INCLUDES} ./src/chip8memory.c -c -o ./build/chip8memory.o 11 | 12 | ./build/chip8stack.o:src/chip8stack.c 13 | gcc ${FLAGS} ${INCLUDES} ./src/chip8stack.c -c -o ./build/chip8stack.o 14 | 15 | ./build/chip8keyboard.o:src/chip8keyboard.c 16 | gcc ${FLAGS} ${INCLUDES} ./src/chip8keyboard.c -c -o ./build/chip8keyboard.o 17 | 18 | ./build/chip8.o:src/chip8.c 19 | gcc ${FLAGS} ${INCLUDES} ./src/chip8.c -c -o ./build/chip8.o 20 | 21 | ./build/chip8screen.o:src/chip8screen.c 22 | gcc ${FLAGS} ${INCLUDES} ./src/chip8screen.c -c -o ./build/chip8screen.o 23 | 24 | clean: 25 | del build\* -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Chip8InCCourse 2 | This repository has been created for the Chip8 in C programming course which can be found here: https://dragonzap.com/course/creating-an-emulator-in-c 3 | Follow the guide and learn how to make this from the ground up 4 | 5 | # Course Description 6 | In this fantastic course you will learn how to create your very own emulator for the Chip-8 in the C programming language. The Chip-8 is a virtual machine from the mid 1970s designed to make game development easier. 7 | 8 | This course is great for anyone who has programming experience and would love to create an emulator but just does not know where to start or has attempted to do it but ran into problems 9 | 10 | You are taken through every step of emulator creation, throughout this course we start by setting up our project, then we start writing code to emulate the display and keyboard from the era. We soon move to simulating the entire Chip-8 instruction set. 11 | 12 | After you complete this course you will have a fully functioning Chip-8 emulator that can run space invaders, pong and many other classic games. 13 | -------------------------------------------------------------------------------- /bin/INVADERS: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/bin/INVADERS -------------------------------------------------------------------------------- /bin/SDL2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/bin/SDL2.dll -------------------------------------------------------------------------------- /bin/file.txt: -------------------------------------------------------------------------------- 1 | Hello world how are you -------------------------------------------------------------------------------- /bin/pong.rom: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/bin/pong.rom -------------------------------------------------------------------------------- /include/SDL2/SDL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL.h 24 | * 25 | * Main include header for the SDL library 26 | */ 27 | 28 | 29 | #ifndef SDL_h_ 30 | #define SDL_h_ 31 | 32 | #include "SDL_main.h" 33 | #include "SDL_stdinc.h" 34 | #include "SDL_assert.h" 35 | #include "SDL_atomic.h" 36 | #include "SDL_audio.h" 37 | #include "SDL_clipboard.h" 38 | #include "SDL_cpuinfo.h" 39 | #include "SDL_endian.h" 40 | #include "SDL_error.h" 41 | #include "SDL_events.h" 42 | #include "SDL_filesystem.h" 43 | #include "SDL_gamecontroller.h" 44 | #include "SDL_haptic.h" 45 | #include "SDL_hints.h" 46 | #include "SDL_joystick.h" 47 | #include "SDL_loadso.h" 48 | #include "SDL_log.h" 49 | #include "SDL_messagebox.h" 50 | #include "SDL_mutex.h" 51 | #include "SDL_power.h" 52 | #include "SDL_render.h" 53 | #include "SDL_rwops.h" 54 | #include "SDL_sensor.h" 55 | #include "SDL_shape.h" 56 | #include "SDL_system.h" 57 | #include "SDL_thread.h" 58 | #include "SDL_timer.h" 59 | #include "SDL_version.h" 60 | #include "SDL_video.h" 61 | 62 | #include "begin_code.h" 63 | /* Set up for C function definitions, even when using C++ */ 64 | #ifdef __cplusplus 65 | extern "C" { 66 | #endif 67 | 68 | /* As of version 0.5, SDL is loaded dynamically into the application */ 69 | 70 | /** 71 | * \name SDL_INIT_* 72 | * 73 | * These are the flags which may be passed to SDL_Init(). You should 74 | * specify the subsystems which you will be using in your application. 75 | */ 76 | /* @{ */ 77 | #define SDL_INIT_TIMER 0x00000001u 78 | #define SDL_INIT_AUDIO 0x00000010u 79 | #define SDL_INIT_VIDEO 0x00000020u /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */ 80 | #define SDL_INIT_JOYSTICK 0x00000200u /**< SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */ 81 | #define SDL_INIT_HAPTIC 0x00001000u 82 | #define SDL_INIT_GAMECONTROLLER 0x00002000u /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */ 83 | #define SDL_INIT_EVENTS 0x00004000u 84 | #define SDL_INIT_SENSOR 0x00008000u 85 | #define SDL_INIT_NOPARACHUTE 0x00100000u /**< compatibility; this flag is ignored. */ 86 | #define SDL_INIT_EVERYTHING ( \ 87 | SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \ 88 | SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER | SDL_INIT_SENSOR \ 89 | ) 90 | /* @} */ 91 | 92 | /** 93 | * This function initializes the subsystems specified by \c flags 94 | */ 95 | extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags); 96 | 97 | /** 98 | * This function initializes specific SDL subsystems 99 | * 100 | * Subsystem initialization is ref-counted, you must call 101 | * SDL_QuitSubSystem() for each SDL_InitSubSystem() to correctly 102 | * shutdown a subsystem manually (or call SDL_Quit() to force shutdown). 103 | * If a subsystem is already loaded then this call will 104 | * increase the ref-count and return. 105 | */ 106 | extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags); 107 | 108 | /** 109 | * This function cleans up specific SDL subsystems 110 | */ 111 | extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags); 112 | 113 | /** 114 | * This function returns a mask of the specified subsystems which have 115 | * previously been initialized. 116 | * 117 | * If \c flags is 0, it returns a mask of all initialized subsystems. 118 | */ 119 | extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags); 120 | 121 | /** 122 | * This function cleans up all initialized subsystems. You should 123 | * call it upon all exit conditions. 124 | */ 125 | extern DECLSPEC void SDLCALL SDL_Quit(void); 126 | 127 | /* Ends C function definitions when using C++ */ 128 | #ifdef __cplusplus 129 | } 130 | #endif 131 | #include "close_code.h" 132 | 133 | #endif /* SDL_h_ */ 134 | 135 | /* vi: set ts=4 sw=4 expandtab: */ 136 | -------------------------------------------------------------------------------- /include/SDL2/SDL_bits.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_bits.h 24 | * 25 | * Functions for fiddling with bits and bitmasks. 26 | */ 27 | 28 | #ifndef SDL_bits_h_ 29 | #define SDL_bits_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /** 40 | * \file SDL_bits.h 41 | */ 42 | 43 | /** 44 | * Get the index of the most significant bit. Result is undefined when called 45 | * with 0. This operation can also be stated as "count leading zeroes" and 46 | * "log base 2". 47 | * 48 | * \return Index of the most significant bit, or -1 if the value is 0. 49 | */ 50 | #if defined(__WATCOMC__) && defined(__386__) 51 | extern _inline int _SDL_clz_watcom (Uint32); 52 | #pragma aux _SDL_clz_watcom = \ 53 | "bsr eax, eax" \ 54 | "xor eax, 31" \ 55 | parm [eax] nomemory \ 56 | value [eax] \ 57 | modify exact [eax] nomemory; 58 | #endif 59 | 60 | SDL_FORCE_INLINE int 61 | SDL_MostSignificantBitIndex32(Uint32 x) 62 | { 63 | #if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 64 | /* Count Leading Zeroes builtin in GCC. 65 | * http://gcc.gnu.org/onlinedocs/gcc-4.3.4/gcc/Other-Builtins.html 66 | */ 67 | if (x == 0) { 68 | return -1; 69 | } 70 | return 31 - __builtin_clz(x); 71 | #elif defined(__WATCOMC__) && defined(__386__) 72 | if (x == 0) { 73 | return -1; 74 | } 75 | return 31 - _SDL_clz_watcom(x); 76 | #else 77 | /* Based off of Bit Twiddling Hacks by Sean Eron Anderson 78 | * , released in the public domain. 79 | * http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog 80 | */ 81 | const Uint32 b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000}; 82 | const int S[] = {1, 2, 4, 8, 16}; 83 | 84 | int msbIndex = 0; 85 | int i; 86 | 87 | if (x == 0) { 88 | return -1; 89 | } 90 | 91 | for (i = 4; i >= 0; i--) 92 | { 93 | if (x & b[i]) 94 | { 95 | x >>= S[i]; 96 | msbIndex |= S[i]; 97 | } 98 | } 99 | 100 | return msbIndex; 101 | #endif 102 | } 103 | 104 | SDL_FORCE_INLINE SDL_bool 105 | SDL_HasExactlyOneBitSet32(Uint32 x) 106 | { 107 | if (x && !(x & (x - 1))) { 108 | return SDL_TRUE; 109 | } 110 | return SDL_FALSE; 111 | } 112 | 113 | /* Ends C function definitions when using C++ */ 114 | #ifdef __cplusplus 115 | } 116 | #endif 117 | #include "close_code.h" 118 | 119 | #endif /* SDL_bits_h_ */ 120 | 121 | /* vi: set ts=4 sw=4 expandtab: */ 122 | -------------------------------------------------------------------------------- /include/SDL2/SDL_blendmode.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_blendmode.h 24 | * 25 | * Header file declaring the SDL_BlendMode enumeration 26 | */ 27 | 28 | #ifndef SDL_blendmode_h_ 29 | #define SDL_blendmode_h_ 30 | 31 | #include "begin_code.h" 32 | /* Set up for C function definitions, even when using C++ */ 33 | #ifdef __cplusplus 34 | extern "C" { 35 | #endif 36 | 37 | /** 38 | * \brief The blend mode used in SDL_RenderCopy() and drawing operations. 39 | */ 40 | typedef enum 41 | { 42 | SDL_BLENDMODE_NONE = 0x00000000, /**< no blending 43 | dstRGBA = srcRGBA */ 44 | SDL_BLENDMODE_BLEND = 0x00000001, /**< alpha blending 45 | dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA)) 46 | dstA = srcA + (dstA * (1-srcA)) */ 47 | SDL_BLENDMODE_ADD = 0x00000002, /**< additive blending 48 | dstRGB = (srcRGB * srcA) + dstRGB 49 | dstA = dstA */ 50 | SDL_BLENDMODE_MOD = 0x00000004, /**< color modulate 51 | dstRGB = srcRGB * dstRGB 52 | dstA = dstA */ 53 | SDL_BLENDMODE_INVALID = 0x7FFFFFFF 54 | 55 | /* Additional custom blend modes can be returned by SDL_ComposeCustomBlendMode() */ 56 | 57 | } SDL_BlendMode; 58 | 59 | /** 60 | * \brief The blend operation used when combining source and destination pixel components 61 | */ 62 | typedef enum 63 | { 64 | SDL_BLENDOPERATION_ADD = 0x1, /**< dst + src: supported by all renderers */ 65 | SDL_BLENDOPERATION_SUBTRACT = 0x2, /**< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES */ 66 | SDL_BLENDOPERATION_REV_SUBTRACT = 0x3, /**< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES */ 67 | SDL_BLENDOPERATION_MINIMUM = 0x4, /**< min(dst, src) : supported by D3D11 */ 68 | SDL_BLENDOPERATION_MAXIMUM = 0x5 /**< max(dst, src) : supported by D3D11 */ 69 | 70 | } SDL_BlendOperation; 71 | 72 | /** 73 | * \brief The normalized factor used to multiply pixel components 74 | */ 75 | typedef enum 76 | { 77 | SDL_BLENDFACTOR_ZERO = 0x1, /**< 0, 0, 0, 0 */ 78 | SDL_BLENDFACTOR_ONE = 0x2, /**< 1, 1, 1, 1 */ 79 | SDL_BLENDFACTOR_SRC_COLOR = 0x3, /**< srcR, srcG, srcB, srcA */ 80 | SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR = 0x4, /**< 1-srcR, 1-srcG, 1-srcB, 1-srcA */ 81 | SDL_BLENDFACTOR_SRC_ALPHA = 0x5, /**< srcA, srcA, srcA, srcA */ 82 | SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 0x6, /**< 1-srcA, 1-srcA, 1-srcA, 1-srcA */ 83 | SDL_BLENDFACTOR_DST_COLOR = 0x7, /**< dstR, dstG, dstB, dstA */ 84 | SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR = 0x8, /**< 1-dstR, 1-dstG, 1-dstB, 1-dstA */ 85 | SDL_BLENDFACTOR_DST_ALPHA = 0x9, /**< dstA, dstA, dstA, dstA */ 86 | SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 0xA /**< 1-dstA, 1-dstA, 1-dstA, 1-dstA */ 87 | 88 | } SDL_BlendFactor; 89 | 90 | /** 91 | * \brief Create a custom blend mode, which may or may not be supported by a given renderer 92 | * 93 | * \param srcColorFactor source color factor 94 | * \param dstColorFactor destination color factor 95 | * \param colorOperation color operation 96 | * \param srcAlphaFactor source alpha factor 97 | * \param dstAlphaFactor destination alpha factor 98 | * \param alphaOperation alpha operation 99 | * 100 | * The result of the blend mode operation will be: 101 | * dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor 102 | * and 103 | * dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor 104 | */ 105 | extern DECLSPEC SDL_BlendMode SDLCALL SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, 106 | SDL_BlendFactor dstColorFactor, 107 | SDL_BlendOperation colorOperation, 108 | SDL_BlendFactor srcAlphaFactor, 109 | SDL_BlendFactor dstAlphaFactor, 110 | SDL_BlendOperation alphaOperation); 111 | 112 | /* Ends C function definitions when using C++ */ 113 | #ifdef __cplusplus 114 | } 115 | #endif 116 | #include "close_code.h" 117 | 118 | #endif /* SDL_blendmode_h_ */ 119 | 120 | /* vi: set ts=4 sw=4 expandtab: */ 121 | -------------------------------------------------------------------------------- /include/SDL2/SDL_clipboard.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_clipboard.h 24 | * 25 | * Include file for SDL clipboard handling 26 | */ 27 | 28 | #ifndef SDL_clipboard_h_ 29 | #define SDL_clipboard_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /* Function prototypes */ 40 | 41 | /** 42 | * \brief Put UTF-8 text into the clipboard 43 | * 44 | * \sa SDL_GetClipboardText() 45 | */ 46 | extern DECLSPEC int SDLCALL SDL_SetClipboardText(const char *text); 47 | 48 | /** 49 | * \brief Get UTF-8 text from the clipboard, which must be freed with SDL_free() 50 | * 51 | * \sa SDL_SetClipboardText() 52 | */ 53 | extern DECLSPEC char * SDLCALL SDL_GetClipboardText(void); 54 | 55 | /** 56 | * \brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty 57 | * 58 | * \sa SDL_GetClipboardText() 59 | */ 60 | extern DECLSPEC SDL_bool SDLCALL SDL_HasClipboardText(void); 61 | 62 | 63 | /* Ends C function definitions when using C++ */ 64 | #ifdef __cplusplus 65 | } 66 | #endif 67 | #include "close_code.h" 68 | 69 | #endif /* SDL_clipboard_h_ */ 70 | 71 | /* vi: set ts=4 sw=4 expandtab: */ 72 | -------------------------------------------------------------------------------- /include/SDL2/SDL_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_config_windows_h_ 23 | #define SDL_config_windows_h_ 24 | #define SDL_config_h_ 25 | 26 | #include "SDL_platform.h" 27 | 28 | /* This is a set of defines to configure the SDL features */ 29 | 30 | #if !defined(_STDINT_H_) && (!defined(HAVE_STDINT_H) || !_HAVE_STDINT_H) 31 | #if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__) 32 | #define HAVE_STDINT_H 1 33 | #elif defined(_MSC_VER) 34 | typedef signed __int8 int8_t; 35 | typedef unsigned __int8 uint8_t; 36 | typedef signed __int16 int16_t; 37 | typedef unsigned __int16 uint16_t; 38 | typedef signed __int32 int32_t; 39 | typedef unsigned __int32 uint32_t; 40 | typedef signed __int64 int64_t; 41 | typedef unsigned __int64 uint64_t; 42 | #ifndef _UINTPTR_T_DEFINED 43 | #ifdef _WIN64 44 | typedef unsigned __int64 uintptr_t; 45 | #else 46 | typedef unsigned int uintptr_t; 47 | #endif 48 | #define _UINTPTR_T_DEFINED 49 | #endif 50 | /* Older Visual C++ headers don't have the Win64-compatible typedefs... */ 51 | #if ((_MSC_VER <= 1200) && (!defined(DWORD_PTR))) 52 | #define DWORD_PTR DWORD 53 | #endif 54 | #if ((_MSC_VER <= 1200) && (!defined(LONG_PTR))) 55 | #define LONG_PTR LONG 56 | #endif 57 | #else /* !__GNUC__ && !_MSC_VER */ 58 | typedef signed char int8_t; 59 | typedef unsigned char uint8_t; 60 | typedef signed short int16_t; 61 | typedef unsigned short uint16_t; 62 | typedef signed int int32_t; 63 | typedef unsigned int uint32_t; 64 | typedef signed long long int64_t; 65 | typedef unsigned long long uint64_t; 66 | #ifndef _SIZE_T_DEFINED_ 67 | #define _SIZE_T_DEFINED_ 68 | typedef unsigned int size_t; 69 | #endif 70 | typedef unsigned int uintptr_t; 71 | #endif /* __GNUC__ || _MSC_VER */ 72 | #endif /* !_STDINT_H_ && !HAVE_STDINT_H */ 73 | 74 | #ifdef _WIN64 75 | # define SIZEOF_VOIDP 8 76 | #else 77 | # define SIZEOF_VOIDP 4 78 | #endif 79 | 80 | #define HAVE_DDRAW_H 1 81 | #define HAVE_DINPUT_H 1 82 | #define HAVE_DSOUND_H 1 83 | #define HAVE_DXGI_H 1 84 | #define HAVE_XINPUT_H 1 85 | #define HAVE_MMDEVICEAPI_H 1 86 | #define HAVE_AUDIOCLIENT_H 1 87 | #define HAVE_ENDPOINTVOLUME_H 1 88 | 89 | /* This is disabled by default to avoid C runtime dependencies and manifest requirements */ 90 | #ifdef HAVE_LIBC 91 | /* Useful headers */ 92 | #define STDC_HEADERS 1 93 | #define HAVE_CTYPE_H 1 94 | #define HAVE_FLOAT_H 1 95 | #define HAVE_LIMITS_H 1 96 | #define HAVE_MATH_H 1 97 | #define HAVE_SIGNAL_H 1 98 | #define HAVE_STDIO_H 1 99 | #define HAVE_STRING_H 1 100 | 101 | /* C library functions */ 102 | #define HAVE_MALLOC 1 103 | #define HAVE_CALLOC 1 104 | #define HAVE_REALLOC 1 105 | #define HAVE_FREE 1 106 | #define HAVE_ALLOCA 1 107 | #define HAVE_QSORT 1 108 | #define HAVE_ABS 1 109 | #define HAVE_MEMSET 1 110 | #define HAVE_MEMCPY 1 111 | #define HAVE_MEMMOVE 1 112 | #define HAVE_MEMCMP 1 113 | #define HAVE_STRLEN 1 114 | #define HAVE__STRREV 1 115 | /* These functions have security warnings, so we won't use them */ 116 | /* #undef HAVE__STRUPR */ 117 | /* #undef HAVE__STRLWR */ 118 | #define HAVE_STRCHR 1 119 | #define HAVE_STRRCHR 1 120 | #define HAVE_STRSTR 1 121 | /* These functions have security warnings, so we won't use them */ 122 | /* #undef HAVE__LTOA */ 123 | /* #undef HAVE__ULTOA */ 124 | #define HAVE_STRTOL 1 125 | #define HAVE_STRTOUL 1 126 | #define HAVE_STRTOD 1 127 | #define HAVE_ATOI 1 128 | #define HAVE_ATOF 1 129 | #define HAVE_STRCMP 1 130 | #define HAVE_STRNCMP 1 131 | #define HAVE__STRICMP 1 132 | #define HAVE__STRNICMP 1 133 | #define HAVE_ACOS 1 134 | #define HAVE_ACOSF 1 135 | #define HAVE_ASIN 1 136 | #define HAVE_ASINF 1 137 | #define HAVE_ATAN 1 138 | #define HAVE_ATANF 1 139 | #define HAVE_ATAN2 1 140 | #define HAVE_ATAN2F 1 141 | #define HAVE_CEILF 1 142 | #define HAVE__COPYSIGN 1 143 | #define HAVE_COS 1 144 | #define HAVE_COSF 1 145 | #define HAVE_EXP 1 146 | #define HAVE_EXPF 1 147 | #define HAVE_FABS 1 148 | #define HAVE_FABSF 1 149 | #define HAVE_FLOOR 1 150 | #define HAVE_FLOORF 1 151 | #define HAVE_FMOD 1 152 | #define HAVE_FMODF 1 153 | #define HAVE_LOG 1 154 | #define HAVE_LOGF 1 155 | #define HAVE_LOG10 1 156 | #define HAVE_LOG10F 1 157 | #define HAVE_POW 1 158 | #define HAVE_POWF 1 159 | #define HAVE_SIN 1 160 | #define HAVE_SINF 1 161 | #define HAVE_SQRT 1 162 | #define HAVE_SQRTF 1 163 | #define HAVE_TAN 1 164 | #define HAVE_TANF 1 165 | #if defined(_MSC_VER) 166 | /* These functions were added with the VC++ 2013 C runtime library */ 167 | #if _MSC_VER >= 1800 168 | #define HAVE_STRTOLL 1 169 | #define HAVE_VSSCANF 1 170 | #define HAVE_SCALBN 1 171 | #define HAVE_SCALBNF 1 172 | #endif 173 | /* This function is available with at least the VC++ 2008 C runtime library */ 174 | #if _MSC_VER >= 1400 175 | #define HAVE__FSEEKI64 1 176 | #endif 177 | #endif 178 | #if !defined(_MSC_VER) || defined(_USE_MATH_DEFINES) 179 | #define HAVE_M_PI 1 180 | #endif 181 | #else 182 | #define HAVE_STDARG_H 1 183 | #define HAVE_STDDEF_H 1 184 | #endif 185 | 186 | /* Enable various audio drivers */ 187 | #define SDL_AUDIO_DRIVER_WASAPI 1 188 | #define SDL_AUDIO_DRIVER_DSOUND 1 189 | #define SDL_AUDIO_DRIVER_WINMM 1 190 | #define SDL_AUDIO_DRIVER_DISK 1 191 | #define SDL_AUDIO_DRIVER_DUMMY 1 192 | 193 | /* Enable various input drivers */ 194 | #define SDL_JOYSTICK_DINPUT 1 195 | #define SDL_JOYSTICK_XINPUT 1 196 | #define SDL_JOYSTICK_HIDAPI 1 197 | #define SDL_HAPTIC_DINPUT 1 198 | #define SDL_HAPTIC_XINPUT 1 199 | 200 | /* Enable the dummy sensor driver */ 201 | #define SDL_SENSOR_DUMMY 1 202 | 203 | /* Enable various shared object loading systems */ 204 | #define SDL_LOADSO_WINDOWS 1 205 | 206 | /* Enable various threading systems */ 207 | #define SDL_THREAD_WINDOWS 1 208 | 209 | /* Enable various timer systems */ 210 | #define SDL_TIMER_WINDOWS 1 211 | 212 | /* Enable various video drivers */ 213 | #define SDL_VIDEO_DRIVER_DUMMY 1 214 | #define SDL_VIDEO_DRIVER_WINDOWS 1 215 | 216 | #ifndef SDL_VIDEO_RENDER_D3D 217 | #define SDL_VIDEO_RENDER_D3D 1 218 | #endif 219 | #ifndef SDL_VIDEO_RENDER_D3D11 220 | #define SDL_VIDEO_RENDER_D3D11 0 221 | #endif 222 | 223 | /* Enable OpenGL support */ 224 | #ifndef SDL_VIDEO_OPENGL 225 | #define SDL_VIDEO_OPENGL 1 226 | #endif 227 | #ifndef SDL_VIDEO_OPENGL_WGL 228 | #define SDL_VIDEO_OPENGL_WGL 1 229 | #endif 230 | #ifndef SDL_VIDEO_RENDER_OGL 231 | #define SDL_VIDEO_RENDER_OGL 1 232 | #endif 233 | #ifndef SDL_VIDEO_RENDER_OGL_ES2 234 | #define SDL_VIDEO_RENDER_OGL_ES2 1 235 | #endif 236 | #ifndef SDL_VIDEO_OPENGL_ES2 237 | #define SDL_VIDEO_OPENGL_ES2 1 238 | #endif 239 | #ifndef SDL_VIDEO_OPENGL_EGL 240 | #define SDL_VIDEO_OPENGL_EGL 1 241 | #endif 242 | 243 | /* Enable Vulkan support */ 244 | #define SDL_VIDEO_VULKAN 1 245 | 246 | /* Enable system power support */ 247 | #define SDL_POWER_WINDOWS 1 248 | 249 | /* Enable filesystem support */ 250 | #define SDL_FILESYSTEM_WINDOWS 1 251 | 252 | /* Enable assembly routines (Win64 doesn't have inline asm) */ 253 | #ifndef _WIN64 254 | #define SDL_ASSEMBLY_ROUTINES 1 255 | #endif 256 | 257 | #endif /* SDL_config_windows_h_ */ 258 | -------------------------------------------------------------------------------- /include/SDL2/SDL_cpuinfo.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_cpuinfo.h 24 | * 25 | * CPU feature detection for SDL. 26 | */ 27 | 28 | #ifndef SDL_cpuinfo_h_ 29 | #define SDL_cpuinfo_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | /* Need to do this here because intrin.h has C++ code in it */ 34 | /* Visual Studio 2005 has a bug where intrin.h conflicts with winnt.h */ 35 | #if defined(_MSC_VER) && (_MSC_VER >= 1500) && (defined(_M_IX86) || defined(_M_X64)) 36 | #ifdef __clang__ 37 | /* Many of the intrinsics SDL uses are not implemented by clang with Visual Studio */ 38 | #undef __MMX__ 39 | #undef __SSE__ 40 | #undef __SSE2__ 41 | #else 42 | #include 43 | #ifndef _WIN64 44 | #ifndef __MMX__ 45 | #define __MMX__ 46 | #endif 47 | #ifndef __3dNOW__ 48 | #define __3dNOW__ 49 | #endif 50 | #endif 51 | #ifndef __SSE__ 52 | #define __SSE__ 53 | #endif 54 | #ifndef __SSE2__ 55 | #define __SSE2__ 56 | #endif 57 | #endif /* __clang__ */ 58 | #elif defined(__MINGW64_VERSION_MAJOR) 59 | #include 60 | #else 61 | /* altivec.h redefining bool causes a number of problems, see bugs 3993 and 4392, so you need to explicitly define SDL_ENABLE_ALTIVEC_H to have it included. */ 62 | #if defined(HAVE_ALTIVEC_H) && defined(__ALTIVEC__) && !defined(__APPLE_ALTIVEC__) && defined(SDL_ENABLE_ALTIVEC_H) 63 | #include 64 | #endif 65 | #if !defined(SDL_DISABLE_ARM_NEON_H) 66 | # if defined(__ARM_NEON) 67 | # include 68 | # elif defined(__WINDOWS__) || defined(__WINRT__) 69 | /* Visual Studio doesn't define __ARM_ARCH, but _M_ARM (if set, always 7), and _M_ARM64 (if set, always 1). */ 70 | # if defined(_M_ARM) 71 | # include 72 | # include 73 | # define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */ 74 | # endif 75 | # if defined (_M_ARM64) 76 | # include 77 | # include 78 | # define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */ 79 | # endif 80 | # endif 81 | #endif 82 | #if defined(__3dNOW__) && !defined(SDL_DISABLE_MM3DNOW_H) 83 | #include 84 | #endif 85 | #if defined(HAVE_IMMINTRIN_H) && !defined(SDL_DISABLE_IMMINTRIN_H) 86 | #include 87 | #else 88 | #if defined(__MMX__) && !defined(SDL_DISABLE_MMINTRIN_H) 89 | #include 90 | #endif 91 | #if defined(__SSE__) && !defined(SDL_DISABLE_XMMINTRIN_H) 92 | #include 93 | #endif 94 | #if defined(__SSE2__) && !defined(SDL_DISABLE_EMMINTRIN_H) 95 | #include 96 | #endif 97 | #if defined(__SSE3__) && !defined(SDL_DISABLE_PMMINTRIN_H) 98 | #include 99 | #endif 100 | #endif /* HAVE_IMMINTRIN_H */ 101 | #endif /* compiler version */ 102 | 103 | #include "begin_code.h" 104 | /* Set up for C function definitions, even when using C++ */ 105 | #ifdef __cplusplus 106 | extern "C" { 107 | #endif 108 | 109 | /* This is a guess for the cacheline size used for padding. 110 | * Most x86 processors have a 64 byte cache line. 111 | * The 64-bit PowerPC processors have a 128 byte cache line. 112 | * We'll use the larger value to be generally safe. 113 | */ 114 | #define SDL_CACHELINE_SIZE 128 115 | 116 | /** 117 | * This function returns the number of CPU cores available. 118 | */ 119 | extern DECLSPEC int SDLCALL SDL_GetCPUCount(void); 120 | 121 | /** 122 | * This function returns the L1 cache line size of the CPU 123 | * 124 | * This is useful for determining multi-threaded structure padding 125 | * or SIMD prefetch sizes. 126 | */ 127 | extern DECLSPEC int SDLCALL SDL_GetCPUCacheLineSize(void); 128 | 129 | /** 130 | * This function returns true if the CPU has the RDTSC instruction. 131 | */ 132 | extern DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void); 133 | 134 | /** 135 | * This function returns true if the CPU has AltiVec features. 136 | */ 137 | extern DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void); 138 | 139 | /** 140 | * This function returns true if the CPU has MMX features. 141 | */ 142 | extern DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void); 143 | 144 | /** 145 | * This function returns true if the CPU has 3DNow! features. 146 | */ 147 | extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void); 148 | 149 | /** 150 | * This function returns true if the CPU has SSE features. 151 | */ 152 | extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void); 153 | 154 | /** 155 | * This function returns true if the CPU has SSE2 features. 156 | */ 157 | extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void); 158 | 159 | /** 160 | * This function returns true if the CPU has SSE3 features. 161 | */ 162 | extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE3(void); 163 | 164 | /** 165 | * This function returns true if the CPU has SSE4.1 features. 166 | */ 167 | extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE41(void); 168 | 169 | /** 170 | * This function returns true if the CPU has SSE4.2 features. 171 | */ 172 | extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE42(void); 173 | 174 | /** 175 | * This function returns true if the CPU has AVX features. 176 | */ 177 | extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX(void); 178 | 179 | /** 180 | * This function returns true if the CPU has AVX2 features. 181 | */ 182 | extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX2(void); 183 | 184 | /** 185 | * This function returns true if the CPU has AVX-512F (foundation) features. 186 | */ 187 | extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX512F(void); 188 | 189 | /** 190 | * This function returns true if the CPU has NEON (ARM SIMD) features. 191 | */ 192 | extern DECLSPEC SDL_bool SDLCALL SDL_HasNEON(void); 193 | 194 | /** 195 | * This function returns the amount of RAM configured in the system, in MB. 196 | */ 197 | extern DECLSPEC int SDLCALL SDL_GetSystemRAM(void); 198 | 199 | /** 200 | * \brief Report the alignment this system needs for SIMD allocations. 201 | * 202 | * This will return the minimum number of bytes to which a pointer must be 203 | * aligned to be compatible with SIMD instructions on the current machine. 204 | * For example, if the machine supports SSE only, it will return 16, but if 205 | * it supports AVX-512F, it'll return 64 (etc). This only reports values for 206 | * instruction sets SDL knows about, so if your SDL build doesn't have 207 | * SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and 208 | * not 64 for the AVX-512 instructions that exist but SDL doesn't know about. 209 | * Plan accordingly. 210 | */ 211 | extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void); 212 | 213 | /** 214 | * \brief Allocate memory in a SIMD-friendly way. 215 | * 216 | * This will allocate a block of memory that is suitable for use with SIMD 217 | * instructions. Specifically, it will be properly aligned and padded for 218 | * the system's supported vector instructions. 219 | * 220 | * The memory returned will be padded such that it is safe to read or write 221 | * an incomplete vector at the end of the memory block. This can be useful 222 | * so you don't have to drop back to a scalar fallback at the end of your 223 | * SIMD processing loop to deal with the final elements without overflowing 224 | * the allocated buffer. 225 | * 226 | * You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() 227 | * or delete[], etc. 228 | * 229 | * Note that SDL will only deal with SIMD instruction sets it is aware of; 230 | * for example, SDL 2.0.8 knows that SSE wants 16-byte vectors 231 | * (SDL_HasSSE()), and AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't 232 | * know that AVX-512 wants 64. To be clear: if you can't decide to use an 233 | * instruction set with an SDL_Has*() function, don't use that instruction 234 | * set with memory allocated through here. 235 | * 236 | * SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't 237 | * out of memory. 238 | * 239 | * \param len The length, in bytes, of the block to allocated. The actual 240 | * allocated block might be larger due to padding, etc. 241 | * \return Pointer to newly-allocated block, NULL if out of memory. 242 | * 243 | * \sa SDL_SIMDAlignment 244 | * \sa SDL_SIMDFree 245 | */ 246 | extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len); 247 | 248 | /** 249 | * \brief Deallocate memory obtained from SDL_SIMDAlloc 250 | * 251 | * It is not valid to use this function on a pointer from anything but 252 | * SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc, 253 | * SDL_malloc, memalign, new[], etc. 254 | * 255 | * However, SDL_SIMDFree(NULL) is a legal no-op. 256 | * 257 | * \sa SDL_SIMDAlloc 258 | */ 259 | extern DECLSPEC void SDLCALL SDL_SIMDFree(void *ptr); 260 | 261 | /* vi: set ts=4 sw=4 expandtab: */ 262 | /* Ends C function definitions when using C++ */ 263 | #ifdef __cplusplus 264 | } 265 | #endif 266 | #include "close_code.h" 267 | 268 | #endif /* SDL_cpuinfo_h_ */ 269 | 270 | /* vi: set ts=4 sw=4 expandtab: */ 271 | -------------------------------------------------------------------------------- /include/SDL2/SDL_endian.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_endian.h 24 | * 25 | * Functions for reading and writing endian-specific values 26 | */ 27 | 28 | #ifndef SDL_endian_h_ 29 | #define SDL_endian_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | /** 34 | * \name The two types of endianness 35 | */ 36 | /* @{ */ 37 | #define SDL_LIL_ENDIAN 1234 38 | #define SDL_BIG_ENDIAN 4321 39 | /* @} */ 40 | 41 | #ifndef SDL_BYTEORDER /* Not defined in SDL_config.h? */ 42 | #ifdef __linux__ 43 | #include 44 | #define SDL_BYTEORDER __BYTE_ORDER 45 | #else /* __linux__ */ 46 | #if defined(__hppa__) || \ 47 | defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \ 48 | (defined(__MIPS__) && defined(__MISPEB__)) || \ 49 | defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \ 50 | defined(__sparc__) 51 | #define SDL_BYTEORDER SDL_BIG_ENDIAN 52 | #else 53 | #define SDL_BYTEORDER SDL_LIL_ENDIAN 54 | #endif 55 | #endif /* __linux__ */ 56 | #endif /* !SDL_BYTEORDER */ 57 | 58 | 59 | #include "begin_code.h" 60 | /* Set up for C function definitions, even when using C++ */ 61 | #ifdef __cplusplus 62 | extern "C" { 63 | #endif 64 | 65 | /** 66 | * \file SDL_endian.h 67 | */ 68 | #if defined(__GNUC__) && defined(__i386__) && \ 69 | !(__GNUC__ == 2 && __GNUC_MINOR__ == 95 /* broken gcc version */) 70 | SDL_FORCE_INLINE Uint16 71 | SDL_Swap16(Uint16 x) 72 | { 73 | __asm__("xchgb %b0,%h0": "=q"(x):"0"(x)); 74 | return x; 75 | } 76 | #elif defined(__GNUC__) && defined(__x86_64__) 77 | SDL_FORCE_INLINE Uint16 78 | SDL_Swap16(Uint16 x) 79 | { 80 | __asm__("xchgb %b0,%h0": "=Q"(x):"0"(x)); 81 | return x; 82 | } 83 | #elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__)) 84 | SDL_FORCE_INLINE Uint16 85 | SDL_Swap16(Uint16 x) 86 | { 87 | int result; 88 | 89 | __asm__("rlwimi %0,%2,8,16,23": "=&r"(result):"0"(x >> 8), "r"(x)); 90 | return (Uint16)result; 91 | } 92 | #elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__) 93 | SDL_FORCE_INLINE Uint16 94 | SDL_Swap16(Uint16 x) 95 | { 96 | __asm__("rorw #8,%0": "=d"(x): "0"(x):"cc"); 97 | return x; 98 | } 99 | #elif defined(__WATCOMC__) && defined(__386__) 100 | extern _inline Uint16 SDL_Swap16(Uint16); 101 | #pragma aux SDL_Swap16 = \ 102 | "xchg al, ah" \ 103 | parm [ax] \ 104 | modify [ax]; 105 | #else 106 | SDL_FORCE_INLINE Uint16 107 | SDL_Swap16(Uint16 x) 108 | { 109 | return SDL_static_cast(Uint16, ((x << 8) | (x >> 8))); 110 | } 111 | #endif 112 | 113 | #if defined(__GNUC__) && defined(__i386__) 114 | SDL_FORCE_INLINE Uint32 115 | SDL_Swap32(Uint32 x) 116 | { 117 | __asm__("bswap %0": "=r"(x):"0"(x)); 118 | return x; 119 | } 120 | #elif defined(__GNUC__) && defined(__x86_64__) 121 | SDL_FORCE_INLINE Uint32 122 | SDL_Swap32(Uint32 x) 123 | { 124 | __asm__("bswapl %0": "=r"(x):"0"(x)); 125 | return x; 126 | } 127 | #elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__)) 128 | SDL_FORCE_INLINE Uint32 129 | SDL_Swap32(Uint32 x) 130 | { 131 | Uint32 result; 132 | 133 | __asm__("rlwimi %0,%2,24,16,23": "=&r"(result):"0"(x >> 24), "r"(x)); 134 | __asm__("rlwimi %0,%2,8,8,15": "=&r"(result):"0"(result), "r"(x)); 135 | __asm__("rlwimi %0,%2,24,0,7": "=&r"(result):"0"(result), "r"(x)); 136 | return result; 137 | } 138 | #elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__) 139 | SDL_FORCE_INLINE Uint32 140 | SDL_Swap32(Uint32 x) 141 | { 142 | __asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0": "=d"(x): "0"(x):"cc"); 143 | return x; 144 | } 145 | #elif defined(__WATCOMC__) && defined(__386__) 146 | extern _inline Uint32 SDL_Swap32(Uint32); 147 | #ifndef __SW_3 /* 486+ */ 148 | #pragma aux SDL_Swap32 = \ 149 | "bswap eax" \ 150 | parm [eax] \ 151 | modify [eax]; 152 | #else /* 386-only */ 153 | #pragma aux SDL_Swap32 = \ 154 | "xchg al, ah" \ 155 | "ror eax, 16" \ 156 | "xchg al, ah" \ 157 | parm [eax] \ 158 | modify [eax]; 159 | #endif 160 | #else 161 | SDL_FORCE_INLINE Uint32 162 | SDL_Swap32(Uint32 x) 163 | { 164 | return SDL_static_cast(Uint32, ((x << 24) | ((x << 8) & 0x00FF0000) | 165 | ((x >> 8) & 0x0000FF00) | (x >> 24))); 166 | } 167 | #endif 168 | 169 | #if defined(__GNUC__) && defined(__i386__) 170 | SDL_FORCE_INLINE Uint64 171 | SDL_Swap64(Uint64 x) 172 | { 173 | union 174 | { 175 | struct 176 | { 177 | Uint32 a, b; 178 | } s; 179 | Uint64 u; 180 | } v; 181 | v.u = x; 182 | __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1": "=r"(v.s.a), "=r"(v.s.b):"0"(v.s.a), 183 | "1"(v.s. 184 | b)); 185 | return v.u; 186 | } 187 | #elif defined(__GNUC__) && defined(__x86_64__) 188 | SDL_FORCE_INLINE Uint64 189 | SDL_Swap64(Uint64 x) 190 | { 191 | __asm__("bswapq %0": "=r"(x):"0"(x)); 192 | return x; 193 | } 194 | #else 195 | SDL_FORCE_INLINE Uint64 196 | SDL_Swap64(Uint64 x) 197 | { 198 | Uint32 hi, lo; 199 | 200 | /* Separate into high and low 32-bit values and swap them */ 201 | lo = SDL_static_cast(Uint32, x & 0xFFFFFFFF); 202 | x >>= 32; 203 | hi = SDL_static_cast(Uint32, x & 0xFFFFFFFF); 204 | x = SDL_Swap32(lo); 205 | x <<= 32; 206 | x |= SDL_Swap32(hi); 207 | return (x); 208 | } 209 | #endif 210 | 211 | 212 | SDL_FORCE_INLINE float 213 | SDL_SwapFloat(float x) 214 | { 215 | union 216 | { 217 | float f; 218 | Uint32 ui32; 219 | } swapper; 220 | swapper.f = x; 221 | swapper.ui32 = SDL_Swap32(swapper.ui32); 222 | return swapper.f; 223 | } 224 | 225 | 226 | /** 227 | * \name Swap to native 228 | * Byteswap item from the specified endianness to the native endianness. 229 | */ 230 | /* @{ */ 231 | #if SDL_BYTEORDER == SDL_LIL_ENDIAN 232 | #define SDL_SwapLE16(X) (X) 233 | #define SDL_SwapLE32(X) (X) 234 | #define SDL_SwapLE64(X) (X) 235 | #define SDL_SwapFloatLE(X) (X) 236 | #define SDL_SwapBE16(X) SDL_Swap16(X) 237 | #define SDL_SwapBE32(X) SDL_Swap32(X) 238 | #define SDL_SwapBE64(X) SDL_Swap64(X) 239 | #define SDL_SwapFloatBE(X) SDL_SwapFloat(X) 240 | #else 241 | #define SDL_SwapLE16(X) SDL_Swap16(X) 242 | #define SDL_SwapLE32(X) SDL_Swap32(X) 243 | #define SDL_SwapLE64(X) SDL_Swap64(X) 244 | #define SDL_SwapFloatLE(X) SDL_SwapFloat(X) 245 | #define SDL_SwapBE16(X) (X) 246 | #define SDL_SwapBE32(X) (X) 247 | #define SDL_SwapBE64(X) (X) 248 | #define SDL_SwapFloatBE(X) (X) 249 | #endif 250 | /* @} *//* Swap to native */ 251 | 252 | /* Ends C function definitions when using C++ */ 253 | #ifdef __cplusplus 254 | } 255 | #endif 256 | #include "close_code.h" 257 | 258 | #endif /* SDL_endian_h_ */ 259 | 260 | /* vi: set ts=4 sw=4 expandtab: */ 261 | -------------------------------------------------------------------------------- /include/SDL2/SDL_error.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_error.h 24 | * 25 | * Simple error message routines for SDL. 26 | */ 27 | 28 | #ifndef SDL_error_h_ 29 | #define SDL_error_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /* Public functions */ 40 | /* SDL_SetError() unconditionally returns -1. */ 41 | extern DECLSPEC int SDLCALL SDL_SetError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1); 42 | extern DECLSPEC const char *SDLCALL SDL_GetError(void); 43 | extern DECLSPEC void SDLCALL SDL_ClearError(void); 44 | 45 | /** 46 | * \name Internal error functions 47 | * 48 | * \internal 49 | * Private error reporting function - used internally. 50 | */ 51 | /* @{ */ 52 | #define SDL_OutOfMemory() SDL_Error(SDL_ENOMEM) 53 | #define SDL_Unsupported() SDL_Error(SDL_UNSUPPORTED) 54 | #define SDL_InvalidParamError(param) SDL_SetError("Parameter '%s' is invalid", (param)) 55 | typedef enum 56 | { 57 | SDL_ENOMEM, 58 | SDL_EFREAD, 59 | SDL_EFWRITE, 60 | SDL_EFSEEK, 61 | SDL_UNSUPPORTED, 62 | SDL_LASTERROR 63 | } SDL_errorcode; 64 | /* SDL_Error() unconditionally returns -1. */ 65 | extern DECLSPEC int SDLCALL SDL_Error(SDL_errorcode code); 66 | /* @} *//* Internal error functions */ 67 | 68 | /* Ends C function definitions when using C++ */ 69 | #ifdef __cplusplus 70 | } 71 | #endif 72 | #include "close_code.h" 73 | 74 | #endif /* SDL_error_h_ */ 75 | 76 | /* vi: set ts=4 sw=4 expandtab: */ 77 | -------------------------------------------------------------------------------- /include/SDL2/SDL_filesystem.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_filesystem.h 24 | * 25 | * \brief Include file for filesystem SDL API functions 26 | */ 27 | 28 | #ifndef SDL_filesystem_h_ 29 | #define SDL_filesystem_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | 35 | /* Set up for C function definitions, even when using C++ */ 36 | #ifdef __cplusplus 37 | extern "C" { 38 | #endif 39 | 40 | /** 41 | * \brief Get the path where the application resides. 42 | * 43 | * Get the "base path". This is the directory where the application was run 44 | * from, which is probably the installation directory, and may or may not 45 | * be the process's current working directory. 46 | * 47 | * This returns an absolute path in UTF-8 encoding, and is guaranteed to 48 | * end with a path separator ('\\' on Windows, '/' most other places). 49 | * 50 | * The pointer returned by this function is owned by you. Please call 51 | * SDL_free() on the pointer when you are done with it, or it will be a 52 | * memory leak. This is not necessarily a fast call, though, so you should 53 | * call this once near startup and save the string if you need it. 54 | * 55 | * Some platforms can't determine the application's path, and on other 56 | * platforms, this might be meaningless. In such cases, this function will 57 | * return NULL. 58 | * 59 | * \return String of base dir in UTF-8 encoding, or NULL on error. 60 | * 61 | * \sa SDL_GetPrefPath 62 | */ 63 | extern DECLSPEC char *SDLCALL SDL_GetBasePath(void); 64 | 65 | /** 66 | * \brief Get the user-and-app-specific path where files can be written. 67 | * 68 | * Get the "pref dir". This is meant to be where users can write personal 69 | * files (preferences and save games, etc) that are specific to your 70 | * application. This directory is unique per user, per application. 71 | * 72 | * This function will decide the appropriate location in the native filesystem, 73 | * create the directory if necessary, and return a string of the absolute 74 | * path to the directory in UTF-8 encoding. 75 | * 76 | * On Windows, the string might look like: 77 | * "C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\" 78 | * 79 | * On Linux, the string might look like: 80 | * "/home/bob/.local/share/My Program Name/" 81 | * 82 | * On Mac OS X, the string might look like: 83 | * "/Users/bob/Library/Application Support/My Program Name/" 84 | * 85 | * (etc.) 86 | * 87 | * You specify the name of your organization (if it's not a real organization, 88 | * your name or an Internet domain you own might do) and the name of your 89 | * application. These should be untranslated proper names. 90 | * 91 | * Both the org and app strings may become part of a directory name, so 92 | * please follow these rules: 93 | * 94 | * - Try to use the same org string (including case-sensitivity) for 95 | * all your applications that use this function. 96 | * - Always use a unique app string for each one, and make sure it never 97 | * changes for an app once you've decided on it. 98 | * - Unicode characters are legal, as long as it's UTF-8 encoded, but... 99 | * - ...only use letters, numbers, and spaces. Avoid punctuation like 100 | * "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient. 101 | * 102 | * This returns an absolute path in UTF-8 encoding, and is guaranteed to 103 | * end with a path separator ('\\' on Windows, '/' most other places). 104 | * 105 | * The pointer returned by this function is owned by you. Please call 106 | * SDL_free() on the pointer when you are done with it, or it will be a 107 | * memory leak. This is not necessarily a fast call, though, so you should 108 | * call this once near startup and save the string if you need it. 109 | * 110 | * You should assume the path returned by this function is the only safe 111 | * place to write files (and that SDL_GetBasePath(), while it might be 112 | * writable, or even the parent of the returned path, aren't where you 113 | * should be writing things). 114 | * 115 | * Some platforms can't determine the pref path, and on other 116 | * platforms, this might be meaningless. In such cases, this function will 117 | * return NULL. 118 | * 119 | * \param org The name of your organization. 120 | * \param app The name of your application. 121 | * \return UTF-8 string of user dir in platform-dependent notation. NULL 122 | * if there's a problem (creating directory failed, etc). 123 | * 124 | * \sa SDL_GetBasePath 125 | */ 126 | extern DECLSPEC char *SDLCALL SDL_GetPrefPath(const char *org, const char *app); 127 | 128 | /* Ends C function definitions when using C++ */ 129 | #ifdef __cplusplus 130 | } 131 | #endif 132 | #include "close_code.h" 133 | 134 | #endif /* SDL_filesystem_h_ */ 135 | 136 | /* vi: set ts=4 sw=4 expandtab: */ 137 | -------------------------------------------------------------------------------- /include/SDL2/SDL_gesture.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_gesture.h 24 | * 25 | * Include file for SDL gesture event handling. 26 | */ 27 | 28 | #ifndef SDL_gesture_h_ 29 | #define SDL_gesture_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | #include "SDL_video.h" 34 | 35 | #include "SDL_touch.h" 36 | 37 | 38 | #include "begin_code.h" 39 | /* Set up for C function definitions, even when using C++ */ 40 | #ifdef __cplusplus 41 | extern "C" { 42 | #endif 43 | 44 | typedef Sint64 SDL_GestureID; 45 | 46 | /* Function prototypes */ 47 | 48 | /** 49 | * \brief Begin Recording a gesture on the specified touch, or all touches (-1) 50 | * 51 | * 52 | */ 53 | extern DECLSPEC int SDLCALL SDL_RecordGesture(SDL_TouchID touchId); 54 | 55 | 56 | /** 57 | * \brief Save all currently loaded Dollar Gesture templates 58 | * 59 | * 60 | */ 61 | extern DECLSPEC int SDLCALL SDL_SaveAllDollarTemplates(SDL_RWops *dst); 62 | 63 | /** 64 | * \brief Save a currently loaded Dollar Gesture template 65 | * 66 | * 67 | */ 68 | extern DECLSPEC int SDLCALL SDL_SaveDollarTemplate(SDL_GestureID gestureId,SDL_RWops *dst); 69 | 70 | 71 | /** 72 | * \brief Load Dollar Gesture templates from a file 73 | * 74 | * 75 | */ 76 | extern DECLSPEC int SDLCALL SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src); 77 | 78 | 79 | /* Ends C function definitions when using C++ */ 80 | #ifdef __cplusplus 81 | } 82 | #endif 83 | #include "close_code.h" 84 | 85 | #endif /* SDL_gesture_h_ */ 86 | 87 | /* vi: set ts=4 sw=4 expandtab: */ 88 | -------------------------------------------------------------------------------- /include/SDL2/SDL_keyboard.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_keyboard.h 24 | * 25 | * Include file for SDL keyboard event handling 26 | */ 27 | 28 | #ifndef SDL_keyboard_h_ 29 | #define SDL_keyboard_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | #include "SDL_keycode.h" 34 | #include "SDL_video.h" 35 | 36 | #include "begin_code.h" 37 | /* Set up for C function definitions, even when using C++ */ 38 | #ifdef __cplusplus 39 | extern "C" { 40 | #endif 41 | 42 | /** 43 | * \brief The SDL keysym structure, used in key events. 44 | * 45 | * \note If you are looking for translated character input, see the ::SDL_TEXTINPUT event. 46 | */ 47 | typedef struct SDL_Keysym 48 | { 49 | SDL_Scancode scancode; /**< SDL physical key code - see ::SDL_Scancode for details */ 50 | SDL_Keycode sym; /**< SDL virtual key code - see ::SDL_Keycode for details */ 51 | Uint16 mod; /**< current key modifiers */ 52 | Uint32 unused; 53 | } SDL_Keysym; 54 | 55 | /* Function prototypes */ 56 | 57 | /** 58 | * \brief Get the window which currently has keyboard focus. 59 | */ 60 | extern DECLSPEC SDL_Window * SDLCALL SDL_GetKeyboardFocus(void); 61 | 62 | /** 63 | * \brief Get a snapshot of the current state of the keyboard. 64 | * 65 | * \param numkeys if non-NULL, receives the length of the returned array. 66 | * 67 | * \return An array of key states. Indexes into this array are obtained by using ::SDL_Scancode values. 68 | * 69 | * \b Example: 70 | * \code 71 | * const Uint8 *state = SDL_GetKeyboardState(NULL); 72 | * if ( state[SDL_SCANCODE_RETURN] ) { 73 | * printf(" is pressed.\n"); 74 | * } 75 | * \endcode 76 | */ 77 | extern DECLSPEC const Uint8 *SDLCALL SDL_GetKeyboardState(int *numkeys); 78 | 79 | /** 80 | * \brief Get the current key modifier state for the keyboard. 81 | */ 82 | extern DECLSPEC SDL_Keymod SDLCALL SDL_GetModState(void); 83 | 84 | /** 85 | * \brief Set the current key modifier state for the keyboard. 86 | * 87 | * \note This does not change the keyboard state, only the key modifier flags. 88 | */ 89 | extern DECLSPEC void SDLCALL SDL_SetModState(SDL_Keymod modstate); 90 | 91 | /** 92 | * \brief Get the key code corresponding to the given scancode according 93 | * to the current keyboard layout. 94 | * 95 | * See ::SDL_Keycode for details. 96 | * 97 | * \sa SDL_GetKeyName() 98 | */ 99 | extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromScancode(SDL_Scancode scancode); 100 | 101 | /** 102 | * \brief Get the scancode corresponding to the given key code according to the 103 | * current keyboard layout. 104 | * 105 | * See ::SDL_Scancode for details. 106 | * 107 | * \sa SDL_GetScancodeName() 108 | */ 109 | extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromKey(SDL_Keycode key); 110 | 111 | /** 112 | * \brief Get a human-readable name for a scancode. 113 | * 114 | * \return A pointer to the name for the scancode. 115 | * If the scancode doesn't have a name, this function returns 116 | * an empty string (""). 117 | * 118 | * \sa SDL_Scancode 119 | */ 120 | extern DECLSPEC const char *SDLCALL SDL_GetScancodeName(SDL_Scancode scancode); 121 | 122 | /** 123 | * \brief Get a scancode from a human-readable name 124 | * 125 | * \return scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized 126 | * 127 | * \sa SDL_Scancode 128 | */ 129 | extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromName(const char *name); 130 | 131 | /** 132 | * \brief Get a human-readable name for a key. 133 | * 134 | * \return A pointer to a UTF-8 string that stays valid at least until the next 135 | * call to this function. If you need it around any longer, you must 136 | * copy it. If the key doesn't have a name, this function returns an 137 | * empty string (""). 138 | * 139 | * \sa SDL_Keycode 140 | */ 141 | extern DECLSPEC const char *SDLCALL SDL_GetKeyName(SDL_Keycode key); 142 | 143 | /** 144 | * \brief Get a key code from a human-readable name 145 | * 146 | * \return key code, or SDLK_UNKNOWN if the name wasn't recognized 147 | * 148 | * \sa SDL_Keycode 149 | */ 150 | extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromName(const char *name); 151 | 152 | /** 153 | * \brief Start accepting Unicode text input events. 154 | * This function will show the on-screen keyboard if supported. 155 | * 156 | * \sa SDL_StopTextInput() 157 | * \sa SDL_SetTextInputRect() 158 | * \sa SDL_HasScreenKeyboardSupport() 159 | */ 160 | extern DECLSPEC void SDLCALL SDL_StartTextInput(void); 161 | 162 | /** 163 | * \brief Return whether or not Unicode text input events are enabled. 164 | * 165 | * \sa SDL_StartTextInput() 166 | * \sa SDL_StopTextInput() 167 | */ 168 | extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputActive(void); 169 | 170 | /** 171 | * \brief Stop receiving any text input events. 172 | * This function will hide the on-screen keyboard if supported. 173 | * 174 | * \sa SDL_StartTextInput() 175 | * \sa SDL_HasScreenKeyboardSupport() 176 | */ 177 | extern DECLSPEC void SDLCALL SDL_StopTextInput(void); 178 | 179 | /** 180 | * \brief Set the rectangle used to type Unicode text inputs. 181 | * This is used as a hint for IME and on-screen keyboard placement. 182 | * 183 | * \sa SDL_StartTextInput() 184 | */ 185 | extern DECLSPEC void SDLCALL SDL_SetTextInputRect(SDL_Rect *rect); 186 | 187 | /** 188 | * \brief Returns whether the platform has some screen keyboard support. 189 | * 190 | * \return SDL_TRUE if some keyboard support is available else SDL_FALSE. 191 | * 192 | * \note Not all screen keyboard functions are supported on all platforms. 193 | * 194 | * \sa SDL_IsScreenKeyboardShown() 195 | */ 196 | extern DECLSPEC SDL_bool SDLCALL SDL_HasScreenKeyboardSupport(void); 197 | 198 | /** 199 | * \brief Returns whether the screen keyboard is shown for given window. 200 | * 201 | * \param window The window for which screen keyboard should be queried. 202 | * 203 | * \return SDL_TRUE if screen keyboard is shown else SDL_FALSE. 204 | * 205 | * \sa SDL_HasScreenKeyboardSupport() 206 | */ 207 | extern DECLSPEC SDL_bool SDLCALL SDL_IsScreenKeyboardShown(SDL_Window *window); 208 | 209 | /* Ends C function definitions when using C++ */ 210 | #ifdef __cplusplus 211 | } 212 | #endif 213 | #include "close_code.h" 214 | 215 | #endif /* SDL_keyboard_h_ */ 216 | 217 | /* vi: set ts=4 sw=4 expandtab: */ 218 | -------------------------------------------------------------------------------- /include/SDL2/SDL_loadso.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_loadso.h 24 | * 25 | * System dependent library loading routines 26 | * 27 | * Some things to keep in mind: 28 | * \li These functions only work on C function names. Other languages may 29 | * have name mangling and intrinsic language support that varies from 30 | * compiler to compiler. 31 | * \li Make sure you declare your function pointers with the same calling 32 | * convention as the actual library function. Your code will crash 33 | * mysteriously if you do not do this. 34 | * \li Avoid namespace collisions. If you load a symbol from the library, 35 | * it is not defined whether or not it goes into the global symbol 36 | * namespace for the application. If it does and it conflicts with 37 | * symbols in your code or other shared libraries, you will not get 38 | * the results you expect. :) 39 | */ 40 | 41 | #ifndef SDL_loadso_h_ 42 | #define SDL_loadso_h_ 43 | 44 | #include "SDL_stdinc.h" 45 | #include "SDL_error.h" 46 | 47 | #include "begin_code.h" 48 | /* Set up for C function definitions, even when using C++ */ 49 | #ifdef __cplusplus 50 | extern "C" { 51 | #endif 52 | 53 | /** 54 | * This function dynamically loads a shared object and returns a pointer 55 | * to the object handle (or NULL if there was an error). 56 | * The 'sofile' parameter is a system dependent name of the object file. 57 | */ 58 | extern DECLSPEC void *SDLCALL SDL_LoadObject(const char *sofile); 59 | 60 | /** 61 | * Given an object handle, this function looks up the address of the 62 | * named function in the shared object and returns it. This address 63 | * is no longer valid after calling SDL_UnloadObject(). 64 | */ 65 | extern DECLSPEC void *SDLCALL SDL_LoadFunction(void *handle, 66 | const char *name); 67 | 68 | /** 69 | * Unload a shared object from memory. 70 | */ 71 | extern DECLSPEC void SDLCALL SDL_UnloadObject(void *handle); 72 | 73 | /* Ends C function definitions when using C++ */ 74 | #ifdef __cplusplus 75 | } 76 | #endif 77 | #include "close_code.h" 78 | 79 | #endif /* SDL_loadso_h_ */ 80 | 81 | /* vi: set ts=4 sw=4 expandtab: */ 82 | -------------------------------------------------------------------------------- /include/SDL2/SDL_log.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_log.h 24 | * 25 | * Simple log messages with categories and priorities. 26 | * 27 | * By default logs are quiet, but if you're debugging SDL you might want: 28 | * 29 | * SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN); 30 | * 31 | * Here's where the messages go on different platforms: 32 | * Windows: debug output stream 33 | * Android: log output 34 | * Others: standard error output (stderr) 35 | */ 36 | 37 | #ifndef SDL_log_h_ 38 | #define SDL_log_h_ 39 | 40 | #include "SDL_stdinc.h" 41 | 42 | #include "begin_code.h" 43 | /* Set up for C function definitions, even when using C++ */ 44 | #ifdef __cplusplus 45 | extern "C" { 46 | #endif 47 | 48 | 49 | /** 50 | * \brief The maximum size of a log message 51 | * 52 | * Messages longer than the maximum size will be truncated 53 | */ 54 | #define SDL_MAX_LOG_MESSAGE 4096 55 | 56 | /** 57 | * \brief The predefined log categories 58 | * 59 | * By default the application category is enabled at the INFO level, 60 | * the assert category is enabled at the WARN level, test is enabled 61 | * at the VERBOSE level and all other categories are enabled at the 62 | * CRITICAL level. 63 | */ 64 | enum 65 | { 66 | SDL_LOG_CATEGORY_APPLICATION, 67 | SDL_LOG_CATEGORY_ERROR, 68 | SDL_LOG_CATEGORY_ASSERT, 69 | SDL_LOG_CATEGORY_SYSTEM, 70 | SDL_LOG_CATEGORY_AUDIO, 71 | SDL_LOG_CATEGORY_VIDEO, 72 | SDL_LOG_CATEGORY_RENDER, 73 | SDL_LOG_CATEGORY_INPUT, 74 | SDL_LOG_CATEGORY_TEST, 75 | 76 | /* Reserved for future SDL library use */ 77 | SDL_LOG_CATEGORY_RESERVED1, 78 | SDL_LOG_CATEGORY_RESERVED2, 79 | SDL_LOG_CATEGORY_RESERVED3, 80 | SDL_LOG_CATEGORY_RESERVED4, 81 | SDL_LOG_CATEGORY_RESERVED5, 82 | SDL_LOG_CATEGORY_RESERVED6, 83 | SDL_LOG_CATEGORY_RESERVED7, 84 | SDL_LOG_CATEGORY_RESERVED8, 85 | SDL_LOG_CATEGORY_RESERVED9, 86 | SDL_LOG_CATEGORY_RESERVED10, 87 | 88 | /* Beyond this point is reserved for application use, e.g. 89 | enum { 90 | MYAPP_CATEGORY_AWESOME1 = SDL_LOG_CATEGORY_CUSTOM, 91 | MYAPP_CATEGORY_AWESOME2, 92 | MYAPP_CATEGORY_AWESOME3, 93 | ... 94 | }; 95 | */ 96 | SDL_LOG_CATEGORY_CUSTOM 97 | }; 98 | 99 | /** 100 | * \brief The predefined log priorities 101 | */ 102 | typedef enum 103 | { 104 | SDL_LOG_PRIORITY_VERBOSE = 1, 105 | SDL_LOG_PRIORITY_DEBUG, 106 | SDL_LOG_PRIORITY_INFO, 107 | SDL_LOG_PRIORITY_WARN, 108 | SDL_LOG_PRIORITY_ERROR, 109 | SDL_LOG_PRIORITY_CRITICAL, 110 | SDL_NUM_LOG_PRIORITIES 111 | } SDL_LogPriority; 112 | 113 | 114 | /** 115 | * \brief Set the priority of all log categories 116 | */ 117 | extern DECLSPEC void SDLCALL SDL_LogSetAllPriority(SDL_LogPriority priority); 118 | 119 | /** 120 | * \brief Set the priority of a particular log category 121 | */ 122 | extern DECLSPEC void SDLCALL SDL_LogSetPriority(int category, 123 | SDL_LogPriority priority); 124 | 125 | /** 126 | * \brief Get the priority of a particular log category 127 | */ 128 | extern DECLSPEC SDL_LogPriority SDLCALL SDL_LogGetPriority(int category); 129 | 130 | /** 131 | * \brief Reset all priorities to default. 132 | * 133 | * \note This is called in SDL_Quit(). 134 | */ 135 | extern DECLSPEC void SDLCALL SDL_LogResetPriorities(void); 136 | 137 | /** 138 | * \brief Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO 139 | */ 140 | extern DECLSPEC void SDLCALL SDL_Log(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1); 141 | 142 | /** 143 | * \brief Log a message with SDL_LOG_PRIORITY_VERBOSE 144 | */ 145 | extern DECLSPEC void SDLCALL SDL_LogVerbose(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 146 | 147 | /** 148 | * \brief Log a message with SDL_LOG_PRIORITY_DEBUG 149 | */ 150 | extern DECLSPEC void SDLCALL SDL_LogDebug(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 151 | 152 | /** 153 | * \brief Log a message with SDL_LOG_PRIORITY_INFO 154 | */ 155 | extern DECLSPEC void SDLCALL SDL_LogInfo(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 156 | 157 | /** 158 | * \brief Log a message with SDL_LOG_PRIORITY_WARN 159 | */ 160 | extern DECLSPEC void SDLCALL SDL_LogWarn(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 161 | 162 | /** 163 | * \brief Log a message with SDL_LOG_PRIORITY_ERROR 164 | */ 165 | extern DECLSPEC void SDLCALL SDL_LogError(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 166 | 167 | /** 168 | * \brief Log a message with SDL_LOG_PRIORITY_CRITICAL 169 | */ 170 | extern DECLSPEC void SDLCALL SDL_LogCritical(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 171 | 172 | /** 173 | * \brief Log a message with the specified category and priority. 174 | */ 175 | extern DECLSPEC void SDLCALL SDL_LogMessage(int category, 176 | SDL_LogPriority priority, 177 | SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(3); 178 | 179 | /** 180 | * \brief Log a message with the specified category and priority. 181 | */ 182 | extern DECLSPEC void SDLCALL SDL_LogMessageV(int category, 183 | SDL_LogPriority priority, 184 | const char *fmt, va_list ap); 185 | 186 | /** 187 | * \brief The prototype for the log output function 188 | */ 189 | typedef void (SDLCALL *SDL_LogOutputFunction)(void *userdata, int category, SDL_LogPriority priority, const char *message); 190 | 191 | /** 192 | * \brief Get the current log output function. 193 | */ 194 | extern DECLSPEC void SDLCALL SDL_LogGetOutputFunction(SDL_LogOutputFunction *callback, void **userdata); 195 | 196 | /** 197 | * \brief This function allows you to replace the default log output 198 | * function with one of your own. 199 | */ 200 | extern DECLSPEC void SDLCALL SDL_LogSetOutputFunction(SDL_LogOutputFunction callback, void *userdata); 201 | 202 | 203 | /* Ends C function definitions when using C++ */ 204 | #ifdef __cplusplus 205 | } 206 | #endif 207 | #include "close_code.h" 208 | 209 | #endif /* SDL_log_h_ */ 210 | 211 | /* vi: set ts=4 sw=4 expandtab: */ 212 | -------------------------------------------------------------------------------- /include/SDL2/SDL_main.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_main_h_ 23 | #define SDL_main_h_ 24 | 25 | #include "SDL_stdinc.h" 26 | 27 | /** 28 | * \file SDL_main.h 29 | * 30 | * Redefine main() on some platforms so that it is called by SDL. 31 | */ 32 | 33 | #ifndef SDL_MAIN_HANDLED 34 | #if defined(__WIN32__) 35 | /* On Windows SDL provides WinMain(), which parses the command line and passes 36 | the arguments to your main function. 37 | 38 | If you provide your own WinMain(), you may define SDL_MAIN_HANDLED 39 | */ 40 | #define SDL_MAIN_AVAILABLE 41 | 42 | #elif defined(__WINRT__) 43 | /* On WinRT, SDL provides a main function that initializes CoreApplication, 44 | creating an instance of IFrameworkView in the process. 45 | 46 | Please note that #include'ing SDL_main.h is not enough to get a main() 47 | function working. In non-XAML apps, the file, 48 | src/main/winrt/SDL_WinRT_main_NonXAML.cpp, or a copy of it, must be compiled 49 | into the app itself. In XAML apps, the function, SDL_WinRTRunApp must be 50 | called, with a pointer to the Direct3D-hosted XAML control passed in. 51 | */ 52 | #define SDL_MAIN_NEEDED 53 | 54 | #elif defined(__IPHONEOS__) 55 | /* On iOS SDL provides a main function that creates an application delegate 56 | and starts the iOS application run loop. 57 | 58 | If you link with SDL dynamically on iOS, the main function can't be in a 59 | shared library, so you need to link with libSDLmain.a, which includes a 60 | stub main function that calls into the shared library to start execution. 61 | 62 | See src/video/uikit/SDL_uikitappdelegate.m for more details. 63 | */ 64 | #define SDL_MAIN_NEEDED 65 | 66 | #elif defined(__ANDROID__) 67 | /* On Android SDL provides a Java class in SDLActivity.java that is the 68 | main activity entry point. 69 | 70 | See docs/README-android.md for more details on extending that class. 71 | */ 72 | #define SDL_MAIN_NEEDED 73 | 74 | /* We need to export SDL_main so it can be launched from Java */ 75 | #define SDLMAIN_DECLSPEC DECLSPEC 76 | 77 | #elif defined(__NACL__) 78 | /* On NACL we use ppapi_simple to set up the application helper code, 79 | then wait for the first PSE_INSTANCE_DIDCHANGEVIEW event before 80 | starting the user main function. 81 | All user code is run in a separate thread by ppapi_simple, thus 82 | allowing for blocking io to take place via nacl_io 83 | */ 84 | #define SDL_MAIN_NEEDED 85 | 86 | #endif 87 | #endif /* SDL_MAIN_HANDLED */ 88 | 89 | #ifndef SDLMAIN_DECLSPEC 90 | #define SDLMAIN_DECLSPEC 91 | #endif 92 | 93 | /** 94 | * \file SDL_main.h 95 | * 96 | * The application's main() function must be called with C linkage, 97 | * and should be declared like this: 98 | * \code 99 | * #ifdef __cplusplus 100 | * extern "C" 101 | * #endif 102 | * int main(int argc, char *argv[]) 103 | * { 104 | * } 105 | * \endcode 106 | */ 107 | 108 | #if defined(SDL_MAIN_NEEDED) || defined(SDL_MAIN_AVAILABLE) 109 | #define main SDL_main 110 | #endif 111 | 112 | #include "begin_code.h" 113 | #ifdef __cplusplus 114 | extern "C" { 115 | #endif 116 | 117 | /** 118 | * The prototype for the application's main() function 119 | */ 120 | typedef int (*SDL_main_func)(int argc, char *argv[]); 121 | extern SDLMAIN_DECLSPEC int SDL_main(int argc, char *argv[]); 122 | 123 | 124 | /** 125 | * This is called by the real SDL main function to let the rest of the 126 | * library know that initialization was done properly. 127 | * 128 | * Calling this yourself without knowing what you're doing can cause 129 | * crashes and hard to diagnose problems with your application. 130 | */ 131 | extern DECLSPEC void SDLCALL SDL_SetMainReady(void); 132 | 133 | #ifdef __WIN32__ 134 | 135 | /** 136 | * This can be called to set the application class at startup 137 | */ 138 | extern DECLSPEC int SDLCALL SDL_RegisterApp(char *name, Uint32 style, void *hInst); 139 | extern DECLSPEC void SDLCALL SDL_UnregisterApp(void); 140 | 141 | #endif /* __WIN32__ */ 142 | 143 | 144 | #ifdef __WINRT__ 145 | 146 | /** 147 | * \brief Initializes and launches an SDL/WinRT application. 148 | * 149 | * \param mainFunction The SDL app's C-style main(). 150 | * \param reserved Reserved for future use; should be NULL 151 | * \return 0 on success, -1 on failure. On failure, use SDL_GetError to retrieve more 152 | * information on the failure. 153 | */ 154 | extern DECLSPEC int SDLCALL SDL_WinRTRunApp(SDL_main_func mainFunction, void * reserved); 155 | 156 | #endif /* __WINRT__ */ 157 | 158 | #if defined(__IPHONEOS__) 159 | 160 | /** 161 | * \brief Initializes and launches an SDL application. 162 | * 163 | * \param argc The argc parameter from the application's main() function 164 | * \param argv The argv parameter from the application's main() function 165 | * \param mainFunction The SDL app's C-style main(). 166 | * \return the return value from mainFunction 167 | */ 168 | extern DECLSPEC int SDLCALL SDL_UIKitRunApp(int argc, char *argv[], SDL_main_func mainFunction); 169 | 170 | #endif /* __IPHONEOS__ */ 171 | 172 | 173 | #ifdef __cplusplus 174 | } 175 | #endif 176 | #include "close_code.h" 177 | 178 | #endif /* SDL_main_h_ */ 179 | 180 | /* vi: set ts=4 sw=4 expandtab: */ 181 | -------------------------------------------------------------------------------- /include/SDL2/SDL_messagebox.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_messagebox_h_ 23 | #define SDL_messagebox_h_ 24 | 25 | #include "SDL_stdinc.h" 26 | #include "SDL_video.h" /* For SDL_Window */ 27 | 28 | #include "begin_code.h" 29 | /* Set up for C function definitions, even when using C++ */ 30 | #ifdef __cplusplus 31 | extern "C" { 32 | #endif 33 | 34 | /** 35 | * \brief SDL_MessageBox flags. If supported will display warning icon, etc. 36 | */ 37 | typedef enum 38 | { 39 | SDL_MESSAGEBOX_ERROR = 0x00000010, /**< error dialog */ 40 | SDL_MESSAGEBOX_WARNING = 0x00000020, /**< warning dialog */ 41 | SDL_MESSAGEBOX_INFORMATION = 0x00000040 /**< informational dialog */ 42 | } SDL_MessageBoxFlags; 43 | 44 | /** 45 | * \brief Flags for SDL_MessageBoxButtonData. 46 | */ 47 | typedef enum 48 | { 49 | SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 0x00000001, /**< Marks the default button when return is hit */ 50 | SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 0x00000002 /**< Marks the default button when escape is hit */ 51 | } SDL_MessageBoxButtonFlags; 52 | 53 | /** 54 | * \brief Individual button data. 55 | */ 56 | typedef struct 57 | { 58 | Uint32 flags; /**< ::SDL_MessageBoxButtonFlags */ 59 | int buttonid; /**< User defined button id (value returned via SDL_ShowMessageBox) */ 60 | const char * text; /**< The UTF-8 button text */ 61 | } SDL_MessageBoxButtonData; 62 | 63 | /** 64 | * \brief RGB value used in a message box color scheme 65 | */ 66 | typedef struct 67 | { 68 | Uint8 r, g, b; 69 | } SDL_MessageBoxColor; 70 | 71 | typedef enum 72 | { 73 | SDL_MESSAGEBOX_COLOR_BACKGROUND, 74 | SDL_MESSAGEBOX_COLOR_TEXT, 75 | SDL_MESSAGEBOX_COLOR_BUTTON_BORDER, 76 | SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND, 77 | SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED, 78 | SDL_MESSAGEBOX_COLOR_MAX 79 | } SDL_MessageBoxColorType; 80 | 81 | /** 82 | * \brief A set of colors to use for message box dialogs 83 | */ 84 | typedef struct 85 | { 86 | SDL_MessageBoxColor colors[SDL_MESSAGEBOX_COLOR_MAX]; 87 | } SDL_MessageBoxColorScheme; 88 | 89 | /** 90 | * \brief MessageBox structure containing title, text, window, etc. 91 | */ 92 | typedef struct 93 | { 94 | Uint32 flags; /**< ::SDL_MessageBoxFlags */ 95 | SDL_Window *window; /**< Parent window, can be NULL */ 96 | const char *title; /**< UTF-8 title */ 97 | const char *message; /**< UTF-8 message text */ 98 | 99 | int numbuttons; 100 | const SDL_MessageBoxButtonData *buttons; 101 | 102 | const SDL_MessageBoxColorScheme *colorScheme; /**< ::SDL_MessageBoxColorScheme, can be NULL to use system settings */ 103 | } SDL_MessageBoxData; 104 | 105 | /** 106 | * \brief Create a modal message box. 107 | * 108 | * \param messageboxdata The SDL_MessageBoxData structure with title, text, etc. 109 | * \param buttonid The pointer to which user id of hit button should be copied. 110 | * 111 | * \return -1 on error, otherwise 0 and buttonid contains user id of button 112 | * hit or -1 if dialog was closed. 113 | * 114 | * \note This function should be called on the thread that created the parent 115 | * window, or on the main thread if the messagebox has no parent. It will 116 | * block execution of that thread until the user clicks a button or 117 | * closes the messagebox. 118 | */ 119 | extern DECLSPEC int SDLCALL SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid); 120 | 121 | /** 122 | * \brief Create a simple modal message box 123 | * 124 | * \param flags ::SDL_MessageBoxFlags 125 | * \param title UTF-8 title text 126 | * \param message UTF-8 message text 127 | * \param window The parent window, or NULL for no parent 128 | * 129 | * \return 0 on success, -1 on error 130 | * 131 | * \sa SDL_ShowMessageBox 132 | */ 133 | extern DECLSPEC int SDLCALL SDL_ShowSimpleMessageBox(Uint32 flags, const char *title, const char *message, SDL_Window *window); 134 | 135 | 136 | /* Ends C function definitions when using C++ */ 137 | #ifdef __cplusplus 138 | } 139 | #endif 140 | #include "close_code.h" 141 | 142 | #endif /* SDL_messagebox_h_ */ 143 | 144 | /* vi: set ts=4 sw=4 expandtab: */ 145 | -------------------------------------------------------------------------------- /include/SDL2/SDL_mutex.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_mutex_h_ 23 | #define SDL_mutex_h_ 24 | 25 | /** 26 | * \file SDL_mutex.h 27 | * 28 | * Functions to provide thread synchronization primitives. 29 | */ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | 34 | #include "begin_code.h" 35 | /* Set up for C function definitions, even when using C++ */ 36 | #ifdef __cplusplus 37 | extern "C" { 38 | #endif 39 | 40 | /** 41 | * Synchronization functions which can time out return this value 42 | * if they time out. 43 | */ 44 | #define SDL_MUTEX_TIMEDOUT 1 45 | 46 | /** 47 | * This is the timeout value which corresponds to never time out. 48 | */ 49 | #define SDL_MUTEX_MAXWAIT (~(Uint32)0) 50 | 51 | 52 | /** 53 | * \name Mutex functions 54 | */ 55 | /* @{ */ 56 | 57 | /* The SDL mutex structure, defined in SDL_sysmutex.c */ 58 | struct SDL_mutex; 59 | typedef struct SDL_mutex SDL_mutex; 60 | 61 | /** 62 | * Create a mutex, initialized unlocked. 63 | */ 64 | extern DECLSPEC SDL_mutex *SDLCALL SDL_CreateMutex(void); 65 | 66 | /** 67 | * Lock the mutex. 68 | * 69 | * \return 0, or -1 on error. 70 | */ 71 | #define SDL_mutexP(m) SDL_LockMutex(m) 72 | extern DECLSPEC int SDLCALL SDL_LockMutex(SDL_mutex * mutex); 73 | 74 | /** 75 | * Try to lock the mutex 76 | * 77 | * \return 0, SDL_MUTEX_TIMEDOUT, or -1 on error 78 | */ 79 | extern DECLSPEC int SDLCALL SDL_TryLockMutex(SDL_mutex * mutex); 80 | 81 | /** 82 | * Unlock the mutex. 83 | * 84 | * \return 0, or -1 on error. 85 | * 86 | * \warning It is an error to unlock a mutex that has not been locked by 87 | * the current thread, and doing so results in undefined behavior. 88 | */ 89 | #define SDL_mutexV(m) SDL_UnlockMutex(m) 90 | extern DECLSPEC int SDLCALL SDL_UnlockMutex(SDL_mutex * mutex); 91 | 92 | /** 93 | * Destroy a mutex. 94 | */ 95 | extern DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex * mutex); 96 | 97 | /* @} *//* Mutex functions */ 98 | 99 | 100 | /** 101 | * \name Semaphore functions 102 | */ 103 | /* @{ */ 104 | 105 | /* The SDL semaphore structure, defined in SDL_syssem.c */ 106 | struct SDL_semaphore; 107 | typedef struct SDL_semaphore SDL_sem; 108 | 109 | /** 110 | * Create a semaphore, initialized with value, returns NULL on failure. 111 | */ 112 | extern DECLSPEC SDL_sem *SDLCALL SDL_CreateSemaphore(Uint32 initial_value); 113 | 114 | /** 115 | * Destroy a semaphore. 116 | */ 117 | extern DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem * sem); 118 | 119 | /** 120 | * This function suspends the calling thread until the semaphore pointed 121 | * to by \c sem has a positive count. It then atomically decreases the 122 | * semaphore count. 123 | */ 124 | extern DECLSPEC int SDLCALL SDL_SemWait(SDL_sem * sem); 125 | 126 | /** 127 | * Non-blocking variant of SDL_SemWait(). 128 | * 129 | * \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would 130 | * block, and -1 on error. 131 | */ 132 | extern DECLSPEC int SDLCALL SDL_SemTryWait(SDL_sem * sem); 133 | 134 | /** 135 | * Variant of SDL_SemWait() with a timeout in milliseconds. 136 | * 137 | * \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not 138 | * succeed in the allotted time, and -1 on error. 139 | * 140 | * \warning On some platforms this function is implemented by looping with a 141 | * delay of 1 ms, and so should be avoided if possible. 142 | */ 143 | extern DECLSPEC int SDLCALL SDL_SemWaitTimeout(SDL_sem * sem, Uint32 ms); 144 | 145 | /** 146 | * Atomically increases the semaphore's count (not blocking). 147 | * 148 | * \return 0, or -1 on error. 149 | */ 150 | extern DECLSPEC int SDLCALL SDL_SemPost(SDL_sem * sem); 151 | 152 | /** 153 | * Returns the current count of the semaphore. 154 | */ 155 | extern DECLSPEC Uint32 SDLCALL SDL_SemValue(SDL_sem * sem); 156 | 157 | /* @} *//* Semaphore functions */ 158 | 159 | 160 | /** 161 | * \name Condition variable functions 162 | */ 163 | /* @{ */ 164 | 165 | /* The SDL condition variable structure, defined in SDL_syscond.c */ 166 | struct SDL_cond; 167 | typedef struct SDL_cond SDL_cond; 168 | 169 | /** 170 | * Create a condition variable. 171 | * 172 | * Typical use of condition variables: 173 | * 174 | * Thread A: 175 | * SDL_LockMutex(lock); 176 | * while ( ! condition ) { 177 | * SDL_CondWait(cond, lock); 178 | * } 179 | * SDL_UnlockMutex(lock); 180 | * 181 | * Thread B: 182 | * SDL_LockMutex(lock); 183 | * ... 184 | * condition = true; 185 | * ... 186 | * SDL_CondSignal(cond); 187 | * SDL_UnlockMutex(lock); 188 | * 189 | * There is some discussion whether to signal the condition variable 190 | * with the mutex locked or not. There is some potential performance 191 | * benefit to unlocking first on some platforms, but there are some 192 | * potential race conditions depending on how your code is structured. 193 | * 194 | * In general it's safer to signal the condition variable while the 195 | * mutex is locked. 196 | */ 197 | extern DECLSPEC SDL_cond *SDLCALL SDL_CreateCond(void); 198 | 199 | /** 200 | * Destroy a condition variable. 201 | */ 202 | extern DECLSPEC void SDLCALL SDL_DestroyCond(SDL_cond * cond); 203 | 204 | /** 205 | * Restart one of the threads that are waiting on the condition variable. 206 | * 207 | * \return 0 or -1 on error. 208 | */ 209 | extern DECLSPEC int SDLCALL SDL_CondSignal(SDL_cond * cond); 210 | 211 | /** 212 | * Restart all threads that are waiting on the condition variable. 213 | * 214 | * \return 0 or -1 on error. 215 | */ 216 | extern DECLSPEC int SDLCALL SDL_CondBroadcast(SDL_cond * cond); 217 | 218 | /** 219 | * Wait on the condition variable, unlocking the provided mutex. 220 | * 221 | * \warning The mutex must be locked before entering this function! 222 | * 223 | * The mutex is re-locked once the condition variable is signaled. 224 | * 225 | * \return 0 when it is signaled, or -1 on error. 226 | */ 227 | extern DECLSPEC int SDLCALL SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex); 228 | 229 | /** 230 | * Waits for at most \c ms milliseconds, and returns 0 if the condition 231 | * variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not 232 | * signaled in the allotted time, and -1 on error. 233 | * 234 | * \warning On some platforms this function is implemented by looping with a 235 | * delay of 1 ms, and so should be avoided if possible. 236 | */ 237 | extern DECLSPEC int SDLCALL SDL_CondWaitTimeout(SDL_cond * cond, 238 | SDL_mutex * mutex, Uint32 ms); 239 | 240 | /* @} *//* Condition variable functions */ 241 | 242 | 243 | /* Ends C function definitions when using C++ */ 244 | #ifdef __cplusplus 245 | } 246 | #endif 247 | #include "close_code.h" 248 | 249 | #endif /* SDL_mutex_h_ */ 250 | 251 | /* vi: set ts=4 sw=4 expandtab: */ 252 | -------------------------------------------------------------------------------- /include/SDL2/SDL_name.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDLname_h_ 23 | #define SDLname_h_ 24 | 25 | #if defined(__STDC__) || defined(__cplusplus) 26 | #define NeedFunctionPrototypes 1 27 | #endif 28 | 29 | #define SDL_NAME(X) SDL_##X 30 | 31 | #endif /* SDLname_h_ */ 32 | 33 | /* vi: set ts=4 sw=4 expandtab: */ 34 | -------------------------------------------------------------------------------- /include/SDL2/SDL_opengles.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_opengles.h 24 | * 25 | * This is a simple file to encapsulate the OpenGL ES 1.X API headers. 26 | */ 27 | #include "SDL_config.h" 28 | 29 | #ifdef __IPHONEOS__ 30 | #include 31 | #include 32 | #else 33 | #include 34 | #include 35 | #endif 36 | 37 | #ifndef APIENTRY 38 | #define APIENTRY 39 | #endif 40 | -------------------------------------------------------------------------------- /include/SDL2/SDL_opengles2.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_opengles2.h 24 | * 25 | * This is a simple file to encapsulate the OpenGL ES 2.0 API headers. 26 | */ 27 | #include "SDL_config.h" 28 | 29 | #ifndef _MSC_VER 30 | 31 | #ifdef __IPHONEOS__ 32 | #include 33 | #include 34 | #else 35 | #include 36 | #include 37 | #include 38 | #endif 39 | 40 | #else /* _MSC_VER */ 41 | 42 | /* OpenGL ES2 headers for Visual Studio */ 43 | #include "SDL_opengles2_khrplatform.h" 44 | #include "SDL_opengles2_gl2platform.h" 45 | #include "SDL_opengles2_gl2.h" 46 | #include "SDL_opengles2_gl2ext.h" 47 | 48 | #endif /* _MSC_VER */ 49 | 50 | #ifndef APIENTRY 51 | #define APIENTRY GL_APIENTRY 52 | #endif 53 | -------------------------------------------------------------------------------- /include/SDL2/SDL_opengles2_gl2platform.h: -------------------------------------------------------------------------------- 1 | #ifndef __gl2platform_h_ 2 | #define __gl2platform_h_ 3 | 4 | /* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */ 5 | 6 | /* 7 | * This document is licensed under the SGI Free Software B License Version 8 | * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ . 9 | */ 10 | 11 | /* Platform-specific types and definitions for OpenGL ES 2.X gl2.h 12 | * 13 | * Adopters may modify khrplatform.h and this file to suit their platform. 14 | * You are encouraged to submit all modifications to the Khronos group so that 15 | * they can be included in future versions of this file. Please submit changes 16 | * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla) 17 | * by filing a bug against product "OpenGL-ES" component "Registry". 18 | */ 19 | 20 | /*#include */ 21 | 22 | #ifndef GL_APICALL 23 | #define GL_APICALL KHRONOS_APICALL 24 | #endif 25 | 26 | #ifndef GL_APIENTRY 27 | #define GL_APIENTRY KHRONOS_APIENTRY 28 | #endif 29 | 30 | #endif /* __gl2platform_h_ */ 31 | -------------------------------------------------------------------------------- /include/SDL2/SDL_platform.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_platform.h 24 | * 25 | * Try to get a standard set of platform defines. 26 | */ 27 | 28 | #ifndef SDL_platform_h_ 29 | #define SDL_platform_h_ 30 | 31 | #if defined(_AIX) 32 | #undef __AIX__ 33 | #define __AIX__ 1 34 | #endif 35 | #if defined(__HAIKU__) 36 | #undef __HAIKU__ 37 | #define __HAIKU__ 1 38 | #endif 39 | #if defined(bsdi) || defined(__bsdi) || defined(__bsdi__) 40 | #undef __BSDI__ 41 | #define __BSDI__ 1 42 | #endif 43 | #if defined(_arch_dreamcast) 44 | #undef __DREAMCAST__ 45 | #define __DREAMCAST__ 1 46 | #endif 47 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 48 | #undef __FREEBSD__ 49 | #define __FREEBSD__ 1 50 | #endif 51 | #if defined(hpux) || defined(__hpux) || defined(__hpux__) 52 | #undef __HPUX__ 53 | #define __HPUX__ 1 54 | #endif 55 | #if defined(sgi) || defined(__sgi) || defined(__sgi__) || defined(_SGI_SOURCE) 56 | #undef __IRIX__ 57 | #define __IRIX__ 1 58 | #endif 59 | #if (defined(linux) || defined(__linux) || defined(__linux__)) 60 | #undef __LINUX__ 61 | #define __LINUX__ 1 62 | #endif 63 | #if defined(ANDROID) || defined(__ANDROID__) 64 | #undef __ANDROID__ 65 | #undef __LINUX__ /* do we need to do this? */ 66 | #define __ANDROID__ 1 67 | #endif 68 | 69 | #if defined(__APPLE__) 70 | /* lets us know what version of Mac OS X we're compiling on */ 71 | #include "AvailabilityMacros.h" 72 | #include "TargetConditionals.h" 73 | #if TARGET_OS_TV 74 | #undef __TVOS__ 75 | #define __TVOS__ 1 76 | #endif 77 | #if TARGET_OS_IPHONE 78 | /* if compiling for iOS */ 79 | #undef __IPHONEOS__ 80 | #define __IPHONEOS__ 1 81 | #undef __MACOSX__ 82 | #else 83 | /* if not compiling for iOS */ 84 | #undef __MACOSX__ 85 | #define __MACOSX__ 1 86 | #if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 87 | # error SDL for Mac OS X only supports deploying on 10.6 and above. 88 | #endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */ 89 | #endif /* TARGET_OS_IPHONE */ 90 | #endif /* defined(__APPLE__) */ 91 | 92 | #if defined(__NetBSD__) 93 | #undef __NETBSD__ 94 | #define __NETBSD__ 1 95 | #endif 96 | #if defined(__OpenBSD__) 97 | #undef __OPENBSD__ 98 | #define __OPENBSD__ 1 99 | #endif 100 | #if defined(__OS2__) || defined(__EMX__) 101 | #undef __OS2__ 102 | #define __OS2__ 1 103 | #endif 104 | #if defined(osf) || defined(__osf) || defined(__osf__) || defined(_OSF_SOURCE) 105 | #undef __OSF__ 106 | #define __OSF__ 1 107 | #endif 108 | #if defined(__QNXNTO__) 109 | #undef __QNXNTO__ 110 | #define __QNXNTO__ 1 111 | #endif 112 | #if defined(riscos) || defined(__riscos) || defined(__riscos__) 113 | #undef __RISCOS__ 114 | #define __RISCOS__ 1 115 | #endif 116 | #if defined(__sun) && defined(__SVR4) 117 | #undef __SOLARIS__ 118 | #define __SOLARIS__ 1 119 | #endif 120 | 121 | #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) 122 | /* Try to find out if we're compiling for WinRT or non-WinRT */ 123 | #if defined(_MSC_VER) && defined(__has_include) 124 | #if __has_include() 125 | #define HAVE_WINAPIFAMILY_H 1 126 | #else 127 | #define HAVE_WINAPIFAMILY_H 0 128 | #endif 129 | 130 | /* If _USING_V110_SDK71_ is defined it means we are using the Windows XP toolset. */ 131 | #elif defined(_MSC_VER) && (_MSC_VER >= 1700 && !_USING_V110_SDK71_) /* _MSC_VER == 1700 for Visual Studio 2012 */ 132 | #define HAVE_WINAPIFAMILY_H 1 133 | #else 134 | #define HAVE_WINAPIFAMILY_H 0 135 | #endif 136 | 137 | #if HAVE_WINAPIFAMILY_H 138 | #include 139 | #define WINAPI_FAMILY_WINRT (!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)) 140 | #else 141 | #define WINAPI_FAMILY_WINRT 0 142 | #endif /* HAVE_WINAPIFAMILY_H */ 143 | 144 | #if WINAPI_FAMILY_WINRT 145 | #undef __WINRT__ 146 | #define __WINRT__ 1 147 | #else 148 | #undef __WINDOWS__ 149 | #define __WINDOWS__ 1 150 | #endif 151 | #endif /* defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) */ 152 | 153 | #if defined(__WINDOWS__) 154 | #undef __WIN32__ 155 | #define __WIN32__ 1 156 | #endif 157 | #if defined(__PSP__) 158 | #undef __PSP__ 159 | #define __PSP__ 1 160 | #endif 161 | 162 | /* The NACL compiler defines __native_client__ and __pnacl__ 163 | * Ref: http://www.chromium.org/nativeclient/pnacl/stability-of-the-pnacl-bitcode-abi 164 | */ 165 | #if defined(__native_client__) 166 | #undef __LINUX__ 167 | #undef __NACL__ 168 | #define __NACL__ 1 169 | #endif 170 | #if defined(__pnacl__) 171 | #undef __LINUX__ 172 | #undef __PNACL__ 173 | #define __PNACL__ 1 174 | /* PNACL with newlib supports static linking only */ 175 | #define __SDL_NOGETPROCADDR__ 176 | #endif 177 | 178 | 179 | #include "begin_code.h" 180 | /* Set up for C function definitions, even when using C++ */ 181 | #ifdef __cplusplus 182 | extern "C" { 183 | #endif 184 | 185 | /** 186 | * \brief Gets the name of the platform. 187 | */ 188 | extern DECLSPEC const char * SDLCALL SDL_GetPlatform (void); 189 | 190 | /* Ends C function definitions when using C++ */ 191 | #ifdef __cplusplus 192 | } 193 | #endif 194 | #include "close_code.h" 195 | 196 | #endif /* SDL_platform_h_ */ 197 | 198 | /* vi: set ts=4 sw=4 expandtab: */ 199 | -------------------------------------------------------------------------------- /include/SDL2/SDL_power.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_power_h_ 23 | #define SDL_power_h_ 24 | 25 | /** 26 | * \file SDL_power.h 27 | * 28 | * Header for the SDL power management routines. 29 | */ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /** 40 | * \brief The basic state for the system's power supply. 41 | */ 42 | typedef enum 43 | { 44 | SDL_POWERSTATE_UNKNOWN, /**< cannot determine power status */ 45 | SDL_POWERSTATE_ON_BATTERY, /**< Not plugged in, running on the battery */ 46 | SDL_POWERSTATE_NO_BATTERY, /**< Plugged in, no battery available */ 47 | SDL_POWERSTATE_CHARGING, /**< Plugged in, charging battery */ 48 | SDL_POWERSTATE_CHARGED /**< Plugged in, battery charged */ 49 | } SDL_PowerState; 50 | 51 | 52 | /** 53 | * \brief Get the current power supply details. 54 | * 55 | * \param secs Seconds of battery life left. You can pass a NULL here if 56 | * you don't care. Will return -1 if we can't determine a 57 | * value, or we're not running on a battery. 58 | * 59 | * \param pct Percentage of battery life left, between 0 and 100. You can 60 | * pass a NULL here if you don't care. Will return -1 if we 61 | * can't determine a value, or we're not running on a battery. 62 | * 63 | * \return The state of the battery (if any). 64 | */ 65 | extern DECLSPEC SDL_PowerState SDLCALL SDL_GetPowerInfo(int *secs, int *pct); 66 | 67 | /* Ends C function definitions when using C++ */ 68 | #ifdef __cplusplus 69 | } 70 | #endif 71 | #include "close_code.h" 72 | 73 | #endif /* SDL_power_h_ */ 74 | 75 | /* vi: set ts=4 sw=4 expandtab: */ 76 | -------------------------------------------------------------------------------- /include/SDL2/SDL_quit.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_quit.h 24 | * 25 | * Include file for SDL quit event handling. 26 | */ 27 | 28 | #ifndef SDL_quit_h_ 29 | #define SDL_quit_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | 34 | /** 35 | * \file SDL_quit.h 36 | * 37 | * An ::SDL_QUIT event is generated when the user tries to close the application 38 | * window. If it is ignored or filtered out, the window will remain open. 39 | * If it is not ignored or filtered, it is queued normally and the window 40 | * is allowed to close. When the window is closed, screen updates will 41 | * complete, but have no effect. 42 | * 43 | * SDL_Init() installs signal handlers for SIGINT (keyboard interrupt) 44 | * and SIGTERM (system termination request), if handlers do not already 45 | * exist, that generate ::SDL_QUIT events as well. There is no way 46 | * to determine the cause of an ::SDL_QUIT event, but setting a signal 47 | * handler in your application will override the default generation of 48 | * quit events for that signal. 49 | * 50 | * \sa SDL_Quit() 51 | */ 52 | 53 | /* There are no functions directly affecting the quit event */ 54 | 55 | #define SDL_QuitRequested() \ 56 | (SDL_PumpEvents(), (SDL_PeepEvents(NULL,0,SDL_PEEKEVENT,SDL_QUIT,SDL_QUIT) > 0)) 57 | 58 | #endif /* SDL_quit_h_ */ 59 | -------------------------------------------------------------------------------- /include/SDL2/SDL_rect.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_rect.h 24 | * 25 | * Header file for SDL_rect definition and management functions. 26 | */ 27 | 28 | #ifndef SDL_rect_h_ 29 | #define SDL_rect_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | #include "SDL_pixels.h" 34 | #include "SDL_rwops.h" 35 | 36 | #include "begin_code.h" 37 | /* Set up for C function definitions, even when using C++ */ 38 | #ifdef __cplusplus 39 | extern "C" { 40 | #endif 41 | 42 | /** 43 | * \brief The structure that defines a point (integer) 44 | * 45 | * \sa SDL_EnclosePoints 46 | * \sa SDL_PointInRect 47 | */ 48 | typedef struct SDL_Point 49 | { 50 | int x; 51 | int y; 52 | } SDL_Point; 53 | 54 | /** 55 | * \brief The structure that defines a point (floating point) 56 | * 57 | * \sa SDL_EnclosePoints 58 | * \sa SDL_PointInRect 59 | */ 60 | typedef struct SDL_FPoint 61 | { 62 | float x; 63 | float y; 64 | } SDL_FPoint; 65 | 66 | 67 | /** 68 | * \brief A rectangle, with the origin at the upper left (integer). 69 | * 70 | * \sa SDL_RectEmpty 71 | * \sa SDL_RectEquals 72 | * \sa SDL_HasIntersection 73 | * \sa SDL_IntersectRect 74 | * \sa SDL_UnionRect 75 | * \sa SDL_EnclosePoints 76 | */ 77 | typedef struct SDL_Rect 78 | { 79 | int x, y; 80 | int w, h; 81 | } SDL_Rect; 82 | 83 | 84 | /** 85 | * \brief A rectangle, with the origin at the upper left (floating point). 86 | */ 87 | typedef struct SDL_FRect 88 | { 89 | float x; 90 | float y; 91 | float w; 92 | float h; 93 | } SDL_FRect; 94 | 95 | 96 | /** 97 | * \brief Returns true if point resides inside a rectangle. 98 | */ 99 | SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r) 100 | { 101 | return ( (p->x >= r->x) && (p->x < (r->x + r->w)) && 102 | (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE; 103 | } 104 | 105 | /** 106 | * \brief Returns true if the rectangle has no area. 107 | */ 108 | SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r) 109 | { 110 | return ((!r) || (r->w <= 0) || (r->h <= 0)) ? SDL_TRUE : SDL_FALSE; 111 | } 112 | 113 | /** 114 | * \brief Returns true if the two rectangles are equal. 115 | */ 116 | SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b) 117 | { 118 | return (a && b && (a->x == b->x) && (a->y == b->y) && 119 | (a->w == b->w) && (a->h == b->h)) ? SDL_TRUE : SDL_FALSE; 120 | } 121 | 122 | /** 123 | * \brief Determine whether two rectangles intersect. 124 | * 125 | * \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise. 126 | */ 127 | extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersection(const SDL_Rect * A, 128 | const SDL_Rect * B); 129 | 130 | /** 131 | * \brief Calculate the intersection of two rectangles. 132 | * 133 | * \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise. 134 | */ 135 | extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRect(const SDL_Rect * A, 136 | const SDL_Rect * B, 137 | SDL_Rect * result); 138 | 139 | /** 140 | * \brief Calculate the union of two rectangles. 141 | */ 142 | extern DECLSPEC void SDLCALL SDL_UnionRect(const SDL_Rect * A, 143 | const SDL_Rect * B, 144 | SDL_Rect * result); 145 | 146 | /** 147 | * \brief Calculate a minimal rectangle enclosing a set of points 148 | * 149 | * \return SDL_TRUE if any points were within the clipping rect 150 | */ 151 | extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points, 152 | int count, 153 | const SDL_Rect * clip, 154 | SDL_Rect * result); 155 | 156 | /** 157 | * \brief Calculate the intersection of a rectangle and line segment. 158 | * 159 | * \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise. 160 | */ 161 | extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect * 162 | rect, int *X1, 163 | int *Y1, int *X2, 164 | int *Y2); 165 | 166 | /* Ends C function definitions when using C++ */ 167 | #ifdef __cplusplus 168 | } 169 | #endif 170 | #include "close_code.h" 171 | 172 | #endif /* SDL_rect_h_ */ 173 | 174 | /* vi: set ts=4 sw=4 expandtab: */ 175 | -------------------------------------------------------------------------------- /include/SDL2/SDL_revision.h: -------------------------------------------------------------------------------- 1 | #define SDL_REVISION "hg-12952:bc90ce38f1e2" 2 | #define SDL_REVISION_NUMBER 12952 3 | -------------------------------------------------------------------------------- /include/SDL2/SDL_sensor.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_sensor.h 24 | * 25 | * Include file for SDL sensor event handling 26 | * 27 | */ 28 | 29 | #ifndef SDL_sensor_h_ 30 | #define SDL_sensor_h_ 31 | 32 | #include "SDL_stdinc.h" 33 | #include "SDL_error.h" 34 | 35 | #include "begin_code.h" 36 | /* Set up for C function definitions, even when using C++ */ 37 | #ifdef __cplusplus 38 | /* *INDENT-OFF* */ 39 | extern "C" { 40 | /* *INDENT-ON* */ 41 | #endif 42 | 43 | /** 44 | * \brief SDL_sensor.h 45 | * 46 | * In order to use these functions, SDL_Init() must have been called 47 | * with the ::SDL_INIT_SENSOR flag. This causes SDL to scan the system 48 | * for sensors, and load appropriate drivers. 49 | */ 50 | 51 | struct _SDL_Sensor; 52 | typedef struct _SDL_Sensor SDL_Sensor; 53 | 54 | /** 55 | * This is a unique ID for a sensor for the time it is connected to the system, 56 | * and is never reused for the lifetime of the application. 57 | * 58 | * The ID value starts at 0 and increments from there. The value -1 is an invalid ID. 59 | */ 60 | typedef Sint32 SDL_SensorID; 61 | 62 | /* The different sensors defined by SDL 63 | * 64 | * Additional sensors may be available, using platform dependent semantics. 65 | * 66 | * Hare are the additional Android sensors: 67 | * https://developer.android.com/reference/android/hardware/SensorEvent.html#values 68 | */ 69 | typedef enum 70 | { 71 | SDL_SENSOR_INVALID = -1, /**< Returned for an invalid sensor */ 72 | SDL_SENSOR_UNKNOWN, /**< Unknown sensor type */ 73 | SDL_SENSOR_ACCEL, /**< Accelerometer */ 74 | SDL_SENSOR_GYRO /**< Gyroscope */ 75 | } SDL_SensorType; 76 | 77 | /** 78 | * Accelerometer sensor 79 | * 80 | * The accelerometer returns the current acceleration in SI meters per 81 | * second squared. This includes gravity, so a device at rest will have 82 | * an acceleration of SDL_STANDARD_GRAVITY straight down. 83 | * 84 | * values[0]: Acceleration on the x axis 85 | * values[1]: Acceleration on the y axis 86 | * values[2]: Acceleration on the z axis 87 | * 88 | * For phones held in portrait mode, the axes are defined as follows: 89 | * -X ... +X : left ... right 90 | * -Y ... +Y : bottom ... top 91 | * -Z ... +Z : farther ... closer 92 | * 93 | * The axis data is not changed when the phone is rotated. 94 | * 95 | * \sa SDL_GetDisplayOrientation() 96 | */ 97 | #define SDL_STANDARD_GRAVITY 9.80665f 98 | 99 | /** 100 | * Gyroscope sensor 101 | * 102 | * The gyroscope returns the current rate of rotation in radians per second. 103 | * The rotation is positive in the counter-clockwise direction. That is, 104 | * an observer looking from a positive location on one of the axes would 105 | * see positive rotation on that axis when it appeared to be rotating 106 | * counter-clockwise. 107 | * 108 | * values[0]: Angular speed around the x axis 109 | * values[1]: Angular speed around the y axis 110 | * values[2]: Angular speed around the z axis 111 | * 112 | * For phones held in portrait mode, the axes are defined as follows: 113 | * -X ... +X : left ... right 114 | * -Y ... +Y : bottom ... top 115 | * -Z ... +Z : farther ... closer 116 | * 117 | * The axis data is not changed when the phone is rotated. 118 | * 119 | * \sa SDL_GetDisplayOrientation() 120 | */ 121 | 122 | /* Function prototypes */ 123 | 124 | /** 125 | * \brief Count the number of sensors attached to the system right now 126 | */ 127 | extern DECLSPEC int SDLCALL SDL_NumSensors(void); 128 | 129 | /** 130 | * \brief Get the implementation dependent name of a sensor. 131 | * 132 | * This can be called before any sensors are opened. 133 | * 134 | * \return The sensor name, or NULL if device_index is out of range. 135 | */ 136 | extern DECLSPEC const char *SDLCALL SDL_SensorGetDeviceName(int device_index); 137 | 138 | /** 139 | * \brief Get the type of a sensor. 140 | * 141 | * This can be called before any sensors are opened. 142 | * 143 | * \return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range. 144 | */ 145 | extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetDeviceType(int device_index); 146 | 147 | /** 148 | * \brief Get the platform dependent type of a sensor. 149 | * 150 | * This can be called before any sensors are opened. 151 | * 152 | * \return The sensor platform dependent type, or -1 if device_index is out of range. 153 | */ 154 | extern DECLSPEC int SDLCALL SDL_SensorGetDeviceNonPortableType(int device_index); 155 | 156 | /** 157 | * \brief Get the instance ID of a sensor. 158 | * 159 | * This can be called before any sensors are opened. 160 | * 161 | * \return The sensor instance ID, or -1 if device_index is out of range. 162 | */ 163 | extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetDeviceInstanceID(int device_index); 164 | 165 | /** 166 | * \brief Open a sensor for use. 167 | * 168 | * The index passed as an argument refers to the N'th sensor on the system. 169 | * 170 | * \return A sensor identifier, or NULL if an error occurred. 171 | */ 172 | extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorOpen(int device_index); 173 | 174 | /** 175 | * Return the SDL_Sensor associated with an instance id. 176 | */ 177 | extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorFromInstanceID(SDL_SensorID instance_id); 178 | 179 | /** 180 | * \brief Get the implementation dependent name of a sensor. 181 | * 182 | * \return The sensor name, or NULL if the sensor is NULL. 183 | */ 184 | extern DECLSPEC const char *SDLCALL SDL_SensorGetName(SDL_Sensor *sensor); 185 | 186 | /** 187 | * \brief Get the type of a sensor. 188 | * 189 | * This can be called before any sensors are opened. 190 | * 191 | * \return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL. 192 | */ 193 | extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetType(SDL_Sensor *sensor); 194 | 195 | /** 196 | * \brief Get the platform dependent type of a sensor. 197 | * 198 | * This can be called before any sensors are opened. 199 | * 200 | * \return The sensor platform dependent type, or -1 if the sensor is NULL. 201 | */ 202 | extern DECLSPEC int SDLCALL SDL_SensorGetNonPortableType(SDL_Sensor *sensor); 203 | 204 | /** 205 | * \brief Get the instance ID of a sensor. 206 | * 207 | * This can be called before any sensors are opened. 208 | * 209 | * \return The sensor instance ID, or -1 if the sensor is NULL. 210 | */ 211 | extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetInstanceID(SDL_Sensor *sensor); 212 | 213 | /** 214 | * Get the current state of an opened sensor. 215 | * 216 | * The number of values and interpretation of the data is sensor dependent. 217 | * 218 | * \param sensor The sensor to query 219 | * \param data A pointer filled with the current sensor state 220 | * \param num_values The number of values to write to data 221 | * 222 | * \return 0 or -1 if an error occurred. 223 | */ 224 | extern DECLSPEC int SDLCALL SDL_SensorGetData(SDL_Sensor * sensor, float *data, int num_values); 225 | 226 | /** 227 | * Close a sensor previously opened with SDL_SensorOpen() 228 | */ 229 | extern DECLSPEC void SDLCALL SDL_SensorClose(SDL_Sensor * sensor); 230 | 231 | /** 232 | * Update the current state of the open sensors. 233 | * 234 | * This is called automatically by the event loop if sensor events are enabled. 235 | * 236 | * This needs to be called from the thread that initialized the sensor subsystem. 237 | */ 238 | extern DECLSPEC void SDLCALL SDL_SensorUpdate(void); 239 | 240 | 241 | /* Ends C function definitions when using C++ */ 242 | #ifdef __cplusplus 243 | /* *INDENT-OFF* */ 244 | } 245 | /* *INDENT-ON* */ 246 | #endif 247 | #include "close_code.h" 248 | 249 | #endif /* SDL_sensor_h_ */ 250 | 251 | /* vi: set ts=4 sw=4 expandtab: */ 252 | -------------------------------------------------------------------------------- /include/SDL2/SDL_shape.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_shape_h_ 23 | #define SDL_shape_h_ 24 | 25 | #include "SDL_stdinc.h" 26 | #include "SDL_pixels.h" 27 | #include "SDL_rect.h" 28 | #include "SDL_surface.h" 29 | #include "SDL_video.h" 30 | 31 | #include "begin_code.h" 32 | /* Set up for C function definitions, even when using C++ */ 33 | #ifdef __cplusplus 34 | extern "C" { 35 | #endif 36 | 37 | /** \file SDL_shape.h 38 | * 39 | * Header file for the shaped window API. 40 | */ 41 | 42 | #define SDL_NONSHAPEABLE_WINDOW -1 43 | #define SDL_INVALID_SHAPE_ARGUMENT -2 44 | #define SDL_WINDOW_LACKS_SHAPE -3 45 | 46 | /** 47 | * \brief Create a window that can be shaped with the specified position, dimensions, and flags. 48 | * 49 | * \param title The title of the window, in UTF-8 encoding. 50 | * \param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or 51 | * ::SDL_WINDOWPOS_UNDEFINED. 52 | * \param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or 53 | * ::SDL_WINDOWPOS_UNDEFINED. 54 | * \param w The width of the window. 55 | * \param h The height of the window. 56 | * \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following: 57 | * ::SDL_WINDOW_OPENGL, ::SDL_WINDOW_INPUT_GRABBED, 58 | * ::SDL_WINDOW_HIDDEN, ::SDL_WINDOW_RESIZABLE, 59 | * ::SDL_WINDOW_MAXIMIZED, ::SDL_WINDOW_MINIMIZED, 60 | * ::SDL_WINDOW_BORDERLESS is always set, and ::SDL_WINDOW_FULLSCREEN is always unset. 61 | * 62 | * \return The window created, or NULL if window creation failed. 63 | * 64 | * \sa SDL_DestroyWindow() 65 | */ 66 | extern DECLSPEC SDL_Window * SDLCALL SDL_CreateShapedWindow(const char *title,unsigned int x,unsigned int y,unsigned int w,unsigned int h,Uint32 flags); 67 | 68 | /** 69 | * \brief Return whether the given window is a shaped window. 70 | * 71 | * \param window The window to query for being shaped. 72 | * 73 | * \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL. 74 | * 75 | * \sa SDL_CreateShapedWindow 76 | */ 77 | extern DECLSPEC SDL_bool SDLCALL SDL_IsShapedWindow(const SDL_Window *window); 78 | 79 | /** \brief An enum denoting the specific type of contents present in an SDL_WindowShapeParams union. */ 80 | typedef enum { 81 | /** \brief The default mode, a binarized alpha cutoff of 1. */ 82 | ShapeModeDefault, 83 | /** \brief A binarized alpha cutoff with a given integer value. */ 84 | ShapeModeBinarizeAlpha, 85 | /** \brief A binarized alpha cutoff with a given integer value, but with the opposite comparison. */ 86 | ShapeModeReverseBinarizeAlpha, 87 | /** \brief A color key is applied. */ 88 | ShapeModeColorKey 89 | } WindowShapeMode; 90 | 91 | #define SDL_SHAPEMODEALPHA(mode) (mode == ShapeModeDefault || mode == ShapeModeBinarizeAlpha || mode == ShapeModeReverseBinarizeAlpha) 92 | 93 | /** \brief A union containing parameters for shaped windows. */ 94 | typedef union { 95 | /** \brief A cutoff alpha value for binarization of the window shape's alpha channel. */ 96 | Uint8 binarizationCutoff; 97 | SDL_Color colorKey; 98 | } SDL_WindowShapeParams; 99 | 100 | /** \brief A struct that tags the SDL_WindowShapeParams union with an enum describing the type of its contents. */ 101 | typedef struct SDL_WindowShapeMode { 102 | /** \brief The mode of these window-shape parameters. */ 103 | WindowShapeMode mode; 104 | /** \brief Window-shape parameters. */ 105 | SDL_WindowShapeParams parameters; 106 | } SDL_WindowShapeMode; 107 | 108 | /** 109 | * \brief Set the shape and parameters of a shaped window. 110 | * 111 | * \param window The shaped window whose parameters should be set. 112 | * \param shape A surface encoding the desired shape for the window. 113 | * \param shape_mode The parameters to set for the shaped window. 114 | * 115 | * \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW 116 | * if the SDL_Window given does not reference a valid shaped window. 117 | * 118 | * \sa SDL_WindowShapeMode 119 | * \sa SDL_GetShapedWindowMode. 120 | */ 121 | extern DECLSPEC int SDLCALL SDL_SetWindowShape(SDL_Window *window,SDL_Surface *shape,SDL_WindowShapeMode *shape_mode); 122 | 123 | /** 124 | * \brief Get the shape parameters of a shaped window. 125 | * 126 | * \param window The shaped window whose parameters should be retrieved. 127 | * \param shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape. 128 | * 129 | * \return 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode 130 | * data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if 131 | * the SDL_Window given is a shapeable window currently lacking a shape. 132 | * 133 | * \sa SDL_WindowShapeMode 134 | * \sa SDL_SetWindowShape 135 | */ 136 | extern DECLSPEC int SDLCALL SDL_GetShapedWindowMode(SDL_Window *window,SDL_WindowShapeMode *shape_mode); 137 | 138 | /* Ends C function definitions when using C++ */ 139 | #ifdef __cplusplus 140 | } 141 | #endif 142 | #include "close_code.h" 143 | 144 | #endif /* SDL_shape_h_ */ 145 | -------------------------------------------------------------------------------- /include/SDL2/SDL_system.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_system.h 24 | * 25 | * Include file for platform specific SDL API functions 26 | */ 27 | 28 | #ifndef SDL_system_h_ 29 | #define SDL_system_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_keyboard.h" 33 | #include "SDL_render.h" 34 | #include "SDL_video.h" 35 | 36 | #include "begin_code.h" 37 | /* Set up for C function definitions, even when using C++ */ 38 | #ifdef __cplusplus 39 | extern "C" { 40 | #endif 41 | 42 | 43 | /* Platform specific functions for Windows */ 44 | #ifdef __WIN32__ 45 | 46 | /** 47 | \brief Set a function that is called for every windows message, before TranslateMessage() 48 | */ 49 | typedef void (SDLCALL * SDL_WindowsMessageHook)(void *userdata, void *hWnd, unsigned int message, Uint64 wParam, Sint64 lParam); 50 | extern DECLSPEC void SDLCALL SDL_SetWindowsMessageHook(SDL_WindowsMessageHook callback, void *userdata); 51 | 52 | /** 53 | \brief Returns the D3D9 adapter index that matches the specified display index. 54 | 55 | This adapter index can be passed to IDirect3D9::CreateDevice and controls 56 | on which monitor a full screen application will appear. 57 | */ 58 | extern DECLSPEC int SDLCALL SDL_Direct3D9GetAdapterIndex( int displayIndex ); 59 | 60 | typedef struct IDirect3DDevice9 IDirect3DDevice9; 61 | /** 62 | \brief Returns the D3D device associated with a renderer, or NULL if it's not a D3D renderer. 63 | 64 | Once you are done using the device, you should release it to avoid a resource leak. 65 | */ 66 | extern DECLSPEC IDirect3DDevice9* SDLCALL SDL_RenderGetD3D9Device(SDL_Renderer * renderer); 67 | 68 | /** 69 | \brief Returns the DXGI Adapter and Output indices for the specified display index. 70 | 71 | These can be passed to EnumAdapters and EnumOutputs respectively to get the objects 72 | required to create a DX10 or DX11 device and swap chain. 73 | */ 74 | extern DECLSPEC SDL_bool SDLCALL SDL_DXGIGetOutputInfo( int displayIndex, int *adapterIndex, int *outputIndex ); 75 | 76 | #endif /* __WIN32__ */ 77 | 78 | 79 | /* Platform specific functions for Linux */ 80 | #ifdef __LINUX__ 81 | 82 | /** 83 | \brief Sets the UNIX nice value for a thread, using setpriority() if possible, and RealtimeKit if available. 84 | 85 | \return 0 on success, or -1 on error. 86 | */ 87 | extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriority(Sint64 threadID, int priority); 88 | 89 | #endif /* __LINUX__ */ 90 | 91 | /* Platform specific functions for iOS */ 92 | #if defined(__IPHONEOS__) && __IPHONEOS__ 93 | 94 | #define SDL_iOSSetAnimationCallback(window, interval, callback, callbackParam) SDL_iPhoneSetAnimationCallback(window, interval, callback, callbackParam) 95 | extern DECLSPEC int SDLCALL SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (*callback)(void*), void *callbackParam); 96 | 97 | #define SDL_iOSSetEventPump(enabled) SDL_iPhoneSetEventPump(enabled) 98 | extern DECLSPEC void SDLCALL SDL_iPhoneSetEventPump(SDL_bool enabled); 99 | 100 | #endif /* __IPHONEOS__ */ 101 | 102 | 103 | /* Platform specific functions for Android */ 104 | #if defined(__ANDROID__) && __ANDROID__ 105 | 106 | /** 107 | \brief Get the JNI environment for the current thread 108 | 109 | This returns JNIEnv*, but the prototype is void* so we don't need jni.h 110 | */ 111 | extern DECLSPEC void * SDLCALL SDL_AndroidGetJNIEnv(void); 112 | 113 | /** 114 | \brief Get the SDL Activity object for the application 115 | 116 | This returns jobject, but the prototype is void* so we don't need jni.h 117 | The jobject returned by SDL_AndroidGetActivity is a local reference. 118 | It is the caller's responsibility to properly release it 119 | (using env->Push/PopLocalFrame or manually with env->DeleteLocalRef) 120 | */ 121 | extern DECLSPEC void * SDLCALL SDL_AndroidGetActivity(void); 122 | 123 | /** 124 | \brief Return true if the application is running on Android TV 125 | */ 126 | extern DECLSPEC SDL_bool SDLCALL SDL_IsAndroidTV(void); 127 | 128 | /** 129 | \brief Return true if the application is running on a Chromebook 130 | */ 131 | extern DECLSPEC SDL_bool SDLCALL SDL_IsChromebook(void); 132 | 133 | /** 134 | \brief Return true is the application is running on a Samsung DeX docking station 135 | */ 136 | extern DECLSPEC SDL_bool SDLCALL SDL_IsDeXMode(void); 137 | 138 | /** 139 | \brief Trigger the Android system back button behavior. 140 | */ 141 | extern DECLSPEC void SDLCALL SDL_AndroidBackButton(void); 142 | 143 | /** 144 | See the official Android developer guide for more information: 145 | http://developer.android.com/guide/topics/data/data-storage.html 146 | */ 147 | #define SDL_ANDROID_EXTERNAL_STORAGE_READ 0x01 148 | #define SDL_ANDROID_EXTERNAL_STORAGE_WRITE 0x02 149 | 150 | /** 151 | \brief Get the path used for internal storage for this application. 152 | 153 | This path is unique to your application and cannot be written to 154 | by other applications. 155 | */ 156 | extern DECLSPEC const char * SDLCALL SDL_AndroidGetInternalStoragePath(void); 157 | 158 | /** 159 | \brief Get the current state of external storage, a bitmask of these values: 160 | SDL_ANDROID_EXTERNAL_STORAGE_READ 161 | SDL_ANDROID_EXTERNAL_STORAGE_WRITE 162 | 163 | If external storage is currently unavailable, this will return 0. 164 | */ 165 | extern DECLSPEC int SDLCALL SDL_AndroidGetExternalStorageState(void); 166 | 167 | /** 168 | \brief Get the path used for external storage for this application. 169 | 170 | This path is unique to your application, but is public and can be 171 | written to by other applications. 172 | */ 173 | extern DECLSPEC const char * SDLCALL SDL_AndroidGetExternalStoragePath(void); 174 | 175 | #endif /* __ANDROID__ */ 176 | 177 | /* Platform specific functions for WinRT */ 178 | #if defined(__WINRT__) && __WINRT__ 179 | 180 | /** 181 | * \brief WinRT / Windows Phone path types 182 | */ 183 | typedef enum 184 | { 185 | /** \brief The installed app's root directory. 186 | Files here are likely to be read-only. */ 187 | SDL_WINRT_PATH_INSTALLED_LOCATION, 188 | 189 | /** \brief The app's local data store. Files may be written here */ 190 | SDL_WINRT_PATH_LOCAL_FOLDER, 191 | 192 | /** \brief The app's roaming data store. Unsupported on Windows Phone. 193 | Files written here may be copied to other machines via a network 194 | connection. 195 | */ 196 | SDL_WINRT_PATH_ROAMING_FOLDER, 197 | 198 | /** \brief The app's temporary data store. Unsupported on Windows Phone. 199 | Files written here may be deleted at any time. */ 200 | SDL_WINRT_PATH_TEMP_FOLDER 201 | } SDL_WinRT_Path; 202 | 203 | 204 | /** 205 | * \brief WinRT Device Family 206 | */ 207 | typedef enum 208 | { 209 | /** \brief Unknown family */ 210 | SDL_WINRT_DEVICEFAMILY_UNKNOWN, 211 | 212 | /** \brief Desktop family*/ 213 | SDL_WINRT_DEVICEFAMILY_DESKTOP, 214 | 215 | /** \brief Mobile family (for example smartphone) */ 216 | SDL_WINRT_DEVICEFAMILY_MOBILE, 217 | 218 | /** \brief XBox family */ 219 | SDL_WINRT_DEVICEFAMILY_XBOX, 220 | } SDL_WinRT_DeviceFamily; 221 | 222 | 223 | /** 224 | * \brief Retrieves a WinRT defined path on the local file system 225 | * 226 | * \note Documentation on most app-specific path types on WinRT 227 | * can be found on MSDN, at the URL: 228 | * http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx 229 | * 230 | * \param pathType The type of path to retrieve. 231 | * \return A UCS-2 string (16-bit, wide-char) containing the path, or NULL 232 | * if the path is not available for any reason. Not all paths are 233 | * available on all versions of Windows. This is especially true on 234 | * Windows Phone. Check the documentation for the given 235 | * SDL_WinRT_Path for more information on which path types are 236 | * supported where. 237 | */ 238 | extern DECLSPEC const wchar_t * SDLCALL SDL_WinRTGetFSPathUNICODE(SDL_WinRT_Path pathType); 239 | 240 | /** 241 | * \brief Retrieves a WinRT defined path on the local file system 242 | * 243 | * \note Documentation on most app-specific path types on WinRT 244 | * can be found on MSDN, at the URL: 245 | * http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx 246 | * 247 | * \param pathType The type of path to retrieve. 248 | * \return A UTF-8 string (8-bit, multi-byte) containing the path, or NULL 249 | * if the path is not available for any reason. Not all paths are 250 | * available on all versions of Windows. This is especially true on 251 | * Windows Phone. Check the documentation for the given 252 | * SDL_WinRT_Path for more information on which path types are 253 | * supported where. 254 | */ 255 | extern DECLSPEC const char * SDLCALL SDL_WinRTGetFSPathUTF8(SDL_WinRT_Path pathType); 256 | 257 | /** 258 | * \brief Detects the device family of WinRT plattform on runtime 259 | * 260 | * \return Device family 261 | */ 262 | extern DECLSPEC SDL_WinRT_DeviceFamily SDLCALL SDL_WinRTGetDeviceFamily(); 263 | 264 | #endif /* __WINRT__ */ 265 | 266 | /** 267 | \brief Return true if the current device is a tablet. 268 | */ 269 | extern DECLSPEC SDL_bool SDLCALL SDL_IsTablet(void); 270 | 271 | /* Ends C function definitions when using C++ */ 272 | #ifdef __cplusplus 273 | } 274 | #endif 275 | #include "close_code.h" 276 | 277 | #endif /* SDL_system_h_ */ 278 | 279 | /* vi: set ts=4 sw=4 expandtab: */ 280 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | #ifndef SDL_test_h_ 31 | #define SDL_test_h_ 32 | 33 | #include "SDL.h" 34 | #include "SDL_test_assert.h" 35 | #include "SDL_test_common.h" 36 | #include "SDL_test_compare.h" 37 | #include "SDL_test_crc32.h" 38 | #include "SDL_test_font.h" 39 | #include "SDL_test_fuzzer.h" 40 | #include "SDL_test_harness.h" 41 | #include "SDL_test_images.h" 42 | #include "SDL_test_log.h" 43 | #include "SDL_test_md5.h" 44 | #include "SDL_test_memory.h" 45 | #include "SDL_test_random.h" 46 | 47 | #include "begin_code.h" 48 | /* Set up for C function definitions, even when using C++ */ 49 | #ifdef __cplusplus 50 | extern "C" { 51 | #endif 52 | 53 | /* Global definitions */ 54 | 55 | /* 56 | * Note: Maximum size of SDLTest log message is less than SDL's limit 57 | * to ensure we can fit additional information such as the timestamp. 58 | */ 59 | #define SDLTEST_MAX_LOGMESSAGE_LENGTH 3584 60 | 61 | /* Ends C function definitions when using C++ */ 62 | #ifdef __cplusplus 63 | } 64 | #endif 65 | #include "close_code.h" 66 | 67 | #endif /* SDL_test_h_ */ 68 | 69 | /* vi: set ts=4 sw=4 expandtab: */ 70 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_assert.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_assert.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | * 32 | * Assert API for test code and test cases 33 | * 34 | */ 35 | 36 | #ifndef SDL_test_assert_h_ 37 | #define SDL_test_assert_h_ 38 | 39 | #include "begin_code.h" 40 | /* Set up for C function definitions, even when using C++ */ 41 | #ifdef __cplusplus 42 | extern "C" { 43 | #endif 44 | 45 | /** 46 | * \brief Fails the assert. 47 | */ 48 | #define ASSERT_FAIL 0 49 | 50 | /** 51 | * \brief Passes the assert. 52 | */ 53 | #define ASSERT_PASS 1 54 | 55 | /** 56 | * \brief Assert that logs and break execution flow on failures. 57 | * 58 | * \param assertCondition Evaluated condition or variable to assert; fail (==0) or pass (!=0). 59 | * \param assertDescription Message to log with the assert describing it. 60 | */ 61 | void SDLTest_Assert(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription, ...) SDL_PRINTF_VARARG_FUNC(2); 62 | 63 | /** 64 | * \brief Assert for test cases that logs but does not break execution flow on failures. Updates assertion counters. 65 | * 66 | * \param assertCondition Evaluated condition or variable to assert; fail (==0) or pass (!=0). 67 | * \param assertDescription Message to log with the assert describing it. 68 | * 69 | * \returns Returns the assertCondition so it can be used to externally to break execution flow if desired. 70 | */ 71 | int SDLTest_AssertCheck(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription, ...) SDL_PRINTF_VARARG_FUNC(2); 72 | 73 | /** 74 | * \brief Explicitly pass without checking an assertion condition. Updates assertion counter. 75 | * 76 | * \param assertDescription Message to log with the assert describing it. 77 | */ 78 | void SDLTest_AssertPass(SDL_PRINTF_FORMAT_STRING const char *assertDescription, ...) SDL_PRINTF_VARARG_FUNC(1); 79 | 80 | /** 81 | * \brief Resets the assert summary counters to zero. 82 | */ 83 | void SDLTest_ResetAssertSummary(void); 84 | 85 | /** 86 | * \brief Logs summary of all assertions (total, pass, fail) since last reset as INFO or ERROR. 87 | */ 88 | void SDLTest_LogAssertSummary(void); 89 | 90 | 91 | /** 92 | * \brief Converts the current assert summary state to a test result. 93 | * 94 | * \returns TEST_RESULT_PASSED, TEST_RESULT_FAILED, or TEST_RESULT_NO_ASSERT 95 | */ 96 | int SDLTest_AssertSummaryToTestResult(void); 97 | 98 | #ifdef __cplusplus 99 | } 100 | #endif 101 | #include "close_code.h" 102 | 103 | #endif /* SDL_test_assert_h_ */ 104 | 105 | /* vi: set ts=4 sw=4 expandtab: */ 106 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_common.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_common.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* Ported from original test\common.h file. */ 31 | 32 | #ifndef SDL_test_common_h_ 33 | #define SDL_test_common_h_ 34 | 35 | #include "SDL.h" 36 | 37 | #if defined(__PSP__) 38 | #define DEFAULT_WINDOW_WIDTH 480 39 | #define DEFAULT_WINDOW_HEIGHT 272 40 | #else 41 | #define DEFAULT_WINDOW_WIDTH 640 42 | #define DEFAULT_WINDOW_HEIGHT 480 43 | #endif 44 | 45 | #define VERBOSE_VIDEO 0x00000001 46 | #define VERBOSE_MODES 0x00000002 47 | #define VERBOSE_RENDER 0x00000004 48 | #define VERBOSE_EVENT 0x00000008 49 | #define VERBOSE_AUDIO 0x00000010 50 | 51 | typedef struct 52 | { 53 | /* SDL init flags */ 54 | char **argv; 55 | Uint32 flags; 56 | Uint32 verbose; 57 | 58 | /* Video info */ 59 | const char *videodriver; 60 | int display; 61 | const char *window_title; 62 | const char *window_icon; 63 | Uint32 window_flags; 64 | int window_x; 65 | int window_y; 66 | int window_w; 67 | int window_h; 68 | int window_minW; 69 | int window_minH; 70 | int window_maxW; 71 | int window_maxH; 72 | int logical_w; 73 | int logical_h; 74 | float scale; 75 | int depth; 76 | int refresh_rate; 77 | int num_windows; 78 | SDL_Window **windows; 79 | 80 | /* Renderer info */ 81 | const char *renderdriver; 82 | Uint32 render_flags; 83 | SDL_bool skip_renderer; 84 | SDL_Renderer **renderers; 85 | SDL_Texture **targets; 86 | 87 | /* Audio info */ 88 | const char *audiodriver; 89 | SDL_AudioSpec audiospec; 90 | 91 | /* GL settings */ 92 | int gl_red_size; 93 | int gl_green_size; 94 | int gl_blue_size; 95 | int gl_alpha_size; 96 | int gl_buffer_size; 97 | int gl_depth_size; 98 | int gl_stencil_size; 99 | int gl_double_buffer; 100 | int gl_accum_red_size; 101 | int gl_accum_green_size; 102 | int gl_accum_blue_size; 103 | int gl_accum_alpha_size; 104 | int gl_stereo; 105 | int gl_multisamplebuffers; 106 | int gl_multisamplesamples; 107 | int gl_retained_backing; 108 | int gl_accelerated; 109 | int gl_major_version; 110 | int gl_minor_version; 111 | int gl_debug; 112 | int gl_profile_mask; 113 | } SDLTest_CommonState; 114 | 115 | #include "begin_code.h" 116 | /* Set up for C function definitions, even when using C++ */ 117 | #ifdef __cplusplus 118 | extern "C" { 119 | #endif 120 | 121 | /* Function prototypes */ 122 | 123 | /** 124 | * \brief Parse command line parameters and create common state. 125 | * 126 | * \param argv Array of command line parameters 127 | * \param flags Flags indicating which subsystem to initialize (i.e. SDL_INIT_VIDEO | SDL_INIT_AUDIO) 128 | * 129 | * \returns Returns a newly allocated common state object. 130 | */ 131 | SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags); 132 | 133 | /** 134 | * \brief Process one common argument. 135 | * 136 | * \param state The common state describing the test window to create. 137 | * \param index The index of the argument to process in argv[]. 138 | * 139 | * \returns The number of arguments processed (i.e. 1 for --fullscreen, 2 for --video [videodriver], or -1 on error. 140 | */ 141 | int SDLTest_CommonArg(SDLTest_CommonState * state, int index); 142 | 143 | 144 | /** 145 | * \brief Logs command line usage info. 146 | * 147 | * This logs the appropriate command line options for the subsystems in use 148 | * plus other common options, and then any application-specific options. 149 | * This uses the SDL_Log() function and splits up output to be friendly to 150 | * 80-character-wide terminals. 151 | * 152 | * \param state The common state describing the test window for the app. 153 | * \param argv0 argv[0], as passed to main/SDL_main. 154 | * \param options an array of strings for application specific options. The last element of the array should be NULL. 155 | */ 156 | void SDLTest_CommonLogUsage(SDLTest_CommonState * state, const char *argv0, const char **options); 157 | 158 | /** 159 | * \brief Open test window. 160 | * 161 | * \param state The common state describing the test window to create. 162 | * 163 | * \returns True if initialization succeeded, false otherwise 164 | */ 165 | SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state); 166 | 167 | /** 168 | * \brief Easy argument handling when test app doesn't need any custom args. 169 | * 170 | * \param state The common state describing the test window to create. 171 | * \param argc argc, as supplied to SDL_main 172 | * \param argv argv, as supplied to SDL_main 173 | * 174 | * \returns False if app should quit, true otherwise. 175 | */ 176 | SDL_bool SDLTest_CommonDefaultArgs(SDLTest_CommonState * state, const int argc, char **argv); 177 | 178 | /** 179 | * \brief Common event handler for test windows. 180 | * 181 | * \param state The common state used to create test window. 182 | * \param event The event to handle. 183 | * \param done Flag indicating we are done. 184 | * 185 | */ 186 | void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done); 187 | 188 | /** 189 | * \brief Close test window. 190 | * 191 | * \param state The common state used to create test window. 192 | * 193 | */ 194 | void SDLTest_CommonQuit(SDLTest_CommonState * state); 195 | 196 | 197 | /* Ends C function definitions when using C++ */ 198 | #ifdef __cplusplus 199 | } 200 | #endif 201 | #include "close_code.h" 202 | 203 | #endif /* SDL_test_common_h_ */ 204 | 205 | /* vi: set ts=4 sw=4 expandtab: */ 206 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_compare.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_compare.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | 32 | Defines comparison functions (i.e. for surfaces). 33 | 34 | */ 35 | 36 | #ifndef SDL_test_compare_h_ 37 | #define SDL_test_compare_h_ 38 | 39 | #include "SDL.h" 40 | 41 | #include "SDL_test_images.h" 42 | 43 | #include "begin_code.h" 44 | /* Set up for C function definitions, even when using C++ */ 45 | #ifdef __cplusplus 46 | extern "C" { 47 | #endif 48 | 49 | /** 50 | * \brief Compares a surface and with reference image data for equality 51 | * 52 | * \param surface Surface used in comparison 53 | * \param referenceSurface Test Surface used in comparison 54 | * \param allowable_error Allowable difference (=sum of squared difference for each RGB component) in blending accuracy. 55 | * 56 | * \returns 0 if comparison succeeded, >0 (=number of pixels for which the comparison failed) if comparison failed, -1 if any of the surfaces were NULL, -2 if the surface sizes differ. 57 | */ 58 | int SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error); 59 | 60 | 61 | /* Ends C function definitions when using C++ */ 62 | #ifdef __cplusplus 63 | } 64 | #endif 65 | #include "close_code.h" 66 | 67 | #endif /* SDL_test_compare_h_ */ 68 | 69 | /* vi: set ts=4 sw=4 expandtab: */ 70 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_crc32.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_crc32.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | 32 | Implements CRC32 calculations (default output is Perl String::CRC32 compatible). 33 | 34 | */ 35 | 36 | #ifndef SDL_test_crc32_h_ 37 | #define SDL_test_crc32_h_ 38 | 39 | #include "begin_code.h" 40 | /* Set up for C function definitions, even when using C++ */ 41 | #ifdef __cplusplus 42 | extern "C" { 43 | #endif 44 | 45 | 46 | /* ------------ Definitions --------- */ 47 | 48 | /* Definition shared by all CRC routines */ 49 | 50 | #ifndef CrcUint32 51 | #define CrcUint32 unsigned int 52 | #endif 53 | #ifndef CrcUint8 54 | #define CrcUint8 unsigned char 55 | #endif 56 | 57 | #ifdef ORIGINAL_METHOD 58 | #define CRC32_POLY 0x04c11db7 /* AUTODIN II, Ethernet, & FDDI */ 59 | #else 60 | #define CRC32_POLY 0xEDB88320 /* Perl String::CRC32 compatible */ 61 | #endif 62 | 63 | /** 64 | * Data structure for CRC32 (checksum) computation 65 | */ 66 | typedef struct { 67 | CrcUint32 crc32_table[256]; /* CRC table */ 68 | } SDLTest_Crc32Context; 69 | 70 | /* ---------- Function Prototypes ------------- */ 71 | 72 | /** 73 | * \brief Initialize the CRC context 74 | * 75 | * Note: The function initializes the crc table required for all crc calculations. 76 | * 77 | * \param crcContext pointer to context variable 78 | * 79 | * \returns 0 for OK, -1 on error 80 | * 81 | */ 82 | int SDLTest_Crc32Init(SDLTest_Crc32Context * crcContext); 83 | 84 | 85 | /** 86 | * \brief calculate a crc32 from a data block 87 | * 88 | * \param crcContext pointer to context variable 89 | * \param inBuf input buffer to checksum 90 | * \param inLen length of input buffer 91 | * \param crc32 pointer to Uint32 to store the final CRC into 92 | * 93 | * \returns 0 for OK, -1 on error 94 | * 95 | */ 96 | int SDLTest_Crc32Calc(SDLTest_Crc32Context * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32); 97 | 98 | /* Same routine broken down into three steps */ 99 | int SDLTest_Crc32CalcStart(SDLTest_Crc32Context * crcContext, CrcUint32 *crc32); 100 | int SDLTest_Crc32CalcEnd(SDLTest_Crc32Context * crcContext, CrcUint32 *crc32); 101 | int SDLTest_Crc32CalcBuffer(SDLTest_Crc32Context * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32); 102 | 103 | 104 | /** 105 | * \brief clean up CRC context 106 | * 107 | * \param crcContext pointer to context variable 108 | * 109 | * \returns 0 for OK, -1 on error 110 | * 111 | */ 112 | 113 | int SDLTest_Crc32Done(SDLTest_Crc32Context * crcContext); 114 | 115 | 116 | /* Ends C function definitions when using C++ */ 117 | #ifdef __cplusplus 118 | } 119 | #endif 120 | #include "close_code.h" 121 | 122 | #endif /* SDL_test_crc32_h_ */ 123 | 124 | /* vi: set ts=4 sw=4 expandtab: */ 125 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_font.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_font.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | #ifndef SDL_test_font_h_ 31 | #define SDL_test_font_h_ 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /* Function prototypes */ 40 | 41 | #define FONT_CHARACTER_SIZE 8 42 | 43 | /** 44 | * \brief Draw a string in the currently set font. 45 | * 46 | * \param renderer The renderer to draw on. 47 | * \param x The X coordinate of the upper left corner of the character. 48 | * \param y The Y coordinate of the upper left corner of the character. 49 | * \param c The character to draw. 50 | * 51 | * \returns Returns 0 on success, -1 on failure. 52 | */ 53 | int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c); 54 | 55 | /** 56 | * \brief Draw a string in the currently set font. 57 | * 58 | * \param renderer The renderer to draw on. 59 | * \param x The X coordinate of the upper left corner of the string. 60 | * \param y The Y coordinate of the upper left corner of the string. 61 | * \param s The string to draw. 62 | * 63 | * \returns Returns 0 on success, -1 on failure. 64 | */ 65 | int SDLTest_DrawString(SDL_Renderer *renderer, int x, int y, const char *s); 66 | 67 | 68 | /** 69 | * \brief Cleanup textures used by font drawing functions. 70 | */ 71 | void SDLTest_CleanupTextDrawing(void); 72 | 73 | /* Ends C function definitions when using C++ */ 74 | #ifdef __cplusplus 75 | } 76 | #endif 77 | #include "close_code.h" 78 | 79 | #endif /* SDL_test_font_h_ */ 80 | 81 | /* vi: set ts=4 sw=4 expandtab: */ 82 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_harness.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_harness.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | Defines types for test case definitions and the test execution harness API. 32 | 33 | Based on original GSOC code by Markus Kauppila 34 | */ 35 | 36 | #ifndef SDL_test_h_arness_h 37 | #define SDL_test_h_arness_h 38 | 39 | #include "begin_code.h" 40 | /* Set up for C function definitions, even when using C++ */ 41 | #ifdef __cplusplus 42 | extern "C" { 43 | #endif 44 | 45 | 46 | /* ! Definitions for test case structures */ 47 | #define TEST_ENABLED 1 48 | #define TEST_DISABLED 0 49 | 50 | /* ! Definition of all the possible test return values of the test case method */ 51 | #define TEST_ABORTED -1 52 | #define TEST_STARTED 0 53 | #define TEST_COMPLETED 1 54 | #define TEST_SKIPPED 2 55 | 56 | /* ! Definition of all the possible test results for the harness */ 57 | #define TEST_RESULT_PASSED 0 58 | #define TEST_RESULT_FAILED 1 59 | #define TEST_RESULT_NO_ASSERT 2 60 | #define TEST_RESULT_SKIPPED 3 61 | #define TEST_RESULT_SETUP_FAILURE 4 62 | 63 | /* !< Function pointer to a test case setup function (run before every test) */ 64 | typedef void (*SDLTest_TestCaseSetUpFp)(void *arg); 65 | 66 | /* !< Function pointer to a test case function */ 67 | typedef int (*SDLTest_TestCaseFp)(void *arg); 68 | 69 | /* !< Function pointer to a test case teardown function (run after every test) */ 70 | typedef void (*SDLTest_TestCaseTearDownFp)(void *arg); 71 | 72 | /** 73 | * Holds information about a single test case. 74 | */ 75 | typedef struct SDLTest_TestCaseReference { 76 | /* !< Func2Stress */ 77 | SDLTest_TestCaseFp testCase; 78 | /* !< Short name (or function name) "Func2Stress" */ 79 | char *name; 80 | /* !< Long name or full description "This test pushes func2() to the limit." */ 81 | char *description; 82 | /* !< Set to TEST_ENABLED or TEST_DISABLED (test won't be run) */ 83 | int enabled; 84 | } SDLTest_TestCaseReference; 85 | 86 | /** 87 | * Holds information about a test suite (multiple test cases). 88 | */ 89 | typedef struct SDLTest_TestSuiteReference { 90 | /* !< "PlatformSuite" */ 91 | char *name; 92 | /* !< The function that is run before each test. NULL skips. */ 93 | SDLTest_TestCaseSetUpFp testSetUp; 94 | /* !< The test cases that are run as part of the suite. Last item should be NULL. */ 95 | const SDLTest_TestCaseReference **testCases; 96 | /* !< The function that is run after each test. NULL skips. */ 97 | SDLTest_TestCaseTearDownFp testTearDown; 98 | } SDLTest_TestSuiteReference; 99 | 100 | 101 | /** 102 | * \brief Generates a random run seed string for the harness. The generated seed will contain alphanumeric characters (0-9A-Z). 103 | * 104 | * Note: The returned string needs to be deallocated by the caller. 105 | * 106 | * \param length The length of the seed string to generate 107 | * 108 | * \returns The generated seed string 109 | */ 110 | char *SDLTest_GenerateRunSeed(const int length); 111 | 112 | /** 113 | * \brief Execute a test suite using the given run seed and execution key. 114 | * 115 | * \param testSuites Suites containing the test case. 116 | * \param userRunSeed Custom run seed provided by user, or NULL to autogenerate one. 117 | * \param userExecKey Custom execution key provided by user, or 0 to autogenerate one. 118 | * \param filter Filter specification. NULL disables. Case sensitive. 119 | * \param testIterations Number of iterations to run each test case. 120 | * 121 | * \returns Test run result; 0 when all tests passed, 1 if any tests failed. 122 | */ 123 | int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *userRunSeed, Uint64 userExecKey, const char *filter, int testIterations); 124 | 125 | 126 | /* Ends C function definitions when using C++ */ 127 | #ifdef __cplusplus 128 | } 129 | #endif 130 | #include "close_code.h" 131 | 132 | #endif /* SDL_test_h_arness_h */ 133 | 134 | /* vi: set ts=4 sw=4 expandtab: */ 135 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_images.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_images.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | 32 | Defines some images for tests. 33 | 34 | */ 35 | 36 | #ifndef SDL_test_images_h_ 37 | #define SDL_test_images_h_ 38 | 39 | #include "SDL.h" 40 | 41 | #include "begin_code.h" 42 | /* Set up for C function definitions, even when using C++ */ 43 | #ifdef __cplusplus 44 | extern "C" { 45 | #endif 46 | 47 | /** 48 | *Type for test images. 49 | */ 50 | typedef struct SDLTest_SurfaceImage_s { 51 | int width; 52 | int height; 53 | unsigned int bytes_per_pixel; /* 3:RGB, 4:RGBA */ 54 | const char *pixel_data; 55 | } SDLTest_SurfaceImage_t; 56 | 57 | /* Test images */ 58 | SDL_Surface *SDLTest_ImageBlit(void); 59 | SDL_Surface *SDLTest_ImageBlitColor(void); 60 | SDL_Surface *SDLTest_ImageBlitAlpha(void); 61 | SDL_Surface *SDLTest_ImageBlitBlendAdd(void); 62 | SDL_Surface *SDLTest_ImageBlitBlend(void); 63 | SDL_Surface *SDLTest_ImageBlitBlendMod(void); 64 | SDL_Surface *SDLTest_ImageBlitBlendNone(void); 65 | SDL_Surface *SDLTest_ImageBlitBlendAll(void); 66 | SDL_Surface *SDLTest_ImageFace(void); 67 | SDL_Surface *SDLTest_ImagePrimitives(void); 68 | SDL_Surface *SDLTest_ImagePrimitivesBlend(void); 69 | 70 | /* Ends C function definitions when using C++ */ 71 | #ifdef __cplusplus 72 | } 73 | #endif 74 | #include "close_code.h" 75 | 76 | #endif /* SDL_test_images_h_ */ 77 | 78 | /* vi: set ts=4 sw=4 expandtab: */ 79 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_log.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_log.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | * 32 | * Wrapper to log in the TEST category 33 | * 34 | */ 35 | 36 | #ifndef SDL_test_log_h_ 37 | #define SDL_test_log_h_ 38 | 39 | #include "begin_code.h" 40 | /* Set up for C function definitions, even when using C++ */ 41 | #ifdef __cplusplus 42 | extern "C" { 43 | #endif 44 | 45 | /** 46 | * \brief Prints given message with a timestamp in the TEST category and INFO priority. 47 | * 48 | * \param fmt Message to be logged 49 | */ 50 | void SDLTest_Log(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1); 51 | 52 | /** 53 | * \brief Prints given message with a timestamp in the TEST category and the ERROR priority. 54 | * 55 | * \param fmt Message to be logged 56 | */ 57 | void SDLTest_LogError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1); 58 | 59 | /* Ends C function definitions when using C++ */ 60 | #ifdef __cplusplus 61 | } 62 | #endif 63 | #include "close_code.h" 64 | 65 | #endif /* SDL_test_log_h_ */ 66 | 67 | /* vi: set ts=4 sw=4 expandtab: */ 68 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_md5.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_md5.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | *********************************************************************** 32 | ** Header file for implementation of MD5 ** 33 | ** RSA Data Security, Inc. MD5 Message-Digest Algorithm ** 34 | ** Created: 2/17/90 RLR ** 35 | ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version ** 36 | ** Revised (for MD5): RLR 4/27/91 ** 37 | ** -- G modified to have y&~z instead of y&z ** 38 | ** -- FF, GG, HH modified to add in last register done ** 39 | ** -- Access pattern: round 2 works mod 5, round 3 works mod 3 ** 40 | ** -- distinct additive constant for each step ** 41 | ** -- round 4 added, working mod 7 ** 42 | *********************************************************************** 43 | */ 44 | 45 | /* 46 | *********************************************************************** 47 | ** Message-digest routines: ** 48 | ** To form the message digest for a message M ** 49 | ** (1) Initialize a context buffer mdContext using MD5Init ** 50 | ** (2) Call MD5Update on mdContext and M ** 51 | ** (3) Call MD5Final on mdContext ** 52 | ** The message digest is now in mdContext->digest[0...15] ** 53 | *********************************************************************** 54 | */ 55 | 56 | #ifndef SDL_test_md5_h_ 57 | #define SDL_test_md5_h_ 58 | 59 | #include "begin_code.h" 60 | /* Set up for C function definitions, even when using C++ */ 61 | #ifdef __cplusplus 62 | extern "C" { 63 | #endif 64 | 65 | /* ------------ Definitions --------- */ 66 | 67 | /* typedef a 32-bit type */ 68 | typedef unsigned long int MD5UINT4; 69 | 70 | /* Data structure for MD5 (Message-Digest) computation */ 71 | typedef struct { 72 | MD5UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ 73 | MD5UINT4 buf[4]; /* scratch buffer */ 74 | unsigned char in[64]; /* input buffer */ 75 | unsigned char digest[16]; /* actual digest after Md5Final call */ 76 | } SDLTest_Md5Context; 77 | 78 | /* ---------- Function Prototypes ------------- */ 79 | 80 | /** 81 | * \brief initialize the context 82 | * 83 | * \param mdContext pointer to context variable 84 | * 85 | * Note: The function initializes the message-digest context 86 | * mdContext. Call before each new use of the context - 87 | * all fields are set to zero. 88 | */ 89 | void SDLTest_Md5Init(SDLTest_Md5Context * mdContext); 90 | 91 | 92 | /** 93 | * \brief update digest from variable length data 94 | * 95 | * \param mdContext pointer to context variable 96 | * \param inBuf pointer to data array/string 97 | * \param inLen length of data array/string 98 | * 99 | * Note: The function updates the message-digest context to account 100 | * for the presence of each of the characters inBuf[0..inLen-1] 101 | * in the message whose digest is being computed. 102 | */ 103 | 104 | void SDLTest_Md5Update(SDLTest_Md5Context * mdContext, unsigned char *inBuf, 105 | unsigned int inLen); 106 | 107 | 108 | /** 109 | * \brief complete digest computation 110 | * 111 | * \param mdContext pointer to context variable 112 | * 113 | * Note: The function terminates the message-digest computation and 114 | * ends with the desired message digest in mdContext.digest[0..15]. 115 | * Always call before using the digest[] variable. 116 | */ 117 | 118 | void SDLTest_Md5Final(SDLTest_Md5Context * mdContext); 119 | 120 | 121 | /* Ends C function definitions when using C++ */ 122 | #ifdef __cplusplus 123 | } 124 | #endif 125 | #include "close_code.h" 126 | 127 | #endif /* SDL_test_md5_h_ */ 128 | 129 | /* vi: set ts=4 sw=4 expandtab: */ 130 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_memory.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_memory.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | #ifndef SDL_test_memory_h_ 31 | #define SDL_test_memory_h_ 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | 40 | /** 41 | * \brief Start tracking SDL memory allocations 42 | * 43 | * \note This should be called before any other SDL functions for complete tracking coverage 44 | */ 45 | int SDLTest_TrackAllocations(void); 46 | 47 | /** 48 | * \brief Print a log of any outstanding allocations 49 | * 50 | * \note This can be called after SDL_Quit() 51 | */ 52 | void SDLTest_LogAllocations(void); 53 | 54 | 55 | /* Ends C function definitions when using C++ */ 56 | #ifdef __cplusplus 57 | } 58 | #endif 59 | #include "close_code.h" 60 | 61 | #endif /* SDL_test_memory_h_ */ 62 | 63 | /* vi: set ts=4 sw=4 expandtab: */ 64 | -------------------------------------------------------------------------------- /include/SDL2/SDL_test_random.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_test_random.h 24 | * 25 | * Include file for SDL test framework. 26 | * 27 | * This code is a part of the SDL2_test library, not the main SDL library. 28 | */ 29 | 30 | /* 31 | 32 | A "32-bit Multiply with carry random number generator. Very fast. 33 | Includes a list of recommended multipliers. 34 | 35 | multiply-with-carry generator: x(n) = a*x(n-1) + carry mod 2^32. 36 | period: (a*2^31)-1 37 | 38 | */ 39 | 40 | #ifndef SDL_test_random_h_ 41 | #define SDL_test_random_h_ 42 | 43 | #include "begin_code.h" 44 | /* Set up for C function definitions, even when using C++ */ 45 | #ifdef __cplusplus 46 | extern "C" { 47 | #endif 48 | 49 | /* --- Definitions */ 50 | 51 | /* 52 | * Macros that return a random number in a specific format. 53 | */ 54 | #define SDLTest_RandomInt(c) ((int)SDLTest_Random(c)) 55 | 56 | /* 57 | * Context structure for the random number generator state. 58 | */ 59 | typedef struct { 60 | unsigned int a; 61 | unsigned int x; 62 | unsigned int c; 63 | unsigned int ah; 64 | unsigned int al; 65 | } SDLTest_RandomContext; 66 | 67 | 68 | /* --- Function prototypes */ 69 | 70 | /** 71 | * \brief Initialize random number generator with two integers. 72 | * 73 | * Note: The random sequence of numbers returned by ...Random() is the 74 | * same for the same two integers and has a period of 2^31. 75 | * 76 | * \param rndContext pointer to context structure 77 | * \param xi integer that defines the random sequence 78 | * \param ci integer that defines the random sequence 79 | * 80 | */ 81 | void SDLTest_RandomInit(SDLTest_RandomContext * rndContext, unsigned int xi, 82 | unsigned int ci); 83 | 84 | /** 85 | * \brief Initialize random number generator based on current system time. 86 | * 87 | * \param rndContext pointer to context structure 88 | * 89 | */ 90 | void SDLTest_RandomInitTime(SDLTest_RandomContext *rndContext); 91 | 92 | 93 | /** 94 | * \brief Initialize random number generator based on current system time. 95 | * 96 | * Note: ...RandomInit() or ...RandomInitTime() must have been called 97 | * before using this function. 98 | * 99 | * \param rndContext pointer to context structure 100 | * 101 | * \returns A random number (32bit unsigned integer) 102 | * 103 | */ 104 | unsigned int SDLTest_Random(SDLTest_RandomContext *rndContext); 105 | 106 | 107 | /* Ends C function definitions when using C++ */ 108 | #ifdef __cplusplus 109 | } 110 | #endif 111 | #include "close_code.h" 112 | 113 | #endif /* SDL_test_random_h_ */ 114 | 115 | /* vi: set ts=4 sw=4 expandtab: */ 116 | -------------------------------------------------------------------------------- /include/SDL2/SDL_timer.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDL_timer_h_ 23 | #define SDL_timer_h_ 24 | 25 | /** 26 | * \file SDL_timer.h 27 | * 28 | * Header for the SDL time management routines. 29 | */ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | 34 | #include "begin_code.h" 35 | /* Set up for C function definitions, even when using C++ */ 36 | #ifdef __cplusplus 37 | extern "C" { 38 | #endif 39 | 40 | /** 41 | * \brief Get the number of milliseconds since the SDL library initialization. 42 | * 43 | * \note This value wraps if the program runs for more than ~49 days. 44 | */ 45 | extern DECLSPEC Uint32 SDLCALL SDL_GetTicks(void); 46 | 47 | /** 48 | * \brief Compare SDL ticks values, and return true if A has passed B 49 | * 50 | * e.g. if you want to wait 100 ms, you could do this: 51 | * Uint32 timeout = SDL_GetTicks() + 100; 52 | * while (!SDL_TICKS_PASSED(SDL_GetTicks(), timeout)) { 53 | * ... do work until timeout has elapsed 54 | * } 55 | */ 56 | #define SDL_TICKS_PASSED(A, B) ((Sint32)((B) - (A)) <= 0) 57 | 58 | /** 59 | * \brief Get the current value of the high resolution counter 60 | */ 61 | extern DECLSPEC Uint64 SDLCALL SDL_GetPerformanceCounter(void); 62 | 63 | /** 64 | * \brief Get the count per second of the high resolution counter 65 | */ 66 | extern DECLSPEC Uint64 SDLCALL SDL_GetPerformanceFrequency(void); 67 | 68 | /** 69 | * \brief Wait a specified number of milliseconds before returning. 70 | */ 71 | extern DECLSPEC void SDLCALL SDL_Delay(Uint32 ms); 72 | 73 | /** 74 | * Function prototype for the timer callback function. 75 | * 76 | * The callback function is passed the current timer interval and returns 77 | * the next timer interval. If the returned value is the same as the one 78 | * passed in, the periodic alarm continues, otherwise a new alarm is 79 | * scheduled. If the callback returns 0, the periodic alarm is cancelled. 80 | */ 81 | typedef Uint32 (SDLCALL * SDL_TimerCallback) (Uint32 interval, void *param); 82 | 83 | /** 84 | * Definition of the timer ID type. 85 | */ 86 | typedef int SDL_TimerID; 87 | 88 | /** 89 | * \brief Add a new timer to the pool of timers already running. 90 | * 91 | * \return A timer ID, or 0 when an error occurs. 92 | */ 93 | extern DECLSPEC SDL_TimerID SDLCALL SDL_AddTimer(Uint32 interval, 94 | SDL_TimerCallback callback, 95 | void *param); 96 | 97 | /** 98 | * \brief Remove a timer knowing its ID. 99 | * 100 | * \return A boolean value indicating success or failure. 101 | * 102 | * \warning It is not safe to remove a timer multiple times. 103 | */ 104 | extern DECLSPEC SDL_bool SDLCALL SDL_RemoveTimer(SDL_TimerID id); 105 | 106 | 107 | /* Ends C function definitions when using C++ */ 108 | #ifdef __cplusplus 109 | } 110 | #endif 111 | #include "close_code.h" 112 | 113 | #endif /* SDL_timer_h_ */ 114 | 115 | /* vi: set ts=4 sw=4 expandtab: */ 116 | -------------------------------------------------------------------------------- /include/SDL2/SDL_touch.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_touch.h 24 | * 25 | * Include file for SDL touch event handling. 26 | */ 27 | 28 | #ifndef SDL_touch_h_ 29 | #define SDL_touch_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | #include "SDL_error.h" 33 | #include "SDL_video.h" 34 | 35 | #include "begin_code.h" 36 | /* Set up for C function definitions, even when using C++ */ 37 | #ifdef __cplusplus 38 | extern "C" { 39 | #endif 40 | 41 | typedef Sint64 SDL_TouchID; 42 | typedef Sint64 SDL_FingerID; 43 | 44 | typedef enum 45 | { 46 | SDL_TOUCH_DEVICE_INVALID = -1, 47 | SDL_TOUCH_DEVICE_DIRECT, /* touch screen with window-relative coordinates */ 48 | SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE, /* trackpad with absolute device coordinates */ 49 | SDL_TOUCH_DEVICE_INDIRECT_RELATIVE /* trackpad with screen cursor-relative coordinates */ 50 | } SDL_TouchDeviceType; 51 | 52 | typedef struct SDL_Finger 53 | { 54 | SDL_FingerID id; 55 | float x; 56 | float y; 57 | float pressure; 58 | } SDL_Finger; 59 | 60 | /* Used as the device ID for mouse events simulated with touch input */ 61 | #define SDL_TOUCH_MOUSEID ((Uint32)-1) 62 | 63 | /* Used as the SDL_TouchID for touch events simulated with mouse input */ 64 | #define SDL_MOUSE_TOUCHID ((Sint64)-1) 65 | 66 | 67 | /* Function prototypes */ 68 | 69 | /** 70 | * \brief Get the number of registered touch devices. 71 | */ 72 | extern DECLSPEC int SDLCALL SDL_GetNumTouchDevices(void); 73 | 74 | /** 75 | * \brief Get the touch ID with the given index, or 0 if the index is invalid. 76 | */ 77 | extern DECLSPEC SDL_TouchID SDLCALL SDL_GetTouchDevice(int index); 78 | 79 | /** 80 | * \brief Get the type of the given touch device. 81 | */ 82 | extern DECLSPEC SDL_TouchDeviceType SDLCALL SDL_GetTouchDeviceType(SDL_TouchID touchID); 83 | 84 | /** 85 | * \brief Get the number of active fingers for a given touch device. 86 | */ 87 | extern DECLSPEC int SDLCALL SDL_GetNumTouchFingers(SDL_TouchID touchID); 88 | 89 | /** 90 | * \brief Get the finger object of the given touch, with the given index. 91 | */ 92 | extern DECLSPEC SDL_Finger * SDLCALL SDL_GetTouchFinger(SDL_TouchID touchID, int index); 93 | 94 | /* Ends C function definitions when using C++ */ 95 | #ifdef __cplusplus 96 | } 97 | #endif 98 | #include "close_code.h" 99 | 100 | #endif /* SDL_touch_h_ */ 101 | 102 | /* vi: set ts=4 sw=4 expandtab: */ 103 | -------------------------------------------------------------------------------- /include/SDL2/SDL_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_types.h 24 | * 25 | * \deprecated 26 | */ 27 | 28 | /* DEPRECATED */ 29 | #include "SDL_stdinc.h" 30 | -------------------------------------------------------------------------------- /include/SDL2/SDL_version.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_version.h 24 | * 25 | * This header defines the current SDL version. 26 | */ 27 | 28 | #ifndef SDL_version_h_ 29 | #define SDL_version_h_ 30 | 31 | #include "SDL_stdinc.h" 32 | 33 | #include "begin_code.h" 34 | /* Set up for C function definitions, even when using C++ */ 35 | #ifdef __cplusplus 36 | extern "C" { 37 | #endif 38 | 39 | /** 40 | * \brief Information the version of SDL in use. 41 | * 42 | * Represents the library's version as three levels: major revision 43 | * (increments with massive changes, additions, and enhancements), 44 | * minor revision (increments with backwards-compatible changes to the 45 | * major revision), and patchlevel (increments with fixes to the minor 46 | * revision). 47 | * 48 | * \sa SDL_VERSION 49 | * \sa SDL_GetVersion 50 | */ 51 | typedef struct SDL_version 52 | { 53 | Uint8 major; /**< major version */ 54 | Uint8 minor; /**< minor version */ 55 | Uint8 patch; /**< update version */ 56 | } SDL_version; 57 | 58 | /* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL 59 | */ 60 | #define SDL_MAJOR_VERSION 2 61 | #define SDL_MINOR_VERSION 0 62 | #define SDL_PATCHLEVEL 10 63 | 64 | /** 65 | * \brief Macro to determine SDL version program was compiled against. 66 | * 67 | * This macro fills in a SDL_version structure with the version of the 68 | * library you compiled against. This is determined by what header the 69 | * compiler uses. Note that if you dynamically linked the library, you might 70 | * have a slightly newer or older version at runtime. That version can be 71 | * determined with SDL_GetVersion(), which, unlike SDL_VERSION(), 72 | * is not a macro. 73 | * 74 | * \param x A pointer to a SDL_version struct to initialize. 75 | * 76 | * \sa SDL_version 77 | * \sa SDL_GetVersion 78 | */ 79 | #define SDL_VERSION(x) \ 80 | { \ 81 | (x)->major = SDL_MAJOR_VERSION; \ 82 | (x)->minor = SDL_MINOR_VERSION; \ 83 | (x)->patch = SDL_PATCHLEVEL; \ 84 | } 85 | 86 | /** 87 | * This macro turns the version numbers into a numeric value: 88 | * \verbatim 89 | (1,2,3) -> (1203) 90 | \endverbatim 91 | * 92 | * This assumes that there will never be more than 100 patchlevels. 93 | */ 94 | #define SDL_VERSIONNUM(X, Y, Z) \ 95 | ((X)*1000 + (Y)*100 + (Z)) 96 | 97 | /** 98 | * This is the version number macro for the current SDL version. 99 | */ 100 | #define SDL_COMPILEDVERSION \ 101 | SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) 102 | 103 | /** 104 | * This macro will evaluate to true if compiled with SDL at least X.Y.Z. 105 | */ 106 | #define SDL_VERSION_ATLEAST(X, Y, Z) \ 107 | (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z)) 108 | 109 | /** 110 | * \brief Get the version of SDL that is linked against your program. 111 | * 112 | * If you are linking to SDL dynamically, then it is possible that the 113 | * current version will be different than the version you compiled against. 114 | * This function returns the current version, while SDL_VERSION() is a 115 | * macro that tells you what version you compiled with. 116 | * 117 | * \code 118 | * SDL_version compiled; 119 | * SDL_version linked; 120 | * 121 | * SDL_VERSION(&compiled); 122 | * SDL_GetVersion(&linked); 123 | * printf("We compiled against SDL version %d.%d.%d ...\n", 124 | * compiled.major, compiled.minor, compiled.patch); 125 | * printf("But we linked against SDL version %d.%d.%d.\n", 126 | * linked.major, linked.minor, linked.patch); 127 | * \endcode 128 | * 129 | * This function may be called safely at any time, even before SDL_Init(). 130 | * 131 | * \sa SDL_VERSION 132 | */ 133 | extern DECLSPEC void SDLCALL SDL_GetVersion(SDL_version * ver); 134 | 135 | /** 136 | * \brief Get the code revision of SDL that is linked against your program. 137 | * 138 | * Returns an arbitrary string (a hash value) uniquely identifying the 139 | * exact revision of the SDL library in use, and is only useful in comparing 140 | * against other revisions. It is NOT an incrementing number. 141 | */ 142 | extern DECLSPEC const char *SDLCALL SDL_GetRevision(void); 143 | 144 | /** 145 | * \brief Get the revision number of SDL that is linked against your program. 146 | * 147 | * Returns a number uniquely identifying the exact revision of the SDL 148 | * library in use. It is an incrementing number based on commits to 149 | * hg.libsdl.org. 150 | */ 151 | extern DECLSPEC int SDLCALL SDL_GetRevisionNumber(void); 152 | 153 | 154 | /* Ends C function definitions when using C++ */ 155 | #ifdef __cplusplus 156 | } 157 | #endif 158 | #include "close_code.h" 159 | 160 | #endif /* SDL_version_h_ */ 161 | 162 | /* vi: set ts=4 sw=4 expandtab: */ 163 | -------------------------------------------------------------------------------- /include/SDL2/begin_code.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file begin_code.h 24 | * 25 | * This file sets things up for C dynamic library function definitions, 26 | * static inlined functions, and structures aligned at 4-byte alignment. 27 | * If you don't like ugly C preprocessor code, don't look at this file. :) 28 | */ 29 | 30 | /* This shouldn't be nested -- included it around code only. */ 31 | #ifdef _begin_code_h 32 | #error Nested inclusion of begin_code.h 33 | #endif 34 | #define _begin_code_h 35 | 36 | #ifndef SDL_DEPRECATED 37 | # if (__GNUC__ >= 4) /* technically, this arrived in gcc 3.1, but oh well. */ 38 | # define SDL_DEPRECATED __attribute__((deprecated)) 39 | # else 40 | # define SDL_DEPRECATED 41 | # endif 42 | #endif 43 | 44 | #ifndef SDL_UNUSED 45 | # ifdef __GNUC__ 46 | # define SDL_UNUSED __attribute__((unused)) 47 | # else 48 | # define SDL_UNUSED 49 | # endif 50 | #endif 51 | 52 | /* Some compilers use a special export keyword */ 53 | #ifndef DECLSPEC 54 | # if defined(__WIN32__) || defined(__WINRT__) 55 | # ifdef __BORLANDC__ 56 | # ifdef BUILD_SDL 57 | # define DECLSPEC 58 | # else 59 | # define DECLSPEC __declspec(dllimport) 60 | # endif 61 | # else 62 | # define DECLSPEC __declspec(dllexport) 63 | # endif 64 | # elif defined(__OS2__) 65 | # ifdef BUILD_SDL 66 | # define DECLSPEC __declspec(dllexport) 67 | # else 68 | # define DECLSPEC 69 | # endif 70 | # else 71 | # if defined(__GNUC__) && __GNUC__ >= 4 72 | # define DECLSPEC __attribute__ ((visibility("default"))) 73 | # else 74 | # define DECLSPEC 75 | # endif 76 | # endif 77 | #endif 78 | 79 | /* By default SDL uses the C calling convention */ 80 | #ifndef SDLCALL 81 | #if (defined(__WIN32__) || defined(__WINRT__)) && !defined(__GNUC__) 82 | #define SDLCALL __cdecl 83 | #elif defined(__OS2__) || defined(__EMX__) 84 | #define SDLCALL _System 85 | # if defined (__GNUC__) && !defined(_System) 86 | # define _System /* for old EMX/GCC compat. */ 87 | # endif 88 | #else 89 | #define SDLCALL 90 | #endif 91 | #endif /* SDLCALL */ 92 | 93 | /* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */ 94 | #ifdef __SYMBIAN32__ 95 | #undef DECLSPEC 96 | #define DECLSPEC 97 | #endif /* __SYMBIAN32__ */ 98 | 99 | /* Force structure packing at 4 byte alignment. 100 | This is necessary if the header is included in code which has structure 101 | packing set to an alternate value, say for loading structures from disk. 102 | The packing is reset to the previous value in close_code.h 103 | */ 104 | #if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__) 105 | #ifdef _MSC_VER 106 | #pragma warning(disable: 4103) 107 | #endif 108 | #ifdef __clang__ 109 | #pragma clang diagnostic ignored "-Wpragma-pack" 110 | #endif 111 | #ifdef __BORLANDC__ 112 | #pragma nopackwarning 113 | #endif 114 | #ifdef _M_X64 115 | /* Use 8-byte alignment on 64-bit architectures, so pointers are aligned */ 116 | #pragma pack(push,8) 117 | #else 118 | #pragma pack(push,4) 119 | #endif 120 | #endif /* Compiler needs structure packing set */ 121 | 122 | #ifndef SDL_INLINE 123 | #if defined(__GNUC__) 124 | #define SDL_INLINE __inline__ 125 | #elif defined(_MSC_VER) || defined(__BORLANDC__) || \ 126 | defined(__DMC__) || defined(__SC__) || \ 127 | defined(__WATCOMC__) || defined(__LCC__) || \ 128 | defined(__DECC) || defined(__CC_ARM) 129 | #define SDL_INLINE __inline 130 | #ifndef __inline__ 131 | #define __inline__ __inline 132 | #endif 133 | #else 134 | #define SDL_INLINE inline 135 | #ifndef __inline__ 136 | #define __inline__ inline 137 | #endif 138 | #endif 139 | #endif /* SDL_INLINE not defined */ 140 | 141 | #ifndef SDL_FORCE_INLINE 142 | #if defined(_MSC_VER) 143 | #define SDL_FORCE_INLINE __forceinline 144 | #elif ( (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) ) 145 | #define SDL_FORCE_INLINE __attribute__((always_inline)) static __inline__ 146 | #else 147 | #define SDL_FORCE_INLINE static SDL_INLINE 148 | #endif 149 | #endif /* SDL_FORCE_INLINE not defined */ 150 | 151 | #ifndef SDL_NORETURN 152 | #if defined(__GNUC__) 153 | #define SDL_NORETURN __attribute__((noreturn)) 154 | #elif defined(_MSC_VER) 155 | #define SDL_NORETURN __declspec(noreturn) 156 | #else 157 | #define SDL_NORETURN 158 | #endif 159 | #endif /* SDL_NORETURN not defined */ 160 | 161 | /* Apparently this is needed by several Windows compilers */ 162 | #if !defined(__MACH__) 163 | #ifndef NULL 164 | #ifdef __cplusplus 165 | #define NULL 0 166 | #else 167 | #define NULL ((void *)0) 168 | #endif 169 | #endif /* NULL */ 170 | #endif /* ! Mac OS X - breaks precompiled headers */ 171 | -------------------------------------------------------------------------------- /include/SDL2/close_code.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2019 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file close_code.h 24 | * 25 | * This file reverses the effects of begin_code.h and should be included 26 | * after you finish any function and structure declarations in your headers 27 | */ 28 | 29 | #ifndef _begin_code_h 30 | #error close_code.h included without matching begin_code.h 31 | #endif 32 | #undef _begin_code_h 33 | 34 | /* Reset structure packing at previous byte alignment */ 35 | #if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__) 36 | #ifdef __BORLANDC__ 37 | #pragma nopackwarning 38 | #endif 39 | #pragma pack(pop) 40 | #endif /* Compiler needs structure packing set */ 41 | -------------------------------------------------------------------------------- /include/chip8.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8_H 2 | #define CHIP8_H 3 | 4 | #include "config.h" 5 | #include "chip8memory.h" 6 | #include "chip8registers.h" 7 | #include "chip8stack.h" 8 | #include "chip8keyboard.h" 9 | #include "chip8screen.h" 10 | #include 11 | struct chip8 12 | { 13 | struct chip8_memory memory; 14 | struct chip8_stack stack; 15 | struct chip8_registers registers; 16 | struct chip8_keyboard keyboard; 17 | struct chip8_screen screen; 18 | }; 19 | 20 | void chip8_init(struct chip8* chip8); 21 | void chip8_load(struct chip8* chip8, const char* buf, size_t size); 22 | void chip8_exec(struct chip8* chip8, unsigned short opcode); 23 | 24 | 25 | #endif -------------------------------------------------------------------------------- /include/chip8keyboard.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8KEYBOARD_H 2 | #define CHIP8KEYBOARD_H 3 | 4 | #include 5 | #include "config.h" 6 | struct chip8_keyboard 7 | { 8 | bool keyboard[CHIP8_TOTAL_KEYS]; 9 | const char* keyboard_map; 10 | }; 11 | 12 | void chip8_keyboard_set_map(struct chip8_keyboard* keyboard, const char* map); 13 | int chip8_keyboard_map(struct chip8_keyboard* keyboard, char key); 14 | void chip8_keyboard_down(struct chip8_keyboard* keyboard, int key); 15 | void chip8_keyboard_up(struct chip8_keyboard* keyboard, int key); 16 | bool chip8_keyboard_is_down(struct chip8_keyboard* keyboard, int key); 17 | 18 | #endif -------------------------------------------------------------------------------- /include/chip8memory.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8MEMORY_H 2 | #define CHIP8MEMORY_H 3 | 4 | #include "config.h" 5 | struct chip8_memory 6 | { 7 | unsigned char memory[CHIP8_MEMORY_SIZE]; 8 | }; 9 | 10 | void chip8_memory_set(struct chip8_memory* memory, int index, unsigned char val); 11 | unsigned char chip8_memory_get(struct chip8_memory* memory, int index); 12 | unsigned short chip8_memory_get_short(struct chip8_memory* memory, int index); 13 | 14 | #endif -------------------------------------------------------------------------------- /include/chip8registers.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8REGISTERS_H 2 | #define CHIP8REGISTERS_H 3 | 4 | #include "config.h" 5 | struct chip8_registers 6 | { 7 | unsigned char V[CHIP8_TOTAL_DATA_REGISTERS]; 8 | unsigned short I; 9 | unsigned char delay_timer; 10 | unsigned char sound_timer; 11 | unsigned short PC; 12 | unsigned char SP; 13 | }; 14 | 15 | #endif -------------------------------------------------------------------------------- /include/chip8screen.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8SCREEN_H 2 | #define CHIP8SCREEN_H 3 | 4 | #include 5 | #include "config.h" 6 | struct chip8_screen 7 | { 8 | bool pixels[CHIP8_HEIGHT][CHIP8_WIDTH]; 9 | }; 10 | 11 | void chip8_screen_clear(struct chip8_screen* screen); 12 | void chip8_screen_set(struct chip8_screen* screen, int x, int y); 13 | bool chip8_screen_is_set(struct chip8_screen* screen, int x, int y); 14 | bool chip8_screen_draw_sprite(struct chip8_screen* screen, int x, int y, const char* sprite, int num); 15 | #endif -------------------------------------------------------------------------------- /include/chip8stack.h: -------------------------------------------------------------------------------- 1 | #ifndef CHIP8STACK_H 2 | #define CHIP8STACK_H 3 | #include "config.h" 4 | 5 | struct chip8; 6 | struct chip8_stack 7 | { 8 | unsigned short stack[CHIP8_TOTAL_STACK_DEPTH]; 9 | }; 10 | 11 | void chip8_stack_push(struct chip8* chip8, unsigned short val); 12 | unsigned short chip8_stack_pop(struct chip8* chip8); 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /include/config.h: -------------------------------------------------------------------------------- 1 | #ifndef CONFIG_H 2 | #define CONFIG_H 3 | 4 | #define EMULATOR_WINDOW_TITLE "Chip8 Emulator" 5 | #define CHIP8_MEMORY_SIZE 4096 6 | #define CHIP8_PROGRAM_LOAD_ADDRESS 0x200 7 | 8 | #define CHIP8_WIDTH 64 9 | #define CHIP8_HEIGHT 32 10 | #define CHIP8_WINDOW_MULTIPLIER 10 11 | 12 | 13 | #define CHIP8_TOTAL_DATA_REGISTERS 16 14 | #define CHIP8_TOTAL_STACK_DEPTH 16 15 | #define CHIP8_TOTAL_KEYS 16 16 | #define CHIP8_CHARACTER_SET_LOAD_ADDRESS 0x00 17 | #define CHIP8_DEFAULT_SPRITE_HEIGHT 5 18 | #endif -------------------------------------------------------------------------------- /lib/libSDL2.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/lib/libSDL2.a -------------------------------------------------------------------------------- /lib/libSDL2.dll.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/lib/libSDL2.dll.a -------------------------------------------------------------------------------- /lib/libSDL2.la: -------------------------------------------------------------------------------- 1 | # libSDL2.la - a libtool library file 2 | # Generated by libtool (GNU libtool) 2.4.2 3 | # 4 | # Please DO NOT delete this file! 5 | # It is necessary for linking the library. 6 | 7 | # The name that we can dlopen(3). 8 | dlname='../bin/SDL2.dll' 9 | 10 | # Names of this library. 11 | library_names='libSDL2.dll.a' 12 | 13 | # The name of the static archive. 14 | old_library='libSDL2.a' 15 | 16 | # Linker flags that can not go in dependency_libs. 17 | inherited_linker_flags='' 18 | 19 | # Libraries that this one depends upon. 20 | dependency_libs=' -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid' 21 | 22 | # Names of additional weak libraries provided by this library 23 | weak_library_names='' 24 | 25 | # Version information for libSDL2. 26 | current=10 27 | age=10 28 | revision=0 29 | 30 | # Is this an already installed library? 31 | installed=yes 32 | 33 | # Should we warn about portability when linking against -modules? 34 | shouldnotlink=no 35 | 36 | # Files to dlopen/dlpreopen 37 | dlopen='' 38 | dlpreopen='' 39 | 40 | # Directory that this library needs to be installed in: 41 | libdir='/Users/valve/release/SDL/SDL2-2.0.10/i686-w64-mingw32/lib' 42 | -------------------------------------------------------------------------------- /lib/libSDL2_test.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/lib/libSDL2_test.a -------------------------------------------------------------------------------- /lib/libSDL2_test.la: -------------------------------------------------------------------------------- 1 | # libSDL2_test.la - a libtool library file 2 | # Generated by libtool (GNU libtool) 2.4.2 3 | # 4 | # Please DO NOT delete this file! 5 | # It is necessary for linking the library. 6 | 7 | # The name that we can dlopen(3). 8 | dlname='' 9 | 10 | # Names of this library. 11 | library_names='' 12 | 13 | # The name of the static archive. 14 | old_library='libSDL2_test.a' 15 | 16 | # Linker flags that can not go in dependency_libs. 17 | inherited_linker_flags='' 18 | 19 | # Libraries that this one depends upon. 20 | dependency_libs='' 21 | 22 | # Names of additional weak libraries provided by this library 23 | weak_library_names='' 24 | 25 | # Version information for libSDL2_test. 26 | current=0 27 | age=0 28 | revision=0 29 | 30 | # Is this an already installed library? 31 | installed=yes 32 | 33 | # Should we warn about portability when linking against -modules? 34 | shouldnotlink=no 35 | 36 | # Files to dlopen/dlpreopen 37 | dlopen='' 38 | dlpreopen='' 39 | 40 | # Directory that this library needs to be installed in: 41 | libdir='/Users/valve/release/SDL/SDL2-2.0.10/i686-w64-mingw32/lib' 42 | -------------------------------------------------------------------------------- /lib/libSDL2main.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nibblebits/Chip8InCCourse/71ccb5619d020daef23a174e298791bafd3806f9/lib/libSDL2main.a -------------------------------------------------------------------------------- /lib/libSDL2main.la: -------------------------------------------------------------------------------- 1 | # libSDL2main.la - a libtool library file 2 | # Generated by libtool (GNU libtool) 2.4.2 3 | # 4 | # Please DO NOT delete this file! 5 | # It is necessary for linking the library. 6 | 7 | # The name that we can dlopen(3). 8 | dlname='' 9 | 10 | # Names of this library. 11 | library_names='' 12 | 13 | # The name of the static archive. 14 | old_library='libSDL2main.a' 15 | 16 | # Linker flags that can not go in dependency_libs. 17 | inherited_linker_flags='' 18 | 19 | # Libraries that this one depends upon. 20 | dependency_libs='' 21 | 22 | # Names of additional weak libraries provided by this library 23 | weak_library_names='' 24 | 25 | # Version information for libSDL2main. 26 | current=0 27 | age=0 28 | revision=0 29 | 30 | # Is this an already installed library? 31 | installed=yes 32 | 33 | # Should we warn about portability when linking against -modules? 34 | shouldnotlink=no 35 | 36 | # Files to dlopen/dlpreopen 37 | dlopen='' 38 | dlpreopen='' 39 | 40 | # Directory that this library needs to be installed in: 41 | libdir='/Users/valve/release/SDL/SDL2-2.0.10/i686-w64-mingw32/lib' 42 | -------------------------------------------------------------------------------- /src/chip8keyboard.c: -------------------------------------------------------------------------------- 1 | #include "chip8keyboard.h" 2 | #include 3 | static void chip8_keyboard_ensure_in_bounds(int key) 4 | { 5 | assert(key >= 0 && key < CHIP8_TOTAL_KEYS); 6 | } 7 | 8 | void chip8_keyboard_set_map(struct chip8_keyboard* keyboard, const char* map) 9 | { 10 | keyboard->keyboard_map = map; 11 | } 12 | 13 | int chip8_keyboard_map(struct chip8_keyboard* keyboard, char key) 14 | { 15 | 16 | for (int i = 0; i < CHIP8_TOTAL_KEYS; i++) 17 | { 18 | if (keyboard->keyboard_map[i] == key) 19 | { 20 | return i; 21 | } 22 | } 23 | 24 | return -1; 25 | } 26 | 27 | void chip8_keyboard_down(struct chip8_keyboard* keyboard, int key) 28 | { 29 | keyboard->keyboard[key] = true; 30 | } 31 | 32 | void chip8_keyboard_up(struct chip8_keyboard* keyboard, int key) 33 | { 34 | keyboard->keyboard[key] = false; 35 | } 36 | 37 | bool chip8_keyboard_is_down(struct chip8_keyboard* keyboard, int key) 38 | { 39 | return keyboard->keyboard[key]; 40 | } -------------------------------------------------------------------------------- /src/chip8memory.c: -------------------------------------------------------------------------------- 1 | #include "chip8memory.h" 2 | #include 3 | 4 | static void chip8_is_memory_in_bounds(int index) 5 | { 6 | assert(index >= 0 && index < CHIP8_MEMORY_SIZE); 7 | } 8 | 9 | void chip8_memory_set(struct chip8_memory* memory, int index, unsigned char val) 10 | { 11 | chip8_is_memory_in_bounds(index); 12 | memory->memory[index] = val; 13 | } 14 | 15 | unsigned char chip8_memory_get(struct chip8_memory* memory, int index) 16 | { 17 | chip8_is_memory_in_bounds(index); 18 | return memory->memory[index]; 19 | } 20 | 21 | unsigned short chip8_memory_get_short(struct chip8_memory* memory, int index) 22 | { 23 | unsigned char byte1 = chip8_memory_get(memory, index); 24 | unsigned char byte2 = chip8_memory_get(memory, index+1); 25 | return byte1 << 8 | byte2; 26 | } -------------------------------------------------------------------------------- /src/chip8screen.c: -------------------------------------------------------------------------------- 1 | #include "chip8screen.h" 2 | #include 3 | #include 4 | 5 | 6 | static void chip8_screen_check_bounds(int x, int y) 7 | { 8 | assert(x >= 0 && x < CHIP8_WIDTH && y >= 0 && y < CHIP8_HEIGHT); 9 | } 10 | 11 | void chip8_screen_set(struct chip8_screen* screen, int x, int y) 12 | { 13 | chip8_screen_check_bounds(x, y); 14 | screen->pixels[y][x] = true; 15 | } 16 | 17 | 18 | void chip8_screen_clear(struct chip8_screen* screen) 19 | { 20 | memset(screen->pixels, 0, sizeof(screen->pixels)); 21 | } 22 | 23 | bool chip8_screen_is_set(struct chip8_screen* screen, int x, int y) 24 | { 25 | chip8_screen_check_bounds(x, y); 26 | return screen->pixels[y][x]; 27 | } 28 | 29 | bool chip8_screen_draw_sprite(struct chip8_screen* screen, int x, int y, const char* sprite, int num) 30 | { 31 | bool pixel_collison = false; 32 | 33 | for (int ly = 0; ly < num; ly++) 34 | { 35 | char c = sprite[ly]; 36 | for (int lx = 0; lx < 8; lx++) 37 | { 38 | if ((c & (0b10000000 >> lx)) == 0) 39 | continue; 40 | 41 | if (screen->pixels[(ly+y) % CHIP8_HEIGHT][(lx+x) % CHIP8_WIDTH]) 42 | { 43 | pixel_collison = true; 44 | } 45 | 46 | screen->pixels[(ly+y) % CHIP8_HEIGHT][(lx+x) % CHIP8_WIDTH] ^= true; 47 | } 48 | } 49 | return pixel_collison; 50 | } -------------------------------------------------------------------------------- /src/chip8stack.c: -------------------------------------------------------------------------------- 1 | #include "chip8stack.h" 2 | #include "chip8.h" 3 | #include 4 | 5 | static void chip8_stack_in_bounds(struct chip8* chip8) 6 | { 7 | assert(chip8->registers.SP < sizeof(chip8->stack.stack)); 8 | } 9 | 10 | void chip8_stack_push(struct chip8* chip8, unsigned short val) 11 | { 12 | chip8->registers.SP += 1; 13 | chip8_stack_in_bounds(chip8); 14 | 15 | chip8->stack.stack[chip8->registers.SP] = val; 16 | } 17 | 18 | unsigned short chip8_stack_pop(struct chip8* chip8) 19 | { 20 | chip8_stack_in_bounds(chip8); 21 | 22 | unsigned short result = chip8->stack.stack[chip8->registers.SP]; 23 | chip8->registers.SP -=1; 24 | return result; 25 | } -------------------------------------------------------------------------------- /src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "SDL2/SDL.h" 5 | #include "chip8.h" 6 | #include "chip8keyboard.h" 7 | 8 | const char keyboard_map[CHIP8_TOTAL_KEYS] = { 9 | SDLK_0, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, 10 | SDLK_6, SDLK_7, SDLK_8, SDLK_9, SDLK_a, SDLK_b, 11 | SDLK_c, SDLK_d, SDLK_e, SDLK_f}; 12 | 13 | int main(int argc, char **argv) 14 | { 15 | 16 | if (argc < 2) 17 | { 18 | printf("You must provide a file to load\n"); 19 | return -1; 20 | } 21 | 22 | const char* filename = argv[1]; 23 | printf("The filename to load is: %s\n", filename); 24 | 25 | FILE* f = fopen(filename, "rb"); 26 | if (!f) 27 | { 28 | printf("Failed to open the file"); 29 | return -1; 30 | } 31 | 32 | fseek(f, 0, SEEK_END); 33 | long size = ftell(f); 34 | fseek(f, 0, SEEK_SET); 35 | 36 | char buf[size]; 37 | int res = fread(buf, size, 1, f); 38 | if (res != 1) 39 | { 40 | printf("Failed to read from file"); 41 | return -1; 42 | } 43 | 44 | struct chip8 chip8; 45 | chip8_init(&chip8); 46 | chip8_load(&chip8, buf, size); 47 | chip8_keyboard_set_map(&chip8.keyboard, keyboard_map); 48 | 49 | 50 | SDL_Init(SDL_INIT_EVERYTHING); 51 | SDL_Window *window = SDL_CreateWindow( 52 | EMULATOR_WINDOW_TITLE, 53 | SDL_WINDOWPOS_UNDEFINED, 54 | SDL_WINDOWPOS_UNDEFINED, 55 | CHIP8_WIDTH * CHIP8_WINDOW_MULTIPLIER, 56 | CHIP8_HEIGHT * CHIP8_WINDOW_MULTIPLIER, SDL_WINDOW_SHOWN); 57 | 58 | SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_TEXTUREACCESS_TARGET); 59 | 60 | while (1) 61 | { 62 | SDL_Event event; 63 | while (SDL_PollEvent(&event)) 64 | { 65 | switch (event.type) 66 | { 67 | case SDL_QUIT: 68 | goto out; 69 | break; 70 | 71 | case SDL_KEYDOWN: 72 | { 73 | char key = event.key.keysym.sym; 74 | int vkey = chip8_keyboard_map(&chip8.keyboard, key); 75 | if (vkey != -1) 76 | { 77 | chip8_keyboard_down(&chip8.keyboard, vkey); 78 | } 79 | } 80 | break; 81 | 82 | case SDL_KEYUP: 83 | { 84 | char key = event.key.keysym.sym; 85 | int vkey = chip8_keyboard_map(&chip8.keyboard, key); 86 | if (vkey != -1) 87 | { 88 | chip8_keyboard_up(&chip8.keyboard, vkey); 89 | } 90 | } 91 | break; 92 | }; 93 | } 94 | 95 | SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); 96 | SDL_RenderClear(renderer); 97 | SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0); 98 | 99 | for (int x = 0; x < CHIP8_WIDTH; x++) 100 | { 101 | for (int y = 0; y < CHIP8_HEIGHT; y++) 102 | { 103 | if (chip8_screen_is_set(&chip8.screen, x, y)) 104 | { 105 | SDL_Rect r; 106 | r.x = x * CHIP8_WINDOW_MULTIPLIER; 107 | r.y = y * CHIP8_WINDOW_MULTIPLIER; 108 | r.w = CHIP8_WINDOW_MULTIPLIER; 109 | r.h = CHIP8_WINDOW_MULTIPLIER; 110 | SDL_RenderFillRect(renderer, &r); 111 | } 112 | } 113 | } 114 | 115 | SDL_RenderPresent(renderer); 116 | if (chip8.registers.delay_timer > 0) 117 | { 118 | Sleep(1); 119 | chip8.registers.delay_timer -=1; 120 | } 121 | 122 | if (chip8.registers.sound_timer > 0) 123 | { 124 | Beep(15000, 10 * chip8.registers.sound_timer); 125 | chip8.registers.sound_timer = 0; 126 | } 127 | 128 | unsigned short opcode = chip8_memory_get_short(&chip8.memory, chip8.registers.PC); 129 | chip8.registers.PC += 2; 130 | chip8_exec(&chip8, opcode); 131 | } 132 | 133 | out: 134 | SDL_DestroyWindow(window); 135 | return 0; 136 | } --------------------------------------------------------------------------------