diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml
index 4547bd60e..dbbe050d2 100644
--- a/.github/workflows/android.yml
+++ b/.github/workflows/android.yml
@@ -67,7 +67,7 @@ jobs:
cp -v ./src/raylib.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/raymath.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/rlgl.h ./build/${{ env.RELEASE_NAME }}/include
- cp -v ./src/extras/raygui.h ./build/${{ env.RELEASE_NAME }}/include
+ cp -v ./CHANGELOG ./build/${{ env.RELEASE_NAME }}/CHANGELOG
cp -v ./README.md ./build/${{ env.RELEASE_NAME }}/README.md
cp -v ./LICENSE ./build/${{ env.RELEASE_NAME }}/LICENSE
cd build
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index c7448241c..59cbfe334 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -87,7 +87,7 @@ jobs:
cp -v ./src/raylib.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/raymath.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/rlgl.h ./build/${{ env.RELEASE_NAME }}/include
- cp -v ./src/extras/raygui.h ./build/${{ env.RELEASE_NAME }}/include
+ cp -v ./CHANGELOG ./build/${{ env.RELEASE_NAME }}/CHANGELOG
cp -v ./README.md ./build/${{ env.RELEASE_NAME }}/README.md
cp -v ./LICENSE ./build/${{ env.RELEASE_NAME }}/LICENSE
cd build
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 53588dffc..e971a8101 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -72,7 +72,7 @@ jobs:
cp -v ./src/raylib.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/raymath.h ./build/${{ env.RELEASE_NAME }}/include
cp -v ./src/rlgl.h ./build/${{ env.RELEASE_NAME }}/include
- cp -v ./src/extras/raygui.h ./build/${{ env.RELEASE_NAME }}/include
+ cp -v ./CHANGELOG ./build/${{ env.RELEASE_NAME }}/CHANGELOG
cp -v ./README.md ./build/${{ env.RELEASE_NAME }}/README.md
cp -v ./LICENSE ./build/${{ env.RELEASE_NAME }}/LICENSE
cd build
diff --git a/.github/workflows/webassembly.yml b/.github/workflows/webassembly.yml
index 9b15c34e9..b5d2ba6ca 100644
--- a/.github/workflows/webassembly.yml
+++ b/.github/workflows/webassembly.yml
@@ -60,7 +60,7 @@ jobs:
copy /Y .\src\raylib.h .\build\${{ env.RELEASE_NAME }}\include\raylib.h
copy /Y .\src\raymath.h .\build\${{ env.RELEASE_NAME }}\include\raymath.h
copy /Y .\src\rlgl.h .\build\${{ env.RELEASE_NAME }}\include\rlgl.h
- copy /Y .\src\extras\raygui.h .\build\${{ env.RELEASE_NAME }}\include\raygui.h
+ copy /Y .\CHANGELOG .\build/${{ env.RELEASE_NAME }}\CHANGELOG
copy /Y .\README.md .\build\${{ env.RELEASE_NAME }}\README.md
copy /Y .\LICENSE .\build\${{ env.RELEASE_NAME }}\LICENSE
cd build
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 4d6357cc5..d7d59b6aa 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -109,7 +109,7 @@ jobs:
copy /Y .\src\raylib.h .\build\${{ env.RELEASE_NAME }}\include\raylib.h
copy /Y .\src\raymath.h .\build\${{ env.RELEASE_NAME }}\include\raymath.h
copy /Y .\src\rlgl.h .\build\${{ env.RELEASE_NAME }}\include\rlgl.h
- copy /Y .\src\extras\raygui.h .\build\${{ env.RELEASE_NAME }}\include\raygui.h
+ copy /Y .\CHANGELOG .\build\${{ env.RELEASE_NAME }}\CHANGELOG
copy /Y .\README.md .\build\${{ env.RELEASE_NAME }}\README.md
copy /Y .\LICENSE .\build\${{ env.RELEASE_NAME }}\LICENSE
cd build
diff --git a/BINDINGS.md b/BINDINGS.md
index e2d916519..320e0a9d6 100644
--- a/BINDINGS.md
+++ b/BINDINGS.md
@@ -44,7 +44,7 @@ Some people ported raylib to other languages in form of bindings or wrappers to
| Relib | 3.5 | [ReCT](https://github.com/RedCubeDev-ByteSpace/ReCT) | ? | https://github.com/RedCubeDev-ByteSpace/Relib |
| rayex | 3.7 | [elixir](https://elixir-lang.org/) | Apache-2.0 | https://github.com/shiryel/rayex |
| kaylib | 3.7 | [Kotlin/native](https://kotlinlang.org) | ? | https://github.com/electronstudio/kaylib |
-| dlang_raylib | 3.7 | [D](https://dlang.org) | ? |https://github.com/rc-05/dlang_raylib |
+| dlang_raylib | **4.0** | [D](https://dlang.org) | MPL-2.0 |https://github.com/rc-05/dlang_raylib |
| raylib-freebasic | **4.0** | [FreeBASIC](https://www.freebasic.net/) | MIT | https://github.com/WIITD/raylib-freebasic |
| raylib-cr | **4.0** | [Crystal](https://crystal-lang.org/) | Apache-2.0 | https://github.com/sol-vin/raylib-cr |
| dart-raylib | **4.0** | [Dart](https://dart.dev/) | MIT | https://gitlab.com/wolfenrain/dart-raylib |
@@ -53,6 +53,7 @@ Some people ported raylib to other languages in form of bindings or wrappers to
| raylib-zig | **4.0** | [Zig](https://ziglang.org/) | MIT | https://github.com/Not-Nik/raylib-zig |
| raylib.zig | **4.1-dev** | [Zig](https://ziglang.org/) | MIT | https://github.com/ryupold/raylib.zig |
| racket-raylib | **4.0** | [Racket](https://racket-lang.org/) | MIT/Apache-2.0 | https://github.com/eutro/racket-raylib |
+| cl-raylib | **4.0** | [Common Lisp](https://common-lisp.net/) | MIT | https://github.com/longlene/cl-raylib |
### Utility Wrapers
These are utility wrappers for specific languages, they are not required to use raylib in the language but may adapt the raylib API to be more inline with the language's pardigm.
@@ -103,7 +104,6 @@ These are older raylib bindings that are more than 2 versions old or have not be
| raylib-php-ffi | 2.4-dev | [PHP](https://en.wikipedia.org/wiki/PHP) | https://github.com/oraoto/raylib-php-ffi |
| raylib-haxe | 2.4 | [Haxe](https://haxe.org/) | https://github.com/ibilon/raylib-haxe |
| ringraylib | 2.6 | [Ring](http://ring-lang.sourceforge.net/) | https://github.com/ringpackages/ringraylib |
-| cl-raylib | 3.0 | [Common Lisp](https://common-lisp.net/) | https://github.com/longlene/cl-raylib |
| raylib-scm | 2.5 | [Chicken Scheme](https://www.call-cc.org/) | https://github.com/yashrk/raylib-scm |
| raylib-chibi | 2.5 | [Chibi-Scheme](https://github.com/ashinn/chibi-scheme) | https://github.com/VincentToups/raylib-chibi |
| raylib-gambit-scheme | 3.1-dev | [Gambit Scheme](https://github.com/gambit/gambit) | https://github.com/georgjz/raylib-gambit-scheme |
diff --git a/CHANGELOG b/CHANGELOG
index dd54f2d6d..27d6f155d 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -3,11 +3,180 @@ changelog
Current Release: raylib 4.0.0 (05 November 2021)
+-------------------------------------------------------------------------
+Release: raylib 4.2 (June 2022)
+-------------------------------------------------------------------------
+KEY CHANGES:
+ - ...
+ - rres 1.0
+ - raygui 3.2
+ - raylib_parser...
+
+Detailed changes:
+[multi] REVIEWED: Multiple trace log messages
+[multi] REVIEWED: Avoid some float to double promotions
+[multi] REVIEWED: Some functions input parametes that should be const
+[multi] REVIEWED: Variables initialization, all variables are initialized on declaration
+[multi] REVIEWED: Static array buffers are always re-initialized with memset()
+[multi] `WARNING`: RENAMED: Some function input parameters from "length" to "size"
+[core] ADDED: GetApplicatonDirectory() (#2256, #2285, #2290) by @JeffM2501
+[core] ADDED: raylibVersion symbol, it could be required by some bindings (#2190)
+[core] ADDED: SetWindowOpacity() (#2254) by @tusharsingh09
+[core] ADDED: GetRenderWidth() and GetRenderHeight() by @ArnaudValensi
+[core] ADDED: EnableEventWaiting() and DisableEventWaiting()
+[core] ADDED: GetFileLength()
+[core] ADDED: Modules info at initialization
+[core] ADDED: Support clipboard copy/paste on web
+[core] ADDED: Support OpenURL() on Android platform (#2396) by @futureapricot
+[core] `WARNING`: RENAMED: GetDirectoryFiles() to LoadDirectoryFiles()
+[core] `WARNING`: RENAMED: `ClearDroppedFiles()` to `UnloadDroppedFiles()`
+[core] `WARNING`: RENAMED: GetDroppedFiles() to LoadDroppedFiles()
+[core] `WARNING`: RENAMED: `ClearDirectoryFiles()` to `UnloadDirectoryFiles()`
+[core] `WARNING`: REDESIGNED: WaitTime() argument from milliseconds to seconds (#2506) by @flashback-fx
+[core] REVIEWED: GetDirectoryFiles(), maximum files allocation (#2126) by @ampers0x26
+[core] REVIEWED: Expose MAX_KEYBOARD_KEYS and MAX_MOUSE_BUTTONS (#2127)
+[core] REVIEWED: ExportMesh() (#2138)
+[core] REVIEWED: Fullscreen switch on PLATFORM_WEB
+[core] REVIEWED: GetMouseWheelMove(), fixed bug
+[core] REVIEWED: GetApplicationDirectory() on macOS (#2304)
+[core] REVIEWED: ToggleFullscreen()
+[core] REVIEWED: Initialize/reset CORE.inputs global state (#2360)
+[core] REVIEWED: MouseScrollCallback() (#2371)
+[core] REVIEWED: SwapScreenBuffers() for PLATFORM_DRM
+[core] REVIEWED: WaitTime(), fix regression causing video stuttering (#2503) by @flashback-fx
+[core] REVIEWED: Mouse device support on PLATFORM_DRM (#2381)
+[core] REVIEWED: Support OpenBSD timming functions
+[core] REVIEWED: Improved boolean definitions (#2485) by @noodlecollie
+[core] REVIEWED: TakeScreenshot(), use GetWindowScaleDPI() to calculate size in screenshot/recording (#2446) by @gulrak
+[core] REVIEWED: Remove fps requirement for drm connector selection (#2468) by @Crydsch
+[core] REVIEWED: OpenURL()
+[rlgl] ADDED: Premultiplied alpha blend mode (#2342) by @megagrump
+[rlgl] REVIEWED: VR rendering not taking render target size into account (#2424) by @FireFlyForLife
+[rlgl] REVIEWED: Set rlgl internal framebuffer (#2420)
+[rlgl] REVIEWED: rlGetCompressedFormatName()
+[rlgl] REVIEWED: Display OpenGL 4.3 capabilities with a compile flag (#2124) by @GithubPrankster
+[rlgl] REVIEWED: rlUpdateTexture()
+[rlgl] REVIEWED: Minimize buffer overflow probability
+[rlgl] REVIEWED: Fix scissor mode on macOS (#2170) by @ArnaudValensi
+[rlgl] REVIEWED: Clear SSBO buffers on loading (#2185)
+[rlgl] REVIEWED: rlLoadShaderCode(), improved shader loading code
+[rlgl] REVIEWED: Comment notes about custom blend modes (#2260) by @glorantq
+[raymath] ADDED: Vector2Transform()
+[raymath] ADDED: Vector2DistanceSqr() (#2376) by @AnilBK
+[raymath] ADDED: Vector3DistanceSqr() (#2376) by @AnilBK
+[raymath] ADDED: Vector2ClampValue(), Vector3ClampValue() (#2428) by @saccharineboi
+[raymath] `WARNING`: REDESIGNED: Vector2Angle() returns radians instead of degrees (#2193) by @schveiguy
+[raymath] `WARNING`: REMOVED: MatrixNormalize() (#2412)
+[raymath] REVIEWED: Fix inverse length in Vector2Normalize() (#2189) by @HarriP
+[raymath] REVIEWED: Vector2Angle() not working as expected (#2196) by @jdeokkim
+[raymath] REVIEWED: Vector2Angle() and Vector3Angle() (#2203) by @trikko
+[raymath] REVIEWED: QuaternionInvert(), code simplified (#2324) by @megagrump
+[raymath] REVIEWED: QuaternionScale() (#2419) by @tana
+[raymath] REVIEWED: Vector2Rotate(), optimized (#2340) by @jdeokkim
+[shapes] REVIEWED: CheckCollision*() consistency
+[shapes] REVIEWED: DrawRectanglePro(), support TRIANGLES drawing
+[textures] ADDED: Support for QOI image format
+[textures] REVIEWED: ImageColorTint(), GetImageColor(), ImageDrawRectangleRec(), optimized functions (#2429) by @AnilBK
+[textures] REVIEWED: LoadTextureFromImage(), allow texture loading with no data transfer
+[textures] REVIEWED: ImageDraw(), comment to note that f32bit is not supported (#2222)
+[textures] REVIEWED: DrawTextureNPatch(), avoid batch overflow (#2401) by @JeffM2501
+[textures] REVIEWED: DrawTextureTiled() (#2173)
+[textures] REVIEWED: GenImageCellular() (#2178)
+[textures] REVIEWED: LoadTextureCubemap() (#2223, #2224)
+[textures] REVIEWED: Export format for float 32bit
+[textures] REVIEWED: ExportImage(), support export ".jpeg" files
+[text] ADDED: ExportFontAsCode()
+[text] ADDED: DrawTextCodepoints() (#2308) by @siddharthroy12
+[text] REVIEWED: TextIsEqual(), protect from NULLs (#2121) by @lukekras
+[text] REVIEWED: LoadFontEx(), comment to specify how to get the default character set (#2221) by @JeffM2501
+[text] REVIEWED: GenImageFontAtlas(), increase atlas size guesstimate by @megagrump
+[text] REVIEWED: GetCodepoint() (#2201)
+[models] ADDED: Reference code to load bones id and weight data for animations
+[models] `WARNING`: REMOVED: GetRayCollisionModel() (#2405)
+[models] REVIEWED: External library: vox_loader.h, 64bit issue (#2186)
+[models] REVIEWED: Material color loading when no texture material is available (#2298) by @royqh1979
+[models] REVIEWED: Fix Undefined Symbol _ftelli64 in cgltf (#2319) by @audinue
+[models] REVIEWED: LoadGLTF(), fix memory leak (#2441, #2442) by @leomonta
+[models] REVIEWED: DrawTriangle3D() batch limits check (#2489)
+[models] REVIEWED: DrawBillboardPro() (#2494)
+[models] REVIEWED: DrawMesh*() issue (#2211)
+[models] REVIEWED: ExportMesh() (#2220)
+[models] REVIEWED: GenMeshCylinder() (#2225)
+[audio] `WARNING`: ADDED: rAudioProcessor pointer to AudioStream struct (used by Sound and Music structs)
+[audio] ADDED: SetSoundPan(), SetMusicPan(), SetAudioStreamPan(), panning support (#2205) by ptarabbia
+[audio] ADDED: Audio stream input callback (#2212) by ptarabbia
+[audio] ADDED: Audio stream processors support (#2212) by ptarabbia
+[audio] REVIEWED: GetMusicTimePlayed(), incorrect value after the stream restarted for XM audio (#2092 #2215) by @ptarabbia
+[audio] REVIEWED: Turn on interpolation for XM playback (#2216) by @ptarabbia
+[audio] REVIEWED: Fix crash with delay example (#2472) by @ptarabbia
+[audio] REVIEWED: PlaySoundMulti() (#2231)
+[audio] REVIEWED: ExportWaveAsCode()
+[utils] ADDED: ExportDataAsCode()
+[utils] REVIEWED: Force flush stdout after trace messages (#2465) by @nagy
+[easings] ADDED: Function descriptions (#2471) by @RobLoach
+[camera] REVIEWED: Fix free camera panning in the wrong direction (#2347) by @DavidLyhedDanielsson
+[examples] ADDED: shapes_top_down_lights (#2199) by JeffM2501
+[examples] REVIEWED: core_input_gamepad, improve joystick visualisation (#2390) by @kristianlm
+[examples] REVIEWED: textures_draw_tiled
+[examples] REVIEWED: shaders_mesh_instancing, free allocated matrices (#2425) by @AnilBK
+[examples] REVIEWED: shaders_raymarching
+[examples] REVIEWED: audio_raw_stream (#2205) by ptarabbia
+[examples] REVIEWED: audio_music_stream
+[parser] ADDED: Defines to parser (#2269) by @iskolbin
+[parser] ADDED: Aliases to parser (#2444) by @lazaray
+[parser] ADDED: Parse struct descriptions (#2214) by @eutro
+[parser] ADDED: Parse enum descriptions and value descriptions (#2208) by @eutro
+[parser] ADDED: Lua output format for parser by @iskolbin
+[parser] ADDED: Makefile for raylib_parser by @iskolbin
+[parser] ADDED: Support for truncating parser input (#2464) by @lazaray
+[parser] ADDED: Support for calculated defines to parser (#2463) by @lazaray
+[parser] REVIEWED: Update parser files (#2125) by @catmanl
+[parser] REVIEWED: Fix memory leak in parser (#2136) by @ronnieholm
+[parser] REVIEWED: EscapeBackslashes()
+[parser] REVIEWED: Parser improvements (#2461 #2462) by @lazaray
+[bindings] ADDED: License details for BINDINGS
+[bindings] ADDED: dart-raylib (#2149) by @wolfenrain
+[bindings] ADDED: raylib-cslo (#2169) by @jasonswearingen
+[bindings] ADDED: raylib-d (#2194) by @schveiguy
+[bindings] ADDED: raylib-guile (#2202) by @petelliott
+[bindings] ADDED: raylib-scopes (#2238) by @salotz
+[bindings] ADDED: naylib (Nim) (#2386) by @planetis-m
+[bindings] ADDED: raylib.jl (Julia) (#2403) by @irishgreencitrus
+[bindings] ADDED: raylib.zig (#2449) by @ryupold
+[bindings] ADDED: racket-raylib (#2454) by @eutro
+[bindings] REVIEWED: Multiple bindings updated to raylib 4.0
+[build] ADDED: VS2022 project
+[build] ADDED: Support macOS by zig build system (#2175)
+[build] ADDED: Support custom modules selection on compilation
+[build] ADDED: Minimal web shell for WebAssembly compilation
+[build] ADDED: BSD support for zig builds (#2332) by @zigster64
+[build] ADDED: Repology badge (#2367) by @jubalh
+[build] REVIEWED: Fixed RPi make install (#2217) by @wereii
+[build] REVIEWED: Fix build results path on Linux and RPi (#2218) by @wereii
+[build] REVIEWED: Makefiles debug flag
+[build] REVIEWED: Fixed cross-compilation from x86-64 to RPi (#2233) by @pitpit
+[build] REVIEWED: All Makefiles, simplified
+[build] REVIEWED: All Makefiles, improve organization
+[build] REVIEWED: All Makefiles, support CUSTOM_CFLAGS
+[build] REVIEWED: Fixed compiling for Android using CMake (#2270) by @hero2002
+[build] REVIEWED: Make zig build functionality available to zig programs (#2271) by @Not-Nik
+[build] REVIEWED: Update CMake project template with docs and web (#2274) by @RobLoach
+[build] REVIEWED: Update VSCode project to work with latest makefile and web (#2296) by @phil-shenk
+[build] REVIEWED: Support audio examples compilation with external glfw (#2329) by @locriacyber
+[build] REVIEWED: Fix "make clean" target failing when shell is not cmd (#2338) by @Peter0x44
+[build] REVIEWED: Makefile linkage -latomic, required by miniaudio on ARM 32bit #2452
+[build] REVIEWED: Update raylib-config.cmake (#2374) by @marcogmaia
+[build] REVIEWED: Simplify build.zig to not require user to specify raylib path (#2383) by @Hejsil
+[build] REVIEWED: Fix OpenGL 4.3 graphics option in CMake (#2427) by @GoldenThumbs
+[misc] `WARNING`: REMOVED: physac from raylib sources/examples, use github.com/raysan5/physac
+[misc] `WARNING`: REMOVED: raygui from raylib/src/extras, use github.com/raysan5/raygui
+[misc] REVIEWED: Update external libraries to latest version released
+
-------------------------------------------------------------------------
Release: raylib 4.0 - 8th Anniversary Edition (05 November 2021)
-------------------------------------------------------------------------
KEY CHANGES:
- - Naming consistency and coherency: Complete review of the library: sintax, naming, comments, decriptions, logs...
+ - Naming consistency and coherency: Complete review of the library: syntax, naming, comments, decriptions, logs...
- Event Automation System: Support for input events recording and automatic re-playing, useful for automated testing and more!
- Custom game-loop control: Intended for advance users that want to control the events polling and the timming mechanisms
- rlgl 4.0: Completely decoupling from platform layer and raylib, intended for standalone usage as single-file header-only
diff --git a/examples/Makefile b/examples/Makefile
index 0252f59b7..0664e5f6a 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -247,7 +247,7 @@ ifeq ($(PLATFORM),PLATFORM_DRM)
endif
# Define include paths for required headers: INCLUDE_PATHS
-# NOTE: Some external/extras libraries could be required (stb, physac, easings...)
+# NOTE: Some external/extras libraries could be required (stb, easings...)
#------------------------------------------------------------------------------------------------
INCLUDE_PATHS = -I. -I$(RAYLIB_PATH)/src -I$(RAYLIB_PATH)/src/external -I$(RAYLIB_PATH)/src/extras
@@ -337,8 +337,6 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
# Libraries for Windows desktop compilation
# NOTE: WinMM library required to set high-res timer resolution
LDLIBS = -lraylib -lopengl32 -lgdi32 -lwinmm
- # Required for physac examples
- LDLIBS += -static -lpthread
endif
ifeq ($(PLATFORM_OS),LINUX)
# Libraries for Debian GNU/Linux desktop compiling
@@ -528,20 +526,12 @@ AUDIO = \
audio/audio_sound_loading \
audio/audio_multichannel_sound
-PHYSICS = \
- physics/physics_demo \
- physics/physics_friction \
- physics/physics_movement \
- physics/physics_restitution \
- physics/physics_shatter
-
-
CURRENT_MAKEFILE = $(lastword $(MAKEFILE_LIST))
# Define processes to execute
#------------------------------------------------------------------------------------------------
# Default target entry
-all: $(CORE) $(SHAPES) $(TEXT) $(TEXTURES) $(MODELS) $(SHADERS) $(AUDIO) $(PHYSICS)
+all: $(CORE) $(SHAPES) $(TEXT) $(TEXTURES) $(MODELS) $(SHADERS) $(AUDIO)
core: $(CORE)
shapes: $(SHAPES)
@@ -550,7 +540,6 @@ text: $(TEXT)
models: $(MODELS)
shaders: $(SHADERS)
audio: $(AUDIO)
-physics: $(PHYSICS)
# Generic compilation pattern
# NOTE: Examples must be ready for Android compilation!
diff --git a/examples/Makefile.Web b/examples/Makefile.Web
index 642527d17..a1a9d9b6b 100644
--- a/examples/Makefile.Web
+++ b/examples/Makefile.Web
@@ -238,7 +238,7 @@ ifeq ($(PLATFORM),PLATFORM_DRM)
endif
# Define include paths for required headers
-# NOTE: Some external/extras libraries could be required (stb, physac, easings...)
+# NOTE: Some external/extras libraries could be required (stb, easings...)
INCLUDE_PATHS = -I. -I$(RAYLIB_PATH)/src -I$(RAYLIB_PATH)/src/external -I$(RAYLIB_PATH)/src/extras
# Define additional directories containing required header files
@@ -324,8 +324,6 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
# Libraries for Windows desktop compilation
# NOTE: WinMM library required to set high-res timer resolution
LDLIBS = -lraylib -lopengl32 -lgdi32 -lwinmm
- # Required for physac examples
- LDLIBS += -static -lpthread
endif
ifeq ($(PLATFORM_OS),LINUX)
# Libraries for Debian GNU/Linux desktop compiling
@@ -508,17 +506,10 @@ AUDIO = \
audio/audio_sound_loading \
audio/audio_multichannel_sound
-PHYSICS = \
- physics/physics_demo \
- physics/physics_friction \
- physics/physics_movement \
- physics/physics_restitution \
- physics/physics_shatter
-
CURRENT_MAKEFILE = $(lastword $(MAKEFILE_LIST))
# Default target entry
-all: $(CORE) $(SHAPES) $(TEXT) $(TEXTURES) $(MODELS) $(SHADERS) $(AUDIO) $(PHYSICS)
+all: $(CORE) $(SHAPES) $(TEXT) $(TEXTURES) $(MODELS) $(SHADERS) $(AUDIO)
core: $(CORE)
shapes: $(SHAPES)
@@ -527,7 +518,6 @@ text: $(TEXT)
models: $(MODELS)
shaders: $(SHADERS)
audio: $(AUDIO)
-physics: $(PHYSICS)
# Compile CORE examples
core/core_basic_window: core/core_basic_window.c
@@ -1007,23 +997,6 @@ audio/audio_multichannel_sound: audio/audio_multichannel_sound.c
--preload-file audio/resources/sound.wav@resources/sound.wav \
--preload-file audio/resources/target.ogg@resources/target.ogg
-# Compile PHYSICS examples
-physics/physics_demo: physics/physics_demo.c
- $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) -DPHYSAC_AVOID_TIMMING_SYSTEM
-
-physics/physics_friction: physics/physics_friction.c
- $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) -DPHYSAC_AVOID_TIMMING_SYSTEM
-
-physics/physics_movement: physics/physics_movement.c
- $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) -DPHYSAC_AVOID_TIMMING_SYSTEM
-
-physics/physics_restitution: physics/physics_restitution.c
- $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) -DPHYSAC_AVOID_TIMMING_SYSTEM
-
-physics/physics_shatter: physics/physics_shatter.c
- $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) -DPHYSAC_AVOID_TIMMING_SYSTEM
-
-
# Clean everything
clean:
ifeq ($(PLATFORM),PLATFORM_DESKTOP)
diff --git a/examples/README.md b/examples/README.md
index 4fffb462e..3a54629ff 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -138,7 +138,6 @@ Examples using raylib models functionality, including models loading/generation
| 82 | [models_yaw_pitch_roll](models/models_yaw_pitch_roll.c) |
| [Berni](https://github.com/Berni8k) | ⭐️ |
| 83 | [models_heightmap](models/models_heightmap.c) |
| ray | |
| 84 | [models_waving_cubes](models/models_waving_cubes.c) |
| [codecat](https://github.com/codecat) | |
-| -- | [models_gltf_model](models/models_gltf_model.c) |
| [object71](https://github.com/object71) | ⭐️ |
### category: shaders
@@ -176,18 +175,6 @@ Examples using raylib audio functionality, including sound/music loading and pla
| 105 | [audio_sound_loading](audio/audio_sound_loading.c) |
| ray | |
| 106 | [audio_multichannel_sound](audio/audio_multichannel_sound.c) |
| [Chris Camacho](https://github.com/codifies) | ⭐️ |
-### category: physics
-
-Examples showing physics functionality with raylib. This functionality is provided by [physac](https://github.com/victorfisac/Physac) library, included with raylib [sources](../src/physac.h). Note this library is not linked with raylib by default, it should be manually included in user code.
-
-| ## | example | image | developer | new |
-|----|----------|--------|:----------:|:---:|
-| 107 | [physics_demo](physics/physics_demo.c) |
| [Victor Fisac](https://github.com/victorfisac) | |
-| 108 | [physics_friction](physics/physics_friction.c) |
| [Victor Fisac](https://github.com/victorfisac) | |
-| 109 | [physics_movement](physics/physics_movement.c) |
| [Victor Fisac](https://github.com/victorfisac) | |
-| 110 | [physics_restitution](physics/physics_restitution.c) |
| [Victor Fisac](https://github.com/victorfisac) | |
-| 111 | [physics_shatter](physics/physics_shatter.c) |
| [Victor Fisac](https://github.com/victorfisac) | |
-
### category: others
Examples showing raylib misc functionality that does not fit in other categories, like standalone modules usage or examples integrating external libraries.
diff --git a/examples/build.zig b/examples/build.zig
index 5c3a69d29..5be56eda7 100644
--- a/examples/build.zig
+++ b/examples/build.zig
@@ -93,7 +93,6 @@ pub fn build(b: *std.build.Builder) !void {
all.dependOn(try add_module("core", b, target));
all.dependOn(try add_module("models", b, target));
all.dependOn(try add_module("others", b, target));
- all.dependOn(try add_module("physics", b, target));
all.dependOn(try add_module("shaders", b, target));
all.dependOn(try add_module("shapes", b, target));
all.dependOn(try add_module("text", b, target));
diff --git a/examples/core/core_drop_files.c b/examples/core/core_drop_files.c
index 5c3af6ab2..129ced105 100644
--- a/examples/core/core_drop_files.c
+++ b/examples/core/core_drop_files.c
@@ -35,7 +35,7 @@ int main(void)
//----------------------------------------------------------------------------------
if (IsFileDropped())
{
- droppedFiles = GetDroppedFiles(&count);
+ droppedFiles = LoadDroppedFiles(&count);
}
//----------------------------------------------------------------------------------
@@ -67,7 +67,7 @@ int main(void)
// De-Initialization
//--------------------------------------------------------------------------------------
- ClearDroppedFiles(); // Clear internal buffers
+ UnloadDroppedFiles(); // Clear internal buffers
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
diff --git a/examples/models/models_loading.c b/examples/models/models_loading.c
index f13b11ef6..7d4543cdc 100644
--- a/examples/models/models_loading.c
+++ b/examples/models/models_loading.c
@@ -68,7 +68,7 @@ int main(void)
if (IsFileDropped())
{
int count = 0;
- char **droppedFiles = GetDroppedFiles(&count);
+ char **droppedFiles = LoadDroppedFiles(&count);
if (count == 1) // Only support one file dropped
{
@@ -95,7 +95,7 @@ int main(void)
}
}
- ClearDroppedFiles(); // Clear internal buffers
+ UnloadDroppedFiles(); // Clear internal buffers
}
// Select model on mouse click
diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index dd202617e..b5e0102d7 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -98,7 +98,7 @@ int main(void)
if (IsFileDropped())
{
int count = 0;
- char **droppedFiles = GetDroppedFiles(&count);
+ char **droppedFiles = LoadDroppedFiles(&count);
if (count == 1) // Only support one file dropped
{
@@ -125,7 +125,7 @@ int main(void)
}
}
- ClearDroppedFiles(); // Clear internal buffers
+ UnloadDroppedFiles(); // Clear internal buffers
}
//----------------------------------------------------------------------------------
diff --git a/examples/physics/physics_demo.c b/examples/physics/physics_demo.c
deleted file mode 100644
index dd7a216f7..000000000
--- a/examples/physics/physics_demo.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [physac] example - physics demo
-*
-* This example has been created using raylib 1.5 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* This example uses physac 1.1 (https://github.com/raysan5/raylib/blob/master/src/physac.h)
-*
-* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "extras/physac.h"
-
-int main(void)
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [physac] example - physics demo");
-
- // Physac logo drawing position
- int logoX = screenWidth - MeasureText("Physac", 30) - 10;
- int logoY = 15;
-
- // Initialize physics and default physics bodies
- InitPhysics();
-
- // Create floor rectangle physics body
- PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, (float)screenHeight }, 500, 100, 10);
- floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
-
- // Create obstacle circle physics body
- PhysicsBody circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2.0f, screenHeight/2.0f }, 45, 10);
- circle->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
-
- SetTargetFPS(60); // Set our game to run at 60 frames-per-second
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- // Update
- //----------------------------------------------------------------------------------
- UpdatePhysics(); // Update physics system
-
- if (IsKeyPressed(KEY_R)) // Reset physics system
- {
- ResetPhysics();
-
- floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, (float)screenHeight }, 500, 100, 10);
- floor->enabled = false;
-
- circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2.0f, screenHeight/2.0f }, 45, 10);
- circle->enabled = false;
- }
-
- // Physics body creation inputs
- if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) CreatePhysicsBodyPolygon(GetMousePosition(), (float)GetRandomValue(20, 80), GetRandomValue(3, 8), 10);
- else if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) CreatePhysicsBodyCircle(GetMousePosition(), (float)GetRandomValue(10, 45), 10);
-
- // Destroy falling physics bodies
- int bodiesCount = GetPhysicsBodiesCount();
- for (int i = bodiesCount - 1; i >= 0; i--)
- {
- PhysicsBody body = GetPhysicsBody(i);
- if (body != NULL && (body->position.y > screenHeight*2)) DestroyPhysicsBody(body);
- }
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(BLACK);
-
- DrawFPS(screenWidth - 90, screenHeight - 30);
-
- // Draw created physics bodies
- bodiesCount = GetPhysicsBodiesCount();
- for (int i = 0; i < bodiesCount; i++)
- {
- PhysicsBody body = GetPhysicsBody(i);
-
- if (body != NULL)
- {
- int vertexCount = GetPhysicsShapeVerticesCount(i);
- for (int j = 0; j < vertexCount; j++)
- {
- // Get physics bodies shape vertices to draw lines
- // Note: GetPhysicsShapeVertex() already calculates rotation transformations
- Vector2 vertexA = GetPhysicsShapeVertex(body, j);
-
- int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
- Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
-
- DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
- }
- }
- }
-
- DrawText("Left mouse button to create a polygon", 10, 10, 10, WHITE);
- DrawText("Right mouse button to create a circle", 10, 25, 10, WHITE);
- DrawText("Press 'R' to reset example", 10, 40, 10, WHITE);
-
- DrawText("Physac", logoX, logoY, 30, WHITE);
- DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- ClosePhysics(); // Unitialize physics
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/physics/physics_demo.png b/examples/physics/physics_demo.png
deleted file mode 100644
index 12dc7e724..000000000
Binary files a/examples/physics/physics_demo.png and /dev/null differ
diff --git a/examples/physics/physics_friction.c b/examples/physics/physics_friction.c
deleted file mode 100644
index 544b9931d..000000000
--- a/examples/physics/physics_friction.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [physac] example - physics friction
-*
-* This example has been created using raylib 1.5 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* This example uses physac 1.1 (https://github.com/raysan5/raylib/blob/master/src/physac.h)
-*
-* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "extras/physac.h"
-
-int main(void)
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [physac] example - physics friction");
-
- // Physac logo drawing position
- int logoX = screenWidth - MeasureText("Physac", 30) - 10;
- int logoY = 15;
-
- // Initialize physics and default physics bodies
- InitPhysics();
-
- // Create floor rectangle physics body
- PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, (float)screenHeight }, (float)screenWidth, 100, 10);
- floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
- PhysicsBody wall = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, screenHeight*0.8f }, 10, 80, 10);
- wall->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
-
- // Create left ramp physics body
- PhysicsBody rectLeft = CreatePhysicsBodyRectangle((Vector2){ 25, (float)screenHeight - 5 }, 250, 250, 10);
- rectLeft->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
- SetPhysicsBodyRotation(rectLeft, 30*DEG2RAD);
-
- // Create right ramp physics body
- PhysicsBody rectRight = CreatePhysicsBodyRectangle((Vector2){ (float)screenWidth - 25, (float)screenHeight - 5 }, 250, 250, 10);
- rectRight->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
- SetPhysicsBodyRotation(rectRight, 330*DEG2RAD);
-
- // Create dynamic physics bodies
- PhysicsBody bodyA = CreatePhysicsBodyRectangle((Vector2){ 35, screenHeight*0.6f }, 40, 40, 10);
- bodyA->staticFriction = 0.1f;
- bodyA->dynamicFriction = 0.1f;
- SetPhysicsBodyRotation(bodyA, 30*DEG2RAD);
-
- PhysicsBody bodyB = CreatePhysicsBodyRectangle((Vector2){ (float)screenWidth - 35, (float)screenHeight*0.6f }, 40, 40, 10);
- bodyB->staticFriction = 1.0f;
- bodyB->dynamicFriction = 1.0f;
- SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
-
- SetTargetFPS(60); // Set our game to run at 60 frames-per-second
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- // Update
- //----------------------------------------------------------------------------------
- UpdatePhysics(); // Update physics system
-
- if (IsKeyPressed(KEY_R)) // Reset physics system
- {
- // Reset dynamic physics bodies position, velocity and rotation
- bodyA->position = (Vector2){ 35, screenHeight*0.6f };
- bodyA->velocity = (Vector2){ 0, 0 };
- bodyA->angularVelocity = 0;
- SetPhysicsBodyRotation(bodyA, 30*DEG2RAD);
-
- bodyB->position = (Vector2){ (float)screenWidth - 35, screenHeight * 0.6f };
- bodyB->velocity = (Vector2){ 0, 0 };
- bodyB->angularVelocity = 0;
- SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
- }
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(BLACK);
-
- DrawFPS(screenWidth - 90, screenHeight - 30);
-
- // Draw created physics bodies
- int bodiesCount = GetPhysicsBodiesCount();
- for (int i = 0; i < bodiesCount; i++)
- {
- PhysicsBody body = GetPhysicsBody(i);
-
- if (body != NULL)
- {
- int vertexCount = GetPhysicsShapeVerticesCount(i);
- for (int j = 0; j < vertexCount; j++)
- {
- // Get physics bodies shape vertices to draw lines
- // Note: GetPhysicsShapeVertex() already calculates rotation transformations
- Vector2 vertexA = GetPhysicsShapeVertex(body, j);
-
- int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
- Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
-
- DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
- }
- }
- }
-
- DrawRectangle(0, screenHeight - 49, screenWidth, 49, BLACK);
-
- DrawText("Friction amount", (screenWidth - MeasureText("Friction amount", 30))/2.0f, 75, 30, WHITE);
- DrawText("0.1", (int)bodyA->position.x - MeasureText("0.1", 20)/2, (int)bodyA->position.y - 7, 20, WHITE);
- DrawText("1", (int)bodyB->position.x - MeasureText("1", 20)/2, (int)bodyB->position.y - 7, 20, WHITE);
-
- DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
-
- DrawText("Physac", logoX, logoY, 30, WHITE);
- DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- ClosePhysics(); // Unitialize physics
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/physics/physics_friction.png b/examples/physics/physics_friction.png
deleted file mode 100644
index e791ec2b9..000000000
Binary files a/examples/physics/physics_friction.png and /dev/null differ
diff --git a/examples/physics/physics_movement.c b/examples/physics/physics_movement.c
deleted file mode 100644
index 068611adb..000000000
--- a/examples/physics/physics_movement.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [physac] example - physics movement
-*
-* This example has been created using raylib 1.5 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* This example uses physac 1.1 (https://github.com/raysan5/raylib/blob/master/src/physac.h)
-*
-* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "extras/physac.h"
-
-#define VELOCITY 0.5f
-
-int main(void)
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [physac] example - physics movement");
-
- // Physac logo drawing position
- int logoX = screenWidth - MeasureText("Physac", 30) - 10;
- int logoY = 15;
-
- // Initialize physics and default physics bodies
- InitPhysics();
-
- // Create floor and walls rectangle physics body
- PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, (float)screenHeight }, (float)screenWidth, 100, 10);
- PhysicsBody platformLeft = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.25f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
- PhysicsBody platformRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.75f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
- PhysicsBody wallLeft = CreatePhysicsBodyRectangle((Vector2){ -5, screenHeight/2.0f }, 10, (float)screenHeight, 10);
- PhysicsBody wallRight = CreatePhysicsBodyRectangle((Vector2){ (float)screenWidth + 5, screenHeight/2.0f }, 10, (float)screenHeight, 10);
-
- // Disable dynamics to floor and walls physics bodies
- floor->enabled = false;
- platformLeft->enabled = false;
- platformRight->enabled = false;
- wallLeft->enabled = false;
- wallRight->enabled = false;
-
- // Create movement physics body
- PhysicsBody body = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, screenHeight/2.0f }, 50, 50, 1);
- body->freezeOrient = true; // Constrain body rotation to avoid little collision torque amounts
-
- SetTargetFPS(60); // Set our game to run at 60 frames-per-second
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- // Update
- //----------------------------------------------------------------------------------
- UpdatePhysics(); // Update physics system
-
- if (IsKeyPressed(KEY_R)) // Reset physics input
- {
- // Reset movement physics body position, velocity and rotation
- body->position = (Vector2){ screenWidth/2.0f, screenHeight/2.0f };
- body->velocity = (Vector2){ 0, 0 };
- SetPhysicsBodyRotation(body, 0);
- }
-
- // Horizontal movement input
- if (IsKeyDown(KEY_RIGHT)) body->velocity.x = VELOCITY;
- else if (IsKeyDown(KEY_LEFT)) body->velocity.x = -VELOCITY;
-
- // Vertical movement input checking if player physics body is grounded
- if (IsKeyDown(KEY_UP) && body->isGrounded) body->velocity.y = -VELOCITY*4;
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(BLACK);
-
- DrawFPS(screenWidth - 90, screenHeight - 30);
-
- // Draw created physics bodies
- int bodiesCount = GetPhysicsBodiesCount();
- for (int i = 0; i < bodiesCount; i++)
- {
- PhysicsBody body = GetPhysicsBody(i);
-
- int vertexCount = GetPhysicsShapeVerticesCount(i);
- for (int j = 0; j < vertexCount; j++)
- {
- // Get physics bodies shape vertices to draw lines
- // Note: GetPhysicsShapeVertex() already calculates rotation transformations
- Vector2 vertexA = GetPhysicsShapeVertex(body, j);
-
- int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
- Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
-
- DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
- }
- }
-
- DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
- DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
-
- DrawText("Physac", logoX, logoY, 30, WHITE);
- DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- ClosePhysics(); // Unitialize physics
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/physics/physics_movement.png b/examples/physics/physics_movement.png
deleted file mode 100644
index a88a7d79f..000000000
Binary files a/examples/physics/physics_movement.png and /dev/null differ
diff --git a/examples/physics/physics_restitution.c b/examples/physics/physics_restitution.c
deleted file mode 100644
index 27241b685..000000000
--- a/examples/physics/physics_restitution.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [physac] example - physics restitution
-*
-* This example has been created using raylib 1.5 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* This example uses physac 1.1 (https://github.com/raysan5/raylib/blob/master/src/physac.h)
-*
-* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "extras/physac.h"
-
-int main(void)
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [physac] example - physics restitution");
-
- // Physac logo drawing position
- int logoX = screenWidth - MeasureText("Physac", 30) - 10;
- int logoY = 15;
-
- // Initialize physics and default physics bodies
- InitPhysics();
-
- // Create floor rectangle physics body
- PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2.0f, (float)screenHeight }, (float)screenWidth, 100, 10);
- floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
- floor->restitution = 1;
-
- // Create circles physics body
- PhysicsBody circleA = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.25f, screenHeight/2.0f }, 30, 10);
- circleA->restitution = 0;
- PhysicsBody circleB = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.5f, screenHeight/2.0f }, 30, 10);
- circleB->restitution = 0.5f;
- PhysicsBody circleC = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.75f, screenHeight/2.0f }, 30, 10);
- circleC->restitution = 1;
-
- // Restitution demo needs a very tiny physics time step for a proper simulation
- SetPhysicsTimeStep(1.0/60.0/100*1000);
-
- SetTargetFPS(60); // Set our game to run at 60 frames-per-second
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- // Update
- //----------------------------------------------------------------------------------
- UpdatePhysics(); // Update physics system
-
- if (IsKeyPressed(KEY_R)) // Reset physics input
- {
- // Reset circles physics bodies position and velocity
- circleA->position = (Vector2){ screenWidth*0.25f, screenHeight/2.0f };
- circleA->velocity = (Vector2){ 0, 0 };
- circleB->position = (Vector2){ screenWidth*0.5f, screenHeight/2.0f };
- circleB->velocity = (Vector2){ 0, 0 };
- circleC->position = (Vector2){ screenWidth*0.75f, screenHeight/2.0f };
- circleC->velocity = (Vector2){ 0, 0 };
- }
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(BLACK);
-
- DrawFPS(screenWidth - 90, screenHeight - 30);
-
- // Draw created physics bodies
- int bodiesCount = GetPhysicsBodiesCount();
- for (int i = 0; i < bodiesCount; i++)
- {
- PhysicsBody body = GetPhysicsBody(i);
-
- int vertexCount = GetPhysicsShapeVerticesCount(i);
- for (int j = 0; j < vertexCount; j++)
- {
- // Get physics bodies shape vertices to draw lines
- // Note: GetPhysicsShapeVertex() already calculates rotation transformations
- Vector2 vertexA = GetPhysicsShapeVertex(body, j);
-
- int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
- Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
-
- DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
- }
- }
-
- DrawText("Restitution amount", (screenWidth - MeasureText("Restitution amount", 30))/2, 75, 30, WHITE);
- DrawText("0", (int)circleA->position.x - MeasureText("0", 20)/2, circleA->position.y - 7, 20, WHITE);
- DrawText("0.5", (int)circleB->position.x - MeasureText("0.5", 20)/2, circleB->position.y - 7, 20, WHITE);
- DrawText("1", (int)circleC->position.x - MeasureText("1", 20)/2, circleC->position.y - 7, 20, WHITE);
-
- DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
-
- DrawText("Physac", logoX, logoY, 30, WHITE);
- DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- DestroyPhysicsBody(circleA);
- DestroyPhysicsBody(circleB);
- DestroyPhysicsBody(circleC);
- DestroyPhysicsBody(floor);
-
- ClosePhysics(); // Unitialize physics
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/physics/physics_restitution.png b/examples/physics/physics_restitution.png
deleted file mode 100644
index 8ec4b3f32..000000000
Binary files a/examples/physics/physics_restitution.png and /dev/null differ
diff --git a/examples/physics/physics_shatter.c b/examples/physics/physics_shatter.c
deleted file mode 100644
index 809227eea..000000000
--- a/examples/physics/physics_shatter.c
+++ /dev/null
@@ -1,111 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [physac] example - physics shatter
-*
-* This example has been created using raylib 1.5 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* This example uses physac 1.1 (https://github.com/raysan5/raylib/blob/master/src/physac.h)
-*
-* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "extras/physac.h"
-
-int main(void)
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [physac] example - physics shatter");
-
- // Physac logo drawing position
- int logoX = screenWidth - MeasureText("Physac", 30) - 10;
- int logoY = 15;
-
- // Initialize physics and default physics bodies
- InitPhysics();
- SetPhysicsGravity(0, 0);
-
- // Create random polygon physics body to shatter
- CreatePhysicsBodyPolygon((Vector2){ screenWidth/2.0f, screenHeight/2.0f }, (float)GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
-
- SetTargetFPS(60); // Set our game to run at 60 frames-per-second
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- //----------------------------------------------------------------------------------
- UpdatePhysics(); // Update physics system
-
- if (IsKeyPressed(KEY_R)) // Reset physics input
- {
- ResetPhysics();
-
- CreatePhysicsBodyPolygon((Vector2){ screenWidth/2.0f, screenHeight/2.0f }, (float)GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
- }
-
- if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) // Physics shatter input
- {
- int count = GetPhysicsBodiesCount();
- for (int i = count - 1; i >= 0; i--)
- {
- PhysicsBody currentBody = GetPhysicsBody(i);
-
- if (currentBody != NULL) PhysicsShatter(currentBody, GetMousePosition(), 10/currentBody->inverseMass);
- }
- }
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(BLACK);
-
- // Draw created physics bodies
- int bodiesCount = GetPhysicsBodiesCount();
- for (int i = 0; i < bodiesCount; i++)
- {
- PhysicsBody currentBody = GetPhysicsBody(i);
-
- int vertexCount = GetPhysicsShapeVerticesCount(i);
- for (int j = 0; j < vertexCount; j++)
- {
- // Get physics bodies shape vertices to draw lines
- // Note: GetPhysicsShapeVertex() already calculates rotation transformations
- Vector2 vertexA = GetPhysicsShapeVertex(currentBody, j);
-
- int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
- Vector2 vertexB = GetPhysicsShapeVertex(currentBody, jj);
-
- DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
- }
- }
-
- DrawText("Left mouse button in polygon area to shatter body\nPress 'R' to reset example", 10, 10, 10, WHITE);
-
- DrawText("Physac", logoX, logoY, 30, WHITE);
- DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- ClosePhysics(); // Unitialize physics
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/physics/physics_shatter.png b/examples/physics/physics_shatter.png
deleted file mode 100644
index 68f9a1b7d..000000000
Binary files a/examples/physics/physics_shatter.png and /dev/null differ
diff --git a/src/extras/raygui.h b/examples/shapes/raygui.h
similarity index 67%
rename from src/extras/raygui.h
rename to examples/shapes/raygui.h
index d588279cd..3e7dea442 100644
--- a/src/extras/raygui.h
+++ b/examples/shapes/raygui.h
@@ -1,6 +1,6 @@
/*******************************************************************************************
*
-* raygui v3.0 - A simple and easy-to-use immediate-mode gui library
+* raygui v3.2 - A simple and easy-to-use immediate-mode gui library
*
* DESCRIPTION:
*
@@ -10,10 +10,11 @@
* Controls provided:
*
* # Container/separators Controls
-* - WindowBox
-* - GroupBox
+* - WindowBox --> StatusBar, Panel
+* - GroupBox --> Line
* - Line
-* - Panel
+* - Panel --> StatusBar
+* - ScrollPanel --> StatusBar
*
* # Basic Controls
* - Label
@@ -32,8 +33,6 @@
* - SliderBar --> Slider
* - ProgressBar
* - StatusBar
-* - ScrollBar
-* - ScrollPanel
* - DummyRec
* - Grid
*
@@ -46,7 +45,7 @@
* It also provides a set of functions for styling the controls based on its properties (size, color).
*
*
-* GUI STYLE (guiStyle):
+* RAYGUI 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
@@ -71,11 +70,11 @@
* TOOL: rGuiStyler is a visual tool to customize raygui style.
*
*
-* GUI ICONS (guiIcons):
+* RAYGUI 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
+* must be same RAYGUI_ICON_SIZE and no more than RAYGUI_ICON_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.
@@ -84,7 +83,7 @@
*
* 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];
+* static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS];
*
* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB
*
@@ -103,17 +102,32 @@
* 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
+* #define RAYGUI_NO_ICONS
* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB)
*
-* #define RAYGUI_CUSTOM_RICONS
+* #define RAYGUI_CUSTOM_ICONS
* 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
+* 3.2 (22-May-2022) RENAMED: Some enum values, for unification, avoiding prefixes
+* REMOVED: GuiScrollBar(), only internal
+* REDESIGNED: GuiPanel() to support text parameter
+* REDESIGNED: GuiScrollPanel() to support text parameter
+* REDESIGNED: GuiColorPicker() to support text parameter
+* REDESIGNED: GuiColorPanel() to support text parameter
+* REDESIGNED: GuiColorBarAlpha() to support text parameter
+* REDESIGNED: GuiColorBarHue() to support text parameter
+* REDESIGNED: GuiTextInputBox() to support password
+* 3.1 (12-Jan-2022) REVIEWED: Default style for consistency (aligned with rGuiLayout v2.5 tool)
+* REVIEWED: GuiLoadStyle() to support compressed font atlas image data and unload previous textures
+* REVIEWED: External icons usage logic
+* REVIEWED: GuiLine() for centered alignment when including text
+* RENAMED: Multiple controls properties definitions to prepend RAYGUI_
+* RENAMED: RICON_ references to RAYGUI_ICON_ for library consistency
+* Projects updated and multiple tweaks
+* 3.0 (04-Nov-2021) Integrated ricons data to avoid external file
* REDESIGNED: GuiTextBoxMulti()
* REMOVED: GuiImageButton*()
* Multiple minor tweaks and bugs corrected
@@ -160,7 +174,7 @@
*
* LICENSE: zlib/libpng
*
-* Copyright (c) 2014-2021 Ramon Santamaria (@raysan5)
+* Copyright (c) 2014-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.
@@ -182,7 +196,7 @@
#ifndef RAYGUI_H
#define RAYGUI_H
-#define RAYGUI_VERSION "3.0"
+#define RAYGUI_VERSION "3.2"
#if !defined(RAYGUI_STANDALONE)
#include "raylib.h"
@@ -206,7 +220,6 @@
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
-
// Allow custom memory allocators
#ifndef RAYGUI_MALLOC
#define RAYGUI_MALLOC(sz) malloc(sz)
@@ -218,8 +231,14 @@
#define RAYGUI_FREE(p) free(p)
#endif
-// TODO: Implement custom TraceLog()
-#define TRACELOG(level, ...) (void)0
+// Simple log system to avoid printf() calls if required
+// NOTE: Avoiding those calls, also avoids const strings memory usage
+#define RAYGUI_SUPPORT_LOG_INFO
+#if defined(RAYGUI_SUPPORT_LOG_INFO)
+ #define RAYGUI_LOG(...) printf(__VA_ARGS__)
+#else
+ #define RAYGUI_LOG(...)
+#endif
//----------------------------------------------------------------------------------
// Types and Structures Definition
@@ -296,27 +315,29 @@
typedef struct GuiStyleProp {
unsigned short controlId;
unsigned short propertyId;
- int propertyValue;
+ unsigned int propertyValue;
} GuiStyleProp;
// Gui control state
typedef enum {
- GUI_STATE_NORMAL = 0,
- GUI_STATE_FOCUSED,
- GUI_STATE_PRESSED,
- GUI_STATE_DISABLED,
-} GuiControlState;
+ STATE_NORMAL = 0,
+ STATE_FOCUSED,
+ STATE_PRESSED,
+ STATE_DISABLED,
+} GuiState;
// Gui control text alignment
typedef enum {
- GUI_TEXT_ALIGN_LEFT = 0,
- GUI_TEXT_ALIGN_CENTER,
- GUI_TEXT_ALIGN_RIGHT,
+ TEXT_ALIGN_LEFT = 0,
+ TEXT_ALIGN_CENTER,
+ TEXT_ALIGN_RIGHT,
} GuiTextAlignment;
// Gui controls
typedef enum {
- DEFAULT = 0, // Generic control -> populates to all controls when set
+ // Default -> populates to all controls when set
+ DEFAULT = 0,
+ // Basic controls
LABEL, // Used also for: LABELBUTTON
BUTTON,
TOGGLE, // Used also for: TOGGLEGROUP
@@ -327,7 +348,7 @@ typedef enum {
DROPDOWNBOX,
TEXTBOX, // Used also for: TEXTBOXMULTI
VALUEBOX,
- SPINNER,
+ SPINNER, // Uses: BUTTON, VALUEBOX
LISTVIEW,
COLORPICKER,
SCROLLBAR,
@@ -357,102 +378,98 @@ typedef enum {
// 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
+// NOTE: Those properties are common to all controls or global
typedef enum {
- TEXT_SIZE = 16,
- TEXT_SPACING,
- LINE_COLOR,
- BACKGROUND_COLOR,
+ TEXT_SIZE = 16, // Text size (glyphs max height)
+ TEXT_SPACING, // Text spacing between glyphs
+ LINE_COLOR, // Line control color
+ BACKGROUND_COLOR, // Background color
} GuiDefaultProperty;
// Label
//typedef enum { } GuiLabelProperty;
-// Button
+// Button/Spinner
//typedef enum { } GuiButtonProperty;
// Toggle/ToggleGroup
typedef enum {
- GROUP_PADDING = 16,
+ GROUP_PADDING = 16, // ToggleGroup separation between toggles
} GuiToggleProperty;
// Slider/SliderBar
typedef enum {
- SLIDER_WIDTH = 16,
- SLIDER_PADDING
+ SLIDER_WIDTH = 16, // Slider size of internal bar
+ SLIDER_PADDING // Slider/SliderBar internal bar padding
} GuiSliderProperty;
// ProgressBar
typedef enum {
- PROGRESS_PADDING = 16,
+ PROGRESS_PADDING = 16, // ProgressBar internal padding
} 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_PADDING, // (SLIDERBAR, SLIDER_PADDING)
SCROLL_SLIDER_SIZE,
SCROLL_PADDING,
SCROLL_SPEED,
} GuiScrollBarProperty;
-// ScrollBar side
+// CheckBox
typedef enum {
- SCROLLBAR_LEFT_SIDE = 0,
- SCROLLBAR_RIGHT_SIDE
-} GuiScrollBarSide;
+ CHECK_PADDING = 16 // CheckBox internal check padding
+} GuiCheckBoxProperty;
+
+// ComboBox
+typedef enum {
+ COMBO_BUTTON_WIDTH = 16, // ComboBox right button width
+ COMBO_BUTTON_SPACING // ComboBox button separation
+} GuiComboBoxProperty;
+
+// DropdownBox
+typedef enum {
+ ARROW_PADDING = 16, // DropdownBox arrow separation from border and items
+ DROPDOWN_ITEMS_SPACING // DropdownBox items separation
+} GuiDropdownBoxProperty;
+
+// TextBox/TextBoxMulti/ValueBox/Spinner
+typedef enum {
+ TEXT_INNER_PADDING = 16, // TextBox/TextBoxMulti/ValueBox/Spinner inner text padding
+ TEXT_LINES_SPACING, // TextBoxMulti lines separation
+} GuiTextBoxProperty;
+
+// Spinner
+typedef enum {
+ SPIN_BUTTON_WIDTH = 16, // Spinner left/right buttons width
+ SPIN_BUTTON_SPACING, // Spinner buttons separation
+} GuiSpinnerProperty;
// ListView
typedef enum {
- LIST_ITEMS_HEIGHT = 16,
- LIST_ITEMS_PADDING,
- SCROLLBAR_WIDTH,
- SCROLLBAR_SIDE,
+ LIST_ITEMS_HEIGHT = 16, // ListView items height
+ LIST_ITEMS_SPACING, // ListView items separation
+ SCROLLBAR_WIDTH, // ListView scrollbar size (usually width)
+ SCROLLBAR_SIDE, // ListView scrollbar side (0-left, 1-right)
} 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
+ HUEBAR_WIDTH, // ColorPicker right hue bar width
+ HUEBAR_PADDING, // ColorPicker right hue bar separation from panel
+ HUEBAR_SELECTOR_HEIGHT, // ColorPicker right hue bar selector height
+ HUEBAR_SELECTOR_OVERFLOW // ColorPicker right hue bar selector overflow
} GuiColorPickerProperty;
+#define SCROLLBAR_LEFT_SIDE 0
+#define SCROLLBAR_RIGHT_SIDE 1
+
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
@@ -488,8 +505,8 @@ RAYGUIAPI int GuiGetStyle(int control, int property); // Get o
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
+RAYGUIAPI void GuiPanel(Rectangle bounds, const char *text); // Panel control, useful to group controls
+RAYGUIAPI Rectangle GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll); // Scroll Panel control
// Basic controls set
RAYGUIAPI void GuiLabel(Rectangle bounds, const char *text); // Label control, shows text
@@ -509,43 +526,301 @@ RAYGUIAPI float GuiSliderBar(Rectangle bounds, const char *textLeft, const char
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
-
+RAYGUIAPI Vector2 GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs); // Grid control, returns mouse cell position
// 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
+RAYGUIAPI int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, int *secretViewActive); // Text Input Box control, ask for text, supports secret
+RAYGUIAPI Color GuiColorPicker(Rectangle bounds, const char *text, Color color); // Color Picker control (multiple color controls)
+RAYGUIAPI Color GuiColorPanel(Rectangle bounds, const char *text, Color color); // Color Panel control
+RAYGUIAPI float GuiColorBarAlpha(Rectangle bounds, const char *text, float alpha); // Color Bar Alpha control
+RAYGUIAPI float GuiColorBarHue(Rectangle bounds, const char *text, 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
-*/
-
+// Icons functionality
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
+#if !defined(RAYGUI_NO_ICONS)
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 GuiSetIconScale(unsigned int scale); // Set icon scale (1 by default)
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
+
+#if !defined(RAYGUI_CUSTOM_ICONS)
+//----------------------------------------------------------------------------------
+// Icons enumeration
+//----------------------------------------------------------------------------------
+typedef enum {
+ ICON_NONE = 0,
+ ICON_FOLDER_FILE_OPEN = 1,
+ ICON_FILE_SAVE_CLASSIC = 2,
+ ICON_FOLDER_OPEN = 3,
+ ICON_FOLDER_SAVE = 4,
+ ICON_FILE_OPEN = 5,
+ ICON_FILE_SAVE = 6,
+ ICON_FILE_EXPORT = 7,
+ ICON_FILE_ADD = 8,
+ ICON_FILE_DELETE = 9,
+ ICON_FILETYPE_TEXT = 10,
+ ICON_FILETYPE_AUDIO = 11,
+ ICON_FILETYPE_IMAGE = 12,
+ ICON_FILETYPE_PLAY = 13,
+ ICON_FILETYPE_VIDEO = 14,
+ ICON_FILETYPE_INFO = 15,
+ ICON_FILE_COPY = 16,
+ ICON_FILE_CUT = 17,
+ ICON_FILE_PASTE = 18,
+ ICON_CURSOR_HAND = 19,
+ ICON_CURSOR_POINTER = 20,
+ ICON_CURSOR_CLASSIC = 21,
+ ICON_PENCIL = 22,
+ ICON_PENCIL_BIG = 23,
+ ICON_BRUSH_CLASSIC = 24,
+ ICON_BRUSH_PAINTER = 25,
+ ICON_WATER_DROP = 26,
+ ICON_COLOR_PICKER = 27,
+ ICON_RUBBER = 28,
+ ICON_COLOR_BUCKET = 29,
+ ICON_TEXT_T = 30,
+ ICON_TEXT_A = 31,
+ ICON_SCALE = 32,
+ ICON_RESIZE = 33,
+ ICON_FILTER_POINT = 34,
+ ICON_FILTER_BILINEAR = 35,
+ ICON_CROP = 36,
+ ICON_CROP_ALPHA = 37,
+ ICON_SQUARE_TOGGLE = 38,
+ ICON_SYMMETRY = 39,
+ ICON_SYMMETRY_HORIZONTAL = 40,
+ ICON_SYMMETRY_VERTICAL = 41,
+ ICON_LENS = 42,
+ ICON_LENS_BIG = 43,
+ ICON_EYE_ON = 44,
+ ICON_EYE_OFF = 45,
+ ICON_FILTER_TOP = 46,
+ ICON_FILTER = 47,
+ ICON_TARGET_POINT = 48,
+ ICON_TARGET_SMALL = 49,
+ ICON_TARGET_BIG = 50,
+ ICON_TARGET_MOVE = 51,
+ ICON_CURSOR_MOVE = 52,
+ ICON_CURSOR_SCALE = 53,
+ ICON_CURSOR_SCALE_RIGHT = 54,
+ ICON_CURSOR_SCALE_LEFT = 55,
+ ICON_UNDO = 56,
+ ICON_REDO = 57,
+ ICON_REREDO = 58,
+ ICON_MUTATE = 59,
+ ICON_ROTATE = 60,
+ ICON_REPEAT = 61,
+ ICON_SHUFFLE = 62,
+ ICON_EMPTYBOX = 63,
+ ICON_TARGET = 64,
+ ICON_TARGET_SMALL_FILL = 65,
+ ICON_TARGET_BIG_FILL = 66,
+ ICON_TARGET_MOVE_FILL = 67,
+ ICON_CURSOR_MOVE_FILL = 68,
+ ICON_CURSOR_SCALE_FILL = 69,
+ ICON_CURSOR_SCALE_RIGHT_FILL = 70,
+ ICON_CURSOR_SCALE_LEFT_FILL = 71,
+ ICON_UNDO_FILL = 72,
+ ICON_REDO_FILL = 73,
+ ICON_REREDO_FILL = 74,
+ ICON_MUTATE_FILL = 75,
+ ICON_ROTATE_FILL = 76,
+ ICON_REPEAT_FILL = 77,
+ ICON_SHUFFLE_FILL = 78,
+ ICON_EMPTYBOX_SMALL = 79,
+ ICON_BOX = 80,
+ ICON_BOX_TOP = 81,
+ ICON_BOX_TOP_RIGHT = 82,
+ ICON_BOX_RIGHT = 83,
+ ICON_BOX_BOTTOM_RIGHT = 84,
+ ICON_BOX_BOTTOM = 85,
+ ICON_BOX_BOTTOM_LEFT = 86,
+ ICON_BOX_LEFT = 87,
+ ICON_BOX_TOP_LEFT = 88,
+ ICON_BOX_CENTER = 89,
+ ICON_BOX_CIRCLE_MASK = 90,
+ ICON_POT = 91,
+ ICON_ALPHA_MULTIPLY = 92,
+ ICON_ALPHA_CLEAR = 93,
+ ICON_DITHERING = 94,
+ ICON_MIPMAPS = 95,
+ ICON_BOX_GRID = 96,
+ ICON_GRID = 97,
+ ICON_BOX_CORNERS_SMALL = 98,
+ ICON_BOX_CORNERS_BIG = 99,
+ ICON_FOUR_BOXES = 100,
+ ICON_GRID_FILL = 101,
+ ICON_BOX_MULTISIZE = 102,
+ ICON_ZOOM_SMALL = 103,
+ ICON_ZOOM_MEDIUM = 104,
+ ICON_ZOOM_BIG = 105,
+ ICON_ZOOM_ALL = 106,
+ ICON_ZOOM_CENTER = 107,
+ ICON_BOX_DOTS_SMALL = 108,
+ ICON_BOX_DOTS_BIG = 109,
+ ICON_BOX_CONCENTRIC = 110,
+ ICON_BOX_GRID_BIG = 111,
+ ICON_OK_TICK = 112,
+ ICON_CROSS = 113,
+ ICON_ARROW_LEFT = 114,
+ ICON_ARROW_RIGHT = 115,
+ ICON_ARROW_DOWN = 116,
+ ICON_ARROW_UP = 117,
+ ICON_ARROW_LEFT_FILL = 118,
+ ICON_ARROW_RIGHT_FILL = 119,
+ ICON_ARROW_DOWN_FILL = 120,
+ ICON_ARROW_UP_FILL = 121,
+ ICON_AUDIO = 122,
+ ICON_FX = 123,
+ ICON_WAVE = 124,
+ ICON_WAVE_SINUS = 125,
+ ICON_WAVE_SQUARE = 126,
+ ICON_WAVE_TRIANGULAR = 127,
+ ICON_CROSS_SMALL = 128,
+ ICON_PLAYER_PREVIOUS = 129,
+ ICON_PLAYER_PLAY_BACK = 130,
+ ICON_PLAYER_PLAY = 131,
+ ICON_PLAYER_PAUSE = 132,
+ ICON_PLAYER_STOP = 133,
+ ICON_PLAYER_NEXT = 134,
+ ICON_PLAYER_RECORD = 135,
+ ICON_MAGNET = 136,
+ ICON_LOCK_CLOSE = 137,
+ ICON_LOCK_OPEN = 138,
+ ICON_CLOCK = 139,
+ ICON_TOOLS = 140,
+ ICON_GEAR = 141,
+ ICON_GEAR_BIG = 142,
+ ICON_BIN = 143,
+ ICON_HAND_POINTER = 144,
+ ICON_LASER = 145,
+ ICON_COIN = 146,
+ ICON_EXPLOSION = 147,
+ ICON_1UP = 148,
+ ICON_PLAYER = 149,
+ ICON_PLAYER_JUMP = 150,
+ ICON_KEY = 151,
+ ICON_DEMON = 152,
+ ICON_TEXT_POPUP = 153,
+ ICON_GEAR_EX = 154,
+ ICON_CRACK = 155,
+ ICON_CRACK_POINTS = 156,
+ ICON_STAR = 157,
+ ICON_DOOR = 158,
+ ICON_EXIT = 159,
+ ICON_MODE_2D = 160,
+ ICON_MODE_3D = 161,
+ ICON_CUBE = 162,
+ ICON_CUBE_FACE_TOP = 163,
+ ICON_CUBE_FACE_LEFT = 164,
+ ICON_CUBE_FACE_FRONT = 165,
+ ICON_CUBE_FACE_BOTTOM = 166,
+ ICON_CUBE_FACE_RIGHT = 167,
+ ICON_CUBE_FACE_BACK = 168,
+ ICON_CAMERA = 169,
+ ICON_SPECIAL = 170,
+ ICON_LINK_NET = 171,
+ ICON_LINK_BOXES = 172,
+ ICON_LINK_MULTI = 173,
+ ICON_LINK = 174,
+ ICON_LINK_BROKE = 175,
+ ICON_TEXT_NOTES = 176,
+ ICON_NOTEBOOK = 177,
+ ICON_SUITCASE = 178,
+ ICON_SUITCASE_ZIP = 179,
+ ICON_MAILBOX = 180,
+ ICON_MONITOR = 181,
+ ICON_PRINTER = 182,
+ ICON_PHOTO_CAMERA = 183,
+ ICON_PHOTO_CAMERA_FLASH = 184,
+ ICON_HOUSE = 185,
+ ICON_HEART = 186,
+ ICON_CORNER = 187,
+ ICON_VERTICAL_BARS = 188,
+ ICON_VERTICAL_BARS_FILL = 189,
+ ICON_LIFE_BARS = 190,
+ ICON_INFO = 191,
+ ICON_CROSSLINE = 192,
+ ICON_HELP = 193,
+ ICON_FILETYPE_ALPHA = 194,
+ ICON_FILETYPE_HOME = 195,
+ ICON_LAYERS_VISIBLE = 196,
+ ICON_LAYERS = 197,
+ ICON_WINDOW = 198,
+ ICON_HIDPI = 199,
+ ICON_FILETYPE_BINARY = 200,
+ ICON_HEX = 201,
+ ICON_SHIELD = 202,
+ ICON_FILE_NEW = 203,
+ ICON_FOLDER_ADD = 204,
+ ICON_ALARM = 205,
+ ICON_206 = 206,
+ ICON_207 = 207,
+ ICON_208 = 208,
+ ICON_209 = 209,
+ ICON_210 = 210,
+ ICON_211 = 211,
+ ICON_212 = 212,
+ ICON_213 = 213,
+ ICON_214 = 214,
+ ICON_215 = 215,
+ ICON_216 = 216,
+ ICON_217 = 217,
+ ICON_218 = 218,
+ ICON_219 = 219,
+ ICON_220 = 220,
+ ICON_221 = 221,
+ ICON_222 = 222,
+ ICON_223 = 223,
+ ICON_224 = 224,
+ ICON_225 = 225,
+ ICON_226 = 226,
+ ICON_227 = 227,
+ ICON_228 = 228,
+ ICON_229 = 229,
+ ICON_230 = 230,
+ ICON_231 = 231,
+ ICON_232 = 232,
+ ICON_233 = 233,
+ ICON_234 = 234,
+ ICON_235 = 235,
+ ICON_236 = 236,
+ ICON_237 = 237,
+ ICON_238 = 238,
+ ICON_239 = 239,
+ ICON_240 = 240,
+ ICON_241 = 241,
+ ICON_242 = 242,
+ ICON_243 = 243,
+ ICON_244 = 244,
+ ICON_245 = 245,
+ ICON_246 = 246,
+ ICON_247 = 247,
+ ICON_248 = 248,
+ ICON_249 = 249,
+ ICON_250 = 250,
+ ICON_251 = 251,
+ ICON_252 = 252,
+ ICON_253 = 253,
+ ICON_254 = 254,
+ ICON_255 = 255,
+} GuiIconName;
+#endif
+
#endif
#if defined(__cplusplus)
@@ -574,286 +849,19 @@ RAYGUIAPI bool GuiCheckIconPixel(int iconId, int x, int y); // Check icon pi
#define RAYGUI_CLITERAL(name) (name)
#endif
-#if !defined(RAYGUI_NO_RICONS)
+#if !defined(RAYGUI_NO_ICONS) && !defined(RAYGUI_CUSTOM_ICONS)
-#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
+// Embedded icons, no external file provided
+#define RAYGUI_ICON_SIZE 16 // Size of icons in pixels (squared)
+#define RAYGUI_ICON_MAX_ICONS 256 // Maximum number of icons
+#define RAYGUI_ICON_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;
+// Those arrays are stored as unsigned int data arrays, so,
+// every array element defines 32 pixels (bits) of information
+// One icon is defined by 8 int, (8 int * 32 bit = 256 bit = 16*16 pixels)
+// NOTE: Number of elemens depend on RAYGUI_ICON_SIZE (by default 16x16 pixels)
+#define RAYGUI_ICON_DATA_ELEMENTS (RAYGUI_ICON_SIZE*RAYGUI_ICON_SIZE/32)
//----------------------------------------------------------------------------------
// Icons data for all gui possible icons (allocated on data segment by default)
@@ -861,276 +869,274 @@ typedef enum {
// 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
+// NOTE 2: A different icon set could be loaded over this array using GuiLoadIcons(),
+// but loaded icons set must be same RAYGUI_ICON_SIZE and no more than RAYGUI_ICON_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
+static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS] = {
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_NONE
+ 0x3ff80000, 0x2f082008, 0x2042207e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x00007ffe, // ICON_FOLDER_FILE_OPEN
+ 0x3ffe0000, 0x44226422, 0x400247e2, 0x5ffa4002, 0x57ea500a, 0x500a500a, 0x40025ffa, 0x00007ffe, // ICON_FILE_SAVE_CLASSIC
+ 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024002, 0x44424282, 0x793e4102, 0x00000100, // ICON_FOLDER_OPEN
+ 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024102, 0x44424102, 0x793e4282, 0x00000000, // ICON_FOLDER_SAVE
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x24442284, 0x21042104, 0x20042104, 0x00003ffc, // ICON_FILE_OPEN
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x21042104, 0x22842444, 0x20042104, 0x00003ffc, // ICON_FILE_SAVE
+ 0x3ff00000, 0x201c2010, 0x00042004, 0x20041004, 0x20844784, 0x00841384, 0x20042784, 0x00003ffc, // ICON_FILE_EXPORT
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x22042204, 0x22042f84, 0x20042204, 0x00003ffc, // ICON_FILE_ADD
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x25042884, 0x25042204, 0x20042884, 0x00003ffc, // ICON_FILE_DELETE
+ 0x3ff00000, 0x201c2010, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // ICON_FILETYPE_TEXT
+ 0x3ff00000, 0x201c2010, 0x27042004, 0x244424c4, 0x26442444, 0x20642664, 0x20042004, 0x00003ffc, // ICON_FILETYPE_AUDIO
+ 0x3ff00000, 0x201c2010, 0x26042604, 0x20042004, 0x35442884, 0x2414222c, 0x20042004, 0x00003ffc, // ICON_FILETYPE_IMAGE
+ 0x3ff00000, 0x201c2010, 0x20c42004, 0x22442144, 0x22442444, 0x20c42144, 0x20042004, 0x00003ffc, // ICON_FILETYPE_PLAY
+ 0x3ff00000, 0x3ffc2ff0, 0x3f3c2ff4, 0x3dbc2eb4, 0x3dbc2bb4, 0x3f3c2eb4, 0x3ffc2ff4, 0x00002ff4, // ICON_FILETYPE_VIDEO
+ 0x3ff00000, 0x201c2010, 0x21842184, 0x21842004, 0x21842184, 0x21842184, 0x20042184, 0x00003ffc, // ICON_FILETYPE_INFO
+ 0x0ff00000, 0x381c0810, 0x28042804, 0x28042804, 0x28042804, 0x28042804, 0x20102ffc, 0x00003ff0, // ICON_FILE_COPY
+ 0x00000000, 0x701c0000, 0x079c1e14, 0x55a000f0, 0x079c00f0, 0x701c1e14, 0x00000000, 0x00000000, // ICON_FILE_CUT
+ 0x01c00000, 0x13e41bec, 0x3f841004, 0x204420c4, 0x20442044, 0x20442044, 0x207c2044, 0x00003fc0, // ICON_FILE_PASTE
+ 0x00000000, 0x3aa00fe0, 0x2abc2aa0, 0x2aa42aa4, 0x20042aa4, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_CURSOR_HAND
+ 0x00000000, 0x003c000c, 0x030800c8, 0x30100c10, 0x10202020, 0x04400840, 0x01800280, 0x00000000, // ICON_CURSOR_POINTER
+ 0x00000000, 0x00180000, 0x01f00078, 0x03e007f0, 0x07c003e0, 0x04000e40, 0x00000000, 0x00000000, // ICON_CURSOR_CLASSIC
+ 0x00000000, 0x04000000, 0x11000a00, 0x04400a80, 0x01100220, 0x00580088, 0x00000038, 0x00000000, // ICON_PENCIL
+ 0x04000000, 0x15000a00, 0x50402880, 0x14102820, 0x05040a08, 0x015c028c, 0x007c00bc, 0x00000000, // ICON_PENCIL_BIG
+ 0x01c00000, 0x01400140, 0x01400140, 0x0ff80140, 0x0ff80808, 0x0aa80808, 0x0aa80aa8, 0x00000ff8, // ICON_BRUSH_CLASSIC
+ 0x1ffc0000, 0x5ffc7ffe, 0x40004000, 0x00807f80, 0x01c001c0, 0x01c001c0, 0x01c001c0, 0x00000080, // ICON_BRUSH_PAINTER
+ 0x00000000, 0x00800000, 0x01c00080, 0x03e001c0, 0x07f003e0, 0x036006f0, 0x000001c0, 0x00000000, // ICON_WATER_DROP
+ 0x00000000, 0x3e003800, 0x1f803f80, 0x0c201e40, 0x02080c10, 0x00840104, 0x00380044, 0x00000000, // ICON_COLOR_PICKER
+ 0x00000000, 0x07800300, 0x1fe00fc0, 0x3f883fd0, 0x0e021f04, 0x02040402, 0x00f00108, 0x00000000, // ICON_RUBBER
+ 0x00c00000, 0x02800140, 0x08200440, 0x20081010, 0x2ffe3004, 0x03f807fc, 0x00e001f0, 0x00000040, // ICON_COLOR_BUCKET
+ 0x00000000, 0x21843ffc, 0x01800180, 0x01800180, 0x01800180, 0x01800180, 0x03c00180, 0x00000000, // ICON_TEXT_T
+ 0x00800000, 0x01400180, 0x06200340, 0x0c100620, 0x1ff80c10, 0x380c1808, 0x70067004, 0x0000f80f, // ICON_TEXT_A
+ 0x78000000, 0x50004000, 0x00004800, 0x03c003c0, 0x03c003c0, 0x00100000, 0x0002000a, 0x0000000e, // ICON_SCALE
+ 0x75560000, 0x5e004002, 0x54001002, 0x41001202, 0x408200fe, 0x40820082, 0x40820082, 0x00006afe, // ICON_RESIZE
+ 0x00000000, 0x3f003f00, 0x3f003f00, 0x3f003f00, 0x00400080, 0x001c0020, 0x001c001c, 0x00000000, // ICON_FILTER_POINT
+ 0x6d800000, 0x00004080, 0x40804080, 0x40800000, 0x00406d80, 0x001c0020, 0x001c001c, 0x00000000, // ICON_FILTER_BILINEAR
+ 0x40080000, 0x1ffe2008, 0x14081008, 0x11081208, 0x10481088, 0x10081028, 0x10047ff8, 0x00001002, // ICON_CROP
+ 0x00100000, 0x3ffc0010, 0x2ab03550, 0x22b02550, 0x20b02150, 0x20302050, 0x2000fff0, 0x00002000, // ICON_CROP_ALPHA
+ 0x40000000, 0x1ff82000, 0x04082808, 0x01082208, 0x00482088, 0x00182028, 0x35542008, 0x00000002, // ICON_SQUARE_TOGGLE
+ 0x00000000, 0x02800280, 0x06c006c0, 0x0ea00ee0, 0x1e901eb0, 0x3e883e98, 0x7efc7e8c, 0x00000000, // ICON_SYMMETRY
+ 0x01000000, 0x05600100, 0x1d480d50, 0x7d423d44, 0x3d447d42, 0x0d501d48, 0x01000560, 0x00000100, // ICON_SYMMETRY_HORIZONTAL
+ 0x01800000, 0x04200240, 0x10080810, 0x00001ff8, 0x00007ffe, 0x0ff01ff8, 0x03c007e0, 0x00000180, // ICON_SYMMETRY_VERTICAL
+ 0x00000000, 0x010800f0, 0x02040204, 0x02040204, 0x07f00308, 0x1c000e00, 0x30003800, 0x00000000, // ICON_LENS
+ 0x00000000, 0x061803f0, 0x08240c0c, 0x08040814, 0x0c0c0804, 0x23f01618, 0x18002400, 0x00000000, // ICON_LENS_BIG
+ 0x00000000, 0x00000000, 0x1c7007c0, 0x638e3398, 0x1c703398, 0x000007c0, 0x00000000, 0x00000000, // ICON_EYE_ON
+ 0x00000000, 0x10002000, 0x04700fc0, 0x610e3218, 0x1c703098, 0x001007a0, 0x00000008, 0x00000000, // ICON_EYE_OFF
+ 0x00000000, 0x00007ffc, 0x40047ffc, 0x10102008, 0x04400820, 0x02800280, 0x02800280, 0x00000100, // ICON_FILTER_TOP
+ 0x00000000, 0x40027ffe, 0x10082004, 0x04200810, 0x02400240, 0x02400240, 0x01400240, 0x000000c0, // ICON_FILTER
+ 0x00800000, 0x00800080, 0x00000080, 0x3c9e0000, 0x00000000, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_POINT
+ 0x00800000, 0x00800080, 0x00800080, 0x3f7e01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_SMALL
+ 0x00800000, 0x00800080, 0x03e00080, 0x3e3e0220, 0x03e00220, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_BIG
+ 0x01000000, 0x04400280, 0x01000100, 0x43842008, 0x43849ab2, 0x01002008, 0x04400100, 0x01000280, // ICON_TARGET_MOVE
+ 0x01000000, 0x04400280, 0x01000100, 0x41042108, 0x41049ff2, 0x01002108, 0x04400100, 0x01000280, // ICON_CURSOR_MOVE
+ 0x781e0000, 0x500a4002, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x4002500a, 0x0000781e, // ICON_CURSOR_SCALE
+ 0x00000000, 0x20003c00, 0x24002800, 0x01000200, 0x00400080, 0x00140024, 0x003c0004, 0x00000000, // ICON_CURSOR_SCALE_RIGHT
+ 0x00000000, 0x0004003c, 0x00240014, 0x00800040, 0x02000100, 0x28002400, 0x3c002000, 0x00000000, // ICON_CURSOR_SCALE_LEFT
+ 0x00000000, 0x00100020, 0x10101fc8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // ICON_UNDO
+ 0x00000000, 0x08000400, 0x080813f8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // ICON_REDO
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3f902020, 0x00400020, 0x00000000, // ICON_REREDO
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3fc82010, 0x00200010, 0x00000000, // ICON_MUTATE
+ 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18101020, 0x00100fc8, 0x00000020, // ICON_ROTATE
+ 0x00000000, 0x04000200, 0x240429fc, 0x20042204, 0x20442004, 0x3f942024, 0x00400020, 0x00000000, // ICON_REPEAT
+ 0x00000000, 0x20001000, 0x22104c0e, 0x00801120, 0x11200040, 0x4c0e2210, 0x10002000, 0x00000000, // ICON_SHUFFLE
+ 0x7ffe0000, 0x50024002, 0x44024802, 0x41024202, 0x40424082, 0x40124022, 0x4002400a, 0x00007ffe, // ICON_EMPTYBOX
+ 0x00800000, 0x03e00080, 0x08080490, 0x3c9e0808, 0x08080808, 0x03e00490, 0x00800080, 0x00000000, // ICON_TARGET
+ 0x00800000, 0x00800080, 0x00800080, 0x3ffe01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_SMALL_FILL
+ 0x00800000, 0x00800080, 0x03e00080, 0x3ffe03e0, 0x03e003e0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_BIG_FILL
+ 0x01000000, 0x07c00380, 0x01000100, 0x638c2008, 0x638cfbbe, 0x01002008, 0x07c00100, 0x01000380, // ICON_TARGET_MOVE_FILL
+ 0x01000000, 0x07c00380, 0x01000100, 0x610c2108, 0x610cfffe, 0x01002108, 0x07c00100, 0x01000380, // ICON_CURSOR_MOVE_FILL
+ 0x781e0000, 0x6006700e, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x700e6006, 0x0000781e, // ICON_CURSOR_SCALE_FILL
+ 0x00000000, 0x38003c00, 0x24003000, 0x01000200, 0x00400080, 0x000c0024, 0x003c001c, 0x00000000, // ICON_CURSOR_SCALE_RIGHT_FILL
+ 0x00000000, 0x001c003c, 0x0024000c, 0x00800040, 0x02000100, 0x30002400, 0x3c003800, 0x00000000, // ICON_CURSOR_SCALE_LEFT_FILL
+ 0x00000000, 0x00300020, 0x10301ff8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // ICON_UNDO_FILL
+ 0x00000000, 0x0c000400, 0x0c081ff8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // ICON_REDO_FILL
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3ff02060, 0x00400060, 0x00000000, // ICON_REREDO_FILL
+ 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3ff82030, 0x00200030, 0x00000000, // ICON_MUTATE_FILL
+ 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18301020, 0x00300ff8, 0x00000020, // ICON_ROTATE_FILL
+ 0x00000000, 0x06000200, 0x26042ffc, 0x20042204, 0x20442004, 0x3ff42064, 0x00400060, 0x00000000, // ICON_REPEAT_FILL
+ 0x00000000, 0x30001000, 0x32107c0e, 0x00801120, 0x11200040, 0x7c0e3210, 0x10003000, 0x00000000, // ICON_SHUFFLE_FILL
+ 0x00000000, 0x30043ffc, 0x24042804, 0x21042204, 0x20442084, 0x20142024, 0x3ffc200c, 0x00000000, // ICON_EMPTYBOX_SMALL
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX
+ 0x00000000, 0x23c43ffc, 0x23c423c4, 0x200423c4, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP
+ 0x00000000, 0x3e043ffc, 0x3e043e04, 0x20043e04, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x3e043e04, 0x3e043e04, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x3e042004, 0x3e043e04, 0x3ffc3e04, 0x00000000, // ICON_BOX_BOTTOM_RIGHT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x23c42004, 0x23c423c4, 0x3ffc23c4, 0x00000000, // ICON_BOX_BOTTOM
+ 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x207c2004, 0x207c207c, 0x3ffc207c, 0x00000000, // ICON_BOX_BOTTOM_LEFT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x207c207c, 0x207c207c, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_LEFT
+ 0x00000000, 0x207c3ffc, 0x207c207c, 0x2004207c, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP_LEFT
+ 0x00000000, 0x20043ffc, 0x20042004, 0x23c423c4, 0x23c423c4, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_CENTER
+ 0x7ffe0000, 0x40024002, 0x47e24182, 0x4ff247e2, 0x47e24ff2, 0x418247e2, 0x40024002, 0x00007ffe, // ICON_BOX_CIRCLE_MASK
+ 0x7fff0000, 0x40014001, 0x40014001, 0x49555ddd, 0x4945495d, 0x400149c5, 0x40014001, 0x00007fff, // ICON_POT
+ 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x404e40ce, 0x48125432, 0x4006540e, 0x00007ffe, // ICON_ALPHA_MULTIPLY
+ 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x5c4e40ce, 0x44124432, 0x40065c0e, 0x00007ffe, // ICON_ALPHA_CLEAR
+ 0x7ffe0000, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x00007ffe, // ICON_DITHERING
+ 0x07fe0000, 0x1ffa0002, 0x7fea000a, 0x402a402a, 0x5b2a512a, 0x5128552a, 0x40205128, 0x00007fe0, // ICON_MIPMAPS
+ 0x00000000, 0x1ff80000, 0x12481248, 0x12481ff8, 0x1ff81248, 0x12481248, 0x00001ff8, 0x00000000, // ICON_BOX_GRID
+ 0x12480000, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x00001248, // ICON_GRID
+ 0x00000000, 0x1c380000, 0x1c3817e8, 0x08100810, 0x08100810, 0x17e81c38, 0x00001c38, 0x00000000, // ICON_BOX_CORNERS_SMALL
+ 0x700e0000, 0x700e5ffa, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x5ffa700e, 0x0000700e, // ICON_BOX_CORNERS_BIG
+ 0x3f7e0000, 0x21422142, 0x21422142, 0x00003f7e, 0x21423f7e, 0x21422142, 0x3f7e2142, 0x00000000, // ICON_FOUR_BOXES
+ 0x00000000, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x00000000, // ICON_GRID_FILL
+ 0x7ffe0000, 0x7ffe7ffe, 0x77fe7000, 0x77fe77fe, 0x777e7700, 0x777e777e, 0x777e777e, 0x0000777e, // ICON_BOX_MULTISIZE
+ 0x781e0000, 0x40024002, 0x00004002, 0x01800000, 0x00000180, 0x40020000, 0x40024002, 0x0000781e, // ICON_ZOOM_SMALL
+ 0x781e0000, 0x40024002, 0x00004002, 0x03c003c0, 0x03c003c0, 0x40020000, 0x40024002, 0x0000781e, // ICON_ZOOM_MEDIUM
+ 0x781e0000, 0x40024002, 0x07e04002, 0x07e007e0, 0x07e007e0, 0x400207e0, 0x40024002, 0x0000781e, // ICON_ZOOM_BIG
+ 0x781e0000, 0x5ffa4002, 0x1ff85ffa, 0x1ff81ff8, 0x1ff81ff8, 0x5ffa1ff8, 0x40025ffa, 0x0000781e, // ICON_ZOOM_ALL
+ 0x00000000, 0x2004381c, 0x00002004, 0x00000000, 0x00000000, 0x20040000, 0x381c2004, 0x00000000, // ICON_ZOOM_CENTER
+ 0x00000000, 0x1db80000, 0x10081008, 0x10080000, 0x00001008, 0x10081008, 0x00001db8, 0x00000000, // ICON_BOX_DOTS_SMALL
+ 0x35560000, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x35562002, 0x00000000, // ICON_BOX_DOTS_BIG
+ 0x7ffe0000, 0x40024002, 0x48124ff2, 0x49924812, 0x48124992, 0x4ff24812, 0x40024002, 0x00007ffe, // ICON_BOX_CONCENTRIC
+ 0x00000000, 0x10841ffc, 0x10841084, 0x1ffc1084, 0x10841084, 0x10841084, 0x00001ffc, 0x00000000, // ICON_BOX_GRID_BIG
+ 0x00000000, 0x00000000, 0x10000000, 0x04000800, 0x01040200, 0x00500088, 0x00000020, 0x00000000, // ICON_OK_TICK
+ 0x00000000, 0x10080000, 0x04200810, 0x01800240, 0x02400180, 0x08100420, 0x00001008, 0x00000000, // ICON_CROSS
+ 0x00000000, 0x02000000, 0x00800100, 0x00200040, 0x00200010, 0x00800040, 0x02000100, 0x00000000, // ICON_ARROW_LEFT
+ 0x00000000, 0x00400000, 0x01000080, 0x04000200, 0x04000800, 0x01000200, 0x00400080, 0x00000000, // ICON_ARROW_RIGHT
+ 0x00000000, 0x00000000, 0x00000000, 0x08081004, 0x02200410, 0x00800140, 0x00000000, 0x00000000, // ICON_ARROW_DOWN
+ 0x00000000, 0x00000000, 0x01400080, 0x04100220, 0x10040808, 0x00000000, 0x00000000, 0x00000000, // ICON_ARROW_UP
+ 0x00000000, 0x02000000, 0x03800300, 0x03e003c0, 0x03e003f0, 0x038003c0, 0x02000300, 0x00000000, // ICON_ARROW_LEFT_FILL
+ 0x00000000, 0x00400000, 0x01c000c0, 0x07c003c0, 0x07c00fc0, 0x01c003c0, 0x004000c0, 0x00000000, // ICON_ARROW_RIGHT_FILL
+ 0x00000000, 0x00000000, 0x00000000, 0x0ff81ffc, 0x03e007f0, 0x008001c0, 0x00000000, 0x00000000, // ICON_ARROW_DOWN_FILL
+ 0x00000000, 0x00000000, 0x01c00080, 0x07f003e0, 0x1ffc0ff8, 0x00000000, 0x00000000, 0x00000000, // ICON_ARROW_UP_FILL
+ 0x00000000, 0x18a008c0, 0x32881290, 0x24822686, 0x26862482, 0x12903288, 0x08c018a0, 0x00000000, // ICON_AUDIO
+ 0x00000000, 0x04800780, 0x004000c0, 0x662000f0, 0x08103c30, 0x130a0e18, 0x0000318e, 0x00000000, // ICON_FX
+ 0x00000000, 0x00800000, 0x08880888, 0x2aaa0a8a, 0x0a8a2aaa, 0x08880888, 0x00000080, 0x00000000, // ICON_WAVE
+ 0x00000000, 0x00600000, 0x01080090, 0x02040108, 0x42044204, 0x24022402, 0x00001800, 0x00000000, // ICON_WAVE_SINUS
+ 0x00000000, 0x07f80000, 0x04080408, 0x04080408, 0x04080408, 0x7c0e0408, 0x00000000, 0x00000000, // ICON_WAVE_SQUARE
+ 0x00000000, 0x00000000, 0x00a00040, 0x22084110, 0x08021404, 0x00000000, 0x00000000, 0x00000000, // ICON_WAVE_TRIANGULAR
+ 0x00000000, 0x00000000, 0x04200000, 0x01800240, 0x02400180, 0x00000420, 0x00000000, 0x00000000, // ICON_CROSS_SMALL
+ 0x00000000, 0x18380000, 0x12281428, 0x10a81128, 0x112810a8, 0x14281228, 0x00001838, 0x00000000, // ICON_PLAYER_PREVIOUS
+ 0x00000000, 0x18000000, 0x11801600, 0x10181060, 0x10601018, 0x16001180, 0x00001800, 0x00000000, // ICON_PLAYER_PLAY_BACK
+ 0x00000000, 0x00180000, 0x01880068, 0x18080608, 0x06081808, 0x00680188, 0x00000018, 0x00000000, // ICON_PLAYER_PLAY
+ 0x00000000, 0x1e780000, 0x12481248, 0x12481248, 0x12481248, 0x12481248, 0x00001e78, 0x00000000, // ICON_PLAYER_PAUSE
+ 0x00000000, 0x1ff80000, 0x10081008, 0x10081008, 0x10081008, 0x10081008, 0x00001ff8, 0x00000000, // ICON_PLAYER_STOP
+ 0x00000000, 0x1c180000, 0x14481428, 0x15081488, 0x14881508, 0x14281448, 0x00001c18, 0x00000000, // ICON_PLAYER_NEXT
+ 0x00000000, 0x03c00000, 0x08100420, 0x10081008, 0x10081008, 0x04200810, 0x000003c0, 0x00000000, // ICON_PLAYER_RECORD
+ 0x00000000, 0x0c3007e0, 0x13c81818, 0x14281668, 0x14281428, 0x1c381c38, 0x08102244, 0x00000000, // ICON_MAGNET
+ 0x07c00000, 0x08200820, 0x3ff80820, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // ICON_LOCK_CLOSE
+ 0x07c00000, 0x08000800, 0x3ff80800, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // ICON_LOCK_OPEN
+ 0x01c00000, 0x0c180770, 0x3086188c, 0x60832082, 0x60034781, 0x30062002, 0x0c18180c, 0x01c00770, // ICON_CLOCK
+ 0x0a200000, 0x1b201b20, 0x04200e20, 0x04200420, 0x04700420, 0x0e700e70, 0x0e700e70, 0x04200e70, // ICON_TOOLS
+ 0x01800000, 0x3bdc318c, 0x0ff01ff8, 0x7c3e1e78, 0x1e787c3e, 0x1ff80ff0, 0x318c3bdc, 0x00000180, // ICON_GEAR
+ 0x01800000, 0x3ffc318c, 0x1c381ff8, 0x781e1818, 0x1818781e, 0x1ff81c38, 0x318c3ffc, 0x00000180, // ICON_GEAR_BIG
+ 0x00000000, 0x08080ff8, 0x08081ffc, 0x0aa80aa8, 0x0aa80aa8, 0x0aa80aa8, 0x08080aa8, 0x00000ff8, // ICON_BIN
+ 0x00000000, 0x00000000, 0x20043ffc, 0x08043f84, 0x04040f84, 0x04040784, 0x000007fc, 0x00000000, // ICON_HAND_POINTER
+ 0x00000000, 0x24400400, 0x00001480, 0x6efe0e00, 0x00000e00, 0x24401480, 0x00000400, 0x00000000, // ICON_LASER
+ 0x00000000, 0x03c00000, 0x08300460, 0x11181118, 0x11181118, 0x04600830, 0x000003c0, 0x00000000, // ICON_COIN
+ 0x00000000, 0x10880080, 0x06c00810, 0x366c07e0, 0x07e00240, 0x00001768, 0x04200240, 0x00000000, // ICON_EXPLOSION
+ 0x00000000, 0x3d280000, 0x2528252c, 0x3d282528, 0x05280528, 0x05e80528, 0x00000000, 0x00000000, // ICON_1UP
+ 0x01800000, 0x03c003c0, 0x018003c0, 0x0ff007e0, 0x0bd00bd0, 0x0a500bd0, 0x02400240, 0x02400240, // ICON_PLAYER
+ 0x01800000, 0x03c003c0, 0x118013c0, 0x03c81ff8, 0x07c003c8, 0x04400440, 0x0c080478, 0x00000000, // ICON_PLAYER_JUMP
+ 0x3ff80000, 0x30183ff8, 0x30183018, 0x3ff83ff8, 0x03000300, 0x03c003c0, 0x03e00300, 0x000003e0, // ICON_KEY
+ 0x3ff80000, 0x3ff83ff8, 0x33983ff8, 0x3ff83398, 0x3ff83ff8, 0x00000540, 0x0fe00aa0, 0x00000fe0, // ICON_DEMON
+ 0x00000000, 0x0ff00000, 0x20041008, 0x25442004, 0x10082004, 0x06000bf0, 0x00000300, 0x00000000, // ICON_TEXT_POPUP
+ 0x00000000, 0x11440000, 0x07f00be8, 0x1c1c0e38, 0x1c1c0c18, 0x07f00e38, 0x11440be8, 0x00000000, // ICON_GEAR_EX
+ 0x00000000, 0x20080000, 0x0c601010, 0x07c00fe0, 0x07c007c0, 0x0c600fe0, 0x20081010, 0x00000000, // ICON_CRACK
+ 0x00000000, 0x20080000, 0x0c601010, 0x04400fe0, 0x04405554, 0x0c600fe0, 0x20081010, 0x00000000, // ICON_CRACK_POINTS
+ 0x00000000, 0x00800080, 0x01c001c0, 0x1ffc3ffe, 0x03e007f0, 0x07f003e0, 0x0c180770, 0x00000808, // ICON_STAR
+ 0x0ff00000, 0x08180810, 0x08100818, 0x0a100810, 0x08180810, 0x08100818, 0x08100810, 0x00001ff8, // ICON_DOOR
+ 0x0ff00000, 0x08100810, 0x08100810, 0x10100010, 0x4f902010, 0x10102010, 0x08100010, 0x00000ff0, // ICON_EXIT
+ 0x00040000, 0x001f000e, 0x0ef40004, 0x12f41284, 0x0ef41214, 0x10040004, 0x7ffc3004, 0x10003000, // ICON_MODE_2D
+ 0x78040000, 0x501f600e, 0x0ef44004, 0x12f41284, 0x0ef41284, 0x10140004, 0x7ffc300c, 0x10003000, // ICON_MODE_3D
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // ICON_CUBE
+ 0x7fe00000, 0x5ff87ff0, 0x47fe4ffc, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // ICON_CUBE_FACE_TOP
+ 0x7fe00000, 0x50386030, 0x47fe483c, 0x443e443e, 0x443e443e, 0x241e75fe, 0x0c06140e, 0x000007fe, // ICON_CUBE_FACE_LEFT
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x47fe47fe, 0x47fe47fe, 0x27fe77fe, 0x0ffe17fe, 0x000007fe, // ICON_CUBE_FACE_FRONT
+ 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x3ff27fe2, 0x0ffe1ffa, 0x000007fe, // ICON_CUBE_FACE_BOTTOM
+ 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // ICON_CUBE_FACE_RIGHT
+ 0x7fe00000, 0x7fe87ff0, 0x7ffe7fe4, 0x7fe27fe2, 0x7fe27fe2, 0x24127fe2, 0x0c06140a, 0x000007fe, // ICON_CUBE_FACE_BACK
+ 0x00000000, 0x2a0233fe, 0x22022602, 0x22022202, 0x2a022602, 0x00a033fe, 0x02080110, 0x00000000, // ICON_CAMERA
+ 0x00000000, 0x200c3ffc, 0x000c000c, 0x3ffc000c, 0x30003000, 0x30003000, 0x3ffc3004, 0x00000000, // ICON_SPECIAL
+ 0x00000000, 0x0022003e, 0x012201e2, 0x0100013e, 0x01000100, 0x79000100, 0x4f004900, 0x00007800, // ICON_LINK_NET
+ 0x00000000, 0x44007c00, 0x45004600, 0x00627cbe, 0x00620022, 0x45007cbe, 0x44004600, 0x00007c00, // ICON_LINK_BOXES
+ 0x00000000, 0x0044007c, 0x0010007c, 0x3f100010, 0x3f1021f0, 0x3f100010, 0x3f0021f0, 0x00000000, // ICON_LINK_MULTI
+ 0x00000000, 0x0044007c, 0x00440044, 0x0010007c, 0x00100010, 0x44107c10, 0x440047f0, 0x00007c00, // ICON_LINK
+ 0x00000000, 0x0044007c, 0x00440044, 0x0000007c, 0x00000010, 0x44007c10, 0x44004550, 0x00007c00, // ICON_LINK_BROKE
+ 0x02a00000, 0x22a43ffc, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // ICON_TEXT_NOTES
+ 0x3ffc0000, 0x20042004, 0x245e27c4, 0x27c42444, 0x2004201e, 0x201e2004, 0x20042004, 0x00003ffc, // ICON_NOTEBOOK
+ 0x00000000, 0x07e00000, 0x04200420, 0x24243ffc, 0x24242424, 0x24242424, 0x3ffc2424, 0x00000000, // ICON_SUITCASE
+ 0x00000000, 0x0fe00000, 0x08200820, 0x40047ffc, 0x7ffc5554, 0x40045554, 0x7ffc4004, 0x00000000, // ICON_SUITCASE_ZIP
+ 0x00000000, 0x20043ffc, 0x3ffc2004, 0x13c81008, 0x100813c8, 0x10081008, 0x1ff81008, 0x00000000, // ICON_MAILBOX
+ 0x00000000, 0x40027ffe, 0x5ffa5ffa, 0x5ffa5ffa, 0x40025ffa, 0x03c07ffe, 0x1ff81ff8, 0x00000000, // ICON_MONITOR
+ 0x0ff00000, 0x6bfe7ffe, 0x7ffe7ffe, 0x68167ffe, 0x08106816, 0x08100810, 0x0ff00810, 0x00000000, // ICON_PRINTER
+ 0x3ff80000, 0xfffe2008, 0x870a8002, 0x904a888a, 0x904a904a, 0x870a888a, 0xfffe8002, 0x00000000, // ICON_PHOTO_CAMERA
+ 0x0fc00000, 0xfcfe0cd8, 0x8002fffe, 0x84428382, 0x84428442, 0x80028382, 0xfffe8002, 0x00000000, // ICON_PHOTO_CAMERA_FLASH
+ 0x00000000, 0x02400180, 0x08100420, 0x20041008, 0x23c42004, 0x22442244, 0x3ffc2244, 0x00000000, // ICON_HOUSE
+ 0x00000000, 0x1c700000, 0x3ff83ef8, 0x3ff83ff8, 0x0fe01ff0, 0x038007c0, 0x00000100, 0x00000000, // ICON_HEART
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0xe000c000, // ICON_CORNER
+ 0x00000000, 0x14001c00, 0x15c01400, 0x15401540, 0x155c1540, 0x15541554, 0x1ddc1554, 0x00000000, // ICON_VERTICAL_BARS
+ 0x00000000, 0x03000300, 0x1b001b00, 0x1b601b60, 0x1b6c1b60, 0x1b6c1b6c, 0x1b6c1b6c, 0x00000000, // ICON_VERTICAL_BARS_FILL
+ 0x00000000, 0x00000000, 0x403e7ffe, 0x7ffe403e, 0x7ffe0000, 0x43fe43fe, 0x00007ffe, 0x00000000, // ICON_LIFE_BARS
+ 0x7ffc0000, 0x43844004, 0x43844284, 0x43844004, 0x42844284, 0x42844284, 0x40044384, 0x00007ffc, // ICON_INFO
+ 0x40008000, 0x10002000, 0x04000800, 0x01000200, 0x00400080, 0x00100020, 0x00040008, 0x00010002, // ICON_CROSSLINE
+ 0x00000000, 0x1ff01ff0, 0x18301830, 0x1f001830, 0x03001f00, 0x00000300, 0x03000300, 0x00000000, // ICON_HELP
+ 0x3ff00000, 0x2abc3550, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x00003ffc, // ICON_FILETYPE_ALPHA
+ 0x3ff00000, 0x201c2010, 0x22442184, 0x28142424, 0x29942814, 0x2ff42994, 0x20042004, 0x00003ffc, // ICON_FILETYPE_HOME
+ 0x07fe0000, 0x04020402, 0x7fe20402, 0x44224422, 0x44224422, 0x402047fe, 0x40204020, 0x00007fe0, // ICON_LAYERS_VISIBLE
+ 0x07fe0000, 0x04020402, 0x7c020402, 0x44024402, 0x44024402, 0x402047fe, 0x40204020, 0x00007fe0, // ICON_LAYERS
+ 0x00000000, 0x40027ffe, 0x7ffe4002, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_WINDOW
+ 0x09100000, 0x09f00910, 0x09100910, 0x00000910, 0x24a2779e, 0x27a224a2, 0x709e20a2, 0x00000000, // ICON_HIDPI
+ 0x3ff00000, 0x201c2010, 0x2a842e84, 0x2e842a84, 0x2ba42004, 0x2aa42aa4, 0x20042ba4, 0x00003ffc, // ICON_FILETYPE_BINARY
+ 0x00000000, 0x00000000, 0x00120012, 0x4a5e4bd2, 0x485233d2, 0x00004bd2, 0x00000000, 0x00000000, // ICON_HEX
+ 0x01800000, 0x381c0660, 0x23c42004, 0x23c42044, 0x13c82204, 0x08101008, 0x02400420, 0x00000180, // ICON_SHIELD
+ 0x007e0000, 0x20023fc2, 0x40227fe2, 0x400a403a, 0x400a400a, 0x400a400a, 0x4008400e, 0x00007ff8, // ICON_FILE_NEW
+ 0x00000000, 0x0042007e, 0x40027fc2, 0x44024002, 0x5f024402, 0x44024402, 0x7ffe4002, 0x00000000, // ICON_FOLDER_ADD
+ 0x44220000, 0x12482244, 0xf3cf0000, 0x14280420, 0x48122424, 0x08100810, 0x1ff81008, 0x03c00420, // ICON_ALARM
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_206
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_207
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_208
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_209
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_210
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_211
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_212
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_213
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_214
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_215
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_216
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_217
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_218
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_219
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_220
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_221
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_222
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_223
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_224
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_225
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_226
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_227
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_228
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_229
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_230
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_231
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_232
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_233
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_234
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_235
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_236
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_237
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_238
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_239
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_240
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_241
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_242
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_243
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_244
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_245
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_246
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_247
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_248
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_249
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_250
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_251
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_252
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_253
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_254
+ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_255
};
-#endif // RAYGUI_CUSTOM_RICONS
+#endif // !RAYGUI_NO_ICONS && !RAYGUI_CUSTOM_ICONS
-#endif // !RAYGUI_NO_RICONS
-
-#ifndef RICON_SIZE
- #define RICON_SIZE 0
+#ifndef RAYGUI_ICON_SIZE
+ #define RAYGUI_ICON_SIZE 0
#endif
#define RAYGUI_MAX_CONTROLS 16 // Maximum number of standard controls
@@ -1146,11 +1152,13 @@ typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement;
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
-static GuiControlState guiState = GUI_STATE_NORMAL;
+static GuiState guiState = STATE_NORMAL; // Gui global state, if !STATE_NORMAL, forces defined state
-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
+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
+
+static unsigned int guiIconScale = 1; // Gui icon default scale (if icons enabled)
//----------------------------------------------------------------------------------
// Style data array for all gui style properties (allocated on data segment by default)
@@ -1166,7 +1174,7 @@ static float guiAlpha = 1.0f; // Gui element transpacency on drawing
//----------------------------------------------------------------------------------
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
+static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization
//----------------------------------------------------------------------------------
// Standalone Mode Functions Declaration
@@ -1245,18 +1253,22 @@ static const char *GetTextIcon(const char *text, int *iconId); // Get text icon
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 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
+static int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue); // Scroll bar control, used by GuiScrollPanel()
+
//----------------------------------------------------------------------------------
// Gui Setup Functions Definition
//----------------------------------------------------------------------------------
// Enable gui global state
-void GuiEnable(void) { guiState = GUI_STATE_NORMAL; }
+// NOTE: We check for STATE_DISABLED to avoid messing custom global state setups
+void GuiEnable(void) { if (guiState == STATE_DISABLED) guiState = STATE_NORMAL; }
// Disable gui global state
-void GuiDisable(void) { guiState = GUI_STATE_DISABLED; }
+// NOTE: We check for STATE_NORMAL to avoid messing custom global state setups
+void GuiDisable(void) { if (guiState == STATE_NORMAL) guiState = STATE_DISABLED; }
// Lock gui global state
void GuiLock(void) { guiLocked = true; }
@@ -1277,7 +1289,7 @@ void GuiFade(float alpha)
}
// Set gui state (global state)
-void GuiSetState(int state) { guiState = (GuiControlState)state; }
+void GuiSetState(int state) { guiState = (GuiState)state; }
// Get gui state (global state)
int GuiGetState(void) { return guiState; }
@@ -1331,19 +1343,21 @@ int GuiGetStyle(int control, int property)
// Window Box control
bool GuiWindowBox(Rectangle bounds, const char *title)
{
+ // Window title bar height (including borders)
// NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox()
- #define WINDOW_STATUSBAR_HEIGHT 22
+ #if !defined(RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT)
+ #define RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT 24
+ #endif
- //GuiControlState state = guiState;
+ //GuiState state = guiState;
bool clicked = false;
- int statusBarHeight = WINDOW_STATUSBAR_HEIGHT + 2*GuiGetStyle(STATUSBAR, BORDER_WIDTH);
- statusBarHeight += (statusBarHeight%2);
+ int statusBarHeight = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT;
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 windowPanel = { bounds.x, bounds.y + (float)statusBarHeight - 1, bounds.width, bounds.height - (float)statusBarHeight + 1 };
Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20,
statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 };
@@ -1355,17 +1369,17 @@ bool GuiWindowBox(Rectangle bounds, const char *title)
// Draw control
//--------------------------------------------------------------------
GuiStatusBar(statusBar, title); // Draw window header as status bar
- GuiPanel(windowPanel); // Draw window base
+ GuiPanel(windowPanel, NULL); // 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)
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER);
+#if defined(RAYGUI_NO_ICONS)
clicked = GuiButton(closeButtonRec, "x");
#else
- clicked = GuiButton(closeButtonRec, GuiIconText(RICON_CROSS_SMALL, NULL));
+ clicked = GuiButton(closeButtonRec, GuiIconText(ICON_CROSS_SMALL, NULL));
#endif
GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth);
GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment);
@@ -1377,29 +1391,35 @@ bool GuiWindowBox(Rectangle bounds, const char *title)
// Group Box control with text name
void GuiGroupBox(Rectangle bounds, const char *text)
{
- #define GROUPBOX_LINE_THICK 1
- #define GROUPBOX_TEXT_PADDING 10
+ #if !defined(RAYGUI_GROUPBOX_LINE_THICK)
+ #define RAYGUI_GROUPBOX_LINE_THICK 1
+ #endif
- GuiControlState state = guiState;
+ GuiState 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));
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, RAYGUI_GROUPBOX_LINE_THICK }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha));
- GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, bounds.width, 1 }, text);
+ GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y - GuiGetStyle(DEFAULT, TEXT_SIZE)/2, bounds.width, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) }, text);
//--------------------------------------------------------------------
}
// Line control
void GuiLine(Rectangle bounds, const char *text)
{
- #define LINE_TEXT_PADDING 10
+ #if !defined(RAYGUI_LINE_ORIGIN_SIZE)
+ #define RAYGUI_LINE_MARGIN_TEXT 12
+ #endif
+ #if !defined(RAYGUI_LINE_TEXT_PADDING)
+ #define RAYGUI_LINE_TEXT_PADDING 4
+ #endif
- GuiControlState state = guiState;
+ GuiState state = guiState;
- Color color = Fade(GetColor(GuiGetStyle(DEFAULT, (state == GUI_STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha);
+ Color color = Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)), guiAlpha);
// Draw control
//--------------------------------------------------------------------
@@ -1408,40 +1428,66 @@ void GuiLine(Rectangle bounds, const char *text)
{
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;
+ textBounds.height = bounds.height;
+ textBounds.x = bounds.x + RAYGUI_LINE_MARGIN_TEXT;
+ textBounds.y = bounds.y;
// 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);
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, RAYGUI_LINE_MARGIN_TEXT - RAYGUI_LINE_TEXT_PADDING, 1 }, 0, BLANK, color);
+ GuiDrawText(text, textBounds, TEXT_ALIGN_LEFT, color);
+ GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + 12 + textBounds.width + 4, bounds.y + bounds.height/2, bounds.width - textBounds.width - RAYGUI_LINE_MARGIN_TEXT - RAYGUI_LINE_TEXT_PADDING, 1 }, 0, BLANK, color);
}
//--------------------------------------------------------------------
}
// Panel control
-void GuiPanel(Rectangle bounds)
+void GuiPanel(Rectangle bounds, const char *text)
{
- #define PANEL_BORDER_WIDTH 1
+ #if !defined(RAYGUI_PANEL_BORDER_WIDTH)
+ #define RAYGUI_PANEL_BORDER_WIDTH 1
+ #endif
- GuiControlState state = guiState;
+ GuiState state = guiState;
+
+ // Text will be drawn as a header bar (if provided)
+ Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT };
+ if ((text != NULL) && (bounds.height < RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f)) bounds.height = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f;
+
+ if (text != NULL)
+ {
+ // Move panel bounds after the header bar
+ bounds.y += (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 1;
+ bounds.height -= (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + 1;
+ }
// 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));
+ if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar
+
+ GuiDrawRectangle(bounds, RAYGUI_PANEL_BORDER_WIDTH, Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), guiAlpha),
+ Fade(GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR)), guiAlpha));
//--------------------------------------------------------------------
}
// Scroll Panel control
-Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
+Rectangle GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
Vector2 scrollPos = { 0.0f, 0.0f };
if (scroll != NULL) scrollPos = *scroll;
+ // Text will be drawn as a header bar (if provided)
+ Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT };
+ if (bounds.height < RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f) bounds.height = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f;
+
+ if (text != NULL)
+ {
+ // Move panel bounds after the header bar
+ bounds.y += (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 1;
+ bounds.height -= (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + 1;
+ }
+
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;
@@ -1449,10 +1495,10 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
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) };
+ int horizontalScrollBarWidth = hasHorizontalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0;
+ int verticalScrollBarWidth = hasVerticalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0;
+ 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 };
+ 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)?
@@ -1463,23 +1509,24 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
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);
+ 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);
+ 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);
+ float verticalMin = hasVerticalScrollBar? 0 : -1;
+ 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)
+ if ((state != 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 (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
+#if defined(SUPPORT_SCROLLBAR_KEY_INPUT)
if (hasHorizontalScrollBar)
{
if (IsKeyDown(KEY_RIGHT)) scrollPos.x -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
@@ -1491,11 +1538,11 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED);
}
-
+#endif
float wheelMove = GetMouseWheelMove();
// Horizontal scroll (Shift + Mouse wheel)
- if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT))) scrollPos.x += wheelMove*20;
+ if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_RIGHT_SHIFT))) scrollPos.x += wheelMove*20;
else scrollPos.y += wheelMove*20; // Vertical scroll
}
}
@@ -1509,6 +1556,8 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
// Draw control
//--------------------------------------------------------------------
+ if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar
+
GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background
// Save size of the scrollbar slider
@@ -1521,6 +1570,7 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
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);
}
+ else scrollPos.x = 0.0f;
// Draw vertical scrollbar if visible
if (hasVerticalScrollBar)
@@ -1529,11 +1579,12 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
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);
}
+ else scrollPos.y = 0.0f;
// 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 };
+ 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));
}
@@ -1552,7 +1603,7 @@ Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll)
// Label control
void GuiLabel(Rectangle bounds, const char *text)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
// Update control
//--------------------------------------------------------------------
@@ -1561,27 +1612,27 @@ void GuiLabel(Rectangle bounds, const char *text)
// 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));
+ GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
//--------------------------------------------------------------------
}
// Button control, returns true when clicked
bool GuiButton(Rectangle bounds, const char *text)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
bool pressed = false;
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != 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 (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
}
@@ -1600,7 +1651,7 @@ bool GuiButton(Rectangle bounds, const char *text)
// Label button control
bool GuiLabelButton(Rectangle bounds, const char *text)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
bool pressed = false;
// NOTE: We force bounds.width to be all text
@@ -1609,15 +1660,15 @@ bool GuiLabelButton(Rectangle bounds, const char *text)
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != 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 (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
}
@@ -1635,31 +1686,31 @@ bool GuiLabelButton(Rectangle bounds, const char *text)
// Toggle Button control, returns true when active
bool GuiToggle(Rectangle bounds, const char *text, bool active)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
// Check toggle button state
if (CheckCollisionPointRec(mousePoint, bounds))
{
- if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON))
{
- state = GUI_STATE_NORMAL;
+ state = STATE_NORMAL;
active = !active;
}
- else state = GUI_STATE_FOCUSED;
+ else state = STATE_FOCUSED;
}
}
//--------------------------------------------------------------------
// Draw control
//--------------------------------------------------------------------
- if (state == GUI_STATE_NORMAL)
+ if (state == 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));
@@ -1677,14 +1728,14 @@ bool GuiToggle(Rectangle bounds, const char *text, bool 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
+ #if !defined(RAYGUI_TOGGLEGROUP_MAX_ITEMS)
+ #define RAYGUI_TOGGLEGROUP_MAX_ITEMS 32
#endif
float initBoundsX = bounds.x;
// Get substrings items from text (items pointers)
- int rows[TOGGLEGROUP_MAX_ELEMENTS] = { 0 };
+ int rows[RAYGUI_TOGGLEGROUP_MAX_ITEMS] = { 0 };
int itemCount = 0;
const char **items = GuiTextSplit(text, &itemCount, rows);
@@ -1711,7 +1762,7 @@ int GuiToggleGroup(Rectangle bounds, const char *text, int active)
// Check Box control, returns true when active
bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
Rectangle textBounds = { 0 };
@@ -1721,17 +1772,17 @@ bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
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);
+ if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING);
}
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
Rectangle totalBounds = {
- (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_LEFT)? textBounds.x : bounds.x,
+ (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT)? textBounds.x : bounds.x,
bounds.y,
bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING),
bounds.height,
@@ -1740,8 +1791,8 @@ bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
// Check checkbox state
if (CheckCollisionPointRec(mousePoint, totalBounds))
{
- if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
- else state = GUI_STATE_FOCUSED;
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) checked = !checked;
}
@@ -1761,7 +1812,7 @@ bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
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));
+ GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
//--------------------------------------------------------------------
return checked;
@@ -1770,11 +1821,11 @@ bool GuiCheckBox(Rectangle bounds, const char *text, bool checked)
// Combo Box control, returns selected item index
int GuiComboBox(Rectangle bounds, const char *text, int active)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
- bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING));
+ bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING));
- Rectangle selector = { (float)bounds.x + bounds.width + GuiGetStyle(COMBOBOX, COMBO_BUTTON_PADDING),
+ Rectangle selector = { (float)bounds.x + bounds.width + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING),
(float)bounds.y, (float)GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH), (float)bounds.height };
// Get substrings items from text (items pointers, lengths and count)
@@ -1786,7 +1837,7 @@ int GuiComboBox(Rectangle bounds, const char *text, int active)
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked && (itemCount > 1))
+ if ((state != STATE_DISABLED) && !guiLocked && (itemCount > 1))
{
Vector2 mousePoint = GetMousePosition();
@@ -1799,8 +1850,8 @@ int GuiComboBox(Rectangle bounds, const char *text, int active)
if (active >= itemCount) active = 0;
}
- if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
- else state = GUI_STATE_FOCUSED;
+ if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
}
}
//--------------------------------------------------------------------
@@ -1816,7 +1867,7 @@ int GuiComboBox(Rectangle bounds, const char *text, int active)
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);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER);
GuiButton(selector, TextFormat("%i/%i", active + 1, itemCount));
@@ -1831,7 +1882,7 @@ int GuiComboBox(Rectangle bounds, const char *text, int active)
// NOTE: Returns mouse click
bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
int itemSelected = *active;
int itemFocused = -1;
@@ -1840,7 +1891,7 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
const char **items = GuiTextSplit(text, &itemCount, NULL);
Rectangle boundsOpen = bounds;
- boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+ boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING));
Rectangle itemBounds = bounds;
@@ -1848,13 +1899,13 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1))
+ if ((state != STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1))
{
Vector2 mousePoint = GetMousePosition();
if (editMode)
{
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
// Check if mouse has been pressed or released outside limits
if (!CheckCollisionPointRec(mousePoint, boundsOpen))
@@ -1869,7 +1920,7 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
for (int i = 0; i < itemCount; i++)
{
// Update item rectangle y position for next item
- itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+ itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING));
if (CheckCollisionPointRec(mousePoint, itemBounds))
{
@@ -1892,9 +1943,9 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
{
pressed = true;
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
}
- else state = GUI_STATE_FOCUSED;
+ else state = STATE_FOCUSED;
}
}
}
@@ -1902,7 +1953,7 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
// Draw control
//--------------------------------------------------------------------
- if (editMode) GuiPanel(boundsOpen);
+ if (editMode) GuiPanel(boundsOpen, NULL);
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));
@@ -1913,7 +1964,7 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
for (int i = 0; i < itemCount; i++)
{
// Update item rectangle y position for next item
- itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING));
+ itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING));
if (i == itemSelected)
{
@@ -1930,12 +1981,12 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
}
// Draw arrows (using icon if available)
-#if defined(RAYGUI_NO_RICONS)
+#if defined(RAYGUI_NO_ICONS)
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));
+ 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
+ TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3))), guiAlpha)); // ICON_ARROW_DOWN_FILL
#endif
//--------------------------------------------------------------------
@@ -1947,7 +1998,7 @@ bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMo
// NOTE 2: Returns if KEY_ENTER pressed (useful for data validation)
bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
bool pressed = false;
Rectangle cursor = {
@@ -1957,31 +2008,31 @@ bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
(float)GuiGetStyle(DEFAULT, TEXT_SIZE)*2
};
- if (cursor.height > bounds.height) cursor.height = bounds.height - GuiGetStyle(TEXTBOX, BORDER_WIDTH)*2;
+ if (cursor.height >= bounds.height) cursor.height = bounds.height - GuiGetStyle(TEXTBOX, BORDER_WIDTH)*2;
+ if (cursor.y < (bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH))) cursor.y = bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH);
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
if (editMode)
{
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
int key = GetCharPressed(); // Returns codepoint as Unicode
int keyCount = (int)strlen(text);
+ int byteSize = 0;
+ const char *textUTF8 = CodepointToUTF8(key, &byteSize);
// Only allow keys in range [32..125]
- if (keyCount < (textSize - 1))
+ if ((keyCount + byteSize) < textSize)
{
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];
@@ -1997,7 +2048,7 @@ bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
{
if (IsKeyPressed(KEY_BACKSPACE))
{
- keyCount--;
+ while ((keyCount > 0) && ((text[--keyCount] & 0xc0) == 0x80));
text[keyCount] = '\0';
}
}
@@ -2006,14 +2057,14 @@ bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
// 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);
+ if (textAlignment == TEXT_ALIGN_CENTER) cursor.x = bounds.x + GetTextWidth(text)/2 + bounds.width/2 + 1;
+ else if (textAlignment == TEXT_ALIGN_RIGHT) cursor.x = bounds.x + bounds.width - GuiGetStyle(TEXTBOX, TEXT_INNER_PADDING);
}
else
{
if (CheckCollisionPointRec(mousePoint, bounds))
{
- state = GUI_STATE_FOCUSED;
+ state = STATE_FOCUSED;
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
}
}
@@ -2022,11 +2073,11 @@ bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
// Draw control
//--------------------------------------------------------------------
- if (state == GUI_STATE_PRESSED)
+ if (state == 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)
+ else if (state == STATE_DISABLED)
{
GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED)), guiAlpha));
}
@@ -2044,13 +2095,13 @@ bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)
// Spinner control, returns selected value
bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode)
{
- GuiControlState state = guiState;
+ GuiState 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 spinner = { bounds.x + GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_SPACING), bounds.y,
+ bounds.width - 2*(GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_SPACING)), 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 };
@@ -2061,23 +2112,31 @@ bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, in
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);
+ if (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING);
}
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != 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 (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = STATE_FOCUSED;
}
}
+#if defined(RAYGUI_NO_ICONS)
+ if (GuiButton(leftButtonBound, "<")) tempValue--;
+ if (GuiButton(rightButtonBound, ">")) tempValue++;
+#else
+ if (GuiButton(leftButtonBound, GuiIconText(ICON_ARROW_LEFT_FILL, NULL))) tempValue--;
+ if (GuiButton(rightButtonBound, GuiIconText(ICON_ARROW_RIGHT_FILL, NULL))) tempValue++;
+#endif
+
if (!editMode)
{
if (tempValue < minValue) tempValue = minValue;
@@ -2095,21 +2154,13 @@ bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, in
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, TEXT_ALIGN_CENTER);
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));
+ GuiDrawText(text, textBounds, (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
//--------------------------------------------------------------------
*value = tempValue;
@@ -2120,14 +2171,14 @@ bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, in
// 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
+ #if !defined(RAYGUI_VALUEBOX_MAX_CHARS)
+ #define RAYGUI_VALUEBOX_MAX_CHARS 32
#endif
- GuiControlState state = guiState;
+ GuiState state = guiState;
bool pressed = false;
- char textValue[VALUEBOX_MAX_CHARS + 1] = "\0";
+ char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0";
sprintf(textValue, "%i", *value);
Rectangle textBounds = { 0 };
@@ -2137,12 +2188,12 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
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);
+ if (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING);
}
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
@@ -2150,12 +2201,12 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
if (editMode)
{
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
int keyCount = (int)strlen(textValue);
// Only allow keys in range [48..57]
- if (keyCount < VALUEBOX_MAX_CHARS)
+ if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS)
{
if (GetTextWidth(textValue) < bounds.width)
{
@@ -2182,6 +2233,10 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
if (valueHasChanged) *value = TextToInteger(textValue);
+ // NOTE: We are not clamp values until user input finishes
+ //if (*value > maxValue) *value = maxValue;
+ //else if (*value < minValue) *value = minValue;
+
if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) pressed = true;
}
else
@@ -2191,7 +2246,7 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
if (CheckCollisionPointRec(mousePoint, bounds))
{
- state = GUI_STATE_FOCUSED;
+ state = STATE_FOCUSED;
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
}
}
@@ -2201,12 +2256,12 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
// 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));
+ if (state == STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED));
+ else if (state == 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));
+ GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3))), guiAlpha));
// Draw cursor
if (editMode)
@@ -2217,7 +2272,7 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
}
// 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));
+ GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(LABEL, TEXT + (state*3))), guiAlpha));
//--------------------------------------------------------------------
return pressed;
@@ -2226,7 +2281,7 @@ bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, i
// Text Box control with multiple lines
bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
{
- GuiControlState state = guiState;
+ GuiState state = guiState;
bool pressed = false;
Rectangle textAreaBounds = {
@@ -2243,13 +2298,13 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
if (editMode)
{
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
// We get an Unicode codepoint
int codepoint = GetCharPressed();
@@ -2303,7 +2358,7 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
{
if (CheckCollisionPointRec(mousePoint, bounds))
{
- state = GUI_STATE_FOCUSED;
+ state = STATE_FOCUSED;
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) pressed = true;
}
}
@@ -2312,11 +2367,11 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
// Draw control
//--------------------------------------------------------------------
- if (state == GUI_STATE_PRESSED)
+ if (state == 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)
+ else if (state == STATE_DISABLED)
{
GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED)), guiAlpha));
}
@@ -2338,7 +2393,7 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
if ((codepointLength == 1) && (codepoint == '\n'))
{
- cursorPos.y += (guiFont.baseSize*scaleFactor + GuiGetStyle(TEXTBOX, TEXT_LINES_PADDING)); // Line feed
+ cursorPos.y += (guiFont.baseSize*scaleFactor + GuiGetStyle(TEXTBOX, TEXT_LINES_SPACING)); // Line feed
cursorPos.x = textAreaBounds.x; // Carriage return
}
else
@@ -2347,12 +2402,12 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
{
int glyphWidth = 0;
if (glyphInfo.advanceX != 0) glyphWidth += glyphInfo.advanceX;
- else glyphWidth += (atlasRec.width + glyphInfo.offsetX);
+ else glyphWidth += (int)(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.y += (guiFont.baseSize*scaleFactor + GuiGetStyle(TEXTBOX, TEXT_LINES_SPACING)); // Line feed
cursorPos.x = textAreaBounds.x; // Carriage return
}
}
@@ -2380,7 +2435,7 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
int glyphWidth = 0;
if (glyphInfo.advanceX != 0) glyphWidth += glyphInfo.advanceX;
- else glyphWidth += (atlasRec.width + glyphInfo.offsetX);
+ else glyphWidth += (int)(atlasRec.width + glyphInfo.offsetX);
cursorPos.x += (glyphWidth*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
//if (i > lastSpacePos) lastSpaceWidth += (atlasRec.width + (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
@@ -2401,7 +2456,7 @@ bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode)
// 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;
+ GuiState state = guiState;
int sliderValue = (int)(((value - minValue)/(maxValue - minValue))*(bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH)));
@@ -2421,7 +2476,7 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
@@ -2429,7 +2484,7 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
{
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
{
- state = GUI_STATE_PRESSED;
+ state = 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;
@@ -2437,7 +2492,7 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
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;
+ else state = STATE_FOCUSED;
}
if (value > maxValue) value = maxValue;
@@ -2458,11 +2513,11 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
// 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));
+ GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(SLIDER, (state != 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));
+ if ((state == STATE_NORMAL) || (state == STATE_PRESSED)) GuiDrawRectangle(slider, 0, BLANK, Fade(GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED)), guiAlpha));
+ else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, Fade(GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED)), guiAlpha));
// Draw left/right text if provided
if (textLeft != NULL)
@@ -2473,7 +2528,7 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
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));
+ GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(SLIDER, TEXT + (state*3))), guiAlpha));
}
if (textRight != NULL)
@@ -2484,7 +2539,7 @@ float GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight
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));
+ GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, Fade(GetColor(GuiGetStyle(SLIDER, TEXT + (state*3))), guiAlpha));
}
//--------------------------------------------------------------------
@@ -2506,7 +2561,7 @@ float GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight
// 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;
+ GuiState state = guiState;
Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH),
bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0,
@@ -2514,7 +2569,9 @@ float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRig
// Update control
//--------------------------------------------------------------------
- if (state != GUI_STATE_DISABLED) progress.width = ((float)(value/(maxValue - minValue))*(float)(bounds.width - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)));
+ if (value > maxValue) value = maxValue;
+
+ if (state != STATE_DISABLED) progress.width = ((float)(value/(maxValue - minValue))*(float)(bounds.width - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)));
//--------------------------------------------------------------------
// Draw control
@@ -2522,8 +2579,8 @@ float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRig
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));
+ if ((state == STATE_NORMAL) || (state == STATE_PRESSED)) GuiDrawRectangle(progress, 0, BLANK, Fade(GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED)), guiAlpha));
+ else if (state == STATE_FOCUSED) GuiDrawRectangle(progress, 0, BLANK, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT_COLOR_FOCUSED)), guiAlpha));
// Draw left/right text if provided
if (textLeft != NULL)
@@ -2534,7 +2591,7 @@ float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRig
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));
+ GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3))), guiAlpha));
}
if (textRight != NULL)
@@ -2545,7 +2602,7 @@ float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRig
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));
+ GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, Fade(GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3))), guiAlpha));
}
//--------------------------------------------------------------------
@@ -2555,158 +2612,43 @@ float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRig
// Status Bar control
void GuiStatusBar(Rectangle bounds, const char *text)
{
- GuiControlState state = guiState;
+ GuiState 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));
+ GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != STATE_DISABLED)? BORDER_COLOR_NORMAL : BORDER_COLOR_DISABLED)), guiAlpha),
+ Fade(GetColor(GuiGetStyle(STATUSBAR, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
+ GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != 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;
+ GuiState state = guiState;
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != 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 (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED;
+ else state = 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));
+ GuiDrawRectangle(bounds, 0, BLANK, Fade(GetColor(GuiGetStyle(DEFAULT, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
+ GuiDrawText(text, GetTextBounds(DEFAULT, bounds), TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(BUTTON, (state != 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)
{
@@ -2721,24 +2663,24 @@ int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int 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;
+ GuiState 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;
+ if ((GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING))*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.x = bounds.x + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING);
+ itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ itemBounds.width = bounds.width - 2*GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) - 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));
+ int visibleItems = (int)bounds.height/(GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING));
if (visibleItems > count) visibleItems = count;
int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex;
@@ -2747,14 +2689,14 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
// Check mouse inside list view
if (CheckCollisionPointRec(mousePoint, bounds))
{
- state = GUI_STATE_FOCUSED;
+ state = STATE_FOCUSED;
// Check focused and selected item
for (int i = 0; i < visibleItems; i++)
@@ -2771,7 +2713,7 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
}
// Update item rectangle y position for next item
- itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING));
}
if (useScrollBar)
@@ -2789,7 +2731,7 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
else itemFocused = -1;
// Reset item rectangle y to [0]
- itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING) + GuiGetStyle(DEFAULT, BORDER_WIDTH);
+ itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH);
}
//--------------------------------------------------------------------
@@ -2800,7 +2742,7 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
// Draw visible items
for (int i = 0; ((i < visibleItems) && (text != NULL)); i++)
{
- if (state == GUI_STATE_DISABLED)
+ if (state == 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));
@@ -2828,7 +2770,7 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
}
// Update item rectangle y position for next item
- itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_PADDING));
+ itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING));
}
if (useScrollBar)
@@ -2862,12 +2804,12 @@ int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, in
}
// Color Panel control
-Color GuiColorPanel(Rectangle bounds, Color color)
+Color GuiColorPanel(Rectangle bounds, const char *text, Color color)
{
const Color colWhite = { 255, 255, 255, 255 };
const Color colBlack = { 0, 0, 0, 255 };
- GuiControlState state = guiState;
+ GuiState state = guiState;
Vector2 pickerSelector = { 0 };
Vector3 vcolor = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2885,7 +2827,7 @@ Color GuiColorPanel(Rectangle bounds, Color color)
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
@@ -2893,7 +2835,7 @@ Color GuiColorPanel(Rectangle bounds, Color color)
{
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
{
- state = GUI_STATE_PRESSED;
+ state = STATE_PRESSED;
pickerSelector = mousePoint;
// Calculate color from picker
@@ -2914,14 +2856,14 @@ Color GuiColorPanel(Rectangle bounds, Color color)
(unsigned char)(255.0f*(float)color.a/255.0f) };
}
- else state = GUI_STATE_FOCUSED;
+ else state = STATE_FOCUSED;
}
}
//--------------------------------------------------------------------
// Draw control
//--------------------------------------------------------------------
- if (state != GUI_STATE_DISABLED)
+ if (state != 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));
@@ -2943,16 +2885,18 @@ Color GuiColorPanel(Rectangle bounds, Color color)
// Color Bar Alpha control
// NOTE: Returns alpha value normalized [0..1]
-float GuiColorBarAlpha(Rectangle bounds, float alpha)
+float GuiColorBarAlpha(Rectangle bounds, const char *text, float alpha)
{
- #define COLORBARALPHA_CHECKED_SIZE 10
+ #if !defined(RAYGUI_COLORBARALPHA_CHECKED_SIZE)
+ #define RAYGUI_COLORBARALPHA_CHECKED_SIZE 10
+ #endif
- GuiControlState state = guiState;
+ GuiState 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)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
@@ -2961,14 +2905,14 @@ float GuiColorBarAlpha(Rectangle bounds, float alpha)
{
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
{
- state = GUI_STATE_PRESSED;
+ state = 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;
+ else state = STATE_FOCUSED;
}
}
//--------------------------------------------------------------------
@@ -2977,16 +2921,16 @@ float GuiColorBarAlpha(Rectangle bounds, float alpha)
//--------------------------------------------------------------------
// Draw alpha bar: checked background
- if (state != GUI_STATE_DISABLED)
+ if (state != STATE_DISABLED)
{
- int checksX = (int)bounds.width/COLORBARALPHA_CHECKED_SIZE;
- int checksY = (int)bounds.height/COLORBARALPHA_CHECKED_SIZE;
+ int checksX = (int)bounds.width/RAYGUI_COLORBARALPHA_CHECKED_SIZE;
+ int checksY = (int)bounds.height/RAYGUI_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 };
+ Rectangle check = { bounds.x + x*RAYGUI_COLORBARALPHA_CHECKED_SIZE, bounds.y + y*RAYGUI_COLORBARALPHA_CHECKED_SIZE, RAYGUI_COLORBARALPHA_CHECKED_SIZE, RAYGUI_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));
}
}
@@ -3010,14 +2954,14 @@ float GuiColorBarAlpha(Rectangle bounds, float alpha)
// Color GuiColorBarSat() [WHITE->color]
// Color GuiColorBarValue() [BLACK->color], HSV/HSL
// float GuiColorBarLuminance() [BLACK->WHITE]
-float GuiColorBarHue(Rectangle bounds, float hue)
+float GuiColorBarHue(Rectangle bounds, const char *text, float hue)
{
- GuiControlState state = guiState;
+ GuiState 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)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
Vector2 mousePoint = GetMousePosition();
@@ -3026,14 +2970,14 @@ float GuiColorBarHue(Rectangle bounds, float hue)
{
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
{
- state = GUI_STATE_PRESSED;
+ state = 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;
+ else state = STATE_FOCUSED;
/*if (IsKeyDown(KEY_UP))
{
@@ -3051,14 +2995,14 @@ float GuiColorBarHue(Rectangle bounds, float hue)
// Draw control
//--------------------------------------------------------------------
- if (state != GUI_STATE_DISABLED)
+ if (state != 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), (int)bounds.width, (int)ceilf(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, (int)ceilf(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, (int)ceilf(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, (int)ceilf(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, (int)ceilf(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));
@@ -3078,15 +3022,15 @@ float GuiColorBarHue(Rectangle bounds, float hue)
// float GuiColorBarAlpha(Rectangle bounds, float alpha)
// float GuiColorBarHue(Rectangle bounds, float value)
// NOTE: bounds define GuiColorPanel() size
-Color GuiColorPicker(Rectangle bounds, Color color)
+Color GuiColorPicker(Rectangle bounds, const char *text, Color color)
{
- color = GuiColorPanel(bounds, color);
+ color = GuiColorPanel(bounds, NULL, 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);
+ hsv.x = GuiColorBarHue(boundsHue, NULL, hsv.x);
//color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f);
Vector3 rgb = ConvertHSVtoRGB(hsv);
@@ -3098,43 +3042,47 @@ Color GuiColorPicker(Rectangle bounds, Color 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
+ #if !defined(RAYGUI_MESSAGEBOX_BUTTON_HEIGHT)
+ #define RAYGUI_MESSAGEBOX_BUTTON_HEIGHT 24
+ #endif
+ #if !defined(RAYGUI_MESSAGEBOX_BUTTON_PADDING)
+ #define RAYGUI_MESSAGEBOX_BUTTON_PADDING 12
+ #endif
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;
+ buttonBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING;
+ buttonBounds.y = bounds.y + bounds.height - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT - RAYGUI_MESSAGEBOX_BUTTON_PADDING;
+ buttonBounds.width = (bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount;
+ buttonBounds.height = RAYGUI_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.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING;
textBounds.width = textSize.x;
- textBounds.height = textSize.y;
+ textBounds.height = bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 3*RAYGUI_MESSAGEBOX_BUTTON_PADDING - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT;
// Draw control
//--------------------------------------------------------------------
if (GuiWindowBox(bounds, title)) clicked = 0;
int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
- GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER);
GuiLabel(textBounds, message);
GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
- GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, 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);
+ buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING);
}
GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment);
@@ -3144,13 +3092,17 @@ int GuiMessageBox(Rectangle bounds, const char *title, const char *message, cons
}
// Text Input Box control, ask for text
-int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text)
+int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, int *secretViewActive)
{
- #define TEXTINPUTBOX_BUTTON_HEIGHT 24
- #define TEXTINPUTBOX_BUTTON_PADDING 10
- #define TEXTINPUTBOX_HEIGHT 30
-
- #define TEXTINPUTBOX_MAX_TEXT_LENGTH 256
+ #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT)
+ #define RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT 28
+ #endif
+ #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_PADDING)
+ #define RAYGUI_TEXTINPUTBOX_BUTTON_PADDING 12
+ #endif
+ #if !defined(RAYGUI_TEXTINPUTBOX_HEIGHT)
+ #define RAYGUI_TEXTINPUTBOX_HEIGHT 28
+ #endif
// Used to enable text edit mode
// WARNING: No more than one GuiTextInputBox() should be open at the same time
@@ -3161,12 +3113,12 @@ int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, co
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;
+ buttonBounds.x = bounds.x + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING;
+ buttonBounds.y = bounds.y + bounds.height - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING;
+ buttonBounds.width = (bounds.width - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount;
+ buttonBounds.height = RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT;
- int messageInputHeight = (int)bounds.height - WINDOW_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - TEXTINPUTBOX_BUTTON_HEIGHT - 2*TEXTINPUTBOX_BUTTON_PADDING;
+ int messageInputHeight = (int)bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - 2*RAYGUI_TEXTINPUTBOX_BUTTON_PADDING;
Rectangle textBounds = { 0 };
if (message != NULL)
@@ -3174,18 +3126,18 @@ int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, co
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.y = bounds.y + RAYGUI_WINDOWBOX_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;
+ textBoxBounds.x = bounds.x + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING;
+ textBoxBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - RAYGUI_TEXTINPUTBOX_HEIGHT/2;
+ if (message == NULL) textBoxBounds.y = bounds.y + 24 + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING;
else textBoxBounds.y += (messageInputHeight/2 + messageInputHeight/4);
- textBoxBounds.width = bounds.width - TEXTINPUTBOX_BUTTON_PADDING*2;
- textBoxBounds.height = TEXTINPUTBOX_HEIGHT;
+ textBoxBounds.width = bounds.width - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*2;
+ textBoxBounds.height = RAYGUI_TEXTINPUTBOX_HEIGHT;
// Draw control
//--------------------------------------------------------------------
@@ -3195,20 +3147,31 @@ int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, co
if (message != NULL)
{
int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT);
- GuiSetStyle(LABEL, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER);
GuiLabel(textBounds, message);
GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment);
}
- if (GuiTextBox(textBoxBounds, text, TEXTINPUTBOX_MAX_TEXT_LENGTH, textEditMode)) textEditMode = !textEditMode;
+ if (secretViewActive != NULL)
+ {
+ static char stars[] = "****************";
+ if (GuiTextBox(RAYGUI_CLITERAL(Rectangle){ textBoxBounds.x, textBoxBounds.y, textBoxBounds.width - 4 - RAYGUI_TEXTINPUTBOX_HEIGHT, textBoxBounds.height },
+ ((*secretViewActive == 1) || textEditMode)? text : stars, textMaxSize, textEditMode)) textEditMode = !textEditMode;
+
+ *secretViewActive = GuiToggle(RAYGUI_CLITERAL(Rectangle){ textBoxBounds.x + textBoxBounds.width - RAYGUI_TEXTINPUTBOX_HEIGHT, textBoxBounds.y, RAYGUI_TEXTINPUTBOX_HEIGHT, RAYGUI_TEXTINPUTBOX_HEIGHT }, (*secretViewActive == 1)? "#44#" : "#45#", *secretViewActive);
+ }
+ else
+ {
+ if (GuiTextBox(textBoxBounds, text, textMaxSize, textEditMode)) textEditMode = !textEditMode;
+ }
int prevBtnTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT);
- GuiSetStyle(BUTTON, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_CENTER);
+ GuiSetStyle(BUTTON, TEXT_ALIGNMENT, 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);
+ buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING);
}
GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment);
@@ -3221,13 +3184,14 @@ int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, co
// 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)
+Vector2 GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs)
{
- #if !defined(GRID_COLOR_ALPHA)
- #define GRID_COLOR_ALPHA 0.15f // Grid lines alpha amount
+ // Grid lines alpha amount
+ #if !defined(RAYGUI_GRID_ALPHA)
+ #define RAYGUI_GRID_ALPHA 0.15f
#endif
- GuiControlState state = guiState;
+ GuiState state = guiState;
Vector2 mousePoint = GetMousePosition();
Vector2 currentCell = { -1, -1 };
@@ -3236,21 +3200,25 @@ Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs)
// Update control
//--------------------------------------------------------------------
- if ((state != GUI_STATE_DISABLED) && !guiLocked)
+ if ((state != STATE_DISABLED) && !guiLocked)
{
if (CheckCollisionPointRec(mousePoint, bounds))
{
- currentCell.x = (mousePoint.x - bounds.x)/spacing;
- currentCell.y = (mousePoint.y - bounds.y)/spacing;
+ // NOTE: Cell values must be rounded to int
+ currentCell.x = (int)((mousePoint.x - bounds.x)/spacing);
+ currentCell.y = (int)((mousePoint.y - bounds.y)/spacing);
}
}
//--------------------------------------------------------------------
// Draw control
//--------------------------------------------------------------------
+
+ // TODO: Draw background panel?
+
switch (state)
{
- case GUI_STATE_NORMAL:
+ case STATE_NORMAL:
{
if (subdivs > 0)
{
@@ -3258,14 +3226,14 @@ Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs)
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));
+ GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0) ? Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA*4) : Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_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));
+ GuiDrawRectangle(lineH, 0, BLANK, ((i%subdivs) == 0) ? Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA*4) : Fade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA));
}
}
} break;
@@ -3280,8 +3248,12 @@ Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs)
//----------------------------------------------------------------------------------
// Load raygui style file (.rgs)
+// NOTE: By default a binary file is expected, that file could contain a custom font,
+// in that case, custom font image atlas is GRAY+ALPHA and pixel data can be compressed (DEFLATE)
void GuiLoadStyle(const char *fileName)
{
+ #define MAX_LINE_BUFFER_SIZE 256
+
bool tryBinary = false;
// Try reading the files as text file first
@@ -3289,8 +3261,8 @@ void GuiLoadStyle(const char *fileName)
if (rgsFile != NULL)
{
- char buffer[256] = { 0 };
- fgets(buffer, 256, rgsFile);
+ char buffer[MAX_LINE_BUFFER_SIZE] = { 0 };
+ fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile);
if (buffer[0] == '#')
{
@@ -3307,7 +3279,6 @@ void GuiLoadStyle(const char *fileName)
// Style property: p
sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue);
-
GuiSetStyle(controlId, propertyId, (int)propertyValue);
} break;
@@ -3335,12 +3306,19 @@ void GuiLoadStyle(const char *fileName)
int *values = (int *)RAYGUI_MALLOC(glyphCount*sizeof(int));
for (int i = 0; i < glyphCount; i++) values[i] = TextToInteger(chars[i]);
+ if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture);
font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, values, glyphCount);
+ if (font.texture.id == 0) font = GetFontDefault();
RAYGUI_FREE(values);
}
}
- else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0);
+ else
+ {
+ if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture);
+ font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0);
+ if (font.texture.id == 0) font = GetFontDefault();
+ }
if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font);
@@ -3348,7 +3326,7 @@ void GuiLoadStyle(const char *fileName)
default: break;
}
- fgets(buffer, 256, rgsFile);
+ fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile);
}
}
else tryBinary = true;
@@ -3362,7 +3340,7 @@ void GuiLoadStyle(const char *fileName)
if (rgsFile == NULL) return;
- char signature[5] = "";
+ char signature[5] = { 0 };
short version = 0;
short reserved = 0;
int propertyCount = 0;
@@ -3379,13 +3357,13 @@ void GuiLoadStyle(const char *fileName)
{
short controlId = 0;
short propertyId = 0;
- int propertyValue = 0;
+ unsigned 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);
+ fread(&propertyValue, 1, sizeof(unsigned int), rgsFile);
if (controlId == 0) // DEFAULT control
{
@@ -3418,24 +3396,42 @@ void GuiLoadStyle(const char *fileName)
fread(&whiteRec, 1, sizeof(Rectangle), rgsFile);
// Load font image parameters
- int fontImageSize = 0;
- fread(&fontImageSize, 1, sizeof(int), rgsFile);
+ int fontImageUncompSize = 0;
+ int fontImageCompSize = 0;
+ fread(&fontImageUncompSize, 1, sizeof(int), rgsFile);
+ fread(&fontImageCompSize, 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);
+
+ if (fontImageCompSize < fontImageUncompSize)
{
- 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);
+ // Compressed font atlas image data (DEFLATE), it requires DecompressData()
+ int dataUncompSize = 0;
+ unsigned char *compData = (unsigned char *)RAYGUI_MALLOC(fontImageCompSize);
+ fread(compData, 1, fontImageCompSize, rgsFile);
+ imFont.data = DecompressData(compData, fontImageCompSize, &dataUncompSize);
- imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageSize);
- fread(imFont.data, 1, fontImageSize, rgsFile);
+ // Security check, dataUncompSize must match the provided fontImageUncompSize
+ if (dataUncompSize != fontImageUncompSize) RAYGUI_LOG("WARNING: Uncompressed font atlas image data could be corrupted");
- font.texture = LoadTextureFromImage(imFont);
-
- RAYGUI_FREE(imFont.data);
+ RAYGUI_FREE(compData);
}
+ else
+ {
+ // Font atlas image data is not compressed
+ imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageUncompSize);
+ fread(imFont.data, 1, fontImageUncompSize, rgsFile);
+ }
+
+ if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture);
+ font.texture = LoadTextureFromImage(imFont);
+ if (font.texture.id == 0) font = GetFontDefault();
+
+ RAYGUI_FREE(imFont.data);
// Load font recs data
font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle));
@@ -3486,23 +3482,23 @@ void GuiLoadStyleDefault(void)
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
+ GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, 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(LABEL, TEXT_ALIGNMENT, 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(SLIDER, TEXT_PADDING, 4);
+ GuiSetStyle(CHECKBOX, TEXT_PADDING, 4);
+ GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, TEXT_ALIGN_RIGHT);
+ GuiSetStyle(TEXTBOX, TEXT_PADDING, 4);
+ GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT);
GuiSetStyle(VALUEBOX, TEXT_PADDING, 4);
- GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, GUI_TEXT_ALIGN_LEFT);
+ GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, 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);
+ GuiSetStyle(SPINNER, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT);
+ GuiSetStyle(STATUSBAR, TEXT_PADDING, 8);
+ GuiSetStyle(STATUSBAR, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT);
// Initialize extended property values
// NOTE: By default, extended property values are initialized to 0
@@ -3511,35 +3507,33 @@ void GuiLoadStyleDefault(void)
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_WIDTH, 16);
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(COMBOBOX, COMBO_BUTTON_WIDTH, 32);
+ GuiSetStyle(COMBOBOX, COMBO_BUTTON_SPACING, 2);
GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16);
- GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_PADDING, 2);
- GuiSetStyle(TEXTBOX, TEXT_LINES_PADDING, 5);
+ GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING, 2);
+ GuiSetStyle(TEXTBOX, TEXT_LINES_SPACING, 4);
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(SPINNER, SPIN_BUTTON_WIDTH, 24);
+ GuiSetStyle(SPINNER, SPIN_BUTTON_SPACING, 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(SCROLLBAR, SCROLL_SPEED, 12);
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 24);
+ GuiSetStyle(LISTVIEW, LIST_ITEMS_SPACING, 2);
+ GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 12);
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, COLOR_SELECTOR_SIZE, 8);
+ GuiSetStyle(COLORPICKER, HUEBAR_WIDTH, 16);
+ GuiSetStyle(COLORPICKER, HUEBAR_PADDING, 8);
+ GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT, 8);
GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW, 2);
guiFont = GetFontDefault(); // Initialize default font
@@ -3550,35 +3544,42 @@ void GuiLoadStyleDefault(void)
// a number that can change between ricon versions
const char *GuiIconText(int iconId, const char *text)
{
-#if defined(RAYGUI_NO_RICONS)
+#if defined(RAYGUI_NO_ICONS)
return NULL;
#else
static char buffer[1024] = { 0 };
- memset(buffer, 0, 1024);
-
- sprintf(buffer, "#%03i#", iconId);
+ static char iconBuffer[6] = { 0 };
if (text != NULL)
{
+ memset(buffer, 0, 1024);
+ sprintf(buffer, "#%03i#", iconId);
+
for (int i = 5; i < 1024; i++)
{
buffer[i] = text[i - 5];
if (text[i - 5] == '\0') break;
}
+
+ return buffer;
+ }
+ else
+ {
+ sprintf(iconBuffer, "#%03i#", iconId & 0x1ff);
+
+ return iconBuffer;
}
-
- return buffer;
#endif
}
-#if !defined(RAYGUI_NO_RICONS)
+#if !defined(RAYGUI_NO_ICONS)
// 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],
+// they are returned as a guiIconsName[iconCount][RAYGUI_ICON_MAX_NAME_LENGTH],
// WARNING: guiIconsName[]][] memory should be manually freed!
char **GuiLoadIcons(const char *fileName, bool loadIconsName)
{
@@ -3612,7 +3613,7 @@ char **GuiLoadIcons(const char *fileName, bool loadIconsName)
if (rgiFile != NULL)
{
- char signature[5] = "";
+ char signature[5] = { 0 };
short version = 0;
short reserved = 0;
short iconCount = 0;
@@ -3634,11 +3635,11 @@ char **GuiLoadIcons(const char *fileName, bool 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);
+ guiIconsName[i] = (char *)RAYGUI_MALLOC(RAYGUI_ICON_MAX_NAME_LENGTH);
+ fread(guiIconsName[i], RAYGUI_ICON_MAX_NAME_LENGTH, 1, rgiFile);
}
}
- else fseek(rgiFile, iconCount*RICON_MAX_NAME_LENGTH, SEEK_CUR);
+ else fseek(rgiFile, iconCount*RAYGUI_ICON_MAX_NAME_LENGTH, SEEK_CUR);
// Read icons data directly over guiIcons data array
fread(guiIcons, iconCount*(iconSize*iconSize/32), sizeof(unsigned int), rgiFile);
@@ -3653,16 +3654,16 @@ char **GuiLoadIcons(const char *fileName, bool loadIconsName)
// 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)))
+ #define BIT_CHECK(a,b) ((a) & (1u<<(b)))
- for (int i = 0, y = 0; i < RICON_SIZE*RICON_SIZE/32; i++)
+ for (int i = 0, y = 0; i < RAYGUI_ICON_SIZE*RAYGUI_ICON_SIZE/32; i++)
{
for (int k = 0; k < 32; k++)
{
- if (BIT_CHECK(guiIcons[iconId*RICON_DATA_ELEMENTS + i], k))
+ if (BIT_CHECK(guiIcons[iconId*RAYGUI_ICON_DATA_ELEMENTS + i], k))
{
#if !defined(RAYGUI_STANDALONE)
- DrawRectangle(posX + (k%RICON_SIZE)*pixelSize, posY + y*pixelSize, pixelSize, pixelSize, color);
+ DrawRectangle(posX + (k%RAYGUI_ICON_SIZE)*pixelSize, posY + y*pixelSize, pixelSize, pixelSize, color);
#endif
}
@@ -3672,65 +3673,91 @@ void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color)
}
// Get icon bit data
-// NOTE: Bit data array grouped as unsigned int (ICON_SIZE*ICON_SIZE/32 elements)
+// NOTE: Bit data array grouped as unsigned int (RAYGUI_ICON_SIZE*RAYGUI_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));
+ static unsigned int iconData[RAYGUI_ICON_DATA_ELEMENTS] = { 0 };
+ memset(iconData, 0, RAYGUI_ICON_DATA_ELEMENTS*sizeof(unsigned int));
- if (iconId < RICON_MAX_ICONS) memcpy(iconData, &guiIcons[iconId*RICON_DATA_ELEMENTS], RICON_DATA_ELEMENTS*sizeof(unsigned int));
+ if (iconId < RAYGUI_ICON_MAX_ICONS) memcpy(iconData, &guiIcons[iconId*RAYGUI_ICON_DATA_ELEMENTS], RAYGUI_ICON_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)
+// NOTE: Data must be provided as unsigned int array (RAYGUI_ICON_SIZE*RAYGUI_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));
+ if (iconId < RAYGUI_ICON_MAX_ICONS) memcpy(&guiIcons[iconId*RAYGUI_ICON_DATA_ELEMENTS], data, RAYGUI_ICON_DATA_ELEMENTS*sizeof(unsigned int));
+}
+
+// Set icon scale (1 by default)
+void GuiSetIconScale(unsigned int scale)
+{
+ guiIconScale = (scale < 1)? 1 : scale;
}
// Set icon pixel value
void GuiSetIconPixel(int iconId, int x, int y)
{
- #define BIT_SET(a,b) ((a) |= (1<<(b)))
+ #define BIT_SET(a,b) ((a) |= (1u<<(b)))
- // This logic works for any RICON_SIZE pixels icons,
+ // This logic works for any RAYGUI_ICON_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));
+ BIT_SET(guiIcons[iconId*RAYGUI_ICON_DATA_ELEMENTS + y/(sizeof(unsigned int)*8/RAYGUI_ICON_SIZE)], x + (y%(sizeof(unsigned int)*8/RAYGUI_ICON_SIZE)*RAYGUI_ICON_SIZE));
}
// Clear icon pixel value
void GuiClearIconPixel(int iconId, int x, int y)
{
- #define BIT_CLEAR(a,b) ((a) &= ~((1)<<(b)))
+ #define BIT_CLEAR(a,b) ((a) &= ~((1u)<<(b)))
- // This logic works for any RICON_SIZE pixels icons,
+ // This logic works for any RAYGUI_ICON_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));
+ BIT_CLEAR(guiIcons[iconId*RAYGUI_ICON_DATA_ELEMENTS + y/(sizeof(unsigned int)*8/RAYGUI_ICON_SIZE)], x + (y%(sizeof(unsigned int)*8/RAYGUI_ICON_SIZE)*RAYGUI_ICON_SIZE));
}
// Check icon pixel value
bool GuiCheckIconPixel(int iconId, int x, int y)
{
- #define BIT_CHECK(a,b) ((a) & (1<<(b)))
+ #define BIT_CHECK(a,b) ((a) & (1u<<(b)))
return (BIT_CHECK(guiIcons[iconId*8 + y/2], x + (y%2*16)));
}
-#endif // !RAYGUI_NO_RICONS
+#endif // !RAYGUI_NO_ICONS
//----------------------------------------------------------------------------------
// Module specific Functions Definition
//----------------------------------------------------------------------------------
-// Gui get text width using default font
-// NOTE: Icon is not considered here
+// Gui get text width considering icon
static int GetTextWidth(const char *text)
{
+ #if !defined(ICON_TEXT_PADDING)
+ #define ICON_TEXT_PADDING 4
+ #endif
+
Vector2 size = { 0 };
+ int textIconOffset = 0;
if ((text != NULL) && (text[0] != '\0'))
{
- size = MeasureTextEx(guiFont, text, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
+ if (text[0] == '#')
+ {
+ for (int i = 1; (text[i] != '\0') && (i < 5); i++)
+ {
+ if (text[i] == '#')
+ {
+ textIconOffset = i;
+ break;
+ }
+ }
+ }
+
+ // Make sure guiFont is set, GuiGetStyle() initializes it lazynessly
+ float fontSize = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
+
+ size = MeasureTextEx(guiFont, text + textIconOffset, fontSize, (float)GuiGetStyle(DEFAULT, TEXT_SPACING));
+ if (textIconOffset > 0) size.x += (RAYGUI_ICON_SIZE - ICON_TEXT_PADDING);
}
return (int)size.x;
@@ -3749,11 +3776,11 @@ static Rectangle GetTextBounds(int control, Rectangle bounds)
// 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 COMBOBOX: bounds.width -= (GuiGetStyle(control, COMBO_BUTTON_WIDTH) + GuiGetStyle(control, COMBO_BUTTON_SPACING)); 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);
+ if (GuiGetStyle(control, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING);
else textBounds.x += GuiGetStyle(control, TEXT_PADDING);
} break;
}
@@ -3768,7 +3795,7 @@ static Rectangle GetTextBounds(int control, Rectangle bounds)
// NOTE: We support up to 999 values for iconId
static const char *GetTextIcon(const char *text, int *iconId)
{
-#if !defined(RAYGUI_NO_RICONS)
+#if !defined(RAYGUI_NO_ICONS)
*iconId = -1;
if (text[0] == '#') // Maybe we have an icon!
{
@@ -3800,6 +3827,10 @@ static void GuiDrawText(const char *text, Rectangle bounds, int alignment, Color
{
#define TEXT_VALIGN_PIXEL_OFFSET(h) ((int)h%2) // Vertical alignment for pixel perfect
+ #if !defined(ICON_TEXT_PADDING)
+ #define ICON_TEXT_PADDING 4
+ #endif
+
if ((text != NULL) && (text[0] != '\0'))
{
int iconId = 0;
@@ -3807,40 +3838,40 @@ static void GuiDrawText(const char *text, Rectangle bounds, int alignment, Color
// 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);
+ // TODO: REVIEW: We consider text size in case of line breaks! -> MeasureTextEx() depends on raylib!
+ Vector2 textSize = MeasureTextEx(GuiGetFont(), text, GuiGetStyle(DEFAULT, TEXT_SIZE), GuiGetStyle(DEFAULT, TEXT_SPACING));
+ //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;
+ textSize.x += RAYGUI_ICON_SIZE*guiIconScale;
// WARNING: If only icon provided, text could be pointing to EOF character: '\0'
- if ((text != NULL) && (text[0] != '\0')) textWidth += RICON_TEXT_PADDING;
+ if ((text != NULL) && (text[0] != '\0')) textSize.x += ICON_TEXT_PADDING;
}
// Check guiTextAlign global variables
switch (alignment)
{
- case GUI_TEXT_ALIGN_LEFT:
+ case TEXT_ALIGN_LEFT:
{
position.x = bounds.x;
- position.y = bounds.y + bounds.height/2 - textHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
+ position.y = bounds.y + bounds.height/2 - textSize.y/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
} break;
- case GUI_TEXT_ALIGN_CENTER:
+ case 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);
+ position.x = bounds.x + bounds.width/2 - textSize.x/2;
+ position.y = bounds.y + bounds.height/2 - textSize.y/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
} break;
- case GUI_TEXT_ALIGN_RIGHT:
+ case 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);
+ position.x = bounds.x + bounds.width - textSize.x;
+ position.y = bounds.y + bounds.height/2 - textSize.y/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height);
} break;
default: break;
}
@@ -3853,12 +3884,12 @@ static void GuiDrawText(const char *text, Rectangle bounds, int alignment, Color
// Draw text (with icon if available)
//---------------------------------------------------------------------------------
-#if !defined(RAYGUI_NO_RICONS)
+#if !defined(RAYGUI_NO_ICONS)
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);
+ GuiDrawIcon(iconId, (int)position.x, (int)(bounds.y + bounds.height/2 - RAYGUI_ICON_SIZE*guiIconScale/2 + TEXT_VALIGN_PIXEL_OFFSET(bounds.height)), guiIconScale, tint);
+ position.x += (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING);
}
#endif
DrawTextEx(guiFont, text, position, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING), tint);
@@ -3892,21 +3923,20 @@ 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
+ // 1. Maximum number of possible split strings is set by RAYGUI_TEXTSPLIT_MAX_ITEMS
+ // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE
// NOTE: Those definitions could be externally provided if required
- #if !defined(TEXTSPLIT_MAX_TEXT_LENGTH)
- #define TEXTSPLIT_MAX_TEXT_LENGTH 1024
+ #if !defined(RAYGUI_TEXTSPLIT_MAX_ITEMS)
+ #define RAYGUI_TEXTSPLIT_MAX_ITEMS 128
+ #endif
+ #if !defined(RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE)
+ #define RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE 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);
+ static const char *result[RAYGUI_TEXTSPLIT_MAX_ITEMS] = { NULL };
+ static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 };
+ memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE);
result[0] = buffer;
int counter = 1;
@@ -3914,7 +3944,7 @@ static const char **GuiTextSplit(const char *text, int *count, int *textRow)
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++)
+ for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++)
{
buffer[i] = text[i];
if (buffer[i] == '\0') break;
@@ -3931,7 +3961,7 @@ static const char **GuiTextSplit(const char *text, int *count, int *textRow)
buffer[i] = '\0'; // Set an end of string at this point
counter++;
- if (counter == TEXTSPLIT_MAX_TEXT_ELEMENTS) break;
+ if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break;
}
}
@@ -4064,6 +4094,121 @@ static Vector3 ConvertHSVtoRGB(Vector3 hsv)
return rgb;
}
+// Scroll bar control (used by GuiScrollPanel())
+static int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue)
+{
+ GuiState 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 != STATE_DISABLED) && !guiLocked)
+ {
+ Vector2 mousePoint = GetMousePosition();
+
+ if (CheckCollisionPointRec(mousePoint, bounds))
+ {
+ state = 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 = 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_ICONS)
+ GuiDrawText(isVertical ? "^" : "<", RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x, arrowUpLeft.y, isVertical ? bounds.width : bounds.height, isVertical ? bounds.width : bounds.height },
+ 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 },
+ 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 },
+ TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3)), guiAlpha)); // ICON_ARROW_UP_FILL / ICON_ARROW_LEFT_FILL
+ GuiDrawText(isVertical ? "#120#" : "#119#", RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical ? bounds.width : bounds.height, isVertical ? bounds.width : bounds.height },
+ TEXT_ALIGN_CENTER, Fade(GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3)), guiAlpha)); // ICON_ARROW_DOWN_FILL / ICON_ARROW_RIGHT_FILL
+#endif
+ }
+ //--------------------------------------------------------------------
+
+ return value;
+}
+
#if defined(RAYGUI_STANDALONE)
// Returns a Color struct from hexadecimal value
static Color GetColor(int hexValue)
@@ -4109,9 +4254,11 @@ static Color Fade(Color color, float alpha)
// Formatting of text with variables to 'embed'
static const char *TextFormat(const char *text, ...)
{
- #define MAX_FORMATTEXT_LENGTH 64
+ #if !defined(RAYGUI_TEXTFORMAT_MAX_SIZE)
+ #define RAYGUI_TEXTFORMAT_MAX_SIZE 256
+ #endif
- static char buffer[MAX_FORMATTEXT_LENGTH];
+ static char buffer[RAYGUI_TEXTFORMAT_MAX_SIZE];
va_list args;
va_start(args, text);
@@ -4129,21 +4276,25 @@ static void DrawRectangleGradientV(int posX, int posY, int width, int height, Co
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
+ // 1. Maximum number of possible split strings is set by RAYGUI_TEXTSPLIT_MAX_ITEMS
+ // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE
- 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);
+ #if !defined(RAYGUI_TEXTSPLIT_MAX_ITEMS)
+ #define RAYGUI_TEXTSPLIT_MAX_ITEMS 128
+ #endif
+ #if !defined(RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE)
+ #define RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE 1024
+ #endif
+
+ static const char *result[RAYGUI_TEXTSPLIT_MAX_ITEMS] = { NULL };
+ static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 };
+ memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE);
result[0] = buffer;
int counter = 0;
@@ -4153,7 +4304,7 @@ const char **TextSplit(const char *text, char delimiter, int *count)
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++)
+ for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++)
{
buffer[i] = text[i];
if (buffer[i] == '\0') break;
@@ -4163,7 +4314,7 @@ const char **TextSplit(const char *text, char delimiter, int *count)
result[counter] = buffer + i + 1;
counter++;
- if (counter == TEXTSPLIT_MAX_SUBSTRINGS_COUNT) break;
+ if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break;
}
}
}
diff --git a/examples/shapes/shapes_draw_circle_sector.c b/examples/shapes/shapes_draw_circle_sector.c
index 101c5378e..d605209a9 100644
--- a/examples/shapes/shapes_draw_circle_sector.c
+++ b/examples/shapes/shapes_draw_circle_sector.c
@@ -14,7 +14,7 @@
#include
#define RAYGUI_IMPLEMENTATION
-#include "extras/raygui.h" // Required for GUI controls
+#include "raygui.h" // Required for GUI controls
int main(void)
{
diff --git a/examples/shapes/shapes_draw_rectangle_rounded.c b/examples/shapes/shapes_draw_rectangle_rounded.c
index d02b1328f..b7b1151ea 100644
--- a/examples/shapes/shapes_draw_rectangle_rounded.c
+++ b/examples/shapes/shapes_draw_rectangle_rounded.c
@@ -14,7 +14,7 @@
#include
#define RAYGUI_IMPLEMENTATION
-#include "extras/raygui.h" // Required for GUI controls
+#include "raygui.h" // Required for GUI controls
int main(void)
{
diff --git a/examples/shapes/shapes_draw_ring.c b/examples/shapes/shapes_draw_ring.c
index de97a0145..cb697d5e8 100644
--- a/examples/shapes/shapes_draw_ring.c
+++ b/examples/shapes/shapes_draw_ring.c
@@ -14,7 +14,7 @@
#include
#define RAYGUI_IMPLEMENTATION
-#include "extras/raygui.h" // Required for GUI controls
+#include "raygui.h" // Required for GUI controls
int main(void)
{
diff --git a/examples/text/text_draw_3d.c b/examples/text/text_draw_3d.c
index a140b1194..c82629dec 100644
--- a/examples/text/text_draw_3d.c
+++ b/examples/text/text_draw_3d.c
@@ -47,7 +47,7 @@ bool SHOW_TEXT_BOUNDRY = false;
//--------------------------------------------------------------------------------------
// Configuration structure for waving the text
-typedef struct {
+typedef struct WaveTextConfig {
Vector3 waveRange;
Vector3 waveSpeed;
Vector3 waveOffset;
@@ -57,19 +57,19 @@ typedef struct {
// Module Functions Declaration
//--------------------------------------------------------------------------------------
// Draw a codepoint in 3D space
-void DrawTextCodepoint3D(Font font, int codepoint, Vector3 position, float fontSize, bool backface, Color tint);
+static void DrawTextCodepoint3D(Font font, int codepoint, Vector3 position, float fontSize, bool backface, Color tint);
// Draw a 2D text in 3D space
-void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, Color tint);
+static void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, Color tint);
// Measure a text in 3D. For some reason `MeasureTextEx()` just doesn't seem to work so i had to use this instead.
-Vector3 MeasureText3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing);
+static Vector3 MeasureText3D(Font font, const char *text, float fontSize, float fontSpacing, float lineSpacing);
// Draw a 2D text in 3D space and wave the parts that start with `~~` and end with `~~`.
// This is a modified version of the original code by @Nighten found here https://github.com/NightenDushi/Raylib_DrawTextStyle
-void DrawTextWave3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, WaveTextConfig* config, float time, Color tint);
+static void DrawTextWave3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, WaveTextConfig *config, float time, Color tint);
// Measure a text in 3D ignoring the `~~` chars.
-Vector3 MeasureTextWave3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing);
+static Vector3 MeasureTextWave3D(Font font, const char *text, float fontSize, float fontSpacing, float lineSpacing);
// Generates a nice color with a random hue
-Color GenerateRandomColor(float s, float v);
+static Color GenerateRandomColor(float s, float v);
//------------------------------------------------------------------------------------
// Program main entry point
@@ -142,7 +142,7 @@ int main(void)
if (IsFileDropped())
{
int count = 0;
- char **droppedFiles = GetDroppedFiles(&count);
+ char **droppedFiles = LoadDroppedFiles(&count);
// NOTE: We only support first ttf file dropped
if (IsFileExtension(droppedFiles[0], ".ttf"))
@@ -156,7 +156,7 @@ int main(void)
font = LoadFont(droppedFiles[0]);
fontSize = font.baseSize;
}
- ClearDroppedFiles();
+ UnloadDroppedFiles();
}
// Handle Events
@@ -445,7 +445,7 @@ int main(void)
// Module Functions Definitions
//--------------------------------------------------------------------------------------
// Draw codepoint at specified position in 3D space
-void DrawTextCodepoint3D(Font font, int codepoint, Vector3 position, float fontSize, bool backface, Color tint)
+static void DrawTextCodepoint3D(Font font, int codepoint, Vector3 position, float fontSize, bool backface, Color tint)
{
// Character index position in sprite font
// NOTE: In case a codepoint is not available in the font, index returned points to '?'
@@ -511,7 +511,8 @@ void DrawTextCodepoint3D(Font font, int codepoint, Vector3 position, float fontS
}
}
-void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, Color tint)
+// Draw a 2D text in 3D space
+static void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, Color tint)
{
int length = TextLength(text); // Total length in bytes of the text, scanned by codepoints in loop
@@ -553,7 +554,8 @@ void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, f
}
}
-Vector3 MeasureText3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing)
+// Measure a text in 3D. For some reason `MeasureTextEx()` just doesn't seem to work so i had to use this instead.
+static Vector3 MeasureText3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing)
{
int len = TextLength(text);
int tempLen = 0; // Used to count longer text line num chars
@@ -607,8 +609,9 @@ Vector3 MeasureText3D(Font font, const char* text, float fontSize, float fontSpa
return vec;
}
-
-void DrawTextWave3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, WaveTextConfig* config, float time, Color tint)
+// Draw a 2D text in 3D space and wave the parts that start with `~~` and end with `~~`.
+// This is a modified version of the original code by @Nighten found here https://github.com/NightenDushi/Raylib_DrawTextStyle
+static void DrawTextWave3D(Font font, const char *text, Vector3 position, float fontSize, float fontSpacing, float lineSpacing, bool backface, WaveTextConfig* config, float time, Color tint)
{
int length = TextLength(text); // Total length in bytes of the text, scanned by codepoints in loop
@@ -669,7 +672,8 @@ void DrawTextWave3D(Font font, const char *text, Vector3 position, float fontSiz
}
}
-Vector3 MeasureTextWave3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing)
+// Measure a text in 3D ignoring the `~~` chars.
+static Vector3 MeasureTextWave3D(Font font, const char* text, float fontSize, float fontSpacing, float lineSpacing)
{
int len = TextLength(text);
int tempLen = 0; // Used to count longer text line num chars
@@ -730,7 +734,8 @@ Vector3 MeasureTextWave3D(Font font, const char* text, float fontSize, float fon
return vec;
}
-Color GenerateRandomColor(float s, float v)
+// Generates a nice color with a random hue
+static Color GenerateRandomColor(float s, float v)
{
const float Phi = 0.618033988749895f; // Golden ratio conjugate
float h = GetRandomValue(0, 360);
diff --git a/examples/text/text_font_filters.c b/examples/text/text_font_filters.c
index 71213ced9..5fb8fc471 100644
--- a/examples/text/text_font_filters.c
+++ b/examples/text/text_font_filters.c
@@ -80,14 +80,14 @@ int main(void)
if (IsFileDropped())
{
int count = 0;
- char **droppedFiles = GetDroppedFiles(&count);
+ char **droppedFiles = LoadDroppedFiles(&count);
// NOTE: We only support first ttf file dropped
if (IsFileExtension(droppedFiles[0], ".ttf"))
{
UnloadFont(font);
font = LoadFontEx(droppedFiles[0], (int)fontSize, 0, 0);
- ClearDroppedFiles();
+ UnloadDroppedFiles();
}
}
//----------------------------------------------------------------------------------
@@ -123,7 +123,7 @@ int main(void)
// De-Initialization
//--------------------------------------------------------------------------------------
- ClearDroppedFiles(); // Clear internal buffers
+ UnloadDroppedFiles(); // Clear internal buffers
UnloadFont(font); // Font unloading
diff --git a/parser/Makefile b/parser/Makefile
index c9b7f443d..ee87bda3f 100644
--- a/parser/Makefile
+++ b/parser/Makefile
@@ -18,11 +18,11 @@ all:
parse:
./raylib_parser -i ../src/raylib.h -o raylib_api.$(EXTENSION) -f $(FORMAT) -d RLAPI
./raylib_parser -i ../src/raymath.h -o raymath_api.$(EXTENSION) -f $(FORMAT) -d RMAPI
- ./raylib_parser -i ../src/extras/easings.h -o easings_api.$(EXTENSION) -f $(FORMAT) -d EASEDEF
- ./raylib_parser -i ../src/extras/physac.h -o physac_api.$(EXTENSION) -f $(FORMAT) -d PHYSACDEF -t "PHYSAC IMPLEMENTATION"
- ./raylib_parser -i ../src/extras/raygui.h -o raygui_api.$(EXTENSION) -f $(FORMAT) -d RAYGUIAPI -t "RAYGUI IMPLEMENTATION"
- ./raylib_parser -i ../src/extras/rmem.h -o rmem_api.$(EXTENSION) -f $(FORMAT) -d RMEMAPI -t "RMEM IMPLEMENTATION"
./raylib_parser -i ../src/rlgl.h -o rlgl_api.$(EXTENSION) -f $(FORMAT) -d RLAPI -t "RLGL IMPLEMENTATION"
+ ./raylib_parser -i ../src/extras/easings.h -o easings_api.$(EXTENSION) -f $(FORMAT) -d EASEDEF
+ ./raylib_parser -i ../src/extras/rmem.h -o rmem_api.$(EXTENSION) -f $(FORMAT) -d RMEMAPI -t "RMEM IMPLEMENTATION"
+ ./raylib_parser -i ../physac.h -o physac_api.$(EXTENSION) -f $(FORMAT) -d PHYSACDEF -t "PHYSAC IMPLEMENTATION"
+ ./raylib_parser -i ../raygui.h -o raygui_api.$(EXTENSION) -f $(FORMAT) -d RAYGUIAPI -t "RAYGUI IMPLEMENTATION"
clean:
rm -f raylib_parser *.json *.txt *.xml *.lua
diff --git a/projects/Notepad++/raylib_npp_parser/raylib_to_parse.h b/projects/Notepad++/raylib_npp_parser/raylib_to_parse.h
index 85b35a405..6e7f903e7 100644
--- a/projects/Notepad++/raylib_npp_parser/raylib_to_parse.h
+++ b/projects/Notepad++/raylib_npp_parser/raylib_to_parse.h
@@ -149,8 +149,8 @@ RLAPI char **GetDirectoryFiles(const char *dirPath, int *count); // Get filenam
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 char **LoadDroppedFiles(int *count); // Get dropped files names (memory should be freed)
+RLAPI void UnloadDroppedFiles(void); // Clear dropped files paths buffer (free memory)
RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time)
// Compression/Encoding functionality
diff --git a/src/Makefile b/src/Makefile
index 2d8be91d4..0ac80190d 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -82,8 +82,11 @@ RAYLIB_MODULE_MODELS ?= TRUE
RAYLIB_MODULE_RAYGUI ?= FALSE
RAYLIB_MODULE_PHYSAC ?= FALSE
-RAYLIB_MODULE_RAYGUI_PATH ?= $(RAYLIB_SRC_PATH)/extras
-RAYLIB_MODULE_PHYSAC_PATH ?= $(RAYLIB_SRC_PATH)/extras
+# NOTE: Additional libraries have been moved to their own repos:
+# raygui: https://github.com/raysan5/raygui
+# physac: https://github.com/raysan5/physac
+RAYLIB_MODULE_RAYGUI_PATH ?= $(RAYLIB_SRC_PATH)/../../raygui/src
+RAYLIB_MODULE_PHYSAC_PATH ?= $(RAYLIB_SRC_PATH)/../../physac/src
# Use external GLFW library instead of rglfw module
USE_EXTERNAL_GLFW ?= FALSE
diff --git a/src/extras/physac.h b/src/extras/physac.h
deleted file mode 100644
index 3ab427acd..000000000
--- a/src/extras/physac.h
+++ /dev/null
@@ -1,1987 +0,0 @@
-/**********************************************************************************************
-*
-* Physac v1.1 - 2D Physics library for videogames
-*
-* DESCRIPTION:
-*
-* Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop
-* to simulate physics. A physics step contains the following phases: get collision information,
-* apply dynamics, collision solving and position correction. It uses a very simple struct for physic
-* bodies with a position vector to be used in any 3D rendering API.
-*
-* CONFIGURATION:
-*
-* #define PHYSAC_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 PHYSAC_DEBUG
-* Show debug traces log messages about physic bodies creation/destruction, physic system errors,
-* some calculations results and NULL reference exceptions.
-*
-* #define PHYSAC_AVOID_TIMMING_SYSTEM
-* Disables internal timming system, used by UpdatePhysics() to launch timmed physic steps,
-* it allows just running UpdatePhysics() automatically on a separate thread at a desired time step.
-* In case physics steps update needs to be controlled by user with a custom timming mechanism,
-* just define this flag and the internal timming mechanism will be avoided, in that case,
-* timming libraries are neither required by the module.
-*
-* #define PHYSAC_MALLOC()
-* #define PHYSAC_CALLOC()
-* #define PHYSAC_FREE()
-* You can define your own malloc/free implementation replacing stdlib.h malloc()/free() functions.
-* Otherwise it will include stdlib.h and use the C standard library malloc()/free() function.
-*
-* COMPILATION:
-*
-* Use the following code to compile with GCC:
-* gcc -o $(NAME_PART).exe $(FILE_NAME) -s -static -lraylib -lopengl32 -lgdi32 -lwinmm -std=c99
-*
-* VERSIONS HISTORY:
-* 1.1 (20-Jan-2021) @raysan5: Library general revision
-* Removed threading system (up to the user)
-* Support MSVC C++ compilation using CLITERAL()
-* Review DEBUG mechanism for TRACELOG() and all TRACELOG() messages
-* Review internal variables/functions naming for consistency
-* Allow option to avoid internal timming system, to allow app manage the steps
-* 1.0 (12-Jun-2017) First release of the library
-*
-*
-* LICENSE: zlib/libpng
-*
-* Copyright (c) 2016-2022 Victor Fisac (@victorfisac) and 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.
-*
-**********************************************************************************************/
-
-#if !defined(PHYSAC_H)
-#define PHYSAC_H
-
-// 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 PHYSACDEF __declspec(dllexport) // We are building the library as a Win32 shared library (.dll)
- #elif defined(USE_LIBTYPE_SHARED)
- #define PHYSACDEF __declspec(dllimport) // We are using the library as a Win32 shared library (.dll)
- #endif
-#endif
-
-#ifndef PHYSACDEF
- #define PHYSACDEF // We are building or using physac as a static library
-#endif
-
-// Allow custom memory allocators
-#ifndef PHYSAC_MALLOC
- #define PHYSAC_MALLOC(size) malloc(size)
-#endif
-#ifndef PHYSAC_CALLOC
- #define PHYSAC_CALLOC(size, n) calloc(size, n)
-#endif
-#ifndef PHYSAC_FREE
- #define PHYSAC_FREE(ptr) free(ptr)
-#endif
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#define PHYSAC_MAX_BODIES 64 // Maximum number of physic bodies supported
-#define PHYSAC_MAX_MANIFOLDS 4096 // Maximum number of physic bodies interactions (64x64)
-#define PHYSAC_MAX_VERTICES 24 // Maximum number of vertex for polygons shapes
-#define PHYSAC_DEFAULT_CIRCLE_VERTICES 24 // Default number of vertices for circle shapes
-
-#define PHYSAC_COLLISION_ITERATIONS 100
-#define PHYSAC_PENETRATION_ALLOWANCE 0.05f
-#define PHYSAC_PENETRATION_CORRECTION 0.4f
-
-#define PHYSAC_PI 3.14159265358979323846f
-#define PHYSAC_DEG2RAD (PHYSAC_PI/180.0f)
-
-//----------------------------------------------------------------------------------
-// Data Types Structure Definition
-//----------------------------------------------------------------------------------
-#if defined(__STDC__) && __STDC_VERSION__ >= 199901L
- #include
-#endif
-
-typedef enum PhysicsShapeType { PHYSICS_CIRCLE = 0, PHYSICS_POLYGON } PhysicsShapeType;
-
-// Previously defined to be used in PhysicsShape struct as circular dependencies
-typedef struct PhysicsBodyData *PhysicsBody;
-
-#if !defined(RL_VECTOR2_TYPE)
-// Vector2 type
-typedef struct Vector2 {
- float x;
- float y;
-} Vector2;
-#endif
-
-// Matrix2x2 type (used for polygon shape rotation matrix)
-typedef struct Matrix2x2 {
- float m00;
- float m01;
- float m10;
- float m11;
-} Matrix2x2;
-
-typedef struct PhysicsVertexData {
- unsigned int vertexCount; // Vertex count (positions and normals)
- Vector2 positions[PHYSAC_MAX_VERTICES]; // Vertex positions vectors
- Vector2 normals[PHYSAC_MAX_VERTICES]; // Vertex normals vectors
-} PhysicsVertexData;
-
-typedef struct PhysicsShape {
- PhysicsShapeType type; // Shape type (circle or polygon)
- PhysicsBody body; // Shape physics body data pointer
- PhysicsVertexData vertexData; // Shape vertices data (used for polygon shapes)
- float radius; // Shape radius (used for circle shapes)
- Matrix2x2 transform; // Vertices transform matrix 2x2
-} PhysicsShape;
-
-typedef struct PhysicsBodyData {
- unsigned int id; // Unique identifier
- bool enabled; // Enabled dynamics state (collisions are calculated anyway)
- Vector2 position; // Physics body shape pivot
- Vector2 velocity; // Current linear velocity applied to position
- Vector2 force; // Current linear force (reset to 0 every step)
- float angularVelocity; // Current angular velocity applied to orient
- float torque; // Current angular force (reset to 0 every step)
- float orient; // Rotation in radians
- float inertia; // Moment of inertia
- float inverseInertia; // Inverse value of inertia
- float mass; // Physics body mass
- float inverseMass; // Inverse value of mass
- float staticFriction; // Friction when the body has not movement (0 to 1)
- float dynamicFriction; // Friction when the body has movement (0 to 1)
- float restitution; // Restitution coefficient of the body (0 to 1)
- bool useGravity; // Apply gravity force to dynamics
- bool isGrounded; // Physics grounded on other body state
- bool freezeOrient; // Physics rotation constraint
- PhysicsShape shape; // Physics body shape information (type, radius, vertices, transform)
-} PhysicsBodyData;
-
-typedef struct PhysicsManifoldData {
- unsigned int id; // Unique identifier
- PhysicsBody bodyA; // Manifold first physics body reference
- PhysicsBody bodyB; // Manifold second physics body reference
- float penetration; // Depth of penetration from collision
- Vector2 normal; // Normal direction vector from 'a' to 'b'
- Vector2 contacts[2]; // Points of contact during collision
- unsigned int contactsCount; // Current collision number of contacts
- float restitution; // Mixed restitution during collision
- float dynamicFriction; // Mixed dynamic friction during collision
- float staticFriction; // Mixed static friction during collision
-} PhysicsManifoldData, *PhysicsManifold;
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-
-#if defined(__cplusplus)
-extern "C" { // Prevents name mangling of functions
-#endif
-// Physics system management
-PHYSACDEF void InitPhysics(void); // Initializes physics system
-PHYSACDEF void UpdatePhysics(void); // Update physics system
-PHYSACDEF void ResetPhysics(void); // Reset physics system (global variables)
-PHYSACDEF void ClosePhysics(void); // Close physics system and unload used memory
-PHYSACDEF void SetPhysicsTimeStep(double delta); // Sets physics fixed time step in milliseconds. 1.666666 by default
-PHYSACDEF void SetPhysicsGravity(float x, float y); // Sets physics global gravity force
-
-// Physic body creation/destroy
-PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); // Creates a new circle physics body with generic parameters
-PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); // Creates a new rectangle physics body with generic parameters
-PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); // Creates a new polygon physics body with generic parameters
-PHYSACDEF void DestroyPhysicsBody(PhysicsBody body); // Destroy a physics body
-
-// Physic body forces
-PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force); // Adds a force to a physics body
-PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount); // Adds an angular force to a physics body
-PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force); // Shatters a polygon shape physics body to little physics bodies with explosion force
-PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians); // Sets physics body shape transform based on radians parameter
-
-// Query physics info
-PHYSACDEF PhysicsBody GetPhysicsBody(int index); // Returns a physics body of the bodies pool at a specific index
-PHYSACDEF int GetPhysicsBodiesCount(void); // Returns the current amount of created physics bodies
-PHYSACDEF int GetPhysicsShapeType(int index); // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
-PHYSACDEF int GetPhysicsShapeVerticesCount(int index); // Returns the amount of vertices of a physics body shape
-PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); // Returns transformed position of a body shape (body position + vertex transformed position)
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // PHYSAC_H
-
-/***********************************************************************************
-*
-* PHYSAC IMPLEMENTATION
-*
-************************************************************************************/
-
-#if defined(PHYSAC_IMPLEMENTATION)
-
-// Support TRACELOG macros
-#if defined(PHYSAC_DEBUG)
- #include // Required for: printf()
- #define TRACELOG(...) printf(__VA_ARGS__)
-#else
- #define TRACELOG(...) (void)0;
-#endif
-
-#include // Required for: malloc(), calloc(), free()
-#include // Required for: cosf(), sinf(), fabs(), sqrtf()
-
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
- // Time management functionality
- #include // Required for: time(), clock_gettime()
- #if defined(_WIN32)
- #if defined(__cplusplus)
- extern "C" { // Prevents name mangling of functions
- #endif
- // Functions required to query time on Windows
- int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount);
- int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency);
- #if defined(__cplusplus)
- }
- #endif
- #endif
- #if defined(__linux__) || defined(__FreeBSD__)
- #if _POSIX_C_SOURCE < 199309L
- #undef _POSIX_C_SOURCE
- #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
- #endif
- #include // Required for: timespec
- #endif
- #if defined(__APPLE__) // macOS also defines __MACH__
- #include // Required for: mach_absolute_time()
- #endif
-#endif
-
-// NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
-// Plain structures in C++ (without constructors) can be initialized from { } initializers.
-#if defined(__cplusplus)
- #define CLITERAL(type) type
-#else
- #define CLITERAL(type) (type)
-#endif
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#define PHYSAC_MIN(a,b) (((a)<(b))?(a):(b))
-#define PHYSAC_MAX(a,b) (((a)>(b))?(a):(b))
-#define PHYSAC_FLT_MAX 3.402823466e+38f
-#define PHYSAC_EPSILON 0.000001f
-#define PHYSAC_K 1.0f/3.0f
-#define PHYSAC_VECTOR_ZERO CLITERAL(Vector2){ 0.0f, 0.0f }
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-static double deltaTime = 1.0/60.0/10.0 * 1000; // Delta time in milliseconds used for physics steps
-
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
-// Time measure variables
-static double baseClockTicks = 0.0; // Offset clock ticks for MONOTONIC clock
-static unsigned long long int frequency = 0; // Hi-res clock frequency
-static double startTime = 0.0; // Start time in milliseconds
-static double currentTime = 0.0; // Current time in milliseconds
-#endif
-
-// Physics system configuration
-static PhysicsBody bodies[PHYSAC_MAX_BODIES]; // Physics bodies pointers array
-static unsigned int physicsBodiesCount = 0; // Physics world current bodies counter
-static PhysicsManifold contacts[PHYSAC_MAX_MANIFOLDS]; // Physics bodies pointers array
-static unsigned int physicsManifoldsCount = 0; // Physics world current manifolds counter
-
-static Vector2 gravityForce = { 0.0f, 9.81f }; // Physics world gravity force
-
-// Utilities variables
-static unsigned int usedMemory = 0; // Total allocated dynamic memory
-
-//----------------------------------------------------------------------------------
-// Module Internal Functions Declaration
-//----------------------------------------------------------------------------------
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
-// Timming measure functions
-static void InitTimerHiRes(void); // Initializes hi-resolution MONOTONIC timer
-static unsigned long long int GetClockTicks(void); // Get hi-res MONOTONIC time measure in mseconds
-static double GetCurrentTime(void); // Get current time measure in milliseconds
-#endif
-
-static void UpdatePhysicsStep(void); // Update physics step (dynamics, collisions and position corrections)
-
-static int FindAvailableBodyIndex(); // Finds a valid index for a new physics body initialization
-static int FindAvailableManifoldIndex(); // Finds a valid index for a new manifold initialization
-static PhysicsVertexData CreateDefaultPolygon(float radius, int sides); // Creates a random polygon shape with max vertex distance from polygon pivot
-static PhysicsVertexData CreateRectanglePolygon(Vector2 pos, Vector2 size); // Creates a rectangle polygon shape based on a min and max positions
-
-static void InitializePhysicsManifolds(PhysicsManifold manifold); // Initializes physics manifolds to solve collisions
-static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b); // Creates a new physics manifold to solve collision
-static void DestroyPhysicsManifold(PhysicsManifold manifold); // Unitializes and destroys a physics manifold
-
-static void SolvePhysicsManifold(PhysicsManifold manifold); // Solves a created physics manifold between two physics bodies
-static void SolveCircleToCircle(PhysicsManifold manifold); // Solves collision between two circle shape physics bodies
-static void SolveCircleToPolygon(PhysicsManifold manifold); // Solves collision between a circle to a polygon shape physics bodies
-static void SolvePolygonToCircle(PhysicsManifold manifold); // Solves collision between a polygon to a circle shape physics bodies
-static void SolvePolygonToPolygon(PhysicsManifold manifold); // Solves collision between two polygons shape physics bodies
-static void IntegratePhysicsForces(PhysicsBody body); // Integrates physics forces into velocity
-static void IntegratePhysicsVelocity(PhysicsBody body); // Integrates physics velocity into position and forces
-static void IntegratePhysicsImpulses(PhysicsManifold manifold); // Integrates physics collisions impulses to solve collisions
-static void CorrectPhysicsPositions(PhysicsManifold manifold); // Corrects physics bodies positions based on manifolds collision information
-static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index); // Finds two polygon shapes incident face
-static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB); // Finds polygon shapes axis least penetration
-
-// Math required functions
-static Vector2 MathVector2Product(Vector2 vector, float value); // Returns the product of a vector and a value
-static float MathVector2CrossProduct(Vector2 v1, Vector2 v2); // Returns the cross product of two vectors
-static float MathVector2SqrLen(Vector2 vector); // Returns the len square root of a vector
-static float MathVector2DotProduct(Vector2 v1, Vector2 v2); // Returns the dot product of two vectors
-static inline float MathVector2SqrDistance(Vector2 v1, Vector2 v2); // Returns the square root of distance between two vectors
-static void MathVector2Normalize(Vector2 *vector); // Returns the normalized values of a vector
-static Vector2 MathVector2Add(Vector2 v1, Vector2 v2); // Returns the sum of two given vectors
-static Vector2 MathVector2Subtract(Vector2 v1, Vector2 v2); // Returns the subtract of two given vectors
-static Matrix2x2 MathMatFromRadians(float radians); // Returns a matrix 2x2 from a given radians value
-static inline Matrix2x2 MathMatTranspose(Matrix2x2 matrix); // Returns the transpose of a given matrix 2x2
-static inline Vector2 MathMatVector2Product(Matrix2x2 matrix, Vector2 vector); // Returns product between matrix 2x2 and vector
-static int MathVector2Clip(Vector2 normal, Vector2 *faceA, Vector2 *faceB, float clip); // Returns clipping value based on a normal and two faces
-static Vector2 MathTriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3); // Returns the barycenter of a triangle given by 3 points
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-
-// Initializes physics values, pointers and creates physics loop thread
-void InitPhysics(void)
-{
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
- // Initialize high resolution timer
- InitTimerHiRes();
-#endif
-
- TRACELOG("[PHYSAC] Physics module initialized successfully\n");
-}
-
-// Sets physics global gravity force
-void SetPhysicsGravity(float x, float y)
-{
- gravityForce.x = x;
- gravityForce.y = y;
-}
-
-// Creates a new circle physics body with generic parameters
-PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density)
-{
- PhysicsBody body = CreatePhysicsBodyPolygon(pos, radius, PHYSAC_DEFAULT_CIRCLE_VERTICES, density);
- return body;
-}
-
-// Creates a new rectangle physics body with generic parameters
-PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density)
-{
- // NOTE: Make sure body data is initialized to 0
- PhysicsBody body = (PhysicsBody)PHYSAC_CALLOC(sizeof(PhysicsBodyData), 1);
- usedMemory += sizeof(PhysicsBodyData);
-
- int id = FindAvailableBodyIndex();
- if (id != -1)
- {
- // Initialize new body with generic values
- body->id = id;
- body->enabled = true;
- body->position = pos;
- body->shape.type = PHYSICS_POLYGON;
- body->shape.body = body;
- body->shape.transform = MathMatFromRadians(0.0f);
- body->shape.vertexData = CreateRectanglePolygon(pos, CLITERAL(Vector2){ width, height });
-
- // Calculate centroid and moment of inertia
- Vector2 center = { 0.0f, 0.0f };
- float area = 0.0f;
- float inertia = 0.0f;
-
- for (unsigned int i = 0; i < body->shape.vertexData.vertexCount; i++)
- {
- // Triangle vertices, third vertex implied as (0, 0)
- Vector2 p1 = body->shape.vertexData.positions[i];
- unsigned int nextIndex = (((i + 1) < body->shape.vertexData.vertexCount) ? (i + 1) : 0);
- Vector2 p2 = body->shape.vertexData.positions[nextIndex];
-
- float D = MathVector2CrossProduct(p1, p2);
- float triangleArea = D/2;
-
- area += triangleArea;
-
- // Use area to weight the centroid average, not just vertex position
- center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
- center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
-
- float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
- float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
- inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
- }
-
- center.x *= 1.0f/area;
- center.y *= 1.0f/area;
-
- // Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
- // Note: this is not really necessary
- for (unsigned int i = 0; i < body->shape.vertexData.vertexCount; i++)
- {
- body->shape.vertexData.positions[i].x -= center.x;
- body->shape.vertexData.positions[i].y -= center.y;
- }
-
- body->mass = density*area;
- body->inverseMass = ((body->mass != 0.0f) ? 1.0f/body->mass : 0.0f);
- body->inertia = density*inertia;
- body->inverseInertia = ((body->inertia != 0.0f) ? 1.0f/body->inertia : 0.0f);
- body->staticFriction = 0.4f;
- body->dynamicFriction = 0.2f;
- body->restitution = 0.0f;
- body->useGravity = true;
- body->isGrounded = false;
- body->freezeOrient = false;
-
- // Add new body to bodies pointers array and update bodies count
- bodies[physicsBodiesCount] = body;
- physicsBodiesCount++;
-
- TRACELOG("[PHYSAC] Physic body created successfully (id: %i)\n", body->id);
- }
- else TRACELOG("[PHYSAC] Physic body could not be created, PHYSAC_MAX_BODIES reached\n");
-
- return body;
-}
-
-// Creates a new polygon physics body with generic parameters
-PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density)
-{
- PhysicsBody body = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
- usedMemory += sizeof(PhysicsBodyData);
-
- int id = FindAvailableBodyIndex();
- if (id != -1)
- {
- // Initialize new body with generic values
- body->id = id;
- body->enabled = true;
- body->position = pos;
- body->velocity = PHYSAC_VECTOR_ZERO;
- body->force = PHYSAC_VECTOR_ZERO;
- body->angularVelocity = 0.0f;
- body->torque = 0.0f;
- body->orient = 0.0f;
- body->shape.type = PHYSICS_POLYGON;
- body->shape.body = body;
- body->shape.transform = MathMatFromRadians(0.0f);
- body->shape.vertexData = CreateDefaultPolygon(radius, sides);
-
- // Calculate centroid and moment of inertia
- Vector2 center = { 0.0f, 0.0f };
- float area = 0.0f;
- float inertia = 0.0f;
-
- for (unsigned int i = 0; i < body->shape.vertexData.vertexCount; i++)
- {
- // Triangle vertices, third vertex implied as (0, 0)
- Vector2 position1 = body->shape.vertexData.positions[i];
- unsigned int nextIndex = (((i + 1) < body->shape.vertexData.vertexCount) ? (i + 1) : 0);
- Vector2 position2 = body->shape.vertexData.positions[nextIndex];
-
- float cross = MathVector2CrossProduct(position1, position2);
- float triangleArea = cross/2;
-
- area += triangleArea;
-
- // Use area to weight the centroid average, not just vertex position
- center.x += triangleArea*PHYSAC_K*(position1.x + position2.x);
- center.y += triangleArea*PHYSAC_K*(position1.y + position2.y);
-
- float intx2 = position1.x*position1.x + position2.x*position1.x + position2.x*position2.x;
- float inty2 = position1.y*position1.y + position2.y*position1.y + position2.y*position2.y;
- inertia += (0.25f*PHYSAC_K*cross)*(intx2 + inty2);
- }
-
- center.x *= 1.0f/area;
- center.y *= 1.0f/area;
-
- // Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
- // Note: this is not really necessary
- for (unsigned int i = 0; i < body->shape.vertexData.vertexCount; i++)
- {
- body->shape.vertexData.positions[i].x -= center.x;
- body->shape.vertexData.positions[i].y -= center.y;
- }
-
- body->mass = density*area;
- body->inverseMass = ((body->mass != 0.0f) ? 1.0f/body->mass : 0.0f);
- body->inertia = density*inertia;
- body->inverseInertia = ((body->inertia != 0.0f) ? 1.0f/body->inertia : 0.0f);
- body->staticFriction = 0.4f;
- body->dynamicFriction = 0.2f;
- body->restitution = 0.0f;
- body->useGravity = true;
- body->isGrounded = false;
- body->freezeOrient = false;
-
- // Add new body to bodies pointers array and update bodies count
- bodies[physicsBodiesCount] = body;
- physicsBodiesCount++;
-
- TRACELOG("[PHYSAC] Physic body created successfully (id: %i)\n", body->id);
- }
- else TRACELOG("[PHYSAC] Physics body could not be created, PHYSAC_MAX_BODIES reached\n");
-
- return body;
-}
-
-// Adds a force to a physics body
-void PhysicsAddForce(PhysicsBody body, Vector2 force)
-{
- if (body != NULL) body->force = MathVector2Add(body->force, force);
-}
-
-// Adds an angular force to a physics body
-void PhysicsAddTorque(PhysicsBody body, float amount)
-{
- if (body != NULL) body->torque += amount;
-}
-
-// Shatters a polygon shape physics body to little physics bodies with explosion force
-void PhysicsShatter(PhysicsBody body, Vector2 position, float force)
-{
- if (body != NULL)
- {
- if (body->shape.type == PHYSICS_POLYGON)
- {
- PhysicsVertexData vertexData = body->shape.vertexData;
- bool collision = false;
-
- for (unsigned int i = 0; i < vertexData.vertexCount; i++)
- {
- Vector2 positionA = body->position;
- Vector2 positionB = MathMatVector2Product(body->shape.transform, MathVector2Add(body->position, vertexData.positions[i]));
- unsigned int nextIndex = (((i + 1) < vertexData.vertexCount) ? (i + 1) : 0);
- Vector2 positionC = MathMatVector2Product(body->shape.transform, MathVector2Add(body->position, vertexData.positions[nextIndex]));
-
- // Check collision between each triangle
- float alpha = ((positionB.y - positionC.y)*(position.x - positionC.x) + (positionC.x - positionB.x)*(position.y - positionC.y))/
- ((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
-
- float beta = ((positionC.y - positionA.y)*(position.x - positionC.x) + (positionA.x - positionC.x)*(position.y - positionC.y))/
- ((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
-
- float gamma = 1.0f - alpha - beta;
-
- if ((alpha > 0.0f) && (beta > 0.0f) & (gamma > 0.0f))
- {
- collision = true;
- break;
- }
- }
-
- if (collision)
- {
- int count = vertexData.vertexCount;
- Vector2 bodyPos = body->position;
- Vector2 *vertices = (Vector2 *)PHYSAC_MALLOC(sizeof(Vector2)*count);
- Matrix2x2 trans = body->shape.transform;
- for (int i = 0; i < count; i++) vertices[i] = vertexData.positions[i];
-
- // Destroy shattered physics body
- DestroyPhysicsBody(body);
-
- for (int i = 0; i < count; i++)
- {
- int nextIndex = (((i + 1) < count) ? (i + 1) : 0);
- Vector2 center = MathTriangleBarycenter(vertices[i], vertices[nextIndex], PHYSAC_VECTOR_ZERO);
- center = MathVector2Add(bodyPos, center);
- Vector2 offset = MathVector2Subtract(center, bodyPos);
-
- PhysicsBody body = CreatePhysicsBodyPolygon(center, 10, 3, 10); // Create polygon physics body with relevant values
-
- PhysicsVertexData vertexData = { 0 };
- vertexData.vertexCount = 3;
-
- vertexData.positions[0] = MathVector2Subtract(vertices[i], offset);
- vertexData.positions[1] = MathVector2Subtract(vertices[nextIndex], offset);
- vertexData.positions[2] = MathVector2Subtract(position, center);
-
- // Separate vertices to avoid unnecessary physics collisions
- vertexData.positions[0].x *= 0.95f;
- vertexData.positions[0].y *= 0.95f;
- vertexData.positions[1].x *= 0.95f;
- vertexData.positions[1].y *= 0.95f;
- vertexData.positions[2].x *= 0.95f;
- vertexData.positions[2].y *= 0.95f;
-
- // Calculate polygon faces normals
- for (unsigned int j = 0; j < vertexData.vertexCount; j++)
- {
- unsigned int nextVertex = (((j + 1) < vertexData.vertexCount) ? (j + 1) : 0);
- Vector2 face = MathVector2Subtract(vertexData.positions[nextVertex], vertexData.positions[j]);
-
- vertexData.normals[j] = CLITERAL(Vector2){ face.y, -face.x };
- MathVector2Normalize(&vertexData.normals[j]);
- }
-
- // Apply computed vertex data to new physics body shape
- body->shape.vertexData = vertexData;
- body->shape.transform = trans;
-
- // Calculate centroid and moment of inertia
- center = PHYSAC_VECTOR_ZERO;
- float area = 0.0f;
- float inertia = 0.0f;
-
- for (unsigned int j = 0; j < body->shape.vertexData.vertexCount; j++)
- {
- // Triangle vertices, third vertex implied as (0, 0)
- Vector2 p1 = body->shape.vertexData.positions[j];
- unsigned int nextVertex = (((j + 1) < body->shape.vertexData.vertexCount) ? (j + 1) : 0);
- Vector2 p2 = body->shape.vertexData.positions[nextVertex];
-
- float D = MathVector2CrossProduct(p1, p2);
- float triangleArea = D/2;
-
- area += triangleArea;
-
- // Use area to weight the centroid average, not just vertex position
- center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
- center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
-
- float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
- float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
- inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
- }
-
- center.x *= 1.0f/area;
- center.y *= 1.0f/area;
-
- body->mass = area;
- body->inverseMass = ((body->mass != 0.0f) ? 1.0f/body->mass : 0.0f);
- body->inertia = inertia;
- body->inverseInertia = ((body->inertia != 0.0f) ? 1.0f/body->inertia : 0.0f);
-
- // Calculate explosion force direction
- Vector2 pointA = body->position;
- Vector2 pointB = MathVector2Subtract(vertexData.positions[1], vertexData.positions[0]);
- pointB.x /= 2.0f;
- pointB.y /= 2.0f;
- Vector2 forceDirection = MathVector2Subtract(MathVector2Add(pointA, MathVector2Add(vertexData.positions[0], pointB)), body->position);
- MathVector2Normalize(&forceDirection);
- forceDirection.x *= force;
- forceDirection.y *= force;
-
- // Apply force to new physics body
- PhysicsAddForce(body, forceDirection);
- }
-
- PHYSAC_FREE(vertices);
- }
- }
- }
- else TRACELOG("[PHYSAC] WARNING: PhysicsShatter: NULL physic body\n");
-}
-
-// Returns the current amount of created physics bodies
-int GetPhysicsBodiesCount(void)
-{
- return physicsBodiesCount;
-}
-
-// Returns a physics body of the bodies pool at a specific index
-PhysicsBody GetPhysicsBody(int index)
-{
- PhysicsBody body = NULL;
-
- if (index < (int)physicsBodiesCount)
- {
- body = bodies[index];
-
- if (body == NULL) TRACELOG("[PHYSAC] WARNING: GetPhysicsBody: NULL physic body\n");
- }
- else TRACELOG("[PHYSAC] WARNING: Physic body index is out of bounds\n");
-
- return body;
-}
-
-// Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
-int GetPhysicsShapeType(int index)
-{
- int result = -1;
-
- if (index < (int)physicsBodiesCount)
- {
- PhysicsBody body = bodies[index];
-
- if (body != NULL) result = body->shape.type;
- else TRACELOG("[PHYSAC] WARNING: GetPhysicsShapeType: NULL physic body\n");
- }
- else TRACELOG("[PHYSAC] WARNING: Physic body index is out of bounds\n");
-
- return result;
-}
-
-// Returns the amount of vertices of a physics body shape
-int GetPhysicsShapeVerticesCount(int index)
-{
- int result = 0;
-
- if (index < (int)physicsBodiesCount)
- {
- PhysicsBody body = bodies[index];
-
- if (body != NULL)
- {
- switch (body->shape.type)
- {
- case PHYSICS_CIRCLE: result = PHYSAC_DEFAULT_CIRCLE_VERTICES; break;
- case PHYSICS_POLYGON: result = body->shape.vertexData.vertexCount; break;
- default: break;
- }
- }
- else TRACELOG("[PHYSAC] WARNING: GetPhysicsShapeVerticesCount: NULL physic body\n");
- }
- else TRACELOG("[PHYSAC] WARNING: Physic body index is out of bounds\n");
-
- return result;
-}
-
-// Returns transformed position of a body shape (body position + vertex transformed position)
-Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex)
-{
- Vector2 position = { 0.0f, 0.0f };
-
- if (body != NULL)
- {
- switch (body->shape.type)
- {
- case PHYSICS_CIRCLE:
- {
- position.x = body->position.x + cosf(360.0f/PHYSAC_DEFAULT_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
- position.y = body->position.y + sinf(360.0f/PHYSAC_DEFAULT_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
- } break;
- case PHYSICS_POLYGON:
- {
- PhysicsVertexData vertexData = body->shape.vertexData;
- position = MathVector2Add(body->position, MathMatVector2Product(body->shape.transform, vertexData.positions[vertex]));
- } break;
- default: break;
- }
- }
- else TRACELOG("[PHYSAC] WARNING: GetPhysicsShapeVertex: NULL physic body\n");
-
- return position;
-}
-
-// Sets physics body shape transform based on radians parameter
-void SetPhysicsBodyRotation(PhysicsBody body, float radians)
-{
- if (body != NULL)
- {
- body->orient = radians;
-
- if (body->shape.type == PHYSICS_POLYGON) body->shape.transform = MathMatFromRadians(radians);
- }
-}
-
-// Unitializes and destroys a physics body
-void DestroyPhysicsBody(PhysicsBody body)
-{
- if (body != NULL)
- {
- int id = body->id;
- int index = -1;
-
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- if (bodies[i]->id == id)
- {
- index = i;
- break;
- }
- }
-
- if (index == -1)
- {
- TRACELOG("[PHYSAC] WARNING: Requested body (id: %i) can not be found\n", id);
- return; // Prevent access to index -1
- }
-
- // Free body allocated memory
- PHYSAC_FREE(body);
- usedMemory -= sizeof(PhysicsBodyData);
- bodies[index] = NULL;
-
- // Reorder physics bodies pointers array and its catched index
- for (unsigned int i = index; i < physicsBodiesCount; i++)
- {
- if ((i + 1) < physicsBodiesCount) bodies[i] = bodies[i + 1];
- }
-
- // Update physics bodies count
- physicsBodiesCount--;
-
- TRACELOG("[PHYSAC] Physic body destroyed successfully (id: %i)\n", id);
- }
- else TRACELOG("[PHYSAC] WARNING: DestroyPhysicsBody: NULL physic body\n");
-}
-
-// Destroys created physics bodies and manifolds and resets global values
-void ResetPhysics(void)
-{
- if (physicsBodiesCount > 0)
- {
- // Unitialize physics bodies dynamic memory allocations
- for (int i = physicsBodiesCount - 1; i >= 0; i--)
- {
- PhysicsBody body = bodies[i];
-
- if (body != NULL)
- {
- PHYSAC_FREE(body);
- bodies[i] = NULL;
- usedMemory -= sizeof(PhysicsBodyData);
- }
- }
-
- physicsBodiesCount = 0;
- }
-
- if (physicsManifoldsCount > 0)
- {
- // Unitialize physics manifolds dynamic memory allocations
- for (int i = physicsManifoldsCount - 1; i >= 0; i--)
- {
- PhysicsManifold manifold = contacts[i];
-
- if (manifold != NULL)
- {
- PHYSAC_FREE(manifold);
- contacts[i] = NULL;
- usedMemory -= sizeof(PhysicsManifoldData);
- }
- }
-
- physicsManifoldsCount = 0;
- }
-
- TRACELOG("[PHYSAC] Physics module reseted successfully\n");
-}
-
-// Unitializes physics pointers and exits physics loop thread
-void ClosePhysics(void)
-{
- // Unitialize physics manifolds dynamic memory allocations
- if (physicsManifoldsCount > 0)
- {
- for (int i = physicsManifoldsCount - 1; i >= 0; i--) DestroyPhysicsManifold(contacts[i]);
- }
-
- // Unitialize physics bodies dynamic memory allocations
- if (physicsBodiesCount > 0)
- {
- for (int i = physicsBodiesCount - 1; i >= 0; i--) DestroyPhysicsBody(bodies[i]);
- }
-
- // Trace log info
- if ((physicsBodiesCount > 0) || (usedMemory != 0))
- {
- TRACELOG("[PHYSAC] WARNING: Physics module closed with unallocated bodies (BODIES: %i, MEMORY: %i bytes)\n", physicsBodiesCount, usedMemory);
- }
- else if ((physicsManifoldsCount > 0) || (usedMemory != 0))
- {
- TRACELOG("[PHYSAC] WARNING: Pysics module closed with unallocated manifolds (MANIFOLDS: %i, MEMORY: %i bytes)\n", physicsManifoldsCount, usedMemory);
- }
- else TRACELOG("[PHYSAC] Physics module closed successfully\n");
-}
-
-// Update physics system
-// Physics steps are launched at a fixed time step if enabled
-void UpdatePhysics(void)
-{
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
- static double deltaTimeAccumulator = 0.0;
-
- // Calculate current time (ms)
- currentTime = GetCurrentTime();
-
- // Calculate current delta time (ms)
- const double delta = currentTime - startTime;
-
- // Store the time elapsed since the last frame began
- deltaTimeAccumulator += delta;
-
- // Fixed time stepping loop
- while (deltaTimeAccumulator >= deltaTime)
- {
- UpdatePhysicsStep();
- deltaTimeAccumulator -= deltaTime;
- }
-
- // Record the starting of this frame
- startTime = currentTime;
-#else
- UpdatePhysicsStep();
-#endif
-}
-
-void SetPhysicsTimeStep(double delta)
-{
- deltaTime = delta;
-}
-
-//----------------------------------------------------------------------------------
-// Module Internal Functions Definition
-//----------------------------------------------------------------------------------
-#if !defined(PHYSAC_AVOID_TIMMING_SYSTEM)
-// Initializes hi-resolution MONOTONIC timer
-static void InitTimerHiRes(void)
-{
-#if defined(_WIN32)
- QueryPerformanceFrequency((unsigned long long int *) &frequency);
-#endif
-
-#if defined(__EMSCRIPTEN__) || defined(__linux__)
- struct timespec now;
- if (clock_gettime(CLOCK_MONOTONIC, &now) == 0) frequency = 1000000000;
-#endif
-
-#if defined(__APPLE__)
- mach_timebase_info_data_t timebase;
- mach_timebase_info(&timebase);
- frequency = (timebase.denom*1e9)/timebase.numer;
-#endif
-
- baseClockTicks = (double)GetClockTicks(); // Get MONOTONIC clock time offset
- startTime = GetCurrentTime(); // Get current time in milliseconds
-}
-
-// Get hi-res MONOTONIC time measure in clock ticks
-static unsigned long long int GetClockTicks(void)
-{
- unsigned long long int value = 0;
-
-#if defined(_WIN32)
- QueryPerformanceCounter((unsigned long long int *) &value);
-#endif
-
-#if defined(__linux__)
- struct timespec now;
- clock_gettime(CLOCK_MONOTONIC, &now);
- value = (unsigned long long int)now.tv_sec*(unsigned long long int)1000000000 + (unsigned long long int)now.tv_nsec;
-#endif
-
-#if defined(__APPLE__)
- value = mach_absolute_time();
-#endif
-
- return value;
-}
-
-// Get current time in milliseconds
-static double GetCurrentTime(void)
-{
- return (double)(GetClockTicks() - baseClockTicks)/frequency*1000;
-}
-#endif // !PHYSAC_AVOID_TIMMING_SYSTEM
-
-// Update physics step (dynamics, collisions and position corrections)
-static void UpdatePhysicsStep(void)
-{
- // Clear previous generated collisions information
- for (int i = (int)physicsManifoldsCount - 1; i >= 0; i--)
- {
- PhysicsManifold manifold = contacts[i];
- if (manifold != NULL) DestroyPhysicsManifold(manifold);
- }
-
- // Reset physics bodies grounded state
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- PhysicsBody body = bodies[i];
- body->isGrounded = false;
- }
-
- // Generate new collision information
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- PhysicsBody bodyA = bodies[i];
-
- if (bodyA != NULL)
- {
- for (unsigned int j = i + 1; j < physicsBodiesCount; j++)
- {
- PhysicsBody bodyB = bodies[j];
-
- if (bodyB != NULL)
- {
- if ((bodyA->inverseMass == 0) && (bodyB->inverseMass == 0)) continue;
-
- PhysicsManifold manifold = CreatePhysicsManifold(bodyA, bodyB);
- SolvePhysicsManifold(manifold);
-
- if (manifold->contactsCount > 0)
- {
- // Create a new manifold with same information as previously solved manifold and add it to the manifolds pool last slot
- PhysicsManifold manifold = CreatePhysicsManifold(bodyA, bodyB);
- manifold->penetration = manifold->penetration;
- manifold->normal = manifold->normal;
- manifold->contacts[0] = manifold->contacts[0];
- manifold->contacts[1] = manifold->contacts[1];
- manifold->contactsCount = manifold->contactsCount;
- manifold->restitution = manifold->restitution;
- manifold->dynamicFriction = manifold->dynamicFriction;
- manifold->staticFriction = manifold->staticFriction;
- }
- }
- }
- }
- }
-
- // Integrate forces to physics bodies
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- PhysicsBody body = bodies[i];
- if (body != NULL) IntegratePhysicsForces(body);
- }
-
- // Initialize physics manifolds to solve collisions
- for (unsigned int i = 0; i < physicsManifoldsCount; i++)
- {
- PhysicsManifold manifold = contacts[i];
- if (manifold != NULL) InitializePhysicsManifolds(manifold);
- }
-
- // Integrate physics collisions impulses to solve collisions
- for (unsigned int i = 0; i < PHYSAC_COLLISION_ITERATIONS; i++)
- {
- for (unsigned int j = 0; j < physicsManifoldsCount; j++)
- {
- PhysicsManifold manifold = contacts[i];
- if (manifold != NULL) IntegratePhysicsImpulses(manifold);
- }
- }
-
- // Integrate velocity to physics bodies
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- PhysicsBody body = bodies[i];
- if (body != NULL) IntegratePhysicsVelocity(body);
- }
-
- // Correct physics bodies positions based on manifolds collision information
- for (unsigned int i = 0; i < physicsManifoldsCount; i++)
- {
- PhysicsManifold manifold = contacts[i];
- if (manifold != NULL) CorrectPhysicsPositions(manifold);
- }
-
- // Clear physics bodies forces
- for (unsigned int i = 0; i < physicsBodiesCount; i++)
- {
- PhysicsBody body = bodies[i];
- if (body != NULL)
- {
- body->force = PHYSAC_VECTOR_ZERO;
- body->torque = 0.0f;
- }
- }
-}
-
-// Finds a valid index for a new physics body initialization
-static int FindAvailableBodyIndex()
-{
- int index = -1;
- for (int i = 0; i < PHYSAC_MAX_BODIES; i++)
- {
- int currentId = i;
-
- // Check if current id already exist in other physics body
- for (unsigned int k = 0; k < physicsBodiesCount; k++)
- {
- if (bodies[k]->id == currentId)
- {
- currentId++;
- break;
- }
- }
-
- // If it is not used, use it as new physics body id
- if (currentId == (int)i)
- {
- index = (int)i;
- break;
- }
- }
-
- return index;
-}
-
-// Creates a default polygon shape with max vertex distance from polygon pivot
-static PhysicsVertexData CreateDefaultPolygon(float radius, int sides)
-{
- PhysicsVertexData data = { 0 };
- data.vertexCount = sides;
-
- // Calculate polygon vertices positions
- for (unsigned int i = 0; i < data.vertexCount; i++)
- {
- data.positions[i].x = (float)cosf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
- data.positions[i].y = (float)sinf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
- }
-
- // Calculate polygon faces normals
- for (int i = 0; i < (int)data.vertexCount; i++)
- {
- int nextIndex = (((i + 1) < sides) ? (i + 1) : 0);
- Vector2 face = MathVector2Subtract(data.positions[nextIndex], data.positions[i]);
-
- data.normals[i] = CLITERAL(Vector2){ face.y, -face.x };
- MathVector2Normalize(&data.normals[i]);
- }
-
- return data;
-}
-
-// Creates a rectangle polygon shape based on a min and max positions
-static PhysicsVertexData CreateRectanglePolygon(Vector2 pos, Vector2 size)
-{
- PhysicsVertexData data = { 0 };
- data.vertexCount = 4;
-
- // Calculate polygon vertices positions
- data.positions[0] = CLITERAL(Vector2){ pos.x + size.x/2, pos.y - size.y/2 };
- data.positions[1] = CLITERAL(Vector2){ pos.x + size.x/2, pos.y + size.y/2 };
- data.positions[2] = CLITERAL(Vector2){ pos.x - size.x/2, pos.y + size.y/2 };
- data.positions[3] = CLITERAL(Vector2){ pos.x - size.x/2, pos.y - size.y/2 };
-
- // Calculate polygon faces normals
- for (unsigned int i = 0; i < data.vertexCount; i++)
- {
- int nextIndex = (((i + 1) < data.vertexCount) ? (i + 1) : 0);
- Vector2 face = MathVector2Subtract(data.positions[nextIndex], data.positions[i]);
-
- data.normals[i] = CLITERAL(Vector2){ face.y, -face.x };
- MathVector2Normalize(&data.normals[i]);
- }
-
- return data;
-}
-
-// Finds a valid index for a new manifold initialization
-static int FindAvailableManifoldIndex()
-{
- int index = -1;
- for (int i = 0; i < PHYSAC_MAX_MANIFOLDS; i++)
- {
- int currentId = i;
-
- // Check if current id already exist in other physics body
- for (unsigned int k = 0; k < physicsManifoldsCount; k++)
- {
- if (contacts[k]->id == currentId)
- {
- currentId++;
- break;
- }
- }
-
- // If it is not used, use it as new physics body id
- if (currentId == i)
- {
- index = i;
- break;
- }
- }
-
- return index;
-}
-
-// Creates a new physics manifold to solve collision
-static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b)
-{
- PhysicsManifold manifold = (PhysicsManifold)PHYSAC_MALLOC(sizeof(PhysicsManifoldData));
- usedMemory += sizeof(PhysicsManifoldData);
-
- int id = FindAvailableManifoldIndex();
- if (id != -1)
- {
- // Initialize new manifold with generic values
- manifold->id = id;
- manifold->bodyA = a;
- manifold->bodyB = b;
- manifold->penetration = 0;
- manifold->normal = PHYSAC_VECTOR_ZERO;
- manifold->contacts[0] = PHYSAC_VECTOR_ZERO;
- manifold->contacts[1] = PHYSAC_VECTOR_ZERO;
- manifold->contactsCount = 0;
- manifold->restitution = 0.0f;
- manifold->dynamicFriction = 0.0f;
- manifold->staticFriction = 0.0f;
-
- // Add new body to bodies pointers array and update bodies count
- contacts[physicsManifoldsCount] = manifold;
- physicsManifoldsCount++;
- }
- else TRACELOG("[PHYSAC] Physic manifold could not be created, PHYSAC_MAX_MANIFOLDS reached\n");
-
- return manifold;
-}
-
-// Unitializes and destroys a physics manifold
-static void DestroyPhysicsManifold(PhysicsManifold manifold)
-{
- if (manifold != NULL)
- {
- int id = manifold->id;
- int index = -1;
-
- for (unsigned int i = 0; i < physicsManifoldsCount; i++)
- {
- if (contacts[i]->id == id)
- {
- index = i;
- break;
- }
- }
-
- if (index == -1) return; // Prevent access to index -1
-
- // Free manifold allocated memory
- PHYSAC_FREE(manifold);
- usedMemory -= sizeof(PhysicsManifoldData);
- contacts[index] = NULL;
-
- // Reorder physics manifolds pointers array and its catched index
- for (unsigned int i = index; i < physicsManifoldsCount; i++)
- {
- if ((i + 1) < physicsManifoldsCount) contacts[i] = contacts[i + 1];
- }
-
- // Update physics manifolds count
- physicsManifoldsCount--;
- }
- else TRACELOG("[PHYSAC] WARNING: DestroyPhysicsManifold: NULL physic manifold\n");
-}
-
-// Solves a created physics manifold between two physics bodies
-static void SolvePhysicsManifold(PhysicsManifold manifold)
-{
- switch (manifold->bodyA->shape.type)
- {
- case PHYSICS_CIRCLE:
- {
- switch (manifold->bodyB->shape.type)
- {
- case PHYSICS_CIRCLE: SolveCircleToCircle(manifold); break;
- case PHYSICS_POLYGON: SolveCircleToPolygon(manifold); break;
- default: break;
- }
- } break;
- case PHYSICS_POLYGON:
- {
- switch (manifold->bodyB->shape.type)
- {
- case PHYSICS_CIRCLE: SolvePolygonToCircle(manifold); break;
- case PHYSICS_POLYGON: SolvePolygonToPolygon(manifold); break;
- default: break;
- }
- } break;
- default: break;
- }
-
- // Update physics body grounded state if normal direction is down and grounded state is not set yet in previous manifolds
- if (!manifold->bodyB->isGrounded) manifold->bodyB->isGrounded = (manifold->normal.y < 0);
-}
-
-// Solves collision between two circle shape physics bodies
-static void SolveCircleToCircle(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- // Calculate translational vector, which is normal
- Vector2 normal = MathVector2Subtract(bodyB->position, bodyA->position);
-
- float distSqr = MathVector2SqrLen(normal);
- float radius = bodyA->shape.radius + bodyB->shape.radius;
-
- // Check if circles are not in contact
- if (distSqr >= radius*radius)
- {
- manifold->contactsCount = 0;
- return;
- }
-
- float distance = sqrtf(distSqr);
- manifold->contactsCount = 1;
-
- if (distance == 0.0f)
- {
- manifold->penetration = bodyA->shape.radius;
- manifold->normal = CLITERAL(Vector2){ 1.0f, 0.0f };
- manifold->contacts[0] = bodyA->position;
- }
- else
- {
- manifold->penetration = radius - distance;
- manifold->normal = CLITERAL(Vector2){ normal.x/distance, normal.y/distance }; // Faster than using MathVector2Normalize() due to sqrt is already performed
- manifold->contacts[0] = CLITERAL(Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
- }
-
- // Update physics body grounded state if normal direction is down
- if (!bodyA->isGrounded) bodyA->isGrounded = (manifold->normal.y < 0);
-}
-
-// Solves collision between a circle to a polygon shape physics bodies
-static void SolveCircleToPolygon(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- manifold->contactsCount = 0;
-
- // Transform circle center to polygon transform space
- Vector2 center = bodyA->position;
- center = MathMatVector2Product(MathMatTranspose(bodyB->shape.transform), MathVector2Subtract(center, bodyB->position));
-
- // Find edge with minimum penetration
- // It is the same concept as using support points in SolvePolygonToPolygon
- float separation = -PHYSAC_FLT_MAX;
- int faceNormal = 0;
- PhysicsVertexData vertexData = bodyB->shape.vertexData;
-
- for (unsigned int i = 0; i < vertexData.vertexCount; i++)
- {
- float currentSeparation = MathVector2DotProduct(vertexData.normals[i], MathVector2Subtract(center, vertexData.positions[i]));
-
- if (currentSeparation > bodyA->shape.radius) return;
-
- if (currentSeparation > separation)
- {
- separation = currentSeparation;
- faceNormal = i;
- }
- }
-
- // Grab face's vertices
- Vector2 v1 = vertexData.positions[faceNormal];
- int nextIndex = (((faceNormal + 1) < (int)vertexData.vertexCount) ? (faceNormal + 1) : 0);
- Vector2 v2 = vertexData.positions[nextIndex];
-
- // Check to see if center is within polygon
- if (separation < PHYSAC_EPSILON)
- {
- manifold->contactsCount = 1;
- Vector2 normal = MathMatVector2Product(bodyB->shape.transform, vertexData.normals[faceNormal]);
- manifold->normal = CLITERAL(Vector2){ -normal.x, -normal.y };
- manifold->contacts[0] = CLITERAL(Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
- manifold->penetration = bodyA->shape.radius;
- return;
- }
-
- // Determine which voronoi region of the edge center of circle lies within
- float dot1 = MathVector2DotProduct(MathVector2Subtract(center, v1), MathVector2Subtract(v2, v1));
- float dot2 = MathVector2DotProduct(MathVector2Subtract(center, v2), MathVector2Subtract(v1, v2));
- manifold->penetration = bodyA->shape.radius - separation;
-
- if (dot1 <= 0.0f) // Closest to v1
- {
- if (MathVector2SqrDistance(center, v1) > bodyA->shape.radius*bodyA->shape.radius) return;
-
- manifold->contactsCount = 1;
- Vector2 normal = MathVector2Subtract(v1, center);
- normal = MathMatVector2Product(bodyB->shape.transform, normal);
- MathVector2Normalize(&normal);
- manifold->normal = normal;
- v1 = MathMatVector2Product(bodyB->shape.transform, v1);
- v1 = MathVector2Add(v1, bodyB->position);
- manifold->contacts[0] = v1;
- }
- else if (dot2 <= 0.0f) // Closest to v2
- {
- if (MathVector2SqrDistance(center, v2) > bodyA->shape.radius*bodyA->shape.radius) return;
-
- manifold->contactsCount = 1;
- Vector2 normal = MathVector2Subtract(v2, center);
- v2 = MathMatVector2Product(bodyB->shape.transform, v2);
- v2 = MathVector2Add(v2, bodyB->position);
- manifold->contacts[0] = v2;
- normal = MathMatVector2Product(bodyB->shape.transform, normal);
- MathVector2Normalize(&normal);
- manifold->normal = normal;
- }
- else // Closest to face
- {
- Vector2 normal = vertexData.normals[faceNormal];
-
- if (MathVector2DotProduct(MathVector2Subtract(center, v1), normal) > bodyA->shape.radius) return;
-
- normal = MathMatVector2Product(bodyB->shape.transform, normal);
- manifold->normal = CLITERAL(Vector2){ -normal.x, -normal.y };
- manifold->contacts[0] = CLITERAL(Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
- manifold->contactsCount = 1;
- }
-}
-
-// Solves collision between a polygon to a circle shape physics bodies
-static void SolvePolygonToCircle(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- manifold->bodyA = bodyB;
- manifold->bodyB = bodyA;
- SolveCircleToPolygon(manifold);
-
- manifold->normal.x *= -1.0f;
- manifold->normal.y *= -1.0f;
-}
-
-// Solves collision between two polygons shape physics bodies
-static void SolvePolygonToPolygon(PhysicsManifold manifold)
-{
- if ((manifold->bodyA == NULL) || (manifold->bodyB == NULL)) return;
-
- PhysicsShape bodyA = manifold->bodyA->shape;
- PhysicsShape bodyB = manifold->bodyB->shape;
- manifold->contactsCount = 0;
-
- // Check for separating axis with A shape's face planes
- int faceA = 0;
- float penetrationA = FindAxisLeastPenetration(&faceA, bodyA, bodyB);
- if (penetrationA >= 0.0f) return;
-
- // Check for separating axis with B shape's face planes
- int faceB = 0;
- float penetrationB = FindAxisLeastPenetration(&faceB, bodyB, bodyA);
- if (penetrationB >= 0.0f) return;
-
- int referenceIndex = 0;
- bool flip = false; // Always point from A shape to B shape
-
- PhysicsShape refPoly; // Reference
- PhysicsShape incPoly; // Incident
-
- // Determine which shape contains reference face
- // Checking bias range for penetration
- if (penetrationA >= (penetrationB*0.95f + penetrationA*0.01f))
- {
- refPoly = bodyA;
- incPoly = bodyB;
- referenceIndex = faceA;
- }
- else
- {
- refPoly = bodyB;
- incPoly = bodyA;
- referenceIndex = faceB;
- flip = true;
- }
-
- // World space incident face
- Vector2 incidentFace[2];
- FindIncidentFace(&incidentFace[0], &incidentFace[1], refPoly, incPoly, referenceIndex);
-
- // Setup reference face vertices
- PhysicsVertexData refData = refPoly.vertexData;
- Vector2 v1 = refData.positions[referenceIndex];
- referenceIndex = (((referenceIndex + 1) < (int)refData.vertexCount) ? (referenceIndex + 1) : 0);
- Vector2 v2 = refData.positions[referenceIndex];
-
- // Transform vertices to world space
- v1 = MathMatVector2Product(refPoly.transform, v1);
- v1 = MathVector2Add(v1, refPoly.body->position);
- v2 = MathMatVector2Product(refPoly.transform, v2);
- v2 = MathVector2Add(v2, refPoly.body->position);
-
- // Calculate reference face side normal in world space
- Vector2 sidePlaneNormal = MathVector2Subtract(v2, v1);
- MathVector2Normalize(&sidePlaneNormal);
-
- // Orthogonalize
- Vector2 refFaceNormal = { sidePlaneNormal.y, -sidePlaneNormal.x };
- float refC = MathVector2DotProduct(refFaceNormal, v1);
- float negSide = MathVector2DotProduct(sidePlaneNormal, v1)*-1;
- float posSide = MathVector2DotProduct(sidePlaneNormal, v2);
-
- // MathVector2Clip incident face to reference face side planes (due to floating point error, possible to not have required points
- if (MathVector2Clip(CLITERAL(Vector2){ -sidePlaneNormal.x, -sidePlaneNormal.y }, &incidentFace[0], &incidentFace[1], negSide) < 2) return;
- if (MathVector2Clip(sidePlaneNormal, &incidentFace[0], &incidentFace[1], posSide) < 2) return;
-
- // Flip normal if required
- manifold->normal = (flip ? CLITERAL(Vector2){ -refFaceNormal.x, -refFaceNormal.y } : refFaceNormal);
-
- // Keep points behind reference face
- int currentPoint = 0; // MathVector2Clipped points behind reference face
- float separation = MathVector2DotProduct(refFaceNormal, incidentFace[0]) - refC;
- if (separation <= 0.0f)
- {
- manifold->contacts[currentPoint] = incidentFace[0];
- manifold->penetration = -separation;
- currentPoint++;
- }
- else manifold->penetration = 0.0f;
-
- separation = MathVector2DotProduct(refFaceNormal, incidentFace[1]) - refC;
-
- if (separation <= 0.0f)
- {
- manifold->contacts[currentPoint] = incidentFace[1];
- manifold->penetration += -separation;
- currentPoint++;
-
- // Calculate total penetration average
- manifold->penetration /= currentPoint;
- }
-
- manifold->contactsCount = currentPoint;
-}
-
-// Integrates physics forces into velocity
-static void IntegratePhysicsForces(PhysicsBody body)
-{
- if ((body == NULL) || (body->inverseMass == 0.0f) || !body->enabled) return;
-
- body->velocity.x += (float)((body->force.x*body->inverseMass)*(deltaTime/2.0));
- body->velocity.y += (float)((body->force.y*body->inverseMass)*(deltaTime/2.0));
-
- if (body->useGravity)
- {
- body->velocity.x += (float)(gravityForce.x*(deltaTime/1000/2.0));
- body->velocity.y += (float)(gravityForce.y*(deltaTime/1000/2.0));
- }
-
- if (!body->freezeOrient) body->angularVelocity += (float)(body->torque*body->inverseInertia*(deltaTime/2.0));
-}
-
-// Initializes physics manifolds to solve collisions
-static void InitializePhysicsManifolds(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- // Calculate average restitution, static and dynamic friction
- manifold->restitution = sqrtf(bodyA->restitution*bodyB->restitution);
- manifold->staticFriction = sqrtf(bodyA->staticFriction*bodyB->staticFriction);
- manifold->dynamicFriction = sqrtf(bodyA->dynamicFriction*bodyB->dynamicFriction);
-
- for (unsigned int i = 0; i < manifold->contactsCount; i++)
- {
- // Caculate radius from center of mass to contact
- Vector2 radiusA = MathVector2Subtract(manifold->contacts[i], bodyA->position);
- Vector2 radiusB = MathVector2Subtract(manifold->contacts[i], bodyB->position);
-
- Vector2 crossA = MathVector2Product(radiusA, bodyA->angularVelocity);
- Vector2 crossB = MathVector2Product(radiusB, bodyB->angularVelocity);
-
- Vector2 radiusV = { 0.0f, 0.0f };
- radiusV.x = bodyB->velocity.x + crossB.x - bodyA->velocity.x - crossA.x;
- radiusV.y = bodyB->velocity.y + crossB.y - bodyA->velocity.y - crossA.y;
-
- // Determine if we should perform a resting collision or not;
- // The idea is if the only thing moving this object is gravity, then the collision should be performed without any restitution
- if (MathVector2SqrLen(radiusV) < (MathVector2SqrLen(CLITERAL(Vector2){ (float)(gravityForce.x*deltaTime/1000), (float)(gravityForce.y*deltaTime/1000) }) + PHYSAC_EPSILON)) manifold->restitution = 0;
- }
-}
-
-// Integrates physics collisions impulses to solve collisions
-static void IntegratePhysicsImpulses(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- // Early out and positional correct if both objects have infinite mass
- if (fabs(bodyA->inverseMass + bodyB->inverseMass) <= PHYSAC_EPSILON)
- {
- bodyA->velocity = PHYSAC_VECTOR_ZERO;
- bodyB->velocity = PHYSAC_VECTOR_ZERO;
- return;
- }
-
- for (unsigned int i = 0; i < manifold->contactsCount; i++)
- {
- // Calculate radius from center of mass to contact
- Vector2 radiusA = MathVector2Subtract(manifold->contacts[i], bodyA->position);
- Vector2 radiusB = MathVector2Subtract(manifold->contacts[i], bodyB->position);
-
- // Calculate relative velocity
- Vector2 radiusV = { 0.0f, 0.0f };
- radiusV.x = bodyB->velocity.x + MathVector2Product(radiusB, bodyB->angularVelocity).x - bodyA->velocity.x - MathVector2Product(radiusA, bodyA->angularVelocity).x;
- radiusV.y = bodyB->velocity.y + MathVector2Product(radiusB, bodyB->angularVelocity).y - bodyA->velocity.y - MathVector2Product(radiusA, bodyA->angularVelocity).y;
-
- // Relative velocity along the normal
- float contactVelocity = MathVector2DotProduct(radiusV, manifold->normal);
-
- // Do not resolve if velocities are separating
- if (contactVelocity > 0.0f) return;
-
- float raCrossN = MathVector2CrossProduct(radiusA, manifold->normal);
- float rbCrossN = MathVector2CrossProduct(radiusB, manifold->normal);
-
- float inverseMassSum = bodyA->inverseMass + bodyB->inverseMass + (raCrossN*raCrossN)*bodyA->inverseInertia + (rbCrossN*rbCrossN)*bodyB->inverseInertia;
-
- // Calculate impulse scalar value
- float impulse = -(1.0f + manifold->restitution)*contactVelocity;
- impulse /= inverseMassSum;
- impulse /= (float)manifold->contactsCount;
-
- // Apply impulse to each physics body
- Vector2 impulseV = { manifold->normal.x*impulse, manifold->normal.y*impulse };
-
- if (bodyA->enabled)
- {
- bodyA->velocity.x += bodyA->inverseMass*(-impulseV.x);
- bodyA->velocity.y += bodyA->inverseMass*(-impulseV.y);
- if (!bodyA->freezeOrient) bodyA->angularVelocity += bodyA->inverseInertia*MathVector2CrossProduct(radiusA, CLITERAL(Vector2){ -impulseV.x, -impulseV.y });
- }
-
- if (bodyB->enabled)
- {
- bodyB->velocity.x += bodyB->inverseMass*(impulseV.x);
- bodyB->velocity.y += bodyB->inverseMass*(impulseV.y);
- if (!bodyB->freezeOrient) bodyB->angularVelocity += bodyB->inverseInertia*MathVector2CrossProduct(radiusB, impulseV);
- }
-
- // Apply friction impulse to each physics body
- radiusV.x = bodyB->velocity.x + MathVector2Product(radiusB, bodyB->angularVelocity).x - bodyA->velocity.x - MathVector2Product(radiusA, bodyA->angularVelocity).x;
- radiusV.y = bodyB->velocity.y + MathVector2Product(radiusB, bodyB->angularVelocity).y - bodyA->velocity.y - MathVector2Product(radiusA, bodyA->angularVelocity).y;
-
- Vector2 tangent = { radiusV.x - (manifold->normal.x*MathVector2DotProduct(radiusV, manifold->normal)), radiusV.y - (manifold->normal.y*MathVector2DotProduct(radiusV, manifold->normal)) };
- MathVector2Normalize(&tangent);
-
- // Calculate impulse tangent magnitude
- float impulseTangent = -MathVector2DotProduct(radiusV, tangent);
- impulseTangent /= inverseMassSum;
- impulseTangent /= (float)manifold->contactsCount;
-
- float absImpulseTangent = (float)fabs(impulseTangent);
-
- // Don't apply tiny friction impulses
- if (absImpulseTangent <= PHYSAC_EPSILON) return;
-
- // Apply coulumb's law
- Vector2 tangentImpulse = { 0.0f, 0.0f };
- if (absImpulseTangent < impulse*manifold->staticFriction) tangentImpulse = CLITERAL(Vector2){ tangent.x*impulseTangent, tangent.y*impulseTangent };
- else tangentImpulse = CLITERAL(Vector2){ tangent.x*-impulse*manifold->dynamicFriction, tangent.y*-impulse*manifold->dynamicFriction };
-
- // Apply friction impulse
- if (bodyA->enabled)
- {
- bodyA->velocity.x += bodyA->inverseMass*(-tangentImpulse.x);
- bodyA->velocity.y += bodyA->inverseMass*(-tangentImpulse.y);
-
- if (!bodyA->freezeOrient) bodyA->angularVelocity += bodyA->inverseInertia*MathVector2CrossProduct(radiusA, CLITERAL(Vector2){ -tangentImpulse.x, -tangentImpulse.y });
- }
-
- if (bodyB->enabled)
- {
- bodyB->velocity.x += bodyB->inverseMass*(tangentImpulse.x);
- bodyB->velocity.y += bodyB->inverseMass*(tangentImpulse.y);
-
- if (!bodyB->freezeOrient) bodyB->angularVelocity += bodyB->inverseInertia*MathVector2CrossProduct(radiusB, tangentImpulse);
- }
- }
-}
-
-// Integrates physics velocity into position and forces
-static void IntegratePhysicsVelocity(PhysicsBody body)
-{
- if ((body == NULL) ||!body->enabled) return;
-
- body->position.x += (float)(body->velocity.x*deltaTime);
- body->position.y += (float)(body->velocity.y*deltaTime);
-
- if (!body->freezeOrient) body->orient += (float)(body->angularVelocity*deltaTime);
- body->shape.transform = MathMatFromRadians(body->orient);
-
- IntegratePhysicsForces(body);
-}
-
-// Corrects physics bodies positions based on manifolds collision information
-static void CorrectPhysicsPositions(PhysicsManifold manifold)
-{
- PhysicsBody bodyA = manifold->bodyA;
- PhysicsBody bodyB = manifold->bodyB;
-
- if ((bodyA == NULL) || (bodyB == NULL)) return;
-
- Vector2 correction = { 0.0f, 0.0f };
- correction.x = (PHYSAC_MAX(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.x*PHYSAC_PENETRATION_CORRECTION;
- correction.y = (PHYSAC_MAX(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.y*PHYSAC_PENETRATION_CORRECTION;
-
- if (bodyA->enabled)
- {
- bodyA->position.x -= correction.x*bodyA->inverseMass;
- bodyA->position.y -= correction.y*bodyA->inverseMass;
- }
-
- if (bodyB->enabled)
- {
- bodyB->position.x += correction.x*bodyB->inverseMass;
- bodyB->position.y += correction.y*bodyB->inverseMass;
- }
-}
-
-// Returns the extreme point along a direction within a polygon
-static Vector2 GetSupport(PhysicsShape shape, Vector2 dir)
-{
- float bestProjection = -PHYSAC_FLT_MAX;
- Vector2 bestVertex = { 0.0f, 0.0f };
- PhysicsVertexData data = shape.vertexData;
-
- for (unsigned int i = 0; i < data.vertexCount; i++)
- {
- Vector2 vertex = data.positions[i];
- float projection = MathVector2DotProduct(vertex, dir);
-
- if (projection > bestProjection)
- {
- bestVertex = vertex;
- bestProjection = projection;
- }
- }
-
- return bestVertex;
-}
-
-// Finds polygon shapes axis least penetration
-static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB)
-{
- float bestDistance = -PHYSAC_FLT_MAX;
- int bestIndex = 0;
-
- PhysicsVertexData dataA = shapeA.vertexData;
- //PhysicsVertexData dataB = shapeB.vertexData;
-
- for (unsigned int i = 0; i < dataA.vertexCount; i++)
- {
- // Retrieve a face normal from A shape
- Vector2 normal = dataA.normals[i];
- Vector2 transNormal = MathMatVector2Product(shapeA.transform, normal);
-
- // Transform face normal into B shape's model space
- Matrix2x2 buT = MathMatTranspose(shapeB.transform);
- normal = MathMatVector2Product(buT, transNormal);
-
- // Retrieve support point from B shape along -n
- Vector2 support = GetSupport(shapeB, CLITERAL(Vector2){ -normal.x, -normal.y });
-
- // Retrieve vertex on face from A shape, transform into B shape's model space
- Vector2 vertex = dataA.positions[i];
- vertex = MathMatVector2Product(shapeA.transform, vertex);
- vertex = MathVector2Add(vertex, shapeA.body->position);
- vertex = MathVector2Subtract(vertex, shapeB.body->position);
- vertex = MathMatVector2Product(buT, vertex);
-
- // Compute penetration distance in B shape's model space
- float distance = MathVector2DotProduct(normal, MathVector2Subtract(support, vertex));
-
- // Store greatest distance
- if (distance > bestDistance)
- {
- bestDistance = distance;
- bestIndex = i;
- }
- }
-
- *faceIndex = bestIndex;
- return bestDistance;
-}
-
-// Finds two polygon shapes incident face
-static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index)
-{
- PhysicsVertexData refData = ref.vertexData;
- PhysicsVertexData incData = inc.vertexData;
-
- Vector2 referenceNormal = refData.normals[index];
-
- // Calculate normal in incident's frame of reference
- referenceNormal = MathMatVector2Product(ref.transform, referenceNormal); // To world space
- referenceNormal = MathMatVector2Product(MathMatTranspose(inc.transform), referenceNormal); // To incident's model space
-
- // Find most anti-normal face on polygon
- int incidentFace = 0;
- float minDot = PHYSAC_FLT_MAX;
-
- for (unsigned int i = 0; i < incData.vertexCount; i++)
- {
- float dot = MathVector2DotProduct(referenceNormal, incData.normals[i]);
-
- if (dot < minDot)
- {
- minDot = dot;
- incidentFace = i;
- }
- }
-
- // Assign face vertices for incident face
- *v0 = MathMatVector2Product(inc.transform, incData.positions[incidentFace]);
- *v0 = MathVector2Add(*v0, inc.body->position);
- incidentFace = (((incidentFace + 1) < (int)incData.vertexCount) ? (incidentFace + 1) : 0);
- *v1 = MathMatVector2Product(inc.transform, incData.positions[incidentFace]);
- *v1 = MathVector2Add(*v1, inc.body->position);
-}
-
-// Returns clipping value based on a normal and two faces
-static int MathVector2Clip(Vector2 normal, Vector2 *faceA, Vector2 *faceB, float clip)
-{
- int sp = 0;
- Vector2 out[2] = { *faceA, *faceB };
-
- // Retrieve distances from each endpoint to the line
- float distanceA = MathVector2DotProduct(normal, *faceA) - clip;
- float distanceB = MathVector2DotProduct(normal, *faceB) - clip;
-
- // If negative (behind plane)
- if (distanceA <= 0.0f) out[sp++] = *faceA;
- if (distanceB <= 0.0f) out[sp++] = *faceB;
-
- // If the points are on different sides of the plane
- if ((distanceA*distanceB) < 0.0f)
- {
- // Push intersection point
- float alpha = distanceA/(distanceA - distanceB);
- out[sp] = *faceA;
- Vector2 delta = MathVector2Subtract(*faceB, *faceA);
- delta.x *= alpha;
- delta.y *= alpha;
- out[sp] = MathVector2Add(out[sp], delta);
- sp++;
- }
-
- // Assign the new converted values
- *faceA = out[0];
- *faceB = out[1];
-
- return sp;
-}
-
-// Returns the barycenter of a triangle given by 3 points
-static Vector2 MathTriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3)
-{
- Vector2 result = { 0.0f, 0.0f };
-
- result.x = (v1.x + v2.x + v3.x)/3;
- result.y = (v1.y + v2.y + v3.y)/3;
-
- return result;
-}
-
-// Returns the cross product of a vector and a value
-static inline Vector2 MathVector2Product(Vector2 vector, float value)
-{
- Vector2 result = { -value*vector.y, value*vector.x };
- return result;
-}
-
-// Returns the cross product of two vectors
-static inline float MathVector2CrossProduct(Vector2 v1, Vector2 v2)
-{
- return (v1.x*v2.y - v1.y*v2.x);
-}
-
-// Returns the len square root of a vector
-static inline float MathVector2SqrLen(Vector2 vector)
-{
- return (vector.x*vector.x + vector.y*vector.y);
-}
-
-// Returns the dot product of two vectors
-static inline float MathVector2DotProduct(Vector2 v1, Vector2 v2)
-{
- return (v1.x*v2.x + v1.y*v2.y);
-}
-
-// Returns the square root of distance between two vectors
-static inline float MathVector2SqrDistance(Vector2 v1, Vector2 v2)
-{
- Vector2 dir = MathVector2Subtract(v1, v2);
- return MathVector2DotProduct(dir, dir);
-}
-
-// Returns the normalized values of a vector
-static void MathVector2Normalize(Vector2 *vector)
-{
- float length, ilength;
-
- Vector2 aux = *vector;
- length = sqrtf(aux.x*aux.x + aux.y*aux.y);
-
- if (length == 0) length = 1.0f;
-
- ilength = 1.0f/length;
-
- vector->x *= ilength;
- vector->y *= ilength;
-}
-
-// Returns the sum of two given vectors
-static inline Vector2 MathVector2Add(Vector2 v1, Vector2 v2)
-{
- Vector2 result = { v1.x + v2.x, v1.y + v2.y };
- return result;
-}
-
-// Returns the subtract of two given vectors
-static inline Vector2 MathVector2Subtract(Vector2 v1, Vector2 v2)
-{
- Vector2 result = { v1.x - v2.x, v1.y - v2.y };
- return result;
-}
-
-// Creates a matrix 2x2 from a given radians value
-static Matrix2x2 MathMatFromRadians(float radians)
-{
- float cos = cosf(radians);
- float sin = sinf(radians);
-
- Matrix2x2 result = { cos, -sin, sin, cos };
- return result;
-}
-
-// Returns the transpose of a given matrix 2x2
-static inline Matrix2x2 MathMatTranspose(Matrix2x2 matrix)
-{
- Matrix2x2 result = { matrix.m00, matrix.m10, matrix.m01, matrix.m11 };
- return result;
-}
-
-// Multiplies a vector by a matrix 2x2
-static inline Vector2 MathMatVector2Product(Matrix2x2 matrix, Vector2 vector)
-{
- Vector2 result = { matrix.m00*vector.x + matrix.m01*vector.y, matrix.m10*vector.x + matrix.m11*vector.y };
- return result;
-}
-
-#endif // PHYSAC_IMPLEMENTATION
diff --git a/src/raylib.h b/src/raylib.h
index 4e989795e..b6037eda2 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -1,6 +1,6 @@
/**********************************************************************************************
*
-* raylib v4.1-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+* raylib v4.2-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
@@ -80,7 +80,7 @@
#include // Required for: va_list - Only used by TraceLogCallback
-#define RAYLIB_VERSION "4.1-dev"
+#define RAYLIB_VERSION "4.2-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
@@ -843,7 +843,7 @@ typedef enum {
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_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha
BLEND_CUSTOM // Blend textures using custom src/dst factors (use rlSetBlendMode())
} BlendMode;
@@ -958,7 +958,7 @@ RLAPI void DisableEventWaiting(void); // Disable wai
// 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)
+RLAPI void WaitTime(double seconds); // Wait for some time (halt program execution)
// Cursor-related functions
RLAPI void ShowCursor(void); // Shows cursor
@@ -1008,9 +1008,9 @@ RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray t
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 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen 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)
@@ -1057,12 +1057,12 @@ RLAPI const char *GetDirectoryPath(const char *filePath); // Get full pa
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 must 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 char **LoadDirectoryFiles(const char *dirPath, int *count); // Load directory filepaths
+RLAPI void UnloadDirectoryFiles(void); // Unload directory filepaths
RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window
-RLAPI char **GetDroppedFiles(int *count); // Get dropped files names (memory must be freed)
-RLAPI void ClearDroppedFiles(void); // Clear dropped files paths buffer (free memory)
+RLAPI char **LoadDroppedFiles(int *count); // Load dropped filepaths
+RLAPI void UnloadDroppedFiles(void); // Unload dropped filepaths
RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time)
// Compression/Encoding functionality
diff --git a/src/rcore.c b/src/rcore.c
index aa1bd2726..75ad37d1f 100644
--- a/src/rcore.c
+++ b/src/rcore.c
@@ -194,9 +194,9 @@
#define DIRENT_MALLOC RL_MALLOC
#define DIRENT_FREE RL_FREE
- #include "external/dirent.h" // Required for: DIR, opendir(), closedir() [Used in GetDirectoryFiles()]
+ #include "external/dirent.h" // Required for: DIR, opendir(), closedir() [Used in LoadDirectoryFiles()]
#else
- #include // Required for: DIR, opendir(), closedir() [Used in GetDirectoryFiles()]
+ #include // Required for: DIR, opendir(), closedir() [Used in LoadDirectoryFiles()]
#endif
#if defined(_WIN32)
@@ -422,7 +422,7 @@ typedef struct CoreData {
Point renderOffset; // Offset from render area (must be divided by 2)
Matrix screenScale; // Matrix to scale screen (framebuffer rendering)
- char **dropFilesPath; // Store dropped files paths as strings
+ char **dropFilepaths; // Store dropped files paths as strings
int dropFileCount; // Count dropped files strings
} Window;
@@ -2087,8 +2087,8 @@ void EndDrawing(void)
// Get image data for the current frame (from backbuffer)
// NOTE: This process is quite slow... :(
Vector2 scale = GetWindowScaleDPI();
- unsigned char *screenData = rlReadScreenPixels(CORE.Window.render.width*scale.x, CORE.Window.render.height*scale.y);
- msf_gif_frame(&gifState, screenData, 10, 16, CORE.Window.render.width*scale.x*4);
+ unsigned char *screenData = rlReadScreenPixels((int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y));
+ msf_gif_frame(&gifState, screenData, 10, 16, (int)((float)CORE.Window.render.width*scale.x)*4);
RL_FREE(screenData); // Free image data
}
@@ -2146,7 +2146,7 @@ void EndDrawing(void)
// Wait for some milliseconds...
if (CORE.Time.frame < CORE.Time.target)
{
- WaitTime((float)(CORE.Time.target - CORE.Time.frame)*1000.0f);
+ WaitTime(CORE.Time.target - CORE.Time.frame);
CORE.Time.current = GetTime();
double waitTime = CORE.Time.current - CORE.Time.previous;
@@ -2811,8 +2811,8 @@ void TakeScreenshot(const char *fileName)
{
#if defined(SUPPORT_MODULE_RTEXTURES)
Vector2 scale = GetWindowScaleDPI();
- unsigned char *imgData = rlReadScreenPixels(CORE.Window.render.width*scale.x, CORE.Window.render.height*scale.y);
- Image image = { imgData, CORE.Window.render.width*scale.x, CORE.Window.render.height*scale.y, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
+ unsigned char *imgData = rlReadScreenPixels((int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y));
+ Image image = { imgData, (int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y), 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
char path[2048] = { 0 };
strcpy(path, TextFormat("%s/%s", CORE.Storage.basePath, fileName));
@@ -3146,11 +3146,11 @@ const char *GetApplicationDirectory(void)
return appDir;
}
-// Get filenames in a directory path
+// Load directory filepaths
// NOTE: Files count is returned by parameters pointer
-char **GetDirectoryFiles(const char *dirPath, int *fileCount)
+char **LoadDirectoryFiles(const char *dirPath, int *fileCount)
{
- ClearDirectoryFiles();
+ UnloadDirectoryFiles();
int counter = 0;
struct dirent *entity;
@@ -3181,8 +3181,8 @@ char **GetDirectoryFiles(const char *dirPath, int *fileCount)
return dirFilesPath;
}
-// Clear directory files paths buffers
-void ClearDirectoryFiles(void)
+// Unload directory filepaths
+void UnloadDirectoryFiles(void)
{
if (dirFileCount > 0)
{
@@ -3211,21 +3211,21 @@ bool IsFileDropped(void)
else return false;
}
-// Get dropped files names
-char **GetDroppedFiles(int *count)
+// Load dropped filepaths
+char **LoadDroppedFiles(int *count)
{
*count = CORE.Window.dropFileCount;
- return CORE.Window.dropFilesPath;
+ return CORE.Window.dropFilepaths;
}
-// Clear dropped files paths buffer
-void ClearDroppedFiles(void)
+// Unload dropped filepaths
+void UnloadDroppedFiles(void)
{
if (CORE.Window.dropFileCount > 0)
{
- for (int i = 0; i < CORE.Window.dropFileCount; i++) RL_FREE(CORE.Window.dropFilesPath[i]);
+ for (int i = 0; i < CORE.Window.dropFileCount; i++) RL_FREE(CORE.Window.dropFilepaths[i]);
- RL_FREE(CORE.Window.dropFilesPath);
+ RL_FREE(CORE.Window.dropFilepaths);
CORE.Window.dropFileCount = 0;
}
@@ -4872,49 +4872,46 @@ static void InitTimer(void)
CORE.Time.previous = GetTime(); // Get time as double
}
-// Wait for some milliseconds (stop program execution)
+// Wait for some time (stop program execution)
// NOTE: Sleep() granularity could be around 10 ms, it means, Sleep() could
// take longer than expected... for that reason we use the busy wait loop
// Ref: http://stackoverflow.com/questions/43057578/c-programming-win32-games-sleep-taking-longer-than-expected
// Ref: http://www.geisswerks.com/ryan/FAQS/timing.html --> All about timming on Win32!
-void WaitTime(float ms)
+void WaitTime(double seconds)
{
-#if defined(SUPPORT_BUSY_WAIT_LOOP)
- double previousTime = GetTime();
- double currentTime = 0.0;
+#if defined(SUPPORT_BUSY_WAIT_LOOP) || defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
+ double destinationTime = GetTime() + seconds;
+#endif
- // Busy wait loop
- while ((currentTime - previousTime) < ms/1000.0f) currentTime = GetTime();
+#if defined(SUPPORT_BUSY_WAIT_LOOP)
+ while (GetTime() < destinationTime) { }
#else
#if defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
- double busyWait = ms*0.05; // NOTE: We are using a busy wait of 5% of the time
- ms -= (float)busyWait;
+ double sleepSeconds = seconds - seconds*0.05; // NOTE: We reserve a percentage of the time for busy waiting
+ #else
+ double sleepSeconds = seconds;
#endif
// System halt functions
#if defined(_WIN32)
- Sleep((unsigned int)ms);
+ Sleep((unsigned long)(sleepSeconds*1000.0));
#endif
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__EMSCRIPTEN__)
struct timespec req = { 0 };
- time_t sec = (int)(ms/1000.0f);
- ms -= (sec*1000);
+ time_t sec = sleepSeconds;
+ long nsec = (sleepSeconds - sec)*1000000000L;
req.tv_sec = sec;
- req.tv_nsec = ms*1000000L;
+ req.tv_nsec = nsec;
// NOTE: Use nanosleep() on Unix platforms... usleep() it's deprecated.
while (nanosleep(&req, &req) == -1) continue;
#endif
#if defined(__APPLE__)
- usleep(ms*1000.0f);
+ usleep(sleepSeconds*1000000.0);
#endif
#if defined(SUPPORT_PARTIALBUSY_WAIT_LOOP)
- double previousTime = GetTime();
- double currentTime = 0.0;
-
- // Partial busy wait loop (only a fraction of the total wait time)
- while ((currentTime - previousTime) < (busyWait/1000.0f)) currentTime = GetTime();
+ while (GetTime() < destinationTime) { }
#endif
#endif
}
@@ -5537,7 +5534,7 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i
gifFrameCounter = 0;
Vector2 scale = GetWindowScaleDPI();
- msf_gif_begin(&gifState, CORE.Window.render.width*scale.x, CORE.Window.render.height*scale.y);
+ msf_gif_begin(&gifState, (int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y));
screenshotCounter++;
TRACELOG(LOG_INFO, "SYSTEM: Start animated GIF recording: %s", TextFormat("screenrec%03i.gif", screenshotCounter));
@@ -5674,14 +5671,14 @@ static void CursorEnterCallback(GLFWwindow *window, int enter)
// Everytime new files are dropped, old ones are discarded
static void WindowDropCallback(GLFWwindow *window, int count, const char **paths)
{
- ClearDroppedFiles();
+ UnloadDroppedFiles();
- CORE.Window.dropFilesPath = (char **)RL_MALLOC(count*sizeof(char *));
+ CORE.Window.dropFilepaths = (char **)RL_MALLOC(count*sizeof(char *));
for (int i = 0; i < count; i++)
{
- CORE.Window.dropFilesPath[i] = (char *)RL_MALLOC(MAX_FILEPATH_LENGTH*sizeof(char));
- strcpy(CORE.Window.dropFilesPath[i], paths[i]);
+ CORE.Window.dropFilepaths[i] = (char *)RL_MALLOC(MAX_FILEPATH_LENGTH*sizeof(char));
+ strcpy(CORE.Window.dropFilepaths[i], paths[i]);
}
CORE.Window.dropFileCount = count;
@@ -6314,12 +6311,13 @@ static void ConfigureEvdevDevice(char *device)
fd = open(device, O_RDONLY | O_NONBLOCK);
if (fd < 0)
{
- TRACELOG(LOG_WARNING, "RPI: Failed to open input device %s", device);
+ TRACELOG(LOG_WARNING, "RPI: Failed to open input device: %s", device);
return;
}
worker->fd = fd;
// Grab number on the end of the devices name "event"
+ // TODO: Grab number on the end of the device name "mouse"
int devNum = 0;
char *ptrDevName = strrchr(device, 't');
worker->eventNum = -1;
@@ -6328,6 +6326,7 @@ static void ConfigureEvdevDevice(char *device)
{
if (sscanf(ptrDevName, "t%d", &devNum) == 1) worker->eventNum = devNum;
}
+ else worker->eventNum = 0; // HACK for mouse0 device!
// At this point we have a connection to the device, but we don't yet know what the device is.
// It could be many things, even as simple as a power button...
@@ -6706,7 +6705,7 @@ static void *EventThread(void *arg)
#endif
}
- WaitTime(5); // Sleep for 5ms to avoid hogging CPU time
+ WaitTime(0.005); // Sleep for 5ms to avoid hogging CPU time
}
close(worker->fd);
@@ -6794,7 +6793,7 @@ static void *GamepadThread(void *arg)
}
}
}
- else WaitTime(1); // Sleep for 1 ms to avoid hogging CPU time
+ else WaitTime(0.001); // Sleep for 1 ms to avoid hogging CPU time
}
}
diff --git a/src/rlgl.h b/src/rlgl.h
index a7124448b..81f08c7e0 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -433,7 +433,7 @@ typedef enum {
RL_BLEND_MULTIPLIED, // Blend textures multiplying colors
RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative)
RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative)
- RL_BLEND_ALPHA_PREMUL, // Blend premultiplied textures considering alpha
+ RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha
RL_BLEND_CUSTOM // Blend textures using custom src/dst factors (use rlSetBlendFactors())
} rlBlendMode;
@@ -1783,7 +1783,7 @@ void rlSetBlendMode(int mode)
case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break;
- case RL_BLEND_ALPHA_PREMUL: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
+ case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_CUSTOM:
{
// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
diff --git a/src/rmodels.c b/src/rmodels.c
index 97fa3908f..af7e0cd76 100644
--- a/src/rmodels.c
+++ b/src/rmodels.c
@@ -4844,7 +4844,7 @@ static Model LoadGLTF(const char *fileName)
LOAD_ATTRIBUTE(attribute, 4, unsigned short, temp);
// Convert data to raylib color data type (4 bytes)
- for (int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(((float)temp[c]/65535.0f)*255.0f);
+ for (unsigned int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(((float)temp[c]/65535.0f)*255.0f);
RL_FREE(temp);
}
@@ -4858,7 +4858,7 @@ static Model LoadGLTF(const char *fileName)
LOAD_ATTRIBUTE(attribute, 4, float, temp);
// Convert data to raylib color data type (4 bytes), we expect the color data normalized
- for (int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(temp[c]*255.0f);
+ for (unsigned int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(temp[c]*255.0f);
RL_FREE(temp);
}
@@ -4893,7 +4893,7 @@ static Model LoadGLTF(const char *fileName)
LOAD_ATTRIBUTE(attribute, 1, unsigned int, temp);
// Convert data to raylib indices data type (unsigned short)
- for (int d = 0; d < attribute->count; d++) model.meshes[meshIndex].indices[d] = (unsigned short)temp[d];
+ for (unsigned int d = 0; d < attribute->count; d++) model.meshes[meshIndex].indices[d] = (unsigned short)temp[d];
TRACELOG(LOG_WARNING, "MODEL: [%s] Indices data converted from u32 to u16, possible loss of data", fileName);
@@ -4905,7 +4905,7 @@ static Model LoadGLTF(const char *fileName)
// Assign to the primitive mesh the corresponding material index
// NOTE: If no material defined, mesh uses the already assigned default material (index: 0)
- for (int m = 0; m < data->materials_count; m++)
+ for (unsigned int m = 0; m < data->materials_count; m++)
{
// The primitive actually keeps the pointer to the corresponding material,
// raylib instead assigns to the mesh the by its index, as loaded in model.materials array
diff --git a/src/utils.c b/src/utils.c
index 5a438beec..b922c8907 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -300,7 +300,7 @@ bool ExportDataAsCode(const char *data, unsigned int size, const char *fileName)
for (int i = 0; varFileName[i] != '\0'; i++) if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; }
byteCount += sprintf(txtData + byteCount, "static unsigned char %s_DATA[%i] = { ", varFileName, size);
- for (int i = 0; i < size - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "0x%x,\n" : "0x%x, "), data[i]);
+ for (unsigned int i = 0; i < size - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "0x%x,\n" : "0x%x, "), data[i]);
byteCount += sprintf(txtData + byteCount, "0x%x };\n", data[size - 1]);
// NOTE: Text data size exported is determined by '\0' (NULL) character