summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorrealtradam <[email protected]>2022-04-14 08:37:05 -0400
committerrealtradam <[email protected]>2022-04-14 08:37:05 -0400
commit20a0d29ccc3a330691519b285121f564374b8eb5 (patch)
tree46445dac6f1edb94ce4a3dd9a3f4e7ef290daccb
downloadzig-chip-8-20a0d29ccc3a330691519b285121f564374b8eb5.tar.gz
zig-chip-8-20a0d29ccc3a330691519b285121f564374b8eb5.zip
init
Diffstat
-rw-r--r--.gitignore6
-rw-r--r--build.zig44
-rw-r--r--include/LICENSE16
-rw-r--r--include/raygui.h4342
-rw-r--r--include/raylib.h1555
-rw-r--r--roms/IBM Logo.ch8bin0 -> 132 bytes
-rw-r--r--src/main.zig84
-rw-r--r--src/raylib.zig8789
8 files changed, 14836 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6b5cd24
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+zig-cache
+zig-cache/*
+zig-out
+zig-out/*
+src/zig-cache
+src/zig-cache/*
diff --git a/build.zig b/build.zig
new file mode 100644
index 0000000..f8394ee
--- /dev/null
+++ b/build.zig
@@ -0,0 +1,44 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+ // Standard target options allows the person running `zig build` to choose
+ // what target to build for. Here we do not override the defaults, which
+ // means any target is allowed, and the default is native. Other options
+ // for restricting supported target set are available.
+ const target = b.standardTargetOptions(.{});
+
+ // Standard release options allow the person running `zig build` to select
+ // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
+ const mode = b.standardReleaseOptions();
+
+ const exe = b.addExecutable("testraylib", "src/main.zig");
+ exe.linkSystemLibrary("c");
+ exe.linkSystemLibrary("raylib");
+ //exe.linkSystemLibrary("extras/raygui");
+ //exe.addStaticLibrary("raygui", getSrcDir() ++ "/include/raygui.h");
+ exe.setTarget(target);
+ exe.setBuildMode(mode);
+ exe.install();
+
+ const run_cmd = exe.run();
+ run_cmd.step.dependOn(b.getInstallStep());
+ if (b.args) |args| {
+ run_cmd.addArgs(args);
+ }
+
+ const run_step = b.step("run", "Run the app");
+ run_step.dependOn(&run_cmd.step);
+
+ const exe_tests = b.addTest("src/main.zig");
+ exe_tests.setTarget(target);
+ exe_tests.setBuildMode(mode);
+
+ const test_step = b.step("test", "Run unit tests");
+ test_step.dependOn(&exe_tests.step);
+}
+
+const srcdir = getSrcDir();
+
+fn getSrcDir() []const u8 {
+ return std.fs.path.dirname(@src().file) orelse ".";
+}
diff --git a/include/LICENSE b/include/LICENSE
new file mode 100644
index 0000000..2694b47
--- /dev/null
+++ b/include/LICENSE
@@ -0,0 +1,16 @@
+Copyright (c) 2013-2022 Ramon Santamaria (@raysan5)
+
+This software is provided "as-is", without any express or implied warranty. In no event
+will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial
+applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not claim that you
+ wrote the original software. If you use this software in a product, an acknowledgment
+ in the product documentation would be appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented
+ as being the original software.
+
+ 3. This notice may not be removed or altered from any source distribution.
diff --git a/include/raygui.h b/include/raygui.h
new file mode 100644
index 0000000..dfb7792
--- /dev/null
+++ b/include/raygui.h
@@ -0,0 +1,4342 @@
+/*******************************************************************************************
+*
+* raygui v3.0 - A simple and easy-to-use immediate-mode gui library
+*
+* DESCRIPTION:
+*
+* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also
+* available as a standalone library, as long as input and drawing functions are provided.
+*
+* Controls provided:
+*
+* # Container/separators Controls
+* - WindowBox
+* - GroupBox
+* - Line
+* - Panel
+*
+* # Basic Controls
+* - Label
+* - Button
+* - LabelButton --> Label
+* - Toggle
+* - ToggleGroup --> Toggle
+* - CheckBox
+* - ComboBox
+* - DropdownBox
+* - TextBox
+* - TextBoxMulti
+* - ValueBox --> TextBox
+* - Spinner --> Button, ValueBox
+* - Slider
+* - SliderBar --> Slider
+* - ProgressBar
+* - StatusBar
+* - ScrollBar
+* - ScrollPanel
+* - DummyRec
+* - Grid
+*
+* # Advance Controls
+* - ListView
+* - ColorPicker --> ColorPanel, ColorBarHue
+* - MessageBox --> Window, Label, Button
+* - TextInputBox --> Window, Label, TextBox, Button
+*
+* It also provides a set of functions for styling the controls based on its properties (size, color).
+*
+*
+* GUI STYLE (guiStyle):
+*
+* raygui uses a global data array for all gui style properties (allocated on data segment by default),
+* when a new style is loaded, it is loaded over the global style... but a default gui style could always be
+* recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one
+*
+* The global style array size is fixed and depends on the number of controls and properties:
+*
+* static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)];
+*
+* guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB
+*
+* Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style
+* used for all controls, when any of those base values is set, it is automatically populated to all
+* controls, so, specific control values overwriting generic style should be set after base values.
+*
+* After the first BASE set we have the EXTENDED properties (by default guiStyle[16..23]), those
+* properties are actually common to all controls and can not be overwritten individually (like BASE ones)
+* Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR
+*
+* Custom control properties can be defined using the EXTENDED properties for each independent control.
+*
+* TOOL: rGuiStyler is a visual tool to customize raygui style.
+*
+*
+* GUI ICONS (guiIcons):
+*
+* raygui could use a global array containing icons data (allocated on data segment by default),
+* a custom icons set could be loaded over this array using GuiLoadIcons(), but loaded icons set
+* must be same RICON_SIZE and no more than RICON_MAX_ICONS will be loaded
+*
+* Every icon is codified in binary form, using 1 bit per pixel, so, every 16x16 icon
+* requires 8 integers (16*16/32) to be stored in memory.
+*
+* When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set.
+*
+* The global icons array size is fixed and depends on the number of icons and size:
+*
+* static unsigned int guiIcons[RICON_MAX_ICONS*RICON_DATA_ELEMENTS];
+*
+* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB
+*
+* TOOL: rGuiIcons is a visual tool to customize raygui icons.
+*
+*
+* CONFIGURATION:
+*
+* #define RAYGUI_IMPLEMENTATION
+* Generates the implementation of the library into the included file.
+* If not defined, the library is in header only mode and can be included in other headers
+* or source files without problems. But only ONE file should hold the implementation.
+*
+* #define RAYGUI_STANDALONE
+* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined
+* internally in the library and input management and drawing functions must be provided by
+* the user (check library implementation for further details).
+*
+* #define RAYGUI_NO_RICONS
+* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB)
+*
+* #define RAYGUI_CUSTOM_RICONS
+* Includes custom ricons.h header defining a set of custom icons,
+* this file can be generated using rGuiIcons tool
+*
+*
+* VERSIONS HISTORY:
+*
+* 3.0 (xx-Sep-2021) Integrated ricons data to avoid external file
+* REDESIGNED: GuiTextBoxMulti()
+* REMOVED: GuiImageButton*()
+* Multiple minor tweaks and bugs corrected
+* 2.9 (17-Mar-2021) REMOVED: Tooltip API
+* 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle()
+* 2.7 (20-Feb-2020) ADDED: Possible tooltips API
+* 2.6 (09-Sep-2019) ADDED: GuiTextInputBox()
+* REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox()
+* REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle()
+* Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties
+* ADDED: 8 new custom styles ready to use
+* Multiple minor tweaks and bugs corrected
+* 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner()
+* 2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed
+* Refactor all controls drawing mechanism to use control state
+* 2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls
+* 2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string
+* REDESIGNED: Style system (breaking change)
+* 2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts
+* REVIEWED: GuiComboBox(), GuiListView()...
+* 1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()...
+* 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout
+* 1.5 (21-Jun-2017) Working in an improved styles system
+* 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones)
+* 1.3 (12-Jun-2017) Complete redesign of style system
+* 1.1 (01-Jun-2017) Complete review of the library
+* 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria.
+* 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria.
+* 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria.
+*
+*
+* CONTRIBUTORS:
+*
+* Ramon Santamaria: Supervision, review, redesign, update and maintenance
+* Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019)
+* Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018)
+* Adria Arranz: Testing and Implementation of additional controls (2018)
+* Jordi Jorba: Testing and Implementation of additional controls (2018)
+* Albert Martos: Review and testing of the library (2015)
+* Ian Eito: Review and testing of the library (2015)
+* Kevin Gato: Initial implementation of basic components (2014)
+* Daniel Nicolas: Initial implementation of basic components (2014)
+*
+*
+* LICENSE: zlib/libpng
+*
+* Copyright (c) 2014-2021 Ramon Santamaria (@raysan5)
+*
+* This software is provided "as-is", without any express or implied warranty. In no event
+* will the authors be held liable for any damages arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose, including commercial
+* applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not claim that you
+* wrote the original software. If you use this software in a product, an acknowledgment
+* in the product documentation would be appreciated but is not required.
+*
+* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
+* as being the original software.
+*
+* 3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+#ifndef RAYGUI_H
+#define RAYGUI_H
+
+#define RAYGUI_VERSION "3.0"
+
+#if !defined(RAYGUI_STANDALONE)
+ #include "raylib.h"
+#endif
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+#if defined(_WIN32)
+ #if defined(BUILD_LIBTYPE_SHARED)
+ #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll)
+ #elif defined(USE_LIBTYPE_SHARED)
+ #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll)
+ #endif
+#endif
+
+// Function specifiers definition
+#ifndef RAYGUIAPI
+ #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+// Allow custom memory allocators
+#ifndef RAYGUI_MALLOC
+ #define RAYGUI_MALLOC(sz) malloc(sz)
+#endif
+#ifndef RAYGUI_CALLOC
+ #define RAYGUI_CALLOC(n,sz) calloc(n,sz)
+#endif
+#ifndef RAYGUI_FREE
+ #define RAYGUI_FREE(p) free(p)
+#endif
+
+// TODO: Implement custom TraceLog()
+#define TRACELOG(level, ...) (void)0
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+// NOTE: Some types are required for RAYGUI_STANDALONE usage
+//----------------------------------------------------------------------------------
+#if defined(RAYGUI_STANDALONE)
+ #ifndef __cplusplus
+ // Boolean type
+ #ifndef true
+ typedef enum { false, true } bool;
+ #endif
+ #endif
+
+ // Vector2 type
+ typedef struct Vector2 {
+ float x;
+ float y;
+ } Vector2;
+
+ // Vector3 type // -- ConvertHSVtoRGB(), ConvertRGBtoHSV()
+ typedef struct Vector3 {
+ float x;
+ float y;
+ float z;
+ } Vector3;
+
+ // Color type, RGBA (32bit)
+ typedef struct Color {
+ unsigned char r;
+ unsigned char g;
+ unsigned char b;
+ unsigned char a;
+ } Color;
+
+ // Rectangle type
+ typedef struct Rectangle {
+ float x;
+ float y;
+ float width;
+ float height;
+ } Rectangle;
+
+ // TODO: Texture2D type is very coupled to raylib, required by Font type
+ // It should be redesigned to be provided by user
+ typedef struct Texture2D {
+ unsigned int id; // OpenGL texture id
+ int width; // Texture base width
+ int height; // Texture base height
+ int mipmaps; // Mipmap levels, 1 by default
+ int format; // Data format (PixelFormat type)
+ } Texture2D;
+
+ // GlyphInfo, font characters glyphs info
+ typedef struct GlyphInfo {
+ int value; // Character value (Unicode)
+ int offsetX; // Character offset X when drawing
+ int offsetY; // Character offset Y when drawing
+ int advanceX; // Character advance position X
+ Image image; // Character image data
+ } GlyphInfo;
+
+ // TODO: Font type is very coupled to raylib, mostly required by GuiLoadStyle()
+ // It should be redesigned to be provided by user
+ typedef struct Font {
+ int baseSize; // Base size (default chars height)
+ int glyphCount; // Number of characters
+ Texture2D texture; // Characters texture atlas
+ Rectangle *recs; // Characters rectangles in texture
+ GlyphInfo *chars; // Characters info data
+ } Font;
+#endif
+
+// Style property
+typedef struct GuiStyleProp {
+ unsigned short controlId;
+ unsigned short propertyId;
+ int propertyValue;
+} GuiStyleProp;
+
+// Gui control state
+typedef enum {
+ GUI_STATE_NORMAL = 0,
+ GUI_STATE_FOCUSED,
+ GUI_STATE_PRESSED,
+ GUI_STATE_DISABLED,
+} GuiControlState;
+
+// Gui control text alignment
+typedef enum {
+ GUI_TEXT_ALIGN_LEFT = 0,
+ GUI_TEXT_ALIGN_CENTER,
+ GUI_TEXT_ALIGN_RIGHT,
+} GuiTextAlignment;
+
+// Gui controls
+typedef enum {
+ DEFAULT = 0, // Generic control -> populates to all controls when set
+ LABEL, // Used also for: LABELBUTTON
+ BUTTON,
+ TOGGLE, // Used also for: TOGGLEGROUP
+ SLIDER, // Used also for: SLIDERBAR
+ PROGRESSBAR,
+ CHECKBOX,
+ COMBOBOX,
+ DROPDOWNBOX,
+ TEXTBOX, // Used also for: TEXTBOXMULTI
+ VALUEBOX,
+ SPINNER,
+ LISTVIEW,
+ COLORPICKER,
+ SCROLLBAR,
+ STATUSBAR
+} GuiControl;
+
+// Gui base properties for every control
+// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties)
+typedef enum {
+ BORDER_COLOR_NORMAL = 0,
+ BASE_COLOR_NORMAL,
+ TEXT_COLOR_NORMAL,
+ BORDER_COLOR_FOCUSED,
+ BASE_COLOR_FOCUSED,
+ TEXT_COLOR_FOCUSED,
+ BORDER_COLOR_PRESSED,
+ BASE_COLOR_PRESSED,
+ TEXT_COLOR_PRESSED,
+ BORDER_COLOR_DISABLED,
+ BASE_COLOR_DISABLED,
+ TEXT_COLOR_DISABLED,
+ BORDER_WIDTH,
+ TEXT_PADDING,
+ TEXT_ALIGNMENT,
+ RESERVED
+} GuiControlProperty;
+
+// Gui extended properties depend on control
+// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default 8 properties)
+
+// DEFAULT extended properties
+// NOTE: Those properties are actually common to all controls
+typedef enum {
+ TEXT_SIZE = 16,
+ TEXT_SPACING,
+ LINE_COLOR,
+ BACKGROUND_COLOR,
+} GuiDefaultProperty;
+
+// Label
+//typedef enum { } GuiLabelProperty;
+
+// Button
+//typedef enum { } GuiButtonProperty;
+
+// Toggle/ToggleGroup
+typedef enum {
+ GROUP_PADDING = 16,
+} GuiToggleProperty;
+
+// Slider/SliderBar
+typedef enum {
+ SLIDER_WIDTH = 16,
+ SLIDER_PADDING
+} GuiSliderProperty;
+
+// ProgressBar
+typedef enum {
+ PROGRESS_PADDING = 16,
+} GuiProgressBarProperty;
+
+// CheckBox
+typedef enum {
+ CHECK_PADDING = 16
+} GuiCheckBoxProperty;
+
+// ComboBox
+typedef enum {
+ COMBO_BUTTON_WIDTH = 16,
+ COMBO_BUTTON_PADDING
+} GuiComboBoxProperty;
+
+// DropdownBox
+typedef enum {
+ ARROW_PADDING = 16,
+ DROPDOWN_ITEMS_PADDING
+} GuiDropdownBoxProperty;
+
+// TextBox/TextBoxMulti/ValueBox/Spinner
+typedef enum {
+ TEXT_INNER_PADDING = 16,
+ TEXT_LINES_PADDING,
+ COLOR_SELECTED_FG,
+ COLOR_SELECTED_BG
+} GuiTextBoxProperty;
+
+// Spinner
+typedef enum {
+ SPIN_BUTTON_WIDTH = 16,
+ SPIN_BUTTON_PADDING,
+} GuiSpinnerProperty;
+
+// ScrollBar
+typedef enum {
+ ARROWS_SIZE = 16,
+ ARROWS_VISIBLE,
+ SCROLL_SLIDER_PADDING,
+ SCROLL_SLIDER_SIZE,
+ SCROLL_PADDING,
+ SCROLL_SPEED,
+} GuiScrollBarProperty;
+
+// ScrollBar side
+typedef enum {
+ SCROLLBAR_LEFT_SIDE = 0,
+ SCROLLBAR_RIGHT_SIDE
+} GuiScrollBarSide;
+
+// ListView
+typedef enum {
+ LIST_ITEMS_HEIGHT = 16,
+ LIST_ITEMS_PADDING,
+ SCROLLBAR_WIDTH,
+ SCROLLBAR_SIDE,
+} GuiListViewProperty;
+
+// ColorPicker
+typedef enum {
+ COLOR_SELECTOR_SIZE = 16,
+ HUEBAR_WIDTH, // Right hue bar width
+ HUEBAR_PADDING, // Right hue bar separation from panel
+ HUEBAR_SELECTOR_HEIGHT, // Right hue bar selector height
+ HUEBAR_SELECTOR_OVERFLOW // Right hue bar selector overflow
+} GuiColorPickerProperty;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+// ...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+extern "C" { // Prevents name mangling of functions
+#endif
+
+// Global gui state control functions
+RAYGUIAPI void GuiEnable(void); // Enable gui controls (global state)
+RAYGUIAPI void GuiDisable(void); // Disable gui controls (global state)
+RAYGUIAPI void GuiLock(void); // Lock gui controls (global state)
+RAYGUIAPI void GuiUnlock(void); // Unlock gui controls (global state)
+RAYGUIAPI bool GuiIsLocked(void); // Check if gui is locked (global state)
+RAYGUIAPI void GuiFade(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
+RAYGUIAPI void GuiSetState(int state); // Set gui state (global state)
+RAYGUIAPI int GuiGetState(void); // Get gui state (global state)
+
+// Font set/get functions
+RAYGUIAPI void GuiSetFont(Font font); // Set gui custom font (global state)
+RAYGUIAPI Font GuiGetFont(void); // Get gui custom font (global state)
+
+// Style set/get functions
+RAYGUIAPI void GuiSetStyle(int control, int property, int value); // Set one style property
+RAYGUIAPI int GuiGetStyle(int control, int property); // Get one style property
+
+// Container/separator controls, useful for controls organization
+RAYGUIAPI bool GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed
+RAYGUIAPI void GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name
+RAYGUIAPI void GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text
+RAYGUIAPI void GuiPanel(Rectangle bounds); // Panel control, useful to group controls
+RAYGUIAPI Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll); // Scroll Panel control
+
+// Basic controls set
+RAYGUIAPI void GuiLabel(Rectangle bounds, const char *text); // Label control, shows text
+RAYGUIAPI bool GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked
+RAYGUIAPI bool GuiLabelButton(Rectangle bounds, const char *text); // Label button control, show true when clicked
+RAYGUIAPI bool GuiToggle(Rectangle bounds, const char *text, bool active); // Toggle Button control, returns true when active
+RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int active); // Toggle Group control, returns active toggle index
+RAYGUIAPI bool GuiCheckBox(Rectangle bounds, const char *text, bool checked); // Check Box control, returns true when active
+RAYGUIAPI int GuiComboBox(Rectangle bounds, const char *text, int active); // Combo Box control, returns selected item index
+RAYGUIAPI bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control, returns selected item
+RAYGUIAPI bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control, returns selected value
+RAYGUIAPI bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers
+RAYGUIAPI bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text
+RAYGUIAPI bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control with multiple lines
+RAYGUIAPI float GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider control, returns selected value
+RAYGUIAPI float GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider Bar control, returns selected value
+RAYGUIAPI float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Progress Bar control, shows current progress value
+RAYGUIAPI void GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text
+RAYGUIAPI void GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders
+RAYGUIAPI int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue); // Scroll Bar control
+RAYGUIAPI Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs); // Grid control
+
+
+// Advance controls set
+RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int active); // List View control, returns selected list item index
+RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, int *scrollIndex, int active); // List View with extended parameters
+RAYGUIAPI int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons); // Message Box control, displays a message
+RAYGUIAPI int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text); // Text Input Box control, ask for text
+RAYGUIAPI Color GuiColorPicker(Rectangle bounds, Color color); // Color Picker control (multiple color controls)
+RAYGUIAPI Color GuiColorPanel(Rectangle bounds, Color color); // Color Panel control
+RAYGUIAPI float GuiColorBarAlpha(Rectangle bounds, float alpha); // Color Bar Alpha control
+RAYGUIAPI float GuiColorBarHue(Rectangle bounds, float value); // Color Bar Hue control
+
+// Styles loading functions
+RAYGUIAPI void GuiLoadStyle(const char *fileName); // Load style file over global style variable (.rgs)
+RAYGUIAPI void GuiLoadStyleDefault(void); // Load style default over global style
+
+/*
+typedef GuiStyle (unsigned int *)
+RAYGUIAPI GuiStyle LoadGuiStyle(const char *fileName); // Load style from file (.rgs)
+RAYGUIAPI void UnloadGuiStyle(GuiStyle style); // Unload style
+*/
+
+RAYGUIAPI const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported)
+
+#if !defined(RAYGUI_NO_RICONS)
+// Gui icons functionality
+RAYGUIAPI void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color);
+
+RAYGUIAPI unsigned int *GuiGetIcons(void); // Get full icons data pointer
+RAYGUIAPI unsigned int *GuiGetIconData(int iconId); // Get icon bit data
+RAYGUIAPI void GuiSetIconData(int iconId, unsigned int *data); // Set icon bit data
+
+RAYGUIAPI void GuiSetIconPixel(int iconId, int x, int y); // Set icon pixel value
+RAYGUIAPI void GuiClearIconPixel(int iconId, int x, int y); // Clear icon pixel value
+RAYGUIAPI bool GuiCheckIconPixel(int iconId, int x, int y); // Check icon pixel value
+#endif
+
+#if defined(__cplusplus)
+} // Prevents name mangling of functions
+#endif
+
+#endif // RAYGUI_H
+
+/***********************************************************************************
+*
+* RAYGUI IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RAYGUI_IMPLEMENTATION)
+
+#include <stdio.h> // Required for: FILE, fopen(), fclose(), fprintf(), feof(), fscanf(), vsprintf() [GuiLoadStyle(), GuiLoadIcons()]
+#include <stdlib.h> // Required for: malloc(), calloc(), free() [GuiLoadStyle(), GuiLoadIcons()]
+#include <string.h> // Required for: strlen() [GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()], memset(), memcpy()
+#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() [TextFormat()]
+#include <math.h> // Required for: roundf() [GuiColorPicker()]
+
+#ifdef __cplusplus
+ #define RAYGUI_CLITERAL(name) name
+#else
+ #define RAYGUI_CLITERAL(name) (name)
+#endif
+
+#if !defined(RAYGUI_NO_RICONS)
+
+#if defined(RAYGUI_CUSTOM_RICONS)
+
+#define RICONS_IMPLEMENTATION
+#include "ricons.h" // External icons data provided, it can be generated with rGuiIcons tool
+
+#else // Embedded raygui icons, no external file provided
+
+#define RICON_SIZE 16 // Size of icons (squared)
+#define RICON_MAX_ICONS 256 // Maximum number of icons
+#define RICON_MAX_NAME_LENGTH 32 // Maximum length of icon name id
+
+// Icons data is defined by bit array (every bit represents one pixel)
+// Those arrays are stored as unsigned int data arrays, so every array
+// element defines 32 pixels (bits) of information
+// Number of elemens depend on RICON_SIZE (by default 16x16 pixels)
+#define RICON_DATA_ELEMENTS (RICON_SIZE*RICON_SIZE/32)
+
+//----------------------------------------------------------------------------------
+// Icons enumeration
+//----------------------------------------------------------------------------------
+typedef enum {
+ RICON_NONE = 0,
+ RICON_FOLDER_FILE_OPEN = 1,
+ RICON_FILE_SAVE_CLASSIC = 2,
+ RICON_FOLDER_OPEN = 3,
+ RICON_FOLDER_SAVE = 4,
+ RICON_FILE_OPEN = 5,
+ RICON_FILE_SAVE = 6,
+ RICON_FILE_EXPORT = 7,
+ RICON_FILE_NEW = 8,
+ RICON_FILE_DELETE = 9,
+ RICON_FILETYPE_TEXT = 10,
+ RICON_FILETYPE_AUDIO = 11,
+ RICON_FILETYPE_IMAGE = 12,
+ RICON_FILETYPE_PLAY = 13,
+ RICON_FILETYPE_VIDEO = 14,
+ RICON_FILETYPE_INFO = 15,
+ RICON_FILE_COPY = 16,
+ RICON_FILE_CUT = 17,
+ RICON_FILE_PASTE = 18,
+ RICON_CURSOR_HAND = 19,
+ RICON_CURSOR_POINTER = 20,
+ RICON_CURSOR_CLASSIC = 21,
+ RICON_PENCIL = 22,
+ RICON_PENCIL_BIG = 23,
+ RICON_BRUSH_CLASSIC = 24,
+ RICON_BRUSH_PAINTER = 25,
+ RICON_WATER_DROP = 26,
+ RICON_COLOR_PICKER = 27,
+ RICON_RUBBER = 28,
+ RICON_COLOR_BUCKET = 29,
+ RICON_TEXT_T = 30,
+ RICON_TEXT_A = 31,
+ RICON_SCALE = 32,
+ RICON_RESIZE = 33,
+ RICON_FILTER_POINT = 34,
+ RICON_FILTER_BILINEAR = 35,
+ RICON_CROP = 36,
+ RICON_CROP_ALPHA = 37,
+ RICON_SQUARE_TOGGLE = 38,
+ RICON_SYMMETRY = 39,
+ RICON_SYMMETRY_HORIZONTAL = 40,
+ RICON_SYMMETRY_VERTICAL = 41,
+ RICON_LENS = 42,
+ RICON_LENS_BIG = 43,
+ RICON_EYE_ON = 44,
+ RICON_EYE_OFF = 45,
+ RICON_FILTER_TOP = 46,
+ RICON_FILTER = 47,
+ RICON_TARGET_POINT = 48,
+ RICON_TARGET_SMALL = 49,
+ RICON_TARGET_BIG = 50,
+ RICON_TARGET_MOVE = 51,
+ RICON_CURSOR_MOVE = 52,
+ RICON_CURSOR_SCALE = 53,
+ RICON_CURSOR_SCALE_RIGHT = 54,
+ RICON_CURSOR_SCALE_LEFT = 55,
+ RICON_UNDO = 56,
+ RICON_REDO = 57,
+ RICON_REREDO = 58,
+ RICON_MUTATE = 59,
+ RICON_ROTATE = 60,
+ RICON_REPEAT = 61,
+ RICON_SHUFFLE = 62,
+ RICON_EMPTYBOX = 63,
+ RICON_TARGET = 64,
+ RICON_TARGET_SMALL_FILL = 65,
+ RICON_TARGET_BIG_FILL = 66,
+ RICON_TARGET_MOVE_FILL = 67,
+ RICON_CURSOR_MOVE_FILL = 68,
+ RICON_CURSOR_SCALE_FILL = 69,
+ RICON_CURSOR_SCALE_RIGHT_FILL = 70,
+ RICON_CURSOR_SCALE_LEFT_FILL = 71,
+ RICON_UNDO_FILL = 72,
+ RICON_REDO_FILL = 73,
+ RICON_REREDO_FILL = 74,
+ RICON_MUTATE_FILL = 75,
+ RICON_ROTATE_FILL = 76,
+ RICON_REPEAT_FILL = 77,
+ RICON_SHUFFLE_FILL = 78,
+ RICON_EMPTYBOX_SMALL = 79,
+ RICON_BOX = 80,
+ RICON_BOX_TOP = 81,
+ RICON_BOX_TOP_RIGHT = 82,
+ RICON_BOX_RIGHT = 83,
+ RICON_BOX_BOTTOM_RIGHT = 84,
+ RICON_BOX_BOTTOM = 85,
+ RICON_BOX_BOTTOM_LEFT = 86,
+ RICON_BOX_LEFT = 87,
+ RICON_BOX_TOP_LEFT = 88,
+ RICON_BOX_CENTER = 89,
+ RICON_BOX_CIRCLE_MASK = 90,
+ RICON_POT = 91,
+ RICON_ALPHA_MULTIPLY = 92,
+ RICON_ALPHA_CLEAR = 93,
+ RICON_DITHERING = 94,
+ RICON_MIPMAPS = 95,
+ RICON_BOX_GRID = 96,
+ RICON_GRID = 97,
+ RICON_BOX_CORNERS_SMALL = 98,
+ RICON_BOX_CORNERS_BIG = 99,
+ RICON_FOUR_BOXES = 100,
+ RICON_GRID_FILL = 101,
+ RICON_BOX_MULTISIZE = 102,
+ RICON_ZOOM_SMALL = 103,
+ RICON_ZOOM_MEDIUM = 104,
+ RICON_ZOOM_BIG = 105,
+ RICON_ZOOM_ALL = 106,
+ RICON_ZOOM_CENTER = 107,
+ RICON_BOX_DOTS_SMALL = 108,
+ RICON_BOX_DOTS_BIG = 109,
+ RICON_BOX_CONCENTRIC = 110,
+ RICON_BOX_GRID_BIG = 111,
+ RICON_OK_TICK = 112,
+ RICON_CROSS = 113,
+ RICON_ARROW_LEFT = 114,
+ RICON_ARROW_RIGHT = 115,
+ RICON_ARROW_DOWN = 116,
+ RICON_ARROW_UP = 117,
+ RICON_ARROW_LEFT_FILL = 118,
+ RICON_ARROW_RIGHT_FILL = 119,
+ RICON_ARROW_DOWN_FILL = 120,
+ RICON_ARROW_UP_FILL = 121,
+ RICON_AUDIO = 122,
+ RICON_FX = 123,
+ RICON_WAVE = 124,
+ RICON_WAVE_SINUS = 125,
+ RICON_WAVE_SQUARE = 126,
+ RICON_WAVE_TRIANGULAR = 127,
+ RICON_CROSS_SMALL = 128,
+ RICON_PLAYER_PREVIOUS = 129,
+ RICON_PLAYER_PLAY_BACK = 130,
+ RICON_PLAYER_PLAY = 131,
+ RICON_PLAYER_PAUSE = 132,
+ RICON_PLAYER_STOP = 133,
+ RICON_PLAYER_NEXT = 134,
+ RICON_PLAYER_RECORD = 135,
+ RICON_MAGNET = 136,
+ RICON_LOCK_CLOSE = 137,
+ RICON_LOCK_OPEN = 138,
+ RICON_CLOCK = 139,
+ RICON_TOOLS = 140,
+ RICON_GEAR = 141,
+ RICON_GEAR_BIG = 142,
+ RICON_BIN = 143,
+ RICON_HAND_POINTER = 144,
+ RICON_LASER = 145,
+ RICON_COIN = 146,
+ RICON_EXPLOSION = 147,
+ RICON_1UP = 148,
+ RICON_PLAYER = 149,
+ RICON_PLAYER_JUMP = 150,
+ RICON_KEY = 151,
+ RICON_DEMON = 152,
+ RICON_TEXT_POPUP = 153,
+ RICON_GEAR_EX = 154,
+ RICON_CRACK = 155,
+ RICON_CRACK_POINTS = 156,
+ RICON_STAR = 157,
+ RICON_DOOR = 158,
+ RICON_EXIT = 159,
+ RICON_MODE_2D = 160,
+ RICON_MODE_3D = 161,
+ RICON_CUBE = 162,
+ RICON_CUBE_FACE_TOP = 163,
+ RICON_CUBE_FACE_LEFT = 164,
+ RICON_CUBE_FACE_FRONT = 165,
+ RICON_CUBE_FACE_BOTTOM = 166,
+ RICON_CUBE_FACE_RIGHT = 167,
+ RICON_CUBE_FACE_BACK = 168,
+ RICON_CAMERA = 169,
+ RICON_SPECIAL = 170,
+ RICON_LINK_NET = 171,
+ RICON_LINK_BOXES = 172,
+ RICON_LINK_MULTI = 173,
+ RICON_LINK = 174,
+ RICON_LINK_BROKE = 175,
+ RICON_TEXT_NOTES = 176,
+ RICON_NOTEBOOK = 177,
+ RICON_SUITCASE = 178,
+ RICON_SUITCASE_ZIP = 179,
+ RICON_MAILBOX = 180,
+ RICON_MONITOR = 181,
+ RICON_PRINTER = 182,
+ RICON_PHOTO_CAMERA = 183,
+ RICON_PHOTO_CAMERA_FLASH = 184,
+ RICON_HOUSE = 185,
+ RICON_HEART = 186,
+ RICON_CORNER = 187,
+ RICON_VERTICAL_BARS = 188,
+ RICON_VERTICAL_BARS_FILL = 189,
+ RICON_LIFE_BARS = 190,
+ RICON_INFO = 191,
+ RICON_CROSSLINE = 192,
+ RICON_HELP = 193,
+ RICON_FILETYPE_ALPHA = 194,
+ RICON_FILETYPE_HOME = 195,
+ RICON_LAYERS_VISIBLE = 196,
+ RICON_LAYERS = 197,
+ RICON_WINDOW = 198,
+ RICON_HIDPI = 199,
+ RICON_200 = 200,
+ RICON_201 = 201,
+ RICON_202 = 202,
+ RICON_203 = 203,
+ RICON_204 = 204,
+ RICON_205 = 205,
+ RICON_206 = 206,
+ RICON_207 = 207,
+ RICON_208 = 208,
+ RICON_209 = 209,
+ RICON_210 = 210,
+ RICON_211 = 211,
+ RICON_212 = 212,
+ RICON_213 = 213,
+ RICON_214 = 214,
+ RICON_215 = 215,
+ RICON_216 = 216,
+ RICON_217 = 217,
+ RICON_218 = 218,
+ RICON_219 = 219,
+ RICON_220 = 220,
+ RICON_221 = 221,
+ RICON_222 = 222,
+ RICON_223 = 223,
+ RICON_224 = 224,
+ RICON_225 = 225,
+ RICON_226 = 226,
+ RICON_227 = 227,
+ RICON_228 = 228,
+ RICON_229 = 229,
+ RICON_230 = 230,
+ RICON_231 = 231,
+ RICON_232 = 232,
+ RICON_233 = 233,
+ RICON_234 = 234,
+ RICON_235 = 235,
+ RICON_236 = 236,
+ RICON_237 = 237,
+ RICON_238 = 238,
+ RICON_239 = 239,
+ RICON_240 = 240,
+ RICON_241 = 241,
+ RICON_242 = 242,
+ RICON_243 = 243,
+ RICON_244 = 244,
+ RICON_245 = 245,
+ RICON_246 = 246,
+ RICON_247 = 247,
+ RICON_248 = 248,
+ RICON_249 = 249,
+ RICON_250 = 250,
+ RICON_251 = 251,
+ RICON_252 = 252,
+ RICON_253 = 253,
+ RICON_254 = 254,
+ RICON_255 = 255,
+} guiIconName;
+
+//----------------------------------------------------------------------------------
+// Icons data for all gui possible icons (allocated on data segment by default)
+//
+// NOTE 1: Every icon is codified in binary form, using 1 bit per pixel, so,
+// every 16x16 icon requires 8 integers (16*16/32) to be stored
+//
+// NOTE 2: A new icon set could be loaded over this array using GuiLoadIcons(),
+// but loaded icons set must be same RICON_SIZE and no more than RICON_MAX_ICONS
+//
+// guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB
+//----------------------------------------------------------------------------------
+static unsigned int guiIcons[RICON_MAX_ICONS*RICON_DATA_ELEMENTS] = {
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_NONE
+ 0x3ff80000, 0x2f082008, 0x2042207e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x00007ffe, // RICON_FOLDER_FILE_OPEN
+ 0x3ffe0000, 0x44226422, 0x400247e2, 0x5ffa4002, 0x57ea500a, 0x500a500a, 0x40025ffa, 0x00007ffe, // RICON_FILE_SAVE_CLASSIC
+ 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024002, 0x44424282, 0x793e4102, 0x00000100, // RICON_FOLDER_OPEN
+ 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024102, 0x44424102, 0x793e4282, 0x00000000, // RICON_FOLDER_SAVE
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x24442284, 0x21042104, 0x20042104, 0x00003ffc, // RICON_FILE_OPEN
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x21042104, 0x22842444, 0x20042104, 0x00003ffc, // RICON_FILE_SAVE
+ 0x3ff00000, 0x201c2010, 0x00042004, 0x20041004, 0x20844784, 0x00841384, 0x20042784, 0x00003ffc, // RICON_FILE_EXPORT
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x22042204, 0x22042f84, 0x20042204, 0x00003ffc, // RICON_FILE_NEW
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x25042884, 0x25042204, 0x20042884, 0x00003ffc, // RICON_FILE_DELETE
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // RICON_FILETYPE_TEXT
+ 0x3ff00000, 0x201c2010, 0x27042004, 0x244424c4, 0x26442444, 0x20642664, 0x20042004, 0x00003ffc, // RICON_FILETYPE_AUDIO
+ 0x3ff00000, 0x201c2010, 0x26042604, 0x20042004, 0x35442884, 0x2414222c, 0x20042004, 0x00003ffc, // RICON_FILETYPE_IMAGE
+ 0x3ff00000, 0x201c2010, 0x20c42004, 0x22442144, 0x22442444, 0x20c42144, 0x20042004, 0x00003ffc, // RICON_FILETYPE_PLAY
+ 0x3ff00000, 0x3ffc2ff0, 0x3f3c2ff4, 0x3dbc2eb4, 0x3dbc2bb4, 0x3f3c2eb4, 0x3ffc2ff4, 0x00002ff4, // RICON_FILETYPE_VIDEO
+ 0x3ff00000, 0x201c2010, 0x21842184, 0x21842004, 0x21842184, 0x21842184, 0x20042184, 0x00003ffc, // RICON_FILETYPE_INFO
+ 0x0ff00000, 0x381c0810, 0x28042804, 0x28042804, 0x28042804, 0x28042804, 0x20102ffc, 0x00003ff0, // RICON_FILE_COPY
+ 0x00000000, 0x701c0000, 0x079c1e14, 0x55a000f0, 0x079c00f0, 0x701c1e14, 0x00000000, 0x00000000, // RICON_FILE_CUT
+ 0x01c00000, 0x13e41bec, 0x3f841004, 0x204420c4, 0x20442044, 0x20442044, 0x207c2044, 0x00003fc0, // RICON_FILE_PASTE
+ 0x00000000, 0x3aa00fe0, 0x2abc2aa0, 0x2aa42aa4, 0x20042aa4, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_CURSOR_HAND
+ 0x00000000, 0x003c000c, 0x030800c8, 0x30100c10, 0x10202020, 0x04400840, 0x01800280, 0x00000000, // RICON_CURSOR_POINTER
+ 0x00000000, 0x00180000, 0x01f00078, 0x03e007f0, 0x07c003e0, 0x04000e40, 0x00000000, 0x00000000, // RICON_CURSOR_CLASSIC
+ 0x00000000, 0x04000000, 0x11000a00, 0x04400a80, 0x01100220, 0x00580088, 0x00000038, 0x00000000, // RICON_PENCIL
+ 0x04000000, 0x15000a00, 0x50402880, 0x14102820, 0x05040a08, 0x015c028c, 0x007c00bc, 0x00000000, // RICON_PENCIL_BIG
+ 0x01c00000, 0x01400140, 0x01400140, 0x0ff80140, 0x0ff80808, 0x0aa80808, 0x0aa80aa8, 0x00000ff8, // RICON_BRUSH_CLASSIC
+ 0x1ffc0000, 0x5ffc7ffe, 0x40004000, 0x00807f80, 0x01c001c0, 0x01c001c0, 0x01c001c0, 0x00000080, // RICON_BRUSH_PAINTER
+ 0x00000000, 0x00800000, 0x01c00080, 0x03e001c0, 0x07f003e0, 0x036006f0, 0x000001c0, 0x00000000, // RICON_WATER_DROP
+ 0x00000000, 0x3e003800, 0x1f803f80, 0x0c201e40, 0x02080c10, 0x00840104, 0x00380044, 0x00000000, // RICON_COLOR_PICKER
+ 0x00000000, 0x07800300, 0x1fe00fc0, 0x3f883fd0, 0x0e021f04, 0x02040402, 0x00f00108, 0x00000000, // RICON_RUBBER
+ 0x00c00000, 0x02800140, 0x08200440, 0x20081010, 0x2ffe3004, 0x03f807fc, 0x00e001f0, 0x00000040, // RICON_COLOR_BUCKET
+ 0x00000000, 0x21843ffc, 0x01800180, 0x01800180, 0x01800180, 0x01800180, 0x03c00180, 0x00000000, // RICON_TEXT_T
+ 0x00800000, 0x01400180, 0x06200340, 0x0c100620, 0x1ff80c10, 0x380c1808, 0x70067004, 0x0000f80f, // RICON_TEXT_A
+ 0x78000000, 0x50004000, 0x00004800, 0x03c003c0, 0x03c003c0, 0x00100000, 0x0002000a, 0x0000000e, // RICON_SCALE
+ 0x75560000, 0x5e004002, 0x54001002, 0x41001202, 0x408200fe, 0x40820082, 0x40820082, 0x00006afe, // RICON_RESIZE
+ 0x00000000, 0x3f003f00, 0x3f003f00, 0x3f003f00, 0x00400080, 0x001c0020, 0x001c001c, 0x00000000, // RICON_FILTER_POINT
+ 0x6d800000, 0x00004080, 0x40804080, 0x40800000, 0x00406d80, 0x001c0020, 0x001c001c, 0x00000000, // RICON_FILTER_BILINEAR
+ 0x40080000, 0x1ffe2008, 0x14081008, 0x11081208, 0x10481088, 0x10081028, 0x10047ff8, 0x00001002, // RICON_CROP
+ 0x00100000, 0x3ffc0010, 0x2ab03550, 0x22b02550, 0x20b02150, 0x20302050, 0x2000fff0, 0x00002000, // RICON_CROP_ALPHA
+ 0x40000000, 0x1ff82000, 0x04082808, 0x01082208, 0x00482088, 0x00182028, 0x35542008, 0x00000002, // RICON_SQUARE_TOGGLE
+ 0x00000000, 0x02800280, 0x06c006c0, 0x0ea00ee0, 0x1e901eb0, 0x3e883e98, 0x7efc7e8c, 0x00000000, // RICON_SIMMETRY
+ 0x01000000, 0x05600100, 0x1d480d50, 0x7d423d44, 0x3d447d42, 0x0d501d48, 0x01000560, 0x00000100, // RICON_SIMMETRY_HORIZONTAL
+ 0x01800000, 0x04200240, 0x10080810, 0x00001ff8, 0x00007ffe, 0x0ff01ff8, 0x03c007e0, 0x00000180, // RICON_SIMMETRY_VERTICAL
+ 0x00000000, 0x010800f0, 0x02040204, 0x02040204, 0x07f00308, 0x1c000e00, 0x30003800, 0x00000000, // RICON_LENS
+ 0x00000000, 0x061803f0, 0x08240c0c, 0x08040814, 0x0c0c0804, 0x23f01618, 0x18002400, 0x00000000, // RICON_LENS_BIG
+ 0x00000000, 0x00000000, 0x1c7007c0, 0x638e3398, 0x1c703398, 0x000007c0, 0x00000000, 0x00000000, // RICON_EYE_ON
+ 0x00000000, 0x10002000, 0x04700fc0, 0x610e3218, 0x1c703098, 0x001007a0, 0x00000008, 0x00000000, // RICON_EYE_OFF
+ 0x00000000, 0x00007ffc, 0x40047ffc, 0x10102008, 0x04400820, 0x02800280, 0x02800280, 0x00000100, // RICON_FILTER_TOP
+ 0x00000000, 0x40027ffe, 0x10082004, 0x04200810, 0x02400240, 0x02400240, 0x01400240, 0x000000c0, // RICON_FILTER
+ 0x00800000, 0x00800080, 0x00000080, 0x3c9e0000, 0x00000000, 0x00800080, 0x00800080, 0x00000000, // RICON_TARGET_POINT
+ 0x00800000, 0x00800080, 0x00800080, 0x3f7e01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // RICON_TARGET_SMALL
+ 0x00800000, 0x00800080, 0x03e00080, 0x3e3e0220, 0x03e00220, 0x00800080, 0x00800080, 0x00000000, // RICON_TARGET_BIG
+ 0x01000000, 0x04400280, 0x01000100, 0x43842008, 0x43849ab2, 0x01002008, 0x04400100, 0x01000280, // RICON_TARGET_MOVE
+ 0x01000000, 0x04400280, 0x01000100, 0x41042108, 0x41049ff2, 0x01002108, 0x04400100, 0x01000280, // RICON_CURSOR_MOVE
+ 0x781e0000, 0x500a4002, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x4002500a, 0x0000781e, // RICON_CURSOR_SCALE
+ 0x00000000, 0x20003c00, 0x24002800, 0x01000200, 0x00400080, 0x00140024, 0x003c0004, 0x00000000, // RICON_CURSOR_SCALE_RIGHT
+ 0x00000000, 0x0004003c, 0x00240014, 0x00800040, 0x02000100, 0x28002400, 0x3c002000, 0x00000000, // RICON_CURSOR_SCALE_LEFT
+ 0x00000000, 0x00100020, 0x10101fc8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // RICON_UNDO
+ 0x00000000, 0x08000400, 0x080813f8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // RICON_REDO
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3f902020, 0x00400020, 0x00000000, // RICON_REREDO
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3fc82010, 0x00200010, 0x00000000, // RICON_MUTATE
+ 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18101020, 0x00100fc8, 0x00000020, // RICON_ROTATE
+ 0x00000000, 0x04000200, 0x240429fc, 0x20042204, 0x20442004, 0x3f942024, 0x00400020, 0x00000000, // RICON_REPEAT
+ 0x00000000, 0x20001000, 0x22104c0e, 0x00801120, 0x11200040, 0x4c0e2210, 0x10002000, 0x00000000, // RICON_SHUFFLE
+ 0x7ffe0000, 0x50024002, 0x44024802, 0x41024202, 0x40424082, 0x40124022, 0x4002400a, 0x00007ffe, // RICON_EMPTYBOX
+ 0x00800000, 0x03e00080, 0x08080490, 0x3c9e0808, 0x08080808, 0x03e00490, 0x00800080, 0x00000000, // RICON_TARGET
+ 0x00800000, 0x00800080, 0x00800080, 0x3ffe01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // RICON_TARGET_SMALL_FILL
+ 0x00800000, 0x00800080, 0x03e00080, 0x3ffe03e0, 0x03e003e0, 0x00800080, 0x00800080, 0x00000000, // RICON_TARGET_BIG_FILL
+ 0x01000000, 0x07c00380, 0x01000100, 0x638c2008, 0x638cfbbe, 0x01002008, 0x07c00100, 0x01000380, // RICON_TARGET_MOVE_FILL
+ 0x01000000, 0x07c00380, 0x01000100, 0x610c2108, 0x610cfffe, 0x01002108, 0x07c00100, 0x01000380, // RICON_CURSOR_MOVE_FILL
+ 0x781e0000, 0x6006700e, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x700e6006, 0x0000781e, // RICON_CURSOR_SCALE_FILL
+ 0x00000000, 0x38003c00, 0x24003000, 0x01000200, 0x00400080, 0x000c0024, 0x003c001c, 0x00000000, // RICON_CURSOR_SCALE_RIGHT
+ 0x00000000, 0x001c003c, 0x0024000c, 0x00800040, 0x02000100, 0x30002400, 0x3c003800, 0x00000000, // RICON_CURSOR_SCALE_LEFT
+ 0x00000000, 0x00300020, 0x10301ff8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // RICON_UNDO_FILL
+ 0x00000000, 0x0c000400, 0x0c081ff8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // RICON_REDO_FILL
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3ff02060, 0x00400060, 0x00000000, // RICON_REREDO_FILL
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3ff82030, 0x00200030, 0x00000000, // RICON_MUTATE_FILL
+ 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18301020, 0x00300ff8, 0x00000020, // RICON_ROTATE_FILL
+ 0x00000000, 0x06000200, 0x26042ffc, 0x20042204, 0x20442004, 0x3ff42064, 0x00400060, 0x00000000, // RICON_REPEAT_FILL
+ 0x00000000, 0x30001000, 0x32107c0e, 0x00801120, 0x11200040, 0x7c0e3210, 0x10003000, 0x00000000, // RICON_SHUFFLE_FILL
+ 0x00000000, 0x30043ffc, 0x24042804, 0x21042204, 0x20442084, 0x20142024, 0x3ffc200c, 0x00000000, // RICON_EMPTYBOX_SMALL
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX
+ 0x00000000, 0x23c43ffc, 0x23c423c4, 0x200423c4, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_TOP
+ 0x00000000, 0x3e043ffc, 0x3e043e04, 0x20043e04, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_TOP_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x3e043e04, 0x3e043e04, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x3e042004, 0x3e043e04, 0x3ffc3e04, 0x00000000, // RICON_BOX_BOTTOM_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x23c42004, 0x23c423c4, 0x3ffc23c4, 0x00000000, // RICON_BOX_BOTTOM
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x207c2004, 0x207c207c, 0x3ffc207c, 0x00000000, // RICON_BOX_BOTTOM_LEFT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x207c207c, 0x207c207c, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_LEFT
+ 0x00000000, 0x207c3ffc, 0x207c207c, 0x2004207c, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_TOP_LEFT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x23c423c4, 0x23c423c4, 0x20042004, 0x3ffc2004, 0x00000000, // RICON_BOX_CIRCLE_MASK
+ 0x7ffe0000, 0x40024002, 0x47e24182, 0x4ff247e2, 0x47e24ff2, 0x418247e2, 0x40024002, 0x00007ffe, // RICON_BOX_CENTER
+ 0x7fff0000, 0x40014001, 0x40014001, 0x49555ddd, 0x4945495d, 0x400149c5, 0x40014001, 0x00007fff, // RICON_POT
+ 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x404e40ce, 0x48125432, 0x4006540e, 0x00007ffe, // RICON_ALPHA_MULTIPLY
+ 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x5c4e40ce, 0x44124432, 0x40065c0e, 0x00007ffe, // RICON_ALPHA_CLEAR
+ 0x7ffe0000, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x00007ffe, // RICON_DITHERING
+ 0x07fe0000, 0x1ffa0002, 0x7fea000a, 0x402a402a, 0x5b2a512a, 0x5128552a, 0x40205128, 0x00007fe0, // RICON_MIPMAPS
+ 0x00000000, 0x1ff80000, 0x12481248, 0x12481ff8, 0x1ff81248, 0x12481248, 0x00001ff8, 0x00000000, // RICON_BOX_GRID
+ 0x12480000, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x00001248, // RICON_GRID
+ 0x00000000, 0x1c380000, 0x1c3817e8, 0x08100810, 0x08100810, 0x17e81c38, 0x00001c38, 0x00000000, // RICON_BOX_CORNERS_SMALL
+ 0x700e0000, 0x700e5ffa, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x5ffa700e, 0x0000700e, // RICON_BOX_CORNERS_BIG
+ 0x3f7e0000, 0x21422142, 0x21422142, 0x00003f7e, 0x21423f7e, 0x21422142, 0x3f7e2142, 0x00000000, // RICON_FOUR_BOXES
+ 0x00000000, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x00000000, // RICON_GRID_FILL
+ 0x7ffe0000, 0x7ffe7ffe, 0x77fe7000, 0x77fe77fe, 0x777e7700, 0x777e777e, 0x777e777e, 0x0000777e, // RICON_BOX_MULTISIZE
+ 0x781e0000, 0x40024002, 0x00004002, 0x01800000, 0x00000180, 0x40020000, 0x40024002, 0x0000781e, // RICON_ZOOM_SMALL
+ 0x781e0000, 0x40024002, 0x00004002, 0x03c003c0, 0x03c003c0, 0x40020000, 0x40024002, 0x0000781e, // RICON_ZOOM_MEDIUM
+ 0x781e0000, 0x40024002, 0x07e04002, 0x07e007e0, 0x07e007e0, 0x400207e0, 0x40024002, 0x0000781e, // RICON_ZOOM_BIG
+ 0x781e0000, 0x5ffa4002, 0x1ff85ffa, 0x1ff81ff8, 0x1ff81ff8, 0x5ffa1ff8, 0x40025ffa, 0x0000781e, // RICON_ZOOM_ALL
+ 0x00000000, 0x2004381c, 0x00002004, 0x00000000, 0x00000000, 0x20040000, 0x381c2004, 0x00000000, // RICON_ZOOM_CENTER
+ 0x00000000, 0x1db80000, 0x10081008, 0x10080000, 0x00001008, 0x10081008, 0x00001db8, 0x00000000, // RICON_BOX_DOTS_SMALL
+ 0x35560000, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x35562002, 0x00000000, // RICON_BOX_DOTS_BIG
+ 0x7ffe0000, 0x40024002, 0x48124ff2, 0x49924812, 0x48124992, 0x4ff24812, 0x40024002, 0x00007ffe, // RICON_BOX_CONCENTRIC
+ 0x00000000, 0x10841ffc, 0x10841084, 0x1ffc1084, 0x10841084, 0x10841084, 0x00001ffc, 0x00000000, // RICON_BOX_GRID_BIG
+ 0x00000000, 0x00000000, 0x10000000, 0x04000800, 0x01040200, 0x00500088, 0x00000020, 0x00000000, // RICON_OK_TICK
+ 0x00000000, 0x10080000, 0x04200810, 0x01800240, 0x02400180, 0x08100420, 0x00001008, 0x00000000, // RICON_CROSS
+ 0x00000000, 0x02000000, 0x00800100, 0x00200040, 0x00200010, 0x00800040, 0x02000100, 0x00000000, // RICON_ARROW_LEFT
+ 0x00000000, 0x00400000, 0x01000080, 0x04000200, 0x04000800, 0x01000200, 0x00400080, 0x00000000, // RICON_ARROW_RIGHT
+ 0x00000000, 0x00000000, 0x00000000, 0x08081004, 0x02200410, 0x00800140, 0x00000000, 0x00000000, // RICON_ARROW_DOWN
+ 0x00000000, 0x00000000, 0x01400080, 0x04100220, 0x10040808, 0x00000000, 0x00000000, 0x00000000, // RICON_ARROW_UP
+ 0x00000000, 0x02000000, 0x03800300, 0x03e003c0, 0x03e003f0, 0x038003c0, 0x02000300, 0x00000000, // RICON_ARROW_LEFT_FILL
+ 0x00000000, 0x00400000, 0x01c000c0, 0x07c003c0, 0x07c00fc0, 0x01c003c0, 0x004000c0, 0x00000000, // RICON_ARROW_RIGHT_FILL
+ 0x00000000, 0x00000000, 0x00000000, 0x0ff81ffc, 0x03e007f0, 0x008001c0, 0x00000000, 0x00000000, // RICON_ARROW_DOWN_FILL
+ 0x00000000, 0x00000000, 0x01c00080, 0x07f003e0, 0x1ffc0ff8, 0x00000000, 0x00000000, 0x00000000, // RICON_ARROW_UP_FILL
+ 0x00000000, 0x18a008c0, 0x32881290, 0x24822686, 0x26862482, 0x12903288, 0x08c018a0, 0x00000000, // RICON_AUDIO
+ 0x00000000, 0x04800780, 0x004000c0, 0x662000f0, 0x08103c30, 0x130a0e18, 0x0000318e, 0x00000000, // RICON_FX
+ 0x00000000, 0x00800000, 0x08880888, 0x2aaa0a8a, 0x0a8a2aaa, 0x08880888, 0x00000080, 0x00000000, // RICON_WAVE
+ 0x00000000, 0x00600000, 0x01080090, 0x02040108, 0x42044204, 0x24022402, 0x00001800, 0x00000000, // RICON_WAVE_SINUS
+ 0x00000000, 0x07f80000, 0x04080408, 0x04080408, 0x04080408, 0x7c0e0408, 0x00000000, 0x00000000, // RICON_WAVE_SQUARE
+ 0x00000000, 0x00000000, 0x00a00040, 0x22084110, 0x08021404, 0x00000000, 0x00000000, 0x00000000, // RICON_WAVE_TRIANGULAR
+ 0x00000000, 0x00000000, 0x04200000, 0x01800240, 0x02400180, 0x00000420, 0x00000000, 0x00000000, // RICON_CROSS_SMALL
+ 0x00000000, 0x18380000, 0x12281428, 0x10a81128, 0x112810a8, 0x14281228, 0x00001838, 0x00000000, // RICON_PLAYER_PREVIOUS
+ 0x00000000, 0x18000000, 0x11801600, 0x10181060, 0x10601018, 0x16001180, 0x00001800, 0x00000000, // RICON_PLAYER_PLAY_BACK
+ 0x00000000, 0x00180000, 0x01880068, 0x18080608, 0x06081808, 0x00680188, 0x00000018, 0x00000000, // RICON_PLAYER_PLAY
+ 0x00000000, 0x1e780000, 0x12481248, 0x12481248, 0x12481248, 0x12481248, 0x00001e78, 0x00000000, // RICON_PLAYER_PAUSE
+ 0x00000000, 0x1ff80000, 0x10081008, 0x10081008, 0x10081008, 0x10081008, 0x00001ff8, 0x00000000, // RICON_PLAYER_STOP
+ 0x00000000, 0x1c180000, 0x14481428, 0x15081488, 0x14881508, 0x14281448, 0x00001c18, 0x00000000, // RICON_PLAYER_NEXT
+ 0x00000000, 0x03c00000, 0x08100420, 0x10081008, 0x10081008, 0x04200810, 0x000003c0, 0x00000000, // RICON_PLAYER_RECORD
+ 0x00000000, 0x0c3007e0, 0x13c81818, 0x14281668, 0x14281428, 0x1c381c38, 0x08102244, 0x00000000, // RICON_MAGNET
+ 0x07c00000, 0x08200820, 0x3ff80820, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // RICON_LOCK_CLOSE
+ 0x07c00000, 0x08000800, 0x3ff80800, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // RICON_LOCK_OPEN
+ 0x01c00000, 0x0c180770, 0x3086188c, 0x60832082, 0x60034781, 0x30062002, 0x0c18180c, 0x01c00770, // RICON_CLOCK
+ 0x0a200000, 0x1b201b20, 0x04200e20, 0x04200420, 0x04700420, 0x0e700e70, 0x0e700e70, 0x04200e70, // RICON_TOOLS
+ 0x01800000, 0x3bdc318c, 0x0ff01ff8, 0x7c3e1e78, 0x1e787c3e, 0x1ff80ff0, 0x318c3bdc, 0x00000180, // RICON_GEAR
+ 0x01800000, 0x3ffc318c, 0x1c381ff8, 0x781e1818, 0x1818781e, 0x1ff81c38, 0x318c3ffc, 0x00000180, // RICON_GEAR_BIG
+ 0x00000000, 0x08080ff8, 0x08081ffc, 0x0aa80aa8, 0x0aa80aa8, 0x0aa80aa8, 0x08080aa8, 0x00000ff8, // RICON_BIN
+ 0x00000000, 0x00000000, 0x20043ffc, 0x08043f84, 0x04040f84, 0x04040784, 0x000007fc, 0x00000000, // RICON_HAND_POINTER
+ 0x00000000, 0x24400400, 0x00001480, 0x6efe0e00, 0x00000e00, 0x24401480, 0x00000400, 0x00000000, // RICON_LASER
+ 0x00000000, 0x03c00000, 0x08300460, 0x11181118, 0x11181118, 0x04600830, 0x000003c0, 0x00000000, // RICON_COIN
+ 0x00000000, 0x10880080, 0x06c00810, 0x366c07e0, 0x07e00240, 0x00001768, 0x04200240, 0x00000000, // RICON_EXPLOSION
+ 0x00000000, 0x3d280000, 0x2528252c, 0x3d282528, 0x05280528, 0x05e80528, 0x00000000, 0x00000000, // RICON_1UP
+ 0x01800000, 0x03c003c0, 0x018003c0, 0x0ff007e0, 0x0bd00bd0, 0x0a500bd0, 0x02400240, 0x02400240, // RICON_PLAYER
+ 0x01800000, 0x03c003c0, 0x118013c0, 0x03c81ff8, 0x07c003c8, 0x04400440, 0x0c080478, 0x00000000, // RICON_PLAYER_JUMP
+ 0x3ff80000, 0x30183ff8, 0x30183018, 0x3ff83ff8, 0x03000300, 0x03c003c0, 0x03e00300, 0x000003e0, // RICON_KEY
+ 0x3ff80000, 0x3ff83ff8, 0x33983ff8, 0x3ff83398, 0x3ff83ff8, 0x00000540, 0x0fe00aa0, 0x00000fe0, // RICON_DEMON
+ 0x00000000, 0x0ff00000, 0x20041008, 0x25442004, 0x10082004, 0x06000bf0, 0x00000300, 0x00000000, // RICON_TEXT_POPUP
+ 0x00000000, 0x11440000, 0x07f00be8, 0x1c1c0e38, 0x1c1c0c18, 0x07f00e38, 0x11440be8, 0x00000000, // RICON_GEAR_EX
+ 0x00000000, 0x20080000, 0x0c601010, 0x07c00fe0, 0x07c007c0, 0x0c600fe0, 0x20081010, 0x00000000, // RICON_CRACK
+ 0x00000000, 0x20080000, 0x0c601010, 0x04400fe0, 0x04405554, 0x0c600fe0, 0x20081010, 0x00000000, // RICON_CRACK_POINTS
+ 0x00000000, 0x00800080, 0x01c001c0, 0x1ffc3ffe, 0x03e007f0, 0x07f003e0, 0x0c180770, 0x00000808, // RICON_STAR
+ 0x0ff00000, 0x08180810, 0x08100818, 0x0a100810, 0x08180810, 0x08100818, 0x08100810, 0x00001ff8, // RICON_DOOR
+ 0x0ff00000, 0x08100810, 0x08100810, 0x10100010, 0x4f902010, 0x10102010, 0x08100010, 0x00000ff0, // RICON_EXIT
+ 0x00040000, 0x001f000e, 0x0ef40004, 0x12f41284, 0x0ef41214, 0x10040004, 0x7ffc3004, 0x10003000, // RICON_MODE_2D
+ 0x78040000, 0x501f600e, 0x0ef44004, 0x12f41284, 0x0ef41284, 0x10140004, 0x7ffc300c, 0x10003000, // RICON_MODE_3D
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // RICON_CUBE
+ 0x7fe00000, 0x5ff87ff0, 0x47fe4ffc, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // RICON_CUBE_FACE_TOP
+ 0x7fe00000, 0x50386030, 0x47fe483c, 0x443e443e, 0x443e443e, 0x241e75fe, 0x0c06140e, 0x000007fe, // RICON_CUBE_FACE_LEFT
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x47fe47fe, 0x47fe47fe, 0x27fe77fe, 0x0ffe17fe, 0x000007fe, // RICON_CUBE_FACE_FRONT
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x3ff27fe2, 0x0ffe1ffa, 0x000007fe, // RICON_CUBE_FACE_BOTTOM
+ 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // RICON_CUBE_FACE_RIGHT
+ 0x7fe00000, 0x7fe87ff0, 0x7ffe7fe4, 0x7fe27fe2, 0x7fe27fe2, 0x24127fe2, 0x0c06140a, 0x000007fe, // RICON_CUBE_FACE_BACK
+ 0x00000000, 0x2a0233fe, 0x22022602, 0x22022202, 0x2a022602, 0x00a033fe, 0x02080110, 0x00000000, // RICON_CAMERA
+ 0x00000000, 0x200c3ffc, 0x000c000c, 0x3ffc000c, 0x30003000, 0x30003000, 0x3ffc3004, 0x00000000, // RICON_SPECIAL
+ 0x00000000, 0x0022003e, 0x012201e2, 0x0100013e, 0x01000100, 0x79000100, 0x4f004900, 0x00007800, // RICON_LINK_NET
+ 0x00000000, 0x44007c00, 0x45004600, 0x00627cbe, 0x00620022, 0x45007cbe, 0x44004600, 0x00007c00, // RICON_LINK_BOXES
+ 0x00000000, 0x0044007c, 0x0010007c, 0x3f100010, 0x3f1021f0, 0x3f100010, 0x3f0021f0, 0x00000000, // RICON_LINK_MULTI
+ 0x00000000, 0x0044007c, 0x00440044, 0x0010007c, 0x00100010, 0x44107c10, 0x440047f0, 0x00007c00, // RICON_LINK
+ 0x00000000, 0x0044007c, 0x00440044, 0x0000007c, 0x00000010, 0x44007c10, 0x44004550, 0x00007c00, // RICON_LINK_BROKE
+ 0x02a00000, 0x22a43ffc, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // RICON_TEXT_NOTES
+ 0x3ffc0000, 0x20042004, 0x245e27c4, 0x27c42444, 0x2004201e, 0x201e2004, 0x20042004, 0x00003ffc, // RICON_NOTEBOOK
+ 0x00000000, 0x07e00000, 0x04200420, 0x24243ffc, 0x24242424, 0x24242424, 0x3ffc2424, 0x00000000, // RICON_SUITCASE
+ 0x00000000, 0x0fe00000, 0x08200820, 0x40047ffc, 0x7ffc5554, 0x40045554, 0x7ffc4004, 0x00000000, // RICON_SUITCASE_ZIP
+ 0x00000000, 0x20043ffc, 0x3ffc2004, 0x13c81008, 0x100813c8, 0x10081008, 0x1ff81008, 0x00000000, // RICON_MAILBOX
+ 0x00000000, 0x40027ffe, 0x5ffa5ffa, 0x5ffa5ffa, 0x40025ffa, 0x03c07ffe, 0x1ff81ff8, 0x00000000, // RICON_MONITOR
+ 0x0ff00000, 0x6bfe7ffe, 0x7ffe7ffe, 0x68167ffe, 0x08106816, 0x08100810, 0x0ff00810, 0x00000000, // RICON_PRINTER
+ 0x3ff80000, 0xfffe2008, 0x870a8002, 0x904a888a, 0x904a904a, 0x870a888a, 0xfffe8002, 0x00000000, // RICON_PHOTO_CAMERA
+ 0x0fc00000, 0xfcfe0cd8, 0x8002fffe, 0x84428382, 0x84428442, 0x80028382, 0xfffe8002, 0x00000000, // RICON_PHOTO_CAMERA_FLASH
+ 0x00000000, 0x02400180, 0x08100420, 0x20041008, 0x23c42004, 0x22442244, 0x3ffc2244, 0x00000000, // RICON_HOUSE
+ 0x00000000, 0x1c700000, 0x3ff83ef8, 0x3ff83ff8, 0x0fe01ff0, 0x038007c0, 0x00000100, 0x00000000, // RICON_HEART
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0xe000c000, // RICON_CORNER
+ 0x00000000, 0x14001c00, 0x15c01400, 0x15401540, 0x155c1540, 0x15541554, 0x1ddc1554, 0x00000000, // RICON_VERTICAL_BARS
+ 0x00000000, 0x03000300, 0x1b001b00, 0x1b601b60, 0x1b6c1b60, 0x1b6c1b6c, 0x1b6c1b6c, 0x00000000, // RICON_VERTICAL_BARS_FILL
+ 0x00000000, 0x00000000, 0x403e7ffe, 0x7ffe403e, 0x7ffe0000, 0x43fe43fe, 0x00007ffe, 0x00000000, // RICON_LIFE_BARS
+ 0x7ffc0000, 0x43844004, 0x43844284, 0x43844004, 0x42844284, 0x42844284, 0x40044384, 0x00007ffc, // RICON_INFO
+ 0x40008000, 0x10002000, 0x04000800, 0x01000200, 0x00400080, 0x00100020, 0x00040008, 0x00010002, // RICON_CROSSLINE
+ 0x00000000, 0x1ff01ff0, 0x18301830, 0x1f001830, 0x03001f00, 0x00000300, 0x03000300, 0x00000000, // RICON_HELP
+ 0x3ff00000, 0x2abc3550, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x00003ffc, // RICON_FILETYPE_ALPHA
+ 0x3ff00000, 0x201c2010, 0x22442184, 0x28142424, 0x29942814, 0x2ff42994, 0x20042004, 0x00003ffc, // RICON_FILETYPE_HOME
+ 0x07fe0000, 0x04020402, 0x7fe20402, 0x44224422, 0x44224422, 0x402047fe, 0x40204020, 0x00007fe0, // RICON_LAYERS_VISIBLE
+ 0x07fe0000, 0x04020402, 0x7c020402, 0x44024402, 0x44024402, 0x402047fe, 0x40204020, 0x00007fe0, // RICON_LAYERS
+ 0x00000000, 0x40027ffe, 0x7ffe4002, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // RICON_WINDOW
+ 0x09100000, 0x09f00910, 0x09100910, 0x00000910, 0x24a2779e, 0x27a224a2, 0x709e20a2, 0x00000000, // RICON_HIDPI
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_200
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_201
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_202
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_203
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_204
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_205
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_206
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_207
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_208
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_209
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_210
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_211
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_212
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_213
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_214
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_215
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_216
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_217
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_218
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_219
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_220
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_221
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_222
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_223
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_224
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_225
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_226
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_227
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_228
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_229
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_230
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_231
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_232
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_233
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_234
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_235
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_236
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_237
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_238
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_239
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_240
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_241
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_242
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_243
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_244
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_245
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_246
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_247
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_248
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_249
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_250
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_251
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_252
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_253
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_254
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RICON_255
+};
+
+#endif // RAYGUI_CUSTOM_RICONS
+
+#endif // !RAYGUI_NO_RICONS
+
+#ifndef RICON_SIZE
+ #define RICON_SIZE 0
+#endif
+
+#define RAYGUI_MAX_CONTROLS 16 // Maximum number of standard controls
+#define RAYGUI_MAX_PROPS_BASE 16 // Maximum number of standard properties
+#define RAYGUI_MAX_PROPS_EXTENDED 8 // Maximum number of extended properties
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+// Gui control property style color element
+typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+static GuiControlState guiState = GUI_STATE_NORMAL;
+
+static Font guiFont = { 0 }; // Gui current font (WARNING: highly coupled to raylib)
+static bool guiLocked = false; // Gui lock state (no inputs processed)
+static float guiAlpha = 1.0f; // Gui element transpacency on drawing
+
+//----------------------------------------------------------------------------------
+// Style data array for all gui style properties (allocated on data segment by default)
+//
+// NOTE 1: First set of BASE properties are generic to all controls but could be individually
+// overwritten per control, first set of EXTENDED properties are generic to all controls and
+// can not be overwritten individually but custom EXTENDED properties can be used by control
+//
+// NOTE 2: A new style set could be loaded over this array using GuiLoadStyle(),
+// but default gui style could always be recovered with GuiLoadStyleDefault()
+//
+// guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB
+//----------------------------------------------------------------------------------
+static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)] = { 0 };
+
+static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization
+
+//----------------------------------------------------------------------------------
+// Standalone Mode Functions Declaration
+//
+// NOTE: raygui depend on some raylib input and drawing functions
+// To use raygui as standalone library, below functions must be defined by the user
+//----------------------------------------------------------------------------------
+#if defined(RAYGUI_STANDALONE)
+
+#define KEY_RIGHT 262
+#define KEY_LEFT 263
+#define KEY_DOWN 264
+#define KEY_UP 265
+#define KEY_BACKSPACE 259
+#define KEY_ENTER 257
+
+#define MOUSE_LEFT_BUTTON 0
+
+// Input required functions
+//-------------------------------------------------------------------------------
+static Vector2 GetMousePosition(void);
+static float GetMouseWheelMove(void);
+static bool IsMouseButtonDown(int button);
+static bool IsMouseButtonPressed(int button);
+static bool IsMouseButtonReleased(int button);
+
+static bool IsKeyDown(int key);
+static bool IsKeyPressed(int key);
+static int GetCharPressed(void); // -- GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()
+//-------------------------------------------------------------------------------
+
+// Drawing required functions
+//-------------------------------------------------------------------------------
+static void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle(), GuiDrawIcon()
+
+static void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker()
+//-------------------------------------------------------------------------------
+
+// Text required functions
+//-------------------------------------------------------------------------------
+static Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount); // -- GuiLoadStyle()
+static Font GetFontDefault(void); // -- GuiLoadStyleDefault()
+static Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle()
+static void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle()
+static char *LoadFileText(const char *fileName); // -- GuiLoadStyle()
+static const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle()
+
+static Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // -- GetTextWidth(), GuiTextBoxMulti()
+static void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // -- GuiDrawText()
+//-------------------------------------------------------------------------------
+
+// raylib functions already implemented in raygui
+//-------------------------------------------------------------------------------
+static Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value
+static int ColorToInt(Color color); // Returns hexadecimal value for a Color
+static Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
+static bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle
+static const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed'
+static const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings
+static int TextToInteger(const char *text); // Get integer value from text
+static int GetCodepoint(const char *text, int *bytesProcessed); // Get next codepoint in a UTF-8 encoded text
+static const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode codepoint into UTF-8 text (char array size returned as parameter)
+
+static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw rectangle vertical gradient
+//-------------------------------------------------------------------------------
+
+#endif // RAYGUI_STANDALONE
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+static int GetTextWidth(const char *text); // Gui get text width using default font
+static Rectangle GetTextBounds(int control, Rectangle bounds); // Get text bounds considering control bounds
+static const char *GetTextIcon(const char *text, int *iconId); // Get text icon if provided and move text cursor
+
+static void GuiDrawText(const char *text, Rectangle bounds, int alignment, Color tint); // Gui draw text using default font
+static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color); // Gui draw rectangle using default raygui style
+
+static const char **GuiTextSplit(const char *text, int *count, int *textRow); // Split controls text into multiple strings
+static Vector3 ConvertHSVtoRGB(Vector3 hsv); // Convert color data from HSV to RGB
+static Vector3 ConvertRGBtoHSV(Vector3 rgb); // Convert color data from RGB to HSV
+
+//----------------------------------------------------------------------------------
+// Gui Setup Functions Definition
+//----------------------------------------------------------------------------------
+// Enable gui global state
+void GuiEnable(void) { guiState = GUI_STATE_NORMAL; }
+
+// Disable gui global state
+void GuiDisable(void) { guiState = GUI_STATE_DISABLED; }
+
+// Lock gui global state
+void GuiLock(void) { guiLocked = true; }
+
+// Unlock gui global state
+void GuiUnlock(void) { guiLocked = false; }
+
+// Check if gui is locked (global state)
+bool GuiIsLocked(void) { return guiLocked; }
+
+// Set gui controls alpha global state
+void GuiFade(float alpha)
+{
+ if (alpha < 0.0f) alpha = 0.0f;
+ else if (alpha > 1.0f) alpha = 1.0f;
+
+ guiAlpha = alpha;
+}
+
+// Set gui state (global state)
+void GuiSetState(int state) { guiState = (GuiControlState)state; }
+
+// Get gui state (global state)
+int GuiGetState(void) { return guiState; }
+
+// Set custom gui font
+// NOTE: Font loading/unloading is external to raygui
+void GuiSetFont(Font font)
+{
+ if (font.texture.id > 0)
+ {
+ // NOTE: If we try to setup a font but default style has not been
+ // lazily loaded before, it will be overwritten, so we need to force
+ // default style loading first
+ if (!guiStyleLoaded) GuiLoadStyleDefault();
+
+ guiFont = font;
+ GuiSetStyle(DEFAULT, TEXT_SIZE, font.baseSize);
+ }
+}
+
+// Get custom gui font
+Font GuiGetFont(void)
+{
+ return guiFont;
+}
+
+// Set control style property value
+void GuiSetStyle(int control, int property, int value)
+{
+ if (!guiStyleLoaded) GuiLoadStyleDefault();
+ guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value;
+
+ // Default properties are propagated to all controls
+ if ((control == 0) && (property < RAYGUI_MAX_PROPS_BASE))
+ {
+ for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) guiStyle[i*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value;
+ }
+}
+
+// Get control style property value
+int GuiGetStyle(int control, int property)
+{
+ if (!guiStyleLoaded) GuiLoadStyleDefault();
+ return guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property];
+}
+
+//----------------------------------------------------------------------------------
+// Gui Controls Functions Definition
+//----------------------------------------------------------------------------------
+
+// Window Box control
+bool GuiWindowBox(Rectangle bounds, const char *title)
+{
+ // NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox()
+ #define WINDOW_STATUSBAR_HEIGHT 22
+
+ //GuiControlState state = guiState;
+ bool clicked = false;
+
+ int statusBarHeight = WINDOW_STATUSBAR_HEIGHT + 2*GuiGetStyle(STATUSBAR, BORDER_WIDTH);
+ statusBarHeight += (statusBarHeight%2);
+
+ Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)statusBarHeight };
+ if (bounds.height < statusBarHeight*2.0f) bounds.height = statusBarHeight*2.0f;
+
+ Rectangle windowPanel = { bounds.x, bounds.y + (float)statusBarHeight - 1, bounds.width, bounds.height - (float)statusBarHeight };
+ Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20,
+ statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 };
+
+ // Update control
+ //--------------------------------------------------------------------
+ // NOTE: Logic is directly managed by button
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiStatusBar(statusBar, title); // Draw window header as status bar
+ GuiPanel(windowPanel); // Draw window base
+
+ // Draw window close button
+ int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, 1);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+#if defined(RAYGUI_NO_RICONS)
+ clicked = GuiButton(closeButtonRec, "x");
+#else
+ clicked = GuiButton(closeButtonRec, GuiIconText(RICON_CROSS_SMALL, NULL));
+#endif
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment);
+ //--------------------------------------------------------------------
+
+ return clicked;
+}
+
+// Group Box control with text name
+void GuiGroupBox(Rectangle bounds, const char *text)
+{
+ #define GROUPBOX_LINE_THICK 1
+ #define GROUPBOX_TEXT_PADDING 10
+
+ GuiControlState state = guiState;
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, GROUPBOX_LINE_THICK }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
+
+ GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, bounds.width, 1 }, text);
+ //--------------------------------------------------------------------
+}
+
+// Line control
+void GuiLine(Rectangle bounds, const char *text)
+{
+ #define LINE_TEXT_PADDING 10
+
+ GuiControlState state = guiState;
+
+ Color color = Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha);
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (text == NULL) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, bounds.width, 1 }, 0, BLANK, color);
+ else
+ {
+ Rectangle textBounds = { 0 };
+ textBounds.width = (float)GetTextWidth(text);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + LINE_TEXT_PADDING;
+ textBounds.y = bounds.y - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+
+ // Draw line with embedded text label: "--- text --------------"
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, LINE_TEXT_PADDING - 2, 1 }, 0, BLANK, color);
+ GuiLabel(textBounds, text);
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + LINE_TEXT_PADDING + textBounds.width + 4, bounds.y, bounds.width - textBounds.width - LINE_TEXT_PADDING - 4, 1 }, 0, BLANK, color);
+ }
+ //--------------------------------------------------------------------
+}
+
+// Panel control
+void GuiPanel(Rectangle bounds)
+{
+ #define PANEL_BORDER_WIDTH 1
+
+ GuiControlState state = guiState;
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, PANEL_BORDER_WIDTH, Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), guiAlpha),
+ Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR)), guiAlpha));
+ //--------------------------------------------------------------------
+}
+
+// Scroll Panel control
+Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
+{
+ GuiControlState state = guiState;
+
+ Vector2 scrollPos = { 0.0f, 0.0f };
+ if (scroll != NULL) scrollPos = *scroll;
+
+ bool hasHorizontalScrollBar = (content.width > bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH))? true : false;
+ bool hasVerticalScrollBar = (content.height > bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH))? true : false;
+
+ // Recheck to account for the other scrollbar being visible
+ if (!hasHorizontalScrollBar) hasHorizontalScrollBar = (hasVerticalScrollBar && (content.width > (bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false;
+ if (!hasVerticalScrollBar) hasVerticalScrollBar = (hasHorizontalScrollBar && (content.height > (bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false;
+
+ const int horizontalScrollBarWidth = hasHorizontalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0;
+ const int verticalScrollBarWidth = hasVerticalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0;
+ const Rectangle horizontalScrollBar = { (float)((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)bounds.x + verticalScrollBarWidth : (float)bounds.x) + GuiGetStyle(DEFAULT, BORDER_WIDTH), (float)bounds.y + bounds.height - horizontalScrollBarWidth - GuiGetStyle(DEFAULT, BORDER_WIDTH), (float)bounds.width - verticalScrollBarWidth - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH), (float)horizontalScrollBarWidth };
+ const Rectangle verticalScrollBar = { (float)((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)bounds.x + bounds.width - verticalScrollBarWidth - GuiGetStyle(DEFAULT, BORDER_WIDTH)), (float)bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), (float)verticalScrollBarWidth, (float)bounds.height - horizontalScrollBarWidth - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) };
+
+ // Calculate view area (area without the scrollbars)
+ Rectangle view = (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)?
+ RAYGUI_CLITERAL(Rectangle){ bounds.x + verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth } :
+ RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth };
+
+ // Clip view area to the actual content size
+ if (view.width > content.width) view.width = content.width;
+ if (view.height > content.height) view.height = content.height;
+
+ const float horizontalMin = hasHorizontalScrollBar? ((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)-verticalScrollBarWidth : 0) - (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (((float)GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)-verticalScrollBarWidth : 0) - (float)GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ const float horizontalMax = hasHorizontalScrollBar? content.width - bounds.width + (float)verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH) - (((float)GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)verticalScrollBarWidth : 0) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ const float verticalMin = hasVerticalScrollBar? (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ const float verticalMax = hasVerticalScrollBar? content.height - bounds.height + (float)horizontalScrollBarWidth + (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH);
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check button state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+
+ if (hasHorizontalScrollBar)
+ {
+ if (IsKeyDown(KEY_RIGHT)) scrollPos.x -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ if (IsKeyDown(KEY_LEFT)) scrollPos.x += GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ }
+
+ if (hasVerticalScrollBar)
+ {
+ if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ }
+
+ float wheelMove = GetMouseWheelMove();
+
+ // Horizontal scroll (Shift + Mouse wheel)
+ if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT))) scrollPos.x += wheelMove*20;
+ else scrollPos.y += wheelMove*20; // Vertical scroll
+ }
+ }
+
+ // Normalize scroll values
+ if (scrollPos.x > -horizontalMin) scrollPos.x = -horizontalMin;
+ if (scrollPos.x < -horizontalMax) scrollPos.x = -horizontalMax;
+ if (scrollPos.y > -verticalMin) scrollPos.y = -verticalMin;
+ if (scrollPos.y < -verticalMax) scrollPos.y = -verticalMax;
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background
+
+ // Save size of the scrollbar slider
+ const int slider = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE);
+
+ // Draw horizontal scrollbar if visible
+ if (hasHorizontalScrollBar)
+ {
+ // Change scrollbar slider size to show the diff in size between the content width and the widget width
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)/(int)content.width)*((int)bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)));
+ scrollPos.x = (float)-GuiScrollBar(horizontalScrollBar, (int)-scrollPos.x, (int)horizontalMin, (int)horizontalMax);
+ }
+
+ // Draw vertical scrollbar if visible
+ if (hasVerticalScrollBar)
+ {
+ // Change scrollbar slider size to show the diff in size between the content height and the widget height
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)/(int)content.height)*((int)bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)));
+ scrollPos.y = (float)-GuiScrollBar(verticalScrollBar, (int)-scrollPos.y, (int)verticalMin, (int)verticalMax);
+ }
+
+ // Draw detail corner rectangle if both scroll bars are visible
+ if (hasHorizontalScrollBar && hasVerticalScrollBar)
+ {
+ Rectangle corner = { (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) ? (bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH) + 2) : (horizontalScrollBar.x + horizontalScrollBar.width + 2), verticalScrollBar.y + verticalScrollBar.height + 2, (float)horizontalScrollBarWidth - 4, (float)verticalScrollBarWidth - 4 };
+ GuiDrawRectangle(corner, 0, BLANK, Fade(GetColor(GuiGetStyle(LISTVIEW, TEXT + (state*3))), guiAlpha));
+ }
+
+ // Draw scrollbar lines depending on current state
+ GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER + (state*3))), guiAlpha), BLANK);
+
+ // Set scrollbar slider size back to the way it was before
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider);
+ //--------------------------------------------------------------------
+
+ if (scroll != NULL) *scroll = scrollPos;
+
+ return view;
+}
+
+// Label control
+void GuiLabel(Rectangle bounds, const char *text)
+{
+ GuiControlState state = guiState;
+
+ // Update control
+ //--------------------------------------------------------------------
+ // ...
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LABEL, (state == GUI_STATE_DISABLED)? TEXT_COLOR_DISABLED : TEXT_COLOR_NORMAL)), guiAlpha));
+ //--------------------------------------------------------------------
+}
+
+// Button control, returns true when clicked
+bool GuiButton(Rectangle bounds, const char *text)
+{
+ GuiControlState state = guiState;
+ bool pressed = false;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check button state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+
+ if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(BUTTON, BASE + (state*3))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(BUTTON, TEXT + (state*3))), guiAlpha));
+ //------------------------------------------------------------------
+
+ return pressed;
+}
+
+// Label button control
+bool GuiLabelButton(Rectangle bounds, const char *text)
+{
+ GuiControlState state = guiState;
+ bool pressed = false;
+
+ // NOTE: We force bounds.width to be all text
+ float textWidth = MeasureTextEx(guiFont, text, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING)).x;
+ if (bounds.width < textWidth) bounds.width = textWidth;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check checkbox state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+
+ if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return pressed;
+}
+
+// Toggle Button control, returns true when active
+bool GuiToggle(Rectangle bounds, const char *text, bool active)
+{
+ GuiControlState state = guiState;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check toggle button state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON))
+ {
+ state = GUI_STATE_NORMAL;
+ active = !active;
+ }
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (state == GUI_STATE_NORMAL)
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TOGGLE, (active? BORDER_COLOR_PRESSED : (BORDER + state*3)))), guiAlpha), Fade(GetColor(GuiGetStyle(TOGGLE, (active? BASE_COLOR_PRESSED : (BASE + state*3)))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, (active? TEXT_COLOR_PRESSED : (TEXT + state*3)))), guiAlpha));
+ }
+ else
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TOGGLE, BORDER + state*3)), guiAlpha), Fade(GetColor(GuiGetStyle(TOGGLE, BASE + state*3)), guiAlpha));
+ GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, TEXT + state*3)), guiAlpha));
+ }
+ //--------------------------------------------------------------------
+
+ return active;
+}
+
+// Toggle Group control, returns toggled button index
+int GuiToggleGroup(Rectangle bounds, const char *text, int active)
+{
+ #if !defined(TOGGLEGROUP_MAX_ELEMENTS)
+ #define TOGGLEGROUP_MAX_ELEMENTS 32
+ #endif
+
+ float initBoundsX = bounds.x;
+
+ // Get substrings items from text (items pointers)
+ int rows[TOGGLEGROUP_MAX_ELEMENTS] = { 0 };
+ int itemCount = 0;
+ const char **items = GuiTextSplit(text, &itemCount, rows);
+
+ int prevRow = rows[0];
+
+ for (int i = 0; i < itemCount; i++)
+ {
+ if (prevRow != rows[i])
+ {
+ bounds.x = initBoundsX;
+ bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING));
+ prevRow = rows[i];
+ }
+
+ if (i == active) GuiToggle(bounds, items[i], true);
+ else if (GuiToggle(bounds, items[i], false) == true) active = i;
+
+ bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING));
+ }
+
+ return active;
+}
+
+// Check Box control, returns true when active
+bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
+{
+ GuiControlState state = guiState;
+
+ Rectangle textBounds = { 0 };
+
+ if (text != NULL)
+ {
+ textBounds.width = (float)GetTextWidth(text);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + bounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+ if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING);
+ }
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ Rectangle totalBounds = {
+ (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT)? textBounds.x : bounds.x,
+ bounds.y,
+ bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING),
+ bounds.height,
+ };
+
+ // Check checkbox state
+ if (CheckCollisionPointRec(mousePoint, totalBounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+
+ if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) checked = !checked;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(CHECKBOX, BORDER + (state*3))), guiAlpha), BLANK);
+
+ if (checked)
+ {
+ Rectangle check = { bounds.x + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING),
+ bounds.y + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING),
+ bounds.width - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)),
+ bounds.height - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)) };
+ GuiDrawRectangle(check, 0, BLANK, Fade(GetColor(GuiGetStyle(CHECKBOX, TEXT + state*3)), guiAlpha));
+ }
+
+ GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT)? GUI_TEXT_ALIGN_LEFT : GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return checked;
+}
+
+// Combo Box control, returns selected item index
+int GuiComboBox(Rectangle bounds, const char *text, int active)
+{
+ GuiControlState state = guiState;
+
+ bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING));
+
+ Rectangle selector = { (float)bounds.x + bounds.width + GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING),
+ (float)bounds.y, (float)GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH), (float)bounds.height };
+
+ // Get substrings items from text (items pointers, lengths and count)
+ int itemCount = 0;
+ const char **items = GuiTextSplit(text, &itemCount, NULL);
+
+ if (active < 0) active = 0;
+ else if (active > itemCount - 1) active = itemCount - 1;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked && (itemCount > 1))
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds) ||
+ CheckCollisionPointRec(mousePoint, selector))
+ {
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+ {
+ active += 1;
+ if (active >= itemCount) active = 0;
+ }
+
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ // Draw combo box main
+ GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(COMBOBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(COMBOBOX, BASE + (state*3))), guiAlpha));
+ GuiDrawText(items[active], GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(COMBOBOX, TEXT + (state*3))), guiAlpha));
+
+ // Draw selector using a custom button
+ // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values
+ int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, 1);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+
+ GuiButton(selector, TextFormat("%i/%i", active + 1, itemCount));
+
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+ //--------------------------------------------------------------------
+
+ return active;
+}
+
+// Dropdown Box control
+// NOTE: Returns mouse click
+bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode)
+{
+ GuiControlState state = guiState;
+ int itemSelected = *active;
+ int itemFocused = -1;
+
+ // Get substrings items from text (items pointers, lengths and count)
+ int itemCount = 0;
+ const char **items = GuiTextSplit(text, &itemCount, NULL);
+
+ Rectangle boundsOpen = bounds;
+ boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+
+ Rectangle itemBounds = bounds;
+
+ bool pressed = false; // Check mouse button pressed
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1))
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (editMode)
+ {
+ state = GUI_STATE_PRESSED;
+
+ // Check if mouse has been pressed or released outside limits
+ if (!CheckCollisionPointRec(mousePoint, boundsOpen))
+ {
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+
+ // Check if already selected item has been pressed again
+ if (CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
+
+ // Check focused and selected item
+ for (int i = 0; i < itemCount; i++)
+ {
+ // Update item rectangle y position for next item
+ itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+
+ if (CheckCollisionPointRec(mousePoint, itemBounds))
+ {
+ itemFocused = i;
+ if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON))
+ {
+ itemSelected = i;
+ pressed = true; // Item selected, change to editMode = false
+ }
+ break;
+ }
+ }
+
+ itemBounds = bounds;
+ }
+ else
+ {
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+ {
+ pressed = true;
+ state = GUI_STATE_PRESSED;
+ }
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (editMode) GuiPanel(boundsOpen);
+
+ GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BORDER + state*3)), guiAlpha), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BASE + state*3)), guiAlpha));
+ GuiDrawText(items[itemSelected], GetTextBounds(DEFAULT, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + state*3)), guiAlpha));
+
+ if (editMode)
+ {
+ // Draw visible items
+ for (int i = 0; i < itemCount; i++)
+ {
+ // Update item rectangle y position for next item
+ itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+
+ if (i == itemSelected)
+ {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED)), guiAlpha), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED)), guiAlpha));
+ GuiDrawText(items[i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED)), guiAlpha));
+ }
+ else if (i == itemFocused)
+ {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED)), guiAlpha), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED)), guiAlpha));
+ GuiDrawText(items[i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED)), guiAlpha));
+ }
+ else GuiDrawText(items[i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL)), guiAlpha));
+ }
+ }
+
+ // Draw arrows (using icon if available)
+#if defined(RAYGUI_NO_RICONS)
+ GuiDrawText("v", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 2, 10, 10 },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3))), guiAlpha));
+#else
+ GuiDrawText("#120#", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 6, 10, 10 },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3))), guiAlpha)); // RICON_ARROW_DOWN_FILL
+#endif
+ //--------------------------------------------------------------------
+
+ *active = itemSelected;
+ return pressed;
+}
+
+// Text Box control, updates input text
+// NOTE 2: Returns if KEY_ENTER pressed (useful for data validation)
+bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
+{
+ GuiControlState state = guiState;
+ bool pressed = false;
+
+ Rectangle cursor = {
+ bounds.x + GuiGetStyle(TEXTBOX, TEXT_PADDING) + GetTextWidth(text) + 2,
+ bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE),
+ 4,
+ (float)GuiGetStyle(DEFAULT, TEXT_SIZE)*2
+ };
+
+ if (cursor.height > bounds.height) cursor.height = bounds.height - GuiGetStyle(TEXTBOX, BORDER_WIDTH)*2;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (editMode)
+ {
+ state = GUI_STATE_PRESSED;
+
+ int key = GetCharPressed(); // Returns codepoint as Unicode
+ int keyCount = (int)strlen(text);
+
+ // Only allow keys in range [32..125]
+ if (keyCount < (textSize - 1))
+ {
+ float maxWidth = (bounds.width - (GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING)*2));
+
+ if ((GetTextWidth(text) < (maxWidth - GuiGetStyle(DEFAULT, TEXT_SIZE))) && (key >= 32))
+ {
+ int byteSize = 0;
+ const char *textUTF8 = CodepointToUTF8(key, &byteSize);
+
+ for (int i = 0; i < byteSize; i++)
+ {
+ text[keyCount] = textUTF8[i];
+ keyCount++;
+ }
+
+ text[keyCount] = '\0';
+ }
+ }
+
+ // Delete text
+ if (keyCount > 0)
+ {
+ if (IsKeyPressed(KEY_BACKSPACE))
+ {
+ keyCount--;
+ text[keyCount] = '\0';
+ if (keyCount < 0) keyCount = 0;
+ }
+ }
+
+ if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) pressed = true;
+
+ // Check text alignment to position cursor properly
+ int textAlignment = GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT);
+ if (textAlignment == GUI_TEXT_ALIGN_CENTER) cursor.x = bounds.x + GetTextWidth(text)/2 + bounds.width/2 + 1;
+ else if (textAlignment == GUI_TEXT_ALIGN_RIGHT) cursor.x = bounds.x + bounds.width - GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING);
+ }
+ else
+ {
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = GUI_STATE_FOCUSED;
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (state == GUI_STATE_PRESSED)
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED)), guiAlpha));
+ }
+ else if (state == GUI_STATE_DISABLED)
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED)), guiAlpha));
+ }
+ else GuiDrawRectangle(bounds, 1, Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), BLANK);
+
+ GuiDrawText(text, GetTextBounds(TEXTBOX, bounds), GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3))), guiAlpha));
+
+ // Draw cursor
+ if (editMode) GuiDrawRectangle(cursor, 0, BLANK, Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED)), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return pressed;
+}
+
+// Spinner control, returns selected value
+bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode)
+{
+ GuiControlState state = guiState;
+
+ bool pressed = false;
+ int tempValue = *value;
+
+ Rectangle spinner = { bounds.x + GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_PADDING), bounds.y,
+ bounds.width - 2*(GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_PADDING)), bounds.height };
+ Rectangle leftButtonBound = { (float)bounds.x, (float)bounds.y, (float)GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.height };
+ Rectangle rightButtonBound = { (float)bounds.x + bounds.width - GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.y, (float)GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.height };
+
+ Rectangle textBounds = { 0 };
+ if (text != NULL)
+ {
+ textBounds.width = (float)GetTextWidth(text);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + bounds.width + GuiGetStyle(SPINNER, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+ if (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING);
+ }
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check spinner state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+
+ if (!editMode)
+ {
+ if (tempValue < minValue) tempValue = minValue;
+ if (tempValue > maxValue) tempValue = maxValue;
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ // TODO: Set Spinner properties for ValueBox
+ pressed = GuiValueBox(spinner, NULL, &tempValue, minValue, maxValue, editMode);
+
+ // Draw value selector custom buttons
+ // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values
+ int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH));
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+
+#if defined(RAYGUI_NO_RICONS)
+ if (GuiButton(leftButtonBound, "<")) tempValue--;
+ if (GuiButton(rightButtonBound, ">")) tempValue++;
+#else
+ if (GuiButton(leftButtonBound, GuiIconText(RICON_ARROW_LEFT_FILL, NULL))) tempValue--;
+ if (GuiButton(rightButtonBound, GuiIconText(RICON_ARROW_RIGHT_FILL, NULL))) tempValue++;
+#endif
+
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+
+ // Draw text label if provided
+ GuiDrawText(text, textBounds, (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT)? GUI_TEXT_ALIGN_LEFT : GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
+ //--------------------------------------------------------------------
+
+ *value = tempValue;
+ return pressed;
+}
+
+// Value Box control, updates input text with numbers
+// NOTE: Requires static variables: frameCounter
+bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode)
+{
+ #if !defined(VALUEBOX_MAX_CHARS)
+ #define VALUEBOX_MAX_CHARS 32
+ #endif
+
+ GuiControlState state = guiState;
+ bool pressed = false;
+
+ char textValue[VALUEBOX_MAX_CHARS + 1] = "\0";
+ sprintf(textValue, "%i", *value);
+
+ Rectangle textBounds = { 0 };
+ if (text != NULL)
+ {
+ textBounds.width = (float)GetTextWidth(text);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + bounds.width + GuiGetStyle(VALUEBOX, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+ if (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING);
+ }
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ bool valueHasChanged = false;
+
+ if (editMode)
+ {
+ state = GUI_STATE_PRESSED;
+
+ int keyCount = (int)strlen(textValue);
+
+ // Only allow keys in range [48..57]
+ if (keyCount < VALUEBOX_MAX_CHARS)
+ {
+ if (GetTextWidth(textValue) < bounds.width)
+ {
+ int key = GetCharPressed();
+ if ((key >= 48) && (key <= 57))
+ {
+ textValue[keyCount] = (char)key;
+ keyCount++;
+ valueHasChanged = true;
+ }
+ }
+ }
+
+ // Delete text
+ if (keyCount > 0)
+ {
+ if (IsKeyPressed(KEY_BACKSPACE))
+ {
+ keyCount--;
+ textValue[keyCount] = '\0';
+ if (keyCount < 0) keyCount = 0;
+ valueHasChanged = true;
+ }
+ }
+
+ if (valueHasChanged) *value = TextToInteger(textValue);
+
+ if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) pressed = true;
+ }
+ else
+ {
+ if (*value > maxValue) *value = maxValue;
+ else if (*value < minValue) *value = minValue;
+
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = GUI_STATE_FOCUSED;
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ Color baseColor = BLANK;
+ if (state == GUI_STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED));
+ else if (state == GUI_STATE_DISABLED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED));
+
+ // WARNING: BLANK color does not work properly with Fade()
+ GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), guiAlpha), baseColor);
+ GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3))), guiAlpha));
+
+ // Draw cursor
+ if (editMode)
+ {
+ // NOTE: ValueBox internal text is always centered
+ Rectangle cursor = { bounds.x + GetTextWidth(textValue)/2 + bounds.width/2 + 2, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) };
+ GuiDrawRectangle(cursor, 0, BLANK, Fade(GetColor(GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED)), guiAlpha));
+ }
+
+ // Draw text label if provided
+ GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT)? GUI_TEXT_ALIGN_LEFT : GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return pressed;
+}
+
+// Text Box control with multiple lines
+bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
+{
+ GuiControlState state = guiState;
+ bool pressed = false;
+
+ Rectangle textAreaBounds = {
+ bounds.x + GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING),
+ bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING),
+ bounds.width - 2*(GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING)),
+ bounds.height - 2*(GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING))
+ };
+
+ // Cursor position, [x, y] values should be updated
+ Rectangle cursor = { 0, -1, 4, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) + 2 };
+
+ float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/(float)guiFont.baseSize; // Character rectangle scaling factor
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (editMode)
+ {
+ state = GUI_STATE_PRESSED;
+
+ // We get an Unicode codepoint
+ int codepoint = GetCharPressed();
+ int textLength = (int)strlen(text); // Length in bytes (UTF-8 string)
+
+ // Introduce characters
+ if (textLength < (textSize - 1))
+ {
+ if (IsKeyPressed(KEY_ENTER))
+ {
+ text[textLength] = '\n';
+ textLength++;
+ }
+ else if (codepoint >= 32)
+ {
+ // Supports Unicode inputs -> Encoded to UTF-8
+ int charUTF8Length = 0;
+ const char *charEncoded = CodepointToUTF8(codepoint, &charUTF8Length);
+ memcpy(text + textLength, charEncoded, charUTF8Length);
+ textLength += charUTF8Length;
+ }
+ }
+
+ // Delete characters
+ if (textLength > 0)
+ {
+ if (IsKeyPressed(KEY_BACKSPACE))
+ {
+ if ((unsigned char)text[textLength - 1] < 127)
+ {
+ // Remove ASCII equivalent character (1 byte)
+ textLength--;
+ text[textLength] = '\0';
+ }
+ else
+ {
+ // Remove latest UTF-8 unicode character introduced (n bytes)
+ int charUTF8Length = 0;
+ while (((unsigned char)text[textLength - 1 - charUTF8Length] & 0b01000000) == 0) charUTF8Length++;
+
+ textLength -= (charUTF8Length + 1);
+ text[textLength] = '\0';
+ }
+ }
+ }
+
+ // Exit edit mode
+ if (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ else
+ {
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = GUI_STATE_FOCUSED;
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
+ }
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (state == GUI_STATE_PRESSED)
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED)), guiAlpha));
+ }
+ else if (state == GUI_STATE_DISABLED)
+ {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED)), guiAlpha));
+ }
+ else GuiDrawRectangle(bounds, 1, Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), BLANK);
+
+ int wrapMode = 1; // 0-No wrap, 1-Char wrap, 2-Word wrap
+ Vector2 cursorPos = { textAreaBounds.x, textAreaBounds.y };
+
+ //int lastSpacePos = 0;
+ //int lastSpaceWidth = 0;
+ //int lastSpaceCursorPos = 0;
+
+ for (int i = 0, codepointLength = 0; text[i] != '\0'; i += codepointLength)
+ {
+ int codepoint = GetCodepoint(text + i, &codepointLength);
+ int index = GetGlyphIndex(guiFont, codepoint); // If requested codepoint is not found, we get '?' (0x3f)
+ Rectangle atlasRec = guiFont.recs[index];
+ GlyphInfo glyphInfo = guiFont.glyphs[index]; // Glyph measures
+
+ if ((codepointLength == 1) && (codepoint == '\n'))
+ {
+ cursorPos.y += (guiFont.baseSize*scaleFactor + GuiGetStyle(TEXTBOX, TEXT_LINES_PADDING)); // Line feed
+ cursorPos.x = textAreaBounds.x; // Carriage return
+ }
+ else
+ {
+ if (wrapMode == 1)
+ {
+ int glyphWidth = 0;
+ if (glyphInfo.advanceX != 0) glyphWidth += glyphInfo.advanceX;
+ else glyphWidth += (atlasRec.width + glyphInfo.offsetX);
+
+ // Jump line if the end of the text box area has been reached
+ if ((cursorPos.x + (glyphWidth*scaleFactor)) > (textAreaBounds.x + textAreaBounds.width))
+ {
+ cursorPos.y += (guiFont.baseSize*scaleFactor + GuiGetStyle(TEXTBOX, TEXT_LINES_PADDING)); // Line feed
+ cursorPos.x = textAreaBounds.x; // Carriage return
+ }
+ }
+ else if (wrapMode == 2)
+ {
+ /*
+ if ((codepointLength == 1) && (codepoint == ' '))
+ {
+ lastSpacePos = i;
+ lastSpaceWidth = 0;
+ lastSpaceCursorPos = cursorPos.x;
+ }
+
+ // Jump line if last word reaches end of text box area
+ if ((lastSpaceCursorPos + lastSpaceWidth) > (textAreaBounds.x + textAreaBounds.width))
+ {
+ cursorPos.y += 12; // Line feed
+ cursorPos.x = textAreaBounds.x; // Carriage return
+ }
+ */
+ }
+
+ // Draw current character glyph
+ DrawTextCodepoint(guiFont, codepoint, cursorPos, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), Fade(GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3))), guiAlpha));
+
+ int glyphWidth = 0;
+ if (glyphInfo.advanceX != 0) glyphWidth += glyphInfo.advanceX;
+ else glyphWidth += (atlasRec.width + glyphInfo.offsetX);
+
+ cursorPos.x += (glyphWidth*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
+ //if (i > lastSpacePos) lastSpaceWidth += (atlasRec.width + (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
+ }
+ }
+
+ cursor.x = cursorPos.x;
+ cursor.y = cursorPos.y;
+
+ // Draw cursor position considering text glyphs
+ if (editMode) GuiDrawRectangle(cursor, 0, BLANK, Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED)), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return pressed;
+}
+
+// Slider control with pro parameters
+// NOTE: Other GuiSlider*() controls use this one
+float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue, int sliderWidth)
+{
+ GuiControlState state = guiState;
+
+ int sliderValue = (int)(((value - minValue)/(maxValue - minValue))*(bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH)));
+
+ Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING),
+ 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) };
+
+ if (sliderWidth > 0) // Slider
+ {
+ slider.x += (sliderValue - sliderWidth/2);
+ slider.width = (float)sliderWidth;
+ }
+ else if (sliderWidth == 0) // SliderBar
+ {
+ slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH);
+ slider.width = (float)sliderValue;
+ }
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+ {
+ state = GUI_STATE_PRESSED;
+
+ // Get equivalent value and slider position from mousePoint.x
+ value = ((maxValue - minValue)*(mousePoint.x - (float)(bounds.x + sliderWidth/2)))/(float)(bounds.width - sliderWidth) + minValue;
+
+ if (sliderWidth > 0) slider.x = mousePoint.x - slider.width/2; // Slider
+ else if (sliderWidth == 0) slider.width = (float)sliderValue; // SliderBar
+ }
+ else state = GUI_STATE_FOCUSED;
+ }
+
+ if (value > maxValue) value = maxValue;
+ else if (value < minValue) value = minValue;
+ }
+
+ // Bar limits check
+ if (sliderWidth > 0) // Slider
+ {
+ if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH);
+ else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH);
+ }
+ else if (sliderWidth == 0) // SliderBar
+ {
+ if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH);
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(SLIDER, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
+
+ // Draw slider internal bar (depends on state)
+ if ((state == GUI_STATE_NORMAL) || (state == GUI_STATE_PRESSED)) GuiDrawRectangle(slider, 0, BLANK, Fade(GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED)), guiAlpha));
+ else if (state == GUI_STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, Fade(GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED)), guiAlpha));
+
+ // Draw left/right text if provided
+ if (textLeft != NULL)
+ {
+ Rectangle textBounds = { 0 };
+ textBounds.width = (float)GetTextWidth(textLeft);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SLIDER, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+
+ GuiDrawText(textLeft, textBounds, GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(SLIDER, TEXT + (state*3))), guiAlpha));
+ }
+
+ if (textRight != NULL)
+ {
+ Rectangle textBounds = { 0 };
+ textBounds.width = (float)GetTextWidth(textRight);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + bounds.width + GuiGetStyle(SLIDER, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+
+ GuiDrawText(textRight, textBounds, GUI_TEXT_ALIGN_LEFT, Fade(GetColor(GuiGetStyle(SLIDER, TEXT + (state*3))), guiAlpha));
+ }
+ //--------------------------------------------------------------------
+
+ return value;
+}
+
+// Slider control extended, returns selected value and has text
+float GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue)
+{
+ return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH));
+}
+
+// Slider Bar control extended, returns selected value
+float GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue)
+{
+ return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, 0);
+}
+
+// Progress Bar control extended, shows current progress value
+float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue)
+{
+ GuiControlState state = guiState;
+
+ Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH),
+ bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0,
+ bounds.height - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) - 2*GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING) };
+
+ // Update control
+ //--------------------------------------------------------------------
+ if (state != GUI_STATE_DISABLED) progress.width = ((float)(value/(maxValue - minValue))*(float)(bounds.width - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)));
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(PROGRESSBAR, BORDER + (state*3))), guiAlpha), BLANK);
+
+ // Draw slider internal progress bar (depends on state)
+ if ((state == GUI_STATE_NORMAL) || (state == GUI_STATE_PRESSED)) GuiDrawRectangle(progress, 0, BLANK, Fade(GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED)), guiAlpha));
+ else if (state == GUI_STATE_FOCUSED) GuiDrawRectangle(progress, 0, BLANK, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT_COLOR_FOCUSED)), guiAlpha));
+
+ // Draw left/right text if provided
+ if (textLeft != NULL)
+ {
+ Rectangle textBounds = { 0 };
+ textBounds.width = (float)GetTextWidth(textLeft);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x - textBounds.width - GuiGetStyle(PROGRESSBAR, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+
+ GuiDrawText(textLeft, textBounds, GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3))), guiAlpha));
+ }
+
+ if (textRight != NULL)
+ {
+ Rectangle textBounds = { 0 };
+ textBounds.width = (float)GetTextWidth(textRight);
+ textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+ textBounds.x = bounds.x + bounds.width + GuiGetStyle(PROGRESSBAR, TEXT_PADDING);
+ textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
+
+ GuiDrawText(textRight, textBounds, GUI_TEXT_ALIGN_LEFT, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3))), guiAlpha));
+ }
+ //--------------------------------------------------------------------
+
+ return value;
+}
+
+// Status Bar control
+void GuiStatusBar(Rectangle bounds, const char *text)
+{
+ GuiControlState state = guiState;
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BORDER_COLOR_NORMAL : BORDER_COLOR_DISABLED)), guiAlpha),
+ Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
+ GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED)), guiAlpha));
+ //--------------------------------------------------------------------
+}
+
+// Dummy rectangle control, intended for placeholding
+void GuiDummyRec(Rectangle bounds, const char *text)
+{
+ GuiControlState state = guiState;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check button state
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
+ GuiDrawText(text, GetTextBounds(DEFAULT, bounds), GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(BUTTON, (state != GUI_STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED)), guiAlpha));
+ //------------------------------------------------------------------
+}
+
+// Scroll Bar control
+int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue)
+{
+ GuiControlState state = guiState;
+
+ // Is the scrollbar horizontal or vertical?
+ bool isVertical = (bounds.width > bounds.height)? false : true;
+
+ // The size (width or height depending on scrollbar type) of the spinner buttons
+ const int spinnerSize = GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE)? (isVertical? (int)bounds.width - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH) : (int)bounds.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH)) : 0;
+
+ // Arrow buttons [<] [>] [∧] [∨]
+ Rectangle arrowUpLeft = { 0 };
+ Rectangle arrowDownRight = { 0 };
+
+ // Actual area of the scrollbar excluding the arrow buttons
+ Rectangle scrollbar = { 0 };
+
+ // Slider bar that moves --[///]-----
+ Rectangle slider = { 0 };
+
+ // Normalize value
+ if (value > maxValue) value = maxValue;
+ if (value < minValue) value = minValue;
+
+ const int range = maxValue - minValue;
+ int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE);
+
+ // Calculate rectangles for all of the components
+ arrowUpLeft = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize };
+
+ if (isVertical)
+ {
+ arrowDownRight = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + bounds.height - spinnerSize - GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize};
+ scrollbar = RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING), arrowUpLeft.y + arrowUpLeft.height, bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING)), bounds.height - arrowUpLeft.height - arrowDownRight.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH) };
+ sliderSize = (sliderSize >= scrollbar.height)? ((int)scrollbar.height - 2) : sliderSize; // Make sure the slider won't get outside of the scrollbar
+ slider = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), (float)scrollbar.y + (int)(((float)(value - minValue)/range)*(scrollbar.height - sliderSize)), (float)bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)), (float)sliderSize };
+ }
+ else
+ {
+ arrowDownRight = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + bounds.width - spinnerSize - GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize};
+ scrollbar = RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x + arrowUpLeft.width, bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING), bounds.width - arrowUpLeft.width - arrowDownRight.width - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH), bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING))};
+ sliderSize = (sliderSize >= scrollbar.width)? ((int)scrollbar.width - 2) : sliderSize; // Make sure the slider won't get outside of the scrollbar
+ slider = RAYGUI_CLITERAL(Rectangle){ (float)scrollbar.x + (int)(((float)(value - minValue)/range)*(scrollbar.width - sliderSize)), (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), (float)sliderSize, (float)bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)) };
+ }
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = GUI_STATE_FOCUSED;
+
+ // Handle mouse wheel
+ int wheel = (int)GetMouseWheelMove();
+ if (wheel != 0) value += wheel;
+
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+ {
+ if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) value -= range/GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) value += range/GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+
+ state = GUI_STATE_PRESSED;
+ }
+ else if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+ {
+ if (!isVertical)
+ {
+ Rectangle scrollArea = { arrowUpLeft.x + arrowUpLeft.width, arrowUpLeft.y, scrollbar.width, bounds.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH)};
+ if (CheckCollisionPointRec(mousePoint, scrollArea)) value = (int)(((float)(mousePoint.x - scrollArea.x - slider.width/2)*range)/(scrollArea.width - slider.width) + minValue);
+ }
+ else
+ {
+ Rectangle scrollArea = { arrowUpLeft.x, arrowUpLeft.y+arrowUpLeft.height, bounds.width - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH), scrollbar.height};
+ if (CheckCollisionPointRec(mousePoint, scrollArea)) value = (int)(((float)(mousePoint.y - scrollArea.y - slider.height/2)*range)/(scrollArea.height - slider.height) + minValue);
+ }
+ }
+ }
+
+ // Normalize value
+ if (value > maxValue) value = maxValue;
+ if (value < minValue) value = minValue;
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), guiAlpha), Fade(GetColor(GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED)), guiAlpha)); // Draw the background
+
+ GuiDrawRectangle(scrollbar, 0, BLANK, Fade(GetColor(GuiGetStyle(BUTTON, BASE_COLOR_NORMAL)), guiAlpha)); // Draw the scrollbar active area background
+ GuiDrawRectangle(slider, 0, BLANK, Fade(GetColor(GuiGetStyle(SLIDER, BORDER + state*3)), guiAlpha)); // Draw the slider bar
+
+ // Draw arrows (using icon if available)
+ if (GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE))
+ {
+#if defined(RAYGUI_NO_RICONS)
+ GuiDrawText(isVertical? "^" : "<", RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x, arrowUpLeft.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3))), guiAlpha));
+ GuiDrawText(isVertical? "v" : ">", RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3))), guiAlpha));
+#else
+ GuiDrawText(isVertical? "#121#" : "#118#", RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x, arrowUpLeft.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3)), guiAlpha)); // RICON_ARROW_UP_FILL / RICON_ARROW_LEFT_FILL
+ GuiDrawText(isVertical? "#120#" : "#119#", RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height },
+ GUI_TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3)), guiAlpha)); // RICON_ARROW_DOWN_FILL / RICON_ARROW_RIGHT_FILL
+#endif
+ }
+ //--------------------------------------------------------------------
+
+ return value;
+}
+
+// List View control
+int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int active)
+{
+ int itemCount = 0;
+ const char **items = NULL;
+
+ if (text != NULL) items = GuiTextSplit(text, &itemCount, NULL);
+
+ return GuiListViewEx(bounds, items, itemCount, NULL, scrollIndex, active);
+}
+
+// List View control with extended parameters
+int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, int *scrollIndex, int active)
+{
+ GuiControlState state = guiState;
+ int itemFocused = (focus == NULL)? -1 : *focus;
+ int itemSelected = active;
+
+ // Check if we need a scroll bar
+ bool useScrollBar = false;
+ if ((GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING))*count > bounds.height) useScrollBar = true;
+
+ // Define base item rectangle [0]
+ Rectangle itemBounds = { 0 };
+ itemBounds.x = bounds.x + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING);
+ itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING) + GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ itemBounds.width = bounds.width - 2*GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING) - GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ itemBounds.height = (float)GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT);
+ if (useScrollBar) itemBounds.width -= GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH);
+
+ // Get items on the list
+ int visibleItems = (int)bounds.height/(GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ if (visibleItems > count) visibleItems = count;
+
+ int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex;
+ if ((startIndex < 0) || (startIndex > (count - visibleItems))) startIndex = 0;
+ int endIndex = startIndex + visibleItems;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ // Check mouse inside list view
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = GUI_STATE_FOCUSED;
+
+ // Check focused and selected item
+ for (int i = 0; i < visibleItems; i++)
+ {
+ if (CheckCollisionPointRec(mousePoint, itemBounds))
+ {
+ itemFocused = startIndex + i;
+ if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+ {
+ if (itemSelected == (startIndex + i)) itemSelected = -1;
+ else itemSelected = startIndex + i;
+ }
+ break;
+ }
+
+ // Update item rectangle y position for next item
+ itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ }
+
+ if (useScrollBar)
+ {
+ int wheelMove = (int)GetMouseWheelMove();
+ startIndex -= wheelMove;
+
+ if (startIndex < 0) startIndex = 0;
+ else if (startIndex > (count - visibleItems)) startIndex = count - visibleItems;
+
+ endIndex = startIndex + visibleItems;
+ if (endIndex > count) endIndex = count;
+ }
+ }
+ else itemFocused = -1;
+
+ // Reset item rectangle y to [0]
+ itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING) + GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), guiAlpha), GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background
+
+ // Draw visible items
+ for (int i = 0; ((i < visibleItems) && (text != NULL)); i++)
+ {
+ if (state == GUI_STATE_DISABLED)
+ {
+ if ((startIndex + i) == itemSelected) GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED)), guiAlpha));
+
+ GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED)), guiAlpha));
+ }
+ else
+ {
+ if ((startIndex + i) == itemSelected)
+ {
+ // Draw item selected
+ GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED)), guiAlpha), Fade(GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED)), guiAlpha));
+ GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED)), guiAlpha));
+ }
+ else if ((startIndex + i) == itemFocused)
+ {
+ // Draw item focused
+ GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED)), guiAlpha), Fade(GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED)), guiAlpha));
+ GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED)), guiAlpha));
+ }
+ else
+ {
+ // Draw item normal
+ GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL)), guiAlpha));
+ }
+ }
+
+ // Update item rectangle y position for next item
+ itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ }
+
+ if (useScrollBar)
+ {
+ Rectangle scrollBarBounds = {
+ bounds.x + bounds.width - GuiGetStyle(LISTVIEW, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH),
+ bounds.y + GuiGetStyle(LISTVIEW, BORDER_WIDTH), (float)GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH),
+ bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH)
+ };
+
+ // Calculate percentage of visible items and apply same percentage to scrollbar
+ float percentVisible = (float)(endIndex - startIndex)/count;
+ float sliderSize = bounds.height*percentVisible;
+
+ int prevSliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); // Save default slider size
+ int prevScrollSpeed = GuiGetStyle(SCROLLBAR, SCROLL_SPEED); // Save default scroll speed
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)sliderSize); // Change slider size
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems); // Change scroll speed
+
+ startIndex = GuiScrollBar(scrollBarBounds, startIndex, 0, count - visibleItems);
+
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed); // Reset scroll speed to default
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize); // Reset slider size to default
+ }
+ //--------------------------------------------------------------------
+
+ if (focus != NULL) *focus = itemFocused;
+ if (scrollIndex != NULL) *scrollIndex = startIndex;
+
+ return itemSelected;
+}
+
+// Color Panel control
+Color GuiColorPanel(Rectangle bounds, Color color)
+{
+ const Color colWhite = { 255, 255, 255, 255 };
+ const Color colBlack = { 0, 0, 0, 255 };
+
+ GuiControlState state = guiState;
+ Vector2 pickerSelector = { 0 };
+
+ Vector3 vcolor = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
+ Vector3 hsv = ConvertRGBtoHSV(vcolor);
+
+ pickerSelector.x = bounds.x + (float)hsv.y*bounds.width; // HSV: Saturation
+ pickerSelector.y = bounds.y + (1.0f - (float)hsv.z)*bounds.height; // HSV: Value
+
+ float hue = -1.0f;
+ Vector3 maxHue = { hue >= 0.0f ? hue : hsv.x, 1.0f, 1.0f };
+ Vector3 rgbHue = ConvertHSVtoRGB(maxHue);
+ Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x),
+ (unsigned char)(255.0f*rgbHue.y),
+ (unsigned char)(255.0f*rgbHue.z), 255 };
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+ {
+ state = GUI_STATE_PRESSED;
+ pickerSelector = mousePoint;
+
+ // Calculate color from picker
+ Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y };
+
+ colorPick.x /= (float)bounds.width; // Get normalized value on x
+ colorPick.y /= (float)bounds.height; // Get normalized value on y
+
+ hsv.y = colorPick.x;
+ hsv.z = 1.0f - colorPick.y;
+
+ Vector3 rgb = ConvertHSVtoRGB(hsv);
+
+ // NOTE: Vector3ToColor() only available on raylib 1.8.1
+ color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x),
+ (unsigned char)(255.0f*rgb.y),
+ (unsigned char)(255.0f*rgb.z),
+ (unsigned char)(255.0f*(float)color.a/255.0f) };
+
+ }
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (state != GUI_STATE_DISABLED)
+ {
+ DrawRectangleGradientEx(bounds, Fade(colWhite, guiAlpha), Fade(colWhite, guiAlpha), Fade(maxHueCol, guiAlpha), Fade(maxHueCol, guiAlpha));
+ DrawRectangleGradientEx(bounds, Fade(colBlack, 0), Fade(colBlack, guiAlpha), Fade(colBlack, guiAlpha), Fade(colBlack, 0));
+
+ // Draw color picker: selector
+ Rectangle selector = { pickerSelector.x - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, pickerSelector.y - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE) };
+ GuiDrawRectangle(selector, 0, BLANK, Fade(colWhite, guiAlpha));
+ }
+ else
+ {
+ DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.6f), guiAlpha));
+ }
+
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), guiAlpha), BLANK);
+ //--------------------------------------------------------------------
+
+ return color;
+}
+
+// Color Bar Alpha control
+// NOTE: Returns alpha value normalized [0..1]
+float GuiColorBarAlpha(Rectangle bounds, float alpha)
+{
+ #define COLORBARALPHA_CHECKED_SIZE 10
+
+ GuiControlState state = guiState;
+ Rectangle selector = { (float)bounds.x + alpha*bounds.width - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)/2, (float)bounds.y - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW), (float)GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT), (float)bounds.height + GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)*2 };
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds) ||
+ CheckCollisionPointRec(mousePoint, selector))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+ {
+ state = GUI_STATE_PRESSED;
+
+ alpha = (mousePoint.x - bounds.x)/bounds.width;
+ if (alpha <= 0.0f) alpha = 0.0f;
+ if (alpha >= 1.0f) alpha = 1.0f;
+ //selector.x = bounds.x + (int)(((alpha - 0)/(100 - 0))*(bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH))) - selector.width/2;
+ }
+ else state = GUI_STATE_FOCUSED;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+
+ // Draw alpha bar: checked background
+ if (state != GUI_STATE_DISABLED)
+ {
+ int checksX = (int)bounds.width/COLORBARALPHA_CHECKED_SIZE;
+ int checksY = (int)bounds.height/COLORBARALPHA_CHECKED_SIZE;
+
+ for (int x = 0; x < checksX; x++)
+ {
+ for (int y = 0; y < checksY; y++)
+ {
+ Rectangle check = { bounds.x + x*COLORBARALPHA_CHECKED_SIZE, bounds.y + y*COLORBARALPHA_CHECKED_SIZE, COLORBARALPHA_CHECKED_SIZE, COLORBARALPHA_CHECKED_SIZE };
+ GuiDrawRectangle(check, 0, BLANK, ((x + y)%2)? Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.4f), guiAlpha) : Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.4f), guiAlpha));
+ }
+ }
+
+ DrawRectangleGradientEx(bounds, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha));
+ }
+ else DrawRectangleGradientEx(bounds, Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha));
+
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), guiAlpha), BLANK);
+
+ // Draw alpha bar: selector
+ GuiDrawRectangle(selector, 0, BLANK, Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return alpha;
+}
+
+// Color Bar Hue control
+// Returns hue value normalized [0..1]
+// NOTE: Other similar bars (for reference):
+// Color GuiColorBarSat() [WHITE->color]
+// Color GuiColorBarValue() [BLACK->color], HSV/HSL
+// float GuiColorBarLuminance() [BLACK->WHITE]
+float GuiColorBarHue(Rectangle bounds, float hue)
+{
+ GuiControlState state = guiState;
+ Rectangle selector = { (float)bounds.x - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW), (float)bounds.y + hue/360.0f*bounds.height - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)/2, (float)bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)*2, (float)GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT) };
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds) ||
+ CheckCollisionPointRec(mousePoint, selector))
+ {
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+ {
+ state = GUI_STATE_PRESSED;
+
+ hue = (mousePoint.y - bounds.y)*360/bounds.height;
+ if (hue <= 0.0f) hue = 0.0f;
+ if (hue >= 359.0f) hue = 359.0f;
+
+ }
+ else state = GUI_STATE_FOCUSED;
+
+ /*if (IsKeyDown(KEY_UP))
+ {
+ hue -= 2.0f;
+ if (hue <= 0.0f) hue = 0.0f;
+ }
+ else if (IsKeyDown(KEY_DOWN))
+ {
+ hue += 2.0f;
+ if (hue >= 360.0f) hue = 360.0f;
+ }*/
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (state != GUI_STATE_DISABLED)
+ {
+ // Draw hue bar:color bars
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y), (int)bounds.width, ceil(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 255, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 255, 255, 0, 255 }, guiAlpha));
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + bounds.height/6), (int)bounds.width, ceil(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 255, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 0, 255, 0, 255 }, guiAlpha));
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 2*(bounds.height/6)), (int)bounds.width, ceil(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 0, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 0, 255, 255, 255 }, guiAlpha));
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 3*(bounds.height/6)), (int)bounds.width, ceil(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 0, 255, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 0, 0, 255, 255 }, guiAlpha));
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 4*(bounds.height/6)), (int)bounds.width, ceil(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 0, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 255, 0, 255, 255 }, guiAlpha));
+ DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 5*(bounds.height/6)), (int)bounds.width, (int)(bounds.height/6), Fade(RAYGUI_CLITERAL(Color) { 255, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color) { 255, 0, 0, 255 }, guiAlpha));
+ }
+ else DrawRectangleGradientV((int)bounds.x, (int)bounds.y, (int)bounds.width, (int)bounds.height, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha));
+
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), guiAlpha), BLANK);
+
+ // Draw hue bar: selector
+ GuiDrawRectangle(selector, 0, BLANK, Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), guiAlpha));
+ //--------------------------------------------------------------------
+
+ return hue;
+}
+
+// Color Picker control
+// NOTE: It's divided in multiple controls:
+// Color GuiColorPanel(Rectangle bounds, Color color)
+// float GuiColorBarAlpha(Rectangle bounds, float alpha)
+// float GuiColorBarHue(Rectangle bounds, float value)
+// NOTE: bounds define GuiColorPanel() size
+Color GuiColorPicker(Rectangle bounds, Color color)
+{
+ color = GuiColorPanel(bounds, color);
+
+ Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height };
+ //Rectangle boundsAlpha = { bounds.x, bounds.y + bounds.height + GuiGetStyle(COLORPICKER, BARS_PADDING), bounds.width, GuiGetStyle(COLORPICKER, BARS_THICK) };
+
+ Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ color.r/255.0f, color.g/255.0f, color.b/255.0f });
+ hsv.x = GuiColorBarHue(boundsHue, hsv.x);
+ //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f);
+ Vector3 rgb = ConvertHSVtoRGB(hsv);
+
+ color = RAYGUI_CLITERAL(Color){ (unsigned char)roundf(rgb.x*255.0f), (unsigned char)roundf(rgb.y*255.0f), (unsigned char)roundf(rgb.z*255.0f), color.a };
+
+ return color;
+}
+
+// Message Box control
+int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons)
+{
+ #define MESSAGEBOX_BUTTON_HEIGHT 24
+ #define MESSAGEBOX_BUTTON_PADDING 10
+
+ int clicked = -1; // Returns clicked button from buttons list, 0 refers to closed window button
+
+ int buttonCount = 0;
+ const char **buttonsText = GuiTextSplit(buttons, &buttonCount, NULL);
+ Rectangle buttonBounds = { 0 };
+ buttonBounds.x = bounds.x + MESSAGEBOX_BUTTON_PADDING;
+ buttonBounds.y = bounds.y + bounds.height - MESSAGEBOX_BUTTON_HEIGHT - MESSAGEBOX_BUTTON_PADDING;
+ buttonBounds.width = (bounds.width - MESSAGEBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount;
+ buttonBounds.height = MESSAGEBOX_BUTTON_HEIGHT;
+
+ Vector2 textSize = MeasureTextEx(guiFont, message, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), 1);
+
+ Rectangle textBounds = { 0 };
+ textBounds.x = bounds.x + bounds.width/2 - textSize.x/2;
+ textBounds.y = bounds.y + WINDOW_STATUSBAR_HEIGHT + (bounds.height - WINDOW_STATUSBAR_HEIGHT - MESSAGEBOX_BUTTON_HEIGHT - MESSAGEBOX_BUTTON_PADDING)/2 - textSize.y/2;
+ textBounds.width = textSize.x;
+ textBounds.height = textSize.y;
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (GuiWindowBox(bounds, title)) clicked = 0;
+
+ int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiLabel(textBounds, message);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
+
+ prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+
+ for (int i = 0; i < buttonCount; i++)
+ {
+ if (GuiButton(buttonBounds, buttonsText[i])) clicked = i + 1;
+ buttonBounds.x += (buttonBounds.width + MESSAGEBOX_BUTTON_PADDING);
+ }
+
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment);
+ //--------------------------------------------------------------------
+
+ return clicked;
+}
+
+// Text Input Box control, ask for text
+int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text)
+{
+ #define TEXTINPUTBOX_BUTTON_HEIGHT 24
+ #define TEXTINPUTBOX_BUTTON_PADDING 10
+ #define TEXTINPUTBOX_HEIGHT 30
+
+ #define TEXTINPUTBOX_MAX_TEXT_LENGTH 256
+
+ // Used to enable text edit mode
+ // WARNING: No more than one GuiTextInputBox() should be open at the same time
+ static bool textEditMode = false;
+
+ int btnIndex = -1;
+
+ int buttonCount = 0;
+ const char **buttonsText = GuiTextSplit(buttons, &buttonCount, NULL);
+ Rectangle buttonBounds = { 0 };
+ buttonBounds.x = bounds.x + TEXTINPUTBOX_BUTTON_PADDING;
+ buttonBounds.y = bounds.y + bounds.height - TEXTINPUTBOX_BUTTON_HEIGHT - TEXTINPUTBOX_BUTTON_PADDING;
+ buttonBounds.width = (bounds.width - TEXTINPUTBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount;
+ buttonBounds.height = TEXTINPUTBOX_BUTTON_HEIGHT;
+
+ int messageInputHeight = (int)bounds.height - WINDOW_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - TEXTINPUTBOX_BUTTON_HEIGHT - 2*TEXTINPUTBOX_BUTTON_PADDING;
+
+ Rectangle textBounds = { 0 };
+ if (message != NULL)
+ {
+ Vector2 textSize = MeasureTextEx(guiFont, message, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), 1);
+
+ textBounds.x = bounds.x + bounds.width/2 - textSize.x/2;
+ textBounds.y = bounds.y + WINDOW_STATUSBAR_HEIGHT + messageInputHeight/4 - textSize.y/2;
+ textBounds.width = textSize.x;
+ textBounds.height = textSize.y;
+ }
+
+ Rectangle textBoxBounds = { 0 };
+ textBoxBounds.x = bounds.x + TEXTINPUTBOX_BUTTON_PADDING;
+ textBoxBounds.y = bounds.y + WINDOW_STATUSBAR_HEIGHT - TEXTINPUTBOX_HEIGHT/2;
+ if (message == NULL) textBoxBounds.y += messageInputHeight/2;
+ else textBoxBounds.y += (messageInputHeight/2 + messageInputHeight/4);
+ textBoxBounds.width = bounds.width - TEXTINPUTBOX_BUTTON_PADDING*2;
+ textBoxBounds.height = TEXTINPUTBOX_HEIGHT;
+
+ // Draw control
+ //--------------------------------------------------------------------
+ if (GuiWindowBox(bounds, title)) btnIndex = 0;
+
+ // Draw message if available
+ if (message != NULL)
+ {
+ int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiLabel(textBounds, message);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
+ }
+
+ if (GuiTextBox(textBoxBounds, text, TEXTINPUTBOX_MAX_TEXT_LENGTH, textEditMode)) textEditMode = !textEditMode;
+
+ int prevBtnTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+
+ for (int i = 0; i < buttonCount; i++)
+ {
+ if (GuiButton(buttonBounds, buttonsText[i])) btnIndex = i + 1;
+ buttonBounds.x += (buttonBounds.width + MESSAGEBOX_BUTTON_PADDING);
+ }
+
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment);
+ //--------------------------------------------------------------------
+
+ return btnIndex;
+}
+
+// Grid control
+// NOTE: Returns grid mouse-hover selected cell
+// About drawing lines at subpixel spacing, simple put, not easy solution:
+// https://stackoverflow.com/questions/4435450/2d-opengl-drawing-lines-that-dont-exactly-fit-pixel-raster
+Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs)
+{
+ #if !defined(GRID_COLOR_ALPHA)
+ #define GRID_COLOR_ALPHA 0.15f // Grid lines alpha amount
+ #endif
+
+ GuiControlState state = guiState;
+ Vector2 mousePoint = GetMousePosition();
+ Vector2 currentCell = { -1, -1 };
+
+ int linesV = ((int)(bounds.width/spacing))*subdivs + 1;
+ int linesH = ((int)(bounds.height/spacing))*subdivs + 1;
+
+ // Update control
+ //--------------------------------------------------------------------
+ if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ {
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ currentCell.x = (mousePoint.x - bounds.x)/spacing;
+ currentCell.y = (mousePoint.y - bounds.y)/spacing;
+ }
+ }
+ //--------------------------------------------------------------------
+
+ // Draw control
+ //--------------------------------------------------------------------
+ switch (state)
+ {
+ case GUI_STATE_NORMAL:
+ {
+ if (subdivs > 0)
+ {
+ // Draw vertical grid lines
+ for (int i = 0; i < linesV; i++)
+ {
+ Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height };
+ GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0) ? Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), GRID_COLOR_ALPHA*4) : Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), GRID_COLOR_ALPHA));
+ }
+
+ // Draw horizontal grid lines
+ for (int i = 0; i < linesH; i++)
+ {
+ Rectangle lineH = { bounds.x, bounds.y + spacing*i/subdivs, bounds.width, 1 };
+ GuiDrawRectangle(lineH, 0, BLANK, ((i%subdivs) == 0) ? Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), GRID_COLOR_ALPHA*4) : Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), GRID_COLOR_ALPHA));
+ }
+ }
+ } break;
+ default: break;
+ }
+
+ return currentCell;
+}
+
+//----------------------------------------------------------------------------------
+// Styles loading functions
+//----------------------------------------------------------------------------------
+
+// Load raygui style file (.rgs)
+void GuiLoadStyle(const char *fileName)
+{
+ bool tryBinary = false;
+
+ // Try reading the files as text file first
+ FILE *rgsFile = fopen(fileName, "rt");
+
+ if (rgsFile != NULL)
+ {
+ char buffer[256] = { 0 };
+ fgets(buffer, 256, rgsFile);
+
+ if (buffer[0] == '#')
+ {
+ int controlId = 0;
+ int propertyId = 0;
+ unsigned int propertyValue = 0;
+
+ while (!feof(rgsFile))
+ {
+ switch (buffer[0])
+ {
+ case 'p':
+ {
+ // Style property: p <control_id> <property_id> <property_value> <property_name>
+
+ sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue);
+
+ GuiSetStyle(controlId, propertyId, (int)propertyValue);
+
+ } break;
+ case 'f':
+ {
+ // Style font: f <gen_font_size> <charmap_file> <font_file>
+
+ int fontSize = 0;
+ char charmapFileName[256] = { 0 };
+ char fontFileName[256] = { 0 };
+ sscanf(buffer, "f %d %s %[^\r\n]s", &fontSize, charmapFileName, fontFileName);
+
+ Font font = { 0 };
+
+ if (charmapFileName[0] != '0')
+ {
+ // Load characters from charmap file,
+ // expected '\n' separated list of integer values
+ char *charValues = LoadFileText(charmapFileName);
+ if (charValues != NULL)
+ {
+ int glyphCount = 0;
+ const char **chars = TextSplit(charValues, '\n', &glyphCount);
+
+ int *values = (int *)RAYGUI_MALLOC(glyphCount*sizeof(int));
+ for (int i = 0; i < glyphCount; i++) values[i] = TextToInteger(chars[i]);
+
+ font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, values, glyphCount);
+
+ RAYGUI_FREE(values);
+ }
+ }
+ else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0);
+
+ if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font);
+
+ } break;
+ default: break;
+ }
+
+ fgets(buffer, 256, rgsFile);
+ }
+ }
+ else tryBinary = true;
+
+ fclose(rgsFile);
+ }
+
+ if (tryBinary)
+ {
+ rgsFile = fopen(fileName, "rb");
+
+ if (rgsFile == NULL) return;
+
+ char signature[5] = "";
+ short version = 0;
+ short reserved = 0;
+ int propertyCount = 0;
+
+ fread(signature, 1, 4, rgsFile);
+ fread(&version, 1, sizeof(short), rgsFile);
+ fread(&reserved, 1, sizeof(short), rgsFile);
+ fread(&propertyCount, 1, sizeof(int), rgsFile);
+
+ if ((signature[0] == 'r') &&
+ (signature[1] == 'G') &&
+ (signature[2] == 'S') &&
+ (signature[3] == ' '))
+ {
+ short controlId = 0;
+ short propertyId = 0;
+ int propertyValue = 0;
+
+ for (int i = 0; i < propertyCount; i++)
+ {
+ fread(&controlId, 1, sizeof(short), rgsFile);
+ fread(&propertyId, 1, sizeof(short), rgsFile);
+ fread(&propertyValue, 1, sizeof(int), rgsFile);
+
+ if (controlId == 0) // DEFAULT control
+ {
+ // If a DEFAULT property is loaded, it is propagated to all controls
+ // NOTE: All DEFAULT properties should be defined first in the file
+ GuiSetStyle(0, (int)propertyId, propertyValue);
+
+ if (propertyId < RAYGUI_MAX_PROPS_BASE) for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) GuiSetStyle(i, (int)propertyId, propertyValue);
+ }
+ else GuiSetStyle((int)controlId, (int)propertyId, propertyValue);
+ }
+
+ // Font loading is highly dependant on raylib API to load font data and image
+#if !defined(RAYGUI_STANDALONE)
+ // Load custom font if available
+ int fontDataSize = 0;
+ fread(&fontDataSize, 1, sizeof(int), rgsFile);
+
+ if (fontDataSize > 0)
+ {
+ Font font = { 0 };
+ int fontType = 0; // 0-Normal, 1-SDF
+ Rectangle whiteRec = { 0 };
+
+ fread(&font.baseSize, 1, sizeof(int), rgsFile);
+ fread(&font.glyphCount, 1, sizeof(int), rgsFile);
+ fread(&fontType, 1, sizeof(int), rgsFile);
+
+ // Load font white rectangle
+ fread(&whiteRec, 1, sizeof(Rectangle), rgsFile);
+
+ // Load font image parameters
+ int fontImageSize = 0;
+ fread(&fontImageSize, 1, sizeof(int), rgsFile);
+
+ if (fontImageSize > 0)
+ {
+ Image imFont = { 0 };
+ imFont.mipmaps = 1;
+ fread(&imFont.width, 1, sizeof(int), rgsFile);
+ fread(&imFont.height, 1, sizeof(int), rgsFile);
+ fread(&imFont.format, 1, sizeof(int), rgsFile);
+
+ imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageSize);
+ fread(imFont.data, 1, fontImageSize, rgsFile);
+
+ font.texture = LoadTextureFromImage(imFont);
+
+ RAYGUI_FREE(imFont.data);
+ }
+
+ // Load font recs data
+ font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle));
+ for (int i = 0; i < font.glyphCount; i++) fread(&font.recs[i], 1, sizeof(Rectangle), rgsFile);
+
+ // Load font chars info data
+ font.glyphs = (GlyphInfo *)RAYGUI_CALLOC(font.glyphCount, sizeof(GlyphInfo));
+ for (int i = 0; i < font.glyphCount; i++)
+ {
+ fread(&font.glyphs[i].value, 1, sizeof(int), rgsFile);
+ fread(&font.glyphs[i].offsetX, 1, sizeof(int), rgsFile);
+ fread(&font.glyphs[i].offsetY, 1, sizeof(int), rgsFile);
+ fread(&font.glyphs[i].advanceX, 1, sizeof(int), rgsFile);
+ }
+
+ GuiSetFont(font);
+
+ // Set font texture source rectangle to be used as white texture to draw shapes
+ // NOTE: This way, all gui can be draw using a single draw call
+ if ((whiteRec.width != 0) && (whiteRec.height != 0)) SetShapesTexture(font.texture, whiteRec);
+ }
+#endif
+ }
+
+ fclose(rgsFile);
+ }
+}
+
+// Load style default over global style
+void GuiLoadStyleDefault(void)
+{
+ // We set this variable first to avoid cyclic function calls
+ // when calling GuiSetStyle() and GuiGetStyle()
+ guiStyleLoaded = true;
+
+ // Initialize default LIGHT style property values
+ GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, 0x838383ff);
+ GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0xc9c9c9ff);
+ GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, 0x686868ff);
+ GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, 0x5bb2d9ff);
+ GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, 0xc9effeff);
+ GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, 0x6c9bbcff);
+ GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, 0x0492c7ff);
+ GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, 0x97e8ffff);
+ GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, 0x368bafff);
+ GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, 0xb5c1c2ff);
+ GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, 0xe6e9e9ff);
+ GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, 0xaeb7b8ff);
+ GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); // WARNING: Some controls use other values
+ GuiSetStyle(DEFAULT, TEXT_PADDING, 0); // WARNING: Some controls use other values
+ GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER); // WARNING: Some controls use other values
+
+ // Initialize control-specific property values
+ // NOTE: Those properties are in default list but require specific values by control type
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, 2);
+ GuiSetStyle(SLIDER, TEXT_PADDING, 5);
+ GuiSetStyle(CHECKBOX, TEXT_PADDING, 5);
+ GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_RIGHT);
+ GuiSetStyle(TEXTBOX, TEXT_PADDING, 5);
+ GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(VALUEBOX, TEXT_PADDING, 4);
+ GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(SPINNER, TEXT_PADDING, 4);
+ GuiSetStyle(SPINNER, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(STATUSBAR, TEXT_PADDING, 6);
+ GuiSetStyle(STATUSBAR, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+
+ // Initialize extended property values
+ // NOTE: By default, extended property values are initialized to 0
+ GuiSetStyle(DEFAULT, TEXT_SIZE, 10); // DEFAULT, shared by all controls
+ GuiSetStyle(DEFAULT, TEXT_SPACING, 1); // DEFAULT, shared by all controls
+ GuiSetStyle(DEFAULT, LINE_COLOR, 0x90abb5ff); // DEFAULT specific property
+ GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0xf5f5f5ff); // DEFAULT specific property
+ GuiSetStyle(TOGGLE, GROUP_PADDING, 2);
+ GuiSetStyle(SLIDER, SLIDER_WIDTH, 15);
+ GuiSetStyle(SLIDER, SLIDER_PADDING, 1);
+ GuiSetStyle(PROGRESSBAR, PROGRESS_PADDING, 1);
+ GuiSetStyle(CHECKBOX, CHECK_PADDING, 1);
+ GuiSetStyle(COMBOBOX, COMBO_BUTTON_WIDTH, 30);
+ GuiSetStyle(COMBOBOX, COMBO_BUTTON_PADDING, 2);
+ GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16);
+ GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING, 2);
+ GuiSetStyle(TEXTBOX, TEXT_LINES_PADDING, 5);
+ GuiSetStyle(TEXTBOX, TEXT_INNER_PADDING, 4);
+ GuiSetStyle(TEXTBOX, COLOR_SELECTED_FG, 0xf0fffeff);
+ GuiSetStyle(TEXTBOX, COLOR_SELECTED_BG, 0x839affe0);
+ GuiSetStyle(SPINNER, SPIN_BUTTON_WIDTH, 20);
+ GuiSetStyle(SPINNER, SPIN_BUTTON_PADDING, 2);
+ GuiSetStyle(SCROLLBAR, BORDER_WIDTH, 0);
+ GuiSetStyle(SCROLLBAR, ARROWS_VISIBLE, 0);
+ GuiSetStyle(SCROLLBAR, ARROWS_SIZE, 6);
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING, 0);
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, 16);
+ GuiSetStyle(SCROLLBAR, SCROLL_PADDING, 0);
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, 10);
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 0x1e);
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_PADDING, 2);
+ GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 10);
+ GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE);
+ GuiSetStyle(COLORPICKER, COLOR_SELECTOR_SIZE, 6);
+ GuiSetStyle(COLORPICKER, HUEBAR_WIDTH, 0x14);
+ GuiSetStyle(COLORPICKER, HUEBAR_PADDING, 0xa);
+ GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT, 6);
+ GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW, 2);
+
+ guiFont = GetFontDefault(); // Initialize default font
+}
+
+// Get text with icon id prepended
+// NOTE: Useful to add icons by name id (enum) instead of
+// a number that can change between ricon versions
+const char *GuiIconText(int iconId, const char *text)
+{
+#if defined(RAYGUI_NO_RICONS)
+ return NULL;
+#else
+ static char buffer[1024] = { 0 };
+ memset(buffer, 0, 1024);
+
+ sprintf(buffer, "#%03i#", iconId);
+
+ if (text != NULL)
+ {
+ for (int i = 5; i < 1024; i++)
+ {
+ buffer[i] = text[i - 5];
+ if (text[i - 5] == '\0') break;
+ }
+ }
+
+ return buffer;
+#endif
+}
+
+#if !defined(RAYGUI_NO_RICONS)
+
+// Get full icons data pointer
+unsigned int *GuiGetIcons(void) { return guiIcons; }
+
+// Load raygui icons file (.rgi)
+// NOTE: In case nameIds are required, they can be requested with loadIconsName,
+// they are returned as a guiIconsName[iconCount][RICON_MAX_NAME_LENGTH],
+// WARNING: guiIconsName[]][] memory should be manually freed!
+char **GuiLoadIcons(const char *fileName, bool loadIconsName)
+{
+ // Style File Structure (.rgi)
+ // ------------------------------------------------------
+ // Offset | Size | Type | Description
+ // ------------------------------------------------------
+ // 0 | 4 | char | Signature: "rGI "
+ // 4 | 2 | short | Version: 100
+ // 6 | 2 | short | reserved
+
+ // 8 | 2 | short | Num icons (N)
+ // 10 | 2 | short | Icons size (Options: 16, 32, 64) (S)
+
+ // Icons name id (32 bytes per name id)
+ // foreach (icon)
+ // {
+ // 12+32*i | 32 | char | Icon NameId
+ // }
+
+ // Icons data: One bit per pixel, stored as unsigned int array (depends on icon size)
+ // S*S pixels/32bit per unsigned int = K unsigned int per icon
+ // foreach (icon)
+ // {
+ // ... | K | unsigned int | Icon Data
+ // }
+
+ FILE *rgiFile = fopen(fileName, "rb");
+
+ char **guiIconsName = NULL;
+
+ if (rgiFile != NULL)
+ {
+ char signature[5] = "";
+ short version = 0;
+ short reserved = 0;
+ short iconCount = 0;
+ short iconSize = 0;
+
+ fread(signature, 1, 4, rgiFile);
+ fread(&version, 1, sizeof(short), rgiFile);
+ fread(&reserved, 1, sizeof(short), rgiFile);
+ fread(&iconCount, 1, sizeof(short), rgiFile);
+ fread(&iconSize, 1, sizeof(short), rgiFile);
+
+ if ((signature[0] == 'r') &&
+ (signature[1] == 'G') &&
+ (signature[2] == 'I') &&
+ (signature[3] == ' '))
+ {
+ if (loadIconsName)
+ {
+ guiIconsName = (char **)RAYGUI_MALLOC(iconCount*sizeof(char **));
+ for (int i = 0; i < iconCount; i++)
+ {
+ guiIconsName[i] = (char *)RAYGUI_MALLOC(RICON_MAX_NAME_LENGTH);
+ fread(guiIconsName[i], RICON_MAX_NAME_LENGTH, 1, rgiFile);
+ }
+ }
+ else fseek(rgiFile, iconCount*RICON_MAX_NAME_LENGTH, SEEK_CUR);
+
+ // Read icons data directly over guiIcons data array
+ fread(guiIcons, iconCount*(iconSize*iconSize/32), sizeof(unsigned int), rgiFile);
+ }
+
+ fclose(rgiFile);
+ }
+
+ return guiIconsName;
+}
+
+// Draw selected icon using rectangles pixel-by-pixel
+void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color)
+{
+ #define BIT_CHECK(a,b) ((a) & (1<<(b)))
+
+ for (int i = 0, y = 0; i < RICON_SIZE*RICON_SIZE/32; i++)
+ {
+ for (int k = 0; k < 32; k++)
+ {
+ if (BIT_CHECK(guiIcons[iconId*RICON_DATA_ELEMENTS + i], k))
+ {
+ #if !defined(RAYGUI_STANDALONE)
+ DrawRectangle(posX + (k%RICON_SIZE)*pixelSize, posY + y*pixelSize, pixelSize, pixelSize, color);
+ #endif
+ }
+
+ if ((k == 15) || (k == 31)) y++;
+ }
+ }
+}
+
+// Get icon bit data
+// NOTE: Bit data array grouped as unsigned int (ICON_SIZE*ICON_SIZE/32 elements)
+unsigned int *GuiGetIconData(int iconId)
+{
+ static unsigned int iconData[RICON_DATA_ELEMENTS] = { 0 };
+ memset(iconData, 0, RICON_DATA_ELEMENTS*sizeof(unsigned int));
+
+ if (iconId < RICON_MAX_ICONS) memcpy(iconData, &guiIcons[iconId*RICON_DATA_ELEMENTS], RICON_DATA_ELEMENTS*sizeof(unsigned int));
+
+ return iconData;
+}
+
+// Set icon bit data
+// NOTE: Data must be provided as unsigned int array (ICON_SIZE*ICON_SIZE/32 elements)
+void GuiSetIconData(int iconId, unsigned int *data)
+{
+ if (iconId < RICON_MAX_ICONS) memcpy(&guiIcons[iconId*RICON_DATA_ELEMENTS], data, RICON_DATA_ELEMENTS*sizeof(unsigned int));
+}
+
+// Set icon pixel value
+void GuiSetIconPixel(int iconId, int x, int y)
+{
+ #define BIT_SET(a,b) ((a) |= (1<<(b)))
+
+ // This logic works for any RICON_SIZE pixels icons,
+ // For example, in case of 16x16 pixels, every 2 lines fit in one unsigned int data element
+ BIT_SET(guiIcons[iconId*RICON_DATA_ELEMENTS + y/(sizeof(unsigned int)*8/RICON_SIZE)], x + (y%(sizeof(unsigned int)*8/RICON_SIZE)*RICON_SIZE));
+}
+
+// Clear icon pixel value
+void GuiClearIconPixel(int iconId, int x, int y)
+{
+ #define BIT_CLEAR(a,b) ((a) &= ~((1)<<(b)))
+
+ // This logic works for any RICON_SIZE pixels icons,
+ // For example, in case of 16x16 pixels, every 2 lines fit in one unsigned int data element
+ BIT_CLEAR(guiIcons[iconId*RICON_DATA_ELEMENTS + y/(sizeof(unsigned int)*8/RICON_SIZE)], x + (y%(sizeof(unsigned int)*8/RICON_SIZE)*RICON_SIZE));
+}
+
+// Check icon pixel value
+bool GuiCheckIconPixel(int iconId, int x, int y)
+{
+ #define BIT_CHECK(a,b) ((a) & (1<<(b)))
+
+ return (BIT_CHECK(guiIcons[iconId*8 + y/2], x + (y%2*16)));
+}
+#endif // !RAYGUI_NO_RICONS
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Definition
+//----------------------------------------------------------------------------------
+// Gui get text width using default font
+// NOTE: Icon is not considered here
+static int GetTextWidth(const char *text)
+{
+ Vector2 size = { 0 };
+
+ if ((text != NULL) && (text[0] != '\0'))
+ {
+ size = MeasureTextEx(guiFont, text, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
+ }
+
+ return (int)size.x;
+}
+
+// Get text bounds considering control bounds
+static Rectangle GetTextBounds(int control, Rectangle bounds)
+{
+ Rectangle textBounds = bounds;
+
+ textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH);
+ textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH);
+ textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH);
+ textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH);
+
+ // Consider TEXT_PADDING properly, depends on control type and TEXT_ALIGNMENT
+ switch (control)
+ {
+ case COMBOBOX: bounds.width -= (GuiGetStyle(control, COMBO_BUTTON_WIDTH) + GuiGetStyle(control, COMBO_BUTTON_PADDING)); break;
+ case VALUEBOX: break; // NOTE: ValueBox text value always centered, text padding applies to label
+ default:
+ {
+ if (GuiGetStyle(control, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING);
+ else textBounds.x += GuiGetStyle(control, TEXT_PADDING);
+ } break;
+ }
+
+ // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW (scrollbar?)
+ // More special cases (label on side): CHECKBOX, SLIDER, VALUEBOX, SPINNER
+
+ return textBounds;
+}
+
+// Get text icon if provided and move text cursor
+// NOTE: We support up to 999 values for iconId
+static const char *GetTextIcon(const char *text, int *iconId)
+{
+#if !defined(RAYGUI_NO_RICONS)
+ *iconId = -1;
+ if (text[0] == '#') // Maybe we have an icon!
+ {
+ char iconValue[4] = { 0 }; // Maximum length for icon value: 3 digits + '\0'
+
+ int pos = 1;
+ while ((pos < 4) && (text[pos] >= '0') && (text[pos] <= '9'))
+ {
+ iconValue[pos - 1] = text[pos];
+ pos++;
+ }
+
+ if (text[pos] == '#')
+ {
+ *iconId = TextToInteger(iconValue);
+
+ // Move text pointer after icon
+ // WARNING: If only icon provided, it could point to EOL character: '\0'
+ if (*iconId >= 0) text += (pos + 1);
+ }
+ }
+#endif
+
+ return text;
+}
+
+// Gui draw text using default font
+static void GuiDrawText(const char *text, Rectangle bounds, int alignment, Color tint)
+{
+ #define TEXT_VALIGN_PIXEL_OFFSET(h) ((int)h%2) // Vertical alignment for pixel perfect
+
+ if ((text != NULL) && (text[0] != '\0'))
+ {
+ int iconId = 0;
+ text = GetTextIcon(text, &iconId); // Check text for icon and move cursor
+
+ // Get text position depending on alignment and iconId
+ //---------------------------------------------------------------------------------
+ #define RICON_TEXT_PADDING 4
+
+ Vector2 position = { bounds.x, bounds.y };
+
+ // NOTE: We get text size after icon has been processed
+ int textWidth = GetTextWidth(text);
+ int textHeight = GuiGetStyle(DEFAULT, TEXT_SIZE);
+
+ // If text requires an icon, add size to measure
+ if (iconId >= 0)
+ {
+ textWidth += RICON_SIZE;
+
+ // WARNING: If only icon provided, text could be pointing to EOF character: '\0'
+ if ((text != NULL) && (text[0] != '\0')) textWidth += RICON_TEXT_PADDING;
+ }
+
+ // Check guiTextAlign global variables
+ switch (alignment)
+ {
+ case GUI_TEXT_ALIGN_LEFT:
+ {
+ position.x = bounds.x;
+ position.y = bounds.y + bounds.height/2 - textHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
+ } break;
+ case GUI_TEXT_ALIGN_CENTER:
+ {
+ position.x = bounds.x + bounds.width/2 - textWidth/2;
+ position.y = bounds.y + bounds.height/2 - textHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
+ } break;
+ case GUI_TEXT_ALIGN_RIGHT:
+ {
+ position.x = bounds.x + bounds.width - textWidth;
+ position.y = bounds.y + bounds.height/2 - textHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
+ } break;
+ default: break;
+ }
+
+ // NOTE: Make sure we get pixel-perfect coordinates,
+ // In case of decimals we got weird text positioning
+ position.x = (float)((int)position.x);
+ position.y = (float)((int)position.y);
+ //---------------------------------------------------------------------------------
+
+ // Draw text (with icon if available)
+ //---------------------------------------------------------------------------------
+#if !defined(RAYGUI_NO_RICONS)
+ if (iconId >= 0)
+ {
+ // NOTE: We consider icon height, probably different than text size
+ GuiDrawIcon(iconId, (int)position.x, (int)(bounds.y + bounds.height/2 - RICON_SIZE/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height)), 1, tint);
+ position.x += (RICON_SIZE + RICON_TEXT_PADDING);
+ }
+#endif
+ DrawTextEx(guiFont, text, position, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING), tint);
+ //---------------------------------------------------------------------------------
+ }
+}
+
+// Gui draw rectangle using default raygui plain style with borders
+static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color)
+{
+ if (color.a > 0)
+ {
+ // Draw rectangle filled with color
+ DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, color);
+ }
+
+ if (borderWidth > 0)
+ {
+ // Draw rectangle border lines with color
+ DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, borderColor);
+ DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
+ DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
+ DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, borderColor);
+ }
+}
+
+// Split controls text into multiple strings
+// Also check for multiple columns (required by GuiToggleGroup())
+static const char **GuiTextSplit(const char *text, int *count, int *textRow)
+{
+ // NOTE: Current implementation returns a copy of the provided string with '\0' (string end delimiter)
+ // inserted between strings defined by "delimiter" parameter. No memory is dynamically allocated,
+ // all used memory is static... it has some limitations:
+ // 1. Maximum number of possible split strings is set by TEXTSPLIT_MAX_TEXT_ELEMENTS
+ // 2. Maximum size of text to split is TEXTSPLIT_MAX_TEXT_LENGTH
+ // NOTE: Those definitions could be externally provided if required
+
+ #if !defined(TEXTSPLIT_MAX_TEXT_LENGTH)
+ #define TEXTSPLIT_MAX_TEXT_LENGTH 1024
+ #endif
+
+ #if !defined(TEXTSPLIT_MAX_TEXT_ELEMENTS)
+ #define TEXTSPLIT_MAX_TEXT_ELEMENTS 128
+ #endif
+
+ static const char *result[TEXTSPLIT_MAX_TEXT_ELEMENTS] = { NULL };
+ static char buffer[TEXTSPLIT_MAX_TEXT_LENGTH] = { 0 };
+ memset(buffer, 0, TEXTSPLIT_MAX_TEXT_LENGTH);
+
+ result[0] = buffer;
+ int counter = 1;
+
+ if (textRow != NULL) textRow[0] = 0;
+
+ // Count how many substrings we have on text and point to every one
+ for (int i = 0; i < TEXTSPLIT_MAX_TEXT_LENGTH; i++)
+ {
+ buffer[i] = text[i];
+ if (buffer[i] == '\0') break;
+ else if ((buffer[i] == ';') || (buffer[i] == '\n'))
+ {
+ result[counter] = buffer + i + 1;
+
+ if (textRow != NULL)
+ {
+ if (buffer[i] == '\n') textRow[counter] = textRow[counter - 1] + 1;
+ else textRow[counter] = textRow[counter - 1];
+ }
+
+ buffer[i] = '\0'; // Set an end of string at this point
+
+ counter++;
+ if (counter == TEXTSPLIT_MAX_TEXT_ELEMENTS) break;
+ }
+ }
+
+ *count = counter;
+
+ return result;
+}
+
+// Convert color data from RGB to HSV
+// NOTE: Color data should be passed normalized
+static Vector3 ConvertRGBtoHSV(Vector3 rgb)
+{
+ Vector3 hsv = { 0 };
+ float min = 0.0f;
+ float max = 0.0f;
+ float delta = 0.0f;
+
+ min = (rgb.x < rgb.y)? rgb.x : rgb.y;
+ min = (min < rgb.z)? min : rgb.z;
+
+ max = (rgb.x > rgb.y)? rgb.x : rgb.y;
+ max = (max > rgb.z)? max : rgb.z;
+
+ hsv.z = max; // Value
+ delta = max - min;
+
+ if (delta < 0.00001f)
+ {
+ hsv.y = 0.0f;
+ hsv.x = 0.0f; // Undefined, maybe NAN?
+ return hsv;
+ }
+
+ if (max > 0.0f)
+ {
+ // NOTE: If max is 0, this divide would cause a crash
+ hsv.y = (delta/max); // Saturation
+ }
+ else
+ {
+ // NOTE: If max is 0, then r = g = b = 0, s = 0, h is undefined
+ hsv.y = 0.0f;
+ hsv.x = 0.0f; // Undefined, maybe NAN?
+ return hsv;
+ }
+
+ // NOTE: Comparing float values could not work properly
+ if (rgb.x >= max) hsv.x = (rgb.y - rgb.z)/delta; // Between yellow & magenta
+ else
+ {
+ if (rgb.y >= max) hsv.x = 2.0f + (rgb.z - rgb.x)/delta; // Between cyan & yellow
+ else hsv.x = 4.0f + (rgb.x - rgb.y)/delta; // Between magenta & cyan
+ }
+
+ hsv.x *= 60.0f; // Convert to degrees
+
+ if (hsv.x < 0.0f) hsv.x += 360.0f;
+
+ return hsv;
+}
+
+// Convert color data from HSV to RGB
+// NOTE: Color data should be passed normalized
+static Vector3 ConvertHSVtoRGB(Vector3 hsv)
+{
+ Vector3 rgb = { 0 };
+ float hh = 0.0f, p = 0.0f, q = 0.0f, t = 0.0f, ff = 0.0f;
+ long i = 0;
+
+ // NOTE: Comparing float values could not work properly
+ if (hsv.y <= 0.0f)
+ {
+ rgb.x = hsv.z;
+ rgb.y = hsv.z;
+ rgb.z = hsv.z;
+ return rgb;
+ }
+
+ hh = hsv.x;
+ if (hh >= 360.0f) hh = 0.0f;
+ hh /= 60.0f;
+
+ i = (long)hh;
+ ff = hh - i;
+ p = hsv.z*(1.0f - hsv.y);
+ q = hsv.z*(1.0f - (hsv.y*ff));
+ t = hsv.z*(1.0f - (hsv.y*(1.0f - ff)));
+
+ switch (i)
+ {
+ case 0:
+ {
+ rgb.x = hsv.z;
+ rgb.y = t;
+ rgb.z = p;
+ } break;
+ case 1:
+ {
+ rgb.x = q;
+ rgb.y = hsv.z;
+ rgb.z = p;
+ } break;
+ case 2:
+ {
+ rgb.x = p;
+ rgb.y = hsv.z;
+ rgb.z = t;
+ } break;
+ case 3:
+ {
+ rgb.x = p;
+ rgb.y = q;
+ rgb.z = hsv.z;
+ } break;
+ case 4:
+ {
+ rgb.x = t;
+ rgb.y = p;
+ rgb.z = hsv.z;
+ } break;
+ case 5:
+ default:
+ {
+ rgb.x = hsv.z;
+ rgb.y = p;
+ rgb.z = q;
+ } break;
+ }
+
+ return rgb;
+}
+
+#if defined(RAYGUI_STANDALONE)
+// Returns a Color struct from hexadecimal value
+static Color GetColor(int hexValue)
+{
+ Color color;
+
+ color.r = (unsigned char)(hexValue >> 24) & 0xFF;
+ color.g = (unsigned char)(hexValue >> 16) & 0xFF;
+ color.b = (unsigned char)(hexValue >> 8) & 0xFF;
+ color.a = (unsigned char)hexValue & 0xFF;
+
+ return color;
+}
+
+// Returns hexadecimal value for a Color
+static int ColorToInt(Color color)
+{
+ return (((int)color.r << 24) | ((int)color.g << 16) | ((int)color.b << 8) | (int)color.a);
+}
+
+// Check if point is inside rectangle
+static bool CheckCollisionPointRec(Vector2 point, Rectangle rec)
+{
+ bool collision = false;
+
+ if ((point.x >= rec.x) && (point.x <= (rec.x + rec.width)) &&
+ (point.y >= rec.y) && (point.y <= (rec.y + rec.height))) collision = true;
+
+ return collision;
+}
+
+// Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
+static Color Fade(Color color, float alpha)
+{
+ if (alpha < 0.0f) alpha = 0.0f;
+ else if (alpha > 1.0f) alpha = 1.0f;
+
+ Color result = { color.r, color.g, color.b, (unsigned char)(255.0f*alpha) };
+
+ return result;
+}
+
+// Formatting of text with variables to 'embed'
+static const char *TextFormat(const char *text, ...)
+{
+ #define MAX_FORMATTEXT_LENGTH 64
+
+ static char buffer[MAX_FORMATTEXT_LENGTH];
+
+ va_list args;
+ va_start(args, text);
+ vsprintf(buffer, text, args);
+ va_end(args);
+
+ return buffer;
+}
+
+// Draw rectangle with vertical gradient fill color
+// NOTE: This function is only used by GuiColorPicker()
+static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2)
+{
+ Rectangle bounds = { (float)posX, (float)posY, (float)width, (float)height };
+ DrawRectangleGradientEx(bounds, color1, color2, color2, color1);
+}
+
+#define TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH 1024 // Size of static buffer: TextSplit()
+#define TEXTSPLIT_MAX_SUBSTRINGS_COUNT 128 // Size of static pointers array: TextSplit()
+
+// Split string into multiple strings
+const char **TextSplit(const char *text, char delimiter, int *count)
+{
+ // NOTE: Current implementation returns a copy of the provided string with '\0' (string end delimiter)
+ // inserted between strings defined by "delimiter" parameter. No memory is dynamically allocated,
+ // all used memory is static... it has some limitations:
+ // 1. Maximum number of possible split strings is set by TEXTSPLIT_MAX_SUBSTRINGS_COUNT
+ // 2. Maximum size of text to split is TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH
+
+ static const char *result[TEXTSPLIT_MAX_SUBSTRINGS_COUNT] = { NULL };
+ static char buffer[TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH] = { 0 };
+ memset(buffer, 0, TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH);
+
+ result[0] = buffer;
+ int counter = 0;
+
+ if (text != NULL)
+ {
+ counter = 1;
+
+ // Count how many substrings we have on text and point to every one
+ for (int i = 0; i < TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH; i++)
+ {
+ buffer[i] = text[i];
+ if (buffer[i] == '\0') break;
+ else if (buffer[i] == delimiter)
+ {
+ buffer[i] = '\0'; // Set an end of string at this point
+ result[counter] = buffer + i + 1;
+ counter++;
+
+ if (counter == TEXTSPLIT_MAX_SUBSTRINGS_COUNT) break;
+ }
+ }
+ }
+
+ *count = counter;
+ return result;
+}
+
+// Get integer value from text
+// NOTE: This function replaces atoi() [stdlib.h]
+static int TextToInteger(const char *text)
+{
+ int value = 0;
+ int sign = 1;
+
+ if ((text[0] == '+') || (text[0] == '-'))
+ {
+ if (text[0] == '-') sign = -1;
+ text++;
+ }
+
+ for (int i = 0; ((text[i] >= '0') && (text[i] <= '9')); ++i) value = value*10 + (int)(text[i] - '0');
+
+ return value*sign;
+}
+
+// Encode codepoint into UTF-8 text (char array size returned as parameter)
+static const char *CodepointToUTF8(int codepoint, int *byteSize)
+{
+ static char utf8[6] = { 0 };
+ int size = 0;
+
+ if (codepoint <= 0x7f)
+ {
+ utf8[0] = (char)codepoint;
+ size = 1;
+ }
+ else if (codepoint <= 0x7ff)
+ {
+ utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0);
+ utf8[1] = (char)((codepoint & 0x3f) | 0x80);
+ size = 2;
+ }
+ else if (codepoint <= 0xffff)
+ {
+ utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0);
+ utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80);
+ utf8[2] = (char)((codepoint & 0x3f) | 0x80);
+ size = 3;
+ }
+ else if (codepoint <= 0x10ffff)
+ {
+ utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0);
+ utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80);
+ utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80);
+ utf8[3] = (char)((codepoint & 0x3f) | 0x80);
+ size = 4;
+ }
+
+ *byteSize = size;
+
+ return utf8;
+}
+
+// Get next codepoint in a UTF-8 encoded text, scanning until '\0' is found
+// When a invalid UTF-8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned
+// Total number of bytes processed are returned as a parameter
+// NOTE: the standard says U+FFFD should be returned in case of errors
+// but that character is not supported by the default font in raylib
+static int GetCodepoint(const char *text, int *bytesProcessed)
+{
+/*
+ UTF-8 specs from https://www.ietf.org/rfc/rfc3629.txt
+
+ Char. number range | UTF-8 octet sequence
+ (hexadecimal) | (binary)
+ --------------------+---------------------------------------------
+ 0000 0000-0000 007F | 0xxxxxxx
+ 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+ 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+ 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+*/
+ // NOTE: on decode errors we return as soon as possible
+
+ int code = 0x3f; // Codepoint (defaults to '?')
+ int octet = (unsigned char)(text[0]); // The first UTF8 octet
+ *bytesProcessed = 1;
+
+ if (octet <= 0x7f)
+ {
+ // Only one octet (ASCII range x00-7F)
+ code = text[0];
+ }
+ else if ((octet & 0xe0) == 0xc0)
+ {
+ // Two octets
+
+ // [0]xC2-DF [1]UTF8-tail(x80-BF)
+ unsigned char octet1 = text[1];
+
+ if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
+
+ if ((octet >= 0xc2) && (octet <= 0xdf))
+ {
+ code = ((octet & 0x1f) << 6) | (octet1 & 0x3f);
+ *bytesProcessed = 2;
+ }
+ }
+ else if ((octet & 0xf0) == 0xe0)
+ {
+ // Three octets
+ unsigned char octet1 = text[1];
+ unsigned char octet2 = '\0';
+
+ if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
+
+ octet2 = text[2];
+
+ if ((octet2 == '\0') || ((octet2 >> 6) != 2)) { *bytesProcessed = 3; return code; } // Unexpected sequence
+
+ // [0]xE0 [1]xA0-BF [2]UTF8-tail(x80-BF)
+ // [0]xE1-EC [1]UTF8-tail [2]UTF8-tail(x80-BF)
+ // [0]xED [1]x80-9F [2]UTF8-tail(x80-BF)
+ // [0]xEE-EF [1]UTF8-tail [2]UTF8-tail(x80-BF)
+
+ if (((octet == 0xe0) && !((octet1 >= 0xa0) && (octet1 <= 0xbf))) ||
+ ((octet == 0xed) && !((octet1 >= 0x80) && (octet1 <= 0x9f)))) { *bytesProcessed = 2; return code; }
+
+ if ((octet >= 0xe0) && (0 <= 0xef))
+ {
+ code = ((octet & 0xf) << 12) | ((octet1 & 0x3f) << 6) | (octet2 & 0x3f);
+ *bytesProcessed = 3;
+ }
+ }
+ else if ((octet & 0xf8) == 0xf0)
+ {
+ // Four octets
+ if (octet > 0xf4) return code;
+
+ unsigned char octet1 = text[1];
+ unsigned char octet2 = '\0';
+ unsigned char octet3 = '\0';
+
+ if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
+
+ octet2 = text[2];
+
+ if ((octet2 == '\0') || ((octet2 >> 6) != 2)) { *bytesProcessed = 3; return code; } // Unexpected sequence
+
+ octet3 = text[3];
+
+ if ((octet3 == '\0') || ((octet3 >> 6) != 2)) { *bytesProcessed = 4; return code; } // Unexpected sequence
+
+ // [0]xF0 [1]x90-BF [2]UTF8-tail [3]UTF8-tail
+ // [0]xF1-F3 [1]UTF8-tail [2]UTF8-tail [3]UTF8-tail
+ // [0]xF4 [1]x80-8F [2]UTF8-tail [3]UTF8-tail
+
+ if (((octet == 0xf0) && !((octet1 >= 0x90) && (octet1 <= 0xbf))) ||
+ ((octet == 0xf4) && !((octet1 >= 0x80) && (octet1 <= 0x8f)))) { *bytesProcessed = 2; return code; } // Unexpected sequence
+
+ if (octet >= 0xf0)
+ {
+ code = ((octet & 0x7) << 18) | ((octet1 & 0x3f) << 12) | ((octet2 & 0x3f) << 6) | (octet3 & 0x3f);
+ *bytesProcessed = 4;
+ }
+ }
+
+ if (code > 0x10ffff) code = 0x3f; // Codepoints after U+10ffff are invalid
+
+ return code;
+}
+#endif // RAYGUI_STANDALONE
+
+#endif // RAYGUI_IMPLEMENTATION
diff --git a/include/raylib.h b/include/raylib.h
new file mode 100644
index 0000000..b6f77d8
--- /dev/null
+++ b/include/raylib.h
@@ -0,0 +1,1555 @@
+/**********************************************************************************************
+*
+* raylib v4.1-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+*
+* FEATURES:
+* - NO external dependencies, all required libraries included with raylib
+* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly,
+* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5.
+* - Written in plain C code (C99) in PascalCase/camelCase notation
+* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile)
+* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
+* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts)
+* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
+* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
+* - Flexible Materials system, supporting classic maps and PBR maps
+* - Animated 3D models supported (skeletal bones animation) (IQM)
+* - Shaders support, including Model shaders and Postprocessing shaders
+* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
+* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
+* - VR stereo rendering with configurable HMD device parameters
+* - Bindings to multiple programming languages available!
+*
+* NOTES:
+* - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text]
+* - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2)
+* - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2)
+* - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2)
+*
+* DEPENDENCIES (included):
+* [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP)
+* [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP)
+* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management
+*
+* OPTIONAL DEPENDENCIES (included):
+* [rcore] msf_gif (Miles Fogle) for GIF recording
+* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
+* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
+* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
+* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
+* [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms
+* [rtext] stb_truetype (Sean Barret) for ttf fonts loading
+* [rtext] stb_rect_pack (Sean Barret) for rectangles packing
+* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation
+* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
+* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF)
+* [raudio] dr_wav (David Reid) for WAV audio file loading
+* [raudio] dr_flac (David Reid) for FLAC audio file loading
+* [raudio] dr_mp3 (David Reid) for MP3 audio file loading
+* [raudio] stb_vorbis (Sean Barret) for OGG audio loading
+* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
+* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
+*
+*
+* LICENSE: zlib/libpng
+*
+* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+* BSD-like license that allows static linking with closed source software:
+*
+* Copyright (c) 2013-2022 Ramon Santamaria (@raysan5)
+*
+* This software is provided "as-is", without any express or implied warranty. In no event
+* will the authors be held liable for any damages arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose, including commercial
+* applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not claim that you
+* wrote the original software. If you use this software in a product, an acknowledgment
+* in the product documentation would be appreciated but is not required.
+*
+* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
+* as being the original software.
+*
+* 3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+#ifndef RAYLIB_H
+#define RAYLIB_H
+
+#include <stdarg.h> // Required for: va_list - Only used by TraceLogCallback
+
+#define RAYLIB_VERSION "4.1-dev"
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+#if defined(_WIN32)
+ #if defined(BUILD_LIBTYPE_SHARED)
+ #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll)
+ #elif defined(USE_LIBTYPE_SHARED)
+ #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll)
+ #endif
+#endif
+
+#ifndef RLAPI
+ #define RLAPI // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+//----------------------------------------------------------------------------------
+// Some basic Defines
+//----------------------------------------------------------------------------------
+#ifndef PI
+ #define PI 3.14159265358979323846f
+#endif
+#ifndef DEG2RAD
+ #define DEG2RAD (PI/180.0f)
+#endif
+#ifndef RAD2DEG
+ #define RAD2DEG (180.0f/PI)
+#endif
+
+// Allow custom memory allocators
+#ifndef RL_MALLOC
+ #define RL_MALLOC(sz) malloc(sz)
+#endif
+#ifndef RL_CALLOC
+ #define RL_CALLOC(n,sz) calloc(n,sz)
+#endif
+#ifndef RL_REALLOC
+ #define RL_REALLOC(ptr,sz) realloc(ptr,sz)
+#endif
+#ifndef RL_FREE
+ #define RL_FREE(ptr) free(ptr)
+#endif
+
+// NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
+// Plain structures in C++ (without constructors) can be initialized with { }
+#if defined(__cplusplus)
+ #define CLITERAL(type) type
+#else
+ #define CLITERAL(type) (type)
+#endif
+
+// NOTE: We set some defines with some data types declared by raylib
+// Other modules (raymath, rlgl) also require some of those types, so,
+// to be able to use those other modules as standalone (not depending on raylib)
+// this defines are very useful for internal check and avoid type (re)definitions
+#define RL_COLOR_TYPE
+#define RL_RECTANGLE_TYPE
+#define RL_VECTOR2_TYPE
+#define RL_VECTOR3_TYPE
+#define RL_VECTOR4_TYPE
+#define RL_QUATERNION_TYPE
+#define RL_MATRIX_TYPE
+
+// Some Basic Colors
+// NOTE: Custom raylib color palette for amazing visuals on WHITE background
+#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray
+#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray
+#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray
+#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow
+#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold
+#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange
+#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink
+#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red
+#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon
+#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green
+#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime
+#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green
+#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue
+#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue
+#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue
+#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple
+#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet
+#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple
+#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige
+#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown
+#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown
+
+#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White
+#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black
+#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent)
+#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta
+#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo)
+
+//----------------------------------------------------------------------------------
+// Structures Definition
+//----------------------------------------------------------------------------------
+// Boolean type
+#if defined(__STDC__) && __STDC_VERSION__ >= 199901L
+ #include <stdbool.h>
+#elif !defined(__cplusplus) && !defined(bool)
+ typedef enum bool { false, true } bool;
+ #define RL_BOOL_TYPE
+#endif
+
+// Vector2, 2 components
+typedef struct Vector2 {
+ float x; // Vector x component
+ float y; // Vector y component
+} Vector2;
+
+// Vector3, 3 components
+typedef struct Vector3 {
+ float x; // Vector x component
+ float y; // Vector y component
+ float z; // Vector z component
+} Vector3;
+
+// Vector4, 4 components
+typedef struct Vector4 {
+ float x; // Vector x component
+ float y; // Vector y component
+ float z; // Vector z component
+ float w; // Vector w component
+} Vector4;
+
+// Quaternion, 4 components (Vector4 alias)
+typedef Vector4 Quaternion;
+
+// Matrix, 4x4 components, column major, OpenGL style, right handed
+typedef struct Matrix {
+ float m0, m4, m8, m12; // Matrix first row (4 components)
+ float m1, m5, m9, m13; // Matrix second row (4 components)
+ float m2, m6, m10, m14; // Matrix third row (4 components)
+ float m3, m7, m11, m15; // Matrix fourth row (4 components)
+} Matrix;
+
+// Color, 4 components, R8G8B8A8 (32bit)
+typedef struct Color {
+ unsigned char r; // Color red value
+ unsigned char g; // Color green value
+ unsigned char b; // Color blue value
+ unsigned char a; // Color alpha value
+} Color;
+
+// Rectangle, 4 components
+typedef struct Rectangle {
+ float x; // Rectangle top-left corner position x
+ float y; // Rectangle top-left corner position y
+ float width; // Rectangle width
+ float height; // Rectangle height
+} Rectangle;
+
+// Image, pixel data stored in CPU memory (RAM)
+typedef struct Image {
+ void *data; // Image raw data
+ int width; // Image base width
+ int height; // Image base height
+ int mipmaps; // Mipmap levels, 1 by default
+ int format; // Data format (PixelFormat type)
+} Image;
+
+// Texture, tex data stored in GPU memory (VRAM)
+typedef struct Texture {
+ unsigned int id; // OpenGL texture id
+ int width; // Texture base width
+ int height; // Texture base height
+ int mipmaps; // Mipmap levels, 1 by default
+ int format; // Data format (PixelFormat type)
+} Texture;
+
+// Texture2D, same as Texture
+typedef Texture Texture2D;
+
+// TextureCubemap, same as Texture
+typedef Texture TextureCubemap;
+
+// RenderTexture, fbo for texture rendering
+typedef struct RenderTexture {
+ unsigned int id; // OpenGL framebuffer object id
+ Texture texture; // Color buffer attachment texture
+ Texture depth; // Depth buffer attachment texture
+} RenderTexture;
+
+// RenderTexture2D, same as RenderTexture
+typedef RenderTexture RenderTexture2D;
+
+// NPatchInfo, n-patch layout info
+typedef struct NPatchInfo {
+ Rectangle source; // Texture source rectangle
+ int left; // Left border offset
+ int top; // Top border offset
+ int right; // Right border offset
+ int bottom; // Bottom border offset
+ int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1
+} NPatchInfo;
+
+// GlyphInfo, font characters glyphs info
+typedef struct GlyphInfo {
+ int value; // Character value (Unicode)
+ int offsetX; // Character offset X when drawing
+ int offsetY; // Character offset Y when drawing
+ int advanceX; // Character advance position X
+ Image image; // Character image data
+} GlyphInfo;
+
+// Font, font texture and GlyphInfo array data
+typedef struct Font {
+ int baseSize; // Base size (default chars height)
+ int glyphCount; // Number of glyph characters
+ int glyphPadding; // Padding around the glyph characters
+ Texture2D texture; // Texture atlas containing the glyphs
+ Rectangle *recs; // Rectangles in texture for the glyphs
+ GlyphInfo *glyphs; // Glyphs info data
+} Font;
+
+// Camera, defines position/orientation in 3d space
+typedef struct Camera3D {
+ Vector3 position; // Camera position
+ Vector3 target; // Camera target it looks-at
+ Vector3 up; // Camera up vector (rotation over its axis)
+ float fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
+ int projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+} Camera3D;
+
+typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D
+
+// Camera2D, defines position/orientation in 2d space
+typedef struct Camera2D {
+ Vector2 offset; // Camera offset (displacement from target)
+ Vector2 target; // Camera target (rotation and zoom origin)
+ float rotation; // Camera rotation in degrees
+ float zoom; // Camera zoom (scaling), should be 1.0f by default
+} Camera2D;
+
+// Mesh, vertex data and vao/vbo
+typedef struct Mesh {
+ int vertexCount; // Number of vertices stored in arrays
+ int triangleCount; // Number of triangles stored (indexed or not)
+
+ // Vertex attributes data
+ float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+ float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+ float *texcoords2; // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
+ float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+ float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
+ unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+ unsigned short *indices; // Vertex indices (in case vertex data comes indexed)
+
+ // Animation vertex data
+ float *animVertices; // Animated vertex positions (after bones transformations)
+ float *animNormals; // Animated normals (after bones transformations)
+ unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
+ float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning)
+
+ // OpenGL identifiers
+ unsigned int vaoId; // OpenGL Vertex Array Object id
+ unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data)
+} Mesh;
+
+// Shader
+typedef struct Shader {
+ unsigned int id; // Shader program id
+ int *locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS)
+} Shader;
+
+// MaterialMap
+typedef struct MaterialMap {
+ Texture2D texture; // Material map texture
+ Color color; // Material map color
+ float value; // Material map value
+} MaterialMap;
+
+// Material, includes shader and maps
+typedef struct Material {
+ Shader shader; // Material shader
+ MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS)
+ float params[4]; // Material generic parameters (if required)
+} Material;
+
+// Transform, vectex transformation data
+typedef struct Transform {
+ Vector3 translation; // Translation
+ Quaternion rotation; // Rotation
+ Vector3 scale; // Scale
+} Transform;
+
+// Bone, skeletal animation bone
+typedef struct BoneInfo {
+ char name[32]; // Bone name
+ int parent; // Bone parent
+} BoneInfo;
+
+// Model, meshes, materials and animation data
+typedef struct Model {
+ Matrix transform; // Local transform matrix
+
+ int meshCount; // Number of meshes
+ int materialCount; // Number of materials
+ Mesh *meshes; // Meshes array
+ Material *materials; // Materials array
+ int *meshMaterial; // Mesh material number
+
+ // Animation data
+ int boneCount; // Number of bones
+ BoneInfo *bones; // Bones information (skeleton)
+ Transform *bindPose; // Bones base transformation (pose)
+} Model;
+
+// ModelAnimation
+typedef struct ModelAnimation {
+ int boneCount; // Number of bones
+ int frameCount; // Number of animation frames
+ BoneInfo *bones; // Bones information (skeleton)
+ Transform **framePoses; // Poses array by frame
+} ModelAnimation;
+
+// Ray, ray for raycasting
+typedef struct Ray {
+ Vector3 position; // Ray position (origin)
+ Vector3 direction; // Ray direction
+} Ray;
+
+// RayCollision, ray hit information
+typedef struct RayCollision {
+ bool hit; // Did the ray hit something?
+ float distance; // Distance to nearest hit
+ Vector3 point; // Point of nearest hit
+ Vector3 normal; // Surface normal of hit
+} RayCollision;
+
+// BoundingBox
+typedef struct BoundingBox {
+ Vector3 min; // Minimum vertex box-corner
+ Vector3 max; // Maximum vertex box-corner
+} BoundingBox;
+
+// Wave, audio wave data
+typedef struct Wave {
+ unsigned int frameCount; // Total number of frames (considering channels)
+ unsigned int sampleRate; // Frequency (samples per second)
+ unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+ unsigned int channels; // Number of channels (1-mono, 2-stereo, ...)
+ void *data; // Buffer data pointer
+} Wave;
+
+// Opaque structs declaration
+// NOTE: Actual structs are defined internally in raudio module
+typedef struct rAudioBuffer rAudioBuffer;
+typedef struct rAudioProcessor rAudioProcessor;
+
+// AudioStream, custom audio stream
+typedef struct AudioStream {
+ rAudioBuffer *buffer; // Pointer to internal data used by the audio system
+ rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects
+
+ unsigned int sampleRate; // Frequency (samples per second)
+ unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+ unsigned int channels; // Number of channels (1-mono, 2-stereo, ...)
+} AudioStream;
+
+// Sound
+typedef struct Sound {
+ AudioStream stream; // Audio stream
+ unsigned int frameCount; // Total number of frames (considering channels)
+} Sound;
+
+// Music, audio stream, anything longer than ~10 seconds should be streamed
+typedef struct Music {
+ AudioStream stream; // Audio stream
+ unsigned int frameCount; // Total number of frames (considering channels)
+ bool looping; // Music looping enable
+
+ int ctxType; // Type of music context (audio filetype)
+ void *ctxData; // Audio context data, depends on type
+} Music;
+
+// VrDeviceInfo, Head-Mounted-Display device parameters
+typedef struct VrDeviceInfo {
+ int hResolution; // Horizontal resolution in pixels
+ int vResolution; // Vertical resolution in pixels
+ float hScreenSize; // Horizontal size in meters
+ float vScreenSize; // Vertical size in meters
+ float vScreenCenter; // Screen center in meters
+ float eyeToScreenDistance; // Distance between eye and display in meters
+ float lensSeparationDistance; // Lens separation distance in meters
+ float interpupillaryDistance; // IPD (distance between pupils) in meters
+ float lensDistortionValues[4]; // Lens distortion constant parameters
+ float chromaAbCorrection[4]; // Chromatic aberration correction parameters
+} VrDeviceInfo;
+
+// VrStereoConfig, VR stereo rendering configuration for simulator
+typedef struct VrStereoConfig {
+ Matrix projection[2]; // VR projection matrices (per eye)
+ Matrix viewOffset[2]; // VR view offset matrices (per eye)
+ float leftLensCenter[2]; // VR left lens center
+ float rightLensCenter[2]; // VR right lens center
+ float leftScreenCenter[2]; // VR left screen center
+ float rightScreenCenter[2]; // VR right screen center
+ float scale[2]; // VR distortion scale
+ float scaleIn[2]; // VR distortion scale in
+} VrStereoConfig;
+
+//----------------------------------------------------------------------------------
+// Enumerators Definition
+//----------------------------------------------------------------------------------
+// System/Window config flags
+// NOTE: Every bit registers one state (use it with bit masks)
+// By default all flags are set to 0
+typedef enum {
+ FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU
+ FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen
+ FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window
+ FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons)
+ FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window
+ FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify)
+ FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor)
+ FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused
+ FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top
+ FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized
+ FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer
+ FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI
+ FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X
+ FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D)
+} ConfigFlags;
+
+// Trace log level
+// NOTE: Organized by priority level
+typedef enum {
+ LOG_ALL = 0, // Display all logs
+ LOG_TRACE, // Trace logging, intended for internal use only
+ LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds
+ LOG_INFO, // Info logging, used for program execution info
+ LOG_WARNING, // Warning logging, used on recoverable failures
+ LOG_ERROR, // Error logging, used on unrecoverable failures
+ LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
+ LOG_NONE // Disable logging
+} TraceLogLevel;
+
+// Keyboard keys (US keyboard layout)
+// NOTE: Use GetKeyPressed() to allow redefining
+// required keys for alternative layouts
+typedef enum {
+ KEY_NULL = 0, // Key: NULL, used for no key pressed
+ // Alphanumeric keys
+ KEY_APOSTROPHE = 39, // Key: '
+ KEY_COMMA = 44, // Key: ,
+ KEY_MINUS = 45, // Key: -
+ KEY_PERIOD = 46, // Key: .
+ KEY_SLASH = 47, // Key: /
+ KEY_ZERO = 48, // Key: 0
+ KEY_ONE = 49, // Key: 1
+ KEY_TWO = 50, // Key: 2
+ KEY_THREE = 51, // Key: 3
+ KEY_FOUR = 52, // Key: 4
+ KEY_FIVE = 53, // Key: 5
+ KEY_SIX = 54, // Key: 6
+ KEY_SEVEN = 55, // Key: 7
+ KEY_EIGHT = 56, // Key: 8
+ KEY_NINE = 57, // Key: 9
+ KEY_SEMICOLON = 59, // Key: ;
+ KEY_EQUAL = 61, // Key: =
+ KEY_A = 65, // Key: A | a
+ KEY_B = 66, // Key: B | b
+ KEY_C = 67, // Key: C | c
+ KEY_D = 68, // Key: D | d
+ KEY_E = 69, // Key: E | e
+ KEY_F = 70, // Key: F | f
+ KEY_G = 71, // Key: G | g
+ KEY_H = 72, // Key: H | h
+ KEY_I = 73, // Key: I | i
+ KEY_J = 74, // Key: J | j
+ KEY_K = 75, // Key: K | k
+ KEY_L = 76, // Key: L | l
+ KEY_M = 77, // Key: M | m
+ KEY_N = 78, // Key: N | n
+ KEY_O = 79, // Key: O | o
+ KEY_P = 80, // Key: P | p
+ KEY_Q = 81, // Key: Q | q
+ KEY_R = 82, // Key: R | r
+ KEY_S = 83, // Key: S | s
+ KEY_T = 84, // Key: T | t
+ KEY_U = 85, // Key: U | u
+ KEY_V = 86, // Key: V | v
+ KEY_W = 87, // Key: W | w
+ KEY_X = 88, // Key: X | x
+ KEY_Y = 89, // Key: Y | y
+ KEY_Z = 90, // Key: Z | z
+ KEY_LEFT_BRACKET = 91, // Key: [
+ KEY_BACKSLASH = 92, // Key: '\'
+ KEY_RIGHT_BRACKET = 93, // Key: ]
+ KEY_GRAVE = 96, // Key: `
+ // Function keys
+ KEY_SPACE = 32, // Key: Space
+ KEY_ESCAPE = 256, // Key: Esc
+ KEY_ENTER = 257, // Key: Enter
+ KEY_TAB = 258, // Key: Tab
+ KEY_BACKSPACE = 259, // Key: Backspace
+ KEY_INSERT = 260, // Key: Ins
+ KEY_DELETE = 261, // Key: Del
+ KEY_RIGHT = 262, // Key: Cursor right
+ KEY_LEFT = 263, // Key: Cursor left
+ KEY_DOWN = 264, // Key: Cursor down
+ KEY_UP = 265, // Key: Cursor up
+ KEY_PAGE_UP = 266, // Key: Page up
+ KEY_PAGE_DOWN = 267, // Key: Page down
+ KEY_HOME = 268, // Key: Home
+ KEY_END = 269, // Key: End
+ KEY_CAPS_LOCK = 280, // Key: Caps lock
+ KEY_SCROLL_LOCK = 281, // Key: Scroll down
+ KEY_NUM_LOCK = 282, // Key: Num lock
+ KEY_PRINT_SCREEN = 283, // Key: Print screen
+ KEY_PAUSE = 284, // Key: Pause
+ KEY_F1 = 290, // Key: F1
+ KEY_F2 = 291, // Key: F2
+ KEY_F3 = 292, // Key: F3
+ KEY_F4 = 293, // Key: F4
+ KEY_F5 = 294, // Key: F5
+ KEY_F6 = 295, // Key: F6
+ KEY_F7 = 296, // Key: F7
+ KEY_F8 = 297, // Key: F8
+ KEY_F9 = 298, // Key: F9
+ KEY_F10 = 299, // Key: F10
+ KEY_F11 = 300, // Key: F11
+ KEY_F12 = 301, // Key: F12
+ KEY_LEFT_SHIFT = 340, // Key: Shift left
+ KEY_LEFT_CONTROL = 341, // Key: Control left
+ KEY_LEFT_ALT = 342, // Key: Alt left
+ KEY_LEFT_SUPER = 343, // Key: Super left
+ KEY_RIGHT_SHIFT = 344, // Key: Shift right
+ KEY_RIGHT_CONTROL = 345, // Key: Control right
+ KEY_RIGHT_ALT = 346, // Key: Alt right
+ KEY_RIGHT_SUPER = 347, // Key: Super right
+ KEY_KB_MENU = 348, // Key: KB menu
+ // Keypad keys
+ KEY_KP_0 = 320, // Key: Keypad 0
+ KEY_KP_1 = 321, // Key: Keypad 1
+ KEY_KP_2 = 322, // Key: Keypad 2
+ KEY_KP_3 = 323, // Key: Keypad 3
+ KEY_KP_4 = 324, // Key: Keypad 4
+ KEY_KP_5 = 325, // Key: Keypad 5
+ KEY_KP_6 = 326, // Key: Keypad 6
+ KEY_KP_7 = 327, // Key: Keypad 7
+ KEY_KP_8 = 328, // Key: Keypad 8
+ KEY_KP_9 = 329, // Key: Keypad 9
+ KEY_KP_DECIMAL = 330, // Key: Keypad .
+ KEY_KP_DIVIDE = 331, // Key: Keypad /
+ KEY_KP_MULTIPLY = 332, // Key: Keypad *
+ KEY_KP_SUBTRACT = 333, // Key: Keypad -
+ KEY_KP_ADD = 334, // Key: Keypad +
+ KEY_KP_ENTER = 335, // Key: Keypad Enter
+ KEY_KP_EQUAL = 336, // Key: Keypad =
+ // Android key buttons
+ KEY_BACK = 4, // Key: Android back button
+ KEY_MENU = 82, // Key: Android menu button
+ KEY_VOLUME_UP = 24, // Key: Android volume up button
+ KEY_VOLUME_DOWN = 25 // Key: Android volume down button
+} KeyboardKey;
+
+// Add backwards compatibility support for deprecated names
+#define MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT
+#define MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT
+#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE
+
+// Mouse buttons
+typedef enum {
+ MOUSE_BUTTON_LEFT = 0, // Mouse button left
+ MOUSE_BUTTON_RIGHT = 1, // Mouse button right
+ MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel)
+ MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device)
+ MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device)
+ MOUSE_BUTTON_FORWARD = 5, // Mouse button fordward (advanced mouse device)
+ MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device)
+} MouseButton;
+
+// Mouse cursor
+typedef enum {
+ MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape
+ MOUSE_CURSOR_ARROW = 1, // Arrow shape
+ MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape
+ MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape
+ MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor
+ MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape
+ MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape
+ MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape
+ MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape
+ MOUSE_CURSOR_RESIZE_ALL = 9, // The omni-directional resize/move cursor shape
+ MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape
+} MouseCursor;
+
+// Gamepad buttons
+typedef enum {
+ GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking
+ GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button
+ GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button
+ GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button
+ GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button
+ GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
+ GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X)
+ GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A)
+ GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B)
+ GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button
+ GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button
+ GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button
+ GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button
+ GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select)
+ GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
+ GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start)
+ GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left
+ GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right
+} GamepadButton;
+
+// Gamepad axis
+typedef enum {
+ GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis
+ GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis
+ GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis
+ GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis
+ GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1]
+ GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1]
+} GamepadAxis;
+
+// Material map index
+typedef enum {
+ MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE)
+ MATERIAL_MAP_METALNESS, // Metalness material (same as: MATERIAL_MAP_SPECULAR)
+ MATERIAL_MAP_NORMAL, // Normal material
+ MATERIAL_MAP_ROUGHNESS, // Roughness material
+ MATERIAL_MAP_OCCLUSION, // Ambient occlusion material
+ MATERIAL_MAP_EMISSION, // Emission material
+ MATERIAL_MAP_HEIGHT, // Heightmap material
+ MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+ MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+ MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+ MATERIAL_MAP_BRDF // Brdf material
+} MaterialMapIndex;
+
+#define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO
+#define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS
+
+// Shader location index
+typedef enum {
+ SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
+ SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01
+ SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02
+ SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal
+ SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent
+ SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color
+ SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection
+ SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform)
+ SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection
+ SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform)
+ SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal
+ SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view
+ SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color
+ SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color
+ SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color
+ SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)
+ SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)
+ SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal
+ SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness
+ SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion
+ SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission
+ SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height
+ SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap
+ SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance
+ SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter
+ SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf
+} ShaderLocationIndex;
+
+#define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO
+#define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS
+
+// Shader uniform data type
+typedef enum {
+ SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
+ SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float)
+ SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float)
+ SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float)
+ SHADER_UNIFORM_INT, // Shader uniform type: int
+ SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int)
+ SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int)
+ SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int)
+ SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d
+} ShaderUniformDataType;
+
+// Shader attribute data types
+typedef enum {
+ SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
+ SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float)
+ SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float)
+ SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float)
+} ShaderAttributeDataType;
+
+// Pixel formats
+// NOTE: Support depends on OpenGL version and platform
+typedef enum {
+ PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+ PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
+ PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
+ PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
+ PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
+ PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
+ PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
+ PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
+} PixelFormat;
+
+// Texture parameters: filter mode
+// NOTE 1: Filtering considers mipmaps if available in the texture
+// NOTE 2: Filter is accordingly set for minification and magnification
+typedef enum {
+ TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation
+ TEXTURE_FILTER_BILINEAR, // Linear filtering
+ TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps)
+ TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x
+ TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x
+ TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x
+} TextureFilter;
+
+// Texture parameters: wrap mode
+typedef enum {
+ TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode
+ TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode
+ TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode
+ TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode
+} TextureWrap;
+
+// Cubemap layouts
+typedef enum {
+ CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type
+ CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces
+ CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by an horizontal line with faces
+ CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces
+ CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces
+ CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirectangular map)
+} CubemapLayout;
+
+// Font type, defines generation method
+typedef enum {
+ FONT_DEFAULT = 0, // Default font generation, anti-aliased
+ FONT_BITMAP, // Bitmap font generation, no anti-aliasing
+ FONT_SDF // SDF font generation, requires external shader
+} FontType;
+
+// Color blending modes (pre-defined)
+typedef enum {
+ BLEND_ALPHA = 0, // Blend textures considering alpha (default)
+ BLEND_ADDITIVE, // Blend textures adding colors
+ BLEND_MULTIPLIED, // Blend textures multiplying colors
+ BLEND_ADD_COLORS, // Blend textures adding colors (alternative)
+ BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative)
+ BLEND_ALPHA_PREMUL, // Blend premultiplied textures considering alpha
+ BLEND_CUSTOM // Blend textures using custom src/dst factors (use rlSetBlendMode())
+} BlendMode;
+
+// Gesture
+// NOTE: It could be used as flags to enable only some gestures
+typedef enum {
+ GESTURE_NONE = 0, // No gesture
+ GESTURE_TAP = 1, // Tap gesture
+ GESTURE_DOUBLETAP = 2, // Double tap gesture
+ GESTURE_HOLD = 4, // Hold gesture
+ GESTURE_DRAG = 8, // Drag gesture
+ GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture
+ GESTURE_SWIPE_LEFT = 32, // Swipe left gesture
+ GESTURE_SWIPE_UP = 64, // Swipe up gesture
+ GESTURE_SWIPE_DOWN = 128, // Swipe down gesture
+ GESTURE_PINCH_IN = 256, // Pinch in gesture
+ GESTURE_PINCH_OUT = 512 // Pinch out gesture
+} Gesture;
+
+// Camera system modes
+typedef enum {
+ CAMERA_CUSTOM = 0, // Custom camera
+ CAMERA_FREE, // Free camera
+ CAMERA_ORBITAL, // Orbital camera
+ CAMERA_FIRST_PERSON, // First person camera
+ CAMERA_THIRD_PERSON // Third person camera
+} CameraMode;
+
+// Camera projection
+typedef enum {
+ CAMERA_PERSPECTIVE = 0, // Perspective projection
+ CAMERA_ORTHOGRAPHIC // Orthographic projection
+} CameraProjection;
+
+// N-patch layout
+typedef enum {
+ NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles
+ NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles
+ NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles
+} NPatchLayout;
+
+// Callbacks to hook some internal functions
+// WARNING: This callbacks are intended for advance users
+typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages
+typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, unsigned int *bytesRead); // FileIO: Load binary data
+typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, unsigned int bytesToWrite); // FileIO: Save binary data
+typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data
+typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data
+
+//------------------------------------------------------------------------------------
+// Global Variables Definition
+//------------------------------------------------------------------------------------
+// It's lonely here...
+
+//------------------------------------------------------------------------------------
+// Window and Graphics Device Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+extern "C" { // Prevents name mangling of functions
+#endif
+
+// Window-related functions
+RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context
+RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed
+RLAPI void CloseWindow(void); // Close window and unload OpenGL context
+RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully
+RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen
+RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowResized(void); // Check if window has been resized last frame
+RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled
+RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP)
+RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags
+RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
+RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
+RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP)
+RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode)
+RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+RLAPI void SetWindowSize(int width, int height); // Set window dimensions
+RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
+RLAPI void *GetWindowHandle(void); // Get native window handle
+RLAPI int GetScreenWidth(void); // Get current screen width
+RLAPI int GetScreenHeight(void); // Get current screen height
+RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI)
+RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI)
+RLAPI int GetMonitorCount(void); // Get number of connected monitors
+RLAPI int GetCurrentMonitor(void); // Get current connected monitor
+RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position
+RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (max available by monitor)
+RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (max available by monitor)
+RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres
+RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres
+RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate
+RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor
+RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor
+RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the primary monitor
+RLAPI void SetClipboardText(const char *text); // Set clipboard text content
+RLAPI const char *GetClipboardText(void); // Get clipboard text content
+
+// Custom frame control functions
+// NOTE: Those functions are intended for advance users that want full control over the frame processing
+// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents()
+// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
+RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing)
+RLAPI void PollInputEvents(void); // Register all input events
+RLAPI void WaitTime(float ms); // Wait for some milliseconds (halt program execution)
+
+// Cursor-related functions
+RLAPI void ShowCursor(void); // Shows cursor
+RLAPI void HideCursor(void); // Hides cursor
+RLAPI bool IsCursorHidden(void); // Check if cursor is not visible
+RLAPI void EnableCursor(void); // Enables cursor (unlock cursor)
+RLAPI void DisableCursor(void); // Disables cursor (lock cursor)
+RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the screen
+
+// Drawing-related functions
+RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color)
+RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing
+RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering)
+RLAPI void BeginMode2D(Camera2D camera); // Begin 2D mode with custom camera (2D)
+RLAPI void EndMode2D(void); // Ends 2D mode with custom camera
+RLAPI void BeginMode3D(Camera3D camera); // Begin 3D mode with custom camera (3D)
+RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode
+RLAPI void BeginTextureMode(RenderTexture2D target); // Begin drawing to render texture
+RLAPI void EndTextureMode(void); // Ends drawing to render texture
+RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing
+RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader)
+RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom)
+RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending)
+RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing)
+RLAPI void EndScissorMode(void); // End scissor mode
+RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator)
+RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator)
+
+// VR stereo config functions for VR simulator
+RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters
+RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config
+
+// Shader management functions
+// NOTE: Shader functionality is not available on OpenGL 1.1
+RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations
+RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
+RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location
+RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location
+RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value
+RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector
+RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4)
+RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d)
+RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM)
+
+// Screen-space-related functions
+RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from mouse position
+RLAPI Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix)
+RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix
+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position
+RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
+RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position
+RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position
+
+// Timing-related functions
+RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum)
+RLAPI int GetFPS(void); // Get current FPS
+RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time)
+RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow()
+
+// Misc. functions
+RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included)
+RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator
+RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format)
+RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS)
+
+RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
+RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level
+RLAPI void *MemAlloc(int size); // Internal memory allocator
+RLAPI void *MemRealloc(void *ptr, int size); // Internal memory reallocator
+RLAPI void MemFree(void *ptr); // Internal memory free
+
+// Set custom callbacks
+// WARNING: Callbacks setup is intended for advance users
+RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log
+RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader
+RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver
+RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader
+RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver
+
+// Files management functions
+RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read)
+RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData()
+RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write), returns true on success
+RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string
+RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText()
+RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success
+RLAPI bool FileExists(const char *fileName); // Check if file exists
+RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists
+RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav)
+RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
+RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png')
+RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string
+RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string)
+RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string)
+RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string)
+RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string)
+RLAPI const char *GetApplicationDirectory(void); // Get the directory if the running application (uses static string)
+RLAPI char **GetDirectoryFiles(const char *dirPath, int *count); // Get filenames in a directory path (memory should be freed)
+RLAPI void ClearDirectoryFiles(void); // Clear directory files paths buffers (free memory)
+RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success
+RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window
+RLAPI char **GetDroppedFiles(int *count); // Get dropped files names (memory should be freed)
+RLAPI void ClearDroppedFiles(void); // Clear dropped files paths buffer (free memory)
+RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time)
+
+// Compression/Encoding functionality
+RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm)
+RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm)
+RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string
+RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data
+
+// Persistent storage management
+RLAPI bool SaveStorageValue(unsigned int position, int value); // Save integer value to storage file (to defined position), returns true on success
+RLAPI int LoadStorageValue(unsigned int position); // Load integer value from storage file (from defined position)
+
+RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available)
+
+//------------------------------------------------------------------------------------
+// Input Handling Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+// Input-related functions: keyboard
+RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once
+RLAPI bool IsKeyDown(int key); // Check if a key is being pressed
+RLAPI bool IsKeyReleased(int key); // Check if a key has been released once
+RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed
+RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC)
+RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
+RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
+
+// Input-related functions: gamepads
+RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available
+RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id
+RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once
+RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed
+RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once
+RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed
+RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed
+RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad
+RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis
+RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB)
+
+// Input-related functions: mouse
+RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once
+RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed
+RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once
+RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed
+RLAPI int GetMouseX(void); // Get mouse position X
+RLAPI int GetMouseY(void); // Get mouse position Y
+RLAPI Vector2 GetMousePosition(void); // Get mouse position XY
+RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames
+RLAPI void SetMousePosition(int x, int y); // Set mouse position XY
+RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset
+RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling
+RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement Y
+RLAPI void SetMouseCursor(int cursor); // Set mouse cursor
+
+// Input-related functions: touch
+RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size)
+RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size)
+RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size)
+RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index
+RLAPI int GetTouchPointCount(void); // Get number of touch points
+
+//------------------------------------------------------------------------------------
+// Gestures and Touch Handling Functions (Module: rgestures)
+//------------------------------------------------------------------------------------
+RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags
+RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected
+RLAPI int GetGestureDetected(void); // Get latest detected gesture
+RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds
+RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector
+RLAPI float GetGestureDragAngle(void); // Get gesture drag angle
+RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta
+RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle
+
+//------------------------------------------------------------------------------------
+// Camera System Functions (Module: rcamera)
+//------------------------------------------------------------------------------------
+RLAPI void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available)
+RLAPI void UpdateCamera(Camera *camera); // Update camera position for selected mode
+
+RLAPI void SetCameraPanControl(int keyPan); // Set camera pan key to combine with mouse movement (free camera)
+RLAPI void SetCameraAltControl(int keyAlt); // Set camera alt key to combine with mouse movement (free camera)
+RLAPI void SetCameraSmoothZoomControl(int keySmoothZoom); // Set camera smooth zoom key to combine with mouse (free camera)
+RLAPI void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown); // Set camera move controls (1st person and 3rd person cameras)
+
+//------------------------------------------------------------------------------------
+// Basic Shapes Drawing Functions (Module: shapes)
+//------------------------------------------------------------------------------------
+// Set texture and rectangle to be used on shapes drawing
+// NOTE: It can be useful when using basic shapes and one single font,
+// defining a font char white rectangle would allow drawing everything in a single draw call
+RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing
+
+// Basic shapes drawing functions
+RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel
+RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version)
+RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line
+RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version)
+RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness
+RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out
+RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point
+RLAPI void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points
+RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence
+RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle
+RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle
+RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
+RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle
+RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version)
+RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline
+RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse
+RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline
+RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
+RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline
+RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle
+RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version)
+RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle
+RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters
+RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
+RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors
+RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline
+RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters
+RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges
+RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
+RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center)
+RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points
+RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version)
+RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides
+RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
+
+// Basic shapes collision detection functions
+RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles
+RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles
+RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle
+RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle
+RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle
+RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle
+RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference
+RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
+RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision
+
+//------------------------------------------------------------------------------------
+// Texture Loading and Drawing Functions (Module: textures)
+//------------------------------------------------------------------------------------
+
+// Image loading functions
+// NOTE: This functions do not require GPU access
+RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM)
+RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data
+RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data)
+RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png'
+RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data
+RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot)
+RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM)
+RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success
+RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success
+
+// Image generation functions
+RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color
+RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient
+RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient
+RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient
+RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked
+RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise
+RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells
+
+// Image manipulation functions
+RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations)
+RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece
+RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font)
+RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font)
+RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format
+RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two)
+RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle
+RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value
+RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color
+RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image
+RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel
+RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm)
+RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm)
+RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color
+RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image
+RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
+RLAPI void ImageFlipVertical(Image *image); // Flip image vertically
+RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally
+RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg
+RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg
+RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint
+RLAPI void ImageColorInvert(Image *image); // Modify image color: invert
+RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale
+RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100)
+RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255)
+RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color
+RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit)
+RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit)
+RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors()
+RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette()
+RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle
+RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position
+
+// Image drawing functions
+// NOTE: Image software-rendering functions (CPU)
+RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color
+RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image
+RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version)
+RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
+RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version)
+RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle within an image
+RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw circle within an image (Vector version)
+RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image
+RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version)
+RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image
+RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image
+RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source)
+RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination)
+RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination)
+
+// Texture loading functions
+// NOTE: These functions require GPU access
+RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM)
+RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data
+RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported
+RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer)
+RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM)
+RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM)
+RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data
+RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data
+
+// Texture configuration functions
+RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture
+RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode
+RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode
+
+// Texture drawing functions
+RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D
+RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2
+RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters
+RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle
+RLAPI void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint); // Draw texture quad with tiling and offset parameters
+RLAPI void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint); // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
+RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
+RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely
+RLAPI void DrawTexturePoly(Texture2D texture, Vector2 center, Vector2 *points, Vector2 *texcoords, int pointCount, Color tint); // Draw a textured polygon
+
+// Color/pixel related functions
+RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f
+RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color
+RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1]
+RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1]
+RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1]
+RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1]
+RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f
+RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint
+RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value
+RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format
+RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer
+RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format
+
+//------------------------------------------------------------------------------------
+// Font Loading and Text Drawing Functions (Module: text)
+//------------------------------------------------------------------------------------
+
+// Font loading/unloading functions
+RLAPI Font GetFontDefault(void); // Get the default Font
+RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM)
+RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set
+RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style)
+RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
+RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use
+RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
+RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount); // Unload font chars info data (RAM)
+RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM)
+RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success
+
+// Text drawing functions
+RLAPI void DrawFPS(int posX, int posY); // Draw current FPS
+RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font)
+RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
+RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
+RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
+RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
+
+// Text font info functions
+RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font
+RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font
+RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
+RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
+RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
+
+// Text codepoints management functions (unicode characters)
+RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
+RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory
+RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string
+RLAPI int GetCodepoint(const char *text, int *bytesProcessed); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
+RLAPI const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
+RLAPI char *TextCodepointsToUTF8(const int *codepoints, int length); // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)
+
+// Text strings management functions (no UTF-8 strings, only byte chars)
+// NOTE: Some strings allocate memory internally for returned strings, just be careful!
+RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied
+RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal
+RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending
+RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style)
+RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string
+RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!)
+RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!)
+RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter
+RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings
+RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor!
+RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string
+RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string
+RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string
+RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string
+RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported)
+
+//------------------------------------------------------------------------------------
+// Basic 3d Shapes Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Basic geometric 3D shapes drawing functions
+RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space
+RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line
+RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
+RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points
+RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube
+RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version)
+RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires
+RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version)
+RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
+RLAPI void DrawCubeTextureRec(Texture2D texture, Rectangle source, Vector3 position, float width, float height, float length, Color color); // Draw cube with a region of a texture
+RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere
+RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters
+RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires
+RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
+RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
+RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
+RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
+RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ
+RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line
+RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0))
+
+//------------------------------------------------------------------------------------
+// Model 3d Loading and Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Model management functions
+RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials)
+RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material)
+RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM)
+RLAPI void UnloadModelKeepMeshes(Model model); // Unload model (but not meshes) from memory (RAM and/or VRAM)
+RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes)
+
+// Model drawing functions
+RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set)
+RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
+RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set)
+RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
+RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires)
+RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture
+RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
+RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation
+
+// Mesh management functions
+RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids
+RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
+RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU
+RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform
+RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms
+RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success
+RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits
+RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents
+RLAPI void GenMeshBinormals(Mesh *mesh); // Compute mesh binormals
+
+// Mesh generation functions
+RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh
+RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions)
+RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh
+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere)
+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap)
+RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh
+RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh
+RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh
+RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh
+RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data
+RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data
+
+// Material loading/unloading functions
+RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file
+RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
+RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM)
+RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
+RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh
+
+// Model animations loading/unloading functions
+RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, unsigned int *animCount); // Load model animations from file
+RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose
+RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data
+RLAPI void UnloadModelAnimations(ModelAnimation *animations, unsigned int count); // Unload animation array data
+RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match
+
+// Collision detection functions
+RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres
+RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes
+RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere
+RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere
+RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box
+RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh
+RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle
+RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad
+
+//------------------------------------------------------------------------------------
+// Audio Loading and Playing Functions (Module: audio)
+//------------------------------------------------------------------------------------
+typedef void (*AudioCallback)(void *bufferData, unsigned int frames);
+
+// Audio device management functions
+RLAPI void InitAudioDevice(void); // Initialize audio device and context
+RLAPI void CloseAudioDevice(void); // Close the audio device and context
+RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully
+RLAPI void SetMasterVolume(float volume); // Set master volume (listener)
+
+// Wave/Sound loading/unloading functions
+RLAPI Wave LoadWave(const char *fileName); // Load wave data from file
+RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
+RLAPI Sound LoadSound(const char *fileName); // Load sound from file
+RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data
+RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
+RLAPI void UnloadWave(Wave wave); // Unload wave data
+RLAPI void UnloadSound(Sound sound); // Unload sound
+RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success
+RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success
+
+// Wave/Sound management functions
+RLAPI void PlaySound(Sound sound); // Play a sound
+RLAPI void StopSound(Sound sound); // Stop playing a sound
+RLAPI void PauseSound(Sound sound); // Pause a sound
+RLAPI void ResumeSound(Sound sound); // Resume a paused sound
+RLAPI void PlaySoundMulti(Sound sound); // Play a sound (using multichannel buffer pool)
+RLAPI void StopSoundMulti(void); // Stop any sound playing (using multichannel buffer pool)
+RLAPI int GetSoundsPlaying(void); // Get number of sounds playing in the multichannel
+RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing
+RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
+RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
+RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center)
+RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave
+RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range
+RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
+RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array
+RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples()
+
+// Music management functions
+RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file
+RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
+RLAPI void UnloadMusicStream(Music music); // Unload music stream
+RLAPI void PlayMusicStream(Music music); // Start music playing
+RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing
+RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming
+RLAPI void StopMusicStream(Music music); // Stop music playing
+RLAPI void PauseMusicStream(Music music); // Pause music playing
+RLAPI void ResumeMusicStream(Music music); // Resume playing paused music
+RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds)
+RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level)
+RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level)
+RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center)
+RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds)
+RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds)
+
+// AudioStream management functions
+RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
+RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory
+RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
+RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill
+RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream
+RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream
+RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream
+RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing
+RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream
+RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level)
+RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level)
+RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered)
+RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams
+RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
+
+RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor);
+RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // RAYLIB_H
diff --git a/roms/IBM Logo.ch8 b/roms/IBM Logo.ch8
new file mode 100644
index 0000000..113338e
--- /dev/null
+++ b/roms/IBM Logo.ch8
Binary files differ
diff --git a/src/main.zig b/src/main.zig
new file mode 100644
index 0000000..9043f8c
--- /dev/null
+++ b/src/main.zig
@@ -0,0 +1,84 @@
+const std = @import("std");
+const ray = @import("raylib.zig");
+//const ray = @cImport({
+// @cInclude("raylib.h");
+//});
+
+const screenWidth: u32 = 64 * 10;
+const screenHeight: u32 = (32 * 10) + 24;
+const RndGen = std.rand.DefaultPrng;
+var Rnd = RndGen.init(0);
+var chip8_screen: ray.RenderTexture = undefined;
+
+const Chip8 = struct {
+ opcode: u16 = 0,
+ memory: [4096]u8 = [_]u8{0} ** 4096,
+ V: [16]u8 = [_]u8{0} ** 16,
+ I: u16 = 0,
+ pc: u16 = 0,
+ gfx: [64 * 32]bool = [_]bool{false} ** (64 * 32),
+ delay_timer: u8 = 0,
+ sound_timer: u8 = 0,
+ stack: [16]u16 = [_]u16{0} ** 16,
+ sp: u16 = 0,
+ key: u8 = 0,
+
+ pub fn new() Chip8 {
+ return Chip8{};
+ }
+
+ pub fn load_game(file_name: []u8) []u8 {
+ // TODO: handle file reading here
+ //var file = try std.fs.cwd().openFile(file_name, .{});
+ //defer file.close();
+ return file_name;
+ }
+};
+
+var chip8 = Chip8{};
+
+pub fn main() void {
+ setup_graphics();
+ defer ray.CloseWindow();
+ var exitWindow: bool = false;
+
+ while (!ray.WindowShouldClose() and !exitWindow) {
+ ray.BeginDrawing();
+ defer ray.EndDrawing();
+
+ ray.ClearBackground(ray.RAYWHITE);
+ exitWindow = ray.GuiWindowBox(ray.Rectangle{ .x = 0, .y = 0, .height = screenHeight, .width = screenWidth }, "CHIP-8");
+
+ update_screen(&chip8_screen, chip8.gfx);
+ ray.DrawTextureEx(chip8_screen.texture, ray.Vector2{ .x = 0, .y = 24 }, 0, 10, ray.WHITE);
+ }
+}
+
+fn setup_graphics() void {
+
+ //for (chip8_screen) |*pixel, index_usize| {
+ // var index: u32 = @intCast(u32, index_usize);
+ // pixel.* = chip8_pixel{ .location = ray.Rectangle{ .x = 10 * @intToFloat(f32, @mod(index, 64)), .y = 24 + 10 * @intToFloat(f32, (index / 64)), .width = 10, .height = 10 } };
+ //}
+
+ ray.InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+ chip8_screen = ray.LoadRenderTexture(64, 32);
+ ray.SetTargetFPS(60);
+}
+
+fn update_screen(screen: *ray.RenderTexture, pixels: [2048]bool) void {
+ ray.BeginTextureMode(screen.*);
+ for (pixels) |_, index_usize| {
+ var rnd: u8 = Rnd.random().int(u8);
+ if (rnd < (256 / 2)) {
+ rnd = 255;
+ } else {
+ rnd = 0;
+ }
+
+ var index: u32 = @intCast(u32, index_usize);
+ //var index_char: u8 = @intCast(u8, @mod(@intCast(u32, index_usize), 256));
+ ray.DrawRectangleRec(ray.Rectangle{ .x = @intToFloat(f32, @mod(index, 64)), .y = @intToFloat(f32, (index / 64)), .width = 1, .height = 1 }, ray.Color{ .r = rnd, .g = rnd, .b = rnd, .a = 255 });
+ }
+ ray.EndTextureMode();
+}
diff --git a/src/raylib.zig b/src/raylib.zig
new file mode 100644
index 0000000..9d801c8
--- /dev/null
+++ b/src/raylib.zig
@@ -0,0 +1,8789 @@
+pub const __builtin_bswap16 = @import("std").zig.c_builtins.__builtin_bswap16;
+pub const __builtin_bswap32 = @import("std").zig.c_builtins.__builtin_bswap32;
+pub const __builtin_bswap64 = @import("std").zig.c_builtins.__builtin_bswap64;
+pub const __builtin_signbit = @import("std").zig.c_builtins.__builtin_signbit;
+pub const __builtin_signbitf = @import("std").zig.c_builtins.__builtin_signbitf;
+pub const __builtin_popcount = @import("std").zig.c_builtins.__builtin_popcount;
+pub const __builtin_ctz = @import("std").zig.c_builtins.__builtin_ctz;
+pub const __builtin_clz = @import("std").zig.c_builtins.__builtin_clz;
+pub const __builtin_sqrt = @import("std").zig.c_builtins.__builtin_sqrt;
+pub const __builtin_sqrtf = @import("std").zig.c_builtins.__builtin_sqrtf;
+pub const __builtin_sin = @import("std").zig.c_builtins.__builtin_sin;
+pub const __builtin_sinf = @import("std").zig.c_builtins.__builtin_sinf;
+pub const __builtin_cos = @import("std").zig.c_builtins.__builtin_cos;
+pub const __builtin_cosf = @import("std").zig.c_builtins.__builtin_cosf;
+pub const __builtin_exp = @import("std").zig.c_builtins.__builtin_exp;
+pub const __builtin_expf = @import("std").zig.c_builtins.__builtin_expf;
+pub const __builtin_exp2 = @import("std").zig.c_builtins.__builtin_exp2;
+pub const __builtin_exp2f = @import("std").zig.c_builtins.__builtin_exp2f;
+pub const __builtin_log = @import("std").zig.c_builtins.__builtin_log;
+pub const __builtin_logf = @import("std").zig.c_builtins.__builtin_logf;
+pub const __builtin_log2 = @import("std").zig.c_builtins.__builtin_log2;
+pub const __builtin_log2f = @import("std").zig.c_builtins.__builtin_log2f;
+pub const __builtin_log10 = @import("std").zig.c_builtins.__builtin_log10;
+pub const __builtin_log10f = @import("std").zig.c_builtins.__builtin_log10f;
+pub const __builtin_abs = @import("std").zig.c_builtins.__builtin_abs;
+pub const __builtin_fabs = @import("std").zig.c_builtins.__builtin_fabs;
+pub const __builtin_fabsf = @import("std").zig.c_builtins.__builtin_fabsf;
+pub const __builtin_floor = @import("std").zig.c_builtins.__builtin_floor;
+pub const __builtin_floorf = @import("std").zig.c_builtins.__builtin_floorf;
+pub const __builtin_ceil = @import("std").zig.c_builtins.__builtin_ceil;
+pub const __builtin_ceilf = @import("std").zig.c_builtins.__builtin_ceilf;
+pub const __builtin_trunc = @import("std").zig.c_builtins.__builtin_trunc;
+pub const __builtin_truncf = @import("std").zig.c_builtins.__builtin_truncf;
+pub const __builtin_round = @import("std").zig.c_builtins.__builtin_round;
+pub const __builtin_roundf = @import("std").zig.c_builtins.__builtin_roundf;
+pub const __builtin_strlen = @import("std").zig.c_builtins.__builtin_strlen;
+pub const __builtin_strcmp = @import("std").zig.c_builtins.__builtin_strcmp;
+pub const __builtin_object_size = @import("std").zig.c_builtins.__builtin_object_size;
+pub const __builtin___memset_chk = @import("std").zig.c_builtins.__builtin___memset_chk;
+pub const __builtin_memset = @import("std").zig.c_builtins.__builtin_memset;
+pub const __builtin___memcpy_chk = @import("std").zig.c_builtins.__builtin___memcpy_chk;
+pub const __builtin_memcpy = @import("std").zig.c_builtins.__builtin_memcpy;
+pub const __builtin_expect = @import("std").zig.c_builtins.__builtin_expect;
+pub const __builtin_nanf = @import("std").zig.c_builtins.__builtin_nanf;
+pub const __builtin_huge_valf = @import("std").zig.c_builtins.__builtin_huge_valf;
+pub const __builtin_inff = @import("std").zig.c_builtins.__builtin_inff;
+pub const __builtin_isnan = @import("std").zig.c_builtins.__builtin_isnan;
+pub const __builtin_isinf = @import("std").zig.c_builtins.__builtin_isinf;
+pub const __builtin_isinf_sign = @import("std").zig.c_builtins.__builtin_isinf_sign;
+pub const __has_builtin = @import("std").zig.c_builtins.__has_builtin;
+pub const __builtin_assume = @import("std").zig.c_builtins.__builtin_assume;
+pub const __builtin_unreachable = @import("std").zig.c_builtins.__builtin_unreachable;
+pub const __builtin_constant_p = @import("std").zig.c_builtins.__builtin_constant_p;
+pub const __builtin_mul_overflow = @import("std").zig.c_builtins.__builtin_mul_overflow;
+pub const struct___va_list_tag = extern struct {
+ gp_offset: c_uint,
+ fp_offset: c_uint,
+ overflow_arg_area: ?*anyopaque,
+ reg_save_area: ?*anyopaque,
+};
+pub const __builtin_va_list = [1]struct___va_list_tag;
+pub const va_list = __builtin_va_list;
+pub const __gnuc_va_list = __builtin_va_list;
+pub const struct_Vector2 = extern struct {
+ x: f32,
+ y: f32,
+};
+pub const Vector2 = struct_Vector2;
+pub const struct_Vector3 = extern struct {
+ x: f32,
+ y: f32,
+ z: f32,
+};
+pub const Vector3 = struct_Vector3;
+pub const struct_Vector4 = extern struct {
+ x: f32,
+ y: f32,
+ z: f32,
+ w: f32,
+};
+pub const Vector4 = struct_Vector4;
+pub const Quaternion = Vector4;
+pub const struct_Matrix = extern struct {
+ m0: f32,
+ m4: f32,
+ m8: f32,
+ m12: f32,
+ m1: f32,
+ m5: f32,
+ m9: f32,
+ m13: f32,
+ m2: f32,
+ m6: f32,
+ m10: f32,
+ m14: f32,
+ m3: f32,
+ m7: f32,
+ m11: f32,
+ m15: f32,
+};
+pub const Matrix = struct_Matrix;
+pub const struct_Color = extern struct {
+ r: u8,
+ g: u8,
+ b: u8,
+ a: u8,
+};
+pub const Color = struct_Color;
+pub const struct_Rectangle = extern struct {
+ x: f32,
+ y: f32,
+ width: f32,
+ height: f32,
+};
+pub const Rectangle = struct_Rectangle;
+pub const struct_Image = extern struct {
+ data: ?*anyopaque,
+ width: c_int,
+ height: c_int,
+ mipmaps: c_int,
+ format: c_int,
+};
+pub const Image = struct_Image;
+pub const struct_Texture = extern struct {
+ id: c_uint,
+ width: c_int,
+ height: c_int,
+ mipmaps: c_int,
+ format: c_int,
+};
+pub const Texture = struct_Texture;
+pub const Texture2D = Texture;
+pub const TextureCubemap = Texture;
+pub const struct_RenderTexture = extern struct {
+ id: c_uint,
+ texture: Texture,
+ depth: Texture,
+};
+pub const RenderTexture = struct_RenderTexture;
+pub const RenderTexture2D = RenderTexture;
+pub const struct_NPatchInfo = extern struct {
+ source: Rectangle,
+ left: c_int,
+ top: c_int,
+ right: c_int,
+ bottom: c_int,
+ layout: c_int,
+};
+pub const NPatchInfo = struct_NPatchInfo;
+pub const struct_GlyphInfo = extern struct {
+ value: c_int,
+ offsetX: c_int,
+ offsetY: c_int,
+ advanceX: c_int,
+ image: Image,
+};
+pub const GlyphInfo = struct_GlyphInfo;
+pub const struct_Font = extern struct {
+ baseSize: c_int,
+ glyphCount: c_int,
+ glyphPadding: c_int,
+ texture: Texture2D,
+ recs: [*c]Rectangle,
+ glyphs: [*c]GlyphInfo,
+};
+pub const Font = struct_Font;
+pub const struct_Camera3D = extern struct {
+ position: Vector3,
+ target: Vector3,
+ up: Vector3,
+ fovy: f32,
+ projection: c_int,
+};
+pub const Camera3D = struct_Camera3D;
+pub const Camera = Camera3D;
+pub const struct_Camera2D = extern struct {
+ offset: Vector2,
+ target: Vector2,
+ rotation: f32,
+ zoom: f32,
+};
+pub const Camera2D = struct_Camera2D;
+pub const struct_Mesh = extern struct {
+ vertexCount: c_int,
+ triangleCount: c_int,
+ vertices: [*c]f32,
+ texcoords: [*c]f32,
+ texcoords2: [*c]f32,
+ normals: [*c]f32,
+ tangents: [*c]f32,
+ colors: [*c]u8,
+ indices: [*c]c_ushort,
+ animVertices: [*c]f32,
+ animNormals: [*c]f32,
+ boneIds: [*c]u8,
+ boneWeights: [*c]f32,
+ vaoId: c_uint,
+ vboId: [*c]c_uint,
+};
+pub const Mesh = struct_Mesh;
+pub const struct_Shader = extern struct {
+ id: c_uint,
+ locs: [*c]c_int,
+};
+pub const Shader = struct_Shader;
+pub const struct_MaterialMap = extern struct {
+ texture: Texture2D,
+ color: Color,
+ value: f32,
+};
+pub const MaterialMap = struct_MaterialMap;
+pub const struct_Material = extern struct {
+ shader: Shader,
+ maps: [*c]MaterialMap,
+ params: [4]f32,
+};
+pub const Material = struct_Material;
+pub const struct_Transform = extern struct {
+ translation: Vector3,
+ rotation: Quaternion,
+ scale: Vector3,
+};
+pub const Transform = struct_Transform;
+pub const struct_BoneInfo = extern struct {
+ name: [32]u8,
+ parent: c_int,
+};
+pub const BoneInfo = struct_BoneInfo;
+pub const struct_Model = extern struct {
+ transform: Matrix,
+ meshCount: c_int,
+ materialCount: c_int,
+ meshes: [*c]Mesh,
+ materials: [*c]Material,
+ meshMaterial: [*c]c_int,
+ boneCount: c_int,
+ bones: [*c]BoneInfo,
+ bindPose: [*c]Transform,
+};
+pub const Model = struct_Model;
+pub const struct_ModelAnimation = extern struct {
+ boneCount: c_int,
+ frameCount: c_int,
+ bones: [*c]BoneInfo,
+ framePoses: [*c][*c]Transform,
+};
+pub const ModelAnimation = struct_ModelAnimation;
+pub const struct_Ray = extern struct {
+ position: Vector3,
+ direction: Vector3,
+};
+pub const Ray = struct_Ray;
+pub const struct_RayCollision = extern struct {
+ hit: bool,
+ distance: f32,
+ point: Vector3,
+ normal: Vector3,
+};
+pub const RayCollision = struct_RayCollision;
+pub const struct_BoundingBox = extern struct {
+ min: Vector3,
+ max: Vector3,
+};
+pub const BoundingBox = struct_BoundingBox;
+pub const struct_Wave = extern struct {
+ frameCount: c_uint,
+ sampleRate: c_uint,
+ sampleSize: c_uint,
+ channels: c_uint,
+ data: ?*anyopaque,
+};
+pub const Wave = struct_Wave;
+pub const struct_rAudioBuffer = opaque {};
+pub const rAudioBuffer = struct_rAudioBuffer;
+pub const struct_rAudioProcessor = opaque {};
+pub const rAudioProcessor = struct_rAudioProcessor;
+pub const struct_AudioStream = extern struct {
+ buffer: ?*rAudioBuffer,
+ processor: ?*rAudioProcessor,
+ sampleRate: c_uint,
+ sampleSize: c_uint,
+ channels: c_uint,
+};
+pub const AudioStream = struct_AudioStream;
+pub const struct_Sound = extern struct {
+ stream: AudioStream,
+ frameCount: c_uint,
+};
+pub const Sound = struct_Sound;
+pub const struct_Music = extern struct {
+ stream: AudioStream,
+ frameCount: c_uint,
+ looping: bool,
+ ctxType: c_int,
+ ctxData: ?*anyopaque,
+};
+pub const Music = struct_Music;
+pub const struct_VrDeviceInfo = extern struct {
+ hResolution: c_int,
+ vResolution: c_int,
+ hScreenSize: f32,
+ vScreenSize: f32,
+ vScreenCenter: f32,
+ eyeToScreenDistance: f32,
+ lensSeparationDistance: f32,
+ interpupillaryDistance: f32,
+ lensDistortionValues: [4]f32,
+ chromaAbCorrection: [4]f32,
+};
+pub const VrDeviceInfo = struct_VrDeviceInfo;
+pub const struct_VrStereoConfig = extern struct {
+ projection: [2]Matrix,
+ viewOffset: [2]Matrix,
+ leftLensCenter: [2]f32,
+ rightLensCenter: [2]f32,
+ leftScreenCenter: [2]f32,
+ rightScreenCenter: [2]f32,
+ scale: [2]f32,
+ scaleIn: [2]f32,
+};
+pub const VrStereoConfig = struct_VrStereoConfig;
+pub const FLAG_VSYNC_HINT: c_int = 64;
+pub const FLAG_FULLSCREEN_MODE: c_int = 2;
+pub const FLAG_WINDOW_RESIZABLE: c_int = 4;
+pub const FLAG_WINDOW_UNDECORATED: c_int = 8;
+pub const FLAG_WINDOW_HIDDEN: c_int = 128;
+pub const FLAG_WINDOW_MINIMIZED: c_int = 512;
+pub const FLAG_WINDOW_MAXIMIZED: c_int = 1024;
+pub const FLAG_WINDOW_UNFOCUSED: c_int = 2048;
+pub const FLAG_WINDOW_TOPMOST: c_int = 4096;
+pub const FLAG_WINDOW_ALWAYS_RUN: c_int = 256;
+pub const FLAG_WINDOW_TRANSPARENT: c_int = 16;
+pub const FLAG_WINDOW_HIGHDPI: c_int = 8192;
+pub const FLAG_MSAA_4X_HINT: c_int = 32;
+pub const FLAG_INTERLACED_HINT: c_int = 65536;
+pub const ConfigFlags = c_uint;
+pub const LOG_ALL: c_int = 0;
+pub const LOG_TRACE: c_int = 1;
+pub const LOG_DEBUG: c_int = 2;
+pub const LOG_INFO: c_int = 3;
+pub const LOG_WARNING: c_int = 4;
+pub const LOG_ERROR: c_int = 5;
+pub const LOG_FATAL: c_int = 6;
+pub const LOG_NONE: c_int = 7;
+pub const TraceLogLevel = c_uint;
+pub const KEY_NULL: c_int = 0;
+pub const KEY_APOSTROPHE: c_int = 39;
+pub const KEY_COMMA: c_int = 44;
+pub const KEY_MINUS: c_int = 45;
+pub const KEY_PERIOD: c_int = 46;
+pub const KEY_SLASH: c_int = 47;
+pub const KEY_ZERO: c_int = 48;
+pub const KEY_ONE: c_int = 49;
+pub const KEY_TWO: c_int = 50;
+pub const KEY_THREE: c_int = 51;
+pub const KEY_FOUR: c_int = 52;
+pub const KEY_FIVE: c_int = 53;
+pub const KEY_SIX: c_int = 54;
+pub const KEY_SEVEN: c_int = 55;
+pub const KEY_EIGHT: c_int = 56;
+pub const KEY_NINE: c_int = 57;
+pub const KEY_SEMICOLON: c_int = 59;
+pub const KEY_EQUAL: c_int = 61;
+pub const KEY_A: c_int = 65;
+pub const KEY_B: c_int = 66;
+pub const KEY_C: c_int = 67;
+pub const KEY_D: c_int = 68;
+pub const KEY_E: c_int = 69;
+pub const KEY_F: c_int = 70;
+pub const KEY_G: c_int = 71;
+pub const KEY_H: c_int = 72;
+pub const KEY_I: c_int = 73;
+pub const KEY_J: c_int = 74;
+pub const KEY_K: c_int = 75;
+pub const KEY_L: c_int = 76;
+pub const KEY_M: c_int = 77;
+pub const KEY_N: c_int = 78;
+pub const KEY_O: c_int = 79;
+pub const KEY_P: c_int = 80;
+pub const KEY_Q: c_int = 81;
+pub const KEY_R: c_int = 82;
+pub const KEY_S: c_int = 83;
+pub const KEY_T: c_int = 84;
+pub const KEY_U: c_int = 85;
+pub const KEY_V: c_int = 86;
+pub const KEY_W: c_int = 87;
+pub const KEY_X: c_int = 88;
+pub const KEY_Y: c_int = 89;
+pub const KEY_Z: c_int = 90;
+pub const KEY_LEFT_BRACKET: c_int = 91;
+pub const KEY_BACKSLASH: c_int = 92;
+pub const KEY_RIGHT_BRACKET: c_int = 93;
+pub const KEY_GRAVE: c_int = 96;
+pub const KEY_SPACE: c_int = 32;
+pub const KEY_ESCAPE: c_int = 256;
+pub const KEY_ENTER: c_int = 257;
+pub const KEY_TAB: c_int = 258;
+pub const KEY_BACKSPACE: c_int = 259;
+pub const KEY_INSERT: c_int = 260;
+pub const KEY_DELETE: c_int = 261;
+pub const KEY_RIGHT: c_int = 262;
+pub const KEY_LEFT: c_int = 263;
+pub const KEY_DOWN: c_int = 264;
+pub const KEY_UP: c_int = 265;
+pub const KEY_PAGE_UP: c_int = 266;
+pub const KEY_PAGE_DOWN: c_int = 267;
+pub const KEY_HOME: c_int = 268;
+pub const KEY_END: c_int = 269;
+pub const KEY_CAPS_LOCK: c_int = 280;
+pub const KEY_SCROLL_LOCK: c_int = 281;
+pub const KEY_NUM_LOCK: c_int = 282;
+pub const KEY_PRINT_SCREEN: c_int = 283;
+pub const KEY_PAUSE: c_int = 284;
+pub const KEY_F1: c_int = 290;
+pub const KEY_F2: c_int = 291;
+pub const KEY_F3: c_int = 292;
+pub const KEY_F4: c_int = 293;
+pub const KEY_F5: c_int = 294;
+pub const KEY_F6: c_int = 295;
+pub const KEY_F7: c_int = 296;
+pub const KEY_F8: c_int = 297;
+pub const KEY_F9: c_int = 298;
+pub const KEY_F10: c_int = 299;
+pub const KEY_F11: c_int = 300;
+pub const KEY_F12: c_int = 301;
+pub const KEY_LEFT_SHIFT: c_int = 340;
+pub const KEY_LEFT_CONTROL: c_int = 341;
+pub const KEY_LEFT_ALT: c_int = 342;
+pub const KEY_LEFT_SUPER: c_int = 343;
+pub const KEY_RIGHT_SHIFT: c_int = 344;
+pub const KEY_RIGHT_CONTROL: c_int = 345;
+pub const KEY_RIGHT_ALT: c_int = 346;
+pub const KEY_RIGHT_SUPER: c_int = 347;
+pub const KEY_KB_MENU: c_int = 348;
+pub const KEY_KP_0: c_int = 320;
+pub const KEY_KP_1: c_int = 321;
+pub const KEY_KP_2: c_int = 322;
+pub const KEY_KP_3: c_int = 323;
+pub const KEY_KP_4: c_int = 324;
+pub const KEY_KP_5: c_int = 325;
+pub const KEY_KP_6: c_int = 326;
+pub const KEY_KP_7: c_int = 327;
+pub const KEY_KP_8: c_int = 328;
+pub const KEY_KP_9: c_int = 329;
+pub const KEY_KP_DECIMAL: c_int = 330;
+pub const KEY_KP_DIVIDE: c_int = 331;
+pub const KEY_KP_MULTIPLY: c_int = 332;
+pub const KEY_KP_SUBTRACT: c_int = 333;
+pub const KEY_KP_ADD: c_int = 334;
+pub const KEY_KP_ENTER: c_int = 335;
+pub const KEY_KP_EQUAL: c_int = 336;
+pub const KEY_BACK: c_int = 4;
+pub const KEY_MENU: c_int = 82;
+pub const KEY_VOLUME_UP: c_int = 24;
+pub const KEY_VOLUME_DOWN: c_int = 25;
+pub const KeyboardKey = c_uint;
+pub const MOUSE_BUTTON_LEFT: c_int = 0;
+pub const MOUSE_BUTTON_RIGHT: c_int = 1;
+pub const MOUSE_BUTTON_MIDDLE: c_int = 2;
+pub const MOUSE_BUTTON_SIDE: c_int = 3;
+pub const MOUSE_BUTTON_EXTRA: c_int = 4;
+pub const MOUSE_BUTTON_FORWARD: c_int = 5;
+pub const MOUSE_BUTTON_BACK: c_int = 6;
+pub const MouseButton = c_uint;
+pub const MOUSE_CURSOR_DEFAULT: c_int = 0;
+pub const MOUSE_CURSOR_ARROW: c_int = 1;
+pub const MOUSE_CURSOR_IBEAM: c_int = 2;
+pub const MOUSE_CURSOR_CROSSHAIR: c_int = 3;
+pub const MOUSE_CURSOR_POINTING_HAND: c_int = 4;
+pub const MOUSE_CURSOR_RESIZE_EW: c_int = 5;
+pub const MOUSE_CURSOR_RESIZE_NS: c_int = 6;
+pub const MOUSE_CURSOR_RESIZE_NWSE: c_int = 7;
+pub const MOUSE_CURSOR_RESIZE_NESW: c_int = 8;
+pub const MOUSE_CURSOR_RESIZE_ALL: c_int = 9;
+pub const MOUSE_CURSOR_NOT_ALLOWED: c_int = 10;
+pub const MouseCursor = c_uint;
+pub const GAMEPAD_BUTTON_UNKNOWN: c_int = 0;
+pub const GAMEPAD_BUTTON_LEFT_FACE_UP: c_int = 1;
+pub const GAMEPAD_BUTTON_LEFT_FACE_RIGHT: c_int = 2;
+pub const GAMEPAD_BUTTON_LEFT_FACE_DOWN: c_int = 3;
+pub const GAMEPAD_BUTTON_LEFT_FACE_LEFT: c_int = 4;
+pub const GAMEPAD_BUTTON_RIGHT_FACE_UP: c_int = 5;
+pub const GAMEPAD_BUTTON_RIGHT_FACE_RIGHT: c_int = 6;
+pub const GAMEPAD_BUTTON_RIGHT_FACE_DOWN: c_int = 7;
+pub const GAMEPAD_BUTTON_RIGHT_FACE_LEFT: c_int = 8;
+pub const GAMEPAD_BUTTON_LEFT_TRIGGER_1: c_int = 9;
+pub const GAMEPAD_BUTTON_LEFT_TRIGGER_2: c_int = 10;
+pub const GAMEPAD_BUTTON_RIGHT_TRIGGER_1: c_int = 11;
+pub const GAMEPAD_BUTTON_RIGHT_TRIGGER_2: c_int = 12;
+pub const GAMEPAD_BUTTON_MIDDLE_LEFT: c_int = 13;
+pub const GAMEPAD_BUTTON_MIDDLE: c_int = 14;
+pub const GAMEPAD_BUTTON_MIDDLE_RIGHT: c_int = 15;
+pub const GAMEPAD_BUTTON_LEFT_THUMB: c_int = 16;
+pub const GAMEPAD_BUTTON_RIGHT_THUMB: c_int = 17;
+pub const GamepadButton = c_uint;
+pub const GAMEPAD_AXIS_LEFT_X: c_int = 0;
+pub const GAMEPAD_AXIS_LEFT_Y: c_int = 1;
+pub const GAMEPAD_AXIS_RIGHT_X: c_int = 2;
+pub const GAMEPAD_AXIS_RIGHT_Y: c_int = 3;
+pub const GAMEPAD_AXIS_LEFT_TRIGGER: c_int = 4;
+pub const GAMEPAD_AXIS_RIGHT_TRIGGER: c_int = 5;
+pub const GamepadAxis = c_uint;
+pub const MATERIAL_MAP_ALBEDO: c_int = 0;
+pub const MATERIAL_MAP_METALNESS: c_int = 1;
+pub const MATERIAL_MAP_NORMAL: c_int = 2;
+pub const MATERIAL_MAP_ROUGHNESS: c_int = 3;
+pub const MATERIAL_MAP_OCCLUSION: c_int = 4;
+pub const MATERIAL_MAP_EMISSION: c_int = 5;
+pub const MATERIAL_MAP_HEIGHT: c_int = 6;
+pub const MATERIAL_MAP_CUBEMAP: c_int = 7;
+pub const MATERIAL_MAP_IRRADIANCE: c_int = 8;
+pub const MATERIAL_MAP_PREFILTER: c_int = 9;
+pub const MATERIAL_MAP_BRDF: c_int = 10;
+pub const MaterialMapIndex = c_uint;
+pub const SHADER_LOC_VERTEX_POSITION: c_int = 0;
+pub const SHADER_LOC_VERTEX_TEXCOORD01: c_int = 1;
+pub const SHADER_LOC_VERTEX_TEXCOORD02: c_int = 2;
+pub const SHADER_LOC_VERTEX_NORMAL: c_int = 3;
+pub const SHADER_LOC_VERTEX_TANGENT: c_int = 4;
+pub const SHADER_LOC_VERTEX_COLOR: c_int = 5;
+pub const SHADER_LOC_MATRIX_MVP: c_int = 6;
+pub const SHADER_LOC_MATRIX_VIEW: c_int = 7;
+pub const SHADER_LOC_MATRIX_PROJECTION: c_int = 8;
+pub const SHADER_LOC_MATRIX_MODEL: c_int = 9;
+pub const SHADER_LOC_MATRIX_NORMAL: c_int = 10;
+pub const SHADER_LOC_VECTOR_VIEW: c_int = 11;
+pub const SHADER_LOC_COLOR_DIFFUSE: c_int = 12;
+pub const SHADER_LOC_COLOR_SPECULAR: c_int = 13;
+pub const SHADER_LOC_COLOR_AMBIENT: c_int = 14;
+pub const SHADER_LOC_MAP_ALBEDO: c_int = 15;
+pub const SHADER_LOC_MAP_METALNESS: c_int = 16;
+pub const SHADER_LOC_MAP_NORMAL: c_int = 17;
+pub const SHADER_LOC_MAP_ROUGHNESS: c_int = 18;
+pub const SHADER_LOC_MAP_OCCLUSION: c_int = 19;
+pub const SHADER_LOC_MAP_EMISSION: c_int = 20;
+pub const SHADER_LOC_MAP_HEIGHT: c_int = 21;
+pub const SHADER_LOC_MAP_CUBEMAP: c_int = 22;
+pub const SHADER_LOC_MAP_IRRADIANCE: c_int = 23;
+pub const SHADER_LOC_MAP_PREFILTER: c_int = 24;
+pub const SHADER_LOC_MAP_BRDF: c_int = 25;
+pub const ShaderLocationIndex = c_uint;
+pub const SHADER_UNIFORM_FLOAT: c_int = 0;
+pub const SHADER_UNIFORM_VEC2: c_int = 1;
+pub const SHADER_UNIFORM_VEC3: c_int = 2;
+pub const SHADER_UNIFORM_VEC4: c_int = 3;
+pub const SHADER_UNIFORM_INT: c_int = 4;
+pub const SHADER_UNIFORM_IVEC2: c_int = 5;
+pub const SHADER_UNIFORM_IVEC3: c_int = 6;
+pub const SHADER_UNIFORM_IVEC4: c_int = 7;
+pub const SHADER_UNIFORM_SAMPLER2D: c_int = 8;
+pub const ShaderUniformDataType = c_uint;
+pub const SHADER_ATTRIB_FLOAT: c_int = 0;
+pub const SHADER_ATTRIB_VEC2: c_int = 1;
+pub const SHADER_ATTRIB_VEC3: c_int = 2;
+pub const SHADER_ATTRIB_VEC4: c_int = 3;
+pub const ShaderAttributeDataType = c_uint;
+pub const PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: c_int = 1;
+pub const PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: c_int = 2;
+pub const PIXELFORMAT_UNCOMPRESSED_R5G6B5: c_int = 3;
+pub const PIXELFORMAT_UNCOMPRESSED_R8G8B8: c_int = 4;
+pub const PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: c_int = 5;
+pub const PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: c_int = 6;
+pub const PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: c_int = 7;
+pub const PIXELFORMAT_UNCOMPRESSED_R32: c_int = 8;
+pub const PIXELFORMAT_UNCOMPRESSED_R32G32B32: c_int = 9;
+pub const PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: c_int = 10;
+pub const PIXELFORMAT_COMPRESSED_DXT1_RGB: c_int = 11;
+pub const PIXELFORMAT_COMPRESSED_DXT1_RGBA: c_int = 12;
+pub const PIXELFORMAT_COMPRESSED_DXT3_RGBA: c_int = 13;
+pub const PIXELFORMAT_COMPRESSED_DXT5_RGBA: c_int = 14;
+pub const PIXELFORMAT_COMPRESSED_ETC1_RGB: c_int = 15;
+pub const PIXELFORMAT_COMPRESSED_ETC2_RGB: c_int = 16;
+pub const PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: c_int = 17;
+pub const PIXELFORMAT_COMPRESSED_PVRT_RGB: c_int = 18;
+pub const PIXELFORMAT_COMPRESSED_PVRT_RGBA: c_int = 19;
+pub const PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: c_int = 20;
+pub const PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: c_int = 21;
+pub const PixelFormat = c_uint;
+pub const TEXTURE_FILTER_POINT: c_int = 0;
+pub const TEXTURE_FILTER_BILINEAR: c_int = 1;
+pub const TEXTURE_FILTER_TRILINEAR: c_int = 2;
+pub const TEXTURE_FILTER_ANISOTROPIC_4X: c_int = 3;
+pub const TEXTURE_FILTER_ANISOTROPIC_8X: c_int = 4;
+pub const TEXTURE_FILTER_ANISOTROPIC_16X: c_int = 5;
+pub const TextureFilter = c_uint;
+pub const TEXTURE_WRAP_REPEAT: c_int = 0;
+pub const TEXTURE_WRAP_CLAMP: c_int = 1;
+pub const TEXTURE_WRAP_MIRROR_REPEAT: c_int = 2;
+pub const TEXTURE_WRAP_MIRROR_CLAMP: c_int = 3;
+pub const TextureWrap = c_uint;
+pub const CUBEMAP_LAYOUT_AUTO_DETECT: c_int = 0;
+pub const CUBEMAP_LAYOUT_LINE_VERTICAL: c_int = 1;
+pub const CUBEMAP_LAYOUT_LINE_HORIZONTAL: c_int = 2;
+pub const CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR: c_int = 3;
+pub const CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE: c_int = 4;
+pub const CUBEMAP_LAYOUT_PANORAMA: c_int = 5;
+pub const CubemapLayout = c_uint;
+pub const FONT_DEFAULT: c_int = 0;
+pub const FONT_BITMAP: c_int = 1;
+pub const FONT_SDF: c_int = 2;
+pub const FontType = c_uint;
+pub const BLEND_ALPHA: c_int = 0;
+pub const BLEND_ADDITIVE: c_int = 1;
+pub const BLEND_MULTIPLIED: c_int = 2;
+pub const BLEND_ADD_COLORS: c_int = 3;
+pub const BLEND_SUBTRACT_COLORS: c_int = 4;
+pub const BLEND_ALPHA_PREMUL: c_int = 5;
+pub const BLEND_CUSTOM: c_int = 6;
+pub const BlendMode = c_uint;
+pub const GESTURE_NONE: c_int = 0;
+pub const GESTURE_TAP: c_int = 1;
+pub const GESTURE_DOUBLETAP: c_int = 2;
+pub const GESTURE_HOLD: c_int = 4;
+pub const GESTURE_DRAG: c_int = 8;
+pub const GESTURE_SWIPE_RIGHT: c_int = 16;
+pub const GESTURE_SWIPE_LEFT: c_int = 32;
+pub const GESTURE_SWIPE_UP: c_int = 64;
+pub const GESTURE_SWIPE_DOWN: c_int = 128;
+pub const GESTURE_PINCH_IN: c_int = 256;
+pub const GESTURE_PINCH_OUT: c_int = 512;
+pub const Gesture = c_uint;
+pub const CAMERA_CUSTOM: c_int = 0;
+pub const CAMERA_FREE: c_int = 1;
+pub const CAMERA_ORBITAL: c_int = 2;
+pub const CAMERA_FIRST_PERSON: c_int = 3;
+pub const CAMERA_THIRD_PERSON: c_int = 4;
+pub const CameraMode = c_uint;
+pub const CAMERA_PERSPECTIVE: c_int = 0;
+pub const CAMERA_ORTHOGRAPHIC: c_int = 1;
+pub const CameraProjection = c_uint;
+pub const NPATCH_NINE_PATCH: c_int = 0;
+pub const NPATCH_THREE_PATCH_VERTICAL: c_int = 1;
+pub const NPATCH_THREE_PATCH_HORIZONTAL: c_int = 2;
+pub const NPatchLayout = c_uint;
+pub const TraceLogCallback = ?fn (c_int, [*c]const u8, [*c]struct___va_list_tag) callconv(.C) void;
+pub const LoadFileDataCallback = ?fn ([*c]const u8, [*c]c_uint) callconv(.C) [*c]u8;
+pub const SaveFileDataCallback = ?fn ([*c]const u8, ?*anyopaque, c_uint) callconv(.C) bool;
+pub const LoadFileTextCallback = ?fn ([*c]const u8) callconv(.C) [*c]u8;
+pub const SaveFileTextCallback = ?fn ([*c]const u8, [*c]u8) callconv(.C) bool;
+pub extern fn InitWindow(width: c_int, height: c_int, title: [*c]const u8) void;
+pub extern fn WindowShouldClose() bool;
+pub extern fn CloseWindow() void;
+pub extern fn IsWindowReady() bool;
+pub extern fn IsWindowFullscreen() bool;
+pub extern fn IsWindowHidden() bool;
+pub extern fn IsWindowMinimized() bool;
+pub extern fn IsWindowMaximized() bool;
+pub extern fn IsWindowFocused() bool;
+pub extern fn IsWindowResized() bool;
+pub extern fn IsWindowState(flag: c_uint) bool;
+pub extern fn SetWindowState(flags: c_uint) void;
+pub extern fn ClearWindowState(flags: c_uint) void;
+pub extern fn ToggleFullscreen() void;
+pub extern fn MaximizeWindow() void;
+pub extern fn MinimizeWindow() void;
+pub extern fn RestoreWindow() void;
+pub extern fn SetWindowIcon(image: Image) void;
+pub extern fn SetWindowTitle(title: [*c]const u8) void;
+pub extern fn SetWindowPosition(x: c_int, y: c_int) void;
+pub extern fn SetWindowMonitor(monitor: c_int) void;
+pub extern fn SetWindowMinSize(width: c_int, height: c_int) void;
+pub extern fn SetWindowSize(width: c_int, height: c_int) void;
+pub extern fn SetWindowOpacity(opacity: f32) void;
+pub extern fn GetWindowHandle() ?*anyopaque;
+pub extern fn GetScreenWidth() c_int;
+pub extern fn GetScreenHeight() c_int;
+pub extern fn GetRenderWidth() c_int;
+pub extern fn GetRenderHeight() c_int;
+pub extern fn GetMonitorCount() c_int;
+pub extern fn GetCurrentMonitor() c_int;
+pub extern fn GetMonitorPosition(monitor: c_int) Vector2;
+pub extern fn GetMonitorWidth(monitor: c_int) c_int;
+pub extern fn GetMonitorHeight(monitor: c_int) c_int;
+pub extern fn GetMonitorPhysicalWidth(monitor: c_int) c_int;
+pub extern fn GetMonitorPhysicalHeight(monitor: c_int) c_int;
+pub extern fn GetMonitorRefreshRate(monitor: c_int) c_int;
+pub extern fn GetWindowPosition() Vector2;
+pub extern fn GetWindowScaleDPI() Vector2;
+pub extern fn GetMonitorName(monitor: c_int) [*c]const u8;
+pub extern fn SetClipboardText(text: [*c]const u8) void;
+pub extern fn GetClipboardText() [*c]const u8;
+pub extern fn SwapScreenBuffer() void;
+pub extern fn PollInputEvents() void;
+pub extern fn WaitTime(ms: f32) void;
+pub extern fn ShowCursor() void;
+pub extern fn HideCursor() void;
+pub extern fn IsCursorHidden() bool;
+pub extern fn EnableCursor() void;
+pub extern fn DisableCursor() void;
+pub extern fn IsCursorOnScreen() bool;
+pub extern fn ClearBackground(color: Color) void;
+pub extern fn BeginDrawing() void;
+pub extern fn EndDrawing() void;
+pub extern fn BeginMode2D(camera: Camera2D) void;
+pub extern fn EndMode2D() void;
+pub extern fn BeginMode3D(camera: Camera3D) void;
+pub extern fn EndMode3D() void;
+pub extern fn BeginTextureMode(target: RenderTexture2D) void;
+pub extern fn EndTextureMode() void;
+pub extern fn BeginShaderMode(shader: Shader) void;
+pub extern fn EndShaderMode() void;
+pub extern fn BeginBlendMode(mode: c_int) void;
+pub extern fn EndBlendMode() void;
+pub extern fn BeginScissorMode(x: c_int, y: c_int, width: c_int, height: c_int) void;
+pub extern fn EndScissorMode() void;
+pub extern fn BeginVrStereoMode(config: VrStereoConfig) void;
+pub extern fn EndVrStereoMode() void;
+pub extern fn LoadVrStereoConfig(device: VrDeviceInfo) VrStereoConfig;
+pub extern fn UnloadVrStereoConfig(config: VrStereoConfig) void;
+pub extern fn LoadShader(vsFileName: [*c]const u8, fsFileName: [*c]const u8) Shader;
+pub extern fn LoadShaderFromMemory(vsCode: [*c]const u8, fsCode: [*c]const u8) Shader;
+pub extern fn GetShaderLocation(shader: Shader, uniformName: [*c]const u8) c_int;
+pub extern fn GetShaderLocationAttrib(shader: Shader, attribName: [*c]const u8) c_int;
+pub extern fn SetShaderValue(shader: Shader, locIndex: c_int, value: ?*const anyopaque, uniformType: c_int) void;
+pub extern fn SetShaderValueV(shader: Shader, locIndex: c_int, value: ?*const anyopaque, uniformType: c_int, count: c_int) void;
+pub extern fn SetShaderValueMatrix(shader: Shader, locIndex: c_int, mat: Matrix) void;
+pub extern fn SetShaderValueTexture(shader: Shader, locIndex: c_int, texture: Texture2D) void;
+pub extern fn UnloadShader(shader: Shader) void;
+pub extern fn GetMouseRay(mousePosition: Vector2, camera: Camera) Ray;
+pub extern fn GetCameraMatrix(camera: Camera) Matrix;
+pub extern fn GetCameraMatrix2D(camera: Camera2D) Matrix;
+pub extern fn GetWorldToScreen(position: Vector3, camera: Camera) Vector2;
+pub extern fn GetWorldToScreenEx(position: Vector3, camera: Camera, width: c_int, height: c_int) Vector2;
+pub extern fn GetWorldToScreen2D(position: Vector2, camera: Camera2D) Vector2;
+pub extern fn GetScreenToWorld2D(position: Vector2, camera: Camera2D) Vector2;
+pub extern fn SetTargetFPS(fps: c_int) void;
+pub extern fn GetFPS() c_int;
+pub extern fn GetFrameTime() f32;
+pub extern fn GetTime() f64;
+pub extern fn GetRandomValue(min: c_int, max: c_int) c_int;
+pub extern fn SetRandomSeed(seed: c_uint) void;
+pub extern fn TakeScreenshot(fileName: [*c]const u8) void;
+pub extern fn SetConfigFlags(flags: c_uint) void;
+pub extern fn TraceLog(logLevel: c_int, text: [*c]const u8, ...) void;
+pub extern fn SetTraceLogLevel(logLevel: c_int) void;
+pub extern fn MemAlloc(size: c_int) ?*anyopaque;
+pub extern fn MemRealloc(ptr: ?*anyopaque, size: c_int) ?*anyopaque;
+pub extern fn MemFree(ptr: ?*anyopaque) void;
+pub extern fn SetTraceLogCallback(callback: TraceLogCallback) void;
+pub extern fn SetLoadFileDataCallback(callback: LoadFileDataCallback) void;
+pub extern fn SetSaveFileDataCallback(callback: SaveFileDataCallback) void;
+pub extern fn SetLoadFileTextCallback(callback: LoadFileTextCallback) void;
+pub extern fn SetSaveFileTextCallback(callback: SaveFileTextCallback) void;
+pub extern fn LoadFileData(fileName: [*c]const u8, bytesRead: [*c]c_uint) [*c]u8;
+pub extern fn UnloadFileData(data: [*c]u8) void;
+pub extern fn SaveFileData(fileName: [*c]const u8, data: ?*anyopaque, bytesToWrite: c_uint) bool;
+pub extern fn LoadFileText(fileName: [*c]const u8) [*c]u8;
+pub extern fn UnloadFileText(text: [*c]u8) void;
+pub extern fn SaveFileText(fileName: [*c]const u8, text: [*c]u8) bool;
+pub extern fn FileExists(fileName: [*c]const u8) bool;
+pub extern fn DirectoryExists(dirPath: [*c]const u8) bool;
+pub extern fn IsFileExtension(fileName: [*c]const u8, ext: [*c]const u8) bool;
+pub extern fn GetFileLength(fileName: [*c]const u8) c_int;
+pub extern fn GetFileExtension(fileName: [*c]const u8) [*c]const u8;
+pub extern fn GetFileName(filePath: [*c]const u8) [*c]const u8;
+pub extern fn GetFileNameWithoutExt(filePath: [*c]const u8) [*c]const u8;
+pub extern fn GetDirectoryPath(filePath: [*c]const u8) [*c]const u8;
+pub extern fn GetPrevDirectoryPath(dirPath: [*c]const u8) [*c]const u8;
+pub extern fn GetWorkingDirectory() [*c]const u8;
+pub extern fn GetApplicationDirectory() [*c]const u8;
+pub extern fn GetDirectoryFiles(dirPath: [*c]const u8, count: [*c]c_int) [*c][*c]u8;
+pub extern fn ClearDirectoryFiles() void;
+pub extern fn ChangeDirectory(dir: [*c]const u8) bool;
+pub extern fn IsFileDropped() bool;
+pub extern fn GetDroppedFiles(count: [*c]c_int) [*c][*c]u8;
+pub extern fn ClearDroppedFiles() void;
+pub extern fn GetFileModTime(fileName: [*c]const u8) c_long;
+pub extern fn CompressData(data: [*c]const u8, dataSize: c_int, compDataSize: [*c]c_int) [*c]u8;
+pub extern fn DecompressData(compData: [*c]const u8, compDataSize: c_int, dataSize: [*c]c_int) [*c]u8;
+pub extern fn EncodeDataBase64(data: [*c]const u8, dataSize: c_int, outputSize: [*c]c_int) [*c]u8;
+pub extern fn DecodeDataBase64(data: [*c]const u8, outputSize: [*c]c_int) [*c]u8;
+pub extern fn SaveStorageValue(position: c_uint, value: c_int) bool;
+pub extern fn LoadStorageValue(position: c_uint) c_int;
+pub extern fn OpenURL(url: [*c]const u8) void;
+pub extern fn IsKeyPressed(key: c_int) bool;
+pub extern fn IsKeyDown(key: c_int) bool;
+pub extern fn IsKeyReleased(key: c_int) bool;
+pub extern fn IsKeyUp(key: c_int) bool;
+pub extern fn SetExitKey(key: c_int) void;
+pub extern fn GetKeyPressed() c_int;
+pub extern fn GetCharPressed() c_int;
+pub extern fn IsGamepadAvailable(gamepad: c_int) bool;
+pub extern fn GetGamepadName(gamepad: c_int) [*c]const u8;
+pub extern fn IsGamepadButtonPressed(gamepad: c_int, button: c_int) bool;
+pub extern fn IsGamepadButtonDown(gamepad: c_int, button: c_int) bool;
+pub extern fn IsGamepadButtonReleased(gamepad: c_int, button: c_int) bool;
+pub extern fn IsGamepadButtonUp(gamepad: c_int, button: c_int) bool;
+pub extern fn GetGamepadButtonPressed() c_int;
+pub extern fn GetGamepadAxisCount(gamepad: c_int) c_int;
+pub extern fn GetGamepadAxisMovement(gamepad: c_int, axis: c_int) f32;
+pub extern fn SetGamepadMappings(mappings: [*c]const u8) c_int;
+pub extern fn IsMouseButtonPressed(button: c_int) bool;
+pub extern fn IsMouseButtonDown(button: c_int) bool;
+pub extern fn IsMouseButtonReleased(button: c_int) bool;
+pub extern fn IsMouseButtonUp(button: c_int) bool;
+pub extern fn GetMouseX() c_int;
+pub extern fn GetMouseY() c_int;
+pub extern fn GetMousePosition() Vector2;
+pub extern fn GetMouseDelta() Vector2;
+pub extern fn SetMousePosition(x: c_int, y: c_int) void;
+pub extern fn SetMouseOffset(offsetX: c_int, offsetY: c_int) void;
+pub extern fn SetMouseScale(scaleX: f32, scaleY: f32) void;
+pub extern fn GetMouseWheelMove() f32;
+pub extern fn SetMouseCursor(cursor: c_int) void;
+pub extern fn GetTouchX() c_int;
+pub extern fn GetTouchY() c_int;
+pub extern fn GetTouchPosition(index: c_int) Vector2;
+pub extern fn GetTouchPointId(index: c_int) c_int;
+pub extern fn GetTouchPointCount() c_int;
+pub extern fn SetGesturesEnabled(flags: c_uint) void;
+pub extern fn IsGestureDetected(gesture: c_int) bool;
+pub extern fn GetGestureDetected() c_int;
+pub extern fn GetGestureHoldDuration() f32;
+pub extern fn GetGestureDragVector() Vector2;
+pub extern fn GetGestureDragAngle() f32;
+pub extern fn GetGesturePinchVector() Vector2;
+pub extern fn GetGesturePinchAngle() f32;
+pub extern fn SetCameraMode(camera: Camera, mode: c_int) void;
+pub extern fn UpdateCamera(camera: [*c]Camera) void;
+pub extern fn SetCameraPanControl(keyPan: c_int) void;
+pub extern fn SetCameraAltControl(keyAlt: c_int) void;
+pub extern fn SetCameraSmoothZoomControl(keySmoothZoom: c_int) void;
+pub extern fn SetCameraMoveControls(keyFront: c_int, keyBack: c_int, keyRight: c_int, keyLeft: c_int, keyUp: c_int, keyDown: c_int) void;
+pub extern fn SetShapesTexture(texture: Texture2D, source: Rectangle) void;
+pub extern fn DrawPixel(posX: c_int, posY: c_int, color: Color) void;
+pub extern fn DrawPixelV(position: Vector2, color: Color) void;
+pub extern fn DrawLine(startPosX: c_int, startPosY: c_int, endPosX: c_int, endPosY: c_int, color: Color) void;
+pub extern fn DrawLineV(startPos: Vector2, endPos: Vector2, color: Color) void;
+pub extern fn DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void;
+pub extern fn DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void;
+pub extern fn DrawLineBezierQuad(startPos: Vector2, endPos: Vector2, controlPos: Vector2, thick: f32, color: Color) void;
+pub extern fn DrawLineBezierCubic(startPos: Vector2, endPos: Vector2, startControlPos: Vector2, endControlPos: Vector2, thick: f32, color: Color) void;
+pub extern fn DrawLineStrip(points: [*c]Vector2, pointCount: c_int, color: Color) void;
+pub extern fn DrawCircle(centerX: c_int, centerY: c_int, radius: f32, color: Color) void;
+pub extern fn DrawCircleSector(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void;
+pub extern fn DrawCircleSectorLines(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void;
+pub extern fn DrawCircleGradient(centerX: c_int, centerY: c_int, radius: f32, color1: Color, color2: Color) void;
+pub extern fn DrawCircleV(center: Vector2, radius: f32, color: Color) void;
+pub extern fn DrawCircleLines(centerX: c_int, centerY: c_int, radius: f32, color: Color) void;
+pub extern fn DrawEllipse(centerX: c_int, centerY: c_int, radiusH: f32, radiusV: f32, color: Color) void;
+pub extern fn DrawEllipseLines(centerX: c_int, centerY: c_int, radiusH: f32, radiusV: f32, color: Color) void;
+pub extern fn DrawRing(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void;
+pub extern fn DrawRingLines(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void;
+pub extern fn DrawRectangle(posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void;
+pub extern fn DrawRectangleV(position: Vector2, size: Vector2, color: Color) void;
+pub extern fn DrawRectangleRec(rec: Rectangle, color: Color) void;
+pub extern fn DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color) void;
+pub extern fn DrawRectangleGradientV(posX: c_int, posY: c_int, width: c_int, height: c_int, color1: Color, color2: Color) void;
+pub extern fn DrawRectangleGradientH(posX: c_int, posY: c_int, width: c_int, height: c_int, color1: Color, color2: Color) void;
+pub extern fn DrawRectangleGradientEx(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color) void;
+pub extern fn DrawRectangleLines(posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void;
+pub extern fn DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color) void;
+pub extern fn DrawRectangleRounded(rec: Rectangle, roundness: f32, segments: c_int, color: Color) void;
+pub extern fn DrawRectangleRoundedLines(rec: Rectangle, roundness: f32, segments: c_int, lineThick: f32, color: Color) void;
+pub extern fn DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void;
+pub extern fn DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void;
+pub extern fn DrawTriangleFan(points: [*c]Vector2, pointCount: c_int, color: Color) void;
+pub extern fn DrawTriangleStrip(points: [*c]Vector2, pointCount: c_int, color: Color) void;
+pub extern fn DrawPoly(center: Vector2, sides: c_int, radius: f32, rotation: f32, color: Color) void;
+pub extern fn DrawPolyLines(center: Vector2, sides: c_int, radius: f32, rotation: f32, color: Color) void;
+pub extern fn DrawPolyLinesEx(center: Vector2, sides: c_int, radius: f32, rotation: f32, lineThick: f32, color: Color) void;
+pub extern fn CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle) bool;
+pub extern fn CheckCollisionCircles(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32) bool;
+pub extern fn CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle) bool;
+pub extern fn CheckCollisionPointRec(point: Vector2, rec: Rectangle) bool;
+pub extern fn CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32) bool;
+pub extern fn CheckCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) bool;
+pub extern fn CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: [*c]Vector2) bool;
+pub extern fn CheckCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: c_int) bool;
+pub extern fn GetCollisionRec(rec1: Rectangle, rec2: Rectangle) Rectangle;
+pub extern fn LoadImage(fileName: [*c]const u8) Image;
+pub extern fn LoadImageRaw(fileName: [*c]const u8, width: c_int, height: c_int, format: c_int, headerSize: c_int) Image;
+pub extern fn LoadImageAnim(fileName: [*c]const u8, frames: [*c]c_int) Image;
+pub extern fn LoadImageFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int) Image;
+pub extern fn LoadImageFromTexture(texture: Texture2D) Image;
+pub extern fn LoadImageFromScreen() Image;
+pub extern fn UnloadImage(image: Image) void;
+pub extern fn ExportImage(image: Image, fileName: [*c]const u8) bool;
+pub extern fn ExportImageAsCode(image: Image, fileName: [*c]const u8) bool;
+pub extern fn GenImageColor(width: c_int, height: c_int, color: Color) Image;
+pub extern fn GenImageGradientV(width: c_int, height: c_int, top: Color, bottom: Color) Image;
+pub extern fn GenImageGradientH(width: c_int, height: c_int, left: Color, right: Color) Image;
+pub extern fn GenImageGradientRadial(width: c_int, height: c_int, density: f32, inner: Color, outer: Color) Image;
+pub extern fn GenImageChecked(width: c_int, height: c_int, checksX: c_int, checksY: c_int, col1: Color, col2: Color) Image;
+pub extern fn GenImageWhiteNoise(width: c_int, height: c_int, factor: f32) Image;
+pub extern fn GenImageCellular(width: c_int, height: c_int, tileSize: c_int) Image;
+pub extern fn ImageCopy(image: Image) Image;
+pub extern fn ImageFromImage(image: Image, rec: Rectangle) Image;
+pub extern fn ImageText(text: [*c]const u8, fontSize: c_int, color: Color) Image;
+pub extern fn ImageTextEx(font: Font, text: [*c]const u8, fontSize: f32, spacing: f32, tint: Color) Image;
+pub extern fn ImageFormat(image: [*c]Image, newFormat: c_int) void;
+pub extern fn ImageToPOT(image: [*c]Image, fill: Color) void;
+pub extern fn ImageCrop(image: [*c]Image, crop: Rectangle) void;
+pub extern fn ImageAlphaCrop(image: [*c]Image, threshold: f32) void;
+pub extern fn ImageAlphaClear(image: [*c]Image, color: Color, threshold: f32) void;
+pub extern fn ImageAlphaMask(image: [*c]Image, alphaMask: Image) void;
+pub extern fn ImageAlphaPremultiply(image: [*c]Image) void;
+pub extern fn ImageResize(image: [*c]Image, newWidth: c_int, newHeight: c_int) void;
+pub extern fn ImageResizeNN(image: [*c]Image, newWidth: c_int, newHeight: c_int) void;
+pub extern fn ImageResizeCanvas(image: [*c]Image, newWidth: c_int, newHeight: c_int, offsetX: c_int, offsetY: c_int, fill: Color) void;
+pub extern fn ImageMipmaps(image: [*c]Image) void;
+pub extern fn ImageDither(image: [*c]Image, rBpp: c_int, gBpp: c_int, bBpp: c_int, aBpp: c_int) void;
+pub extern fn ImageFlipVertical(image: [*c]Image) void;
+pub extern fn ImageFlipHorizontal(image: [*c]Image) void;
+pub extern fn ImageRotateCW(image: [*c]Image) void;
+pub extern fn ImageRotateCCW(image: [*c]Image) void;
+pub extern fn ImageColorTint(image: [*c]Image, color: Color) void;
+pub extern fn ImageColorInvert(image: [*c]Image) void;
+pub extern fn ImageColorGrayscale(image: [*c]Image) void;
+pub extern fn ImageColorContrast(image: [*c]Image, contrast: f32) void;
+pub extern fn ImageColorBrightness(image: [*c]Image, brightness: c_int) void;
+pub extern fn ImageColorReplace(image: [*c]Image, color: Color, replace: Color) void;
+pub extern fn LoadImageColors(image: Image) [*c]Color;
+pub extern fn LoadImagePalette(image: Image, maxPaletteSize: c_int, colorCount: [*c]c_int) [*c]Color;
+pub extern fn UnloadImageColors(colors: [*c]Color) void;
+pub extern fn UnloadImagePalette(colors: [*c]Color) void;
+pub extern fn GetImageAlphaBorder(image: Image, threshold: f32) Rectangle;
+pub extern fn GetImageColor(image: Image, x: c_int, y: c_int) Color;
+pub extern fn ImageClearBackground(dst: [*c]Image, color: Color) void;
+pub extern fn ImageDrawPixel(dst: [*c]Image, posX: c_int, posY: c_int, color: Color) void;
+pub extern fn ImageDrawPixelV(dst: [*c]Image, position: Vector2, color: Color) void;
+pub extern fn ImageDrawLine(dst: [*c]Image, startPosX: c_int, startPosY: c_int, endPosX: c_int, endPosY: c_int, color: Color) void;
+pub extern fn ImageDrawLineV(dst: [*c]Image, start: Vector2, end: Vector2, color: Color) void;
+pub extern fn ImageDrawCircle(dst: [*c]Image, centerX: c_int, centerY: c_int, radius: c_int, color: Color) void;
+pub extern fn ImageDrawCircleV(dst: [*c]Image, center: Vector2, radius: c_int, color: Color) void;
+pub extern fn ImageDrawRectangle(dst: [*c]Image, posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void;
+pub extern fn ImageDrawRectangleV(dst: [*c]Image, position: Vector2, size: Vector2, color: Color) void;
+pub extern fn ImageDrawRectangleRec(dst: [*c]Image, rec: Rectangle, color: Color) void;
+pub extern fn ImageDrawRectangleLines(dst: [*c]Image, rec: Rectangle, thick: c_int, color: Color) void;
+pub extern fn ImageDraw(dst: [*c]Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color) void;
+pub extern fn ImageDrawText(dst: [*c]Image, text: [*c]const u8, posX: c_int, posY: c_int, fontSize: c_int, color: Color) void;
+pub extern fn ImageDrawTextEx(dst: [*c]Image, font: Font, text: [*c]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void;
+pub extern fn LoadTexture(fileName: [*c]const u8) Texture2D;
+pub extern fn LoadTextureFromImage(image: Image) Texture2D;
+pub extern fn LoadTextureCubemap(image: Image, layout: c_int) TextureCubemap;
+pub extern fn LoadRenderTexture(width: c_int, height: c_int) RenderTexture2D;
+pub extern fn UnloadTexture(texture: Texture2D) void;
+pub extern fn UnloadRenderTexture(target: RenderTexture2D) void;
+pub extern fn UpdateTexture(texture: Texture2D, pixels: ?*const anyopaque) void;
+pub extern fn UpdateTextureRec(texture: Texture2D, rec: Rectangle, pixels: ?*const anyopaque) void;
+pub extern fn GenTextureMipmaps(texture: [*c]Texture2D) void;
+pub extern fn SetTextureFilter(texture: Texture2D, filter: c_int) void;
+pub extern fn SetTextureWrap(texture: Texture2D, wrap: c_int) void;
+pub extern fn DrawTexture(texture: Texture2D, posX: c_int, posY: c_int, tint: Color) void;
+pub extern fn DrawTextureV(texture: Texture2D, position: Vector2, tint: Color) void;
+pub extern fn DrawTextureEx(texture: Texture2D, position: Vector2, rotation: f32, scale: f32, tint: Color) void;
+pub extern fn DrawTextureRec(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color) void;
+pub extern fn DrawTextureQuad(texture: Texture2D, tiling: Vector2, offset: Vector2, quad: Rectangle, tint: Color) void;
+pub extern fn DrawTextureTiled(texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: f32, scale: f32, tint: Color) void;
+pub extern fn DrawTexturePro(texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) void;
+pub extern fn DrawTextureNPatch(texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) void;
+pub extern fn DrawTexturePoly(texture: Texture2D, center: Vector2, points: [*c]Vector2, texcoords: [*c]Vector2, pointCount: c_int, tint: Color) void;
+pub extern fn Fade(color: Color, alpha: f32) Color;
+pub extern fn ColorToInt(color: Color) c_int;
+pub extern fn ColorNormalize(color: Color) Vector4;
+pub extern fn ColorFromNormalized(normalized: Vector4) Color;
+pub extern fn ColorToHSV(color: Color) Vector3;
+pub extern fn ColorFromHSV(hue: f32, saturation: f32, value: f32) Color;
+pub extern fn ColorAlpha(color: Color, alpha: f32) Color;
+pub extern fn ColorAlphaBlend(dst: Color, src: Color, tint: Color) Color;
+pub extern fn GetColor(hexValue: c_uint) Color;
+pub extern fn GetPixelColor(srcPtr: ?*anyopaque, format: c_int) Color;
+pub extern fn SetPixelColor(dstPtr: ?*anyopaque, color: Color, format: c_int) void;
+pub extern fn GetPixelDataSize(width: c_int, height: c_int, format: c_int) c_int;
+pub extern fn GetFontDefault() Font;
+pub extern fn LoadFont(fileName: [*c]const u8) Font;
+pub extern fn LoadFontEx(fileName: [*c]const u8, fontSize: c_int, fontChars: [*c]c_int, glyphCount: c_int) Font;
+pub extern fn LoadFontFromImage(image: Image, key: Color, firstChar: c_int) Font;
+pub extern fn LoadFontFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int, fontSize: c_int, fontChars: [*c]c_int, glyphCount: c_int) Font;
+pub extern fn LoadFontData(fileData: [*c]const u8, dataSize: c_int, fontSize: c_int, fontChars: [*c]c_int, glyphCount: c_int, @"type": c_int) [*c]GlyphInfo;
+pub extern fn GenImageFontAtlas(chars: [*c]const GlyphInfo, recs: [*c][*c]Rectangle, glyphCount: c_int, fontSize: c_int, padding: c_int, packMethod: c_int) Image;
+pub extern fn UnloadFontData(chars: [*c]GlyphInfo, glyphCount: c_int) void;
+pub extern fn UnloadFont(font: Font) void;
+pub extern fn ExportFontAsCode(font: Font, fileName: [*c]const u8) bool;
+pub extern fn DrawFPS(posX: c_int, posY: c_int) void;
+pub extern fn DrawText(text: [*c]const u8, posX: c_int, posY: c_int, fontSize: c_int, color: Color) void;
+pub extern fn DrawTextEx(font: Font, text: [*c]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void;
+pub extern fn DrawTextPro(font: Font, text: [*c]const u8, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color) void;
+pub extern fn DrawTextCodepoint(font: Font, codepoint: c_int, position: Vector2, fontSize: f32, tint: Color) void;
+pub extern fn DrawTextCodepoints(font: Font, codepoints: [*c]const c_int, count: c_int, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void;
+pub extern fn MeasureText(text: [*c]const u8, fontSize: c_int) c_int;
+pub extern fn MeasureTextEx(font: Font, text: [*c]const u8, fontSize: f32, spacing: f32) Vector2;
+pub extern fn GetGlyphIndex(font: Font, codepoint: c_int) c_int;
+pub extern fn GetGlyphInfo(font: Font, codepoint: c_int) GlyphInfo;
+pub extern fn GetGlyphAtlasRec(font: Font, codepoint: c_int) Rectangle;
+pub extern fn LoadCodepoints(text: [*c]const u8, count: [*c]c_int) [*c]c_int;
+pub extern fn UnloadCodepoints(codepoints: [*c]c_int) void;
+pub extern fn GetCodepointCount(text: [*c]const u8) c_int;
+pub extern fn GetCodepoint(text: [*c]const u8, bytesProcessed: [*c]c_int) c_int;
+pub extern fn CodepointToUTF8(codepoint: c_int, byteSize: [*c]c_int) [*c]const u8;
+pub extern fn TextCodepointsToUTF8(codepoints: [*c]const c_int, length: c_int) [*c]u8;
+pub extern fn TextCopy(dst: [*c]u8, src: [*c]const u8) c_int;
+pub extern fn TextIsEqual(text1: [*c]const u8, text2: [*c]const u8) bool;
+pub extern fn TextLength(text: [*c]const u8) c_uint;
+pub extern fn TextFormat(text: [*c]const u8, ...) [*c]const u8;
+pub extern fn TextSubtext(text: [*c]const u8, position: c_int, length: c_int) [*c]const u8;
+pub extern fn TextReplace(text: [*c]u8, replace: [*c]const u8, by: [*c]const u8) [*c]u8;
+pub extern fn TextInsert(text: [*c]const u8, insert: [*c]const u8, position: c_int) [*c]u8;
+pub extern fn TextJoin(textList: [*c][*c]const u8, count: c_int, delimiter: [*c]const u8) [*c]const u8;
+pub extern fn TextSplit(text: [*c]const u8, delimiter: u8, count: [*c]c_int) [*c][*c]const u8;
+pub extern fn TextAppend(text: [*c]u8, append: [*c]const u8, position: [*c]c_int) void;
+pub extern fn TextFindIndex(text: [*c]const u8, find: [*c]const u8) c_int;
+pub extern fn TextToUpper(text: [*c]const u8) [*c]const u8;
+pub extern fn TextToLower(text: [*c]const u8) [*c]const u8;
+pub extern fn TextToPascal(text: [*c]const u8) [*c]const u8;
+pub extern fn TextToInteger(text: [*c]const u8) c_int;
+pub extern fn DrawLine3D(startPos: Vector3, endPos: Vector3, color: Color) void;
+pub extern fn DrawPoint3D(position: Vector3, color: Color) void;
+pub extern fn DrawCircle3D(center: Vector3, radius: f32, rotationAxis: Vector3, rotationAngle: f32, color: Color) void;
+pub extern fn DrawTriangle3D(v1: Vector3, v2: Vector3, v3: Vector3, color: Color) void;
+pub extern fn DrawTriangleStrip3D(points: [*c]Vector3, pointCount: c_int, color: Color) void;
+pub extern fn DrawCube(position: Vector3, width: f32, height: f32, length: f32, color: Color) void;
+pub extern fn DrawCubeV(position: Vector3, size: Vector3, color: Color) void;
+pub extern fn DrawCubeWires(position: Vector3, width: f32, height: f32, length: f32, color: Color) void;
+pub extern fn DrawCubeWiresV(position: Vector3, size: Vector3, color: Color) void;
+pub extern fn DrawCubeTexture(texture: Texture2D, position: Vector3, width: f32, height: f32, length: f32, color: Color) void;
+pub extern fn DrawCubeTextureRec(texture: Texture2D, source: Rectangle, position: Vector3, width: f32, height: f32, length: f32, color: Color) void;
+pub extern fn DrawSphere(centerPos: Vector3, radius: f32, color: Color) void;
+pub extern fn DrawSphereEx(centerPos: Vector3, radius: f32, rings: c_int, slices: c_int, color: Color) void;
+pub extern fn DrawSphereWires(centerPos: Vector3, radius: f32, rings: c_int, slices: c_int, color: Color) void;
+pub extern fn DrawCylinder(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, slices: c_int, color: Color) void;
+pub extern fn DrawCylinderEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: c_int, color: Color) void;
+pub extern fn DrawCylinderWires(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, slices: c_int, color: Color) void;
+pub extern fn DrawCylinderWiresEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: c_int, color: Color) void;
+pub extern fn DrawPlane(centerPos: Vector3, size: Vector2, color: Color) void;
+pub extern fn DrawRay(ray: Ray, color: Color) void;
+pub extern fn DrawGrid(slices: c_int, spacing: f32) void;
+pub extern fn LoadModel(fileName: [*c]const u8) Model;
+pub extern fn LoadModelFromMesh(mesh: Mesh) Model;
+pub extern fn UnloadModel(model: Model) void;
+pub extern fn UnloadModelKeepMeshes(model: Model) void;
+pub extern fn GetModelBoundingBox(model: Model) BoundingBox;
+pub extern fn DrawModel(model: Model, position: Vector3, scale: f32, tint: Color) void;
+pub extern fn DrawModelEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) void;
+pub extern fn DrawModelWires(model: Model, position: Vector3, scale: f32, tint: Color) void;
+pub extern fn DrawModelWiresEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) void;
+pub extern fn DrawBoundingBox(box: BoundingBox, color: Color) void;
+pub extern fn DrawBillboard(camera: Camera, texture: Texture2D, position: Vector3, size: f32, tint: Color) void;
+pub extern fn DrawBillboardRec(camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, size: Vector2, tint: Color) void;
+pub extern fn DrawBillboardPro(camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: f32, tint: Color) void;
+pub extern fn UploadMesh(mesh: [*c]Mesh, dynamic: bool) void;
+pub extern fn UpdateMeshBuffer(mesh: Mesh, index: c_int, data: ?*const anyopaque, dataSize: c_int, offset: c_int) void;
+pub extern fn UnloadMesh(mesh: Mesh) void;
+pub extern fn DrawMesh(mesh: Mesh, material: Material, transform: Matrix) void;
+pub extern fn DrawMeshInstanced(mesh: Mesh, material: Material, transforms: [*c]const Matrix, instances: c_int) void;
+pub extern fn ExportMesh(mesh: Mesh, fileName: [*c]const u8) bool;
+pub extern fn GetMeshBoundingBox(mesh: Mesh) BoundingBox;
+pub extern fn GenMeshTangents(mesh: [*c]Mesh) void;
+pub extern fn GenMeshBinormals(mesh: [*c]Mesh) void;
+pub extern fn GenMeshPoly(sides: c_int, radius: f32) Mesh;
+pub extern fn GenMeshPlane(width: f32, length: f32, resX: c_int, resZ: c_int) Mesh;
+pub extern fn GenMeshCube(width: f32, height: f32, length: f32) Mesh;
+pub extern fn GenMeshSphere(radius: f32, rings: c_int, slices: c_int) Mesh;
+pub extern fn GenMeshHemiSphere(radius: f32, rings: c_int, slices: c_int) Mesh;
+pub extern fn GenMeshCylinder(radius: f32, height: f32, slices: c_int) Mesh;
+pub extern fn GenMeshCone(radius: f32, height: f32, slices: c_int) Mesh;
+pub extern fn GenMeshTorus(radius: f32, size: f32, radSeg: c_int, sides: c_int) Mesh;
+pub extern fn GenMeshKnot(radius: f32, size: f32, radSeg: c_int, sides: c_int) Mesh;
+pub extern fn GenMeshHeightmap(heightmap: Image, size: Vector3) Mesh;
+pub extern fn GenMeshCubicmap(cubicmap: Image, cubeSize: Vector3) Mesh;
+pub extern fn LoadMaterials(fileName: [*c]const u8, materialCount: [*c]c_int) [*c]Material;
+pub extern fn LoadMaterialDefault() Material;
+pub extern fn UnloadMaterial(material: Material) void;
+pub extern fn SetMaterialTexture(material: [*c]Material, mapType: c_int, texture: Texture2D) void;
+pub extern fn SetModelMeshMaterial(model: [*c]Model, meshId: c_int, materialId: c_int) void;
+pub extern fn LoadModelAnimations(fileName: [*c]const u8, animCount: [*c]c_uint) [*c]ModelAnimation;
+pub extern fn UpdateModelAnimation(model: Model, anim: ModelAnimation, frame: c_int) void;
+pub extern fn UnloadModelAnimation(anim: ModelAnimation) void;
+pub extern fn UnloadModelAnimations(animations: [*c]ModelAnimation, count: c_uint) void;
+pub extern fn IsModelAnimationValid(model: Model, anim: ModelAnimation) bool;
+pub extern fn CheckCollisionSpheres(center1: Vector3, radius1: f32, center2: Vector3, radius2: f32) bool;
+pub extern fn CheckCollisionBoxes(box1: BoundingBox, box2: BoundingBox) bool;
+pub extern fn CheckCollisionBoxSphere(box: BoundingBox, center: Vector3, radius: f32) bool;
+pub extern fn GetRayCollisionSphere(ray: Ray, center: Vector3, radius: f32) RayCollision;
+pub extern fn GetRayCollisionBox(ray: Ray, box: BoundingBox) RayCollision;
+pub extern fn GetRayCollisionMesh(ray: Ray, mesh: Mesh, transform: Matrix) RayCollision;
+pub extern fn GetRayCollisionTriangle(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3) RayCollision;
+pub extern fn GetRayCollisionQuad(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3) RayCollision;
+pub const AudioCallback = ?fn (?*anyopaque, c_uint) callconv(.C) void;
+pub extern fn InitAudioDevice() void;
+pub extern fn CloseAudioDevice() void;
+pub extern fn IsAudioDeviceReady() bool;
+pub extern fn SetMasterVolume(volume: f32) void;
+pub extern fn LoadWave(fileName: [*c]const u8) Wave;
+pub extern fn LoadWaveFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int) Wave;
+pub extern fn LoadSound(fileName: [*c]const u8) Sound;
+pub extern fn LoadSoundFromWave(wave: Wave) Sound;
+pub extern fn UpdateSound(sound: Sound, data: ?*const anyopaque, sampleCount: c_int) void;
+pub extern fn UnloadWave(wave: Wave) void;
+pub extern fn UnloadSound(sound: Sound) void;
+pub extern fn ExportWave(wave: Wave, fileName: [*c]const u8) bool;
+pub extern fn ExportWaveAsCode(wave: Wave, fileName: [*c]const u8) bool;
+pub extern fn PlaySound(sound: Sound) void;
+pub extern fn StopSound(sound: Sound) void;
+pub extern fn PauseSound(sound: Sound) void;
+pub extern fn ResumeSound(sound: Sound) void;
+pub extern fn PlaySoundMulti(sound: Sound) void;
+pub extern fn StopSoundMulti() void;
+pub extern fn GetSoundsPlaying() c_int;
+pub extern fn IsSoundPlaying(sound: Sound) bool;
+pub extern fn SetSoundVolume(sound: Sound, volume: f32) void;
+pub extern fn SetSoundPitch(sound: Sound, pitch: f32) void;
+pub extern fn SetSoundPan(sound: Sound, pan: f32) void;
+pub extern fn WaveCopy(wave: Wave) Wave;
+pub extern fn WaveCrop(wave: [*c]Wave, initSample: c_int, finalSample: c_int) void;
+pub extern fn WaveFormat(wave: [*c]Wave, sampleRate: c_int, sampleSize: c_int, channels: c_int) void;
+pub extern fn LoadWaveSamples(wave: Wave) [*c]f32;
+pub extern fn UnloadWaveSamples(samples: [*c]f32) void;
+pub extern fn LoadMusicStream(fileName: [*c]const u8) Music;
+pub extern fn LoadMusicStreamFromMemory(fileType: [*c]const u8, data: [*c]const u8, dataSize: c_int) Music;
+pub extern fn UnloadMusicStream(music: Music) void;
+pub extern fn PlayMusicStream(music: Music) void;
+pub extern fn IsMusicStreamPlaying(music: Music) bool;
+pub extern fn UpdateMusicStream(music: Music) void;
+pub extern fn StopMusicStream(music: Music) void;
+pub extern fn PauseMusicStream(music: Music) void;
+pub extern fn ResumeMusicStream(music: Music) void;
+pub extern fn SeekMusicStream(music: Music, position: f32) void;
+pub extern fn SetMusicVolume(music: Music, volume: f32) void;
+pub extern fn SetMusicPitch(music: Music, pitch: f32) void;
+pub extern fn SetMusicPan(music: Music, pan: f32) void;
+pub extern fn GetMusicTimeLength(music: Music) f32;
+pub extern fn GetMusicTimePlayed(music: Music) f32;
+pub extern fn LoadAudioStream(sampleRate: c_uint, sampleSize: c_uint, channels: c_uint) AudioStream;
+pub extern fn UnloadAudioStream(stream: AudioStream) void;
+pub extern fn UpdateAudioStream(stream: AudioStream, data: ?*const anyopaque, frameCount: c_int) void;
+pub extern fn IsAudioStreamProcessed(stream: AudioStream) bool;
+pub extern fn PlayAudioStream(stream: AudioStream) void;
+pub extern fn PauseAudioStream(stream: AudioStream) void;
+pub extern fn ResumeAudioStream(stream: AudioStream) void;
+pub extern fn IsAudioStreamPlaying(stream: AudioStream) bool;
+pub extern fn StopAudioStream(stream: AudioStream) void;
+pub extern fn SetAudioStreamVolume(stream: AudioStream, volume: f32) void;
+pub extern fn SetAudioStreamPitch(stream: AudioStream, pitch: f32) void;
+pub extern fn SetAudioStreamPan(stream: AudioStream, pan: f32) void;
+pub extern fn SetAudioStreamBufferSizeDefault(size: c_int) void;
+pub extern fn SetAudioStreamCallback(stream: AudioStream, callback: AudioCallback) void;
+pub extern fn AttachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void;
+pub extern fn DetachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void;
+pub const struct_GuiStyleProp = extern struct {
+ controlId: c_ushort,
+ propertyId: c_ushort,
+ propertyValue: c_int,
+};
+pub const GuiStyleProp = struct_GuiStyleProp;
+pub const GUI_STATE_NORMAL: c_int = 0;
+pub const GUI_STATE_FOCUSED: c_int = 1;
+pub const GUI_STATE_PRESSED: c_int = 2;
+pub const GUI_STATE_DISABLED: c_int = 3;
+pub const GuiControlState = c_uint;
+pub const GUI_TEXT_ALIGN_LEFT: c_int = 0;
+pub const GUI_TEXT_ALIGN_CENTER: c_int = 1;
+pub const GUI_TEXT_ALIGN_RIGHT: c_int = 2;
+pub const GuiTextAlignment = c_uint;
+pub const DEFAULT: c_int = 0;
+pub const LABEL: c_int = 1;
+pub const BUTTON: c_int = 2;
+pub const TOGGLE: c_int = 3;
+pub const SLIDER: c_int = 4;
+pub const PROGRESSBAR: c_int = 5;
+pub const CHECKBOX: c_int = 6;
+pub const COMBOBOX: c_int = 7;
+pub const DROPDOWNBOX: c_int = 8;
+pub const TEXTBOX: c_int = 9;
+pub const VALUEBOX: c_int = 10;
+pub const SPINNER: c_int = 11;
+pub const LISTVIEW: c_int = 12;
+pub const COLORPICKER: c_int = 13;
+pub const SCROLLBAR: c_int = 14;
+pub const STATUSBAR: c_int = 15;
+pub const GuiControl = c_uint;
+pub const BORDER_COLOR_NORMAL: c_int = 0;
+pub const BASE_COLOR_NORMAL: c_int = 1;
+pub const TEXT_COLOR_NORMAL: c_int = 2;
+pub const BORDER_COLOR_FOCUSED: c_int = 3;
+pub const BASE_COLOR_FOCUSED: c_int = 4;
+pub const TEXT_COLOR_FOCUSED: c_int = 5;
+pub const BORDER_COLOR_PRESSED: c_int = 6;
+pub const BASE_COLOR_PRESSED: c_int = 7;
+pub const TEXT_COLOR_PRESSED: c_int = 8;
+pub const BORDER_COLOR_DISABLED: c_int = 9;
+pub const BASE_COLOR_DISABLED: c_int = 10;
+pub const TEXT_COLOR_DISABLED: c_int = 11;
+pub const BORDER_WIDTH: c_int = 12;
+pub const TEXT_PADDING: c_int = 13;
+pub const TEXT_ALIGNMENT: c_int = 14;
+pub const RESERVED: c_int = 15;
+pub const GuiControlProperty = c_uint;
+pub const TEXT_SIZE: c_int = 16;
+pub const TEXT_SPACING: c_int = 17;
+pub const LINE_COLOR: c_int = 18;
+pub const BACKGROUND_COLOR: c_int = 19;
+pub const GuiDefaultProperty = c_uint;
+pub const GROUP_PADDING: c_int = 16;
+pub const GuiToggleProperty = c_uint;
+pub const SLIDER_WIDTH: c_int = 16;
+pub const SLIDER_PADDING: c_int = 17;
+pub const GuiSliderProperty = c_uint;
+pub const PROGRESS_PADDING: c_int = 16;
+pub const GuiProgressBarProperty = c_uint;
+pub const CHECK_PADDING: c_int = 16;
+pub const GuiCheckBoxProperty = c_uint;
+pub const COMBO_BUTTON_WIDTH: c_int = 16;
+pub const COMBO_BUTTON_PADDING: c_int = 17;
+pub const GuiComboBoxProperty = c_uint;
+pub const ARROW_PADDING: c_int = 16;
+pub const DROPDOWN_ITEMS_PADDING: c_int = 17;
+pub const GuiDropdownBoxProperty = c_uint;
+pub const TEXT_INNER_PADDING: c_int = 16;
+pub const TEXT_LINES_PADDING: c_int = 17;
+pub const COLOR_SELECTED_FG: c_int = 18;
+pub const COLOR_SELECTED_BG: c_int = 19;
+pub const GuiTextBoxProperty = c_uint;
+pub const SPIN_BUTTON_WIDTH: c_int = 16;
+pub const SPIN_BUTTON_PADDING: c_int = 17;
+pub const GuiSpinnerProperty = c_uint;
+pub const ARROWS_SIZE: c_int = 16;
+pub const ARROWS_VISIBLE: c_int = 17;
+pub const SCROLL_SLIDER_PADDING: c_int = 18;
+pub const SCROLL_SLIDER_SIZE: c_int = 19;
+pub const SCROLL_PADDING: c_int = 20;
+pub const SCROLL_SPEED: c_int = 21;
+pub const GuiScrollBarProperty = c_uint;
+pub const SCROLLBAR_LEFT_SIDE: c_int = 0;
+pub const SCROLLBAR_RIGHT_SIDE: c_int = 1;
+pub const GuiScrollBarSide = c_uint;
+pub const LIST_ITEMS_HEIGHT: c_int = 16;
+pub const LIST_ITEMS_PADDING: c_int = 17;
+pub const SCROLLBAR_WIDTH: c_int = 18;
+pub const SCROLLBAR_SIDE: c_int = 19;
+pub const GuiListViewProperty = c_uint;
+pub const COLOR_SELECTOR_SIZE: c_int = 16;
+pub const HUEBAR_WIDTH: c_int = 17;
+pub const HUEBAR_PADDING: c_int = 18;
+pub const HUEBAR_SELECTOR_HEIGHT: c_int = 19;
+pub const HUEBAR_SELECTOR_OVERFLOW: c_int = 20;
+pub const GuiColorPickerProperty = c_uint;
+pub export fn GuiEnable() void {
+ guiState = @bitCast(c_uint, GUI_STATE_NORMAL);
+}
+pub export fn GuiDisable() void {
+ guiState = @bitCast(c_uint, GUI_STATE_DISABLED);
+}
+pub export fn GuiLock() void {
+ guiLocked = @as(c_int, 1) != 0;
+}
+pub export fn GuiUnlock() void {
+ guiLocked = @as(c_int, 0) != 0;
+}
+pub export fn GuiIsLocked() bool {
+ return guiLocked;
+}
+pub export fn GuiFade(arg_alpha: f32) void {
+ var alpha = arg_alpha;
+ if (alpha < 0.0) {
+ alpha = 0.0;
+ } else if (alpha > 1.0) {
+ alpha = 1.0;
+ }
+ guiAlpha = alpha;
+}
+pub export fn GuiSetState(arg_state: c_int) void {
+ var state = arg_state;
+ guiState = @bitCast(c_uint, state);
+}
+pub export fn GuiGetState() c_int {
+ return @bitCast(c_int, guiState);
+}
+pub export fn GuiSetFont(arg_font: Font) void {
+ var font = arg_font;
+ if (font.texture.id > @bitCast(c_uint, @as(c_int, 0))) {
+ if (!guiStyleLoaded) {
+ GuiLoadStyleDefault();
+ }
+ guiFont = font;
+ GuiSetStyle(DEFAULT, TEXT_SIZE, font.baseSize);
+ }
+}
+pub export fn GuiGetFont() Font {
+ return guiFont;
+}
+pub export fn GuiSetStyle(arg_control: c_int, arg_property: c_int, arg_value: c_int) void {
+ var control = arg_control;
+ var property = arg_property;
+ var value = arg_value;
+ if (!guiStyleLoaded) {
+ GuiLoadStyleDefault();
+ }
+ guiStyle[@intCast(c_uint, (control * (@as(c_int, 16) + @as(c_int, 8))) + property)] = @bitCast(c_uint, value);
+ if ((control == @as(c_int, 0)) and (property < @as(c_int, 16))) {
+ {
+ var i: c_int = 1;
+ while (i < @as(c_int, 16)) : (i += 1) {
+ guiStyle[@intCast(c_uint, (i * (@as(c_int, 16) + @as(c_int, 8))) + property)] = @bitCast(c_uint, value);
+ }
+ }
+ }
+}
+pub export fn GuiGetStyle(arg_control: c_int, arg_property: c_int) c_int {
+ var control = arg_control;
+ var property = arg_property;
+ if (!guiStyleLoaded) {
+ GuiLoadStyleDefault();
+ }
+ return @bitCast(c_int, guiStyle[@intCast(c_uint, (control * (@as(c_int, 16) + @as(c_int, 8))) + property)]);
+}
+pub export fn GuiWindowBox(arg_bounds: Rectangle, arg_title: [*c]const u8) bool {
+ var bounds = arg_bounds;
+ var title = arg_title;
+ var clicked: bool = @as(c_int, 0) != 0;
+ var statusBarHeight: c_int = @as(c_int, 22) + (@as(c_int, 2) * GuiGetStyle(STATUSBAR, BORDER_WIDTH));
+ statusBarHeight += @import("std").zig.c_translation.signedRemainder(statusBarHeight, @as(c_int, 2));
+ var statusBar: Rectangle = Rectangle{
+ .x = bounds.x,
+ .y = bounds.y,
+ .width = bounds.width,
+ .height = @intToFloat(f32, statusBarHeight),
+ };
+ if (bounds.height < (@intToFloat(f32, statusBarHeight) * 2.0)) {
+ bounds.height = @intToFloat(f32, statusBarHeight) * 2.0;
+ }
+ var windowPanel: Rectangle = Rectangle{
+ .x = bounds.x,
+ .y = (bounds.y + @intToFloat(f32, statusBarHeight)) - @intToFloat(f32, @as(c_int, 1)),
+ .width = bounds.width,
+ .height = bounds.height - @intToFloat(f32, statusBarHeight),
+ };
+ var closeButtonRec: Rectangle = Rectangle{
+ .x = ((statusBar.x + statusBar.width) - @intToFloat(f32, GuiGetStyle(STATUSBAR, BORDER_WIDTH))) - @intToFloat(f32, @as(c_int, 20)),
+ .y = (statusBar.y + (@intToFloat(f32, statusBarHeight) / 2.0)) - (18.0 / 2.0),
+ .width = @intToFloat(f32, @as(c_int, 18)),
+ .height = @intToFloat(f32, @as(c_int, 18)),
+ };
+ GuiStatusBar(statusBar, title);
+ GuiPanel(windowPanel);
+ var tempBorderWidth: c_int = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ var tempTextAlignment: c_int = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, @as(c_int, 1));
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ clicked = GuiButton(closeButtonRec, GuiIconText(RICON_CROSS_SMALL, null));
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment);
+ return clicked;
+}
+pub export fn GuiGroupBox(arg_bounds: Rectangle, arg_text: [*c]const u8) void {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ GuiDrawRectangle(Rectangle{
+ .x = bounds.x,
+ .y = bounds.y,
+ .width = @intToFloat(f32, @as(c_int, 1)),
+ .height = bounds.height,
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_DISABLED else LINE_COLOR))), guiAlpha));
+ GuiDrawRectangle(Rectangle{
+ .x = bounds.x,
+ .y = (bounds.y + bounds.height) - @intToFloat(f32, @as(c_int, 1)),
+ .width = bounds.width,
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_DISABLED else LINE_COLOR))), guiAlpha));
+ GuiDrawRectangle(Rectangle{
+ .x = (bounds.x + bounds.width) - @intToFloat(f32, @as(c_int, 1)),
+ .y = bounds.y,
+ .width = @intToFloat(f32, @as(c_int, 1)),
+ .height = bounds.height,
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_DISABLED else LINE_COLOR))), guiAlpha));
+ GuiLine(Rectangle{
+ .x = bounds.x,
+ .y = bounds.y,
+ .width = bounds.width,
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ }, text);
+}
+pub export fn GuiLine(arg_bounds: Rectangle, arg_text: [*c]const u8) void {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ var color: Color = Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_DISABLED else LINE_COLOR))), guiAlpha);
+ if (text == @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ GuiDrawRectangle(Rectangle{
+ .x = bounds.x,
+ .y = bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2))),
+ .width = bounds.width,
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, color);
+ } else {
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.width = @intToFloat(f32, GetTextWidth(text));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = bounds.x + @intToFloat(f32, @as(c_int, 10));
+ textBounds.y = bounds.y - (@intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)) / @intToFloat(f32, @as(c_int, 2)));
+ GuiDrawRectangle(Rectangle{
+ .x = bounds.x,
+ .y = bounds.y,
+ .width = @intToFloat(f32, @as(c_int, 10) - @as(c_int, 2)),
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, color);
+ GuiLabel(textBounds, text);
+ GuiDrawRectangle(Rectangle{
+ .x = ((bounds.x + @intToFloat(f32, @as(c_int, 10))) + textBounds.width) + @intToFloat(f32, @as(c_int, 4)),
+ .y = bounds.y,
+ .width = ((bounds.width - textBounds.width) - @intToFloat(f32, @as(c_int, 10))) - @intToFloat(f32, @as(c_int, 4)),
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ }, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, color);
+ }
+}
+pub export fn GuiPanel(arg_bounds: Rectangle) void {
+ var bounds = arg_bounds;
+ var state: GuiControlState = guiState;
+ GuiDrawRectangle(bounds, @as(c_int, 1), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_DISABLED else LINE_COLOR))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) BASE_COLOR_DISABLED else BACKGROUND_COLOR))), guiAlpha));
+}
+pub export fn GuiScrollPanel(arg_bounds: Rectangle, arg_content: Rectangle, arg_scroll: [*c]Vector2) Rectangle {
+ var bounds = arg_bounds;
+ var content = arg_content;
+ var scroll = arg_scroll;
+ var state: GuiControlState = guiState;
+ var scrollPos: Vector2 = Vector2{
+ .x = 0.0,
+ .y = 0.0,
+ };
+ if (scroll != @ptrCast([*c]Vector2, @alignCast(@import("std").meta.alignment(Vector2), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ scrollPos = scroll.*;
+ }
+ var hasHorizontalScrollBar: bool = (if (content.width > (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH)))) @as(c_int, 1) else @as(c_int, 0)) != 0;
+ var hasVerticalScrollBar: bool = (if (content.height > (bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH)))) @as(c_int, 1) else @as(c_int, 0)) != 0;
+ if (!hasHorizontalScrollBar) {
+ hasHorizontalScrollBar = (if ((@as(c_int, @boolToInt(hasVerticalScrollBar)) != 0) and (content.width > ((bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))) @as(c_int, 1) else @as(c_int, 0)) != 0;
+ }
+ if (!hasVerticalScrollBar) {
+ hasVerticalScrollBar = (if ((@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) and (content.height > ((bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))) @as(c_int, 1) else @as(c_int, 0)) != 0;
+ }
+ const horizontalScrollBarWidth: c_int = if (@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) else @as(c_int, 0);
+ const verticalScrollBarWidth: c_int = if (@as(c_int, @boolToInt(hasVerticalScrollBar)) != 0) GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) else @as(c_int, 0);
+ const horizontalScrollBar: Rectangle = Rectangle{
+ .x = (if (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) bounds.x + @intToFloat(f32, verticalScrollBarWidth) else bounds.x) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .y = ((bounds.y + bounds.height) - @intToFloat(f32, horizontalScrollBarWidth)) - @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .width = (bounds.width - @intToFloat(f32, verticalScrollBarWidth)) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .height = @intToFloat(f32, horizontalScrollBarWidth),
+ };
+ const verticalScrollBar: Rectangle = Rectangle{
+ .x = if (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) bounds.x + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)) else ((bounds.x + bounds.width) - @intToFloat(f32, verticalScrollBarWidth)) - @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .width = @intToFloat(f32, verticalScrollBarWidth),
+ .height = (bounds.height - @intToFloat(f32, horizontalScrollBarWidth)) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ };
+ var view: Rectangle = if (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) Rectangle{
+ .x = (bounds.x + @intToFloat(f32, verticalScrollBarWidth)) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .width = (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, verticalScrollBarWidth),
+ .height = (bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, horizontalScrollBarWidth),
+ } else Rectangle{
+ .x = bounds.x + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ .width = (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, verticalScrollBarWidth),
+ .height = (bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, horizontalScrollBarWidth),
+ };
+ if (view.width > content.width) {
+ view.width = content.width;
+ }
+ if (view.height > content.height) {
+ view.height = content.height;
+ }
+ const horizontalMin: f32 = if (@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) (if (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) @intToFloat(f32, -verticalScrollBarWidth) else @intToFloat(f32, @as(c_int, 0))) - @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)) else (if (@intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE)) == @intToFloat(f32, SCROLLBAR_LEFT_SIDE)) @intToFloat(f32, -verticalScrollBarWidth) else @intToFloat(f32, @as(c_int, 0))) - @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ const horizontalMax: f32 = if (@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) (((content.width - bounds.width) + @intToFloat(f32, verticalScrollBarWidth)) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH))) - (if (@intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE)) == @intToFloat(f32, SCROLLBAR_LEFT_SIDE)) @intToFloat(f32, verticalScrollBarWidth) else @intToFloat(f32, @as(c_int, 0))) else @intToFloat(f32, -GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ const verticalMin: f32 = if (@as(c_int, @boolToInt(hasVerticalScrollBar)) != 0) @intToFloat(f32, -GuiGetStyle(DEFAULT, BORDER_WIDTH)) else @intToFloat(f32, -GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ const verticalMax: f32 = if (@as(c_int, @boolToInt(hasVerticalScrollBar)) != 0) ((content.height - bounds.height) + @intToFloat(f32, horizontalScrollBarWidth)) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH)) else @intToFloat(f32, -GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ if (hasHorizontalScrollBar) {
+ if (IsKeyDown(KEY_RIGHT)) {
+ scrollPos.x -= @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ }
+ if (IsKeyDown(KEY_LEFT)) {
+ scrollPos.x += @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ }
+ }
+ if (hasVerticalScrollBar) {
+ if (IsKeyDown(KEY_DOWN)) {
+ scrollPos.y -= @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ }
+ if (IsKeyDown(KEY_UP)) {
+ scrollPos.y += @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ }
+ }
+ var wheelMove: f32 = GetMouseWheelMove();
+ if ((@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) and ((@as(c_int, @boolToInt(IsKeyDown(KEY_LEFT_SHIFT))) != 0) or (@as(c_int, @boolToInt(IsKeyDown(KEY_RIGHT_SHIFT))) != 0))) {
+ scrollPos.x += wheelMove * @intToFloat(f32, @as(c_int, 20));
+ } else {
+ scrollPos.y += wheelMove * @intToFloat(f32, @as(c_int, 20));
+ }
+ }
+ }
+ if (scrollPos.x > -horizontalMin) {
+ scrollPos.x = -horizontalMin;
+ }
+ if (scrollPos.x < -horizontalMax) {
+ scrollPos.x = -horizontalMax;
+ }
+ if (scrollPos.y > -verticalMin) {
+ scrollPos.y = -verticalMin;
+ }
+ if (scrollPos.y < -verticalMax) {
+ scrollPos.y = -verticalMax;
+ }
+ GuiDrawRectangle(bounds, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, BACKGROUND_COLOR))));
+ const slider: c_int = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE);
+ if (hasHorizontalScrollBar) {
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, @floatToInt(c_int, (((bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, verticalScrollBarWidth)) / @intToFloat(f32, @floatToInt(c_int, content.width))) * @intToFloat(f32, (@floatToInt(c_int, bounds.width) - (@as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - verticalScrollBarWidth)));
+ scrollPos.x = @intToFloat(f32, -GuiScrollBar(horizontalScrollBar, @floatToInt(c_int, -scrollPos.x), @floatToInt(c_int, horizontalMin), @floatToInt(c_int, horizontalMax)));
+ }
+ if (hasVerticalScrollBar) {
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, @floatToInt(c_int, (((bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - @intToFloat(f32, horizontalScrollBarWidth)) / @intToFloat(f32, @floatToInt(c_int, content.height))) * @intToFloat(f32, (@floatToInt(c_int, bounds.height) - (@as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH))) - horizontalScrollBarWidth)));
+ scrollPos.y = @intToFloat(f32, -GuiScrollBar(verticalScrollBar, @floatToInt(c_int, -scrollPos.y), @floatToInt(c_int, verticalMin), @floatToInt(c_int, verticalMax)));
+ }
+ if ((@as(c_int, @boolToInt(hasHorizontalScrollBar)) != 0) and (@as(c_int, @boolToInt(hasVerticalScrollBar)) != 0)) {
+ var corner: Rectangle = Rectangle{
+ .x = if (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE) (bounds.x + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH))) + @intToFloat(f32, @as(c_int, 2)) else (horizontalScrollBar.x + horizontalScrollBar.width) + @intToFloat(f32, @as(c_int, 2)),
+ .y = (verticalScrollBar.y + verticalScrollBar.height) + @intToFloat(f32, @as(c_int, 2)),
+ .width = @intToFloat(f32, horizontalScrollBarWidth) - @intToFloat(f32, @as(c_int, 4)),
+ .height = @intToFloat(f32, verticalScrollBarWidth) - @intToFloat(f32, @as(c_int, 4)),
+ };
+ GuiDrawRectangle(corner, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider);
+ if (scroll != @ptrCast([*c]Vector2, @alignCast(@import("std").meta.alignment(Vector2), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ scroll.* = scrollPos;
+ }
+ return view;
+}
+pub export fn GuiLabel(arg_bounds: Rectangle, arg_text: [*c]const u8) void {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LABEL, if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) TEXT_COLOR_DISABLED else TEXT_COLOR_NORMAL))), guiAlpha));
+}
+pub export fn GuiButton(arg_bounds: Rectangle, arg_text: [*c]const u8) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(BUTTON, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(BUTTON, @bitCast(c_int, @bitCast(c_uint, BASE) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(BUTTON, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return pressed;
+}
+pub export fn GuiLabelButton(arg_bounds: Rectangle, arg_text: [*c]const u8) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ var textWidth: f32 = MeasureTextEx(guiFont, text, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SPACING))).x;
+ if (bounds.width < textWidth) {
+ bounds.width = textWidth;
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LABEL, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return pressed;
+}
+pub export fn GuiToggle(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_active: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var active = arg_active;
+ var state: GuiControlState = guiState;
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_NORMAL);
+ active = !active;
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ if (state == @bitCast(c_uint, GUI_STATE_NORMAL)) {
+ GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, if (@as(c_int, @boolToInt(active)) != 0) @bitCast(c_uint, BORDER_COLOR_PRESSED) else @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, if (@as(c_int, @boolToInt(active)) != 0) @bitCast(c_uint, BASE_COLOR_PRESSED) else @bitCast(c_uint, BASE) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, if (@as(c_int, @boolToInt(active)) != 0) @bitCast(c_uint, TEXT_COLOR_PRESSED) else @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ } else {
+ GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, @bitCast(c_uint, BASE) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TOGGLE, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ return active;
+}
+pub export fn GuiToggleGroup(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_active: c_int) c_int {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var active = arg_active;
+ var initBoundsX: f32 = bounds.x;
+ var rows: [32]c_int = [1]c_int{
+ 0,
+ } ++ [1]c_int{0} ** 31;
+ var itemCount: c_int = 0;
+ var items: [*c][*c]const u8 = GuiTextSplit(text, &itemCount, @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), &rows)));
+ var prevRow: c_int = rows[@intCast(c_uint, @as(c_int, 0))];
+ {
+ var i: c_int = 0;
+ while (i < itemCount) : (i += 1) {
+ if (prevRow != rows[@intCast(c_uint, i)]) {
+ bounds.x = initBoundsX;
+ bounds.y += bounds.height + @intToFloat(f32, GuiGetStyle(TOGGLE, GROUP_PADDING));
+ prevRow = rows[@intCast(c_uint, i)];
+ }
+ if (i == active) {
+ _ = GuiToggle(bounds, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, @as(c_int, 1) != 0);
+ } else if (@as(c_int, @boolToInt(GuiToggle(bounds, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, @as(c_int, 0) != 0))) == @as(c_int, 1)) {
+ active = i;
+ }
+ bounds.x += bounds.width + @intToFloat(f32, GuiGetStyle(TOGGLE, GROUP_PADDING));
+ }
+ }
+ return active;
+}
+pub export fn GuiCheckBox(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_checked: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var checked = arg_checked;
+ var state: GuiControlState = guiState;
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ if (text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ textBounds.width = @intToFloat(f32, GetTextWidth(text));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(CHECKBOX, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) {
+ textBounds.x = (bounds.x - textBounds.width) - @intToFloat(f32, GuiGetStyle(CHECKBOX, TEXT_PADDING));
+ }
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ var totalBounds: Rectangle = Rectangle{
+ .x = if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) textBounds.x else bounds.x,
+ .y = bounds.y,
+ .width = (bounds.width + textBounds.width) + @intToFloat(f32, GuiGetStyle(CHECKBOX, TEXT_PADDING)),
+ .height = bounds.height,
+ };
+ if (CheckCollisionPointRec(mousePoint, totalBounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+ checked = !checked;
+ }
+ }
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(CHECKBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ if (checked) {
+ var check: Rectangle = Rectangle{
+ .x = (bounds.x + @intToFloat(f32, GuiGetStyle(CHECKBOX, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(CHECKBOX, CHECK_PADDING)),
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(CHECKBOX, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(CHECKBOX, CHECK_PADDING)),
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING))),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING))),
+ };
+ GuiDrawRectangle(check, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(CHECKBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ GuiDrawText(text, textBounds, if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) GUI_TEXT_ALIGN_LEFT else GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LABEL, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return checked;
+}
+pub export fn GuiComboBox(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_active: c_int) c_int {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var active = arg_active;
+ var state: GuiControlState = guiState;
+ bounds.width -= @intToFloat(f32, GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING));
+ var selector: Rectangle = Rectangle{
+ .x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING)),
+ .y = bounds.y,
+ .width = @intToFloat(f32, GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH)),
+ .height = bounds.height,
+ };
+ var itemCount: c_int = 0;
+ var items: [*c][*c]const u8 = GuiTextSplit(text, &itemCount, null);
+ if (active < @as(c_int, 0)) {
+ active = 0;
+ } else if (active > (itemCount - @as(c_int, 1))) {
+ active = itemCount - @as(c_int, 1);
+ }
+ if (((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) and (itemCount > @as(c_int, 1))) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if ((@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, bounds))) != 0) or (@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, selector))) != 0)) {
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ active += @as(c_int, 1);
+ if (active >= itemCount) {
+ active = 0;
+ }
+ }
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COMBOBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COMBOBOX, @bitCast(c_int, @bitCast(c_uint, BASE) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = active;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COMBOBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ var tempBorderWidth: c_int = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ var tempTextAlign: c_int = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, @as(c_int, 1));
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ _ = GuiButton(selector, TextFormat("%i/%i", active + @as(c_int, 1), itemCount));
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+ return active;
+}
+pub export fn GuiDropdownBox(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_active: [*c]c_int, arg_editMode: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var active = arg_active;
+ var editMode = arg_editMode;
+ var state: GuiControlState = guiState;
+ var itemSelected: c_int = active.*;
+ var itemFocused: c_int = -@as(c_int, 1);
+ var itemCount: c_int = 0;
+ var items: [*c][*c]const u8 = GuiTextSplit(text, &itemCount, null);
+ var boundsOpen: Rectangle = bounds;
+ boundsOpen.height = @intToFloat(f32, itemCount + @as(c_int, 1)) * (bounds.height + @intToFloat(f32, GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING)));
+ var itemBounds: Rectangle = bounds;
+ var pressed: bool = @as(c_int, 0) != 0;
+ if (((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and ((@as(c_int, @boolToInt(editMode)) != 0) or !guiLocked)) and (itemCount > @as(c_int, 1))) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (editMode) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ if (!CheckCollisionPointRec(mousePoint, boundsOpen)) {
+ if ((@as(c_int, @boolToInt(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))) != 0) or (@as(c_int, @boolToInt(IsMouseButtonReleased(MOUSE_BUTTON_LEFT))) != 0)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ if ((@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, bounds))) != 0) and (@as(c_int, @boolToInt(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))) != 0)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ {
+ var i: c_int = 0;
+ while (i < itemCount) : (i += 1) {
+ itemBounds.y += bounds.height + @intToFloat(f32, GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+ if (CheckCollisionPointRec(mousePoint, itemBounds)) {
+ itemFocused = i;
+ if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+ itemSelected = i;
+ pressed = @as(c_int, 1) != 0;
+ }
+ break;
+ }
+ }
+ }
+ itemBounds = bounds;
+ } else {
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ }
+ if (editMode) {
+ GuiPanel(boundsOpen);
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, @bitCast(c_int, @bitCast(c_uint, BASE) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = itemSelected;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ if (editMode) {
+ {
+ var i: c_int = 0;
+ while (i < itemCount) : (i += 1) {
+ itemBounds.y += bounds.height + @intToFloat(f32, GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+ if (i == itemSelected) {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED))), guiAlpha));
+ } else if (i == itemFocused) {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED))), guiAlpha));
+ } else {
+ GuiDrawText((blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk items + @intCast(usize, tmp) else break :blk items - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL))), guiAlpha));
+ }
+ }
+ }
+ }
+ GuiDrawText("#120#", Rectangle{
+ .x = (bounds.x + bounds.width) - @intToFloat(f32, GuiGetStyle(DROPDOWNBOX, ARROW_PADDING)),
+ .y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @as(c_int, 6)),
+ .width = @intToFloat(f32, @as(c_int, 10)),
+ .height = @intToFloat(f32, @as(c_int, 10)),
+ }, GUI_TEXT_ALIGN_CENTER, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DROPDOWNBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ active.* = itemSelected;
+ return pressed;
+}
+pub export fn GuiSpinner(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_value: [*c]c_int, arg_minValue: c_int, arg_maxValue: c_int, arg_editMode: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ var editMode = arg_editMode;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ var tempValue: c_int = value.*;
+ var spinner: Rectangle = Rectangle{
+ .x = (bounds.x + @intToFloat(f32, GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH))) + @intToFloat(f32, GuiGetStyle(SPINNER, SPIN_BUTTON_PADDING)),
+ .y = bounds.y,
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_PADDING))),
+ .height = bounds.height,
+ };
+ var leftButtonBound: Rectangle = Rectangle{
+ .x = bounds.x,
+ .y = bounds.y,
+ .width = @intToFloat(f32, GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH)),
+ .height = bounds.height,
+ };
+ var rightButtonBound: Rectangle = Rectangle{
+ .x = (bounds.x + bounds.width) - @intToFloat(f32, GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH)),
+ .y = bounds.y,
+ .width = @intToFloat(f32, GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH)),
+ .height = bounds.height,
+ };
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ if (text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ textBounds.width = @intToFloat(f32, GetTextWidth(text));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(SPINNER, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ if (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) {
+ textBounds.x = (bounds.x - textBounds.width) - @intToFloat(f32, GuiGetStyle(SPINNER, TEXT_PADDING));
+ }
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ if (!editMode) {
+ if (tempValue < minValue) {
+ tempValue = minValue;
+ }
+ if (tempValue > maxValue) {
+ tempValue = maxValue;
+ }
+ }
+ pressed = GuiValueBox(spinner, null, &tempValue, minValue, maxValue, editMode);
+ var tempBorderWidth: c_int = GuiGetStyle(BUTTON, BORDER_WIDTH);
+ var tempTextAlign: c_int = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH));
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ if (GuiButton(leftButtonBound, GuiIconText(RICON_ARROW_LEFT_FILL, null))) {
+ tempValue -= 1;
+ }
+ if (GuiButton(rightButtonBound, GuiIconText(RICON_ARROW_RIGHT_FILL, null))) {
+ tempValue += 1;
+ }
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
+ GuiDrawText(text, textBounds, if (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) GUI_TEXT_ALIGN_LEFT else GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LABEL, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ value.* = tempValue;
+ return pressed;
+}
+pub export fn GuiValueBox(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_value: [*c]c_int, arg_minValue: c_int, arg_maxValue: c_int, arg_editMode: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ var editMode = arg_editMode;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ var textValue: [33]u8 = "\x00"[0..1].* ++ [1]u8{0} ** 32;
+ _ = sprintf(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue)), "%i", value.*);
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ if (text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ textBounds.width = @intToFloat(f32, GetTextWidth(text));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(VALUEBOX, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ if (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT) {
+ textBounds.x = (bounds.x - textBounds.width) - @intToFloat(f32, GuiGetStyle(VALUEBOX, TEXT_PADDING));
+ }
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ var valueHasChanged: bool = @as(c_int, 0) != 0;
+ if (editMode) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ var keyCount: c_int = @bitCast(c_int, @truncate(c_uint, strlen(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue)))));
+ if (keyCount < @as(c_int, 32)) {
+ if (@intToFloat(f32, GetTextWidth(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue)))) < bounds.width) {
+ var key: c_int = GetCharPressed();
+ if ((key >= @as(c_int, 48)) and (key <= @as(c_int, 57))) {
+ textValue[@intCast(c_uint, keyCount)] = @bitCast(u8, @truncate(i8, key));
+ keyCount += 1;
+ valueHasChanged = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ if (keyCount > @as(c_int, 0)) {
+ if (IsKeyPressed(KEY_BACKSPACE)) {
+ keyCount -= 1;
+ textValue[@intCast(c_uint, keyCount)] = '\x00';
+ if (keyCount < @as(c_int, 0)) {
+ keyCount = 0;
+ }
+ valueHasChanged = @as(c_int, 1) != 0;
+ }
+ }
+ if (valueHasChanged) {
+ value.* = TextToInteger(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue)));
+ }
+ if ((@as(c_int, @boolToInt(IsKeyPressed(KEY_ENTER))) != 0) or (!CheckCollisionPointRec(mousePoint, bounds) and (@as(c_int, @boolToInt(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))) != 0))) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ } else {
+ if (value.* > maxValue) {
+ value.* = maxValue;
+ } else if (value.* < minValue) {
+ value.* = minValue;
+ }
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ }
+ var baseColor: Color = Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ };
+ if (state == @bitCast(c_uint, GUI_STATE_PRESSED)) {
+ baseColor = GetColor(@bitCast(c_uint, GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED)));
+ } else if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ baseColor = GetColor(@bitCast(c_uint, GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED)));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(VALUEBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), baseColor);
+ GuiDrawText(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue)), GetTextBounds(VALUEBOX, bounds), GUI_TEXT_ALIGN_CENTER, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(VALUEBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ if (editMode) {
+ var cursor: Rectangle = Rectangle{
+ .x = ((bounds.x + @intToFloat(f32, @divTrunc(GetTextWidth(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &textValue))), @as(c_int, 2)))) + (bounds.width / @intToFloat(f32, @as(c_int, 2)))) + @intToFloat(f32, @as(c_int, 2)),
+ .y = bounds.y + @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(VALUEBOX, BORDER_WIDTH)),
+ .width = @intToFloat(f32, @as(c_int, 4)),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 4) * GuiGetStyle(VALUEBOX, BORDER_WIDTH)),
+ };
+ GuiDrawRectangle(cursor, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED))), guiAlpha));
+ }
+ GuiDrawText(text, textBounds, if (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) GUI_TEXT_ALIGN_LEFT else GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LABEL, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return pressed;
+}
+pub export fn GuiTextBox(arg_bounds: Rectangle, arg_text: [*c]u8, arg_textSize: c_int, arg_editMode: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var textSize = arg_textSize;
+ var editMode = arg_editMode;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ var cursor: Rectangle = Rectangle{
+ .x = ((bounds.x + @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_PADDING))) + @intToFloat(f32, GetTextWidth(text))) + @intToFloat(f32, @as(c_int, 2)),
+ .y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)),
+ .width = @intToFloat(f32, @as(c_int, 4)),
+ .height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)) * @intToFloat(f32, @as(c_int, 2)),
+ };
+ if (cursor.height > bounds.height) {
+ cursor.height = bounds.height - @intToFloat(f32, GuiGetStyle(TEXTBOX, BORDER_WIDTH) * @as(c_int, 2));
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (editMode) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ var key: c_int = GetCharPressed();
+ var keyCount: c_int = @bitCast(c_int, @truncate(c_uint, strlen(text)));
+ if (keyCount < (textSize - @as(c_int, 1))) {
+ var maxWidth: f32 = bounds.width - @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING) * @as(c_int, 2));
+ if ((@intToFloat(f32, GetTextWidth(text)) < (maxWidth - @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)))) and (key >= @as(c_int, 32))) {
+ var byteSize: c_int = 0;
+ var textUTF8: [*c]const u8 = CodepointToUTF8(key, &byteSize);
+ {
+ var i: c_int = 0;
+ while (i < byteSize) : (i += 1) {
+ (blk: {
+ const tmp = keyCount;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk textUTF8 + @intCast(usize, tmp) else break :blk textUTF8 - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ keyCount += 1;
+ }
+ }
+ (blk: {
+ const tmp = keyCount;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = '\x00';
+ }
+ }
+ if (keyCount > @as(c_int, 0)) {
+ if (IsKeyPressed(KEY_BACKSPACE)) {
+ keyCount -= 1;
+ (blk: {
+ const tmp = keyCount;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = '\x00';
+ if (keyCount < @as(c_int, 0)) {
+ keyCount = 0;
+ }
+ }
+ }
+ if ((@as(c_int, @boolToInt(IsKeyPressed(KEY_ENTER))) != 0) or (!CheckCollisionPointRec(mousePoint, bounds) and (@as(c_int, @boolToInt(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))) != 0))) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ var textAlignment: c_int = GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT);
+ if (textAlignment == GUI_TEXT_ALIGN_CENTER) {
+ cursor.x = ((bounds.x + @intToFloat(f32, @divTrunc(GetTextWidth(text), @as(c_int, 2)))) + (bounds.width / @intToFloat(f32, @as(c_int, 2)))) + @intToFloat(f32, @as(c_int, 1));
+ } else if (textAlignment == GUI_TEXT_ALIGN_RIGHT) {
+ cursor.x = (bounds.x + bounds.width) - @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING));
+ }
+ } else {
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ }
+ if (state == @bitCast(c_uint, GUI_STATE_PRESSED)) {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))), guiAlpha));
+ } else if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))), guiAlpha));
+ } else {
+ GuiDrawRectangle(bounds, @as(c_int, 1), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ }
+ GuiDrawText(text, GetTextBounds(TEXTBOX, bounds), GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ if (editMode) {
+ GuiDrawRectangle(cursor, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))), guiAlpha));
+ }
+ return pressed;
+}
+pub export fn GuiTextBoxMulti(arg_bounds: Rectangle, arg_text: [*c]u8, arg_textSize: c_int, arg_editMode: bool) bool {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var textSize = arg_textSize;
+ var editMode = arg_editMode;
+ var state: GuiControlState = guiState;
+ var pressed: bool = @as(c_int, 0) != 0;
+ var textAreaBounds: Rectangle = Rectangle{
+ .x = (bounds.x + @intToFloat(f32, GuiGetStyle(TEXTBOX, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING)),
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(TEXTBOX, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING)),
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING))),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(TEXTBOX, BORDER_WIDTH) + GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING))),
+ };
+ var cursor: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = @intToFloat(f32, -@as(c_int, 1)),
+ .width = @intToFloat(f32, @as(c_int, 4)),
+ .height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)) + @intToFloat(f32, @as(c_int, 2)),
+ };
+ var scaleFactor: f32 = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)) / @intToFloat(f32, guiFont.baseSize);
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (editMode) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ var codepoint: c_int = GetCharPressed();
+ var textLength: c_int = @bitCast(c_int, @truncate(c_uint, strlen(text)));
+ if (textLength < (textSize - @as(c_int, 1))) {
+ if (IsKeyPressed(KEY_ENTER)) {
+ (blk: {
+ const tmp = textLength;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = '\n';
+ textLength += 1;
+ } else if (codepoint >= @as(c_int, 32)) {
+ var charUTF8Length: c_int = 0;
+ var charEncoded: [*c]const u8 = CodepointToUTF8(codepoint, &charUTF8Length);
+ _ = memcpy(@ptrCast(?*anyopaque, text + @bitCast(usize, @intCast(isize, textLength))), @ptrCast(?*const anyopaque, charEncoded), @bitCast(c_ulong, @as(c_long, charUTF8Length)));
+ textLength += charUTF8Length;
+ }
+ }
+ if (textLength > @as(c_int, 0)) {
+ if (IsKeyPressed(KEY_BACKSPACE)) {
+ if (@bitCast(c_int, @as(c_uint, @bitCast(u8, (blk: {
+ const tmp = textLength - @as(c_int, 1);
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*))) < @as(c_int, 127)) {
+ textLength -= 1;
+ (blk: {
+ const tmp = textLength;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = '\x00';
+ } else {
+ var charUTF8Length: c_int = 0;
+ while ((@bitCast(c_int, @as(c_uint, @bitCast(u8, (blk: {
+ const tmp = (textLength - @as(c_int, 1)) - charUTF8Length;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*))) & @as(c_int, 64)) == @as(c_int, 0)) {
+ charUTF8Length += 1;
+ }
+ textLength -= charUTF8Length + @as(c_int, 1);
+ (blk: {
+ const tmp = textLength;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = '\x00';
+ }
+ }
+ }
+ if (!CheckCollisionPointRec(mousePoint, bounds) and (@as(c_int, @boolToInt(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))) != 0)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ } else {
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ pressed = @as(c_int, 1) != 0;
+ }
+ }
+ }
+ }
+ if (state == @bitCast(c_uint, GUI_STATE_PRESSED)) {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))), guiAlpha));
+ } else if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))), guiAlpha));
+ } else {
+ GuiDrawRectangle(bounds, @as(c_int, 1), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ }
+ var wrapMode: c_int = 1;
+ var cursorPos: Vector2 = Vector2{
+ .x = textAreaBounds.x,
+ .y = textAreaBounds.y,
+ };
+ {
+ var i: c_int = 0;
+ var codepointLength: c_int = 0;
+ while (@bitCast(c_int, @as(c_uint, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) != @as(c_int, '\x00')) : (i += codepointLength) {
+ var codepoint: c_int = GetCodepoint(text + @bitCast(usize, @intCast(isize, i)), &codepointLength);
+ var index_1: c_int = GetGlyphIndex(guiFont, codepoint);
+ var atlasRec: Rectangle = (blk: {
+ const tmp = index_1;
+ if (tmp >= 0) break :blk guiFont.recs + @intCast(usize, tmp) else break :blk guiFont.recs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ var glyphInfo: GlyphInfo = (blk: {
+ const tmp = index_1;
+ if (tmp >= 0) break :blk guiFont.glyphs + @intCast(usize, tmp) else break :blk guiFont.glyphs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ if ((codepointLength == @as(c_int, 1)) and (codepoint == @as(c_int, '\n'))) {
+ cursorPos.y += (@intToFloat(f32, guiFont.baseSize) * scaleFactor) + @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_LINES_PADDING));
+ cursorPos.x = textAreaBounds.x;
+ } else {
+ if (wrapMode == @as(c_int, 1)) {
+ var glyphWidth: c_int = 0;
+ if (glyphInfo.advanceX != @as(c_int, 0)) {
+ glyphWidth += glyphInfo.advanceX;
+ } else {
+ glyphWidth += @floatToInt(i32, atlasRec.width + @intToFloat(f32, glyphInfo.offsetX));
+ }
+ if ((cursorPos.x + (@intToFloat(f32, glyphWidth) * scaleFactor)) > (textAreaBounds.x + textAreaBounds.width)) {
+ cursorPos.y += (@intToFloat(f32, guiFont.baseSize) * scaleFactor) + @intToFloat(f32, GuiGetStyle(TEXTBOX, TEXT_LINES_PADDING));
+ cursorPos.x = textAreaBounds.x;
+ }
+ } else if (wrapMode == @as(c_int, 2)) {}
+ DrawTextCodepoint(guiFont, codepoint, cursorPos, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ var glyphWidth: c_int = 0;
+ if (glyphInfo.advanceX != @as(c_int, 0)) {
+ glyphWidth += glyphInfo.advanceX;
+ } else {
+ glyphWidth += @floatToInt(i32, atlasRec.width + @intToFloat(f32, glyphInfo.offsetX));
+ }
+ cursorPos.x += (@intToFloat(f32, glyphWidth) * scaleFactor) + @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SPACING));
+ }
+ }
+ }
+ cursor.x = cursorPos.x;
+ cursor.y = cursorPos.y;
+ if (editMode) {
+ GuiDrawRectangle(cursor, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))), guiAlpha));
+ }
+ return pressed;
+}
+pub export fn GuiSlider(arg_bounds: Rectangle, arg_textLeft: [*c]const u8, arg_textRight: [*c]const u8, arg_value: f32, arg_minValue: f32, arg_maxValue: f32) f32 {
+ var bounds = arg_bounds;
+ var textLeft = arg_textLeft;
+ var textRight = arg_textRight;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH));
+}
+pub export fn GuiSliderBar(arg_bounds: Rectangle, arg_textLeft: [*c]const u8, arg_textRight: [*c]const u8, arg_value: f32, arg_minValue: f32, arg_maxValue: f32) f32 {
+ var bounds = arg_bounds;
+ var textLeft = arg_textLeft;
+ var textRight = arg_textRight;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, @as(c_int, 0));
+}
+pub export fn GuiProgressBar(arg_bounds: Rectangle, arg_textLeft: [*c]const u8, arg_textRight: [*c]const u8, arg_value: f32, arg_minValue: f32, arg_maxValue: f32) f32 {
+ var bounds = arg_bounds;
+ var textLeft = arg_textLeft;
+ var textRight = arg_textRight;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ var state: GuiControlState = guiState;
+ var progress: Rectangle = Rectangle{
+ .x = bounds.x + @intToFloat(f32, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)),
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING)),
+ .width = @intToFloat(f32, @as(c_int, 0)),
+ .height = (bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(PROGRESSBAR, BORDER_WIDTH))) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING)),
+ };
+ if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ progress.width = (value / (maxValue - minValue)) * (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(PROGRESSBAR, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ if ((state == @bitCast(c_uint, GUI_STATE_NORMAL)) or (state == @bitCast(c_uint, GUI_STATE_PRESSED))) {
+ GuiDrawRectangle(progress, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED))), guiAlpha));
+ } else if (state == @bitCast(c_uint, GUI_STATE_FOCUSED)) {
+ GuiDrawRectangle(progress, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(PROGRESSBAR, TEXT_COLOR_FOCUSED))), guiAlpha));
+ }
+ if (textLeft != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.width = @intToFloat(f32, GetTextWidth(textLeft));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x - textBounds.width) - @intToFloat(f32, GuiGetStyle(PROGRESSBAR, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ GuiDrawText(textLeft, textBounds, GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(PROGRESSBAR, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ if (textRight != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.width = @intToFloat(f32, GetTextWidth(textRight));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(PROGRESSBAR, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ GuiDrawText(textRight, textBounds, GUI_TEXT_ALIGN_LEFT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(PROGRESSBAR, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ return value;
+}
+pub export fn GuiStatusBar(arg_bounds: Rectangle, arg_text: [*c]const u8) void {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(STATUSBAR, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) BORDER_COLOR_NORMAL else BORDER_COLOR_DISABLED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(STATUSBAR, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) BASE_COLOR_NORMAL else BASE_COLOR_DISABLED))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(STATUSBAR, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) TEXT_COLOR_NORMAL else TEXT_COLOR_DISABLED))), guiAlpha));
+}
+pub export fn GuiDummyRec(arg_bounds: Rectangle, arg_text: [*c]const u8) void {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var state: GuiControlState = guiState;
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ GuiDrawRectangle(bounds, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) BASE_COLOR_NORMAL else BASE_COLOR_DISABLED))), guiAlpha));
+ GuiDrawText(text, GetTextBounds(DEFAULT, bounds), GUI_TEXT_ALIGN_CENTER, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(BUTTON, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) TEXT_COLOR_NORMAL else TEXT_COLOR_DISABLED))), guiAlpha));
+}
+pub export fn GuiScrollBar(arg_bounds: Rectangle, arg_value: c_int, arg_minValue: c_int, arg_maxValue: c_int) c_int {
+ var bounds = arg_bounds;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ var state: GuiControlState = guiState;
+ var isVertical: bool = (if (bounds.width > bounds.height) @as(c_int, 0) else @as(c_int, 1)) != 0;
+ const spinnerSize: c_int = if (GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE) != 0) if (@as(c_int, @boolToInt(isVertical)) != 0) @floatToInt(c_int, bounds.width) - (@as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)) else @floatToInt(c_int, bounds.height) - (@as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)) else @as(c_int, 0);
+ var arrowUpLeft: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ var arrowDownRight: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ var scrollbar: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ var slider: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ if (value > maxValue) {
+ value = maxValue;
+ }
+ if (value < minValue) {
+ value = minValue;
+ }
+ const range: c_int = maxValue - minValue;
+ var sliderSize: c_int = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE);
+ arrowUpLeft = Rectangle{
+ .x = bounds.x + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .width = @intToFloat(f32, spinnerSize),
+ .height = @intToFloat(f32, spinnerSize),
+ };
+ if (isVertical) {
+ arrowDownRight = Rectangle{
+ .x = bounds.x + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .y = ((bounds.y + bounds.height) - @intToFloat(f32, spinnerSize)) - @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .width = @intToFloat(f32, spinnerSize),
+ .height = @intToFloat(f32, spinnerSize),
+ };
+ scrollbar = Rectangle{
+ .x = (bounds.x + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_PADDING)),
+ .y = arrowUpLeft.y + arrowUpLeft.height,
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING))),
+ .height = ((bounds.height - arrowUpLeft.height) - arrowDownRight.height) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ };
+ sliderSize = if (@intToFloat(f32, sliderSize) >= scrollbar.height) @floatToInt(c_int, scrollbar.height) - @as(c_int, 2) else sliderSize;
+ slider = Rectangle{
+ .x = (bounds.x + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)),
+ .y = scrollbar.y + @intToFloat(f32, @floatToInt(c_int, (@intToFloat(f32, value - minValue) / @intToFloat(f32, range)) * (scrollbar.height - @intToFloat(f32, sliderSize)))),
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING))),
+ .height = @intToFloat(f32, sliderSize),
+ };
+ } else {
+ arrowDownRight = Rectangle{
+ .x = ((bounds.x + bounds.width) - @intToFloat(f32, spinnerSize)) - @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .width = @intToFloat(f32, spinnerSize),
+ .height = @intToFloat(f32, spinnerSize),
+ };
+ scrollbar = Rectangle{
+ .x = arrowUpLeft.x + arrowUpLeft.width,
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_PADDING)),
+ .width = ((bounds.width - arrowUpLeft.width) - arrowDownRight.width) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING))),
+ };
+ sliderSize = if (@intToFloat(f32, sliderSize) >= scrollbar.width) @floatToInt(c_int, scrollbar.width) - @as(c_int, 2) else sliderSize;
+ slider = Rectangle{
+ .x = scrollbar.x + @intToFloat(f32, @floatToInt(c_int, (@intToFloat(f32, value - minValue) / @intToFloat(f32, range)) * (scrollbar.width - @intToFloat(f32, sliderSize)))),
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(SCROLLBAR, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)),
+ .width = @intToFloat(f32, sliderSize),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * (GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING))),
+ };
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ var wheel: c_int = @floatToInt(c_int, GetMouseWheelMove());
+ if (wheel != @as(c_int, 0)) {
+ value += wheel;
+ }
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) {
+ value -= @divTrunc(range, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ } else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) {
+ value += @divTrunc(range, GuiGetStyle(SCROLLBAR, SCROLL_SPEED));
+ }
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ } else if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ if (!isVertical) {
+ var scrollArea: Rectangle = Rectangle{
+ .x = arrowUpLeft.x + arrowUpLeft.width,
+ .y = arrowUpLeft.y,
+ .width = scrollbar.width,
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ };
+ if (CheckCollisionPointRec(mousePoint, scrollArea)) {
+ value = @floatToInt(c_int, ((((mousePoint.x - scrollArea.x) - (slider.width / @intToFloat(f32, @as(c_int, 2)))) * @intToFloat(f32, range)) / (scrollArea.width - slider.width)) + @intToFloat(f32, minValue));
+ }
+ } else {
+ var scrollArea: Rectangle = Rectangle{
+ .x = arrowUpLeft.x,
+ .y = arrowUpLeft.y + arrowUpLeft.height,
+ .width = bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SCROLLBAR, BORDER_WIDTH)),
+ .height = scrollbar.height,
+ };
+ if (CheckCollisionPointRec(mousePoint, scrollArea)) {
+ value = @floatToInt(c_int, ((((mousePoint.y - scrollArea.y) - (slider.height / @intToFloat(f32, @as(c_int, 2)))) * @intToFloat(f32, range)) / (scrollArea.height - slider.height)) + @intToFloat(f32, minValue));
+ }
+ }
+ }
+ }
+ if (value > maxValue) {
+ value = maxValue;
+ }
+ if (value < minValue) {
+ value = minValue;
+ }
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED))), guiAlpha));
+ GuiDrawRectangle(scrollbar, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(BUTTON, BASE_COLOR_NORMAL))), guiAlpha));
+ GuiDrawRectangle(slider, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ if (GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE) != 0) {
+ GuiDrawText(if (@as(c_int, @boolToInt(isVertical)) != 0) "#121#" else "#118#", Rectangle{
+ .x = arrowUpLeft.x,
+ .y = arrowUpLeft.y,
+ .width = if (@as(c_int, @boolToInt(isVertical)) != 0) bounds.width else bounds.height,
+ .height = if (@as(c_int, @boolToInt(isVertical)) != 0) bounds.width else bounds.height,
+ }, GUI_TEXT_ALIGN_CENTER, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SCROLLBAR, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ GuiDrawText(if (@as(c_int, @boolToInt(isVertical)) != 0) "#120#" else "#119#", Rectangle{
+ .x = arrowDownRight.x,
+ .y = arrowDownRight.y,
+ .width = if (@as(c_int, @boolToInt(isVertical)) != 0) bounds.width else bounds.height,
+ .height = if (@as(c_int, @boolToInt(isVertical)) != 0) bounds.width else bounds.height,
+ }, GUI_TEXT_ALIGN_CENTER, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SCROLLBAR, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ return value;
+}
+pub export fn GuiGrid(arg_bounds: Rectangle, arg_spacing: f32, arg_subdivs: c_int) Vector2 {
+ var bounds = arg_bounds;
+ var spacing = arg_spacing;
+ var subdivs = arg_subdivs;
+ var state: GuiControlState = guiState;
+ var mousePoint: Vector2 = GetMousePosition();
+ var currentCell: Vector2 = Vector2{
+ .x = @intToFloat(f32, -@as(c_int, 1)),
+ .y = @intToFloat(f32, -@as(c_int, 1)),
+ };
+ var linesV: c_int = (@floatToInt(c_int, bounds.width / spacing) * subdivs) + @as(c_int, 1);
+ var linesH: c_int = (@floatToInt(c_int, bounds.height / spacing) * subdivs) + @as(c_int, 1);
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ currentCell.x = (mousePoint.x - bounds.x) / spacing;
+ currentCell.y = (mousePoint.y - bounds.y) / spacing;
+ }
+ }
+ while (true) {
+ switch (state) {
+ @bitCast(c_uint, @as(c_int, 0)) => {
+ {
+ if (subdivs > @as(c_int, 0)) {
+ {
+ var i: c_int = 0;
+ while (i < linesV) : (i += 1) {
+ var lineV: Rectangle = Rectangle{
+ .x = bounds.x + ((spacing * @intToFloat(f32, i)) / @intToFloat(f32, subdivs)),
+ .y = bounds.y,
+ .width = @intToFloat(f32, @as(c_int, 1)),
+ .height = bounds.height,
+ };
+ GuiDrawRectangle(lineV, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, if (@import("std").zig.c_translation.signedRemainder(i, subdivs) == @as(c_int, 0)) Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, LINE_COLOR))), 0.15000000596046448 * @intToFloat(f32, @as(c_int, 4))) else Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, LINE_COLOR))), 0.15000000596046448));
+ }
+ }
+ {
+ var i: c_int = 0;
+ while (i < linesH) : (i += 1) {
+ var lineH: Rectangle = Rectangle{
+ .x = bounds.x,
+ .y = bounds.y + ((spacing * @intToFloat(f32, i)) / @intToFloat(f32, subdivs)),
+ .width = bounds.width,
+ .height = @intToFloat(f32, @as(c_int, 1)),
+ };
+ GuiDrawRectangle(lineH, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, if (@import("std").zig.c_translation.signedRemainder(i, subdivs) == @as(c_int, 0)) Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, LINE_COLOR))), 0.15000000596046448 * @intToFloat(f32, @as(c_int, 4))) else Fade(GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, LINE_COLOR))), 0.15000000596046448));
+ }
+ }
+ }
+ }
+ break;
+ },
+ else => break,
+ }
+ break;
+ }
+ return currentCell;
+}
+pub export fn GuiListView(arg_bounds: Rectangle, arg_text: [*c]const u8, arg_scrollIndex: [*c]c_int, arg_active: c_int) c_int {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var scrollIndex = arg_scrollIndex;
+ var active = arg_active;
+ var itemCount: c_int = 0;
+ var items: [*c][*c]const u8 = null;
+ if (text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ items = GuiTextSplit(text, &itemCount, null);
+ }
+ return GuiListViewEx(bounds, items, itemCount, null, scrollIndex, active);
+}
+pub export fn GuiListViewEx(arg_bounds: Rectangle, arg_text: [*c][*c]const u8, arg_count: c_int, arg_focus: [*c]c_int, arg_scrollIndex: [*c]c_int, arg_active: c_int) c_int {
+ var bounds = arg_bounds;
+ var text = arg_text;
+ var count = arg_count;
+ var focus = arg_focus;
+ var scrollIndex = arg_scrollIndex;
+ var active = arg_active;
+ var state: GuiControlState = guiState;
+ var itemFocused: c_int = if (focus == @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) -@as(c_int, 1) else focus.*;
+ var itemSelected: c_int = active;
+ var useScrollBar: bool = @as(c_int, 0) != 0;
+ if (@intToFloat(f32, (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING)) * count) > bounds.height) {
+ useScrollBar = @as(c_int, 1) != 0;
+ }
+ var itemBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ itemBounds.x = bounds.x + @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ itemBounds.y = (bounds.y + @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING))) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ itemBounds.width = (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING))) - @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ itemBounds.height = @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT));
+ if (useScrollBar) {
+ itemBounds.width -= @intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH));
+ }
+ var visibleItems: c_int = @divTrunc(@floatToInt(c_int, bounds.height), GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ if (visibleItems > count) {
+ visibleItems = count;
+ }
+ var startIndex: c_int = if (scrollIndex == @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) @as(c_int, 0) else scrollIndex.*;
+ if ((startIndex < @as(c_int, 0)) or (startIndex > (count - visibleItems))) {
+ startIndex = 0;
+ }
+ var endIndex: c_int = startIndex + visibleItems;
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ {
+ var i: c_int = 0;
+ while (i < visibleItems) : (i += 1) {
+ if (CheckCollisionPointRec(mousePoint, itemBounds)) {
+ itemFocused = startIndex + i;
+ if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+ if (itemSelected == (startIndex + i)) {
+ itemSelected = -@as(c_int, 1);
+ } else {
+ itemSelected = startIndex + i;
+ }
+ }
+ break;
+ }
+ itemBounds.y += @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ }
+ }
+ if (useScrollBar) {
+ var wheelMove: c_int = @floatToInt(c_int, GetMouseWheelMove());
+ startIndex -= wheelMove;
+ if (startIndex < @as(c_int, 0)) {
+ startIndex = 0;
+ } else if (startIndex > (count - visibleItems)) {
+ startIndex = count - visibleItems;
+ }
+ endIndex = startIndex + visibleItems;
+ if (endIndex > count) {
+ endIndex = count;
+ }
+ }
+ } else {
+ itemFocused = -@as(c_int, 1);
+ }
+ itemBounds.y = (bounds.y + @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING))) + @intToFloat(f32, GuiGetStyle(DEFAULT, BORDER_WIDTH));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), GetColor(@bitCast(c_uint, GuiGetStyle(DEFAULT, BACKGROUND_COLOR))));
+ {
+ var i: c_int = 0;
+ while ((i < visibleItems) and (text != @ptrCast([*c][*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @intToPtr(?*anyopaque, @as(c_int, 0)))))) : (i += 1) {
+ if (state == @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ if ((startIndex + i) == itemSelected) {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED))), guiAlpha));
+ }
+ GuiDrawText((blk: {
+ const tmp = startIndex + i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED))), guiAlpha));
+ } else {
+ if ((startIndex + i) == itemSelected) {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = startIndex + i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED))), guiAlpha));
+ } else if ((startIndex + i) == itemFocused) {
+ GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED))), guiAlpha));
+ GuiDrawText((blk: {
+ const tmp = startIndex + i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED))), guiAlpha));
+ } else {
+ GuiDrawText((blk: {
+ const tmp = startIndex + i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*, GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL))), guiAlpha));
+ }
+ }
+ itemBounds.y += @intToFloat(f32, GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ }
+ }
+ if (useScrollBar) {
+ var scrollBarBounds: Rectangle = Rectangle{
+ .x = ((bounds.x + bounds.width) - @intToFloat(f32, GuiGetStyle(LISTVIEW, BORDER_WIDTH))) - @intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH)),
+ .y = bounds.y + @intToFloat(f32, GuiGetStyle(LISTVIEW, BORDER_WIDTH)),
+ .width = @intToFloat(f32, GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH)),
+ .height = bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(DEFAULT, BORDER_WIDTH)),
+ };
+ var percentVisible: f32 = @intToFloat(f32, endIndex - startIndex) / @intToFloat(f32, count);
+ var sliderSize: f32 = bounds.height * percentVisible;
+ var prevSliderSize: c_int = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE);
+ var prevScrollSpeed: c_int = GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, @floatToInt(c_int, sliderSize));
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems);
+ startIndex = GuiScrollBar(scrollBarBounds, startIndex, @as(c_int, 0), count - visibleItems);
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed);
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize);
+ }
+ if (focus != @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ focus.* = itemFocused;
+ }
+ if (scrollIndex != @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ scrollIndex.* = startIndex;
+ }
+ return itemSelected;
+}
+pub export fn GuiMessageBox(arg_bounds: Rectangle, arg_title: [*c]const u8, arg_message: [*c]const u8, arg_buttons: [*c]const u8) c_int {
+ var bounds = arg_bounds;
+ var title = arg_title;
+ var message = arg_message;
+ var buttons = arg_buttons;
+ var clicked: c_int = -@as(c_int, 1);
+ var buttonCount: c_int = 0;
+ var buttonsText: [*c][*c]const u8 = GuiTextSplit(buttons, &buttonCount, null);
+ var buttonBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ buttonBounds.x = bounds.x + @intToFloat(f32, @as(c_int, 10));
+ buttonBounds.y = ((bounds.y + bounds.height) - @intToFloat(f32, @as(c_int, 24))) - @intToFloat(f32, @as(c_int, 10));
+ buttonBounds.width = (bounds.width - @intToFloat(f32, @as(c_int, 10) * (buttonCount + @as(c_int, 1)))) / @intToFloat(f32, buttonCount);
+ buttonBounds.height = 24;
+ var textSize: Vector2 = MeasureTextEx(guiFont, message, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), @intToFloat(f32, @as(c_int, 1)));
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.x = (bounds.x + (bounds.width / @intToFloat(f32, @as(c_int, 2)))) - (textSize.x / @intToFloat(f32, @as(c_int, 2)));
+ textBounds.y = ((bounds.y + @intToFloat(f32, @as(c_int, 22))) + ((((bounds.height - @intToFloat(f32, @as(c_int, 22))) - @intToFloat(f32, @as(c_int, 24))) - @intToFloat(f32, @as(c_int, 10))) / @intToFloat(f32, @as(c_int, 2)))) - (textSize.y / @intToFloat(f32, @as(c_int, 2)));
+ textBounds.width = textSize.x;
+ textBounds.height = textSize.y;
+ if (GuiWindowBox(bounds, title)) {
+ clicked = 0;
+ }
+ var prevTextAlignment: c_int = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiLabel(textBounds, message);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
+ prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ {
+ var i: c_int = 0;
+ while (i < buttonCount) : (i += 1) {
+ if (GuiButton(buttonBounds, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk buttonsText + @intCast(usize, tmp) else break :blk buttonsText - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) {
+ clicked = i + @as(c_int, 1);
+ }
+ buttonBounds.x += buttonBounds.width + @intToFloat(f32, @as(c_int, 10));
+ }
+ }
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment);
+ return clicked;
+}
+pub export fn GuiTextInputBox(arg_bounds: Rectangle, arg_title: [*c]const u8, arg_message: [*c]const u8, arg_buttons: [*c]const u8, arg_text: [*c]u8) c_int {
+ var bounds = arg_bounds;
+ var title = arg_title;
+ var message = arg_message;
+ var buttons = arg_buttons;
+ var text = arg_text;
+ const textEditMode = struct {
+ var static: bool = @as(c_int, 0) != 0;
+ };
+ var btnIndex: c_int = -@as(c_int, 1);
+ var buttonCount: c_int = 0;
+ var buttonsText: [*c][*c]const u8 = GuiTextSplit(buttons, &buttonCount, null);
+ var buttonBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ buttonBounds.x = bounds.x + @intToFloat(f32, @as(c_int, 10));
+ buttonBounds.y = ((bounds.y + bounds.height) - @intToFloat(f32, @as(c_int, 24))) - @intToFloat(f32, @as(c_int, 10));
+ buttonBounds.width = (bounds.width - @intToFloat(f32, @as(c_int, 10) * (buttonCount + @as(c_int, 1)))) / @intToFloat(f32, buttonCount);
+ buttonBounds.height = 24;
+ var messageInputHeight: c_int = (((@floatToInt(c_int, bounds.height) - @as(c_int, 22)) - GuiGetStyle(STATUSBAR, BORDER_WIDTH)) - @as(c_int, 24)) - (@as(c_int, 2) * @as(c_int, 10));
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ if (message != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var textSize: Vector2 = MeasureTextEx(guiFont, message, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), @intToFloat(f32, @as(c_int, 1)));
+ textBounds.x = (bounds.x + (bounds.width / @intToFloat(f32, @as(c_int, 2)))) - (textSize.x / @intToFloat(f32, @as(c_int, 2)));
+ textBounds.y = ((bounds.y + @intToFloat(f32, @as(c_int, 22))) + @intToFloat(f32, @divTrunc(messageInputHeight, @as(c_int, 4)))) - (textSize.y / @intToFloat(f32, @as(c_int, 2)));
+ textBounds.width = textSize.x;
+ textBounds.height = textSize.y;
+ }
+ var textBoxBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBoxBounds.x = bounds.x + @intToFloat(f32, @as(c_int, 10));
+ textBoxBounds.y = (bounds.y + @intToFloat(f32, @as(c_int, 22))) - @intToFloat(f32, @divTrunc(@as(c_int, 30), @as(c_int, 2)));
+ if (message == @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ textBoxBounds.y += @intToFloat(f32, @divTrunc(messageInputHeight, @as(c_int, 2)));
+ } else {
+ textBoxBounds.y += @intToFloat(f32, @divTrunc(messageInputHeight, @as(c_int, 2)) + @divTrunc(messageInputHeight, @as(c_int, 4)));
+ }
+ textBoxBounds.width = bounds.width - @intToFloat(f32, @as(c_int, 10) * @as(c_int, 2));
+ textBoxBounds.height = 30;
+ if (GuiWindowBox(bounds, title)) {
+ btnIndex = 0;
+ }
+ if (message != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var prevTextAlignment: c_int = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiLabel(textBounds, message);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
+ }
+ if (GuiTextBox(textBoxBounds, text, @as(c_int, 256), textEditMode.static)) {
+ textEditMode.static = !textEditMode.static;
+ }
+ var prevBtnTextAlignment: c_int = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ {
+ var i: c_int = 0;
+ while (i < buttonCount) : (i += 1) {
+ if (GuiButton(buttonBounds, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk buttonsText + @intCast(usize, tmp) else break :blk buttonsText - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) {
+ btnIndex = i + @as(c_int, 1);
+ }
+ buttonBounds.x += buttonBounds.width + @intToFloat(f32, @as(c_int, 10));
+ }
+ }
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment);
+ return btnIndex;
+}
+pub export fn GuiColorPicker(arg_bounds: Rectangle, arg_color: Color) Color {
+ var bounds = arg_bounds;
+ var color = arg_color;
+ color = GuiColorPanel(bounds, color);
+ var boundsHue: Rectangle = Rectangle{
+ .x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_PADDING)),
+ .y = bounds.y,
+ .width = @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_WIDTH)),
+ .height = bounds.height,
+ };
+ var hsv: Vector3 = ConvertRGBtoHSV(Vector3{
+ .x = @intToFloat(f32, @bitCast(c_int, @as(c_uint, color.r))) / 255.0,
+ .y = @intToFloat(f32, @bitCast(c_int, @as(c_uint, color.g))) / 255.0,
+ .z = @intToFloat(f32, @bitCast(c_int, @as(c_uint, color.b))) / 255.0,
+ });
+ hsv.x = GuiColorBarHue(boundsHue, hsv.x);
+ var rgb: Vector3 = ConvertHSVtoRGB(hsv);
+ color = Color{
+ .r = @floatToInt(u8, roundf(rgb.x * 255.0)),
+ .g = @floatToInt(u8, roundf(rgb.y * 255.0)),
+ .b = @floatToInt(u8, roundf(rgb.z * 255.0)),
+ .a = color.a,
+ };
+ return color;
+}
+pub export fn GuiColorPanel(arg_bounds: Rectangle, arg_color: Color) Color {
+ var bounds = arg_bounds;
+ var color = arg_color;
+ const colWhite: Color = Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ };
+ const colBlack: Color = Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ };
+ var state: GuiControlState = guiState;
+ var pickerSelector: Vector2 = Vector2{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ };
+ var vcolor: Vector3 = Vector3{
+ .x = @intToFloat(f32, color.r) / 255.0,
+ .y = @intToFloat(f32, color.g) / 255.0,
+ .z = @intToFloat(f32, color.b) / 255.0,
+ };
+ var hsv: Vector3 = ConvertRGBtoHSV(vcolor);
+ pickerSelector.x = bounds.x + (hsv.y * bounds.width);
+ pickerSelector.y = bounds.y + ((1.0 - hsv.z) * bounds.height);
+ var hue: f32 = -1.0;
+ var maxHue: Vector3 = Vector3{
+ .x = if (hue >= 0.0) hue else hsv.x,
+ .y = 1.0,
+ .z = 1.0,
+ };
+ var rgbHue: Vector3 = ConvertHSVtoRGB(maxHue);
+ var maxHueCol: Color = Color{
+ .r = @floatToInt(u8, 255.0 * rgbHue.x),
+ .g = @floatToInt(u8, 255.0 * rgbHue.y),
+ .b = @floatToInt(u8, 255.0 * rgbHue.z),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ };
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ pickerSelector = mousePoint;
+ var colorPick: Vector2 = Vector2{
+ .x = pickerSelector.x - bounds.x,
+ .y = pickerSelector.y - bounds.y,
+ };
+ colorPick.x /= bounds.width;
+ colorPick.y /= bounds.height;
+ hsv.y = colorPick.x;
+ hsv.z = 1.0 - colorPick.y;
+ var rgb: Vector3 = ConvertHSVtoRGB(hsv);
+ color = Color{
+ .r = @floatToInt(u8, 255.0 * rgb.x),
+ .g = @floatToInt(u8, 255.0 * rgb.y),
+ .b = @floatToInt(u8, 255.0 * rgb.z),
+ .a = @floatToInt(u8, (255.0 * @intToFloat(f32, color.a)) / 255.0),
+ };
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ DrawRectangleGradientEx(bounds, Fade(colWhite, guiAlpha), Fade(colWhite, guiAlpha), Fade(maxHueCol, guiAlpha), Fade(maxHueCol, guiAlpha));
+ DrawRectangleGradientEx(bounds, Fade(colBlack, @intToFloat(f32, @as(c_int, 0))), Fade(colBlack, guiAlpha), Fade(colBlack, guiAlpha), Fade(colBlack, @intToFloat(f32, @as(c_int, 0))));
+ var selector: Rectangle = Rectangle{
+ .x = pickerSelector.x - @intToFloat(f32, @divTrunc(GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), @as(c_int, 2))),
+ .y = pickerSelector.y - @intToFloat(f32, @divTrunc(GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), @as(c_int, 2))),
+ .width = @intToFloat(f32, GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)),
+ .height = @intToFloat(f32, GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)),
+ };
+ GuiDrawRectangle(selector, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(colWhite, guiAlpha));
+ } else {
+ DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED))), 0.10000000149011612), guiAlpha), Fade(Fade(colBlack, 0.6000000238418579), guiAlpha), Fade(Fade(colBlack, 0.6000000238418579), guiAlpha), Fade(Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED))), 0.6000000238418579), guiAlpha));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ return color;
+}
+pub export fn GuiColorBarAlpha(arg_bounds: Rectangle, arg_alpha: f32) f32 {
+ var bounds = arg_bounds;
+ var alpha = arg_alpha;
+ var state: GuiControlState = guiState;
+ var selector: Rectangle = Rectangle{
+ .x = (bounds.x + (alpha * bounds.width)) - @intToFloat(f32, @divTrunc(GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT), @as(c_int, 2))),
+ .y = bounds.y - @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)),
+ .width = @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)),
+ .height = bounds.height + @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW) * @as(c_int, 2)),
+ };
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if ((@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, bounds))) != 0) or (@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, selector))) != 0)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ alpha = (mousePoint.x - bounds.x) / bounds.width;
+ if (alpha <= 0.0) {
+ alpha = 0.0;
+ }
+ if (alpha >= 1.0) {
+ alpha = 1.0;
+ }
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ var checksX: c_int = @divTrunc(@floatToInt(c_int, bounds.width), @as(c_int, 10));
+ var checksY: c_int = @divTrunc(@floatToInt(c_int, bounds.height), @as(c_int, 10));
+ {
+ var x: c_int = 0;
+ while (x < checksX) : (x += 1) {
+ {
+ var y: c_int = 0;
+ while (y < checksY) : (y += 1) {
+ var check: Rectangle = Rectangle{
+ .x = bounds.x + @intToFloat(f32, x * @as(c_int, 10)),
+ .y = bounds.y + @intToFloat(f32, y * @as(c_int, 10)),
+ .width = @intToFloat(f32, @as(c_int, 10)),
+ .height = @intToFloat(f32, @as(c_int, 10)),
+ };
+ GuiDrawRectangle(check, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, if (@import("std").zig.c_translation.signedRemainder(x + y, @as(c_int, 2)) != 0) Fade(Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED))), 0.4000000059604645), guiAlpha) else Fade(Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED))), 0.4000000059604645), guiAlpha));
+ }
+ }
+ }
+ }
+ DrawRectangleGradientEx(bounds, Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ } else {
+ DrawRectangleGradientEx(bounds, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED))), 0.10000000149011612), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED))), 0.10000000149011612), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED))), guiAlpha));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ GuiDrawRectangle(selector, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return alpha;
+}
+pub export fn GuiColorBarHue(arg_bounds: Rectangle, arg_hue: f32) f32 {
+ var bounds = arg_bounds;
+ var hue = arg_hue;
+ var state: GuiControlState = guiState;
+ var selector: Rectangle = Rectangle{
+ .x = bounds.x - @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)),
+ .y = (bounds.y + ((hue / 360.0) * bounds.height)) - @intToFloat(f32, @divTrunc(GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT), @as(c_int, 2))),
+ .width = bounds.width + @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW) * @as(c_int, 2)),
+ .height = @intToFloat(f32, GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)),
+ };
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if ((@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, bounds))) != 0) or (@as(c_int, @boolToInt(CheckCollisionPointRec(mousePoint, selector))) != 0)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ hue = ((mousePoint.y - bounds.y) * @intToFloat(f32, @as(c_int, 360))) / bounds.height;
+ if (hue <= 0.0) {
+ hue = 0.0;
+ }
+ if (hue >= 359.0) {
+ hue = 359.0;
+ }
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ }
+ if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) {
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y), @floatToInt(c_int, bounds.width), @floatToInt(c_int, ceil(@floatCast(f64, bounds.height / @intToFloat(f32, @as(c_int, 6))))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 6)))), @floatToInt(c_int, bounds.width), @floatToInt(c_int, ceil(@floatCast(f64, bounds.height / @intToFloat(f32, @as(c_int, 6))))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y + (@intToFloat(f32, @as(c_int, 2)) * (bounds.height / @intToFloat(f32, @as(c_int, 6))))), @floatToInt(c_int, bounds.width), @floatToInt(c_int, ceil(@floatCast(f64, bounds.height / @intToFloat(f32, @as(c_int, 6))))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y + (@intToFloat(f32, @as(c_int, 3)) * (bounds.height / @intToFloat(f32, @as(c_int, 6))))), @floatToInt(c_int, bounds.width), @floatToInt(c_int, ceil(@floatCast(f64, bounds.height / @intToFloat(f32, @as(c_int, 6))))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y + (@intToFloat(f32, @as(c_int, 4)) * (bounds.height / @intToFloat(f32, @as(c_int, 6))))), @floatToInt(c_int, bounds.width), @floatToInt(c_int, ceil(@floatCast(f64, bounds.height / @intToFloat(f32, @as(c_int, 6))))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y + (@intToFloat(f32, @as(c_int, 5)) * (bounds.height / @intToFloat(f32, @as(c_int, 6))))), @floatToInt(c_int, bounds.width), @floatToInt(c_int, bounds.height / @intToFloat(f32, @as(c_int, 6))), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha), Fade(Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 255))),
+ }, guiAlpha));
+ } else {
+ DrawRectangleGradientV(@floatToInt(c_int, bounds.x), @floatToInt(c_int, bounds.y), @floatToInt(c_int, bounds.width), @floatToInt(c_int, bounds.height), Fade(Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED))), 0.10000000149011612), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED))), guiAlpha));
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ });
+ GuiDrawRectangle(selector, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(COLORPICKER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ return hue;
+}
+pub const struct__IO_marker = opaque {};
+pub const __off_t = c_long;
+pub const _IO_lock_t = anyopaque;
+pub const __off64_t = c_long;
+pub const struct__IO_codecvt = opaque {};
+pub const struct__IO_wide_data = opaque {};
+pub const struct__IO_FILE = extern struct {
+ _flags: c_int,
+ _IO_read_ptr: [*c]u8,
+ _IO_read_end: [*c]u8,
+ _IO_read_base: [*c]u8,
+ _IO_write_base: [*c]u8,
+ _IO_write_ptr: [*c]u8,
+ _IO_write_end: [*c]u8,
+ _IO_buf_base: [*c]u8,
+ _IO_buf_end: [*c]u8,
+ _IO_save_base: [*c]u8,
+ _IO_backup_base: [*c]u8,
+ _IO_save_end: [*c]u8,
+ _markers: ?*struct__IO_marker,
+ _chain: [*c]struct__IO_FILE,
+ _fileno: c_int,
+ _flags2: c_int,
+ _old_offset: __off_t,
+ _cur_column: c_ushort,
+ _vtable_offset: i8,
+ _shortbuf: [1]u8,
+ _lock: ?*_IO_lock_t,
+ _offset: __off64_t,
+ _codecvt: ?*struct__IO_codecvt,
+ _wide_data: ?*struct__IO_wide_data,
+ _freeres_list: [*c]struct__IO_FILE,
+ _freeres_buf: ?*anyopaque,
+ __pad5: usize,
+ _mode: c_int,
+ _unused2: [20]u8,
+};
+pub const FILE = struct__IO_FILE;
+pub export fn GuiLoadStyle(arg_fileName: [*c]const u8) void {
+ var fileName = arg_fileName;
+ var tryBinary: bool = @as(c_int, 0) != 0;
+ var rgsFile: [*c]FILE = fopen(fileName, "rt");
+ if (rgsFile != @ptrCast([*c]FILE, @alignCast(@import("std").meta.alignment(FILE), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var buffer: [256]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 255;
+ _ = fgets(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer)), @as(c_int, 256), rgsFile);
+ if (@bitCast(c_int, @as(c_uint, buffer[@intCast(c_uint, @as(c_int, 0))])) == @as(c_int, '#')) {
+ var controlId: c_int = 0;
+ var propertyId: c_int = 0;
+ var propertyValue: c_uint = 0;
+ while (!(feof(rgsFile) != 0)) {
+ while (true) {
+ switch (@bitCast(c_int, @as(c_uint, buffer[@intCast(c_uint, @as(c_int, 0))]))) {
+ @as(c_int, 112) => {
+ {
+ _ = sscanf(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer)), "p %d %d 0x%x", &controlId, &propertyId, &propertyValue);
+ GuiSetStyle(controlId, propertyId, @bitCast(c_int, propertyValue));
+ }
+ break;
+ },
+ @as(c_int, 102) => {
+ {
+ var fontSize: c_int = 0;
+ var charmapFileName: [256]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 255;
+ var fontFileName: [256]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 255;
+ _ = sscanf(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer)), "f %d %s %[^\r\n]s", &fontSize, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &charmapFileName)), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &fontFileName)));
+ var font: Font = Font{
+ .baseSize = @as(c_int, 0),
+ .glyphCount = 0,
+ .glyphPadding = 0,
+ .texture = @import("std").mem.zeroes(struct_Texture),
+ .recs = null,
+ .glyphs = null,
+ };
+ if (@bitCast(c_int, @as(c_uint, charmapFileName[@intCast(c_uint, @as(c_int, 0))])) != @as(c_int, '0')) {
+ var charValues: [*c]u8 = LoadFileText(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &charmapFileName)));
+ if (charValues != @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var glyphCount: c_int = 0;
+ var chars: [*c][*c]const u8 = TextSplit(charValues, @bitCast(u8, @truncate(i8, @as(c_int, '\n'))), &glyphCount);
+ var values: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), malloc(@bitCast(c_ulong, @as(c_long, glyphCount)) *% @sizeOf(c_int))));
+ {
+ var i: c_int = 0;
+ while (i < glyphCount) : (i += 1) {
+ (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk values + @intCast(usize, tmp) else break :blk values - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = TextToInteger((blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk chars + @intCast(usize, tmp) else break :blk chars - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*);
+ }
+ }
+ font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &fontFileName))), fontSize, values, glyphCount);
+ free(@ptrCast(?*anyopaque, values));
+ }
+ } else {
+ font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &fontFileName))), fontSize, null, @as(c_int, 0));
+ }
+ if ((font.texture.id > @bitCast(c_uint, @as(c_int, 0))) and (font.glyphCount > @as(c_int, 0))) {
+ GuiSetFont(font);
+ }
+ }
+ break;
+ },
+ else => break,
+ }
+ break;
+ }
+ _ = fgets(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer)), @as(c_int, 256), rgsFile);
+ }
+ } else {
+ tryBinary = @as(c_int, 1) != 0;
+ }
+ _ = fclose(rgsFile);
+ }
+ if (tryBinary) {
+ rgsFile = fopen(fileName, "rb");
+ if (rgsFile == @ptrCast([*c]FILE, @alignCast(@import("std").meta.alignment(FILE), @intToPtr(?*anyopaque, @as(c_int, 0))))) return;
+ var signature: [5]u8 = [1]u8{0} ** 5;
+ var version: c_short = 0;
+ var reserved: c_short = 0;
+ var propertyCount: c_int = 0;
+ _ = fread(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &signature))), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @bitCast(c_ulong, @as(c_long, @as(c_int, 4))), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &version), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &reserved), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &propertyCount), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ if ((((@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 0))])) == @as(c_int, 'r')) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 1))])) == @as(c_int, 'G'))) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 2))])) == @as(c_int, 'S'))) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 3))])) == @as(c_int, ' '))) {
+ var controlId: c_short = 0;
+ var propertyId: c_short = 0;
+ var propertyValue: c_int = 0;
+ {
+ var i: c_int = 0;
+ while (i < propertyCount) : (i += 1) {
+ _ = fread(@ptrCast(?*anyopaque, &controlId), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &propertyId), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &propertyValue), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ if (@bitCast(c_int, @as(c_int, controlId)) == @as(c_int, 0)) {
+ GuiSetStyle(@as(c_int, 0), @bitCast(c_int, @as(c_int, propertyId)), propertyValue);
+ if (@bitCast(c_int, @as(c_int, propertyId)) < @as(c_int, 16)) {
+ var i_1: c_int = 1;
+ while (i_1 < @as(c_int, 16)) : (i_1 += 1) {
+ GuiSetStyle(i_1, @bitCast(c_int, @as(c_int, propertyId)), propertyValue);
+ }
+ }
+ } else {
+ GuiSetStyle(@bitCast(c_int, @as(c_int, controlId)), @bitCast(c_int, @as(c_int, propertyId)), propertyValue);
+ }
+ }
+ }
+ var fontDataSize: c_int = 0;
+ _ = fread(@ptrCast(?*anyopaque, &fontDataSize), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ if (fontDataSize > @as(c_int, 0)) {
+ var font: Font = Font{
+ .baseSize = @as(c_int, 0),
+ .glyphCount = 0,
+ .glyphPadding = 0,
+ .texture = @import("std").mem.zeroes(struct_Texture),
+ .recs = null,
+ .glyphs = null,
+ };
+ var fontType: c_int = 0;
+ var whiteRec: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ _ = fread(@ptrCast(?*anyopaque, &font.baseSize), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &font.glyphCount), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &fontType), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &whiteRec), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(Rectangle), rgsFile);
+ var fontImageSize: c_int = 0;
+ _ = fread(@ptrCast(?*anyopaque, &fontImageSize), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ if (fontImageSize > @as(c_int, 0)) {
+ var imFont: Image = Image{
+ .data = null,
+ .width = 0,
+ .height = 0,
+ .mipmaps = 0,
+ .format = 0,
+ };
+ imFont.mipmaps = 1;
+ _ = fread(@ptrCast(?*anyopaque, &imFont.width), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &imFont.height), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &imFont.format), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ imFont.data = @ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), malloc(@bitCast(c_ulong, @as(c_long, fontImageSize))))));
+ _ = fread(imFont.data, @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @bitCast(c_ulong, @as(c_long, fontImageSize)), rgsFile);
+ font.texture = LoadTextureFromImage(imFont);
+ free(imFont.data);
+ }
+ font.recs = @ptrCast([*c]Rectangle, @alignCast(@import("std").meta.alignment(Rectangle), calloc(@bitCast(c_ulong, @as(c_long, font.glyphCount)), @sizeOf(Rectangle))));
+ {
+ var i: c_int = 0;
+ while (i < font.glyphCount) : (i += 1) {
+ _ = fread(@ptrCast(?*anyopaque, &(blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk font.recs + @intCast(usize, tmp) else break :blk font.recs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(Rectangle), rgsFile);
+ }
+ }
+ font.glyphs = @ptrCast([*c]GlyphInfo, @alignCast(@import("std").meta.alignment(GlyphInfo), calloc(@bitCast(c_ulong, @as(c_long, font.glyphCount)), @sizeOf(GlyphInfo))));
+ {
+ var i: c_int = 0;
+ while (i < font.glyphCount) : (i += 1) {
+ _ = fread(@ptrCast(?*anyopaque, &(blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk font.glyphs + @intCast(usize, tmp) else break :blk font.glyphs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*.value), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &(blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk font.glyphs + @intCast(usize, tmp) else break :blk font.glyphs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*.offsetX), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &(blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk font.glyphs + @intCast(usize, tmp) else break :blk font.glyphs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*.offsetY), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ _ = fread(@ptrCast(?*anyopaque, &(blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk font.glyphs + @intCast(usize, tmp) else break :blk font.glyphs - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*.advanceX), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_int), rgsFile);
+ }
+ }
+ GuiSetFont(font);
+ if ((whiteRec.width != @intToFloat(f32, @as(c_int, 0))) and (whiteRec.height != @intToFloat(f32, @as(c_int, 0)))) {
+ SetShapesTexture(font.texture, whiteRec);
+ }
+ }
+ }
+ _ = fclose(rgsFile);
+ }
+}
+pub export fn GuiLoadStyleDefault() void {
+ guiStyleLoaded = @as(c_int, 1) != 0;
+ GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, @bitCast(c_int, @as(c_uint, 2206434303)));
+ GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, @bitCast(c_int, @as(c_uint, 3385444863)));
+ GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, @as(c_int, 1751673087));
+ GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, @as(c_int, 1538447871));
+ GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, @bitCast(c_int, @as(c_uint, 3387948799)));
+ GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, @as(c_int, 1822145791));
+ GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, @as(c_int, 76728319));
+ GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, @bitCast(c_int, @as(c_uint, 2548629503)));
+ GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, @as(c_int, 915124223));
+ GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, @bitCast(c_int, @as(c_uint, 3049374463)));
+ GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, @bitCast(c_int, @as(c_uint, 3874089471)));
+ GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, @bitCast(c_int, @as(c_uint, 2931276031)));
+ GuiSetStyle(DEFAULT, BORDER_WIDTH, @as(c_int, 1));
+ GuiSetStyle(DEFAULT, TEXT_PADDING, @as(c_int, 0));
+ GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(BUTTON, BORDER_WIDTH, @as(c_int, 2));
+ GuiSetStyle(SLIDER, TEXT_PADDING, @as(c_int, 5));
+ GuiSetStyle(CHECKBOX, TEXT_PADDING, @as(c_int, 5));
+ GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_RIGHT);
+ GuiSetStyle(TEXTBOX, TEXT_PADDING, @as(c_int, 5));
+ GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(VALUEBOX, TEXT_PADDING, @as(c_int, 4));
+ GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(SPINNER, TEXT_PADDING, @as(c_int, 4));
+ GuiSetStyle(SPINNER, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(STATUSBAR, TEXT_PADDING, @as(c_int, 6));
+ GuiSetStyle(STATUSBAR, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(DEFAULT, TEXT_SIZE, @as(c_int, 10));
+ GuiSetStyle(DEFAULT, TEXT_SPACING, @as(c_int, 1));
+ GuiSetStyle(DEFAULT, LINE_COLOR, @bitCast(c_int, @as(c_uint, 2427172351)));
+ GuiSetStyle(DEFAULT, BACKGROUND_COLOR, @bitCast(c_int, @as(c_uint, 4126537215)));
+ GuiSetStyle(TOGGLE, GROUP_PADDING, @as(c_int, 2));
+ GuiSetStyle(SLIDER, SLIDER_WIDTH, @as(c_int, 15));
+ GuiSetStyle(SLIDER, SLIDER_PADDING, @as(c_int, 1));
+ GuiSetStyle(PROGRESSBAR, PROGRESS_PADDING, @as(c_int, 1));
+ GuiSetStyle(CHECKBOX, CHECK_PADDING, @as(c_int, 1));
+ GuiSetStyle(COMBOBOX, COMBO_BUTTON_WIDTH, @as(c_int, 30));
+ GuiSetStyle(COMBOBOX, COMBO_BUTTON_PADDING, @as(c_int, 2));
+ GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, @as(c_int, 16));
+ GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING, @as(c_int, 2));
+ GuiSetStyle(TEXTBOX, TEXT_LINES_PADDING, @as(c_int, 5));
+ GuiSetStyle(TEXTBOX, TEXT_INNER_PADDING, @as(c_int, 4));
+ GuiSetStyle(TEXTBOX, COLOR_SELECTED_FG, @bitCast(c_int, @as(c_uint, 4043308799)));
+ GuiSetStyle(TEXTBOX, COLOR_SELECTED_BG, @bitCast(c_int, @as(c_uint, 2207973344)));
+ GuiSetStyle(SPINNER, SPIN_BUTTON_WIDTH, @as(c_int, 20));
+ GuiSetStyle(SPINNER, SPIN_BUTTON_PADDING, @as(c_int, 2));
+ GuiSetStyle(SCROLLBAR, BORDER_WIDTH, @as(c_int, 0));
+ GuiSetStyle(SCROLLBAR, ARROWS_VISIBLE, @as(c_int, 0));
+ GuiSetStyle(SCROLLBAR, ARROWS_SIZE, @as(c_int, 6));
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING, @as(c_int, 0));
+ GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, @as(c_int, 16));
+ GuiSetStyle(SCROLLBAR, SCROLL_PADDING, @as(c_int, 0));
+ GuiSetStyle(SCROLLBAR, SCROLL_SPEED, @as(c_int, 10));
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, @as(c_int, 30));
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_PADDING, @as(c_int, 2));
+ GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, @as(c_int, 10));
+ GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE);
+ GuiSetStyle(COLORPICKER, COLOR_SELECTOR_SIZE, @as(c_int, 6));
+ GuiSetStyle(COLORPICKER, HUEBAR_WIDTH, @as(c_int, 20));
+ GuiSetStyle(COLORPICKER, HUEBAR_PADDING, @as(c_int, 10));
+ GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT, @as(c_int, 6));
+ GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW, @as(c_int, 2));
+ guiFont = GetFontDefault();
+}
+pub export fn GuiIconText(arg_iconId: c_int, arg_text: [*c]const u8) [*c]const u8 {
+ var iconId = arg_iconId;
+ var text = arg_text;
+ const buffer = struct {
+ var static: [1024]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 1023;
+ };
+ _ = memset(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static))), @as(c_int, 0), @bitCast(c_ulong, @as(c_long, @as(c_int, 1024))));
+ _ = sprintf(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static)), "#%03i#", iconId);
+ if (text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ {
+ var i: c_int = 5;
+ while (i < @as(c_int, 1024)) : (i += 1) {
+ buffer.static[@intCast(c_uint, i)] = (blk: {
+ const tmp = i - @as(c_int, 5);
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ if (@bitCast(c_int, @as(c_uint, (blk: {
+ const tmp = i - @as(c_int, 5);
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) == @as(c_int, '\x00')) break;
+ }
+ }
+ }
+ return @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static));
+}
+pub export fn GuiDrawIcon(arg_iconId: c_int, arg_posX: c_int, arg_posY: c_int, arg_pixelSize: c_int, arg_color: Color) void {
+ var iconId = arg_iconId;
+ var posX = arg_posX;
+ var posY = arg_posY;
+ var pixelSize = arg_pixelSize;
+ var color = arg_color;
+ {
+ var i: c_int = 0;
+ var y: c_int = 0;
+ while (i < @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32))) : (i += 1) {
+ {
+ var k: c_int = 0;
+ while (k < @as(c_int, 32)) : (k += 1) {
+ if ((guiIcons[@intCast(c_uint, (iconId * @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32))) + i)] & @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), k))) != 0) {
+ DrawRectangle(posX + (@import("std").zig.c_translation.signedRemainder(k, @as(c_int, 16)) * pixelSize), posY + (y * pixelSize), pixelSize, pixelSize, color);
+ }
+ if ((k == @as(c_int, 15)) or (k == @as(c_int, 31))) {
+ y += 1;
+ }
+ }
+ }
+ }
+ }
+}
+pub export fn GuiGetIcons() [*c]c_uint {
+ return @ptrCast([*c]c_uint, @alignCast(@import("std").meta.alignment(c_uint), &guiIcons));
+}
+pub export fn GuiGetIconData(arg_iconId: c_int) [*c]c_uint {
+ var iconId = arg_iconId;
+ const iconData = struct {
+ var static: [8]c_uint = [1]c_uint{
+ 0,
+ } ++ [1]c_uint{0} ** 7;
+ };
+ _ = memset(@ptrCast(?*anyopaque, @ptrCast([*c]c_uint, @alignCast(@import("std").meta.alignment(c_uint), &iconData.static))), @as(c_int, 0), @bitCast(c_ulong, @as(c_long, @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))) *% @sizeOf(c_uint));
+ if (iconId < @as(c_int, 256)) {
+ _ = memcpy(@ptrCast(?*anyopaque, @ptrCast([*c]c_uint, @alignCast(@import("std").meta.alignment(c_uint), &iconData.static))), @ptrCast(?*const anyopaque, &guiIcons[@intCast(c_uint, iconId * @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))]), @bitCast(c_ulong, @as(c_long, @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))) *% @sizeOf(c_uint));
+ }
+ return @ptrCast([*c]c_uint, @alignCast(@import("std").meta.alignment(c_uint), &iconData.static));
+}
+pub export fn GuiSetIconData(arg_iconId: c_int, arg_data: [*c]c_uint) void {
+ var iconId = arg_iconId;
+ var data = arg_data;
+ if (iconId < @as(c_int, 256)) {
+ _ = memcpy(@ptrCast(?*anyopaque, &guiIcons[@intCast(c_uint, iconId * @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))]), @ptrCast(?*const anyopaque, data), @bitCast(c_ulong, @as(c_long, @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))) *% @sizeOf(c_uint));
+ }
+}
+pub export fn GuiSetIconPixel(arg_iconId: c_int, arg_x: c_int, arg_y: c_int) void {
+ var iconId = arg_iconId;
+ var x = arg_x;
+ var y = arg_y;
+ _ = blk: {
+ const ref = &guiIcons[@bitCast(c_ulong, @as(c_long, iconId * @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))) +% (@bitCast(c_ulong, @as(c_long, y)) / ((@sizeOf(c_uint) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))) / @bitCast(c_ulong, @as(c_long, @as(c_int, 16)))))];
+ ref.* |= @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), @bitCast(c_ulong, @as(c_long, x)) +% ((@bitCast(c_ulong, @as(c_long, y)) % ((@sizeOf(c_uint) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))) / @bitCast(c_ulong, @as(c_long, @as(c_int, 16))))) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 16))))));
+ break :blk ref.*;
+ };
+}
+pub export fn GuiClearIconPixel(arg_iconId: c_int, arg_x: c_int, arg_y: c_int) void {
+ var iconId = arg_iconId;
+ var x = arg_x;
+ var y = arg_y;
+ _ = blk: {
+ const ref = &guiIcons[@bitCast(c_ulong, @as(c_long, iconId * @divTrunc(@as(c_int, 16) * @as(c_int, 16), @as(c_int, 32)))) +% (@bitCast(c_ulong, @as(c_long, y)) / ((@sizeOf(c_uint) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))) / @bitCast(c_ulong, @as(c_long, @as(c_int, 16)))))];
+ ref.* &= @bitCast(c_uint, ~(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), @bitCast(c_ulong, @as(c_long, x)) +% ((@bitCast(c_ulong, @as(c_long, y)) % ((@sizeOf(c_uint) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))) / @bitCast(c_ulong, @as(c_long, @as(c_int, 16))))) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 16)))))));
+ break :blk ref.*;
+ };
+}
+pub export fn GuiCheckIconPixel(arg_iconId: c_int, arg_x: c_int, arg_y: c_int) bool {
+ var iconId = arg_iconId;
+ var x = arg_x;
+ var y = arg_y;
+ return (guiIcons[@intCast(c_uint, (iconId * @as(c_int, 8)) + @divTrunc(y, @as(c_int, 2)))] & @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), x + (@import("std").zig.c_translation.signedRemainder(y, @as(c_int, 2)) * @as(c_int, 16))))) != 0;
+}
+pub const __u_char = u8;
+pub const __u_short = c_ushort;
+pub const __u_int = c_uint;
+pub const __u_long = c_ulong;
+pub const __int8_t = i8;
+pub const __uint8_t = u8;
+pub const __int16_t = c_short;
+pub const __uint16_t = c_ushort;
+pub const __int32_t = c_int;
+pub const __uint32_t = c_uint;
+pub const __int64_t = c_long;
+pub const __uint64_t = c_ulong;
+pub const __int_least8_t = __int8_t;
+pub const __uint_least8_t = __uint8_t;
+pub const __int_least16_t = __int16_t;
+pub const __uint_least16_t = __uint16_t;
+pub const __int_least32_t = __int32_t;
+pub const __uint_least32_t = __uint32_t;
+pub const __int_least64_t = __int64_t;
+pub const __uint_least64_t = __uint64_t;
+pub const __quad_t = c_long;
+pub const __u_quad_t = c_ulong;
+pub const __intmax_t = c_long;
+pub const __uintmax_t = c_ulong;
+pub const __dev_t = c_ulong;
+pub const __uid_t = c_uint;
+pub const __gid_t = c_uint;
+pub const __ino_t = c_ulong;
+pub const __ino64_t = c_ulong;
+pub const __mode_t = c_uint;
+pub const __nlink_t = c_ulong;
+pub const __pid_t = c_int;
+pub const __fsid_t = extern struct {
+ __val: [2]c_int,
+};
+pub const __clock_t = c_long;
+pub const __rlim_t = c_ulong;
+pub const __rlim64_t = c_ulong;
+pub const __id_t = c_uint;
+pub const __time_t = c_long;
+pub const __useconds_t = c_uint;
+pub const __suseconds_t = c_long;
+pub const __suseconds64_t = c_long;
+pub const __daddr_t = c_int;
+pub const __key_t = c_int;
+pub const __clockid_t = c_int;
+pub const __timer_t = ?*anyopaque;
+pub const __blksize_t = c_long;
+pub const __blkcnt_t = c_long;
+pub const __blkcnt64_t = c_long;
+pub const __fsblkcnt_t = c_ulong;
+pub const __fsblkcnt64_t = c_ulong;
+pub const __fsfilcnt_t = c_ulong;
+pub const __fsfilcnt64_t = c_ulong;
+pub const __fsword_t = c_long;
+pub const __ssize_t = c_long;
+pub const __syscall_slong_t = c_long;
+pub const __syscall_ulong_t = c_ulong;
+pub const __loff_t = __off64_t;
+pub const __caddr_t = [*c]u8;
+pub const __intptr_t = c_long;
+pub const __socklen_t = c_uint;
+pub const __sig_atomic_t = c_int;
+const union_unnamed_1 = extern union {
+ __wch: c_uint,
+ __wchb: [4]u8,
+};
+pub const __mbstate_t = extern struct {
+ __count: c_int,
+ __value: union_unnamed_1,
+};
+pub const struct__G_fpos_t = extern struct {
+ __pos: __off_t,
+ __state: __mbstate_t,
+};
+pub const __fpos_t = struct__G_fpos_t;
+pub const struct__G_fpos64_t = extern struct {
+ __pos: __off64_t,
+ __state: __mbstate_t,
+};
+pub const __fpos64_t = struct__G_fpos64_t;
+pub const __FILE = struct__IO_FILE;
+pub const off_t = __off_t;
+pub const fpos_t = __fpos_t;
+pub extern var stdin: [*c]FILE;
+pub extern var stdout: [*c]FILE;
+pub extern var stderr: [*c]FILE;
+pub extern fn remove(__filename: [*c]const u8) c_int;
+pub extern fn rename(__old: [*c]const u8, __new: [*c]const u8) c_int;
+pub extern fn renameat(__oldfd: c_int, __old: [*c]const u8, __newfd: c_int, __new: [*c]const u8) c_int;
+pub extern fn fclose(__stream: [*c]FILE) c_int;
+pub extern fn tmpfile() [*c]FILE;
+pub extern fn tmpnam([*c]u8) [*c]u8;
+pub extern fn tmpnam_r(__s: [*c]u8) [*c]u8;
+pub extern fn tempnam(__dir: [*c]const u8, __pfx: [*c]const u8) [*c]u8;
+pub extern fn fflush(__stream: [*c]FILE) c_int;
+pub extern fn fflush_unlocked(__stream: [*c]FILE) c_int;
+pub extern fn fopen(__filename: [*c]const u8, __modes: [*c]const u8) [*c]FILE;
+pub extern fn freopen(noalias __filename: [*c]const u8, noalias __modes: [*c]const u8, noalias __stream: [*c]FILE) [*c]FILE;
+pub extern fn fdopen(__fd: c_int, __modes: [*c]const u8) [*c]FILE;
+pub extern fn fmemopen(__s: ?*anyopaque, __len: usize, __modes: [*c]const u8) [*c]FILE;
+pub extern fn open_memstream(__bufloc: [*c][*c]u8, __sizeloc: [*c]usize) [*c]FILE;
+pub extern fn setbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8) void;
+pub extern fn setvbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __modes: c_int, __n: usize) c_int;
+pub extern fn setbuffer(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __size: usize) void;
+pub extern fn setlinebuf(__stream: [*c]FILE) void;
+pub extern fn fprintf(__stream: [*c]FILE, __format: [*c]const u8, ...) c_int;
+pub extern fn printf(__format: [*c]const u8, ...) c_int;
+pub extern fn sprintf(__s: [*c]u8, __format: [*c]const u8, ...) c_int;
+pub extern fn vfprintf(__s: [*c]FILE, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub fn vprintf(arg___fmt: [*c]const u8, arg___arg: [*c]struct___va_list_tag) callconv(.C) c_int {
+ var __fmt = arg___fmt;
+ var __arg = arg___arg;
+ return vfprintf(stdout, __fmt, __arg);
+}
+pub extern fn vsprintf(__s: [*c]u8, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn snprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, ...) c_int;
+pub extern fn vsnprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn vdprintf(__fd: c_int, noalias __fmt: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn dprintf(__fd: c_int, noalias __fmt: [*c]const u8, ...) c_int;
+pub extern fn fscanf(noalias __stream: [*c]FILE, noalias __format: [*c]const u8, ...) c_int;
+pub extern fn scanf(noalias __format: [*c]const u8, ...) c_int;
+pub extern fn sscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, ...) c_int;
+pub const _Float32 = f32;
+pub const _Float64 = f64;
+pub const _Float32x = f64;
+pub const _Float64x = c_longdouble;
+pub extern fn vfscanf(noalias __s: [*c]FILE, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn vscanf(noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn vsscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int;
+pub extern fn fgetc(__stream: [*c]FILE) c_int;
+pub extern fn getc(__stream: [*c]FILE) c_int;
+pub fn getchar() callconv(.C) c_int {
+ return getc(stdin);
+}
+pub fn getc_unlocked(arg___fp: [*c]FILE) callconv(.C) c_int {
+ var __fp = arg___fp;
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(__fp.*._IO_read_ptr >= __fp.*._IO_read_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __uflow(__fp) else @bitCast(c_int, @as(c_uint, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), blk: {
+ const ref = &__fp.*._IO_read_ptr;
+ const tmp = ref.*;
+ ref.* += 1;
+ break :blk tmp;
+ })).*));
+}
+pub fn getchar_unlocked() callconv(.C) c_int {
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(stdin.*._IO_read_ptr >= stdin.*._IO_read_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __uflow(stdin) else @bitCast(c_int, @as(c_uint, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), blk: {
+ const ref = &stdin.*._IO_read_ptr;
+ const tmp = ref.*;
+ ref.* += 1;
+ break :blk tmp;
+ })).*));
+}
+pub fn fgetc_unlocked(arg___fp: [*c]FILE) callconv(.C) c_int {
+ var __fp = arg___fp;
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(__fp.*._IO_read_ptr >= __fp.*._IO_read_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __uflow(__fp) else @bitCast(c_int, @as(c_uint, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), blk: {
+ const ref = &__fp.*._IO_read_ptr;
+ const tmp = ref.*;
+ ref.* += 1;
+ break :blk tmp;
+ })).*));
+}
+pub extern fn fputc(__c: c_int, __stream: [*c]FILE) c_int;
+pub extern fn putc(__c: c_int, __stream: [*c]FILE) c_int;
+pub fn putchar(arg___c: c_int) callconv(.C) c_int {
+ var __c = arg___c;
+ return putc(__c, stdout);
+}
+pub fn fputc_unlocked(arg___c: c_int, arg___stream: [*c]FILE) callconv(.C) c_int {
+ var __c = arg___c;
+ var __stream = arg___stream;
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(__stream.*._IO_write_ptr >= __stream.*._IO_write_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __overflow(__stream, @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(i8, __c))))) else @bitCast(c_int, @as(c_uint, @bitCast(u8, blk: {
+ const tmp = @bitCast(u8, @truncate(i8, __c));
+ (blk_1: {
+ const ref = &__stream.*._IO_write_ptr;
+ const tmp_2 = ref.*;
+ ref.* += 1;
+ break :blk_1 tmp_2;
+ }).* = tmp;
+ break :blk tmp;
+ })));
+}
+pub fn putc_unlocked(arg___c: c_int, arg___stream: [*c]FILE) callconv(.C) c_int {
+ var __c = arg___c;
+ var __stream = arg___stream;
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(__stream.*._IO_write_ptr >= __stream.*._IO_write_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __overflow(__stream, @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(i8, __c))))) else @bitCast(c_int, @as(c_uint, @bitCast(u8, blk: {
+ const tmp = @bitCast(u8, @truncate(i8, __c));
+ (blk_1: {
+ const ref = &__stream.*._IO_write_ptr;
+ const tmp_2 = ref.*;
+ ref.* += 1;
+ break :blk_1 tmp_2;
+ }).* = tmp;
+ break :blk tmp;
+ })));
+}
+pub fn putchar_unlocked(arg___c: c_int) callconv(.C) c_int {
+ var __c = arg___c;
+ return if (__builtin_expect(@bitCast(c_long, @as(c_long, @boolToInt(stdout.*._IO_write_ptr >= stdout.*._IO_write_end))), @bitCast(c_long, @as(c_long, @as(c_int, 0)))) != 0) __overflow(stdout, @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(i8, __c))))) else @bitCast(c_int, @as(c_uint, @bitCast(u8, blk: {
+ const tmp = @bitCast(u8, @truncate(i8, __c));
+ (blk_1: {
+ const ref = &stdout.*._IO_write_ptr;
+ const tmp_2 = ref.*;
+ ref.* += 1;
+ break :blk_1 tmp_2;
+ }).* = tmp;
+ break :blk tmp;
+ })));
+}
+pub extern fn getw(__stream: [*c]FILE) c_int;
+pub extern fn putw(__w: c_int, __stream: [*c]FILE) c_int;
+pub extern fn fgets(noalias __s: [*c]u8, __n: c_int, noalias __stream: [*c]FILE) [*c]u8;
+pub extern fn __getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t;
+pub extern fn getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t;
+pub extern fn getline(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, noalias __stream: [*c]FILE) __ssize_t;
+pub extern fn fputs(noalias __s: [*c]const u8, noalias __stream: [*c]FILE) c_int;
+pub extern fn puts(__s: [*c]const u8) c_int;
+pub extern fn ungetc(__c: c_int, __stream: [*c]FILE) c_int;
+pub extern fn fread(__ptr: ?*anyopaque, __size: c_ulong, __n: c_ulong, __stream: [*c]FILE) c_ulong;
+pub extern fn fwrite(__ptr: ?*const anyopaque, __size: c_ulong, __n: c_ulong, __s: [*c]FILE) c_ulong;
+pub extern fn fread_unlocked(noalias __ptr: ?*anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize;
+pub extern fn fwrite_unlocked(noalias __ptr: ?*const anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize;
+pub extern fn fseek(__stream: [*c]FILE, __off: c_long, __whence: c_int) c_int;
+pub extern fn ftell(__stream: [*c]FILE) c_long;
+pub extern fn rewind(__stream: [*c]FILE) void;
+pub extern fn fseeko(__stream: [*c]FILE, __off: __off_t, __whence: c_int) c_int;
+pub extern fn ftello(__stream: [*c]FILE) __off_t;
+pub extern fn fgetpos(noalias __stream: [*c]FILE, noalias __pos: [*c]fpos_t) c_int;
+pub extern fn fsetpos(__stream: [*c]FILE, __pos: [*c]const fpos_t) c_int;
+pub extern fn clearerr(__stream: [*c]FILE) void;
+pub extern fn feof(__stream: [*c]FILE) c_int;
+pub extern fn ferror(__stream: [*c]FILE) c_int;
+pub extern fn clearerr_unlocked(__stream: [*c]FILE) void;
+pub fn feof_unlocked(arg___stream: [*c]FILE) callconv(.C) c_int {
+ var __stream = arg___stream;
+ return @boolToInt((__stream.*._flags & @as(c_int, 16)) != @as(c_int, 0));
+}
+pub fn ferror_unlocked(arg___stream: [*c]FILE) callconv(.C) c_int {
+ var __stream = arg___stream;
+ return @boolToInt((__stream.*._flags & @as(c_int, 32)) != @as(c_int, 0));
+}
+pub extern fn perror(__s: [*c]const u8) void;
+pub extern fn fileno(__stream: [*c]FILE) c_int;
+pub extern fn fileno_unlocked(__stream: [*c]FILE) c_int;
+pub extern fn pclose(__stream: [*c]FILE) c_int;
+pub extern fn popen(__command: [*c]const u8, __modes: [*c]const u8) [*c]FILE;
+pub extern fn ctermid(__s: [*c]u8) [*c]u8;
+pub extern fn flockfile(__stream: [*c]FILE) void;
+pub extern fn ftrylockfile(__stream: [*c]FILE) c_int;
+pub extern fn funlockfile(__stream: [*c]FILE) void;
+pub extern fn __uflow([*c]FILE) c_int;
+pub extern fn __overflow([*c]FILE, c_int) c_int;
+pub const wchar_t = c_int;
+pub const div_t = extern struct {
+ quot: c_int,
+ rem: c_int,
+};
+pub const ldiv_t = extern struct {
+ quot: c_long,
+ rem: c_long,
+};
+pub const lldiv_t = extern struct {
+ quot: c_longlong,
+ rem: c_longlong,
+};
+pub extern fn __ctype_get_mb_cur_max() usize;
+pub fn atof(arg___nptr: [*c]const u8) callconv(.C) f64 {
+ var __nptr = arg___nptr;
+ return strtod(__nptr, @ptrCast([*c][*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), @intToPtr(?*anyopaque, @as(c_int, 0)))));
+}
+pub fn atoi(arg___nptr: [*c]const u8) callconv(.C) c_int {
+ var __nptr = arg___nptr;
+ return @bitCast(c_int, @truncate(c_int, strtol(__nptr, @ptrCast([*c][*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), @intToPtr(?*anyopaque, @as(c_int, 0)))), @as(c_int, 10))));
+}
+pub fn atol(arg___nptr: [*c]const u8) callconv(.C) c_long {
+ var __nptr = arg___nptr;
+ return strtol(__nptr, @ptrCast([*c][*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), @intToPtr(?*anyopaque, @as(c_int, 0)))), @as(c_int, 10));
+}
+pub fn atoll(arg___nptr: [*c]const u8) callconv(.C) c_longlong {
+ var __nptr = arg___nptr;
+ return strtoll(__nptr, @ptrCast([*c][*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), @intToPtr(?*anyopaque, @as(c_int, 0)))), @as(c_int, 10));
+}
+pub extern fn strtod(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f64;
+pub extern fn strtof(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f32;
+pub extern fn strtold(__nptr: [*c]const u8, __endptr: [*c][*c]u8) c_longdouble;
+pub extern fn strtol(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_long;
+pub extern fn strtoul(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulong;
+pub extern fn strtoq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_longlong;
+pub extern fn strtouq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_ulonglong;
+pub extern fn strtoll(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_longlong;
+pub extern fn strtoull(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulonglong;
+pub extern fn l64a(__n: c_long) [*c]u8;
+pub extern fn a64l(__s: [*c]const u8) c_long;
+pub const u_char = __u_char;
+pub const u_short = __u_short;
+pub const u_int = __u_int;
+pub const u_long = __u_long;
+pub const quad_t = __quad_t;
+pub const u_quad_t = __u_quad_t;
+pub const fsid_t = __fsid_t;
+pub const loff_t = __loff_t;
+pub const ino_t = __ino_t;
+pub const dev_t = __dev_t;
+pub const gid_t = __gid_t;
+pub const mode_t = __mode_t;
+pub const nlink_t = __nlink_t;
+pub const uid_t = __uid_t;
+pub const pid_t = __pid_t;
+pub const id_t = __id_t;
+pub const daddr_t = __daddr_t;
+pub const caddr_t = __caddr_t;
+pub const key_t = __key_t;
+pub const clock_t = __clock_t;
+pub const clockid_t = __clockid_t;
+pub const time_t = __time_t;
+pub const timer_t = __timer_t;
+pub const ulong = c_ulong;
+pub const ushort = c_ushort;
+pub const uint = c_uint;
+pub const u_int8_t = __uint8_t;
+pub const u_int16_t = __uint16_t;
+pub const u_int32_t = __uint32_t;
+pub const u_int64_t = __uint64_t;
+pub const register_t = c_long;
+pub fn __bswap_16(arg___bsx: __uint16_t) callconv(.C) __uint16_t {
+ var __bsx = arg___bsx;
+ return @bitCast(__uint16_t, @truncate(c_short, ((@bitCast(c_int, @as(c_uint, __bsx)) >> @intCast(@import("std").math.Log2Int(c_int), 8)) & @as(c_int, 255)) | ((@bitCast(c_int, @as(c_uint, __bsx)) & @as(c_int, 255)) << @intCast(@import("std").math.Log2Int(c_int), 8))));
+}
+pub fn __bswap_32(arg___bsx: __uint32_t) callconv(.C) __uint32_t {
+ var __bsx = arg___bsx;
+ return ((((__bsx & @as(c_uint, 4278190080)) >> @intCast(@import("std").math.Log2Int(c_uint), 24)) | ((__bsx & @as(c_uint, 16711680)) >> @intCast(@import("std").math.Log2Int(c_uint), 8))) | ((__bsx & @as(c_uint, 65280)) << @intCast(@import("std").math.Log2Int(c_uint), 8))) | ((__bsx & @as(c_uint, 255)) << @intCast(@import("std").math.Log2Int(c_uint), 24));
+}
+pub fn __bswap_64(arg___bsx: __uint64_t) callconv(.C) __uint64_t {
+ var __bsx = arg___bsx;
+ return @bitCast(__uint64_t, @truncate(c_ulong, ((((((((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 18374686479671623680)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 56)) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 71776119061217280)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 40))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 280375465082880)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 24))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 1095216660480)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 4278190080)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 16711680)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 24))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 65280)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 40))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 255)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 56))));
+}
+pub fn __uint16_identity(arg___x: __uint16_t) callconv(.C) __uint16_t {
+ var __x = arg___x;
+ return __x;
+}
+pub fn __uint32_identity(arg___x: __uint32_t) callconv(.C) __uint32_t {
+ var __x = arg___x;
+ return __x;
+}
+pub fn __uint64_identity(arg___x: __uint64_t) callconv(.C) __uint64_t {
+ var __x = arg___x;
+ return __x;
+}
+pub const __sigset_t = extern struct {
+ __val: [16]c_ulong,
+};
+pub const sigset_t = __sigset_t;
+pub const struct_timeval = extern struct {
+ tv_sec: __time_t,
+ tv_usec: __suseconds_t,
+};
+pub const struct_timespec = extern struct {
+ tv_sec: __time_t,
+ tv_nsec: __syscall_slong_t,
+};
+pub const suseconds_t = __suseconds_t;
+pub const __fd_mask = c_long;
+pub const fd_set = extern struct {
+ __fds_bits: [16]__fd_mask,
+};
+pub const fd_mask = __fd_mask;
+pub extern fn select(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]struct_timeval) c_int;
+pub extern fn pselect(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]const struct_timespec, noalias __sigmask: [*c]const __sigset_t) c_int;
+pub const blksize_t = __blksize_t;
+pub const blkcnt_t = __blkcnt_t;
+pub const fsblkcnt_t = __fsblkcnt_t;
+pub const fsfilcnt_t = __fsfilcnt_t;
+pub const struct___pthread_internal_list = extern struct {
+ __prev: [*c]struct___pthread_internal_list,
+ __next: [*c]struct___pthread_internal_list,
+};
+pub const __pthread_list_t = struct___pthread_internal_list;
+pub const struct___pthread_internal_slist = extern struct {
+ __next: [*c]struct___pthread_internal_slist,
+};
+pub const __pthread_slist_t = struct___pthread_internal_slist;
+pub const struct___pthread_mutex_s = extern struct {
+ __lock: c_int,
+ __count: c_uint,
+ __owner: c_int,
+ __nusers: c_uint,
+ __kind: c_int,
+ __spins: c_short,
+ __elision: c_short,
+ __list: __pthread_list_t,
+};
+pub const struct___pthread_rwlock_arch_t = extern struct {
+ __readers: c_uint,
+ __writers: c_uint,
+ __wrphase_futex: c_uint,
+ __writers_futex: c_uint,
+ __pad3: c_uint,
+ __pad4: c_uint,
+ __cur_writer: c_int,
+ __shared: c_int,
+ __rwelision: i8,
+ __pad1: [7]u8,
+ __pad2: c_ulong,
+ __flags: c_uint,
+};
+const struct_unnamed_3 = extern struct {
+ __low: c_uint,
+ __high: c_uint,
+};
+const union_unnamed_2 = extern union {
+ __wseq: c_ulonglong,
+ __wseq32: struct_unnamed_3,
+};
+const struct_unnamed_5 = extern struct {
+ __low: c_uint,
+ __high: c_uint,
+};
+const union_unnamed_4 = extern union {
+ __g1_start: c_ulonglong,
+ __g1_start32: struct_unnamed_5,
+};
+pub const struct___pthread_cond_s = extern struct {
+ unnamed_0: union_unnamed_2,
+ unnamed_1: union_unnamed_4,
+ __g_refs: [2]c_uint,
+ __g_size: [2]c_uint,
+ __g1_orig_size: c_uint,
+ __wrefs: c_uint,
+ __g_signals: [2]c_uint,
+};
+pub const __tss_t = c_uint;
+pub const __thrd_t = c_ulong;
+pub const __once_flag = extern struct {
+ __data: c_int,
+};
+pub const pthread_t = c_ulong;
+pub const pthread_mutexattr_t = extern union {
+ __size: [4]u8,
+ __align: c_int,
+};
+pub const pthread_condattr_t = extern union {
+ __size: [4]u8,
+ __align: c_int,
+};
+pub const pthread_key_t = c_uint;
+pub const pthread_once_t = c_int;
+pub const union_pthread_attr_t = extern union {
+ __size: [56]u8,
+ __align: c_long,
+};
+pub const pthread_attr_t = union_pthread_attr_t;
+pub const pthread_mutex_t = extern union {
+ __data: struct___pthread_mutex_s,
+ __size: [40]u8,
+ __align: c_long,
+};
+pub const pthread_cond_t = extern union {
+ __data: struct___pthread_cond_s,
+ __size: [48]u8,
+ __align: c_longlong,
+};
+pub const pthread_rwlock_t = extern union {
+ __data: struct___pthread_rwlock_arch_t,
+ __size: [56]u8,
+ __align: c_long,
+};
+pub const pthread_rwlockattr_t = extern union {
+ __size: [8]u8,
+ __align: c_long,
+};
+pub const pthread_spinlock_t = c_int;
+pub const pthread_barrier_t = extern union {
+ __size: [32]u8,
+ __align: c_long,
+};
+pub const pthread_barrierattr_t = extern union {
+ __size: [4]u8,
+ __align: c_int,
+};
+pub extern fn random() c_long;
+pub extern fn srandom(__seed: c_uint) void;
+pub extern fn initstate(__seed: c_uint, __statebuf: [*c]u8, __statelen: usize) [*c]u8;
+pub extern fn setstate(__statebuf: [*c]u8) [*c]u8;
+pub const struct_random_data = extern struct {
+ fptr: [*c]i32,
+ rptr: [*c]i32,
+ state: [*c]i32,
+ rand_type: c_int,
+ rand_deg: c_int,
+ rand_sep: c_int,
+ end_ptr: [*c]i32,
+};
+pub extern fn random_r(noalias __buf: [*c]struct_random_data, noalias __result: [*c]i32) c_int;
+pub extern fn srandom_r(__seed: c_uint, __buf: [*c]struct_random_data) c_int;
+pub extern fn initstate_r(__seed: c_uint, noalias __statebuf: [*c]u8, __statelen: usize, noalias __buf: [*c]struct_random_data) c_int;
+pub extern fn setstate_r(noalias __statebuf: [*c]u8, noalias __buf: [*c]struct_random_data) c_int;
+pub extern fn rand() c_int;
+pub extern fn srand(__seed: c_uint) void;
+pub extern fn rand_r(__seed: [*c]c_uint) c_int;
+pub extern fn drand48() f64;
+pub extern fn erand48(__xsubi: [*c]c_ushort) f64;
+pub extern fn lrand48() c_long;
+pub extern fn nrand48(__xsubi: [*c]c_ushort) c_long;
+pub extern fn mrand48() c_long;
+pub extern fn jrand48(__xsubi: [*c]c_ushort) c_long;
+pub extern fn srand48(__seedval: c_long) void;
+pub extern fn seed48(__seed16v: [*c]c_ushort) [*c]c_ushort;
+pub extern fn lcong48(__param: [*c]c_ushort) void;
+pub const struct_drand48_data = extern struct {
+ __x: [3]c_ushort,
+ __old_x: [3]c_ushort,
+ __c: c_ushort,
+ __init: c_ushort,
+ __a: c_ulonglong,
+};
+pub extern fn drand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int;
+pub extern fn erand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int;
+pub extern fn lrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int;
+pub extern fn nrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int;
+pub extern fn mrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int;
+pub extern fn jrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int;
+pub extern fn srand48_r(__seedval: c_long, __buffer: [*c]struct_drand48_data) c_int;
+pub extern fn seed48_r(__seed16v: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int;
+pub extern fn lcong48_r(__param: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int;
+pub extern fn malloc(__size: c_ulong) ?*anyopaque;
+pub extern fn calloc(__nmemb: c_ulong, __size: c_ulong) ?*anyopaque;
+pub extern fn realloc(__ptr: ?*anyopaque, __size: c_ulong) ?*anyopaque;
+pub extern fn free(__ptr: ?*anyopaque) void;
+pub extern fn reallocarray(__ptr: ?*anyopaque, __nmemb: usize, __size: usize) ?*anyopaque;
+pub extern fn alloca(__size: c_ulong) ?*anyopaque;
+pub extern fn valloc(__size: usize) ?*anyopaque;
+pub extern fn posix_memalign(__memptr: [*c]?*anyopaque, __alignment: usize, __size: usize) c_int;
+pub extern fn aligned_alloc(__alignment: c_ulong, __size: c_ulong) ?*anyopaque;
+pub extern fn abort() noreturn;
+pub extern fn atexit(__func: ?fn () callconv(.C) void) c_int;
+pub extern fn at_quick_exit(__func: ?fn () callconv(.C) void) c_int;
+pub extern fn on_exit(__func: ?fn (c_int, ?*anyopaque) callconv(.C) void, __arg: ?*anyopaque) c_int;
+pub extern fn exit(__status: c_int) noreturn;
+pub extern fn quick_exit(__status: c_int) noreturn;
+pub extern fn _Exit(__status: c_int) noreturn;
+pub extern fn getenv(__name: [*c]const u8) [*c]u8;
+pub extern fn putenv(__string: [*c]u8) c_int;
+pub extern fn setenv(__name: [*c]const u8, __value: [*c]const u8, __replace: c_int) c_int;
+pub extern fn unsetenv(__name: [*c]const u8) c_int;
+pub extern fn clearenv() c_int;
+pub extern fn mktemp(__template: [*c]u8) [*c]u8;
+pub extern fn mkstemp(__template: [*c]u8) c_int;
+pub extern fn mkstemps(__template: [*c]u8, __suffixlen: c_int) c_int;
+pub extern fn mkdtemp(__template: [*c]u8) [*c]u8;
+pub extern fn system(__command: [*c]const u8) c_int;
+pub extern fn realpath(noalias __name: [*c]const u8, noalias __resolved: [*c]u8) [*c]u8;
+pub const __compar_fn_t = ?fn (?*const anyopaque, ?*const anyopaque) callconv(.C) c_int;
+pub fn bsearch(arg___key: ?*const anyopaque, arg___base: ?*const anyopaque, arg___nmemb: usize, arg___size: usize, arg___compar: __compar_fn_t) callconv(.C) ?*anyopaque {
+ var __key = arg___key;
+ var __base = arg___base;
+ var __nmemb = arg___nmemb;
+ var __size = arg___size;
+ var __compar = arg___compar;
+ var __l: usize = undefined;
+ var __u: usize = undefined;
+ var __idx: usize = undefined;
+ var __p: ?*const anyopaque = undefined;
+ var __comparison: c_int = undefined;
+ __l = 0;
+ __u = __nmemb;
+ while (__l < __u) {
+ __idx = (__l +% __u) / @bitCast(c_ulong, @as(c_long, @as(c_int, 2)));
+ __p = @intToPtr(?*anyopaque, @ptrToInt(@ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), __base)) + (__idx *% __size)));
+ __comparison = __compar.?(__key, __p);
+ if (__comparison < @as(c_int, 0)) {
+ __u = __idx;
+ } else if (__comparison > @as(c_int, 0)) {
+ __l = __idx +% @bitCast(c_ulong, @as(c_long, @as(c_int, 1)));
+ } else return @intToPtr(?*anyopaque, @ptrToInt(__p));
+ }
+ return @intToPtr(?*anyopaque, @as(c_int, 0));
+}
+pub extern fn qsort(__base: ?*anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) void;
+pub extern fn abs(__x: c_int) c_int;
+pub extern fn labs(__x: c_long) c_long;
+pub extern fn llabs(__x: c_longlong) c_longlong;
+pub extern fn div(__numer: c_int, __denom: c_int) div_t;
+pub extern fn ldiv(__numer: c_long, __denom: c_long) ldiv_t;
+pub extern fn lldiv(__numer: c_longlong, __denom: c_longlong) lldiv_t;
+pub extern fn ecvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8;
+pub extern fn fcvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8;
+pub extern fn gcvt(__value: f64, __ndigit: c_int, __buf: [*c]u8) [*c]u8;
+pub extern fn qecvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8;
+pub extern fn qfcvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8;
+pub extern fn qgcvt(__value: c_longdouble, __ndigit: c_int, __buf: [*c]u8) [*c]u8;
+pub extern fn ecvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int;
+pub extern fn fcvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int;
+pub extern fn qecvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int;
+pub extern fn qfcvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int;
+pub extern fn mblen(__s: [*c]const u8, __n: usize) c_int;
+pub extern fn mbtowc(noalias __pwc: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) c_int;
+pub extern fn wctomb(__s: [*c]u8, __wchar: wchar_t) c_int;
+pub extern fn mbstowcs(noalias __pwcs: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) usize;
+pub extern fn wcstombs(noalias __s: [*c]u8, noalias __pwcs: [*c]const wchar_t, __n: usize) usize;
+pub extern fn rpmatch(__response: [*c]const u8) c_int;
+pub extern fn getsubopt(noalias __optionp: [*c][*c]u8, noalias __tokens: [*c]const [*c]u8, noalias __valuep: [*c][*c]u8) c_int;
+pub extern fn getloadavg(__loadavg: [*c]f64, __nelem: c_int) c_int;
+pub extern fn memcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque;
+pub extern fn memmove(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque;
+pub extern fn memccpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque;
+pub extern fn memset(__s: ?*anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque;
+pub extern fn memcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int;
+pub extern fn memchr(__s: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque;
+pub extern fn strcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8;
+pub extern fn strncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8;
+pub extern fn strcat(__dest: [*c]u8, __src: [*c]const u8) [*c]u8;
+pub extern fn strncat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8;
+pub extern fn strcmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int;
+pub extern fn strncmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int;
+pub extern fn strcoll(__s1: [*c]const u8, __s2: [*c]const u8) c_int;
+pub extern fn strxfrm(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong;
+pub const struct___locale_data = opaque {};
+pub const struct___locale_struct = extern struct {
+ __locales: [13]?*struct___locale_data,
+ __ctype_b: [*c]const c_ushort,
+ __ctype_tolower: [*c]const c_int,
+ __ctype_toupper: [*c]const c_int,
+ __names: [13][*c]const u8,
+};
+pub const __locale_t = [*c]struct___locale_struct;
+pub const locale_t = __locale_t;
+pub extern fn strcoll_l(__s1: [*c]const u8, __s2: [*c]const u8, __l: locale_t) c_int;
+pub extern fn strxfrm_l(__dest: [*c]u8, __src: [*c]const u8, __n: usize, __l: locale_t) usize;
+pub extern fn strdup(__s: [*c]const u8) [*c]u8;
+pub extern fn strndup(__string: [*c]const u8, __n: c_ulong) [*c]u8;
+pub extern fn strchr(__s: [*c]const u8, __c: c_int) [*c]u8;
+pub extern fn strrchr(__s: [*c]const u8, __c: c_int) [*c]u8;
+pub extern fn strcspn(__s: [*c]const u8, __reject: [*c]const u8) c_ulong;
+pub extern fn strspn(__s: [*c]const u8, __accept: [*c]const u8) c_ulong;
+pub extern fn strpbrk(__s: [*c]const u8, __accept: [*c]const u8) [*c]u8;
+pub extern fn strstr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8;
+pub extern fn strtok(__s: [*c]u8, __delim: [*c]const u8) [*c]u8;
+pub extern fn __strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8;
+pub extern fn strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8;
+pub extern fn strlen(__s: [*c]const u8) c_ulong;
+pub extern fn strnlen(__string: [*c]const u8, __maxlen: usize) usize;
+pub extern fn strerror(__errnum: c_int) [*c]u8;
+pub extern fn strerror_r(__errnum: c_int, __buf: [*c]u8, __buflen: usize) c_int;
+pub extern fn strerror_l(__errnum: c_int, __l: locale_t) [*c]u8;
+pub extern fn bcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int;
+pub extern fn bcopy(__src: ?*const anyopaque, __dest: ?*anyopaque, __n: usize) void;
+pub extern fn bzero(__s: ?*anyopaque, __n: c_ulong) void;
+pub extern fn index(__s: [*c]const u8, __c: c_int) [*c]u8;
+pub extern fn rindex(__s: [*c]const u8, __c: c_int) [*c]u8;
+pub extern fn ffs(__i: c_int) c_int;
+pub extern fn ffsl(__l: c_long) c_int;
+pub extern fn ffsll(__ll: c_longlong) c_int;
+pub extern fn strcasecmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int;
+pub extern fn strncasecmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int;
+pub extern fn strcasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __loc: locale_t) c_int;
+pub extern fn strncasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __n: usize, __loc: locale_t) c_int;
+pub extern fn explicit_bzero(__s: ?*anyopaque, __n: usize) void;
+pub extern fn strsep(noalias __stringp: [*c][*c]u8, noalias __delim: [*c]const u8) [*c]u8;
+pub extern fn strsignal(__sig: c_int) [*c]u8;
+pub extern fn __stpcpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8) [*c]u8;
+pub extern fn stpcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8;
+pub extern fn __stpncpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8, __n: usize) [*c]u8;
+pub extern fn stpncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8;
+pub const float_t = f32;
+pub const double_t = f64;
+pub extern fn __fpclassify(__value: f64) c_int;
+pub extern fn __signbit(__value: f64) c_int;
+pub extern fn __isinf(__value: f64) c_int;
+pub extern fn __finite(__value: f64) c_int;
+pub extern fn __isnan(__value: f64) c_int;
+pub extern fn __iseqsig(__x: f64, __y: f64) c_int;
+pub extern fn __issignaling(__value: f64) c_int;
+pub extern fn acos(__x: f64) f64;
+pub extern fn __acos(__x: f64) f64;
+pub extern fn asin(__x: f64) f64;
+pub extern fn __asin(__x: f64) f64;
+pub extern fn atan(__x: f64) f64;
+pub extern fn __atan(__x: f64) f64;
+pub extern fn atan2(__y: f64, __x: f64) f64;
+pub extern fn __atan2(__y: f64, __x: f64) f64;
+pub extern fn cos(__x: f64) f64;
+pub extern fn __cos(__x: f64) f64;
+pub extern fn sin(__x: f64) f64;
+pub extern fn __sin(__x: f64) f64;
+pub extern fn tan(__x: f64) f64;
+pub extern fn __tan(__x: f64) f64;
+pub extern fn cosh(__x: f64) f64;
+pub extern fn __cosh(__x: f64) f64;
+pub extern fn sinh(__x: f64) f64;
+pub extern fn __sinh(__x: f64) f64;
+pub extern fn tanh(__x: f64) f64;
+pub extern fn __tanh(__x: f64) f64;
+pub extern fn acosh(__x: f64) f64;
+pub extern fn __acosh(__x: f64) f64;
+pub extern fn asinh(__x: f64) f64;
+pub extern fn __asinh(__x: f64) f64;
+pub extern fn atanh(__x: f64) f64;
+pub extern fn __atanh(__x: f64) f64;
+pub extern fn exp(__x: f64) f64;
+pub extern fn __exp(__x: f64) f64;
+pub extern fn frexp(__x: f64, __exponent: [*c]c_int) f64;
+pub extern fn __frexp(__x: f64, __exponent: [*c]c_int) f64;
+pub extern fn ldexp(__x: f64, __exponent: c_int) f64;
+pub extern fn __ldexp(__x: f64, __exponent: c_int) f64;
+pub extern fn log(__x: f64) f64;
+pub extern fn __log(__x: f64) f64;
+pub extern fn log10(__x: f64) f64;
+pub extern fn __log10(__x: f64) f64;
+pub extern fn modf(__x: f64, __iptr: [*c]f64) f64;
+pub extern fn __modf(__x: f64, __iptr: [*c]f64) f64;
+pub extern fn expm1(__x: f64) f64;
+pub extern fn __expm1(__x: f64) f64;
+pub extern fn log1p(__x: f64) f64;
+pub extern fn __log1p(__x: f64) f64;
+pub extern fn logb(__x: f64) f64;
+pub extern fn __logb(__x: f64) f64;
+pub extern fn exp2(__x: f64) f64;
+pub extern fn __exp2(__x: f64) f64;
+pub extern fn log2(__x: f64) f64;
+pub extern fn __log2(__x: f64) f64;
+pub extern fn pow(__x: f64, __y: f64) f64;
+pub extern fn __pow(__x: f64, __y: f64) f64;
+pub extern fn sqrt(__x: f64) f64;
+pub extern fn __sqrt(__x: f64) f64;
+pub extern fn hypot(__x: f64, __y: f64) f64;
+pub extern fn __hypot(__x: f64, __y: f64) f64;
+pub extern fn cbrt(__x: f64) f64;
+pub extern fn __cbrt(__x: f64) f64;
+pub extern fn ceil(__x: f64) f64;
+pub extern fn __ceil(__x: f64) f64;
+pub extern fn fabs(__x: f64) f64;
+pub extern fn __fabs(__x: f64) f64;
+pub extern fn floor(__x: f64) f64;
+pub extern fn __floor(__x: f64) f64;
+pub extern fn fmod(__x: f64, __y: f64) f64;
+pub extern fn __fmod(__x: f64, __y: f64) f64;
+pub extern fn isinf(__value: f64) c_int;
+pub extern fn finite(__value: f64) c_int;
+pub extern fn drem(__x: f64, __y: f64) f64;
+pub extern fn __drem(__x: f64, __y: f64) f64;
+pub extern fn significand(__x: f64) f64;
+pub extern fn __significand(__x: f64) f64;
+pub extern fn copysign(__x: f64, __y: f64) f64;
+pub extern fn __copysign(__x: f64, __y: f64) f64;
+pub extern fn nan(__tagb: [*c]const u8) f64;
+pub extern fn __nan(__tagb: [*c]const u8) f64;
+pub extern fn isnan(__value: f64) c_int;
+pub extern fn j0(f64) f64;
+pub extern fn __j0(f64) f64;
+pub extern fn j1(f64) f64;
+pub extern fn __j1(f64) f64;
+pub extern fn jn(c_int, f64) f64;
+pub extern fn __jn(c_int, f64) f64;
+pub extern fn y0(f64) f64;
+pub extern fn __y0(f64) f64;
+pub extern fn y1(f64) f64;
+pub extern fn __y1(f64) f64;
+pub extern fn yn(c_int, f64) f64;
+pub extern fn __yn(c_int, f64) f64;
+pub extern fn erf(f64) f64;
+pub extern fn __erf(f64) f64;
+pub extern fn erfc(f64) f64;
+pub extern fn __erfc(f64) f64;
+pub extern fn lgamma(f64) f64;
+pub extern fn __lgamma(f64) f64;
+pub extern fn tgamma(f64) f64;
+pub extern fn __tgamma(f64) f64;
+pub extern fn gamma(f64) f64;
+pub extern fn __gamma(f64) f64;
+pub extern fn lgamma_r(f64, __signgamp: [*c]c_int) f64;
+pub extern fn __lgamma_r(f64, __signgamp: [*c]c_int) f64;
+pub extern fn rint(__x: f64) f64;
+pub extern fn __rint(__x: f64) f64;
+pub extern fn nextafter(__x: f64, __y: f64) f64;
+pub extern fn __nextafter(__x: f64, __y: f64) f64;
+pub extern fn nexttoward(__x: f64, __y: c_longdouble) f64;
+pub extern fn __nexttoward(__x: f64, __y: c_longdouble) f64;
+pub extern fn remainder(__x: f64, __y: f64) f64;
+pub extern fn __remainder(__x: f64, __y: f64) f64;
+pub extern fn scalbn(__x: f64, __n: c_int) f64;
+pub extern fn __scalbn(__x: f64, __n: c_int) f64;
+pub extern fn ilogb(__x: f64) c_int;
+pub extern fn __ilogb(__x: f64) c_int;
+pub extern fn scalbln(__x: f64, __n: c_long) f64;
+pub extern fn __scalbln(__x: f64, __n: c_long) f64;
+pub extern fn nearbyint(__x: f64) f64;
+pub extern fn __nearbyint(__x: f64) f64;
+pub extern fn round(__x: f64) f64;
+pub extern fn __round(__x: f64) f64;
+pub extern fn trunc(__x: f64) f64;
+pub extern fn __trunc(__x: f64) f64;
+pub extern fn remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64;
+pub extern fn __remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64;
+pub extern fn lrint(__x: f64) c_long;
+pub extern fn __lrint(__x: f64) c_long;
+pub extern fn llrint(__x: f64) c_longlong;
+pub extern fn __llrint(__x: f64) c_longlong;
+pub extern fn lround(__x: f64) c_long;
+pub extern fn __lround(__x: f64) c_long;
+pub extern fn llround(__x: f64) c_longlong;
+pub extern fn __llround(__x: f64) c_longlong;
+pub extern fn fdim(__x: f64, __y: f64) f64;
+pub extern fn __fdim(__x: f64, __y: f64) f64;
+pub extern fn fmax(__x: f64, __y: f64) f64;
+pub extern fn __fmax(__x: f64, __y: f64) f64;
+pub extern fn fmin(__x: f64, __y: f64) f64;
+pub extern fn __fmin(__x: f64, __y: f64) f64;
+pub extern fn fma(__x: f64, __y: f64, __z: f64) f64;
+pub extern fn __fma(__x: f64, __y: f64, __z: f64) f64;
+pub extern fn scalb(__x: f64, __n: f64) f64;
+pub extern fn __scalb(__x: f64, __n: f64) f64;
+pub extern fn __fpclassifyf(__value: f32) c_int;
+pub extern fn __signbitf(__value: f32) c_int;
+pub extern fn __isinff(__value: f32) c_int;
+pub extern fn __finitef(__value: f32) c_int;
+pub extern fn __isnanf(__value: f32) c_int;
+pub extern fn __iseqsigf(__x: f32, __y: f32) c_int;
+pub extern fn __issignalingf(__value: f32) c_int;
+pub extern fn acosf(__x: f32) f32;
+pub extern fn __acosf(__x: f32) f32;
+pub extern fn asinf(__x: f32) f32;
+pub extern fn __asinf(__x: f32) f32;
+pub extern fn atanf(__x: f32) f32;
+pub extern fn __atanf(__x: f32) f32;
+pub extern fn atan2f(__y: f32, __x: f32) f32;
+pub extern fn __atan2f(__y: f32, __x: f32) f32;
+pub extern fn cosf(__x: f32) f32;
+pub extern fn __cosf(__x: f32) f32;
+pub extern fn sinf(__x: f32) f32;
+pub extern fn __sinf(__x: f32) f32;
+pub extern fn tanf(__x: f32) f32;
+pub extern fn __tanf(__x: f32) f32;
+pub extern fn coshf(__x: f32) f32;
+pub extern fn __coshf(__x: f32) f32;
+pub extern fn sinhf(__x: f32) f32;
+pub extern fn __sinhf(__x: f32) f32;
+pub extern fn tanhf(__x: f32) f32;
+pub extern fn __tanhf(__x: f32) f32;
+pub extern fn acoshf(__x: f32) f32;
+pub extern fn __acoshf(__x: f32) f32;
+pub extern fn asinhf(__x: f32) f32;
+pub extern fn __asinhf(__x: f32) f32;
+pub extern fn atanhf(__x: f32) f32;
+pub extern fn __atanhf(__x: f32) f32;
+pub extern fn expf(__x: f32) f32;
+pub extern fn __expf(__x: f32) f32;
+pub extern fn frexpf(__x: f32, __exponent: [*c]c_int) f32;
+pub extern fn __frexpf(__x: f32, __exponent: [*c]c_int) f32;
+pub extern fn ldexpf(__x: f32, __exponent: c_int) f32;
+pub extern fn __ldexpf(__x: f32, __exponent: c_int) f32;
+pub extern fn logf(__x: f32) f32;
+pub extern fn __logf(__x: f32) f32;
+pub extern fn log10f(__x: f32) f32;
+pub extern fn __log10f(__x: f32) f32;
+pub extern fn modff(__x: f32, __iptr: [*c]f32) f32;
+pub extern fn __modff(__x: f32, __iptr: [*c]f32) f32;
+pub extern fn expm1f(__x: f32) f32;
+pub extern fn __expm1f(__x: f32) f32;
+pub extern fn log1pf(__x: f32) f32;
+pub extern fn __log1pf(__x: f32) f32;
+pub extern fn logbf(__x: f32) f32;
+pub extern fn __logbf(__x: f32) f32;
+pub extern fn exp2f(__x: f32) f32;
+pub extern fn __exp2f(__x: f32) f32;
+pub extern fn log2f(__x: f32) f32;
+pub extern fn __log2f(__x: f32) f32;
+pub extern fn powf(__x: f32, __y: f32) f32;
+pub extern fn __powf(__x: f32, __y: f32) f32;
+pub extern fn sqrtf(__x: f32) f32;
+pub extern fn __sqrtf(__x: f32) f32;
+pub extern fn hypotf(__x: f32, __y: f32) f32;
+pub extern fn __hypotf(__x: f32, __y: f32) f32;
+pub extern fn cbrtf(__x: f32) f32;
+pub extern fn __cbrtf(__x: f32) f32;
+pub extern fn ceilf(__x: f32) f32;
+pub extern fn __ceilf(__x: f32) f32;
+pub extern fn fabsf(__x: f32) f32;
+pub extern fn __fabsf(__x: f32) f32;
+pub extern fn floorf(__x: f32) f32;
+pub extern fn __floorf(__x: f32) f32;
+pub extern fn fmodf(__x: f32, __y: f32) f32;
+pub extern fn __fmodf(__x: f32, __y: f32) f32;
+pub extern fn isinff(__value: f32) c_int;
+pub extern fn finitef(__value: f32) c_int;
+pub extern fn dremf(__x: f32, __y: f32) f32;
+pub extern fn __dremf(__x: f32, __y: f32) f32;
+pub extern fn significandf(__x: f32) f32;
+pub extern fn __significandf(__x: f32) f32;
+pub extern fn copysignf(__x: f32, __y: f32) f32;
+pub extern fn __copysignf(__x: f32, __y: f32) f32;
+pub extern fn nanf(__tagb: [*c]const u8) f32;
+pub extern fn __nanf(__tagb: [*c]const u8) f32;
+pub extern fn isnanf(__value: f32) c_int;
+pub extern fn j0f(f32) f32;
+pub extern fn __j0f(f32) f32;
+pub extern fn j1f(f32) f32;
+pub extern fn __j1f(f32) f32;
+pub extern fn jnf(c_int, f32) f32;
+pub extern fn __jnf(c_int, f32) f32;
+pub extern fn y0f(f32) f32;
+pub extern fn __y0f(f32) f32;
+pub extern fn y1f(f32) f32;
+pub extern fn __y1f(f32) f32;
+pub extern fn ynf(c_int, f32) f32;
+pub extern fn __ynf(c_int, f32) f32;
+pub extern fn erff(f32) f32;
+pub extern fn __erff(f32) f32;
+pub extern fn erfcf(f32) f32;
+pub extern fn __erfcf(f32) f32;
+pub extern fn lgammaf(f32) f32;
+pub extern fn __lgammaf(f32) f32;
+pub extern fn tgammaf(f32) f32;
+pub extern fn __tgammaf(f32) f32;
+pub extern fn gammaf(f32) f32;
+pub extern fn __gammaf(f32) f32;
+pub extern fn lgammaf_r(f32, __signgamp: [*c]c_int) f32;
+pub extern fn __lgammaf_r(f32, __signgamp: [*c]c_int) f32;
+pub extern fn rintf(__x: f32) f32;
+pub extern fn __rintf(__x: f32) f32;
+pub extern fn nextafterf(__x: f32, __y: f32) f32;
+pub extern fn __nextafterf(__x: f32, __y: f32) f32;
+pub extern fn nexttowardf(__x: f32, __y: c_longdouble) f32;
+pub extern fn __nexttowardf(__x: f32, __y: c_longdouble) f32;
+pub extern fn remainderf(__x: f32, __y: f32) f32;
+pub extern fn __remainderf(__x: f32, __y: f32) f32;
+pub extern fn scalbnf(__x: f32, __n: c_int) f32;
+pub extern fn __scalbnf(__x: f32, __n: c_int) f32;
+pub extern fn ilogbf(__x: f32) c_int;
+pub extern fn __ilogbf(__x: f32) c_int;
+pub extern fn scalblnf(__x: f32, __n: c_long) f32;
+pub extern fn __scalblnf(__x: f32, __n: c_long) f32;
+pub extern fn nearbyintf(__x: f32) f32;
+pub extern fn __nearbyintf(__x: f32) f32;
+pub extern fn roundf(__x: f32) f32;
+pub extern fn __roundf(__x: f32) f32;
+pub extern fn truncf(__x: f32) f32;
+pub extern fn __truncf(__x: f32) f32;
+pub extern fn remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32;
+pub extern fn __remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32;
+pub extern fn lrintf(__x: f32) c_long;
+pub extern fn __lrintf(__x: f32) c_long;
+pub extern fn llrintf(__x: f32) c_longlong;
+pub extern fn __llrintf(__x: f32) c_longlong;
+pub extern fn lroundf(__x: f32) c_long;
+pub extern fn __lroundf(__x: f32) c_long;
+pub extern fn llroundf(__x: f32) c_longlong;
+pub extern fn __llroundf(__x: f32) c_longlong;
+pub extern fn fdimf(__x: f32, __y: f32) f32;
+pub extern fn __fdimf(__x: f32, __y: f32) f32;
+pub extern fn fmaxf(__x: f32, __y: f32) f32;
+pub extern fn __fmaxf(__x: f32, __y: f32) f32;
+pub extern fn fminf(__x: f32, __y: f32) f32;
+pub extern fn __fminf(__x: f32, __y: f32) f32;
+pub extern fn fmaf(__x: f32, __y: f32, __z: f32) f32;
+pub extern fn __fmaf(__x: f32, __y: f32, __z: f32) f32;
+pub extern fn scalbf(__x: f32, __n: f32) f32;
+pub extern fn __scalbf(__x: f32, __n: f32) f32;
+pub extern fn __fpclassifyl(__value: c_longdouble) c_int;
+pub extern fn __signbitl(__value: c_longdouble) c_int;
+pub extern fn __isinfl(__value: c_longdouble) c_int;
+pub extern fn __finitel(__value: c_longdouble) c_int;
+pub extern fn __isnanl(__value: c_longdouble) c_int;
+pub extern fn __iseqsigl(__x: c_longdouble, __y: c_longdouble) c_int;
+pub extern fn __issignalingl(__value: c_longdouble) c_int;
+pub extern fn acosl(__x: c_longdouble) c_longdouble;
+pub extern fn __acosl(__x: c_longdouble) c_longdouble;
+pub extern fn asinl(__x: c_longdouble) c_longdouble;
+pub extern fn __asinl(__x: c_longdouble) c_longdouble;
+pub extern fn atanl(__x: c_longdouble) c_longdouble;
+pub extern fn __atanl(__x: c_longdouble) c_longdouble;
+pub extern fn atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble;
+pub extern fn __atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble;
+pub extern fn cosl(__x: c_longdouble) c_longdouble;
+pub extern fn __cosl(__x: c_longdouble) c_longdouble;
+pub extern fn sinl(__x: c_longdouble) c_longdouble;
+pub extern fn __sinl(__x: c_longdouble) c_longdouble;
+pub extern fn tanl(__x: c_longdouble) c_longdouble;
+pub extern fn __tanl(__x: c_longdouble) c_longdouble;
+pub extern fn coshl(__x: c_longdouble) c_longdouble;
+pub extern fn __coshl(__x: c_longdouble) c_longdouble;
+pub extern fn sinhl(__x: c_longdouble) c_longdouble;
+pub extern fn __sinhl(__x: c_longdouble) c_longdouble;
+pub extern fn tanhl(__x: c_longdouble) c_longdouble;
+pub extern fn __tanhl(__x: c_longdouble) c_longdouble;
+pub extern fn acoshl(__x: c_longdouble) c_longdouble;
+pub extern fn __acoshl(__x: c_longdouble) c_longdouble;
+pub extern fn asinhl(__x: c_longdouble) c_longdouble;
+pub extern fn __asinhl(__x: c_longdouble) c_longdouble;
+pub extern fn atanhl(__x: c_longdouble) c_longdouble;
+pub extern fn __atanhl(__x: c_longdouble) c_longdouble;
+pub extern fn expl(__x: c_longdouble) c_longdouble;
+pub extern fn __expl(__x: c_longdouble) c_longdouble;
+pub extern fn frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble;
+pub extern fn __frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble;
+pub extern fn ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble;
+pub extern fn __ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble;
+pub extern fn logl(__x: c_longdouble) c_longdouble;
+pub extern fn __logl(__x: c_longdouble) c_longdouble;
+pub extern fn log10l(__x: c_longdouble) c_longdouble;
+pub extern fn __log10l(__x: c_longdouble) c_longdouble;
+pub extern fn modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble;
+pub extern fn __modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble;
+pub extern fn expm1l(__x: c_longdouble) c_longdouble;
+pub extern fn __expm1l(__x: c_longdouble) c_longdouble;
+pub extern fn log1pl(__x: c_longdouble) c_longdouble;
+pub extern fn __log1pl(__x: c_longdouble) c_longdouble;
+pub extern fn logbl(__x: c_longdouble) c_longdouble;
+pub extern fn __logbl(__x: c_longdouble) c_longdouble;
+pub extern fn exp2l(__x: c_longdouble) c_longdouble;
+pub extern fn __exp2l(__x: c_longdouble) c_longdouble;
+pub extern fn log2l(__x: c_longdouble) c_longdouble;
+pub extern fn __log2l(__x: c_longdouble) c_longdouble;
+pub extern fn powl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __powl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn sqrtl(__x: c_longdouble) c_longdouble;
+pub extern fn __sqrtl(__x: c_longdouble) c_longdouble;
+pub extern fn hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn cbrtl(__x: c_longdouble) c_longdouble;
+pub extern fn __cbrtl(__x: c_longdouble) c_longdouble;
+pub extern fn ceill(__x: c_longdouble) c_longdouble;
+pub extern fn __ceill(__x: c_longdouble) c_longdouble;
+pub extern fn fabsl(__x: c_longdouble) c_longdouble;
+pub extern fn __fabsl(__x: c_longdouble) c_longdouble;
+pub extern fn floorl(__x: c_longdouble) c_longdouble;
+pub extern fn __floorl(__x: c_longdouble) c_longdouble;
+pub extern fn fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn isinfl(__value: c_longdouble) c_int;
+pub extern fn finitel(__value: c_longdouble) c_int;
+pub extern fn dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn significandl(__x: c_longdouble) c_longdouble;
+pub extern fn __significandl(__x: c_longdouble) c_longdouble;
+pub extern fn copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn nanl(__tagb: [*c]const u8) c_longdouble;
+pub extern fn __nanl(__tagb: [*c]const u8) c_longdouble;
+pub extern fn isnanl(__value: c_longdouble) c_int;
+pub extern fn j0l(c_longdouble) c_longdouble;
+pub extern fn __j0l(c_longdouble) c_longdouble;
+pub extern fn j1l(c_longdouble) c_longdouble;
+pub extern fn __j1l(c_longdouble) c_longdouble;
+pub extern fn jnl(c_int, c_longdouble) c_longdouble;
+pub extern fn __jnl(c_int, c_longdouble) c_longdouble;
+pub extern fn y0l(c_longdouble) c_longdouble;
+pub extern fn __y0l(c_longdouble) c_longdouble;
+pub extern fn y1l(c_longdouble) c_longdouble;
+pub extern fn __y1l(c_longdouble) c_longdouble;
+pub extern fn ynl(c_int, c_longdouble) c_longdouble;
+pub extern fn __ynl(c_int, c_longdouble) c_longdouble;
+pub extern fn erfl(c_longdouble) c_longdouble;
+pub extern fn __erfl(c_longdouble) c_longdouble;
+pub extern fn erfcl(c_longdouble) c_longdouble;
+pub extern fn __erfcl(c_longdouble) c_longdouble;
+pub extern fn lgammal(c_longdouble) c_longdouble;
+pub extern fn __lgammal(c_longdouble) c_longdouble;
+pub extern fn tgammal(c_longdouble) c_longdouble;
+pub extern fn __tgammal(c_longdouble) c_longdouble;
+pub extern fn gammal(c_longdouble) c_longdouble;
+pub extern fn __gammal(c_longdouble) c_longdouble;
+pub extern fn lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble;
+pub extern fn __lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble;
+pub extern fn rintl(__x: c_longdouble) c_longdouble;
+pub extern fn __rintl(__x: c_longdouble) c_longdouble;
+pub extern fn nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn scalbnl(__x: c_longdouble, __n: c_int) c_longdouble;
+pub extern fn __scalbnl(__x: c_longdouble, __n: c_int) c_longdouble;
+pub extern fn ilogbl(__x: c_longdouble) c_int;
+pub extern fn __ilogbl(__x: c_longdouble) c_int;
+pub extern fn scalblnl(__x: c_longdouble, __n: c_long) c_longdouble;
+pub extern fn __scalblnl(__x: c_longdouble, __n: c_long) c_longdouble;
+pub extern fn nearbyintl(__x: c_longdouble) c_longdouble;
+pub extern fn __nearbyintl(__x: c_longdouble) c_longdouble;
+pub extern fn roundl(__x: c_longdouble) c_longdouble;
+pub extern fn __roundl(__x: c_longdouble) c_longdouble;
+pub extern fn truncl(__x: c_longdouble) c_longdouble;
+pub extern fn __truncl(__x: c_longdouble) c_longdouble;
+pub extern fn remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble;
+pub extern fn __remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble;
+pub extern fn lrintl(__x: c_longdouble) c_long;
+pub extern fn __lrintl(__x: c_longdouble) c_long;
+pub extern fn llrintl(__x: c_longdouble) c_longlong;
+pub extern fn __llrintl(__x: c_longdouble) c_longlong;
+pub extern fn lroundl(__x: c_longdouble) c_long;
+pub extern fn __lroundl(__x: c_longdouble) c_long;
+pub extern fn llroundl(__x: c_longdouble) c_longlong;
+pub extern fn __llroundl(__x: c_longdouble) c_longlong;
+pub extern fn fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn __fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble;
+pub extern fn fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble;
+pub extern fn __fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble;
+pub extern fn scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble;
+pub extern fn __scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble;
+pub extern var signgam: c_int;
+pub const FP_NAN: c_int = 0;
+pub const FP_INFINITE: c_int = 1;
+pub const FP_ZERO: c_int = 2;
+pub const FP_SUBNORMAL: c_int = 3;
+pub const FP_NORMAL: c_int = 4;
+const enum_unnamed_6 = c_uint;
+pub const RICON_NONE: c_int = 0;
+pub const RICON_FOLDER_FILE_OPEN: c_int = 1;
+pub const RICON_FILE_SAVE_CLASSIC: c_int = 2;
+pub const RICON_FOLDER_OPEN: c_int = 3;
+pub const RICON_FOLDER_SAVE: c_int = 4;
+pub const RICON_FILE_OPEN: c_int = 5;
+pub const RICON_FILE_SAVE: c_int = 6;
+pub const RICON_FILE_EXPORT: c_int = 7;
+pub const RICON_FILE_NEW: c_int = 8;
+pub const RICON_FILE_DELETE: c_int = 9;
+pub const RICON_FILETYPE_TEXT: c_int = 10;
+pub const RICON_FILETYPE_AUDIO: c_int = 11;
+pub const RICON_FILETYPE_IMAGE: c_int = 12;
+pub const RICON_FILETYPE_PLAY: c_int = 13;
+pub const RICON_FILETYPE_VIDEO: c_int = 14;
+pub const RICON_FILETYPE_INFO: c_int = 15;
+pub const RICON_FILE_COPY: c_int = 16;
+pub const RICON_FILE_CUT: c_int = 17;
+pub const RICON_FILE_PASTE: c_int = 18;
+pub const RICON_CURSOR_HAND: c_int = 19;
+pub const RICON_CURSOR_POINTER: c_int = 20;
+pub const RICON_CURSOR_CLASSIC: c_int = 21;
+pub const RICON_PENCIL: c_int = 22;
+pub const RICON_PENCIL_BIG: c_int = 23;
+pub const RICON_BRUSH_CLASSIC: c_int = 24;
+pub const RICON_BRUSH_PAINTER: c_int = 25;
+pub const RICON_WATER_DROP: c_int = 26;
+pub const RICON_COLOR_PICKER: c_int = 27;
+pub const RICON_RUBBER: c_int = 28;
+pub const RICON_COLOR_BUCKET: c_int = 29;
+pub const RICON_TEXT_T: c_int = 30;
+pub const RICON_TEXT_A: c_int = 31;
+pub const RICON_SCALE: c_int = 32;
+pub const RICON_RESIZE: c_int = 33;
+pub const RICON_FILTER_POINT: c_int = 34;
+pub const RICON_FILTER_BILINEAR: c_int = 35;
+pub const RICON_CROP: c_int = 36;
+pub const RICON_CROP_ALPHA: c_int = 37;
+pub const RICON_SQUARE_TOGGLE: c_int = 38;
+pub const RICON_SYMMETRY: c_int = 39;
+pub const RICON_SYMMETRY_HORIZONTAL: c_int = 40;
+pub const RICON_SYMMETRY_VERTICAL: c_int = 41;
+pub const RICON_LENS: c_int = 42;
+pub const RICON_LENS_BIG: c_int = 43;
+pub const RICON_EYE_ON: c_int = 44;
+pub const RICON_EYE_OFF: c_int = 45;
+pub const RICON_FILTER_TOP: c_int = 46;
+pub const RICON_FILTER: c_int = 47;
+pub const RICON_TARGET_POINT: c_int = 48;
+pub const RICON_TARGET_SMALL: c_int = 49;
+pub const RICON_TARGET_BIG: c_int = 50;
+pub const RICON_TARGET_MOVE: c_int = 51;
+pub const RICON_CURSOR_MOVE: c_int = 52;
+pub const RICON_CURSOR_SCALE: c_int = 53;
+pub const RICON_CURSOR_SCALE_RIGHT: c_int = 54;
+pub const RICON_CURSOR_SCALE_LEFT: c_int = 55;
+pub const RICON_UNDO: c_int = 56;
+pub const RICON_REDO: c_int = 57;
+pub const RICON_REREDO: c_int = 58;
+pub const RICON_MUTATE: c_int = 59;
+pub const RICON_ROTATE: c_int = 60;
+pub const RICON_REPEAT: c_int = 61;
+pub const RICON_SHUFFLE: c_int = 62;
+pub const RICON_EMPTYBOX: c_int = 63;
+pub const RICON_TARGET: c_int = 64;
+pub const RICON_TARGET_SMALL_FILL: c_int = 65;
+pub const RICON_TARGET_BIG_FILL: c_int = 66;
+pub const RICON_TARGET_MOVE_FILL: c_int = 67;
+pub const RICON_CURSOR_MOVE_FILL: c_int = 68;
+pub const RICON_CURSOR_SCALE_FILL: c_int = 69;
+pub const RICON_CURSOR_SCALE_RIGHT_FILL: c_int = 70;
+pub const RICON_CURSOR_SCALE_LEFT_FILL: c_int = 71;
+pub const RICON_UNDO_FILL: c_int = 72;
+pub const RICON_REDO_FILL: c_int = 73;
+pub const RICON_REREDO_FILL: c_int = 74;
+pub const RICON_MUTATE_FILL: c_int = 75;
+pub const RICON_ROTATE_FILL: c_int = 76;
+pub const RICON_REPEAT_FILL: c_int = 77;
+pub const RICON_SHUFFLE_FILL: c_int = 78;
+pub const RICON_EMPTYBOX_SMALL: c_int = 79;
+pub const RICON_BOX: c_int = 80;
+pub const RICON_BOX_TOP: c_int = 81;
+pub const RICON_BOX_TOP_RIGHT: c_int = 82;
+pub const RICON_BOX_RIGHT: c_int = 83;
+pub const RICON_BOX_BOTTOM_RIGHT: c_int = 84;
+pub const RICON_BOX_BOTTOM: c_int = 85;
+pub const RICON_BOX_BOTTOM_LEFT: c_int = 86;
+pub const RICON_BOX_LEFT: c_int = 87;
+pub const RICON_BOX_TOP_LEFT: c_int = 88;
+pub const RICON_BOX_CENTER: c_int = 89;
+pub const RICON_BOX_CIRCLE_MASK: c_int = 90;
+pub const RICON_POT: c_int = 91;
+pub const RICON_ALPHA_MULTIPLY: c_int = 92;
+pub const RICON_ALPHA_CLEAR: c_int = 93;
+pub const RICON_DITHERING: c_int = 94;
+pub const RICON_MIPMAPS: c_int = 95;
+pub const RICON_BOX_GRID: c_int = 96;
+pub const RICON_GRID: c_int = 97;
+pub const RICON_BOX_CORNERS_SMALL: c_int = 98;
+pub const RICON_BOX_CORNERS_BIG: c_int = 99;
+pub const RICON_FOUR_BOXES: c_int = 100;
+pub const RICON_GRID_FILL: c_int = 101;
+pub const RICON_BOX_MULTISIZE: c_int = 102;
+pub const RICON_ZOOM_SMALL: c_int = 103;
+pub const RICON_ZOOM_MEDIUM: c_int = 104;
+pub const RICON_ZOOM_BIG: c_int = 105;
+pub const RICON_ZOOM_ALL: c_int = 106;
+pub const RICON_ZOOM_CENTER: c_int = 107;
+pub const RICON_BOX_DOTS_SMALL: c_int = 108;
+pub const RICON_BOX_DOTS_BIG: c_int = 109;
+pub const RICON_BOX_CONCENTRIC: c_int = 110;
+pub const RICON_BOX_GRID_BIG: c_int = 111;
+pub const RICON_OK_TICK: c_int = 112;
+pub const RICON_CROSS: c_int = 113;
+pub const RICON_ARROW_LEFT: c_int = 114;
+pub const RICON_ARROW_RIGHT: c_int = 115;
+pub const RICON_ARROW_DOWN: c_int = 116;
+pub const RICON_ARROW_UP: c_int = 117;
+pub const RICON_ARROW_LEFT_FILL: c_int = 118;
+pub const RICON_ARROW_RIGHT_FILL: c_int = 119;
+pub const RICON_ARROW_DOWN_FILL: c_int = 120;
+pub const RICON_ARROW_UP_FILL: c_int = 121;
+pub const RICON_AUDIO: c_int = 122;
+pub const RICON_FX: c_int = 123;
+pub const RICON_WAVE: c_int = 124;
+pub const RICON_WAVE_SINUS: c_int = 125;
+pub const RICON_WAVE_SQUARE: c_int = 126;
+pub const RICON_WAVE_TRIANGULAR: c_int = 127;
+pub const RICON_CROSS_SMALL: c_int = 128;
+pub const RICON_PLAYER_PREVIOUS: c_int = 129;
+pub const RICON_PLAYER_PLAY_BACK: c_int = 130;
+pub const RICON_PLAYER_PLAY: c_int = 131;
+pub const RICON_PLAYER_PAUSE: c_int = 132;
+pub const RICON_PLAYER_STOP: c_int = 133;
+pub const RICON_PLAYER_NEXT: c_int = 134;
+pub const RICON_PLAYER_RECORD: c_int = 135;
+pub const RICON_MAGNET: c_int = 136;
+pub const RICON_LOCK_CLOSE: c_int = 137;
+pub const RICON_LOCK_OPEN: c_int = 138;
+pub const RICON_CLOCK: c_int = 139;
+pub const RICON_TOOLS: c_int = 140;
+pub const RICON_GEAR: c_int = 141;
+pub const RICON_GEAR_BIG: c_int = 142;
+pub const RICON_BIN: c_int = 143;
+pub const RICON_HAND_POINTER: c_int = 144;
+pub const RICON_LASER: c_int = 145;
+pub const RICON_COIN: c_int = 146;
+pub const RICON_EXPLOSION: c_int = 147;
+pub const RICON_1UP: c_int = 148;
+pub const RICON_PLAYER: c_int = 149;
+pub const RICON_PLAYER_JUMP: c_int = 150;
+pub const RICON_KEY: c_int = 151;
+pub const RICON_DEMON: c_int = 152;
+pub const RICON_TEXT_POPUP: c_int = 153;
+pub const RICON_GEAR_EX: c_int = 154;
+pub const RICON_CRACK: c_int = 155;
+pub const RICON_CRACK_POINTS: c_int = 156;
+pub const RICON_STAR: c_int = 157;
+pub const RICON_DOOR: c_int = 158;
+pub const RICON_EXIT: c_int = 159;
+pub const RICON_MODE_2D: c_int = 160;
+pub const RICON_MODE_3D: c_int = 161;
+pub const RICON_CUBE: c_int = 162;
+pub const RICON_CUBE_FACE_TOP: c_int = 163;
+pub const RICON_CUBE_FACE_LEFT: c_int = 164;
+pub const RICON_CUBE_FACE_FRONT: c_int = 165;
+pub const RICON_CUBE_FACE_BOTTOM: c_int = 166;
+pub const RICON_CUBE_FACE_RIGHT: c_int = 167;
+pub const RICON_CUBE_FACE_BACK: c_int = 168;
+pub const RICON_CAMERA: c_int = 169;
+pub const RICON_SPECIAL: c_int = 170;
+pub const RICON_LINK_NET: c_int = 171;
+pub const RICON_LINK_BOXES: c_int = 172;
+pub const RICON_LINK_MULTI: c_int = 173;
+pub const RICON_LINK: c_int = 174;
+pub const RICON_LINK_BROKE: c_int = 175;
+pub const RICON_TEXT_NOTES: c_int = 176;
+pub const RICON_NOTEBOOK: c_int = 177;
+pub const RICON_SUITCASE: c_int = 178;
+pub const RICON_SUITCASE_ZIP: c_int = 179;
+pub const RICON_MAILBOX: c_int = 180;
+pub const RICON_MONITOR: c_int = 181;
+pub const RICON_PRINTER: c_int = 182;
+pub const RICON_PHOTO_CAMERA: c_int = 183;
+pub const RICON_PHOTO_CAMERA_FLASH: c_int = 184;
+pub const RICON_HOUSE: c_int = 185;
+pub const RICON_HEART: c_int = 186;
+pub const RICON_CORNER: c_int = 187;
+pub const RICON_VERTICAL_BARS: c_int = 188;
+pub const RICON_VERTICAL_BARS_FILL: c_int = 189;
+pub const RICON_LIFE_BARS: c_int = 190;
+pub const RICON_INFO: c_int = 191;
+pub const RICON_CROSSLINE: c_int = 192;
+pub const RICON_HELP: c_int = 193;
+pub const RICON_FILETYPE_ALPHA: c_int = 194;
+pub const RICON_FILETYPE_HOME: c_int = 195;
+pub const RICON_LAYERS_VISIBLE: c_int = 196;
+pub const RICON_LAYERS: c_int = 197;
+pub const RICON_WINDOW: c_int = 198;
+pub const RICON_HIDPI: c_int = 199;
+pub const RICON_200: c_int = 200;
+pub const RICON_201: c_int = 201;
+pub const RICON_202: c_int = 202;
+pub const RICON_203: c_int = 203;
+pub const RICON_204: c_int = 204;
+pub const RICON_205: c_int = 205;
+pub const RICON_206: c_int = 206;
+pub const RICON_207: c_int = 207;
+pub const RICON_208: c_int = 208;
+pub const RICON_209: c_int = 209;
+pub const RICON_210: c_int = 210;
+pub const RICON_211: c_int = 211;
+pub const RICON_212: c_int = 212;
+pub const RICON_213: c_int = 213;
+pub const RICON_214: c_int = 214;
+pub const RICON_215: c_int = 215;
+pub const RICON_216: c_int = 216;
+pub const RICON_217: c_int = 217;
+pub const RICON_218: c_int = 218;
+pub const RICON_219: c_int = 219;
+pub const RICON_220: c_int = 220;
+pub const RICON_221: c_int = 221;
+pub const RICON_222: c_int = 222;
+pub const RICON_223: c_int = 223;
+pub const RICON_224: c_int = 224;
+pub const RICON_225: c_int = 225;
+pub const RICON_226: c_int = 226;
+pub const RICON_227: c_int = 227;
+pub const RICON_228: c_int = 228;
+pub const RICON_229: c_int = 229;
+pub const RICON_230: c_int = 230;
+pub const RICON_231: c_int = 231;
+pub const RICON_232: c_int = 232;
+pub const RICON_233: c_int = 233;
+pub const RICON_234: c_int = 234;
+pub const RICON_235: c_int = 235;
+pub const RICON_236: c_int = 236;
+pub const RICON_237: c_int = 237;
+pub const RICON_238: c_int = 238;
+pub const RICON_239: c_int = 239;
+pub const RICON_240: c_int = 240;
+pub const RICON_241: c_int = 241;
+pub const RICON_242: c_int = 242;
+pub const RICON_243: c_int = 243;
+pub const RICON_244: c_int = 244;
+pub const RICON_245: c_int = 245;
+pub const RICON_246: c_int = 246;
+pub const RICON_247: c_int = 247;
+pub const RICON_248: c_int = 248;
+pub const RICON_249: c_int = 249;
+pub const RICON_250: c_int = 250;
+pub const RICON_251: c_int = 251;
+pub const RICON_252: c_int = 252;
+pub const RICON_253: c_int = 253;
+pub const RICON_254: c_int = 254;
+pub const RICON_255: c_int = 255;
+pub const guiIconName = c_uint;
+pub var guiIcons: [2048]c_uint = [2048]c_uint{
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073217536)),
+ @bitCast(c_uint, @as(c_int, 789061640)),
+ @bitCast(c_uint, @as(c_int, 541204606)),
+ @bitCast(c_uint, @as(c_int, 1073905602)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 1073610752)),
+ @bitCast(c_uint, @as(c_int, 1143104546)),
+ @bitCast(c_uint, @as(c_int, 1073891298)),
+ @bitCast(c_uint, @as(c_int, 1610235906)),
+ @bitCast(c_uint, @as(c_int, 1474973706)),
+ @bitCast(c_uint, @as(c_int, 1342853130)),
+ @bitCast(c_uint, @as(c_int, 1073897466)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 4325502)),
+ @bitCast(c_uint, @as(c_int, 1073905602)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1090666498)),
+ @bitCast(c_uint, @as(c_int, 1145193090)),
+ @bitCast(c_uint, @as(c_int, 2034123010)),
+ @bitCast(c_uint, @as(c_int, 256)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 4325502)),
+ @bitCast(c_uint, @as(c_int, 1073905602)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1090666754)),
+ @bitCast(c_uint, @as(c_int, 1145192706)),
+ @bitCast(c_uint, @as(c_int, 2034123394)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 553918468)),
+ @bitCast(c_uint, @as(c_int, 608445060)),
+ @bitCast(c_uint, @as(c_int, 553918724)),
+ @bitCast(c_uint, @as(c_int, 537141508)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 553918468)),
+ @bitCast(c_uint, @as(c_int, 553918724)),
+ @bitCast(c_uint, @as(c_int, 579085380)),
+ @bitCast(c_uint, @as(c_int, 537141508)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 270340)),
+ @bitCast(c_uint, @as(c_int, 537137156)),
+ @bitCast(c_uint, @as(c_int, 545539972)),
+ @bitCast(c_uint, @as(c_int, 8655748)),
+ @bitCast(c_uint, @as(c_int, 537143172)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 570696196)),
+ @bitCast(c_uint, @as(c_int, 570699652)),
+ @bitCast(c_uint, @as(c_int, 537141764)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 621029508)),
+ @bitCast(c_uint, @as(c_int, 621027844)),
+ @bitCast(c_uint, @as(c_int, 537143428)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 654581764)),
+ @bitCast(c_uint, @as(c_int, 608445636)),
+ @bitCast(c_uint, @as(c_int, 641999940)),
+ @bitCast(c_uint, @as(c_int, 543434340)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 637806084)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 893659268)),
+ @bitCast(c_uint, @as(c_int, 605299244)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 549724164)),
+ @bitCast(c_uint, @as(c_int, 574890308)),
+ @bitCast(c_uint, @as(c_int, 574891076)),
+ @bitCast(c_uint, @as(c_int, 549724484)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 1073491952)),
+ @bitCast(c_uint, @as(c_int, 1060909044)),
+ @bitCast(c_uint, @as(c_int, 1035742900)),
+ @bitCast(c_uint, @as(c_int, 1035742132)),
+ @bitCast(c_uint, @as(c_int, 1060908724)),
+ @bitCast(c_uint, @as(c_int, 1073491956)),
+ @bitCast(c_uint, @as(c_int, 12276)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 562307460)),
+ @bitCast(c_uint, @as(c_int, 562307076)),
+ @bitCast(c_uint, @as(c_int, 562307460)),
+ @bitCast(c_uint, @as(c_int, 562307460)),
+ @bitCast(c_uint, @as(c_int, 537141636)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 941361168)),
+ @bitCast(c_uint, @as(c_int, 671361028)),
+ @bitCast(c_uint, @as(c_int, 671361028)),
+ @bitCast(c_uint, @as(c_int, 671361028)),
+ @bitCast(c_uint, @as(c_int, 671361028)),
+ @bitCast(c_uint, @as(c_int, 537931772)),
+ @bitCast(c_uint, @as(c_int, 16368)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1880883200)),
+ @bitCast(c_uint, @as(c_int, 127671828)),
+ @bitCast(c_uint, @as(c_int, 1436549360)),
+ @bitCast(c_uint, @as(c_int, 127664368)),
+ @bitCast(c_uint, @as(c_int, 1880890900)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 29360128)),
+ @bitCast(c_uint, @as(c_int, 333716460)),
+ @bitCast(c_uint, @as(c_int, 1065619460)),
+ @bitCast(c_uint, @as(c_int, 541335748)),
+ @bitCast(c_uint, @as(c_int, 541335620)),
+ @bitCast(c_uint, @as(c_int, 541335620)),
+ @bitCast(c_uint, @as(c_int, 545005636)),
+ @bitCast(c_uint, @as(c_int, 16320)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 983568352)),
+ @bitCast(c_uint, @as(c_int, 716974752)),
+ @bitCast(c_uint, @as(c_int, 715401892)),
+ @bitCast(c_uint, @as(c_int, 537143972)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 3932172)),
+ @bitCast(c_uint, @as(c_int, 50856136)),
+ @bitCast(c_uint, @as(c_int, 806358032)),
+ @bitCast(c_uint, @as(c_int, 270540832)),
+ @bitCast(c_uint, @as(c_int, 71305280)),
+ @bitCast(c_uint, @as(c_int, 25166464)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1572864)),
+ @bitCast(c_uint, @as(c_int, 32505976)),
+ @bitCast(c_uint, @as(c_int, 65013744)),
+ @bitCast(c_uint, @as(c_int, 130024416)),
+ @bitCast(c_uint, @as(c_int, 67112512)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 67108864)),
+ @bitCast(c_uint, @as(c_int, 285215232)),
+ @bitCast(c_uint, @as(c_int, 71305856)),
+ @bitCast(c_uint, @as(c_int, 17826336)),
+ @bitCast(c_uint, @as(c_int, 5767304)),
+ 56,
+ 0,
+ @bitCast(c_uint, @as(c_int, 67108864)),
+ @bitCast(c_uint, @as(c_int, 352324096)),
+ @bitCast(c_uint, @as(c_int, 1346381952)),
+ @bitCast(c_uint, @as(c_int, 336603168)),
+ @bitCast(c_uint, @as(c_int, 84150792)),
+ @bitCast(c_uint, @as(c_int, 22807180)),
+ @bitCast(c_uint, @as(c_int, 8126652)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 29360128)),
+ @bitCast(c_uint, @as(c_int, 20971840)),
+ @bitCast(c_uint, @as(c_int, 20971840)),
+ @bitCast(c_uint, @as(c_int, 267911488)),
+ @bitCast(c_uint, @as(c_int, 267913224)),
+ @bitCast(c_uint, @as(c_int, 178784264)),
+ @bitCast(c_uint, @as(c_int, 178784936)),
+ @bitCast(c_uint, @as(c_int, 4088)),
+ @bitCast(c_uint, @as(c_int, 536608768)),
+ @bitCast(c_uint, @as(c_int, 1610383358)),
+ @bitCast(c_uint, @as(c_int, 1073758208)),
+ @bitCast(c_uint, @as(c_int, 8421248)),
+ @bitCast(c_uint, @as(c_int, 29360576)),
+ @bitCast(c_uint, @as(c_int, 29360576)),
+ @bitCast(c_uint, @as(c_int, 29360576)),
+ 128,
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 29360256)),
+ @bitCast(c_uint, @as(c_int, 65012160)),
+ @bitCast(c_uint, @as(c_int, 133170144)),
+ @bitCast(c_uint, @as(c_int, 56624880)),
+ @bitCast(c_uint, @as(c_int, 448)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1040201728)),
+ @bitCast(c_uint, @as(c_int, 528498560)),
+ @bitCast(c_uint, @as(c_int, 203431488)),
+ @bitCast(c_uint, @as(c_int, 34081808)),
+ @bitCast(c_uint, @as(c_int, 8651012)),
+ @bitCast(c_uint, @as(c_int, 3670084)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 125829888)),
+ @bitCast(c_uint, @as(c_int, 534777792)),
+ @bitCast(c_uint, @as(c_int, 1065893840)),
+ @bitCast(c_uint, @as(c_int, 235020036)),
+ @bitCast(c_uint, @as(c_int, 33817602)),
+ @bitCast(c_uint, @as(c_int, 15728904)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 12582912)),
+ @bitCast(c_uint, @as(c_int, 41943360)),
+ @bitCast(c_uint, @as(c_int, 136315968)),
+ @bitCast(c_uint, @as(c_int, 537399312)),
+ @bitCast(c_uint, @as(c_int, 805187588)),
+ @bitCast(c_uint, @as(c_int, 66586620)),
+ @bitCast(c_uint, @as(c_int, 14680560)),
+ 64,
+ 0,
+ @bitCast(c_uint, @as(c_int, 562315260)),
+ @bitCast(c_uint, @as(c_int, 25166208)),
+ @bitCast(c_uint, @as(c_int, 25166208)),
+ @bitCast(c_uint, @as(c_int, 25166208)),
+ @bitCast(c_uint, @as(c_int, 25166208)),
+ @bitCast(c_uint, @as(c_int, 62914944)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 20971904)),
+ @bitCast(c_uint, @as(c_int, 102761280)),
+ @bitCast(c_uint, @as(c_int, 202376736)),
+ @bitCast(c_uint, @as(c_int, 536349712)),
+ @bitCast(c_uint, @as(c_int, 940316680)),
+ @bitCast(c_uint, @as(c_int, 1879470084)),
+ @bitCast(c_uint, @as(c_int, 63503)),
+ @bitCast(c_uint, @as(c_int, 2013265920)),
+ @bitCast(c_uint, @as(c_int, 1342193664)),
+ @bitCast(c_uint, @as(c_int, 18432)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 1048576)),
+ @bitCast(c_uint, @as(c_int, 131082)),
+ 14,
+ @bitCast(c_uint, @as(c_int, 1968570368)),
+ @bitCast(c_uint, @as(c_int, 1577074690)),
+ @bitCast(c_uint, @as(c_int, 1409290242)),
+ @bitCast(c_uint, @as(c_int, 1090523650)),
+ @bitCast(c_uint, @as(c_int, 1082261758)),
+ @bitCast(c_uint, @as(c_int, 1082261634)),
+ @bitCast(c_uint, @as(c_int, 1082261634)),
+ @bitCast(c_uint, @as(c_int, 27390)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1056980736)),
+ @bitCast(c_uint, @as(c_int, 1056980736)),
+ @bitCast(c_uint, @as(c_int, 1056980736)),
+ @bitCast(c_uint, @as(c_int, 4194432)),
+ @bitCast(c_uint, @as(c_int, 1835040)),
+ @bitCast(c_uint, @as(c_int, 1835036)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1837105152)),
+ @bitCast(c_uint, @as(c_int, 16512)),
+ @bitCast(c_uint, @as(c_int, 1082146944)),
+ @bitCast(c_uint, @as(c_int, 1082130432)),
+ @bitCast(c_uint, @as(c_int, 4222336)),
+ @bitCast(c_uint, @as(c_int, 1835040)),
+ @bitCast(c_uint, @as(c_int, 1835036)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1074266112)),
+ @bitCast(c_uint, @as(c_int, 536748040)),
+ @bitCast(c_uint, @as(c_int, 336072712)),
+ @bitCast(c_uint, @as(c_int, 285741576)),
+ @bitCast(c_uint, @as(c_int, 273158280)),
+ @bitCast(c_uint, @as(c_int, 268963880)),
+ @bitCast(c_uint, @as(c_int, 268730360)),
+ @bitCast(c_uint, @as(c_int, 4098)),
+ @bitCast(c_uint, @as(c_int, 1048576)),
+ @bitCast(c_uint, @as(c_int, 1073479696)),
+ @bitCast(c_uint, @as(c_int, 716191056)),
+ @bitCast(c_uint, @as(c_int, 581969232)),
+ @bitCast(c_uint, @as(c_int, 548413776)),
+ @bitCast(c_uint, @as(c_int, 540024912)),
+ @bitCast(c_uint, @as(c_int, 536936432)),
+ @bitCast(c_uint, @as(c_int, 8192)),
+ @bitCast(c_uint, @as(c_int, 1073741824)),
+ @bitCast(c_uint, @as(c_int, 536354816)),
+ @bitCast(c_uint, @as(c_int, 67643400)),
+ @bitCast(c_uint, @as(c_int, 17310216)),
+ @bitCast(c_uint, @as(c_int, 4726920)),
+ @bitCast(c_uint, @as(c_int, 1581096)),
+ @bitCast(c_uint, @as(c_int, 894705672)),
+ 2,
+ 0,
+ @bitCast(c_uint, @as(c_int, 41943680)),
+ @bitCast(c_uint, @as(c_int, 113247936)),
+ @bitCast(c_uint, @as(c_int, 245370592)),
+ @bitCast(c_uint, @as(c_int, 512761520)),
+ @bitCast(c_uint, @as(c_int, 1049116312)),
+ @bitCast(c_uint, @as(c_int, 2130476684)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 16777216)),
+ @bitCast(c_uint, @as(c_int, 90177792)),
+ @bitCast(c_uint, @as(c_int, 491261264)),
+ @bitCast(c_uint, @as(c_int, 2101493060)),
+ @bitCast(c_uint, @as(c_int, 1027898690)),
+ @bitCast(c_uint, @as(c_int, 223354184)),
+ @bitCast(c_uint, @as(c_int, 16778592)),
+ @bitCast(c_uint, @as(c_int, 256)),
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 69206592)),
+ @bitCast(c_uint, @as(c_int, 268961808)),
+ @bitCast(c_uint, @as(c_int, 8184)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 267395064)),
+ @bitCast(c_uint, @as(c_int, 62916576)),
+ @bitCast(c_uint, @as(c_int, 384)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 17301744)),
+ @bitCast(c_uint, @as(c_int, 33817092)),
+ @bitCast(c_uint, @as(c_int, 33817092)),
+ @bitCast(c_uint, @as(c_int, 133169928)),
+ @bitCast(c_uint, @as(c_int, 469765632)),
+ @bitCast(c_uint, @as(c_int, 805320704)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 102237168)),
+ @bitCast(c_uint, @as(c_int, 136580108)),
+ @bitCast(c_uint, @as(c_int, 134481940)),
+ @bitCast(c_uint, @as(c_int, 202115076)),
+ @bitCast(c_uint, @as(c_int, 602936856)),
+ @bitCast(c_uint, @as(c_int, 402662400)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 477104064)),
+ @bitCast(c_uint, @as(c_int, 1670263704)),
+ @bitCast(c_uint, @as(c_int, 477115288)),
+ @bitCast(c_uint, @as(c_int, 1984)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 268443648)),
+ @bitCast(c_uint, @as(c_int, 74452928)),
+ @bitCast(c_uint, @as(c_int, 1628320280)),
+ @bitCast(c_uint, @as(c_int, 477114520)),
+ @bitCast(c_uint, @as(c_int, 1050528)),
+ 8,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 32764)),
+ @bitCast(c_uint, @as(c_int, 1074036732)),
+ @bitCast(c_uint, @as(c_int, 269492232)),
+ @bitCast(c_uint, @as(c_int, 71305248)),
+ @bitCast(c_uint, @as(c_int, 41943680)),
+ @bitCast(c_uint, @as(c_int, 41943680)),
+ @bitCast(c_uint, @as(c_int, 256)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073905662)),
+ @bitCast(c_uint, @as(c_int, 268967940)),
+ @bitCast(c_uint, @as(c_int, 69208080)),
+ @bitCast(c_uint, @as(c_int, 37749312)),
+ @bitCast(c_uint, @as(c_int, 37749312)),
+ @bitCast(c_uint, @as(c_int, 20972096)),
+ 192,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 128,
+ @bitCast(c_uint, @as(c_int, 1016987648)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 1065222592)),
+ @bitCast(c_uint, @as(c_int, 8389056)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 65011840)),
+ @bitCast(c_uint, @as(c_int, 1044251168)),
+ @bitCast(c_uint, @as(c_int, 65012256)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 16777216)),
+ @bitCast(c_uint, @as(c_int, 71303808)),
+ @bitCast(c_uint, @as(c_int, 16777472)),
+ @bitCast(c_uint, @as(c_int, 1132732424)),
+ @bitCast(c_uint, @as(c_int, 1132763826)),
+ @bitCast(c_uint, @as(c_int, 16785416)),
+ @bitCast(c_uint, @as(c_int, 71303424)),
+ @bitCast(c_uint, @as(c_int, 16777856)),
+ @bitCast(c_uint, @as(c_int, 16777216)),
+ @bitCast(c_uint, @as(c_int, 71303808)),
+ @bitCast(c_uint, @as(c_int, 16777472)),
+ @bitCast(c_uint, @as(c_int, 1090789640)),
+ @bitCast(c_uint, @as(c_int, 1090822130)),
+ @bitCast(c_uint, @as(c_int, 16785672)),
+ @bitCast(c_uint, @as(c_int, 71303424)),
+ @bitCast(c_uint, @as(c_int, 16777856)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1342849026)),
+ @bitCast(c_uint, @as(c_int, 69224466)),
+ @bitCast(c_uint, @as(c_int, 576)),
+ @bitCast(c_uint, @as(c_int, 37748736)),
+ @bitCast(c_uint, @as(c_int, 1209140256)),
+ @bitCast(c_uint, @as(c_int, 1073893386)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 536886272)),
+ @bitCast(c_uint, @as(c_int, 603990016)),
+ @bitCast(c_uint, @as(c_int, 16777728)),
+ @bitCast(c_uint, @as(c_int, 4194432)),
+ @bitCast(c_uint, @as(c_int, 1310756)),
+ @bitCast(c_uint, @as(c_int, 3932164)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 262204)),
+ @bitCast(c_uint, @as(c_int, 2359316)),
+ @bitCast(c_uint, @as(c_int, 8388672)),
+ @bitCast(c_uint, @as(c_int, 33554688)),
+ @bitCast(c_uint, @as(c_int, 671097856)),
+ @bitCast(c_uint, @as(c_int, 1006641152)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1048608)),
+ @bitCast(c_uint, @as(c_int, 269492168)),
+ @bitCast(c_uint, @as(c_int, 268439584)),
+ @bitCast(c_uint, @as(c_int, 268439552)),
+ @bitCast(c_uint, @as(c_int, 268439552)),
+ @bitCast(c_uint, @as(c_int, 8128)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 134218752)),
+ @bitCast(c_uint, @as(c_int, 134747128)),
+ @bitCast(c_uint, @as(c_int, 525320)),
+ @bitCast(c_uint, @as(c_int, 524296)),
+ @bitCast(c_uint, @as(c_int, 524296)),
+ @bitCast(c_uint, @as(c_int, 1016)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073479680)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 536879104)),
+ @bitCast(c_uint, @as(c_int, 541073408)),
+ @bitCast(c_uint, @as(c_int, 1066410016)),
+ @bitCast(c_uint, @as(c_int, 4194336)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073479680)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 670834692)),
+ @bitCast(c_uint, @as(c_int, 538976256)),
+ @bitCast(c_uint, @as(c_int, 1070080016)),
+ @bitCast(c_uint, @as(c_int, 2097168)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 268965912)),
+ @bitCast(c_uint, @as(c_int, 293605384)),
+ @bitCast(c_uint, @as(c_int, 268439936)),
+ @bitCast(c_uint, @as(c_int, 403705888)),
+ @bitCast(c_uint, @as(c_int, 1052616)),
+ 32,
+ 0,
+ @bitCast(c_uint, @as(c_int, 67109376)),
+ @bitCast(c_uint, @as(c_int, 604252668)),
+ @bitCast(c_uint, @as(c_int, 537141764)),
+ @bitCast(c_uint, @as(c_int, 541335556)),
+ @bitCast(c_uint, @as(c_int, 1066672164)),
+ @bitCast(c_uint, @as(c_int, 4194336)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 536875008)),
+ @bitCast(c_uint, @as(c_int, 571493390)),
+ @bitCast(c_uint, @as(c_int, 8392992)),
+ @bitCast(c_uint, @as(c_int, 287309888)),
+ @bitCast(c_uint, @as(c_int, 1275994640)),
+ @bitCast(c_uint, @as(c_int, 268443648)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1342324738)),
+ @bitCast(c_uint, @as(c_int, 1141000194)),
+ @bitCast(c_uint, @as(c_int, 1090667010)),
+ @bitCast(c_uint, @as(c_int, 1078083714)),
+ @bitCast(c_uint, @as(c_int, 1074937890)),
+ @bitCast(c_uint, @as(c_int, 1073889290)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 65011840)),
+ @bitCast(c_uint, @as(c_int, 134743184)),
+ @bitCast(c_uint, @as(c_int, 1016989704)),
+ @bitCast(c_uint, @as(c_int, 134744072)),
+ @bitCast(c_uint, @as(c_int, 65012880)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 1073611200)),
+ @bitCast(c_uint, @as(c_int, 8389056)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 65011840)),
+ @bitCast(c_uint, @as(c_int, 1073611744)),
+ @bitCast(c_uint, @as(c_int, 65012704)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 16777216)),
+ @bitCast(c_uint, @as(c_int, 130024320)),
+ @bitCast(c_uint, @as(c_int, 16777472)),
+ @bitCast(c_uint, @as(c_int, 1670127624)),
+ @bitCast(c_uint, @as(c_int, 1670183870)),
+ @bitCast(c_uint, @as(c_int, 16785416)),
+ @bitCast(c_uint, @as(c_int, 130023680)),
+ @bitCast(c_uint, @as(c_int, 16778112)),
+ @bitCast(c_uint, @as(c_int, 16777216)),
+ @bitCast(c_uint, @as(c_int, 130024320)),
+ @bitCast(c_uint, @as(c_int, 16777472)),
+ @bitCast(c_uint, @as(c_int, 1628184840)),
+ @bitCast(c_uint, @as(c_int, 1628241918)),
+ @bitCast(c_uint, @as(c_int, 16785672)),
+ @bitCast(c_uint, @as(c_int, 130023680)),
+ @bitCast(c_uint, @as(c_int, 16778112)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1611034638)),
+ @bitCast(c_uint, @as(c_int, 69224466)),
+ @bitCast(c_uint, @as(c_int, 576)),
+ @bitCast(c_uint, @as(c_int, 37748736)),
+ @bitCast(c_uint, @as(c_int, 1209140256)),
+ @bitCast(c_uint, @as(c_int, 1879990278)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 939539456)),
+ @bitCast(c_uint, @as(c_int, 603992064)),
+ @bitCast(c_uint, @as(c_int, 16777728)),
+ @bitCast(c_uint, @as(c_int, 4194432)),
+ @bitCast(c_uint, @as(c_int, 786468)),
+ @bitCast(c_uint, @as(c_int, 3932188)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1835068)),
+ @bitCast(c_uint, @as(c_int, 2359308)),
+ @bitCast(c_uint, @as(c_int, 8388672)),
+ @bitCast(c_uint, @as(c_int, 33554688)),
+ @bitCast(c_uint, @as(c_int, 805315584)),
+ @bitCast(c_uint, @as(c_int, 1006647296)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 3145760)),
+ @bitCast(c_uint, @as(c_int, 271589368)),
+ @bitCast(c_uint, @as(c_int, 268439584)),
+ @bitCast(c_uint, @as(c_int, 268439552)),
+ @bitCast(c_uint, @as(c_int, 268439552)),
+ @bitCast(c_uint, @as(c_int, 8128)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 201327616)),
+ @bitCast(c_uint, @as(c_int, 201859064)),
+ @bitCast(c_uint, @as(c_int, 525320)),
+ @bitCast(c_uint, @as(c_int, 524296)),
+ @bitCast(c_uint, @as(c_int, 524296)),
+ @bitCast(c_uint, @as(c_int, 1016)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073479680)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 536879104)),
+ @bitCast(c_uint, @as(c_int, 541073408)),
+ @bitCast(c_uint, @as(c_int, 1072701536)),
+ @bitCast(c_uint, @as(c_int, 4194400)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073479680)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 670834692)),
+ @bitCast(c_uint, @as(c_int, 538976256)),
+ @bitCast(c_uint, @as(c_int, 1073225776)),
+ @bitCast(c_uint, @as(c_int, 2097200)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 268965912)),
+ @bitCast(c_uint, @as(c_int, 293605384)),
+ @bitCast(c_uint, @as(c_int, 268439936)),
+ @bitCast(c_uint, @as(c_int, 405803040)),
+ @bitCast(c_uint, @as(c_int, 3149816)),
+ 32,
+ 0,
+ @bitCast(c_uint, @as(c_int, 100663808)),
+ @bitCast(c_uint, @as(c_int, 637808636)),
+ @bitCast(c_uint, @as(c_int, 537141764)),
+ @bitCast(c_uint, @as(c_int, 541335556)),
+ @bitCast(c_uint, @as(c_int, 1072963684)),
+ @bitCast(c_uint, @as(c_int, 4194400)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 805310464)),
+ @bitCast(c_uint, @as(c_int, 839941134)),
+ @bitCast(c_uint, @as(c_int, 8392992)),
+ @bitCast(c_uint, @as(c_int, 287309888)),
+ @bitCast(c_uint, @as(c_int, 2081305104)),
+ @bitCast(c_uint, @as(c_int, 268447744)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 805584892)),
+ @bitCast(c_uint, @as(c_int, 604252164)),
+ @bitCast(c_uint, @as(c_int, 553918980)),
+ @bitCast(c_uint, @as(c_int, 541335684)),
+ @bitCast(c_uint, @as(c_int, 538189860)),
+ @bitCast(c_uint, @as(c_int, 1073487884)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 600063996)),
+ @bitCast(c_uint, @as(c_int, 600056772)),
+ @bitCast(c_uint, @as(c_int, 537142212)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1040465916)),
+ @bitCast(c_uint, @as(c_int, 1040465412)),
+ @bitCast(c_uint, @as(c_int, 537148932)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1040465412)),
+ @bitCast(c_uint, @as(c_int, 1040465412)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1040457732)),
+ @bitCast(c_uint, @as(c_int, 1040465412)),
+ @bitCast(c_uint, @as(c_int, 1073495556)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 600055812)),
+ @bitCast(c_uint, @as(c_int, 600056772)),
+ @bitCast(c_uint, @as(c_int, 1073488836)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 545005572)),
+ @bitCast(c_uint, @as(c_int, 545005692)),
+ @bitCast(c_uint, @as(c_int, 1073487996)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 545005692)),
+ @bitCast(c_uint, @as(c_int, 545005692)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 545013756)),
+ @bitCast(c_uint, @as(c_int, 545005692)),
+ @bitCast(c_uint, @as(c_int, 537141372)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 600056772)),
+ @bitCast(c_uint, @as(c_int, 600056772)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1206010242)),
+ @bitCast(c_uint, @as(c_int, 1341278178)),
+ @bitCast(c_uint, @as(c_int, 1206013938)),
+ @bitCast(c_uint, @as(c_int, 1099057122)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 2147418112)),
+ @bitCast(c_uint, @as(c_int, 1073823745)),
+ @bitCast(c_uint, @as(c_int, 1073823745)),
+ @bitCast(c_uint, @as(c_int, 1230331357)),
+ @bitCast(c_uint, @as(c_int, 1229277533)),
+ @bitCast(c_uint, @as(c_int, 1073826245)),
+ @bitCast(c_uint, @as(c_int, 1073823745)),
+ @bitCast(c_uint, @as(c_int, 32767)),
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1395815218)),
+ @bitCast(c_uint, @as(c_int, 1154370766)),
+ @bitCast(c_uint, @as(c_int, 1093813042)),
+ @bitCast(c_uint, @as(c_int, 1078870222)),
+ @bitCast(c_uint, @as(c_int, 1209160754)),
+ @bitCast(c_uint, @as(c_int, 1074156558)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1395815218)),
+ @bitCast(c_uint, @as(c_int, 1154370766)),
+ @bitCast(c_uint, @as(c_int, 1093813042)),
+ @bitCast(c_uint, @as(c_int, 1548632270)),
+ @bitCast(c_uint, @as(c_int, 1142047794)),
+ @bitCast(c_uint, @as(c_int, 1074158606)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 1123959166)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ @bitCast(c_uint, @as(c_int, 134086656)),
+ @bitCast(c_uint, @as(c_int, 536477698)),
+ @bitCast(c_uint, @as(c_int, 2146041866)),
+ @bitCast(c_uint, @as(c_int, 1076510762)),
+ @bitCast(c_uint, @as(c_int, 1529499946)),
+ @bitCast(c_uint, @as(c_int, 1361597738)),
+ @bitCast(c_uint, @as(c_int, 1075859752)),
+ @bitCast(c_uint, @as(c_int, 32736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 536346624)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306716664)),
+ @bitCast(c_uint, @as(c_int, 536351304)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 8184)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 306708480)),
+ @bitCast(c_uint, @as(c_int, 2147357256)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306741246)),
+ @bitCast(c_uint, @as(c_int, 2147357256)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306741246)),
+ @bitCast(c_uint, @as(c_int, 4680)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 473432064)),
+ @bitCast(c_uint, @as(c_int, 473438184)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 401087544)),
+ @bitCast(c_uint, @as(c_int, 7224)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1879965696)),
+ @bitCast(c_uint, @as(c_int, 1879990266)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 1610248206)),
+ @bitCast(c_uint, @as(c_int, 28686)),
+ @bitCast(c_uint, @as(c_int, 1065222144)),
+ @bitCast(c_uint, @as(c_int, 557982018)),
+ @bitCast(c_uint, @as(c_int, 557982018)),
+ @bitCast(c_uint, @as(c_int, 16254)),
+ @bitCast(c_uint, @as(c_int, 557989758)),
+ @bitCast(c_uint, @as(c_int, 557982018)),
+ @bitCast(c_uint, @as(c_int, 1065230658)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1001914368)),
+ @bitCast(c_uint, @as(c_int, 1001929656)),
+ @bitCast(c_uint, @as(c_int, 1001914368)),
+ @bitCast(c_uint, @as(c_int, 1001929656)),
+ @bitCast(c_uint, @as(c_int, 1001914368)),
+ @bitCast(c_uint, @as(c_int, 1001929656)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 2147385342)),
+ @bitCast(c_uint, @as(c_int, 2013163520)),
+ @bitCast(c_uint, @as(c_int, 2013165566)),
+ @bitCast(c_uint, @as(c_int, 2004776704)),
+ @bitCast(c_uint, @as(c_int, 2004776830)),
+ @bitCast(c_uint, @as(c_int, 2004776830)),
+ @bitCast(c_uint, @as(c_int, 30590)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 16386)),
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 384)),
+ @bitCast(c_uint, @as(c_int, 1073872896)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 16386)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 1073872896)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 132136962)),
+ @bitCast(c_uint, @as(c_int, 132122592)),
+ @bitCast(c_uint, @as(c_int, 132122592)),
+ @bitCast(c_uint, @as(c_int, 1073874912)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ @bitCast(c_uint, @as(c_int, 2015232000)),
+ @bitCast(c_uint, @as(c_int, 1610235906)),
+ @bitCast(c_uint, @as(c_int, 536371194)),
+ @bitCast(c_uint, @as(c_int, 536354808)),
+ @bitCast(c_uint, @as(c_int, 536354808)),
+ @bitCast(c_uint, @as(c_int, 1610227704)),
+ @bitCast(c_uint, @as(c_int, 1073897466)),
+ @bitCast(c_uint, @as(c_int, 30750)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 537147420)),
+ @bitCast(c_uint, @as(c_int, 8196)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537133056)),
+ @bitCast(c_uint, @as(c_int, 941367300)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 498597888)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 268959744)),
+ @bitCast(c_uint, @as(c_int, 4104)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 7608)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 894828544)),
+ @bitCast(c_uint, @as(c_int, 8194)),
+ @bitCast(c_uint, @as(c_int, 8194)),
+ @bitCast(c_uint, @as(c_int, 8194)),
+ @bitCast(c_uint, @as(c_int, 8194)),
+ @bitCast(c_uint, @as(c_int, 8194)),
+ @bitCast(c_uint, @as(c_int, 894836738)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1209159666)),
+ @bitCast(c_uint, @as(c_int, 1234323474)),
+ @bitCast(c_uint, @as(c_int, 1209158034)),
+ @bitCast(c_uint, @as(c_int, 1341278226)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 277094396)),
+ @bitCast(c_uint, @as(c_int, 277090436)),
+ @bitCast(c_uint, @as(c_int, 536612996)),
+ @bitCast(c_uint, @as(c_int, 277090436)),
+ @bitCast(c_uint, @as(c_int, 277090436)),
+ @bitCast(c_uint, @as(c_int, 8188)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 268435456)),
+ @bitCast(c_uint, @as(c_int, 67110912)),
+ @bitCast(c_uint, @as(c_int, 17039872)),
+ @bitCast(c_uint, @as(c_int, 5243016)),
+ 32,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 268959744)),
+ @bitCast(c_uint, @as(c_int, 69208080)),
+ @bitCast(c_uint, @as(c_int, 25166400)),
+ @bitCast(c_uint, @as(c_int, 37749120)),
+ @bitCast(c_uint, @as(c_int, 135267360)),
+ @bitCast(c_uint, @as(c_int, 4104)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 33554432)),
+ @bitCast(c_uint, @as(c_int, 8388864)),
+ @bitCast(c_uint, @as(c_int, 2097216)),
+ @bitCast(c_uint, @as(c_int, 2097168)),
+ @bitCast(c_uint, @as(c_int, 8388672)),
+ @bitCast(c_uint, @as(c_int, 33554688)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 4194304)),
+ @bitCast(c_uint, @as(c_int, 16777344)),
+ @bitCast(c_uint, @as(c_int, 67109376)),
+ @bitCast(c_uint, @as(c_int, 67110912)),
+ @bitCast(c_uint, @as(c_int, 16777728)),
+ @bitCast(c_uint, @as(c_int, 4194432)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 134746116)),
+ @bitCast(c_uint, @as(c_int, 35652624)),
+ @bitCast(c_uint, @as(c_int, 8388928)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 20971648)),
+ @bitCast(c_uint, @as(c_int, 68157984)),
+ @bitCast(c_uint, @as(c_int, 268699656)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 33554432)),
+ @bitCast(c_uint, @as(c_int, 58721024)),
+ @bitCast(c_uint, @as(c_int, 65012672)),
+ @bitCast(c_uint, @as(c_int, 65012720)),
+ @bitCast(c_uint, @as(c_int, 58721216)),
+ @bitCast(c_uint, @as(c_int, 33555200)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 4194304)),
+ @bitCast(c_uint, @as(c_int, 29360320)),
+ @bitCast(c_uint, @as(c_int, 130024384)),
+ @bitCast(c_uint, @as(c_int, 130027456)),
+ @bitCast(c_uint, @as(c_int, 29361088)),
+ @bitCast(c_uint, @as(c_int, 4194496)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 267919356)),
+ @bitCast(c_uint, @as(c_int, 65013744)),
+ @bitCast(c_uint, @as(c_int, 8389056)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 29360256)),
+ @bitCast(c_uint, @as(c_int, 133170144)),
+ @bitCast(c_uint, @as(c_int, 536612856)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 413141184)),
+ @bitCast(c_uint, @as(c_int, 847778448)),
+ @bitCast(c_uint, @as(c_int, 612509318)),
+ @bitCast(c_uint, @as(c_int, 646325378)),
+ @bitCast(c_uint, @as(c_int, 311440008)),
+ @bitCast(c_uint, @as(c_int, 146806944)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 75499392)),
+ @bitCast(c_uint, @as(c_int, 4194496)),
+ @bitCast(c_uint, @as(c_int, 1713373424)),
+ @bitCast(c_uint, @as(c_int, 135281712)),
+ @bitCast(c_uint, @as(c_int, 319426072)),
+ @bitCast(c_uint, @as(c_int, 12686)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388608)),
+ @bitCast(c_uint, @as(c_int, 143132808)),
+ @bitCast(c_uint, @as(c_int, 715786890)),
+ @bitCast(c_uint, @as(c_int, 176827050)),
+ @bitCast(c_uint, @as(c_int, 143132808)),
+ 128,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 6291456)),
+ @bitCast(c_uint, @as(c_int, 17301648)),
+ @bitCast(c_uint, @as(c_int, 33816840)),
+ @bitCast(c_uint, @as(c_int, 1107575300)),
+ @bitCast(c_uint, @as(c_int, 604120066)),
+ @bitCast(c_uint, @as(c_int, 6144)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 133693440)),
+ @bitCast(c_uint, @as(c_int, 67634184)),
+ @bitCast(c_uint, @as(c_int, 67634184)),
+ @bitCast(c_uint, @as(c_int, 67634184)),
+ @bitCast(c_uint, @as(c_int, 2081293320)),
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 10485824)),
+ @bitCast(c_uint, @as(c_int, 570966288)),
+ @bitCast(c_uint, @as(c_int, 134353924)),
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 69206016)),
+ @bitCast(c_uint, @as(c_int, 25166400)),
+ @bitCast(c_uint, @as(c_int, 37749120)),
+ @bitCast(c_uint, @as(c_int, 1056)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 406323200)),
+ @bitCast(c_uint, @as(c_int, 304616488)),
+ @bitCast(c_uint, @as(c_int, 279449896)),
+ @bitCast(c_uint, @as(c_int, 287838376)),
+ @bitCast(c_uint, @as(c_int, 338170408)),
+ @bitCast(c_uint, @as(c_int, 6200)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 402653184)),
+ @bitCast(c_uint, @as(c_int, 293606912)),
+ @bitCast(c_uint, @as(c_int, 270012512)),
+ @bitCast(c_uint, @as(c_int, 274731032)),
+ @bitCast(c_uint, @as(c_int, 369103232)),
+ @bitCast(c_uint, @as(c_int, 6144)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1572864)),
+ @bitCast(c_uint, @as(c_int, 25690216)),
+ @bitCast(c_uint, @as(c_int, 403179016)),
+ @bitCast(c_uint, @as(c_int, 101193736)),
+ @bitCast(c_uint, @as(c_int, 6816136)),
+ 24,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 511180800)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 306713160)),
+ @bitCast(c_uint, @as(c_int, 7800)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 536346624)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 8184)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 471334912)),
+ @bitCast(c_uint, @as(c_int, 340268072)),
+ @bitCast(c_uint, @as(c_int, 352851080)),
+ @bitCast(c_uint, @as(c_int, 344462600)),
+ @bitCast(c_uint, @as(c_int, 338170952)),
+ @bitCast(c_uint, @as(c_int, 7192)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 62914560)),
+ @bitCast(c_uint, @as(c_int, 135267360)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 69208080)),
+ @bitCast(c_uint, @as(c_int, 960)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 204474336)),
+ @bitCast(c_uint, @as(c_int, 331880472)),
+ @bitCast(c_uint, @as(c_int, 338171496)),
+ @bitCast(c_uint, @as(c_int, 338170920)),
+ @bitCast(c_uint, @as(c_int, 473439288)),
+ @bitCast(c_uint, @as(c_int, 135275076)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 130023424)),
+ @bitCast(c_uint, @as(c_int, 136316960)),
+ @bitCast(c_uint, @as(c_int, 1073219616)),
+ @bitCast(c_uint, @as(c_int, 596123656)),
+ @bitCast(c_uint, @as(c_int, 554181512)),
+ @bitCast(c_uint, @as(c_int, 537403656)),
+ @bitCast(c_uint, @as(c_int, 535830536)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 130023424)),
+ @bitCast(c_uint, @as(c_int, 134219776)),
+ @bitCast(c_uint, @as(c_int, 1073219584)),
+ @bitCast(c_uint, @as(c_int, 596123656)),
+ @bitCast(c_uint, @as(c_int, 554181512)),
+ @bitCast(c_uint, @as(c_int, 537403656)),
+ @bitCast(c_uint, @as(c_int, 535830536)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 29360128)),
+ @bitCast(c_uint, @as(c_int, 202901360)),
+ @bitCast(c_uint, @as(c_int, 814094476)),
+ @bitCast(c_uint, @as(c_int, 1619206274)),
+ @bitCast(c_uint, @as(c_int, 1610827649)),
+ @bitCast(c_uint, @as(c_int, 805707778)),
+ @bitCast(c_uint, @as(c_int, 202905612)),
+ @bitCast(c_uint, @as(c_int, 29362032)),
+ @bitCast(c_uint, @as(c_int, 169869312)),
+ @bitCast(c_uint, @as(c_int, 455088928)),
+ @bitCast(c_uint, @as(c_int, 69209632)),
+ @bitCast(c_uint, @as(c_int, 69207072)),
+ @bitCast(c_uint, @as(c_int, 74449952)),
+ @bitCast(c_uint, @as(c_int, 242224752)),
+ @bitCast(c_uint, @as(c_int, 242224752)),
+ @bitCast(c_uint, @as(c_int, 69209712)),
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 1004286348)),
+ @bitCast(c_uint, @as(c_int, 267395064)),
+ @bitCast(c_uint, @as(c_int, 2084445816)),
+ @bitCast(c_uint, @as(c_int, 511212606)),
+ @bitCast(c_uint, @as(c_int, 536350704)),
+ @bitCast(c_uint, @as(c_int, 831273948)),
+ @bitCast(c_uint, @as(c_int, 384)),
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 1073492364)),
+ @bitCast(c_uint, @as(c_int, 473440248)),
+ @bitCast(c_uint, @as(c_int, 2015238168)),
+ @bitCast(c_uint, @as(c_int, 404256798)),
+ @bitCast(c_uint, @as(c_int, 536353848)),
+ @bitCast(c_uint, @as(c_int, 831275004)),
+ @bitCast(c_uint, @as(c_int, 384)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 134746104)),
+ @bitCast(c_uint, @as(c_int, 134750204)),
+ @bitCast(c_uint, @as(c_int, 178784936)),
+ @bitCast(c_uint, @as(c_int, 178784936)),
+ @bitCast(c_uint, @as(c_int, 178784936)),
+ @bitCast(c_uint, @as(c_int, 134744744)),
+ @bitCast(c_uint, @as(c_int, 4088)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 134496132)),
+ @bitCast(c_uint, @as(c_int, 67374980)),
+ @bitCast(c_uint, @as(c_int, 67372932)),
+ @bitCast(c_uint, @as(c_int, 2044)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 608175104)),
+ @bitCast(c_uint, @as(c_int, 5248)),
+ @bitCast(c_uint, @as(c_int, 1862143488)),
+ @bitCast(c_uint, @as(c_int, 3584)),
+ @bitCast(c_uint, @as(c_int, 608179328)),
+ @bitCast(c_uint, @as(c_int, 1024)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 62914560)),
+ @bitCast(c_uint, @as(c_int, 137364576)),
+ @bitCast(c_uint, @as(c_int, 286789912)),
+ @bitCast(c_uint, @as(c_int, 286789912)),
+ @bitCast(c_uint, @as(c_int, 73402416)),
+ @bitCast(c_uint, @as(c_int, 960)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 277348480)),
+ @bitCast(c_uint, @as(c_int, 113248272)),
+ @bitCast(c_uint, @as(c_int, 913049568)),
+ @bitCast(c_uint, @as(c_int, 132121152)),
+ @bitCast(c_uint, @as(c_int, 5992)),
+ @bitCast(c_uint, @as(c_int, 69206592)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1026031616)),
+ @bitCast(c_uint, @as(c_int, 623387948)),
+ @bitCast(c_uint, @as(c_int, 1026041128)),
+ @bitCast(c_uint, @as(c_int, 86508840)),
+ @bitCast(c_uint, @as(c_int, 99091752)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 25166784)),
+ @bitCast(c_uint, @as(c_int, 267388896)),
+ @bitCast(c_uint, @as(c_int, 198183888)),
+ @bitCast(c_uint, @as(c_int, 173018064)),
+ @bitCast(c_uint, @as(c_int, 37749312)),
+ @bitCast(c_uint, @as(c_int, 37749312)),
+ @bitCast(c_uint, @as(c_int, 25165824)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 293606336)),
+ @bitCast(c_uint, @as(c_int, 63447032)),
+ @bitCast(c_uint, @as(c_int, 130024392)),
+ @bitCast(c_uint, @as(c_int, 71304256)),
+ @bitCast(c_uint, @as(c_int, 201852024)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073217536)),
+ @bitCast(c_uint, @as(c_int, 806895608)),
+ @bitCast(c_uint, @as(c_int, 806891544)),
+ @bitCast(c_uint, @as(c_int, 1073233912)),
+ @bitCast(c_uint, @as(c_int, 50332416)),
+ @bitCast(c_uint, @as(c_int, 62915520)),
+ @bitCast(c_uint, @as(c_int, 65012480)),
+ @bitCast(c_uint, @as(c_int, 992)),
+ @bitCast(c_uint, @as(c_int, 1073217536)),
+ @bitCast(c_uint, @as(c_int, 1073233912)),
+ @bitCast(c_uint, @as(c_int, 865615864)),
+ @bitCast(c_uint, @as(c_int, 1073230744)),
+ @bitCast(c_uint, @as(c_int, 1073233912)),
+ @bitCast(c_uint, @as(c_int, 1344)),
+ @bitCast(c_uint, @as(c_int, 266341024)),
+ @bitCast(c_uint, @as(c_int, 4064)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 537137160)),
+ @bitCast(c_uint, @as(c_int, 625221636)),
+ @bitCast(c_uint, @as(c_int, 268967940)),
+ @bitCast(c_uint, @as(c_int, 100666352)),
+ @bitCast(c_uint, @as(c_int, 768)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 289669120)),
+ @bitCast(c_uint, @as(c_int, 133172200)),
+ @bitCast(c_uint, @as(c_int, 471600696)),
+ @bitCast(c_uint, @as(c_int, 471600152)),
+ @bitCast(c_uint, @as(c_int, 133172792)),
+ @bitCast(c_uint, @as(c_int, 289672168)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537395200)),
+ @bitCast(c_uint, @as(c_int, 207622160)),
+ @bitCast(c_uint, @as(c_int, 130027488)),
+ @bitCast(c_uint, @as(c_int, 130025408)),
+ @bitCast(c_uint, @as(c_int, 207622112)),
+ @bitCast(c_uint, @as(c_int, 537399312)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537395200)),
+ @bitCast(c_uint, @as(c_int, 207622160)),
+ @bitCast(c_uint, @as(c_int, 71307232)),
+ @bitCast(c_uint, @as(c_int, 71325012)),
+ @bitCast(c_uint, @as(c_int, 207622112)),
+ @bitCast(c_uint, @as(c_int, 537399312)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 8388736)),
+ @bitCast(c_uint, @as(c_int, 29360576)),
+ @bitCast(c_uint, @as(c_int, 536625150)),
+ @bitCast(c_uint, @as(c_int, 65013744)),
+ @bitCast(c_uint, @as(c_int, 133170144)),
+ @bitCast(c_uint, @as(c_int, 202901360)),
+ @bitCast(c_uint, @as(c_int, 2056)),
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 135792656)),
+ @bitCast(c_uint, @as(c_int, 135268376)),
+ @bitCast(c_uint, @as(c_int, 168822800)),
+ @bitCast(c_uint, @as(c_int, 135792656)),
+ @bitCast(c_uint, @as(c_int, 135268376)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 8184)),
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 269484048)),
+ @bitCast(c_uint, @as(c_int, 1334845456)),
+ @bitCast(c_uint, @as(c_int, 269492240)),
+ @bitCast(c_uint, @as(c_int, 135266320)),
+ @bitCast(c_uint, @as(c_int, 4080)),
+ @bitCast(c_uint, @as(c_int, 262144)),
+ @bitCast(c_uint, @as(c_int, 2031630)),
+ @bitCast(c_uint, @as(c_int, 250871812)),
+ @bitCast(c_uint, @as(c_int, 317985412)),
+ @bitCast(c_uint, @as(c_int, 250876436)),
+ @bitCast(c_uint, @as(c_int, 268697604)),
+ @bitCast(c_uint, @as(c_int, 2147233796)),
+ @bitCast(c_uint, @as(c_int, 268447744)),
+ @bitCast(c_uint, @as(c_int, 2013528064)),
+ @bitCast(c_uint, @as(c_int, 1344233486)),
+ @bitCast(c_uint, @as(c_int, 250888196)),
+ @bitCast(c_uint, @as(c_int, 317985412)),
+ @bitCast(c_uint, @as(c_int, 250876548)),
+ @bitCast(c_uint, @as(c_int, 269746180)),
+ @bitCast(c_uint, @as(c_int, 2147233804)),
+ @bitCast(c_uint, @as(c_int, 268447744)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1344823344)),
+ @bitCast(c_uint, @as(c_int, 1207846916)),
+ @bitCast(c_uint, @as(c_int, 1143096322)),
+ @bitCast(c_uint, @as(c_int, 1143096354)),
+ @bitCast(c_uint, @as(c_int, 605189602)),
+ @bitCast(c_uint, @as(c_int, 201724938)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1610121200)),
+ @bitCast(c_uint, @as(c_int, 1207848956)),
+ @bitCast(c_uint, @as(c_int, 1143096322)),
+ @bitCast(c_uint, @as(c_int, 1143096354)),
+ @bitCast(c_uint, @as(c_int, 605189602)),
+ @bitCast(c_uint, @as(c_int, 201724938)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1345871920)),
+ @bitCast(c_uint, @as(c_int, 1207846972)),
+ @bitCast(c_uint, @as(c_int, 1144931390)),
+ @bitCast(c_uint, @as(c_int, 1144931390)),
+ @bitCast(c_uint, @as(c_int, 605976062)),
+ @bitCast(c_uint, @as(c_int, 201724942)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1344823344)),
+ @bitCast(c_uint, @as(c_int, 1207846916)),
+ @bitCast(c_uint, @as(c_int, 1207846910)),
+ @bitCast(c_uint, @as(c_int, 1207846910)),
+ @bitCast(c_uint, @as(c_int, 670988286)),
+ @bitCast(c_uint, @as(c_int, 268310526)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1344823344)),
+ @bitCast(c_uint, @as(c_int, 1207846916)),
+ @bitCast(c_uint, @as(c_int, 1143096322)),
+ @bitCast(c_uint, @as(c_int, 1143096354)),
+ @bitCast(c_uint, @as(c_int, 1072857058)),
+ @bitCast(c_uint, @as(c_int, 268312570)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 1881694256)),
+ @bitCast(c_uint, @as(c_int, 2147383300)),
+ @bitCast(c_uint, @as(c_int, 2082634754)),
+ @bitCast(c_uint, @as(c_int, 2082634786)),
+ @bitCast(c_uint, @as(c_int, 1007844834)),
+ @bitCast(c_uint, @as(c_int, 201726986)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ @bitCast(c_uint, @as(c_int, 2145386496)),
+ @bitCast(c_uint, @as(c_int, 2145943536)),
+ @bitCast(c_uint, @as(c_int, 2147385316)),
+ @bitCast(c_uint, @as(c_int, 2145550306)),
+ @bitCast(c_uint, @as(c_int, 2145550306)),
+ @bitCast(c_uint, @as(c_int, 605192162)),
+ @bitCast(c_uint, @as(c_int, 201724938)),
+ @bitCast(c_uint, @as(c_int, 2046)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 704787454)),
+ @bitCast(c_uint, @as(c_int, 570566146)),
+ @bitCast(c_uint, @as(c_int, 570565122)),
+ @bitCast(c_uint, @as(c_int, 704783874)),
+ @bitCast(c_uint, @as(c_int, 10499070)),
+ @bitCast(c_uint, @as(c_int, 34078992)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537673724)),
+ @bitCast(c_uint, @as(c_int, 786444)),
+ @bitCast(c_uint, @as(c_int, 1073479692)),
+ @bitCast(c_uint, @as(c_int, 805318656)),
+ @bitCast(c_uint, @as(c_int, 805318656)),
+ @bitCast(c_uint, @as(c_int, 1073491972)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 2228286)),
+ @bitCast(c_uint, @as(c_int, 19005922)),
+ @bitCast(c_uint, @as(c_int, 16777534)),
+ @bitCast(c_uint, @as(c_int, 16777472)),
+ @bitCast(c_uint, @as(c_int, 2030043392)),
+ @bitCast(c_uint, @as(c_int, 1325418752)),
+ @bitCast(c_uint, @as(c_int, 30720)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1140882432)),
+ @bitCast(c_uint, @as(c_int, 1157645824)),
+ @bitCast(c_uint, @as(c_int, 6454462)),
+ @bitCast(c_uint, @as(c_int, 6422562)),
+ @bitCast(c_uint, @as(c_int, 1157659838)),
+ @bitCast(c_uint, @as(c_int, 1140868608)),
+ @bitCast(c_uint, @as(c_int, 31744)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 4456572)),
+ @bitCast(c_uint, @as(c_int, 1048700)),
+ @bitCast(c_uint, @as(c_int, 1058013200)),
+ @bitCast(c_uint, @as(c_int, 1058021872)),
+ @bitCast(c_uint, @as(c_int, 1058013200)),
+ @bitCast(c_uint, @as(c_int, 1056973296)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 4456572)),
+ @bitCast(c_uint, @as(c_int, 4456516)),
+ @bitCast(c_uint, @as(c_int, 1048700)),
+ @bitCast(c_uint, @as(c_int, 1048592)),
+ @bitCast(c_uint, @as(c_int, 1141931024)),
+ @bitCast(c_uint, @as(c_int, 1140869104)),
+ @bitCast(c_uint, @as(c_int, 31744)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 4456572)),
+ @bitCast(c_uint, @as(c_int, 4456516)),
+ 124,
+ 16,
+ @bitCast(c_uint, @as(c_int, 1140882448)),
+ @bitCast(c_uint, @as(c_int, 1140868432)),
+ @bitCast(c_uint, @as(c_int, 31744)),
+ @bitCast(c_uint, @as(c_int, 44040192)),
+ @bitCast(c_uint, @as(c_int, 581189628)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537145332)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1073479680)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 610150340)),
+ @bitCast(c_uint, @as(c_int, 667165764)),
+ @bitCast(c_uint, @as(c_int, 537141278)),
+ @bitCast(c_uint, @as(c_int, 538845188)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 132120576)),
+ @bitCast(c_uint, @as(c_int, 69207072)),
+ @bitCast(c_uint, @as(c_int, 606355452)),
+ @bitCast(c_uint, @as(c_int, 606348324)),
+ @bitCast(c_uint, @as(c_int, 606348324)),
+ @bitCast(c_uint, @as(c_int, 1073488932)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 266338304)),
+ @bitCast(c_uint, @as(c_int, 136316960)),
+ @bitCast(c_uint, @as(c_int, 1074036732)),
+ @bitCast(c_uint, @as(c_int, 2147243348)),
+ @bitCast(c_uint, @as(c_int, 1074025812)),
+ @bitCast(c_uint, @as(c_int, 2147237892)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 537149436)),
+ @bitCast(c_uint, @as(c_int, 1073487876)),
+ @bitCast(c_uint, @as(c_int, 331878408)),
+ @bitCast(c_uint, @as(c_int, 268964808)),
+ @bitCast(c_uint, @as(c_int, 268963848)),
+ @bitCast(c_uint, @as(c_int, 536350728)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073905662)),
+ @bitCast(c_uint, @as(c_int, 1610244090)),
+ @bitCast(c_uint, @as(c_int, 1610244090)),
+ @bitCast(c_uint, @as(c_int, 1073897466)),
+ @bitCast(c_uint, @as(c_int, 62947326)),
+ @bitCast(c_uint, @as(c_int, 536354808)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 267386880)),
+ @bitCast(c_uint, @as(c_int, 1811841022)),
+ @bitCast(c_uint, @as(c_int, 2147385342)),
+ @bitCast(c_uint, @as(c_int, 1746305022)),
+ @bitCast(c_uint, @as(c_int, 135292950)),
+ @bitCast(c_uint, @as(c_int, 135268368)),
+ @bitCast(c_uint, @as(c_int, 267388944)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073217536)),
+ 4294844424,
+ 2265612290,
+ 2420803722,
+ 2420805706,
+ 2265614474,
+ 4294868994,
+ 0,
+ @bitCast(c_uint, @as(c_int, 264241152)),
+ 4244507864,
+ 2147680254,
+ 2218951554,
+ 2218951746,
+ 2147648386,
+ 4294868994,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 37749120)),
+ @bitCast(c_uint, @as(c_int, 135267360)),
+ @bitCast(c_uint, @as(c_int, 537137160)),
+ @bitCast(c_uint, @as(c_int, 600055812)),
+ @bitCast(c_uint, @as(c_int, 574890564)),
+ @bitCast(c_uint, @as(c_int, 1073488452)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 477102080)),
+ @bitCast(c_uint, @as(c_int, 1073233656)),
+ @bitCast(c_uint, @as(c_int, 1073233912)),
+ @bitCast(c_uint, @as(c_int, 266346480)),
+ @bitCast(c_uint, @as(c_int, 58722240)),
+ @bitCast(c_uint, @as(c_int, 256)),
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 2147483648,
+ 3758145536,
+ 0,
+ @bitCast(c_uint, @as(c_int, 335551488)),
+ @bitCast(c_uint, @as(c_int, 364909568)),
+ @bitCast(c_uint, @as(c_int, 356521280)),
+ @bitCast(c_uint, @as(c_int, 358356288)),
+ @bitCast(c_uint, @as(c_int, 357832020)),
+ @bitCast(c_uint, @as(c_int, 500962644)),
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 50332416)),
+ @bitCast(c_uint, @as(c_int, 452991744)),
+ @bitCast(c_uint, @as(c_int, 459283296)),
+ @bitCast(c_uint, @as(c_int, 460069728)),
+ @bitCast(c_uint, @as(c_int, 460069740)),
+ @bitCast(c_uint, @as(c_int, 460069740)),
+ 0,
+ 0,
+ 0,
+ @bitCast(c_uint, @as(c_int, 1077837822)),
+ @bitCast(c_uint, @as(c_int, 2147369022)),
+ @bitCast(c_uint, @as(c_int, 2147352576)),
+ @bitCast(c_uint, @as(c_int, 1140737022)),
+ @bitCast(c_uint, @as(c_int, 32766)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 2147221504)),
+ @bitCast(c_uint, @as(c_int, 1132740612)),
+ @bitCast(c_uint, @as(c_int, 1132741252)),
+ @bitCast(c_uint, @as(c_int, 1132740612)),
+ @bitCast(c_uint, @as(c_int, 1115964036)),
+ @bitCast(c_uint, @as(c_int, 1115964036)),
+ @bitCast(c_uint, @as(c_int, 1074021252)),
+ @bitCast(c_uint, @as(c_int, 32764)),
+ @bitCast(c_uint, @as(c_int, 1073774592)),
+ @bitCast(c_uint, @as(c_int, 268443648)),
+ @bitCast(c_uint, @as(c_int, 67110912)),
+ @bitCast(c_uint, @as(c_int, 16777728)),
+ @bitCast(c_uint, @as(c_int, 4194432)),
+ @bitCast(c_uint, @as(c_int, 1048608)),
+ @bitCast(c_uint, @as(c_int, 262152)),
+ @bitCast(c_uint, @as(c_int, 65538)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 535830512)),
+ @bitCast(c_uint, @as(c_int, 405805104)),
+ @bitCast(c_uint, @as(c_int, 520099888)),
+ @bitCast(c_uint, @as(c_int, 50339584)),
+ @bitCast(c_uint, @as(c_int, 768)),
+ @bitCast(c_uint, @as(c_int, 50332416)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 716977488)),
+ @bitCast(c_uint, @as(c_int, 715928916)),
+ @bitCast(c_uint, @as(c_int, 715928916)),
+ @bitCast(c_uint, @as(c_int, 715928916)),
+ @bitCast(c_uint, @as(c_int, 715928916)),
+ @bitCast(c_uint, @as(c_int, 715928916)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 1072693248)),
+ @bitCast(c_uint, @as(c_int, 538714128)),
+ @bitCast(c_uint, @as(c_int, 574890372)),
+ @bitCast(c_uint, @as(c_int, 672408612)),
+ @bitCast(c_uint, @as(c_int, 697575444)),
+ @bitCast(c_uint, @as(c_int, 804530580)),
+ @bitCast(c_uint, @as(c_int, 537141252)),
+ @bitCast(c_uint, @as(c_int, 16380)),
+ @bitCast(c_uint, @as(c_int, 134086656)),
+ @bitCast(c_uint, @as(c_int, 67240962)),
+ @bitCast(c_uint, @as(c_int, 2145518594)),
+ @bitCast(c_uint, @as(c_int, 1143096354)),
+ @bitCast(c_uint, @as(c_int, 1143096354)),
+ @bitCast(c_uint, @as(c_int, 1075857406)),
+ @bitCast(c_uint, @as(c_int, 1075855392)),
+ @bitCast(c_uint, @as(c_int, 32736)),
+ @bitCast(c_uint, @as(c_int, 134086656)),
+ @bitCast(c_uint, @as(c_int, 67240962)),
+ @bitCast(c_uint, @as(c_int, 2080506882)),
+ @bitCast(c_uint, @as(c_int, 1140999170)),
+ @bitCast(c_uint, @as(c_int, 1140999170)),
+ @bitCast(c_uint, @as(c_int, 1075857406)),
+ @bitCast(c_uint, @as(c_int, 1075855392)),
+ @bitCast(c_uint, @as(c_int, 32736)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 1073905662)),
+ @bitCast(c_uint, @as(c_int, 2147368962)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 1073889282)),
+ @bitCast(c_uint, @as(c_int, 2147368962)),
+ 0,
+ @bitCast(c_uint, @as(c_int, 152043520)),
+ @bitCast(c_uint, @as(c_int, 166725904)),
+ @bitCast(c_uint, @as(c_int, 152045840)),
+ @bitCast(c_uint, @as(c_int, 2320)),
+ @bitCast(c_uint, @as(c_int, 614627230)),
+ @bitCast(c_uint, @as(c_int, 664937634)),
+ @bitCast(c_uint, @as(c_int, 1889411234)),
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+};
+pub const BORDER: c_int = 0;
+pub const BASE: c_int = 1;
+pub const TEXT: c_int = 2;
+pub const OTHER: c_int = 3;
+pub const GuiPropertyElement = c_uint;
+pub var guiState: GuiControlState = @bitCast(c_uint, GUI_STATE_NORMAL);
+pub var guiFont: Font = Font{
+ .baseSize = @as(c_int, 0),
+ .glyphCount = 0,
+ .glyphPadding = 0,
+ .texture = @import("std").mem.zeroes(struct_Texture),
+ .recs = null,
+ .glyphs = null,
+};
+pub var guiLocked: bool = @as(c_int, 0) != 0;
+pub var guiAlpha: f32 = 1.0;
+pub var guiStyle: [384]c_uint = [1]c_uint{
+ 0,
+} ++ [1]c_uint{0} ** 383;
+pub var guiStyleLoaded: bool = @as(c_int, 0) != 0;
+pub fn GetTextWidth(arg_text: [*c]const u8) callconv(.C) c_int {
+ var text = arg_text;
+ var size: Vector2 = Vector2{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ };
+ if ((text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) and (@bitCast(c_int, @as(c_uint, text[@intCast(c_uint, @as(c_int, 0))])) != @as(c_int, '\x00'))) {
+ size = MeasureTextEx(guiFont, text, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SPACING)));
+ }
+ return @floatToInt(c_int, size.x);
+}
+pub fn GetTextBounds(arg_control: c_int, arg_bounds: Rectangle) callconv(.C) Rectangle {
+ var control = arg_control;
+ var bounds = arg_bounds;
+ var textBounds: Rectangle = bounds;
+ textBounds.x = bounds.x + @intToFloat(f32, GuiGetStyle(control, BORDER_WIDTH));
+ textBounds.y = bounds.y + @intToFloat(f32, GuiGetStyle(control, BORDER_WIDTH));
+ textBounds.width = bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(control, BORDER_WIDTH));
+ textBounds.height = bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(control, BORDER_WIDTH));
+ while (true) {
+ switch (control) {
+ @as(c_int, 7) => {
+ bounds.width -= @intToFloat(f32, GuiGetStyle(control, COMBO_BUTTON_WIDTH) + GuiGetStyle(control, COMBO_BUTTON_PADDING));
+ break;
+ },
+ @as(c_int, 10) => break,
+ else => {
+ {
+ if (GuiGetStyle(control, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) {
+ textBounds.x -= @intToFloat(f32, GuiGetStyle(control, TEXT_PADDING));
+ } else {
+ textBounds.x += @intToFloat(f32, GuiGetStyle(control, TEXT_PADDING));
+ }
+ }
+ break;
+ },
+ }
+ break;
+ }
+ return textBounds;
+}
+pub fn GetTextIcon(arg_text: [*c]const u8, arg_iconId: [*c]c_int) callconv(.C) [*c]const u8 {
+ var text = arg_text;
+ var iconId = arg_iconId;
+ iconId.* = -@as(c_int, 1);
+ if (@bitCast(c_int, @as(c_uint, text[@intCast(c_uint, @as(c_int, 0))])) == @as(c_int, '#')) {
+ var iconValue: [4]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 3;
+ var pos: c_int = 1;
+ while (((pos < @as(c_int, 4)) and (@bitCast(c_int, @as(c_uint, (blk: {
+ const tmp = pos;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) >= @as(c_int, '0'))) and (@bitCast(c_int, @as(c_uint, (blk: {
+ const tmp = pos;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) <= @as(c_int, '9'))) {
+ iconValue[@intCast(c_uint, pos - @as(c_int, 1))] = (blk: {
+ const tmp = pos;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ pos += 1;
+ }
+ if (@bitCast(c_int, @as(c_uint, (blk: {
+ const tmp = pos;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*)) == @as(c_int, '#')) {
+ iconId.* = TextToInteger(@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &iconValue)));
+ if (iconId.* >= @as(c_int, 0)) {
+ text += @bitCast(usize, @intCast(isize, pos + @as(c_int, 1)));
+ }
+ }
+ }
+ return text;
+}
+pub fn GuiDrawText(arg_text: [*c]const u8, arg_bounds: Rectangle, arg_alignment: c_int, arg_tint: Color) callconv(.C) void {
+ var text = arg_text;
+ var bounds = arg_bounds;
+ var alignment = arg_alignment;
+ var tint = arg_tint;
+ if ((text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) and (@bitCast(c_int, @as(c_uint, text[@intCast(c_uint, @as(c_int, 0))])) != @as(c_int, '\x00'))) {
+ var iconId: c_int = 0;
+ text = GetTextIcon(text, &iconId);
+ var position: Vector2 = Vector2{
+ .x = bounds.x,
+ .y = bounds.y,
+ };
+ var textWidth: c_int = GetTextWidth(text);
+ var textHeight: c_int = GuiGetStyle(DEFAULT, TEXT_SIZE);
+ if (iconId >= @as(c_int, 0)) {
+ textWidth += @as(c_int, 16);
+ if ((text != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) and (@bitCast(c_int, @as(c_uint, text[@intCast(c_uint, @as(c_int, 0))])) != @as(c_int, '\x00'))) {
+ textWidth += @as(c_int, 4);
+ }
+ }
+ while (true) {
+ switch (alignment) {
+ @as(c_int, 0) => {
+ {
+ position.x = bounds.x;
+ position.y = ((bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(textHeight, @as(c_int, 2)))) + @intToFloat(f32, @import("std").zig.c_translation.signedRemainder(@floatToInt(c_int, bounds.height), @as(c_int, 2)));
+ }
+ break;
+ },
+ @as(c_int, 1) => {
+ {
+ position.x = (bounds.x + (bounds.width / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(textWidth, @as(c_int, 2)));
+ position.y = ((bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(textHeight, @as(c_int, 2)))) + @intToFloat(f32, @import("std").zig.c_translation.signedRemainder(@floatToInt(c_int, bounds.height), @as(c_int, 2)));
+ }
+ break;
+ },
+ @as(c_int, 2) => {
+ {
+ position.x = (bounds.x + bounds.width) - @intToFloat(f32, textWidth);
+ position.y = ((bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(textHeight, @as(c_int, 2)))) + @intToFloat(f32, @import("std").zig.c_translation.signedRemainder(@floatToInt(c_int, bounds.height), @as(c_int, 2)));
+ }
+ break;
+ },
+ else => break,
+ }
+ break;
+ }
+ position.x = @intToFloat(f32, @floatToInt(c_int, position.x));
+ position.y = @intToFloat(f32, @floatToInt(c_int, position.y));
+ if (iconId >= @as(c_int, 0)) {
+ GuiDrawIcon(iconId, @floatToInt(c_int, position.x), @floatToInt(c_int, ((bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(@as(c_int, 16), @as(c_int, 2)))) + @intToFloat(f32, @import("std").zig.c_translation.signedRemainder(@floatToInt(c_int, bounds.height), @as(c_int, 2)))), @as(c_int, 1), tint);
+ position.x += @intToFloat(f32, @as(c_int, 16) + @as(c_int, 4));
+ }
+ DrawTextEx(guiFont, text, position, @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE)), @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SPACING)), tint);
+ }
+}
+pub fn GuiDrawRectangle(arg_rec: Rectangle, arg_borderWidth: c_int, arg_borderColor: Color, arg_color: Color) callconv(.C) void {
+ var rec = arg_rec;
+ var borderWidth = arg_borderWidth;
+ var borderColor = arg_borderColor;
+ var color = arg_color;
+ if (@bitCast(c_int, @as(c_uint, color.a)) > @as(c_int, 0)) {
+ DrawRectangle(@floatToInt(c_int, rec.x), @floatToInt(c_int, rec.y), @floatToInt(c_int, rec.width), @floatToInt(c_int, rec.height), color);
+ }
+ if (borderWidth > @as(c_int, 0)) {
+ DrawRectangle(@floatToInt(c_int, rec.x), @floatToInt(c_int, rec.y), @floatToInt(c_int, rec.width), borderWidth, borderColor);
+ DrawRectangle(@floatToInt(c_int, rec.x), @floatToInt(c_int, rec.y) + borderWidth, borderWidth, @floatToInt(c_int, rec.height) - (@as(c_int, 2) * borderWidth), borderColor);
+ DrawRectangle((@floatToInt(c_int, rec.x) + @floatToInt(c_int, rec.width)) - borderWidth, @floatToInt(c_int, rec.y) + borderWidth, borderWidth, @floatToInt(c_int, rec.height) - (@as(c_int, 2) * borderWidth), borderColor);
+ DrawRectangle(@floatToInt(c_int, rec.x), (@floatToInt(c_int, rec.y) + @floatToInt(c_int, rec.height)) - borderWidth, @floatToInt(c_int, rec.width), borderWidth, borderColor);
+ }
+}
+pub fn GuiTextSplit(arg_text: [*c]const u8, arg_count: [*c]c_int, arg_textRow: [*c]c_int) callconv(.C) [*c][*c]const u8 {
+ var text = arg_text;
+ var count = arg_count;
+ var textRow = arg_textRow;
+ const result = struct {
+ var static: [128][*c]const u8 = [1][*c]const u8{
+ null,
+ } ++ [1][*c]const u8{null} ** 127;
+ };
+ const buffer = struct {
+ var static: [1024]u8 = [1]u8{
+ 0,
+ } ++ [1]u8{0} ** 1023;
+ };
+ _ = memset(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static))), @as(c_int, 0), @bitCast(c_ulong, @as(c_long, @as(c_int, 1024))));
+ result.static[@intCast(c_uint, @as(c_int, 0))] = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static));
+ var counter: c_int = 1;
+ if (textRow != @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ textRow[@intCast(c_uint, @as(c_int, 0))] = 0;
+ }
+ {
+ var i: c_int = 0;
+ while (i < @as(c_int, 1024)) : (i += 1) {
+ buffer.static[@intCast(c_uint, i)] = (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk text + @intCast(usize, tmp) else break :blk text - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ if (@bitCast(c_int, @as(c_uint, buffer.static[@intCast(c_uint, i)])) == @as(c_int, '\x00')) break else if ((@bitCast(c_int, @as(c_uint, buffer.static[@intCast(c_uint, i)])) == @as(c_int, ';')) or (@bitCast(c_int, @as(c_uint, buffer.static[@intCast(c_uint, i)])) == @as(c_int, '\n'))) {
+ result.static[@intCast(c_uint, counter)] = (@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &buffer.static)) + @bitCast(usize, @intCast(isize, i))) + @bitCast(usize, @intCast(isize, @as(c_int, 1)));
+ if (textRow != @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ if (@bitCast(c_int, @as(c_uint, buffer.static[@intCast(c_uint, i)])) == @as(c_int, '\n')) {
+ (blk: {
+ const tmp = counter;
+ if (tmp >= 0) break :blk textRow + @intCast(usize, tmp) else break :blk textRow - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = (blk: {
+ const tmp = counter - @as(c_int, 1);
+ if (tmp >= 0) break :blk textRow + @intCast(usize, tmp) else break :blk textRow - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* + @as(c_int, 1);
+ } else {
+ (blk: {
+ const tmp = counter;
+ if (tmp >= 0) break :blk textRow + @intCast(usize, tmp) else break :blk textRow - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = (blk: {
+ const tmp = counter - @as(c_int, 1);
+ if (tmp >= 0) break :blk textRow + @intCast(usize, tmp) else break :blk textRow - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*;
+ }
+ }
+ buffer.static[@intCast(c_uint, i)] = '\x00';
+ counter += 1;
+ if (counter == @as(c_int, 128)) break;
+ }
+ }
+ }
+ count.* = counter;
+ return @ptrCast([*c][*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &result.static));
+}
+pub fn ConvertHSVtoRGB(arg_hsv: Vector3) callconv(.C) Vector3 {
+ var hsv = arg_hsv;
+ var rgb: Vector3 = Vector3{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .z = 0,
+ };
+ var hh: f32 = 0.0;
+ var p: f32 = 0.0;
+ var q: f32 = 0.0;
+ var t: f32 = 0.0;
+ var ff: f32 = 0.0;
+ var i: c_long = 0;
+ if (hsv.y <= 0.0) {
+ rgb.x = hsv.z;
+ rgb.y = hsv.z;
+ rgb.z = hsv.z;
+ return rgb;
+ }
+ hh = hsv.x;
+ if (hh >= 360.0) {
+ hh = 0.0;
+ }
+ hh /= 60.0;
+ i = @floatToInt(c_long, hh);
+ ff = hh - @intToFloat(f32, i);
+ p = hsv.z * (1.0 - hsv.y);
+ q = hsv.z * (1.0 - (hsv.y * ff));
+ t = hsv.z * (1.0 - (hsv.y * (1.0 - ff)));
+ while (true) {
+ switch (i) {
+ @bitCast(c_long, @as(c_long, @as(c_int, 0))) => {
+ {
+ rgb.x = hsv.z;
+ rgb.y = t;
+ rgb.z = p;
+ }
+ break;
+ },
+ @bitCast(c_long, @as(c_long, @as(c_int, 1))) => {
+ {
+ rgb.x = q;
+ rgb.y = hsv.z;
+ rgb.z = p;
+ }
+ break;
+ },
+ @bitCast(c_long, @as(c_long, @as(c_int, 2))) => {
+ {
+ rgb.x = p;
+ rgb.y = hsv.z;
+ rgb.z = t;
+ }
+ break;
+ },
+ @bitCast(c_long, @as(c_long, @as(c_int, 3))) => {
+ {
+ rgb.x = p;
+ rgb.y = q;
+ rgb.z = hsv.z;
+ }
+ break;
+ },
+ @bitCast(c_long, @as(c_long, @as(c_int, 4))) => {
+ {
+ rgb.x = t;
+ rgb.y = p;
+ rgb.z = hsv.z;
+ }
+ break;
+ },
+ else => {
+ {
+ rgb.x = hsv.z;
+ rgb.y = p;
+ rgb.z = q;
+ }
+ break;
+ },
+ }
+ break;
+ }
+ return rgb;
+}
+pub fn ConvertRGBtoHSV(arg_rgb: Vector3) callconv(.C) Vector3 {
+ var rgb = arg_rgb;
+ var hsv: Vector3 = Vector3{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .z = 0,
+ };
+ var min: f32 = 0.0;
+ var max: f32 = 0.0;
+ var delta: f32 = 0.0;
+ min = if (rgb.x < rgb.y) rgb.x else rgb.y;
+ min = if (min < rgb.z) min else rgb.z;
+ max = if (rgb.x > rgb.y) rgb.x else rgb.y;
+ max = if (max > rgb.z) max else rgb.z;
+ hsv.z = max;
+ delta = max - min;
+ if (delta < 0.000009999999747378752) {
+ hsv.y = 0.0;
+ hsv.x = 0.0;
+ return hsv;
+ }
+ if (max > 0.0) {
+ hsv.y = delta / max;
+ } else {
+ hsv.y = 0.0;
+ hsv.x = 0.0;
+ return hsv;
+ }
+ if (rgb.x >= max) {
+ hsv.x = (rgb.y - rgb.z) / delta;
+ } else {
+ if (rgb.y >= max) {
+ hsv.x = 2.0 + ((rgb.z - rgb.x) / delta);
+ } else {
+ hsv.x = 4.0 + ((rgb.x - rgb.y) / delta);
+ }
+ }
+ hsv.x *= 60.0;
+ if (hsv.x < 0.0) {
+ hsv.x += 360.0;
+ }
+ return hsv;
+}
+pub export fn GuiSliderPro(arg_bounds: Rectangle, arg_textLeft: [*c]const u8, arg_textRight: [*c]const u8, arg_value: f32, arg_minValue: f32, arg_maxValue: f32, arg_sliderWidth: c_int) f32 {
+ var bounds = arg_bounds;
+ var textLeft = arg_textLeft;
+ var textRight = arg_textRight;
+ var value = arg_value;
+ var minValue = arg_minValue;
+ var maxValue = arg_maxValue;
+ var sliderWidth = arg_sliderWidth;
+ var state: GuiControlState = guiState;
+ var sliderValue: c_int = @floatToInt(c_int, ((value - minValue) / (maxValue - minValue)) * (bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SLIDER, BORDER_WIDTH))));
+ var slider: Rectangle = Rectangle{
+ .x = bounds.x,
+ .y = (bounds.y + @intToFloat(f32, GuiGetStyle(SLIDER, BORDER_WIDTH))) + @intToFloat(f32, GuiGetStyle(SLIDER, SLIDER_PADDING)),
+ .width = @intToFloat(f32, @as(c_int, 0)),
+ .height = (bounds.height - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SLIDER, BORDER_WIDTH))) - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SLIDER, SLIDER_PADDING)),
+ };
+ if (sliderWidth > @as(c_int, 0)) {
+ slider.x += @intToFloat(f32, sliderValue - @divTrunc(sliderWidth, @as(c_int, 2)));
+ slider.width = @intToFloat(f32, sliderWidth);
+ } else if (sliderWidth == @as(c_int, 0)) {
+ slider.x += @intToFloat(f32, GuiGetStyle(SLIDER, BORDER_WIDTH));
+ slider.width = @intToFloat(f32, sliderValue);
+ }
+ if ((state != @bitCast(c_uint, GUI_STATE_DISABLED)) and !guiLocked) {
+ var mousePoint: Vector2 = GetMousePosition();
+ if (CheckCollisionPointRec(mousePoint, bounds)) {
+ if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+ state = @bitCast(c_uint, GUI_STATE_PRESSED);
+ value = (((maxValue - minValue) * (mousePoint.x - (bounds.x + @intToFloat(f32, @divTrunc(sliderWidth, @as(c_int, 2)))))) / (bounds.width - @intToFloat(f32, sliderWidth))) + minValue;
+ if (sliderWidth > @as(c_int, 0)) {
+ slider.x = mousePoint.x - (slider.width / @intToFloat(f32, @as(c_int, 2)));
+ } else if (sliderWidth == @as(c_int, 0)) {
+ slider.width = @intToFloat(f32, sliderValue);
+ }
+ } else {
+ state = @bitCast(c_uint, GUI_STATE_FOCUSED);
+ }
+ }
+ if (value > maxValue) {
+ value = maxValue;
+ } else if (value < minValue) {
+ value = minValue;
+ }
+ }
+ if (sliderWidth > @as(c_int, 0)) {
+ if (slider.x <= (bounds.x + @intToFloat(f32, GuiGetStyle(SLIDER, BORDER_WIDTH)))) {
+ slider.x = bounds.x + @intToFloat(f32, GuiGetStyle(SLIDER, BORDER_WIDTH));
+ } else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) {
+ slider.x = ((bounds.x + bounds.width) - slider.width) - @intToFloat(f32, GuiGetStyle(SLIDER, BORDER_WIDTH));
+ }
+ } else if (sliderWidth == @as(c_int, 0)) {
+ if (slider.width > bounds.width) {
+ slider.width = bounds.width - @intToFloat(f32, @as(c_int, 2) * GuiGetStyle(SLIDER, BORDER_WIDTH));
+ }
+ }
+ GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, @bitCast(c_int, @bitCast(c_uint, BORDER) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha), Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, if (state != @bitCast(c_uint, GUI_STATE_DISABLED)) BASE_COLOR_NORMAL else BASE_COLOR_DISABLED))), guiAlpha));
+ if ((state == @bitCast(c_uint, GUI_STATE_NORMAL)) or (state == @bitCast(c_uint, GUI_STATE_PRESSED))) {
+ GuiDrawRectangle(slider, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))), guiAlpha));
+ } else if (state == @bitCast(c_uint, GUI_STATE_FOCUSED)) {
+ GuiDrawRectangle(slider, @as(c_int, 0), Color{
+ .r = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .g = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .b = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ .a = @bitCast(u8, @truncate(i8, @as(c_int, 0))),
+ }, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED))), guiAlpha));
+ }
+ if (textLeft != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.width = @intToFloat(f32, GetTextWidth(textLeft));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x - textBounds.width) - @intToFloat(f32, GuiGetStyle(SLIDER, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ GuiDrawText(textLeft, textBounds, GUI_TEXT_ALIGN_RIGHT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ if (textRight != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment(u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var textBounds: Rectangle = Rectangle{
+ .x = @intToFloat(f32, @as(c_int, 0)),
+ .y = 0,
+ .width = 0,
+ .height = 0,
+ };
+ textBounds.width = @intToFloat(f32, GetTextWidth(textRight));
+ textBounds.height = @intToFloat(f32, GuiGetStyle(DEFAULT, TEXT_SIZE));
+ textBounds.x = (bounds.x + bounds.width) + @intToFloat(f32, GuiGetStyle(SLIDER, TEXT_PADDING));
+ textBounds.y = (bounds.y + (bounds.height / @intToFloat(f32, @as(c_int, 2)))) - @intToFloat(f32, @divTrunc(GuiGetStyle(DEFAULT, TEXT_SIZE), @as(c_int, 2)));
+ GuiDrawText(textRight, textBounds, GUI_TEXT_ALIGN_LEFT, Fade(GetColor(@bitCast(c_uint, GuiGetStyle(SLIDER, @bitCast(c_int, @bitCast(c_uint, TEXT) +% (state *% @bitCast(c_uint, @as(c_int, 3))))))), guiAlpha));
+ }
+ return value;
+}
+pub export fn GuiLoadIcons(arg_fileName: [*c]const u8, arg_loadIconsName: bool) [*c][*c]u8 {
+ var fileName = arg_fileName;
+ var loadIconsName = arg_loadIconsName;
+ var rgiFile: [*c]FILE = fopen(fileName, "rb");
+ var guiIconsName: [*c][*c]u8 = null;
+ if (rgiFile != @ptrCast([*c]FILE, @alignCast(@import("std").meta.alignment(FILE), @intToPtr(?*anyopaque, @as(c_int, 0))))) {
+ var signature: [5]u8 = [1]u8{0} ** 5;
+ var version: c_short = 0;
+ var reserved: c_short = 0;
+ var iconCount: c_short = 0;
+ var iconSize: c_short = 0;
+ _ = fread(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), &signature))), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @bitCast(c_ulong, @as(c_long, @as(c_int, 4))), rgiFile);
+ _ = fread(@ptrCast(?*anyopaque, &version), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgiFile);
+ _ = fread(@ptrCast(?*anyopaque, &reserved), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgiFile);
+ _ = fread(@ptrCast(?*anyopaque, &iconCount), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgiFile);
+ _ = fread(@ptrCast(?*anyopaque, &iconSize), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(c_short), rgiFile);
+ if ((((@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 0))])) == @as(c_int, 'r')) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 1))])) == @as(c_int, 'G'))) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 2))])) == @as(c_int, 'I'))) and (@bitCast(c_int, @as(c_uint, signature[@intCast(c_uint, @as(c_int, 3))])) == @as(c_int, ' '))) {
+ if (loadIconsName) {
+ //guiIconsName = @ptrCast([*c][*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), malloc(@bitCast(c_ulong, @as(c_long, iconCount)) *% @sizeOf([*c][*c]u8))));
+ {
+ var i: c_int = 0;
+ while (i < @bitCast(c_int, @as(c_int, iconCount))) : (i += 1) {
+ (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk guiIconsName + @intCast(usize, tmp) else break :blk guiIconsName - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).* = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), malloc(@bitCast(c_ulong, @as(c_long, @as(c_int, 32))))));
+ _ = fread(@ptrCast(?*anyopaque, (blk: {
+ const tmp = i;
+ if (tmp >= 0) break :blk guiIconsName + @intCast(usize, tmp) else break :blk guiIconsName - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+ }).*), @bitCast(c_ulong, @as(c_long, @as(c_int, 32))), @bitCast(c_ulong, @as(c_long, @as(c_int, 1))), rgiFile);
+ }
+ }
+ } else {
+ _ = fseek(rgiFile, @bitCast(c_long, @as(c_long, @bitCast(c_int, @as(c_int, iconCount)) * @as(c_int, 32))), @as(c_int, 1));
+ }
+ _ = fread(@ptrCast(?*anyopaque, @ptrCast([*c]c_uint, @alignCast(@import("std").meta.alignment(c_uint), &guiIcons))), @bitCast(c_ulong, @as(c_long, @bitCast(c_int, @as(c_int, iconCount)) * @divTrunc(@bitCast(c_int, @as(c_int, iconSize)) * @bitCast(c_int, @as(c_int, iconSize)), @as(c_int, 32)))), @sizeOf(c_uint), rgiFile);
+ }
+ _ = fclose(rgiFile);
+ }
+ return guiIconsName;
+}
+pub const __INTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); // (no file):67:9
+pub const __UINTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); // (no file):73:9
+pub const __INT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); // (no file):164:9
+pub const __UINT32_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `U`"); // (no file):186:9
+pub const __UINT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); // (no file):194:9
+pub const __seg_gs = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // (no file):315:9
+pub const __seg_fs = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // (no file):316:9
+pub const va_start = @compileError("unable to translate macro: undefined identifier `__builtin_va_start`"); // /home/tradam/.asdf/installs/zig/master/lib/include/stdarg.h:17:9
+pub const va_end = @compileError("unable to translate macro: undefined identifier `__builtin_va_end`"); // /home/tradam/.asdf/installs/zig/master/lib/include/stdarg.h:18:9
+pub const va_arg = @compileError("unable to translate macro: undefined identifier `__builtin_va_arg`"); // /home/tradam/.asdf/installs/zig/master/lib/include/stdarg.h:19:9
+pub const __va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // /home/tradam/.asdf/installs/zig/master/lib/include/stdarg.h:24:9
+pub const va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // /home/tradam/.asdf/installs/zig/master/lib/include/stdarg.h:27:9
+pub const TRACELOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // raygui.h:222:9
+pub const __GLIBC_USE = @compileError("unable to translate macro: undefined identifier `__GLIBC_USE_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/features.h:186:9
+pub const __glibc_has_attribute = @compileError("unable to translate macro: undefined identifier `__has_attribute`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:44:10
+pub const __glibc_has_extension = @compileError("unable to translate macro: undefined identifier `__has_extension`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:54:10
+pub const __THROW = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:78:11
+pub const __THROWNL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:79:11
+pub const __NTH = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:80:11
+pub const __NTHNL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:81:11
+pub const __CONCAT = @compileError("unable to translate C expr: unexpected token '##'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:123:9
+pub const __STRING = @compileError("unable to translate C expr: unexpected token '#'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:124:9
+pub const __warnattr = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:158:10
+pub const __errordecl = @compileError("unable to translate C expr: unexpected token 'extern'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:159:10
+pub const __flexarr = @compileError("unable to translate C expr: unexpected token '['"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:167:10
+pub const __REDIRECT = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:198:10
+pub const __REDIRECT_NTH = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:205:11
+pub const __REDIRECT_NTHNL = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:207:11
+pub const __ASMNAME2 = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:211:10
+pub const __attribute_malloc__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:232:10
+pub const __attribute_alloc_size__ = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:243:10
+pub const __attribute_pure__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:250:10
+pub const __attribute_const__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:257:10
+pub const __attribute_maybe_unused__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:263:10
+pub const __attribute_used__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:272:10
+pub const __attribute_noinline__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:273:10
+pub const __attribute_deprecated__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:281:10
+pub const __attribute_deprecated_msg__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:291:10
+pub const __attribute_format_arg__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:304:10
+pub const __attribute_format_strfmon__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:314:10
+pub const __nonnull = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:324:11
+pub const __returns_nonnull = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:337:10
+pub const __attribute_warn_unused_result__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:346:10
+pub const __always_inline = @compileError("unable to translate macro: undefined identifier `__inline`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:364:10
+pub const __attribute_artificial__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:373:10
+pub const __extern_inline = @compileError("unable to translate macro: undefined identifier `__inline`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:391:11
+pub const __extern_always_inline = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:392:11
+pub const __restrict_arr = @compileError("unable to translate macro: undefined identifier `__restrict`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:435:10
+pub const __attribute_copy__ = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:484:10
+pub const __LDBL_REDIR2_DECL = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:560:10
+pub const __LDBL_REDIR_DECL = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:561:10
+pub const __glibc_macro_warning1 = @compileError("unable to translate macro: undefined identifier `_Pragma`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:575:10
+pub const __glibc_macro_warning = @compileError("unable to translate macro: undefined identifier `GCC`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:576:10
+pub const __attr_access = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:612:11
+pub const __attr_access_none = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:613:11
+pub const __attr_dealloc = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:623:10
+pub const __attribute_returns_twice__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/sys/cdefs.h:630:10
+pub const __STD_TYPE = @compileError("unable to translate C expr: unexpected token 'typedef'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/types.h:137:10
+pub const __FSID_T_TYPE = @compileError("unable to translate macro: undefined identifier `__val`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/x86_64-linux-gnu/bits/typesizes.h:73:9
+pub const __getc_unlocked_body = @compileError("TODO postfix inc/dec expr"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/types/struct_FILE.h:102:9
+pub const __putc_unlocked_body = @compileError("TODO postfix inc/dec expr"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/types/struct_FILE.h:106:9
+pub const __f32 = @compileError("unable to translate macro: undefined identifier `f`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:91:12
+pub const __f64x = @compileError("unable to translate macro: undefined identifier `l`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:120:13
+pub const __CFLOAT32 = @compileError("unable to translate: TODO _Complex"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:149:12
+pub const __CFLOAT64 = @compileError("unable to translate: TODO _Complex"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:160:13
+pub const __CFLOAT32X = @compileError("unable to translate: TODO _Complex"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:169:12
+pub const __CFLOAT64X = @compileError("unable to translate: TODO _Complex"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:178:13
+pub const __builtin_nansf32 = @compileError("unable to translate macro: undefined identifier `__builtin_nansf`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:221:12
+pub const __builtin_huge_valf64 = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:255:13
+pub const __builtin_inff64 = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:256:13
+pub const __builtin_nanf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:257:13
+pub const __builtin_nansf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:258:13
+pub const __builtin_huge_valf32x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:272:12
+pub const __builtin_inff32x = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:273:12
+pub const __builtin_nanf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:274:12
+pub const __builtin_nansf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:275:12
+pub const __builtin_huge_valf64x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:289:13
+pub const __builtin_inff64x = @compileError("unable to translate macro: undefined identifier `__builtin_infl`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:290:13
+pub const __builtin_nanf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nanl`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:291:13
+pub const __builtin_nansf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nansl`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/floatn-common.h:292:13
+pub const __FD_ZERO = @compileError("unable to translate macro: undefined identifier `__i`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/select.h:25:9
+pub const __FD_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/select.h:32:9
+pub const __FD_CLR = @compileError("unable to translate C expr: expected ')' instead got '&='"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/select.h:34:9
+pub const __PTHREAD_MUTEX_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/x86_64-linux-gnu/bits/struct_mutex.h:56:10
+pub const __PTHREAD_RWLOCK_ELISION_EXTRA = @compileError("unable to translate C expr: unexpected token '{'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/x86_64-linux-gnu/bits/struct_rwlock.h:40:11
+pub const __ONCE_FLAG_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/bits/thread-shared-types.h:127:9
+pub const HUGE_VAL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:48:10
+pub const HUGE_VALL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:60:11
+pub const __SIMD_DECL = @compileError("unable to translate macro: undefined identifier `__DECL_SIMD_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:276:9
+pub const __MATHCALL_VEC = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:278:9
+pub const __MATHDECL_VEC = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:282:9
+pub const __MATHDECL = @compileError("unable to translate macro: undefined identifier `__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:288:9
+pub const __MATHDECLX = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:293:9
+pub const __MATHDECL_1_IMPL = @compileError("unable to translate C expr: unexpected token 'extern'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:296:9
+pub const __MATHREDIR = @compileError("unable to translate C expr: unexpected token 'extern'"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:305:9
+pub const __MATHCALL_NARROW_ARGS_1 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:550:9
+pub const __MATHCALL_NARROW_ARGS_2 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:551:9
+pub const __MATHCALL_NARROW_ARGS_3 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:552:9
+pub const __MATHCALL_NARROW_NORMAL = @compileError("unable to translate macro: undefined identifier `_Mret_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:553:9
+pub const __MATHCALL_NARROW_REDIR = @compileError("unable to translate macro: undefined identifier `_Mret_`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:555:9
+pub const __MATH_TG = @compileError("unable to translate macro: undefined identifier `f`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:916:10
+pub const fpclassify = @compileError("unable to translate macro: undefined identifier `__builtin_fpclassify`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:961:11
+pub const isfinite = @compileError("unable to translate macro: undefined identifier `__builtin_isfinite`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:988:11
+pub const isnormal = @compileError("unable to translate macro: undefined identifier `__builtin_isnormal`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:996:11
+pub const isgreater = @compileError("unable to translate macro: undefined identifier `__builtin_isgreater`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1282:11
+pub const isgreaterequal = @compileError("unable to translate macro: undefined identifier `__builtin_isgreaterequal`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1283:11
+pub const isless = @compileError("unable to translate macro: undefined identifier `__builtin_isless`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1284:11
+pub const islessequal = @compileError("unable to translate macro: undefined identifier `__builtin_islessequal`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1285:11
+pub const islessgreater = @compileError("unable to translate macro: undefined identifier `__builtin_islessgreater`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1286:11
+pub const isunordered = @compileError("unable to translate macro: undefined identifier `__builtin_isunordered`"); // /home/tradam/.asdf/installs/zig/master/lib/libc/include/generic-glibc/math.h:1287:11
+pub const BIT_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); // raygui.h:3698:13
+pub const BIT_CLEAR = @compileError("unable to translate C expr: expected ')' instead got '&='"); // raygui.h:3708:13
+pub const __llvm__ = @as(c_int, 1);
+pub const __clang__ = @as(c_int, 1);
+pub const __clang_major__ = @as(c_int, 13);
+pub const __clang_minor__ = @as(c_int, 0);
+pub const __clang_patchlevel__ = @as(c_int, 1);
+pub const __clang_version__ = "13.0.1 ([email protected]:ziglang/zig-bootstrap.git 81f0e6c5b902ead84753490db4f0007d08df964a)";
+pub const __GNUC__ = @as(c_int, 4);
+pub const __GNUC_MINOR__ = @as(c_int, 2);
+pub const __GNUC_PATCHLEVEL__ = @as(c_int, 1);
+pub const __GXX_ABI_VERSION = @as(c_int, 1002);
+pub const __ATOMIC_RELAXED = @as(c_int, 0);
+pub const __ATOMIC_CONSUME = @as(c_int, 1);
+pub const __ATOMIC_ACQUIRE = @as(c_int, 2);
+pub const __ATOMIC_RELEASE = @as(c_int, 3);
+pub const __ATOMIC_ACQ_REL = @as(c_int, 4);
+pub const __ATOMIC_SEQ_CST = @as(c_int, 5);
+pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = @as(c_int, 0);
+pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = @as(c_int, 1);
+pub const __OPENCL_MEMORY_SCOPE_DEVICE = @as(c_int, 2);
+pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = @as(c_int, 3);
+pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = @as(c_int, 4);
+pub const __PRAGMA_REDEFINE_EXTNAME = @as(c_int, 1);
+pub const __VERSION__ = "Clang 13.0.1 ([email protected]:ziglang/zig-bootstrap.git 81f0e6c5b902ead84753490db4f0007d08df964a)";
+pub const __OBJC_BOOL_IS_BOOL = @as(c_int, 0);
+pub const __CONSTANT_CFSTRINGS__ = @as(c_int, 1);
+pub const __clang_literal_encoding__ = "UTF-8";
+pub const __clang_wide_literal_encoding__ = "UTF-32";
+pub const __OPTIMIZE__ = @as(c_int, 1);
+pub const __ORDER_LITTLE_ENDIAN__ = @as(c_int, 1234);
+pub const __ORDER_BIG_ENDIAN__ = @as(c_int, 4321);
+pub const __ORDER_PDP_ENDIAN__ = @as(c_int, 3412);
+pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__;
+pub const __LITTLE_ENDIAN__ = @as(c_int, 1);
+pub const _LP64 = @as(c_int, 1);
+pub const __LP64__ = @as(c_int, 1);
+pub const __CHAR_BIT__ = @as(c_int, 8);
+pub const __SCHAR_MAX__ = @as(c_int, 127);
+pub const __SHRT_MAX__ = @as(c_int, 32767);
+pub const __INT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __LONG_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807);
+pub const __WCHAR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __WINT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal);
+pub const __INTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __SIZE_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __UINTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __PTRDIFF_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __INTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __UINTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __SIZEOF_DOUBLE__ = @as(c_int, 8);
+pub const __SIZEOF_FLOAT__ = @as(c_int, 4);
+pub const __SIZEOF_INT__ = @as(c_int, 4);
+pub const __SIZEOF_LONG__ = @as(c_int, 8);
+pub const __SIZEOF_LONG_DOUBLE__ = @as(c_int, 16);
+pub const __SIZEOF_LONG_LONG__ = @as(c_int, 8);
+pub const __SIZEOF_POINTER__ = @as(c_int, 8);
+pub const __SIZEOF_SHORT__ = @as(c_int, 2);
+pub const __SIZEOF_PTRDIFF_T__ = @as(c_int, 8);
+pub const __SIZEOF_SIZE_T__ = @as(c_int, 8);
+pub const __SIZEOF_WCHAR_T__ = @as(c_int, 4);
+pub const __SIZEOF_WINT_T__ = @as(c_int, 4);
+pub const __SIZEOF_INT128__ = @as(c_int, 16);
+pub const __INTMAX_TYPE__ = c_long;
+pub const __INTMAX_FMTd__ = "ld";
+pub const __INTMAX_FMTi__ = "li";
+pub const __UINTMAX_TYPE__ = c_ulong;
+pub const __UINTMAX_FMTo__ = "lo";
+pub const __UINTMAX_FMTu__ = "lu";
+pub const __UINTMAX_FMTx__ = "lx";
+pub const __UINTMAX_FMTX__ = "lX";
+pub const __INTMAX_WIDTH__ = @as(c_int, 64);
+pub const __PTRDIFF_TYPE__ = c_long;
+pub const __PTRDIFF_FMTd__ = "ld";
+pub const __PTRDIFF_FMTi__ = "li";
+pub const __PTRDIFF_WIDTH__ = @as(c_int, 64);
+pub const __INTPTR_TYPE__ = c_long;
+pub const __INTPTR_FMTd__ = "ld";
+pub const __INTPTR_FMTi__ = "li";
+pub const __INTPTR_WIDTH__ = @as(c_int, 64);
+pub const __SIZE_TYPE__ = c_ulong;
+pub const __SIZE_FMTo__ = "lo";
+pub const __SIZE_FMTu__ = "lu";
+pub const __SIZE_FMTx__ = "lx";
+pub const __SIZE_FMTX__ = "lX";
+pub const __SIZE_WIDTH__ = @as(c_int, 64);
+pub const __WCHAR_TYPE__ = c_int;
+pub const __WCHAR_WIDTH__ = @as(c_int, 32);
+pub const __WINT_TYPE__ = c_uint;
+pub const __WINT_WIDTH__ = @as(c_int, 32);
+pub const __SIG_ATOMIC_WIDTH__ = @as(c_int, 32);
+pub const __SIG_ATOMIC_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __CHAR16_TYPE__ = c_ushort;
+pub const __CHAR32_TYPE__ = c_uint;
+pub const __UINTMAX_WIDTH__ = @as(c_int, 64);
+pub const __UINTPTR_TYPE__ = c_ulong;
+pub const __UINTPTR_FMTo__ = "lo";
+pub const __UINTPTR_FMTu__ = "lu";
+pub const __UINTPTR_FMTx__ = "lx";
+pub const __UINTPTR_FMTX__ = "lX";
+pub const __UINTPTR_WIDTH__ = @as(c_int, 64);
+pub const __FLT_DENORM_MIN__ = @as(f32, 1.40129846e-45);
+pub const __FLT_HAS_DENORM__ = @as(c_int, 1);
+pub const __FLT_DIG__ = @as(c_int, 6);
+pub const __FLT_DECIMAL_DIG__ = @as(c_int, 9);
+pub const __FLT_EPSILON__ = @as(f32, 1.19209290e-7);
+pub const __FLT_HAS_INFINITY__ = @as(c_int, 1);
+pub const __FLT_HAS_QUIET_NAN__ = @as(c_int, 1);
+pub const __FLT_MANT_DIG__ = @as(c_int, 24);
+pub const __FLT_MAX_10_EXP__ = @as(c_int, 38);
+pub const __FLT_MAX_EXP__ = @as(c_int, 128);
+pub const __FLT_MAX__ = @as(f32, 3.40282347e+38);
+pub const __FLT_MIN_10_EXP__ = -@as(c_int, 37);
+pub const __FLT_MIN_EXP__ = -@as(c_int, 125);
+pub const __FLT_MIN__ = @as(f32, 1.17549435e-38);
+pub const __DBL_DENORM_MIN__ = 4.9406564584124654e-324;
+pub const __DBL_HAS_DENORM__ = @as(c_int, 1);
+pub const __DBL_DIG__ = @as(c_int, 15);
+pub const __DBL_DECIMAL_DIG__ = @as(c_int, 17);
+pub const __DBL_EPSILON__ = 2.2204460492503131e-16;
+pub const __DBL_HAS_INFINITY__ = @as(c_int, 1);
+pub const __DBL_HAS_QUIET_NAN__ = @as(c_int, 1);
+pub const __DBL_MANT_DIG__ = @as(c_int, 53);
+pub const __DBL_MAX_10_EXP__ = @as(c_int, 308);
+pub const __DBL_MAX_EXP__ = @as(c_int, 1024);
+pub const __DBL_MAX__ = 1.7976931348623157e+308;
+pub const __DBL_MIN_10_EXP__ = -@as(c_int, 307);
+pub const __DBL_MIN_EXP__ = -@as(c_int, 1021);
+pub const __DBL_MIN__ = 2.2250738585072014e-308;
+pub const __LDBL_DENORM_MIN__ = @as(c_longdouble, 3.64519953188247460253e-4951);
+pub const __LDBL_HAS_DENORM__ = @as(c_int, 1);
+pub const __LDBL_DIG__ = @as(c_int, 18);
+pub const __LDBL_DECIMAL_DIG__ = @as(c_int, 21);
+pub const __LDBL_EPSILON__ = @as(c_longdouble, 1.08420217248550443401e-19);
+pub const __LDBL_HAS_INFINITY__ = @as(c_int, 1);
+pub const __LDBL_HAS_QUIET_NAN__ = @as(c_int, 1);
+pub const __LDBL_MANT_DIG__ = @as(c_int, 64);
+pub const __LDBL_MAX_10_EXP__ = @as(c_int, 4932);
+pub const __LDBL_MAX_EXP__ = @as(c_int, 16384);
+pub const __LDBL_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932);
+pub const __LDBL_MIN_10_EXP__ = -@as(c_int, 4931);
+pub const __LDBL_MIN_EXP__ = -@as(c_int, 16381);
+pub const __LDBL_MIN__ = @as(c_longdouble, 3.36210314311209350626e-4932);
+pub const __POINTER_WIDTH__ = @as(c_int, 64);
+pub const __BIGGEST_ALIGNMENT__ = @as(c_int, 16);
+pub const __WINT_UNSIGNED__ = @as(c_int, 1);
+pub const __INT8_TYPE__ = i8;
+pub const __INT8_FMTd__ = "hhd";
+pub const __INT8_FMTi__ = "hhi";
+pub const __INT8_C_SUFFIX__ = "";
+pub const __INT16_TYPE__ = c_short;
+pub const __INT16_FMTd__ = "hd";
+pub const __INT16_FMTi__ = "hi";
+pub const __INT16_C_SUFFIX__ = "";
+pub const __INT32_TYPE__ = c_int;
+pub const __INT32_FMTd__ = "d";
+pub const __INT32_FMTi__ = "i";
+pub const __INT32_C_SUFFIX__ = "";
+pub const __INT64_TYPE__ = c_long;
+pub const __INT64_FMTd__ = "ld";
+pub const __INT64_FMTi__ = "li";
+pub const __UINT8_TYPE__ = u8;
+pub const __UINT8_FMTo__ = "hho";
+pub const __UINT8_FMTu__ = "hhu";
+pub const __UINT8_FMTx__ = "hhx";
+pub const __UINT8_FMTX__ = "hhX";
+pub const __UINT8_C_SUFFIX__ = "";
+pub const __UINT8_MAX__ = @as(c_int, 255);
+pub const __INT8_MAX__ = @as(c_int, 127);
+pub const __UINT16_TYPE__ = c_ushort;
+pub const __UINT16_FMTo__ = "ho";
+pub const __UINT16_FMTu__ = "hu";
+pub const __UINT16_FMTx__ = "hx";
+pub const __UINT16_FMTX__ = "hX";
+pub const __UINT16_C_SUFFIX__ = "";
+pub const __UINT16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal);
+pub const __INT16_MAX__ = @as(c_int, 32767);
+pub const __UINT32_TYPE__ = c_uint;
+pub const __UINT32_FMTo__ = "o";
+pub const __UINT32_FMTu__ = "u";
+pub const __UINT32_FMTx__ = "x";
+pub const __UINT32_FMTX__ = "X";
+pub const __UINT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal);
+pub const __INT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __UINT64_TYPE__ = c_ulong;
+pub const __UINT64_FMTo__ = "lo";
+pub const __UINT64_FMTu__ = "lu";
+pub const __UINT64_FMTx__ = "lx";
+pub const __UINT64_FMTX__ = "lX";
+pub const __UINT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __INT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __INT_LEAST8_TYPE__ = i8;
+pub const __INT_LEAST8_MAX__ = @as(c_int, 127);
+pub const __INT_LEAST8_FMTd__ = "hhd";
+pub const __INT_LEAST8_FMTi__ = "hhi";
+pub const __UINT_LEAST8_TYPE__ = u8;
+pub const __UINT_LEAST8_MAX__ = @as(c_int, 255);
+pub const __UINT_LEAST8_FMTo__ = "hho";
+pub const __UINT_LEAST8_FMTu__ = "hhu";
+pub const __UINT_LEAST8_FMTx__ = "hhx";
+pub const __UINT_LEAST8_FMTX__ = "hhX";
+pub const __INT_LEAST16_TYPE__ = c_short;
+pub const __INT_LEAST16_MAX__ = @as(c_int, 32767);
+pub const __INT_LEAST16_FMTd__ = "hd";
+pub const __INT_LEAST16_FMTi__ = "hi";
+pub const __UINT_LEAST16_TYPE__ = c_ushort;
+pub const __UINT_LEAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal);
+pub const __UINT_LEAST16_FMTo__ = "ho";
+pub const __UINT_LEAST16_FMTu__ = "hu";
+pub const __UINT_LEAST16_FMTx__ = "hx";
+pub const __UINT_LEAST16_FMTX__ = "hX";
+pub const __INT_LEAST32_TYPE__ = c_int;
+pub const __INT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __INT_LEAST32_FMTd__ = "d";
+pub const __INT_LEAST32_FMTi__ = "i";
+pub const __UINT_LEAST32_TYPE__ = c_uint;
+pub const __UINT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal);
+pub const __UINT_LEAST32_FMTo__ = "o";
+pub const __UINT_LEAST32_FMTu__ = "u";
+pub const __UINT_LEAST32_FMTx__ = "x";
+pub const __UINT_LEAST32_FMTX__ = "X";
+pub const __INT_LEAST64_TYPE__ = c_long;
+pub const __INT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __INT_LEAST64_FMTd__ = "ld";
+pub const __INT_LEAST64_FMTi__ = "li";
+pub const __UINT_LEAST64_TYPE__ = c_ulong;
+pub const __UINT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __UINT_LEAST64_FMTo__ = "lo";
+pub const __UINT_LEAST64_FMTu__ = "lu";
+pub const __UINT_LEAST64_FMTx__ = "lx";
+pub const __UINT_LEAST64_FMTX__ = "lX";
+pub const __INT_FAST8_TYPE__ = i8;
+pub const __INT_FAST8_MAX__ = @as(c_int, 127);
+pub const __INT_FAST8_FMTd__ = "hhd";
+pub const __INT_FAST8_FMTi__ = "hhi";
+pub const __UINT_FAST8_TYPE__ = u8;
+pub const __UINT_FAST8_MAX__ = @as(c_int, 255);
+pub const __UINT_FAST8_FMTo__ = "hho";
+pub const __UINT_FAST8_FMTu__ = "hhu";
+pub const __UINT_FAST8_FMTx__ = "hhx";
+pub const __UINT_FAST8_FMTX__ = "hhX";
+pub const __INT_FAST16_TYPE__ = c_short;
+pub const __INT_FAST16_MAX__ = @as(c_int, 32767);
+pub const __INT_FAST16_FMTd__ = "hd";
+pub const __INT_FAST16_FMTi__ = "hi";
+pub const __UINT_FAST16_TYPE__ = c_ushort;
+pub const __UINT_FAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal);
+pub const __UINT_FAST16_FMTo__ = "ho";
+pub const __UINT_FAST16_FMTu__ = "hu";
+pub const __UINT_FAST16_FMTx__ = "hx";
+pub const __UINT_FAST16_FMTX__ = "hX";
+pub const __INT_FAST32_TYPE__ = c_int;
+pub const __INT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const __INT_FAST32_FMTd__ = "d";
+pub const __INT_FAST32_FMTi__ = "i";
+pub const __UINT_FAST32_TYPE__ = c_uint;
+pub const __UINT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal);
+pub const __UINT_FAST32_FMTo__ = "o";
+pub const __UINT_FAST32_FMTu__ = "u";
+pub const __UINT_FAST32_FMTx__ = "x";
+pub const __UINT_FAST32_FMTX__ = "X";
+pub const __INT_FAST64_TYPE__ = c_long;
+pub const __INT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal);
+pub const __INT_FAST64_FMTd__ = "ld";
+pub const __INT_FAST64_FMTi__ = "li";
+pub const __UINT_FAST64_TYPE__ = c_ulong;
+pub const __UINT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal);
+pub const __UINT_FAST64_FMTo__ = "lo";
+pub const __UINT_FAST64_FMTu__ = "lu";
+pub const __UINT_FAST64_FMTx__ = "lx";
+pub const __UINT_FAST64_FMTX__ = "lX";
+pub const __USER_LABEL_PREFIX__ = "";
+pub const __FINITE_MATH_ONLY__ = @as(c_int, 0);
+pub const __GNUC_STDC_INLINE__ = @as(c_int, 1);
+pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = @as(c_int, 1);
+pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_INT_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2);
+pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_INT_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2);
+pub const __GCC_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2);
+pub const __PIC__ = @as(c_int, 2);
+pub const __pic__ = @as(c_int, 2);
+pub const __FLT_EVAL_METHOD__ = @as(c_int, 0);
+pub const __FLT_RADIX__ = @as(c_int, 2);
+pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__;
+pub const __SSP_STRONG__ = @as(c_int, 2);
+pub const __GCC_ASM_FLAG_OUTPUTS__ = @as(c_int, 1);
+pub const __code_model_small__ = @as(c_int, 1);
+pub const __amd64__ = @as(c_int, 1);
+pub const __amd64 = @as(c_int, 1);
+pub const __x86_64 = @as(c_int, 1);
+pub const __x86_64__ = @as(c_int, 1);
+pub const __SEG_GS = @as(c_int, 1);
+pub const __SEG_FS = @as(c_int, 1);
+pub const __corei7 = @as(c_int, 1);
+pub const __corei7__ = @as(c_int, 1);
+pub const __tune_corei7__ = @as(c_int, 1);
+pub const __REGISTER_PREFIX__ = "";
+pub const __NO_MATH_INLINES = @as(c_int, 1);
+pub const __AES__ = @as(c_int, 1);
+pub const __PCLMUL__ = @as(c_int, 1);
+pub const __LAHF_SAHF__ = @as(c_int, 1);
+pub const __RDRND__ = @as(c_int, 1);
+pub const __FSGSBASE__ = @as(c_int, 1);
+pub const __POPCNT__ = @as(c_int, 1);
+pub const __F16C__ = @as(c_int, 1);
+pub const __FXSR__ = @as(c_int, 1);
+pub const __XSAVE__ = @as(c_int, 1);
+pub const __XSAVEOPT__ = @as(c_int, 1);
+pub const __AVX__ = @as(c_int, 1);
+pub const __SSE4_2__ = @as(c_int, 1);
+pub const __SSE4_1__ = @as(c_int, 1);
+pub const __SSSE3__ = @as(c_int, 1);
+pub const __SSE3__ = @as(c_int, 1);
+pub const __SSE2__ = @as(c_int, 1);
+pub const __SSE2_MATH__ = @as(c_int, 1);
+pub const __SSE__ = @as(c_int, 1);
+pub const __SSE_MATH__ = @as(c_int, 1);
+pub const __MMX__ = @as(c_int, 1);
+pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = @as(c_int, 1);
+pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = @as(c_int, 1);
+pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = @as(c_int, 1);
+pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = @as(c_int, 1);
+pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = @as(c_int, 1);
+pub const __SIZEOF_FLOAT128__ = @as(c_int, 16);
+pub const unix = @as(c_int, 1);
+pub const __unix = @as(c_int, 1);
+pub const __unix__ = @as(c_int, 1);
+pub const linux = @as(c_int, 1);
+pub const __linux = @as(c_int, 1);
+pub const __linux__ = @as(c_int, 1);
+pub const __ELF__ = @as(c_int, 1);
+pub const __gnu_linux__ = @as(c_int, 1);
+pub const __FLOAT128__ = @as(c_int, 1);
+pub const __STDC__ = @as(c_int, 1);
+pub const __STDC_HOSTED__ = @as(c_int, 1);
+pub const __STDC_VERSION__ = @as(c_long, 201710);
+pub const __STDC_UTF_16__ = @as(c_int, 1);
+pub const __STDC_UTF_32__ = @as(c_int, 1);
+pub const __GLIBC_MINOR__ = @as(c_int, 19);
+pub const _DEBUG = @as(c_int, 1);
+pub const RAYGUI_IMPLEMENTATION = @as(c_int, 1);
+pub const __GCC_HAVE_DWARF2_CFI_ASM = @as(c_int, 1);
+pub const RAYGUI_H = "";
+pub const RAYGUI_VERSION = "3.0";
+pub const RAYLIB_H = "";
+pub const __STDARG_H = "";
+pub const _VA_LIST = "";
+pub const __GNUC_VA_LIST = @as(c_int, 1);
+pub const RAYLIB_VERSION = "4.1-dev";
+pub const RLAPI = "";
+pub const PI = @as(f32, 3.14159265358979323846);
+pub const DEG2RAD = PI / @as(f32, 180.0);
+pub const RAD2DEG = @as(f32, 180.0) / PI;
+pub inline fn RL_MALLOC(sz: anytype) @TypeOf(malloc(sz)) {
+ return malloc(sz);
+}
+pub inline fn RL_CALLOC(n: anytype, sz: anytype) @TypeOf(calloc(n, sz)) {
+ return calloc(n, sz);
+}
+pub inline fn RL_REALLOC(ptr: anytype, sz: anytype) @TypeOf(realloc(ptr, sz)) {
+ return realloc(ptr, sz);
+}
+pub inline fn RL_FREE(ptr: anytype) @TypeOf(free(ptr)) {
+ return free(ptr);
+}
+pub inline fn CLITERAL(@"type": anytype) @TypeOf(@"type") {
+ return @"type";
+}
+pub const RL_COLOR_TYPE = "";
+pub const RL_RECTANGLE_TYPE = "";
+pub const RL_VECTOR2_TYPE = "";
+pub const RL_VECTOR3_TYPE = "";
+pub const RL_VECTOR4_TYPE = "";
+pub const RL_QUATERNION_TYPE = "";
+pub const RL_MATRIX_TYPE = "";
+pub const LIGHTGRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 200), @as(c_int, 200), @as(c_int, 200), @as(c_int, 255) });
+pub const GRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 130), @as(c_int, 130), @as(c_int, 130), @as(c_int, 255) });
+pub const DARKGRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 80), @as(c_int, 80), @as(c_int, 80), @as(c_int, 255) });
+pub const YELLOW = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 253), @as(c_int, 249), @as(c_int, 0), @as(c_int, 255) });
+pub const GOLD = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 203), @as(c_int, 0), @as(c_int, 255) });
+pub const ORANGE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 161), @as(c_int, 0), @as(c_int, 255) });
+pub const PINK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 109), @as(c_int, 194), @as(c_int, 255) });
+pub const RED = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 230), @as(c_int, 41), @as(c_int, 55), @as(c_int, 255) });
+pub const MAROON = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 190), @as(c_int, 33), @as(c_int, 55), @as(c_int, 255) });
+pub const GREEN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 228), @as(c_int, 48), @as(c_int, 255) });
+pub const LIME = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 158), @as(c_int, 47), @as(c_int, 255) });
+pub const DARKGREEN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 117), @as(c_int, 44), @as(c_int, 255) });
+pub const SKYBLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 102), @as(c_int, 191), @as(c_int, 255), @as(c_int, 255) });
+pub const BLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 121), @as(c_int, 241), @as(c_int, 255) });
+pub const DARKBLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 82), @as(c_int, 172), @as(c_int, 255) });
+pub const PURPLE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 200), @as(c_int, 122), @as(c_int, 255), @as(c_int, 255) });
+pub const VIOLET = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 135), @as(c_int, 60), @as(c_int, 190), @as(c_int, 255) });
+pub const DARKPURPLE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 112), @as(c_int, 31), @as(c_int, 126), @as(c_int, 255) });
+pub const BEIGE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 211), @as(c_int, 176), @as(c_int, 131), @as(c_int, 255) });
+pub const BROWN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 127), @as(c_int, 106), @as(c_int, 79), @as(c_int, 255) });
+pub const DARKBROWN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 76), @as(c_int, 63), @as(c_int, 47), @as(c_int, 255) });
+pub const WHITE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 255), @as(c_int, 255), @as(c_int, 255) });
+pub const BLACK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0), @as(c_int, 255) });
+pub const BLANK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0), @as(c_int, 0) });
+pub const MAGENTA = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 0), @as(c_int, 255), @as(c_int, 255) });
+pub const RAYWHITE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 245), @as(c_int, 245), @as(c_int, 245), @as(c_int, 255) });
+pub const __STDBOOL_H = "";
+pub const @"bool" = bool;
+pub const @"true" = @as(c_int, 1);
+pub const @"false" = @as(c_int, 0);
+pub const __bool_true_false_are_defined = @as(c_int, 1);
+pub const MOUSE_LEFT_BUTTON = MOUSE_BUTTON_LEFT;
+pub const MOUSE_RIGHT_BUTTON = MOUSE_BUTTON_RIGHT;
+pub const MOUSE_MIDDLE_BUTTON = MOUSE_BUTTON_MIDDLE;
+pub const MATERIAL_MAP_DIFFUSE = MATERIAL_MAP_ALBEDO;
+pub const MATERIAL_MAP_SPECULAR = MATERIAL_MAP_METALNESS;
+pub const SHADER_LOC_MAP_DIFFUSE = SHADER_LOC_MAP_ALBEDO;
+pub const SHADER_LOC_MAP_SPECULAR = SHADER_LOC_MAP_METALNESS;
+pub const RAYGUIAPI = "";
+pub inline fn RAYGUI_MALLOC(sz: anytype) @TypeOf(malloc(sz)) {
+ return malloc(sz);
+}
+pub inline fn RAYGUI_CALLOC(n: anytype, sz: anytype) @TypeOf(calloc(n, sz)) {
+ return calloc(n, sz);
+}
+pub inline fn RAYGUI_FREE(p: anytype) @TypeOf(free(p)) {
+ return free(p);
+}
+pub const _STDIO_H = @as(c_int, 1);
+pub const __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION = "";
+pub const _FEATURES_H = @as(c_int, 1);
+pub const __KERNEL_STRICT_NAMES = "";
+pub inline fn __GNUC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) {
+ return ((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min);
+}
+pub inline fn __glibc_clang_prereq(maj: anytype, min: anytype) @TypeOf(((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min)) {
+ return ((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min);
+}
+pub const _DEFAULT_SOURCE = @as(c_int, 1);
+pub const __GLIBC_USE_ISOC2X = @as(c_int, 0);
+pub const __USE_ISOC11 = @as(c_int, 1);
+pub const __USE_ISOC99 = @as(c_int, 1);
+pub const __USE_ISOC95 = @as(c_int, 1);
+pub const __USE_POSIX_IMPLICITLY = @as(c_int, 1);
+pub const _POSIX_SOURCE = @as(c_int, 1);
+pub const _POSIX_C_SOURCE = @as(c_long, 200809);
+pub const __USE_POSIX = @as(c_int, 1);
+pub const __USE_POSIX2 = @as(c_int, 1);
+pub const __USE_POSIX199309 = @as(c_int, 1);
+pub const __USE_POSIX199506 = @as(c_int, 1);
+pub const __USE_XOPEN2K = @as(c_int, 1);
+pub const __USE_XOPEN2K8 = @as(c_int, 1);
+pub const _ATFILE_SOURCE = @as(c_int, 1);
+pub const __WORDSIZE = @as(c_int, 64);
+pub const __WORDSIZE_TIME64_COMPAT32 = @as(c_int, 1);
+pub const __SYSCALL_WORDSIZE = @as(c_int, 64);
+pub const __TIMESIZE = __WORDSIZE;
+pub const __USE_MISC = @as(c_int, 1);
+pub const __USE_ATFILE = @as(c_int, 1);
+pub const __USE_FORTIFY_LEVEL = @as(c_int, 0);
+pub const __GLIBC_USE_DEPRECATED_GETS = @as(c_int, 0);
+pub const __GLIBC_USE_DEPRECATED_SCANF = @as(c_int, 0);
+pub const _STDC_PREDEF_H = @as(c_int, 1);
+pub const __STDC_IEC_559__ = @as(c_int, 1);
+pub const __STDC_IEC_559_COMPLEX__ = @as(c_int, 1);
+pub const __STDC_ISO_10646__ = @as(c_long, 201706);
+pub const __GNU_LIBRARY__ = @as(c_int, 6);
+pub const __GLIBC__ = @as(c_int, 2);
+pub inline fn __GLIBC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) {
+ return ((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min);
+}
+pub const _SYS_CDEFS_H = @as(c_int, 1);
+pub inline fn __glibc_has_builtin(name: anytype) @TypeOf(__has_builtin(name)) {
+ return __has_builtin(name);
+}
+pub const __LEAF = "";
+pub const __LEAF_ATTR = "";
+pub inline fn __P(args: anytype) @TypeOf(args) {
+ return args;
+}
+pub inline fn __PMT(args: anytype) @TypeOf(args) {
+ return args;
+}
+pub const __ptr_t = ?*anyopaque;
+pub const __BEGIN_DECLS = "";
+pub const __END_DECLS = "";
+pub inline fn __bos(ptr: anytype) @TypeOf(__builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1))) {
+ return __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1));
+}
+pub inline fn __bos0(ptr: anytype) @TypeOf(__builtin_object_size(ptr, @as(c_int, 0))) {
+ return __builtin_object_size(ptr, @as(c_int, 0));
+}
+pub inline fn __glibc_objsize0(__o: anytype) @TypeOf(__bos0(__o)) {
+ return __bos0(__o);
+}
+pub inline fn __glibc_objsize(__o: anytype) @TypeOf(__bos(__o)) {
+ return __bos(__o);
+}
+pub const __glibc_c99_flexarr_available = @as(c_int, 1);
+pub inline fn __ASMNAME(cname: anytype) @TypeOf(__ASMNAME2(__USER_LABEL_PREFIX__, cname)) {
+ return __ASMNAME2(__USER_LABEL_PREFIX__, cname);
+}
+pub const __wur = "";
+pub const __fortify_function = __extern_always_inline ++ __attribute_artificial__;
+pub inline fn __glibc_unlikely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 0))) {
+ return __builtin_expect(cond, @as(c_int, 0));
+}
+pub inline fn __glibc_likely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 1))) {
+ return __builtin_expect(cond, @as(c_int, 1));
+}
+pub const __attribute_nonstring__ = "";
+pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = @as(c_int, 0);
+pub inline fn __LDBL_REDIR1(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto) {
+ _ = alias;
+ return name ++ proto;
+}
+pub inline fn __LDBL_REDIR(name: anytype, proto: anytype) @TypeOf(name ++ proto) {
+ return name ++ proto;
+}
+pub inline fn __LDBL_REDIR1_NTH(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto ++ __THROW) {
+ _ = alias;
+ return name ++ proto ++ __THROW;
+}
+pub inline fn __LDBL_REDIR_NTH(name: anytype, proto: anytype) @TypeOf(name ++ proto ++ __THROW) {
+ return name ++ proto ++ __THROW;
+}
+pub inline fn __REDIRECT_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT(name, proto, alias)) {
+ return __REDIRECT(name, proto, alias);
+}
+pub inline fn __REDIRECT_NTH_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT_NTH(name, proto, alias)) {
+ return __REDIRECT_NTH(name, proto, alias);
+}
+pub const __HAVE_GENERIC_SELECTION = @as(c_int, 1);
+pub const __attr_dealloc_free = "";
+pub const __USE_EXTERN_INLINES = @as(c_int, 1);
+pub const __stub___compat_bdflush = "";
+pub const __stub_chflags = "";
+pub const __stub_fchflags = "";
+pub const __stub_gtty = "";
+pub const __stub_revoke = "";
+pub const __stub_setlogin = "";
+pub const __stub_sigreturn = "";
+pub const __stub_stty = "";
+pub const __GLIBC_USE_LIB_EXT2 = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_BFP_EXT = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_EXT = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_FUNCS_EXT = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = @as(c_int, 0);
+pub const __GLIBC_USE_IEC_60559_TYPES_EXT = @as(c_int, 0);
+pub const __need_size_t = "";
+pub const __need_NULL = "";
+pub const _SIZE_T = "";
+pub const NULL = @import("std").zig.c_translation.cast(?*anyopaque, @as(c_int, 0));
+pub const __need___va_list = "";
+pub const _BITS_TYPES_H = @as(c_int, 1);
+pub const __S16_TYPE = c_short;
+pub const __U16_TYPE = c_ushort;
+pub const __S32_TYPE = c_int;
+pub const __U32_TYPE = c_uint;
+pub const __SLONGWORD_TYPE = c_long;
+pub const __ULONGWORD_TYPE = c_ulong;
+pub const __SQUAD_TYPE = c_long;
+pub const __UQUAD_TYPE = c_ulong;
+pub const __SWORD_TYPE = c_long;
+pub const __UWORD_TYPE = c_ulong;
+pub const __SLONG32_TYPE = c_int;
+pub const __ULONG32_TYPE = c_uint;
+pub const __S64_TYPE = c_long;
+pub const __U64_TYPE = c_ulong;
+pub const _BITS_TYPESIZES_H = @as(c_int, 1);
+pub const __SYSCALL_SLONG_TYPE = __SLONGWORD_TYPE;
+pub const __SYSCALL_ULONG_TYPE = __ULONGWORD_TYPE;
+pub const __DEV_T_TYPE = __UQUAD_TYPE;
+pub const __UID_T_TYPE = __U32_TYPE;
+pub const __GID_T_TYPE = __U32_TYPE;
+pub const __INO_T_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __INO64_T_TYPE = __UQUAD_TYPE;
+pub const __MODE_T_TYPE = __U32_TYPE;
+pub const __NLINK_T_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __FSWORD_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __OFF_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __OFF64_T_TYPE = __SQUAD_TYPE;
+pub const __PID_T_TYPE = __S32_TYPE;
+pub const __RLIM_T_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __RLIM64_T_TYPE = __UQUAD_TYPE;
+pub const __BLKCNT_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __BLKCNT64_T_TYPE = __SQUAD_TYPE;
+pub const __FSBLKCNT_T_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __FSBLKCNT64_T_TYPE = __UQUAD_TYPE;
+pub const __FSFILCNT_T_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __FSFILCNT64_T_TYPE = __UQUAD_TYPE;
+pub const __ID_T_TYPE = __U32_TYPE;
+pub const __CLOCK_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __TIME_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __USECONDS_T_TYPE = __U32_TYPE;
+pub const __SUSECONDS_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __SUSECONDS64_T_TYPE = __SQUAD_TYPE;
+pub const __DADDR_T_TYPE = __S32_TYPE;
+pub const __KEY_T_TYPE = __S32_TYPE;
+pub const __CLOCKID_T_TYPE = __S32_TYPE;
+pub const __TIMER_T_TYPE = ?*anyopaque;
+pub const __BLKSIZE_T_TYPE = __SYSCALL_SLONG_TYPE;
+pub const __SSIZE_T_TYPE = __SWORD_TYPE;
+pub const __CPU_MASK_TYPE = __SYSCALL_ULONG_TYPE;
+pub const __OFF_T_MATCHES_OFF64_T = @as(c_int, 1);
+pub const __INO_T_MATCHES_INO64_T = @as(c_int, 1);
+pub const __RLIM_T_MATCHES_RLIM64_T = @as(c_int, 1);
+pub const __STATFS_MATCHES_STATFS64 = @as(c_int, 1);
+pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = @as(c_int, 1);
+pub const __FD_SETSIZE = @as(c_int, 1024);
+pub const _BITS_TIME64_H = @as(c_int, 1);
+pub const __TIME64_T_TYPE = __TIME_T_TYPE;
+pub const _____fpos_t_defined = @as(c_int, 1);
+pub const ____mbstate_t_defined = @as(c_int, 1);
+pub const _____fpos64_t_defined = @as(c_int, 1);
+pub const ____FILE_defined = @as(c_int, 1);
+pub const __FILE_defined = @as(c_int, 1);
+pub const __struct_FILE_defined = @as(c_int, 1);
+pub const _IO_EOF_SEEN = @as(c_int, 0x0010);
+pub inline fn __feof_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0)) {
+ return (_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0);
+}
+pub const _IO_ERR_SEEN = @as(c_int, 0x0020);
+pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0)) {
+ return (_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0);
+}
+pub const _IO_USER_LOCK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal);
+pub const _VA_LIST_DEFINED = "";
+pub const __off_t_defined = "";
+pub const __ssize_t_defined = "";
+pub const _IOFBF = @as(c_int, 0);
+pub const _IOLBF = @as(c_int, 1);
+pub const _IONBF = @as(c_int, 2);
+pub const BUFSIZ = @as(c_int, 8192);
+pub const EOF = -@as(c_int, 1);
+pub const SEEK_SET = @as(c_int, 0);
+pub const SEEK_CUR = @as(c_int, 1);
+pub const SEEK_END = @as(c_int, 2);
+pub const P_tmpdir = "/tmp";
+pub const _BITS_STDIO_LIM_H = @as(c_int, 1);
+pub const L_tmpnam = @as(c_int, 20);
+pub const TMP_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 238328, .decimal);
+pub const FILENAME_MAX = @as(c_int, 4096);
+pub const L_ctermid = @as(c_int, 9);
+pub const FOPEN_MAX = @as(c_int, 16);
+pub const __attr_dealloc_fclose = __attr_dealloc(fclose, @as(c_int, 1));
+pub const _BITS_FLOATN_H = "";
+pub const __HAVE_FLOAT128 = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT128 = @as(c_int, 0);
+pub const __HAVE_FLOAT64X = @as(c_int, 1);
+pub const __HAVE_FLOAT64X_LONG_DOUBLE = @as(c_int, 1);
+pub const _BITS_FLOATN_COMMON_H = "";
+pub const __HAVE_FLOAT16 = @as(c_int, 0);
+pub const __HAVE_FLOAT32 = @as(c_int, 1);
+pub const __HAVE_FLOAT64 = @as(c_int, 1);
+pub const __HAVE_FLOAT32X = @as(c_int, 1);
+pub const __HAVE_FLOAT128X = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT16 = __HAVE_FLOAT16;
+pub const __HAVE_DISTINCT_FLOAT32 = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT64 = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT32X = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT64X = @as(c_int, 0);
+pub const __HAVE_DISTINCT_FLOAT128X = __HAVE_FLOAT128X;
+pub const __HAVE_FLOAT128_UNLIKE_LDBL = (__HAVE_DISTINCT_FLOAT128 != 0) and (__LDBL_MANT_DIG__ != @as(c_int, 113));
+pub const __HAVE_FLOATN_NOT_TYPEDEF = @as(c_int, 0);
+pub inline fn __f64(x: anytype) @TypeOf(x) {
+ return x;
+}
+pub inline fn __f32x(x: anytype) @TypeOf(x) {
+ return x;
+}
+pub inline fn __builtin_huge_valf32() @TypeOf(__builtin_huge_valf()) {
+ return __builtin_huge_valf();
+}
+pub inline fn __builtin_inff32() @TypeOf(__builtin_inff()) {
+ return __builtin_inff();
+}
+pub inline fn __builtin_nanf32(x: anytype) @TypeOf(__builtin_nanf(x)) {
+ return __builtin_nanf(x);
+}
+pub const _BITS_STDIO_H = @as(c_int, 1);
+pub const __STDIO_INLINE = __extern_inline;
+pub const __need_wchar_t = "";
+pub const _WCHAR_T = "";
+pub const _STDLIB_H = @as(c_int, 1);
+pub const WNOHANG = @as(c_int, 1);
+pub const WUNTRACED = @as(c_int, 2);
+pub const WSTOPPED = @as(c_int, 2);
+pub const WEXITED = @as(c_int, 4);
+pub const WCONTINUED = @as(c_int, 8);
+pub const WNOWAIT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x01000000, .hexadecimal);
+pub const __WNOTHREAD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hexadecimal);
+pub const __WALL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hexadecimal);
+pub const __WCLONE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal);
+pub inline fn __WEXITSTATUS(status: anytype) @TypeOf((status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hexadecimal)) >> @as(c_int, 8)) {
+ return (status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hexadecimal)) >> @as(c_int, 8);
+}
+pub inline fn __WTERMSIG(status: anytype) @TypeOf(status & @as(c_int, 0x7f)) {
+ return status & @as(c_int, 0x7f);
+}
+pub inline fn __WSTOPSIG(status: anytype) @TypeOf(__WEXITSTATUS(status)) {
+ return __WEXITSTATUS(status);
+}
+pub inline fn __WIFEXITED(status: anytype) @TypeOf(__WTERMSIG(status) == @as(c_int, 0)) {
+ return __WTERMSIG(status) == @as(c_int, 0);
+}
+pub inline fn __WIFSIGNALED(status: anytype) @TypeOf((@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0)) {
+ return (@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0);
+}
+pub inline fn __WIFSTOPPED(status: anytype) @TypeOf((status & @as(c_int, 0xff)) == @as(c_int, 0x7f)) {
+ return (status & @as(c_int, 0xff)) == @as(c_int, 0x7f);
+}
+pub inline fn __WIFCONTINUED(status: anytype) @TypeOf(status == __W_CONTINUED) {
+ return status == __W_CONTINUED;
+}
+pub inline fn __WCOREDUMP(status: anytype) @TypeOf(status & __WCOREFLAG) {
+ return status & __WCOREFLAG;
+}
+pub inline fn __W_EXITCODE(ret: anytype, sig: anytype) @TypeOf((ret << @as(c_int, 8)) | sig) {
+ return (ret << @as(c_int, 8)) | sig;
+}
+pub inline fn __W_STOPCODE(sig: anytype) @TypeOf((sig << @as(c_int, 8)) | @as(c_int, 0x7f)) {
+ return (sig << @as(c_int, 8)) | @as(c_int, 0x7f);
+}
+pub const __W_CONTINUED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hexadecimal);
+pub const __WCOREFLAG = @as(c_int, 0x80);
+pub inline fn WEXITSTATUS(status: anytype) @TypeOf(__WEXITSTATUS(status)) {
+ return __WEXITSTATUS(status);
+}
+pub inline fn WTERMSIG(status: anytype) @TypeOf(__WTERMSIG(status)) {
+ return __WTERMSIG(status);
+}
+pub inline fn WSTOPSIG(status: anytype) @TypeOf(__WSTOPSIG(status)) {
+ return __WSTOPSIG(status);
+}
+pub inline fn WIFEXITED(status: anytype) @TypeOf(__WIFEXITED(status)) {
+ return __WIFEXITED(status);
+}
+pub inline fn WIFSIGNALED(status: anytype) @TypeOf(__WIFSIGNALED(status)) {
+ return __WIFSIGNALED(status);
+}
+pub inline fn WIFSTOPPED(status: anytype) @TypeOf(__WIFSTOPPED(status)) {
+ return __WIFSTOPPED(status);
+}
+pub inline fn WIFCONTINUED(status: anytype) @TypeOf(__WIFCONTINUED(status)) {
+ return __WIFCONTINUED(status);
+}
+pub const __ldiv_t_defined = @as(c_int, 1);
+pub const __lldiv_t_defined = @as(c_int, 1);
+pub const RAND_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
+pub const EXIT_FAILURE = @as(c_int, 1);
+pub const EXIT_SUCCESS = @as(c_int, 0);
+pub const MB_CUR_MAX = __ctype_get_mb_cur_max();
+pub const _SYS_TYPES_H = @as(c_int, 1);
+pub const __u_char_defined = "";
+pub const __ino_t_defined = "";
+pub const __dev_t_defined = "";
+pub const __gid_t_defined = "";
+pub const __mode_t_defined = "";
+pub const __nlink_t_defined = "";
+pub const __uid_t_defined = "";
+pub const __pid_t_defined = "";
+pub const __id_t_defined = "";
+pub const __daddr_t_defined = "";
+pub const __key_t_defined = "";
+pub const __clock_t_defined = @as(c_int, 1);
+pub const __clockid_t_defined = @as(c_int, 1);
+pub const __time_t_defined = @as(c_int, 1);
+pub const __timer_t_defined = @as(c_int, 1);
+pub const _BITS_STDINT_INTN_H = @as(c_int, 1);
+pub const __BIT_TYPES_DEFINED__ = @as(c_int, 1);
+pub const _ENDIAN_H = @as(c_int, 1);
+pub const _BITS_ENDIAN_H = @as(c_int, 1);
+pub const __LITTLE_ENDIAN = @as(c_int, 1234);
+pub const __BIG_ENDIAN = @as(c_int, 4321);
+pub const __PDP_ENDIAN = @as(c_int, 3412);
+pub const _BITS_ENDIANNESS_H = @as(c_int, 1);
+pub const __BYTE_ORDER = __LITTLE_ENDIAN;
+pub const __FLOAT_WORD_ORDER = __BYTE_ORDER;
+pub inline fn __LONG_LONG_PAIR(HI: anytype, LO: anytype) @TypeOf(HI) {
+ return blk: {
+ _ = LO;
+ break :blk HI;
+ };
+}
+pub const LITTLE_ENDIAN = __LITTLE_ENDIAN;
+pub const BIG_ENDIAN = __BIG_ENDIAN;
+pub const PDP_ENDIAN = __PDP_ENDIAN;
+pub const BYTE_ORDER = __BYTE_ORDER;
+pub const _BITS_BYTESWAP_H = @as(c_int, 1);
+pub inline fn __bswap_constant_16(x: anytype) __uint16_t {
+ return @import("std").zig.c_translation.cast(__uint16_t, ((x >> @as(c_int, 8)) & @as(c_int, 0xff)) | ((x & @as(c_int, 0xff)) << @as(c_int, 8)));
+}
+pub inline fn __bswap_constant_32(x: anytype) @TypeOf(((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hexadecimal)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hexadecimal)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24))) {
+ return ((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hexadecimal)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hexadecimal)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24));
+}
+pub inline fn __bswap_constant_64(x: anytype) @TypeOf(((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56))) {
+ return ((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56));
+}
+pub const _BITS_UINTN_IDENTITY_H = @as(c_int, 1);
+pub inline fn htobe16(x: anytype) @TypeOf(__bswap_16(x)) {
+ return __bswap_16(x);
+}
+pub inline fn htole16(x: anytype) @TypeOf(__uint16_identity(x)) {
+ return __uint16_identity(x);
+}
+pub inline fn be16toh(x: anytype) @TypeOf(__bswap_16(x)) {
+ return __bswap_16(x);
+}
+pub inline fn le16toh(x: anytype) @TypeOf(__uint16_identity(x)) {
+ return __uint16_identity(x);
+}
+pub inline fn htobe32(x: anytype) @TypeOf(__bswap_32(x)) {
+ return __bswap_32(x);
+}
+pub inline fn htole32(x: anytype) @TypeOf(__uint32_identity(x)) {
+ return __uint32_identity(x);
+}
+pub inline fn be32toh(x: anytype) @TypeOf(__bswap_32(x)) {
+ return __bswap_32(x);
+}
+pub inline fn le32toh(x: anytype) @TypeOf(__uint32_identity(x)) {
+ return __uint32_identity(x);
+}
+pub inline fn htobe64(x: anytype) @TypeOf(__bswap_64(x)) {
+ return __bswap_64(x);
+}
+pub inline fn htole64(x: anytype) @TypeOf(__uint64_identity(x)) {
+ return __uint64_identity(x);
+}
+pub inline fn be64toh(x: anytype) @TypeOf(__bswap_64(x)) {
+ return __bswap_64(x);
+}
+pub inline fn le64toh(x: anytype) @TypeOf(__uint64_identity(x)) {
+ return __uint64_identity(x);
+}
+pub const _SYS_SELECT_H = @as(c_int, 1);
+pub inline fn __FD_ISSET(d: anytype, s: anytype) @TypeOf((__FDS_BITS(s)[__FD_ELT(d)] & __FD_MASK(d)) != @as(c_int, 0)) {
+ return (__FDS_BITS(s)[__FD_ELT(d)] & __FD_MASK(d)) != @as(c_int, 0);
+}
+pub const __sigset_t_defined = @as(c_int, 1);
+pub const ____sigset_t_defined = "";
+pub const _SIGSET_NWORDS = @as(c_int, 1024) / (@as(c_int, 8) * @import("std").zig.c_translation.sizeof(c_ulong));
+pub const __timeval_defined = @as(c_int, 1);
+pub const _STRUCT_TIMESPEC = @as(c_int, 1);
+pub const __suseconds_t_defined = "";
+pub const __NFDBITS = @as(c_int, 8) * @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.sizeof(__fd_mask));
+pub inline fn __FD_ELT(d: anytype) @TypeOf(d / __NFDBITS) {
+ return d / __NFDBITS;
+}
+pub inline fn __FD_MASK(d: anytype) __fd_mask {
+ return @import("std").zig.c_translation.cast(__fd_mask, @as(c_ulong, 1) << (d % __NFDBITS));
+}
+pub inline fn __FDS_BITS(set: anytype) @TypeOf(set.*.__fds_bits) {
+ return set.*.__fds_bits;
+}
+pub const FD_SETSIZE = __FD_SETSIZE;
+pub const NFDBITS = __NFDBITS;
+pub inline fn FD_SET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_SET(fd, fdsetp)) {
+ return __FD_SET(fd, fdsetp);
+}
+pub inline fn FD_CLR(fd: anytype, fdsetp: anytype) @TypeOf(__FD_CLR(fd, fdsetp)) {
+ return __FD_CLR(fd, fdsetp);
+}
+pub inline fn FD_ISSET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_ISSET(fd, fdsetp)) {
+ return __FD_ISSET(fd, fdsetp);
+}
+pub inline fn FD_ZERO(fdsetp: anytype) @TypeOf(__FD_ZERO(fdsetp)) {
+ return __FD_ZERO(fdsetp);
+}
+pub const __blksize_t_defined = "";
+pub const __blkcnt_t_defined = "";
+pub const __fsblkcnt_t_defined = "";
+pub const __fsfilcnt_t_defined = "";
+pub const _BITS_PTHREADTYPES_COMMON_H = @as(c_int, 1);
+pub const _THREAD_SHARED_TYPES_H = @as(c_int, 1);
+pub const _BITS_PTHREADTYPES_ARCH_H = @as(c_int, 1);
+pub const __SIZEOF_PTHREAD_MUTEX_T = @as(c_int, 40);
+pub const __SIZEOF_PTHREAD_ATTR_T = @as(c_int, 56);
+pub const __SIZEOF_PTHREAD_RWLOCK_T = @as(c_int, 56);
+pub const __SIZEOF_PTHREAD_BARRIER_T = @as(c_int, 32);
+pub const __SIZEOF_PTHREAD_MUTEXATTR_T = @as(c_int, 4);
+pub const __SIZEOF_PTHREAD_COND_T = @as(c_int, 48);
+pub const __SIZEOF_PTHREAD_CONDATTR_T = @as(c_int, 4);
+pub const __SIZEOF_PTHREAD_RWLOCKATTR_T = @as(c_int, 8);
+pub const __SIZEOF_PTHREAD_BARRIERATTR_T = @as(c_int, 4);
+pub const __LOCK_ALIGNMENT = "";
+pub const __ONCE_ALIGNMENT = "";
+pub const _THREAD_MUTEX_INTERNAL_H = @as(c_int, 1);
+pub const __PTHREAD_MUTEX_HAVE_PREV = @as(c_int, 1);
+pub const _RWLOCK_INTERNAL_H = "";
+pub inline fn __PTHREAD_RWLOCK_INITIALIZER(__flags: anytype) @TypeOf(__flags) {
+ return blk: {
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = @as(c_int, 0);
+ _ = __PTHREAD_RWLOCK_ELISION_EXTRA;
+ _ = @as(c_int, 0);
+ break :blk __flags;
+ };
+}
+pub const __have_pthread_attr_t = @as(c_int, 1);
+pub const _ALLOCA_H = @as(c_int, 1);
+pub const __COMPAR_FN_T = "";
+pub const _STRING_H = @as(c_int, 1);
+pub const _BITS_TYPES_LOCALE_T_H = @as(c_int, 1);
+pub const _BITS_TYPES___LOCALE_T_H = @as(c_int, 1);
+pub const _STRINGS_H = @as(c_int, 1);
+pub const _MATH_H = @as(c_int, 1);
+pub const _BITS_LIBM_SIMD_DECL_STUBS_H = @as(c_int, 1);
+pub const __DECL_SIMD_cos = "";
+pub const __DECL_SIMD_cosf = "";
+pub const __DECL_SIMD_cosl = "";
+pub const __DECL_SIMD_cosf16 = "";
+pub const __DECL_SIMD_cosf32 = "";
+pub const __DECL_SIMD_cosf64 = "";
+pub const __DECL_SIMD_cosf128 = "";
+pub const __DECL_SIMD_cosf32x = "";
+pub const __DECL_SIMD_cosf64x = "";
+pub const __DECL_SIMD_cosf128x = "";
+pub const __DECL_SIMD_sin = "";
+pub const __DECL_SIMD_sinf = "";
+pub const __DECL_SIMD_sinl = "";
+pub const __DECL_SIMD_sinf16 = "";
+pub const __DECL_SIMD_sinf32 = "";
+pub const __DECL_SIMD_sinf64 = "";
+pub const __DECL_SIMD_sinf128 = "";
+pub const __DECL_SIMD_sinf32x = "";
+pub const __DECL_SIMD_sinf64x = "";
+pub const __DECL_SIMD_sinf128x = "";
+pub const __DECL_SIMD_sincos = "";
+pub const __DECL_SIMD_sincosf = "";
+pub const __DECL_SIMD_sincosl = "";
+pub const __DECL_SIMD_sincosf16 = "";
+pub const __DECL_SIMD_sincosf32 = "";
+pub const __DECL_SIMD_sincosf64 = "";
+pub const __DECL_SIMD_sincosf128 = "";
+pub const __DECL_SIMD_sincosf32x = "";
+pub const __DECL_SIMD_sincosf64x = "";
+pub const __DECL_SIMD_sincosf128x = "";
+pub const __DECL_SIMD_log = "";
+pub const __DECL_SIMD_logf = "";
+pub const __DECL_SIMD_logl = "";
+pub const __DECL_SIMD_logf16 = "";
+pub const __DECL_SIMD_logf32 = "";
+pub const __DECL_SIMD_logf64 = "";
+pub const __DECL_SIMD_logf128 = "";
+pub const __DECL_SIMD_logf32x = "";
+pub const __DECL_SIMD_logf64x = "";
+pub const __DECL_SIMD_logf128x = "";
+pub const __DECL_SIMD_exp = "";
+pub const __DECL_SIMD_expf = "";
+pub const __DECL_SIMD_expl = "";
+pub const __DECL_SIMD_expf16 = "";
+pub const __DECL_SIMD_expf32 = "";
+pub const __DECL_SIMD_expf64 = "";
+pub const __DECL_SIMD_expf128 = "";
+pub const __DECL_SIMD_expf32x = "";
+pub const __DECL_SIMD_expf64x = "";
+pub const __DECL_SIMD_expf128x = "";
+pub const __DECL_SIMD_pow = "";
+pub const __DECL_SIMD_powf = "";
+pub const __DECL_SIMD_powl = "";
+pub const __DECL_SIMD_powf16 = "";
+pub const __DECL_SIMD_powf32 = "";
+pub const __DECL_SIMD_powf64 = "";
+pub const __DECL_SIMD_powf128 = "";
+pub const __DECL_SIMD_powf32x = "";
+pub const __DECL_SIMD_powf64x = "";
+pub const __DECL_SIMD_powf128x = "";
+pub const HUGE_VALF = __builtin_huge_valf();
+pub const INFINITY = __builtin_inff();
+pub const NAN = __builtin_nanf("");
+pub const __GLIBC_FLT_EVAL_METHOD = __FLT_EVAL_METHOD__;
+pub const __FP_LOGB0_IS_MIN = @as(c_int, 1);
+pub const __FP_LOGBNAN_IS_MIN = @as(c_int, 1);
+pub const FP_ILOGB0 = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1);
+pub const FP_ILOGBNAN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1);
+pub inline fn __MATHCALL(function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL(_Mdouble_, function, suffix, args)) {
+ return __MATHDECL(_Mdouble_, function, suffix, args);
+}
+pub inline fn __MATHCALLX(function: anytype, suffix: anytype, args: anytype, attrib: anytype) @TypeOf(__MATHDECLX(_Mdouble_, function, suffix, args, attrib)) {
+ return __MATHDECLX(_Mdouble_, function, suffix, args, attrib);
+}
+pub inline fn __MATHDECL_1(@"type": anytype, function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL_1_IMPL(@"type", function, suffix, args)) {
+ return __MATHDECL_1_IMPL(@"type", function, suffix, args);
+}
+pub inline fn __MATHDECL_ALIAS(@"type": anytype, function: anytype, suffix: anytype, args: anytype, alias: anytype) @TypeOf(__MATHDECL_1(@"type", function, suffix, args)) {
+ _ = alias;
+ return __MATHDECL_1(@"type", function, suffix, args);
+}
+pub const _Mdouble_ = f64;
+pub inline fn __MATH_PRECNAME(name: anytype, r: anytype) @TypeOf(__CONCAT(name, r)) {
+ return __CONCAT(name, r);
+}
+pub const __MATH_DECLARING_DOUBLE = @as(c_int, 1);
+pub const __MATH_DECLARING_FLOATN = @as(c_int, 0);
+pub const __MATH_DECLARE_LDOUBLE = @as(c_int, 1);
+pub inline fn __MATHCALL_NARROW(func: anytype, redir: anytype, nargs: anytype) @TypeOf(__MATHCALL_NARROW_NORMAL(func, nargs)) {
+ _ = redir;
+ return __MATHCALL_NARROW_NORMAL(func, nargs);
+}
+pub inline fn signbit(x: anytype) @TypeOf(__builtin_signbit(x)) {
+ return __builtin_signbit(x);
+}
+pub const MATH_ERRNO = @as(c_int, 1);
+pub const MATH_ERREXCEPT = @as(c_int, 2);
+pub const math_errhandling = MATH_ERRNO | MATH_ERREXCEPT;
+pub const M_E = 2.7182818284590452354;
+pub const M_LOG2E = 1.4426950408889634074;
+pub const M_LOG10E = 0.43429448190325182765;
+pub const M_LN2 = 0.69314718055994530942;
+pub const M_LN10 = 2.30258509299404568402;
+pub const M_PI = 3.14159265358979323846;
+pub const M_PI_2 = 1.57079632679489661923;
+pub const M_PI_4 = 0.78539816339744830962;
+pub const M_1_PI = 0.31830988618379067154;
+pub const M_2_PI = 0.63661977236758134308;
+pub const M_2_SQRTPI = 1.12837916709551257390;
+pub const M_SQRT2 = 1.41421356237309504880;
+pub const M_SQRT1_2 = 0.70710678118654752440;
+pub inline fn RAYGUI_CLITERAL(name: anytype) @TypeOf(name) {
+ return name;
+}
+pub const RICON_SIZE = @as(c_int, 16);
+pub const RICON_MAX_ICONS = @as(c_int, 256);
+pub const RICON_MAX_NAME_LENGTH = @as(c_int, 32);
+pub const RICON_DATA_ELEMENTS = (RICON_SIZE * RICON_SIZE) / @as(c_int, 32);
+pub const RAYGUI_MAX_CONTROLS = @as(c_int, 16);
+pub const RAYGUI_MAX_PROPS_BASE = @as(c_int, 16);
+pub const RAYGUI_MAX_PROPS_EXTENDED = @as(c_int, 8);
+pub const WINDOW_STATUSBAR_HEIGHT = @as(c_int, 22);
+pub const GROUPBOX_LINE_THICK = @as(c_int, 1);
+pub const GROUPBOX_TEXT_PADDING = @as(c_int, 10);
+pub const LINE_TEXT_PADDING = @as(c_int, 10);
+pub const PANEL_BORDER_WIDTH = @as(c_int, 1);
+pub const TOGGLEGROUP_MAX_ELEMENTS = @as(c_int, 32);
+pub const VALUEBOX_MAX_CHARS = @as(c_int, 32);
+pub const COLORBARALPHA_CHECKED_SIZE = @as(c_int, 10);
+pub const MESSAGEBOX_BUTTON_HEIGHT = @as(c_int, 24);
+pub const MESSAGEBOX_BUTTON_PADDING = @as(c_int, 10);
+pub const TEXTINPUTBOX_BUTTON_HEIGHT = @as(c_int, 24);
+pub const TEXTINPUTBOX_BUTTON_PADDING = @as(c_int, 10);
+pub const TEXTINPUTBOX_HEIGHT = @as(c_int, 30);
+pub const TEXTINPUTBOX_MAX_TEXT_LENGTH = @as(c_int, 256);
+pub const GRID_COLOR_ALPHA = @as(f32, 0.15);
+pub inline fn BIT_CHECK(a: anytype, b: anytype) @TypeOf(a & (@as(c_int, 1) << b)) {
+ return a & (@as(c_int, 1) << b);
+}
+pub inline fn TEXT_VALIGN_PIXEL_OFFSET(h: anytype) @TypeOf(@import("std").zig.c_translation.cast(c_int, h) % @as(c_int, 2)) {
+ return @import("std").zig.c_translation.cast(c_int, h) % @as(c_int, 2);
+}
+pub const RICON_TEXT_PADDING = @as(c_int, 4);
+pub const TEXTSPLIT_MAX_TEXT_LENGTH = @as(c_int, 1024);
+pub const TEXTSPLIT_MAX_TEXT_ELEMENTS = @as(c_int, 128);
+pub const __va_list_tag = struct___va_list_tag;
+pub const _IO_marker = struct__IO_marker;
+pub const _IO_codecvt = struct__IO_codecvt;
+pub const _IO_wide_data = struct__IO_wide_data;
+pub const _IO_FILE = struct__IO_FILE;
+pub const _G_fpos_t = struct__G_fpos_t;
+pub const _G_fpos64_t = struct__G_fpos64_t;
+pub const timeval = struct_timeval;
+pub const timespec = struct_timespec;
+pub const __pthread_internal_list = struct___pthread_internal_list;
+pub const __pthread_internal_slist = struct___pthread_internal_slist;
+pub const __pthread_mutex_s = struct___pthread_mutex_s;
+pub const __pthread_rwlock_arch_t = struct___pthread_rwlock_arch_t;
+pub const __pthread_cond_s = struct___pthread_cond_s;
+pub const random_data = struct_random_data;
+pub const drand48_data = struct_drand48_data;
+pub const __locale_data = struct___locale_data;
+pub const __locale_struct = struct___locale_struct;
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-14 12:14:18 +0000