From bbbfea74df6a7eeca59863123432b08a0aef3d4f Mon Sep 17 00:00:00 2001 From: Reproog Date: Tue, 11 Jun 2024 08:31:59 +0200 Subject: [PATCH] Initial Commit --- README.md | 10 + nob.c | 26 + nob.h | 1174 ++++ raylib-src/old-raygui-src/raygui.c | 5540 +++++++++++++++++ raylib-src/old-raygui-src/raygui.h | 5540 +++++++++++++++++ raylib-src/old-raygui-src/raygui.so | Bin 0 -> 1320304 bytes raylib-src/raylib-5.0_linux_amd64.tar.gz | Bin 0 -> 1840378 bytes raylib-src/raylib-5.0_linux_amd64/CHANGELOG | 2128 +++++++ raylib-src/raylib-5.0_linux_amd64/LICENSE | 16 + raylib-src/raylib-5.0_linux_amd64/README.md | 150 + .../raylib-5.0_linux_amd64/include/raygui.h | 5540 +++++++++++++++++ .../raylib-5.0_linux_amd64/include/raylib.h | 1662 +++++ .../raylib-5.0_linux_amd64/include/raymath.h | 2190 +++++++ .../raylib-5.0_linux_amd64/include/rlgl.h | 4859 +++++++++++++++ .../raylib-5.0_linux_amd64/lib/libraylib.a | Bin 0 -> 2908626 bytes .../raylib-5.0_linux_amd64/lib/libraylib.so | 1 + .../lib/libraylib.so.5.0.0 | Bin 0 -> 2300656 bytes .../lib/libraylib.so.500 | 1 + .../raylib-5.0_linux_amd64/lib/raygui.so | Bin 0 -> 1320304 bytes src/main.c | 349 ++ 20 files changed, 29186 insertions(+) create mode 100644 README.md create mode 100644 nob.c create mode 100644 nob.h create mode 100644 raylib-src/old-raygui-src/raygui.c create mode 100644 raylib-src/old-raygui-src/raygui.h create mode 100755 raylib-src/old-raygui-src/raygui.so create mode 100644 raylib-src/raylib-5.0_linux_amd64.tar.gz create mode 100644 raylib-src/raylib-5.0_linux_amd64/CHANGELOG create mode 100644 raylib-src/raylib-5.0_linux_amd64/LICENSE create mode 100644 raylib-src/raylib-5.0_linux_amd64/README.md create mode 100644 raylib-src/raylib-5.0_linux_amd64/include/raygui.h create mode 100644 raylib-src/raylib-5.0_linux_amd64/include/raylib.h create mode 100644 raylib-src/raylib-5.0_linux_amd64/include/raymath.h create mode 100644 raylib-src/raylib-5.0_linux_amd64/include/rlgl.h create mode 100644 raylib-src/raylib-5.0_linux_amd64/lib/libraylib.a create mode 120000 raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so create mode 100755 raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.5.0.0 create mode 120000 raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.500 create mode 100755 raylib-src/raylib-5.0_linux_amd64/lib/raygui.so create mode 100644 src/main.c diff --git a/README.md b/README.md new file mode 100644 index 0000000..4fea4dc --- /dev/null +++ b/README.md @@ -0,0 +1,10 @@ +# Doppelspaltenapp in C + +## Quickstart: + +```console +gcc nob.c -o nob +./nob +``` + + diff --git a/nob.c b/nob.c new file mode 100644 index 0000000..43eed8f --- /dev/null +++ b/nob.c @@ -0,0 +1,26 @@ +#define NOB_IMPLEMENTATION +#include "nob.h" + +int main(int argc, char **argv) +{ + NOB_GO_REBUILD_URSELF(argc, argv); + + // COMPILE WITH RAYLIB + Nob_Cmd cmd = {0}; // SRC FILE + + nob_cmd_append(&cmd, "gcc", "src/main.c", "-ggdb"); + nob_cmd_append(&cmd, "-I", "./sqlite-src/sqlite3-src/", "-I", "./raylib-src/raylib-5.0_linux_amd64/include/"); + nob_cmd_append(&cmd, "-L", "./raylib-src/raylib-5.0_linux_amd64/lib/", "-L", "./raylib-src/old-raygui-src/", "-l:libraylib.a", "-l:raygui.so", "-lm"); + + // Main Exec File + nob_cmd_append(&cmd, "-o", "./bin/main.c"); + + if (!nob_cmd_run_sync(cmd)) return -1; + + cmd.count = 0; + nob_cmd_append(&cmd, "./bin/main.c"); + if (!nob_cmd_run_sync(cmd)) return -1; + + return 0; +} + diff --git a/nob.h b/nob.h new file mode 100644 index 0000000..a00249c --- /dev/null +++ b/nob.h @@ -0,0 +1,1174 @@ +// This is a complete backward incompatible rewrite of https://github.com/tsoding/nobuild +// because I'm really unhappy with the direction it is going. It's gonna sit in this repo +// until it's matured enough and then I'll probably extract it to its own repo. + +// Copyright 2023 Alexey Kutepov +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +#ifndef NOB_H_ +#define NOB_H_ + +#define NOB_ASSERT assert +#define NOB_REALLOC realloc +#define NOB_FREE free + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _WIN32 +# define WIN32_LEAN_AND_MEAN +# include +# include +# include +#else +# include +# include +# include +# include +# include +#endif + +#ifdef _WIN32 +# define NOB_LINE_END "\r\n" +#else +# define NOB_LINE_END "\n" +#endif + +#define NOB_ARRAY_LEN(array) (sizeof(array)/sizeof(array[0])) +#define NOB_ARRAY_GET(array, index) \ + (NOB_ASSERT(index >= 0), NOB_ASSERT(index < NOB_ARRAY_LEN(array)), array[index]) + +typedef enum { + NOB_INFO, + NOB_WARNING, + NOB_ERROR, +} Nob_Log_Level; + +void nob_log(Nob_Log_Level level, const char *fmt, ...); + +// It is an equivalent of shift command from bash. It basically pops a command line +// argument from the beginning. +char *nob_shift_args(int *argc, char ***argv); + +typedef struct { + const char **items; + size_t count; + size_t capacity; +} Nob_File_Paths; + +typedef enum { + NOB_FILE_REGULAR = 0, + NOB_FILE_DIRECTORY, + NOB_FILE_SYMLINK, + NOB_FILE_OTHER, +} Nob_File_Type; + +bool nob_mkdir_if_not_exists(const char *path); +bool nob_copy_file(const char *src_path, const char *dst_path); +bool nob_copy_directory_recursively(const char *src_path, const char *dst_path); +bool nob_read_entire_dir(const char *parent, Nob_File_Paths *children); +bool nob_write_entire_file(const char *path, void *data, size_t size); +Nob_File_Type nob_get_file_type(const char *path); + +#define nob_return_defer(value) do { result = (value); goto defer; } while(0) + +// Initial capacity of a dynamic array +#define NOB_DA_INIT_CAP 256 + +// Append an item to a dynamic array +#define nob_da_append(da, item) \ + do { \ + if ((da)->count >= (da)->capacity) { \ + (da)->capacity = (da)->capacity == 0 ? NOB_DA_INIT_CAP : (da)->capacity*2; \ + (da)->items = NOB_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \ + NOB_ASSERT((da)->items != NULL && "Buy more RAM lol"); \ + } \ + \ + (da)->items[(da)->count++] = (item); \ + } while (0) + +#define nob_da_free(da) NOB_FREE((da).items) + +// Append several items to a dynamic array +#define nob_da_append_many(da, new_items, new_items_count) \ + do { \ + if ((da)->count + new_items_count > (da)->capacity) { \ + if ((da)->capacity == 0) { \ + (da)->capacity = NOB_DA_INIT_CAP; \ + } \ + while ((da)->count + new_items_count > (da)->capacity) { \ + (da)->capacity *= 2; \ + } \ + (da)->items = NOB_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \ + NOB_ASSERT((da)->items != NULL && "Buy more RAM lol"); \ + } \ + memcpy((da)->items + (da)->count, new_items, new_items_count*sizeof(*(da)->items)); \ + (da)->count += new_items_count; \ + } while (0) + +typedef struct { + char *items; + size_t count; + size_t capacity; +} Nob_String_Builder; + +bool nob_read_entire_file(const char *path, Nob_String_Builder *sb); + +// Append a sized buffer to a string builder +#define nob_sb_append_buf(sb, buf, size) nob_da_append_many(sb, buf, size) + +// Append a NULL-terminated string to a string builder +#define nob_sb_append_cstr(sb, cstr) \ + do { \ + const char *s = (cstr); \ + size_t n = strlen(s); \ + nob_da_append_many(sb, s, n); \ + } while (0) + +// Append a single NULL character at the end of a string builder. So then you can +// use it a NULL-terminated C string +#define nob_sb_append_null(sb) nob_da_append_many(sb, "", 1) + +// Free the memory allocated by a string builder +#define nob_sb_free(sb) NOB_FREE((sb).items) + +// Process handle +#ifdef _WIN32 +typedef HANDLE Nob_Proc; +#define NOB_INVALID_PROC INVALID_HANDLE_VALUE +#else +typedef int Nob_Proc; +#define NOB_INVALID_PROC (-1) +#endif // _WIN32 + +typedef struct { + Nob_Proc *items; + size_t count; + size_t capacity; +} Nob_Procs; + +bool nob_procs_wait(Nob_Procs procs); + +// Wait until the process has finished +bool nob_proc_wait(Nob_Proc proc); + +// A command - the main workhorse of Nob. Nob is all about building commands an running them +typedef struct { + const char **items; + size_t count; + size_t capacity; +} Nob_Cmd; + +// Render a string representation of a command into a string builder. Keep in mind the the +// string builder is not NULL-terminated by default. Use nob_sb_append_null if you plan to +// use it as a C string. +void nob_cmd_render(Nob_Cmd cmd, Nob_String_Builder *render); + +#define nob_cmd_append(cmd, ...) \ + nob_da_append_many(cmd, ((const char*[]){__VA_ARGS__}), (sizeof((const char*[]){__VA_ARGS__})/sizeof(const char*))) + +// Free all the memory allocated by command arguments +#define nob_cmd_free(cmd) NOB_FREE(cmd.items) + +// Run command asynchronously +Nob_Proc nob_cmd_run_async(Nob_Cmd cmd); + +// Run command synchronously +bool nob_cmd_run_sync(Nob_Cmd cmd); + +#ifndef NOB_TEMP_CAPACITY +#define NOB_TEMP_CAPACITY (8*1024*1024) +#endif // NOB_TEMP_CAPACITY +char *nob_temp_strdup(const char *cstr); +void *nob_temp_alloc(size_t size); +char *nob_temp_sprintf(const char *format, ...); +void nob_temp_reset(void); +size_t nob_temp_save(void); +void nob_temp_rewind(size_t checkpoint); + +int is_path1_modified_after_path2(const char *path1, const char *path2); +bool nob_rename(const char *old_path, const char *new_path); +int nob_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count); +int nob_needs_rebuild1(const char *output_path, const char *input_path); +int nob_file_exists(const char *file_path); + +// TODO: add MinGW support for Go Rebuild Urself™ Technology +#ifndef NOB_REBUILD_URSELF +# if _WIN32 +# if defined(__GNUC__) +# define NOB_REBUILD_URSELF(binary_path, source_path) "gcc", "-o", binary_path, source_path +# elif defined(__clang__) +# define NOB_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path +# elif defined(_MSC_VER) +# define NOB_REBUILD_URSELF(binary_path, source_path) "cl.exe", source_path +# endif +# else +# define NOB_REBUILD_URSELF(binary_path, source_path) "cc", "-o", binary_path, source_path +# endif +#endif + +// Go Rebuild Urself™ Technology +// +// How to use it: +// int main(int argc, char** argv) { +// GO_REBUILD_URSELF(argc, argv); +// // actual work +// return 0; +// } +// +// After your added this macro every time you run ./nobuild it will detect +// that you modified its original source code and will try to rebuild itself +// before doing any actual work. So you only need to bootstrap your build system +// once. +// +// The modification is detected by comparing the last modified times of the executable +// and its source code. The same way the make utility usually does it. +// +// The rebuilding is done by using the REBUILD_URSELF macro which you can redefine +// if you need a special way of bootstraping your build system. (which I personally +// do not recommend since the whole idea of nobuild is to keep the process of bootstrapping +// as simple as possible and doing all of the actual work inside of the nobuild) +// +#define NOB_GO_REBUILD_URSELF(argc, argv) \ + do { \ + const char *source_path = __FILE__; \ + assert(argc >= 1); \ + const char *binary_path = argv[0]; \ + \ + int rebuild_is_needed = nob_needs_rebuild(binary_path, &source_path, 1); \ + if (rebuild_is_needed < 0) exit(1); \ + if (rebuild_is_needed) { \ + Nob_String_Builder sb = {0}; \ + nob_sb_append_cstr(&sb, binary_path); \ + nob_sb_append_cstr(&sb, ".old"); \ + nob_sb_append_null(&sb); \ + \ + if (!nob_rename(binary_path, sb.items)) exit(1); \ + Nob_Cmd rebuild = {0}; \ + nob_cmd_append(&rebuild, NOB_REBUILD_URSELF(binary_path, source_path)); \ + bool rebuild_succeeded = nob_cmd_run_sync(rebuild); \ + nob_cmd_free(rebuild); \ + if (!rebuild_succeeded) { \ + nob_rename(sb.items, binary_path); \ + exit(1); \ + } \ + \ + Nob_Cmd cmd = {0}; \ + nob_da_append_many(&cmd, argv, argc); \ + if (!nob_cmd_run_sync(cmd)) exit(1); \ + exit(0); \ + } \ + } while(0) +// The implementation idea is stolen from https://github.com/zhiayang/nabs + +typedef struct { + size_t count; + const char *data; +} Nob_String_View; + +const char *nob_temp_sv_to_cstr(Nob_String_View sv); + +Nob_String_View nob_sv_chop_by_delim(Nob_String_View *sv, char delim); +Nob_String_View nob_sv_chop_by_space(Nob_String_View *sv); +Nob_String_View nob_sv_trim(Nob_String_View sv); +bool nob_sv_eq(Nob_String_View a, Nob_String_View b); +Nob_String_View nob_sv_from_cstr(const char *cstr); +Nob_String_View nob_sv_from_parts(const char *data, size_t count); + +// printf macros for String_View +#ifndef SV_Fmt +#define SV_Fmt "%.*s" +#endif // SV_Fmt +#ifndef SV_Arg +#define SV_Arg(sv) (int) (sv).count, (sv).data +#endif // SV_Arg +// USAGE: +// String_View name = ...; +// printf("Name: "SV_Fmt"\n", SV_Arg(name)); + + +// minirent.h HEADER BEGIN //////////////////////////////////////// +// Copyright 2021 Alexey Kutepov +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// ============================================================ +// +// minirent — 0.0.1 — A subset of dirent interface for Windows. +// +// https://github.com/tsoding/minirent +// +// ============================================================ +// +// ChangeLog (https://semver.org/ is implied) +// +// 0.0.2 Automatically include dirent.h on non-Windows +// platforms +// 0.0.1 First Official Release + +#ifndef _WIN32 +#include +#else // _WIN32 + +#define WIN32_LEAN_AND_MEAN +#include "windows.h" + +struct dirent +{ + char d_name[MAX_PATH+1]; +}; + +typedef struct DIR DIR; + +DIR *opendir(const char *dirpath); +struct dirent *readdir(DIR *dirp); +int closedir(DIR *dirp); +#endif // _WIN32 +// minirent.h HEADER END //////////////////////////////////////// + +#endif // NOB_H_ + +#ifdef NOB_IMPLEMENTATION + +static size_t nob_temp_size = 0; +static char nob_temp[NOB_TEMP_CAPACITY] = {0}; + +bool nob_mkdir_if_not_exists(const char *path) +{ +#ifdef _WIN32 + int result = mkdir(path); +#else + int result = mkdir(path, 0755); +#endif + if (result < 0) { + if (errno == EEXIST) { + nob_log(NOB_INFO, "directory `%s` already exists", path); + return true; + } + nob_log(NOB_ERROR, "could not create directory `%s`: %s", path, strerror(errno)); + return false; + } + + nob_log(NOB_INFO, "created directory `%s`", path); + return true; +} + +bool nob_copy_file(const char *src_path, const char *dst_path) +{ + nob_log(NOB_INFO, "copying %s -> %s", src_path, dst_path); +#ifdef _WIN32 + if (!CopyFile(src_path, dst_path, FALSE)) { + nob_log(NOB_ERROR, "Could not copy file: %lu", GetLastError()); + return false; + } + return true; +#else + int src_fd = -1; + int dst_fd = -1; + size_t buf_size = 32*1024; + char *buf = NOB_REALLOC(NULL, buf_size); + NOB_ASSERT(buf != NULL && "Buy more RAM lol!!"); + bool result = true; + + src_fd = open(src_path, O_RDONLY); + if (src_fd < 0) { + nob_log(NOB_ERROR, "Could not open file %s: %s", src_path, strerror(errno)); + nob_return_defer(false); + } + + struct stat src_stat; + if (fstat(src_fd, &src_stat) < 0) { + nob_log(NOB_ERROR, "Could not get mode of file %s: %s", src_path, strerror(errno)); + nob_return_defer(false); + } + + dst_fd = open(dst_path, O_CREAT | O_TRUNC | O_WRONLY, src_stat.st_mode); + if (dst_fd < 0) { + nob_log(NOB_ERROR, "Could not create file %s: %s", dst_path, strerror(errno)); + nob_return_defer(false); + } + + for (;;) { + ssize_t n = read(src_fd, buf, buf_size); + if (n == 0) break; + if (n < 0) { + nob_log(NOB_ERROR, "Could not read from file %s: %s", src_path, strerror(errno)); + nob_return_defer(false); + } + char *buf2 = buf; + while (n > 0) { + ssize_t m = write(dst_fd, buf2, n); + if (m < 0) { + nob_log(NOB_ERROR, "Could not write to file %s: %s", dst_path, strerror(errno)); + nob_return_defer(false); + } + n -= m; + buf2 += m; + } + } + +defer: + free(buf); + close(src_fd); + close(dst_fd); + return result; +#endif +} + +void nob_cmd_render(Nob_Cmd cmd, Nob_String_Builder *render) +{ + for (size_t i = 0; i < cmd.count; ++i) { + const char *arg = cmd.items[i]; + if (arg == NULL) break; + if (i > 0) nob_sb_append_cstr(render, " "); + if (!strchr(arg, ' ')) { + nob_sb_append_cstr(render, arg); + } else { + nob_da_append(render, '\''); + nob_sb_append_cstr(render, arg); + nob_da_append(render, '\''); + } + } +} + +Nob_Proc nob_cmd_run_async(Nob_Cmd cmd) +{ + if (cmd.count < 1) { + nob_log(NOB_ERROR, "Could not run empty command"); + return NOB_INVALID_PROC; + } + + Nob_String_Builder sb = {0}; + nob_cmd_render(cmd, &sb); + nob_sb_append_null(&sb); + nob_log(NOB_INFO, "CMD: %s", sb.items); + nob_sb_free(sb); + memset(&sb, 0, sizeof(sb)); + +#ifdef _WIN32 + // https://docs.microsoft.com/en-us/windows/win32/procthread/creating-a-child-process-with-redirected-input-and-output + + STARTUPINFO siStartInfo; + ZeroMemory(&siStartInfo, sizeof(siStartInfo)); + siStartInfo.cb = sizeof(STARTUPINFO); + // NOTE: theoretically setting NULL to std handles should not be a problem + // https://docs.microsoft.com/en-us/windows/console/getstdhandle?redirectedfrom=MSDN#attachdetach-behavior + // TODO: check for errors in GetStdHandle + siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); + siStartInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); + siStartInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + siStartInfo.dwFlags |= STARTF_USESTDHANDLES; + + PROCESS_INFORMATION piProcInfo; + ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION)); + + // TODO: use a more reliable rendering of the command instead of cmd_render + // cmd_render is for logging primarily + nob_cmd_render(cmd, &sb); + nob_sb_append_null(&sb); + BOOL bSuccess = CreateProcessA(NULL, sb.items, NULL, NULL, TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo); + nob_sb_free(sb); + + if (!bSuccess) { + nob_log(NOB_ERROR, "Could not create child process: %lu", GetLastError()); + return NOB_INVALID_PROC; + } + + CloseHandle(piProcInfo.hThread); + + return piProcInfo.hProcess; +#else + pid_t cpid = fork(); + if (cpid < 0) { + nob_log(NOB_ERROR, "Could not fork child process: %s", strerror(errno)); + return NOB_INVALID_PROC; + } + + if (cpid == 0) { + // NOTE: This leaks a bit of memory in the child process. + // But do we actually care? It's a one off leak anyway... + Nob_Cmd cmd_null = {0}; + nob_da_append_many(&cmd_null, cmd.items, cmd.count); + nob_cmd_append(&cmd_null, NULL); + + if (execvp(cmd.items[0], (char * const*) cmd_null.items) < 0) { + nob_log(NOB_ERROR, "Could not exec child process: %s", strerror(errno)); + exit(1); + } + NOB_ASSERT(0 && "unreachable"); + } + + return cpid; +#endif +} + +bool nob_procs_wait(Nob_Procs procs) +{ + bool success = true; + for (size_t i = 0; i < procs.count; ++i) { + success = nob_proc_wait(procs.items[i]) && success; + } + return success; +} + +bool nob_proc_wait(Nob_Proc proc) +{ + if (proc == NOB_INVALID_PROC) return false; + +#ifdef _WIN32 + DWORD result = WaitForSingleObject( + proc, // HANDLE hHandle, + INFINITE // DWORD dwMilliseconds + ); + + if (result == WAIT_FAILED) { + nob_log(NOB_ERROR, "could not wait on child process: %lu", GetLastError()); + return false; + } + + DWORD exit_status; + if (!GetExitCodeProcess(proc, &exit_status)) { + nob_log(NOB_ERROR, "could not get process exit code: %lu", GetLastError()); + return false; + } + + if (exit_status != 0) { + nob_log(NOB_ERROR, "command exited with exit code %lu", exit_status); + return false; + } + + CloseHandle(proc); + + return true; +#else + for (;;) { + int wstatus = 0; + if (waitpid(proc, &wstatus, 0) < 0) { + nob_log(NOB_ERROR, "could not wait on command (pid %d): %s", proc, strerror(errno)); + return false; + } + + if (WIFEXITED(wstatus)) { + int exit_status = WEXITSTATUS(wstatus); + if (exit_status != 0) { + nob_log(NOB_ERROR, "command exited with exit code %d", exit_status); + return false; + } + + break; + } + + if (WIFSIGNALED(wstatus)) { + nob_log(NOB_ERROR, "command process was terminated by %s", strsignal(WTERMSIG(wstatus))); + return false; + } + } + + return true; +#endif +} + +bool nob_cmd_run_sync(Nob_Cmd cmd) +{ + Nob_Proc p = nob_cmd_run_async(cmd); + if (p == NOB_INVALID_PROC) return false; + return nob_proc_wait(p); +} + +char *nob_shift_args(int *argc, char ***argv) +{ + NOB_ASSERT(*argc > 0); + char *result = **argv; + (*argv) += 1; + (*argc) -= 1; + return result; +} + +void nob_log(Nob_Log_Level level, const char *fmt, ...) +{ + switch (level) { + case NOB_INFO: + fprintf(stderr, "[INFO] "); + break; + case NOB_WARNING: + fprintf(stderr, "[WARNING] "); + break; + case NOB_ERROR: + fprintf(stderr, "[ERROR] "); + break; + default: + NOB_ASSERT(0 && "unreachable"); + } + + va_list args; + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); + fprintf(stderr, "\n"); +} + +bool nob_read_entire_dir(const char *parent, Nob_File_Paths *children) +{ + bool result = true; + DIR *dir = NULL; + + dir = opendir(parent); + if (dir == NULL) { + nob_log(NOB_ERROR, "Could not open directory %s: %s", parent, strerror(errno)); + nob_return_defer(false); + } + + errno = 0; + struct dirent *ent = readdir(dir); + while (ent != NULL) { + nob_da_append(children, nob_temp_strdup(ent->d_name)); + ent = readdir(dir); + } + + if (errno != 0) { + nob_log(NOB_ERROR, "Could not read directory %s: %s", parent, strerror(errno)); + nob_return_defer(false); + } + +defer: + if (dir) closedir(dir); + return result; +} + +bool nob_write_entire_file(const char *path, void *data, size_t size) +{ + bool result = true; + + FILE *f = fopen(path, "wb"); + if (f == NULL) { + nob_log(NOB_ERROR, "Could not open file %s for writing: %s\n", path, strerror(errno)); + nob_return_defer(false); + } + + // len + // v + // aaaaaaaaaa + // ^ + // data + + char *buf = data; + while (size > 0) { + size_t n = fwrite(buf, 1, size, f); + if (ferror(f)) { + nob_log(NOB_ERROR, "Could not write into file %s: %s\n", path, strerror(errno)); + nob_return_defer(false); + } + size -= n; + buf += n; + } + +defer: + if (f) fclose(f); + return result; +} + +Nob_File_Type nob_get_file_type(const char *path) +{ +#ifdef _WIN32 + DWORD attr = GetFileAttributesA(path); + if (attr == INVALID_FILE_ATTRIBUTES) { + nob_log(NOB_ERROR, "Could not get file attributes of %s: %lu", path, GetLastError()); + return -1; + } + + if (attr & FILE_ATTRIBUTE_DIRECTORY) return NOB_FILE_DIRECTORY; + // TODO: detect symlinks on Windows (whatever that means on Windows anyway) + return NOB_FILE_REGULAR; +#else // _WIN32 + struct stat statbuf; + if (stat(path, &statbuf) < 0) { + nob_log(NOB_ERROR, "Could not get stat of %s: %s", path, strerror(errno)); + return -1; + } + + switch (statbuf.st_mode & S_IFMT) { + case S_IFDIR: return NOB_FILE_DIRECTORY; + case S_IFREG: return NOB_FILE_REGULAR; + case S_IFLNK: return NOB_FILE_SYMLINK; + default: return NOB_FILE_OTHER; + } +#endif // _WIN32 +} + +bool nob_copy_directory_recursively(const char *src_path, const char *dst_path) +{ + bool result = true; + Nob_File_Paths children = {0}; + Nob_String_Builder src_sb = {0}; + Nob_String_Builder dst_sb = {0}; + size_t temp_checkpoint = nob_temp_save(); + + Nob_File_Type type = nob_get_file_type(src_path); + if (type < 0) return false; + + switch (type) { + case NOB_FILE_DIRECTORY: { + if (!nob_mkdir_if_not_exists(dst_path)) nob_return_defer(false); + if (!nob_read_entire_dir(src_path, &children)) nob_return_defer(false); + + for (size_t i = 0; i < children.count; ++i) { + if (strcmp(children.items[i], ".") == 0) continue; + if (strcmp(children.items[i], "..") == 0) continue; + + src_sb.count = 0; + nob_sb_append_cstr(&src_sb, src_path); + nob_sb_append_cstr(&src_sb, "/"); + nob_sb_append_cstr(&src_sb, children.items[i]); + nob_sb_append_null(&src_sb); + + dst_sb.count = 0; + nob_sb_append_cstr(&dst_sb, dst_path); + nob_sb_append_cstr(&dst_sb, "/"); + nob_sb_append_cstr(&dst_sb, children.items[i]); + nob_sb_append_null(&dst_sb); + + if (!nob_copy_directory_recursively(src_sb.items, dst_sb.items)) { + nob_return_defer(false); + } + } + } break; + + case NOB_FILE_REGULAR: { + if (!nob_copy_file(src_path, dst_path)) { + nob_return_defer(false); + } + } break; + + case NOB_FILE_SYMLINK: { + nob_log(NOB_WARNING, "TODO: Copying symlinks is not supported yet"); + } break; + + case NOB_FILE_OTHER: { + nob_log(NOB_ERROR, "Unsupported type of file %s", src_path); + nob_return_defer(false); + } break; + + default: NOB_ASSERT(0 && "unreachable"); + } + +defer: + nob_temp_rewind(temp_checkpoint); + nob_da_free(src_sb); + nob_da_free(dst_sb); + nob_da_free(children); + return result; +} + +char *nob_temp_strdup(const char *cstr) +{ + size_t n = strlen(cstr); + char *result = nob_temp_alloc(n + 1); + NOB_ASSERT(result != NULL && "Increase NOB_TEMP_CAPACITY"); + memcpy(result, cstr, n); + result[n] = '\0'; + return result; +} + +void *nob_temp_alloc(size_t size) +{ + if (nob_temp_size + size > NOB_TEMP_CAPACITY) return NULL; + void *result = &nob_temp[nob_temp_size]; + nob_temp_size += size; + return result; +} + +char *nob_temp_sprintf(const char *format, ...) +{ + va_list args; + va_start(args, format); + int n = vsnprintf(NULL, 0, format, args); + va_end(args); + + NOB_ASSERT(n >= 0); + char *result = nob_temp_alloc(n + 1); + NOB_ASSERT(result != NULL && "Extend the size of the temporary allocator"); + // TODO: use proper arenas for the temporary allocator; + va_start(args, format); + vsnprintf(result, n + 1, format, args); + va_end(args); + + return result; +} + +void nob_temp_reset(void) +{ + nob_temp_size = 0; +} + +size_t nob_temp_save(void) +{ + return nob_temp_size; +} + +void nob_temp_rewind(size_t checkpoint) +{ + nob_temp_size = checkpoint; +} + +const char *nob_temp_sv_to_cstr(Nob_String_View sv) +{ + char *result = nob_temp_alloc(sv.count + 1); + NOB_ASSERT(result != NULL && "Extend the size of the temporary allocator"); + memcpy(result, sv.data, sv.count); + result[sv.count] = '\0'; + return result; +} + +int nob_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count) +{ +#ifdef _WIN32 + BOOL bSuccess; + + HANDLE output_path_fd = CreateFile(output_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); + if (output_path_fd == INVALID_HANDLE_VALUE) { + // NOTE: if output does not exist it 100% must be rebuilt + if (GetLastError() == ERROR_FILE_NOT_FOUND) return 1; + nob_log(NOB_ERROR, "Could not open file %s: %lu", output_path, GetLastError()); + return -1; + } + FILETIME output_path_time; + bSuccess = GetFileTime(output_path_fd, NULL, NULL, &output_path_time); + CloseHandle(output_path_fd); + if (!bSuccess) { + nob_log(NOB_ERROR, "Could not get time of %s: %lu", output_path, GetLastError()); + return -1; + } + + for (size_t i = 0; i < input_paths_count; ++i) { + const char *input_path = input_paths[i]; + HANDLE input_path_fd = CreateFile(input_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); + if (input_path_fd == INVALID_HANDLE_VALUE) { + // NOTE: non-existing input is an error cause it is needed for building in the first place + nob_log(NOB_ERROR, "Could not open file %s: %lu", input_path, GetLastError()); + return -1; + } + FILETIME input_path_time; + bSuccess = GetFileTime(input_path_fd, NULL, NULL, &input_path_time); + CloseHandle(input_path_fd); + if (!bSuccess) { + nob_log(NOB_ERROR, "Could not get time of %s: %lu", input_path, GetLastError()); + return -1; + } + + // NOTE: if even a single input_path is fresher than output_path that's 100% rebuild + if (CompareFileTime(&input_path_time, &output_path_time) == 1) return 1; + } + + return 0; +#else + struct stat statbuf = {0}; + + if (stat(output_path, &statbuf) < 0) { + // NOTE: if output does not exist it 100% must be rebuilt + if (errno == ENOENT) return 1; + nob_log(NOB_ERROR, "could not stat %s: %s", output_path, strerror(errno)); + return -1; + } + int output_path_time = statbuf.st_mtime; + + for (size_t i = 0; i < input_paths_count; ++i) { + const char *input_path = input_paths[i]; + if (stat(input_path, &statbuf) < 0) { + // NOTE: non-existing input is an error cause it is needed for building in the first place + nob_log(NOB_ERROR, "could not stat %s: %s", input_path, strerror(errno)); + return -1; + } + int input_path_time = statbuf.st_mtime; + // NOTE: if even a single input_path is fresher than output_path that's 100% rebuild + if (input_path_time > output_path_time) return 1; + } + + return 0; +#endif +} + +int nob_needs_rebuild1(const char *output_path, const char *input_path) +{ + return nob_needs_rebuild(output_path, &input_path, 1); +} + +bool nob_rename(const char *old_path, const char *new_path) +{ + nob_log(NOB_INFO, "renaming %s -> %s", old_path, new_path); +#ifdef _WIN32 + if (!MoveFileEx(old_path, new_path, MOVEFILE_REPLACE_EXISTING)) { + nob_log(NOB_ERROR, "could not rename %s to %s: %lu", old_path, new_path, GetLastError()); + return false; + } +#else + if (rename(old_path, new_path) < 0) { + nob_log(NOB_ERROR, "could not rename %s to %s: %s", old_path, new_path, strerror(errno)); + return false; + } +#endif // _WIN32 + return true; +} + +bool nob_read_entire_file(const char *path, Nob_String_Builder *sb) +{ + bool result = true; + size_t buf_size = 32*1024; + char *buf = NOB_REALLOC(NULL, buf_size); + NOB_ASSERT(buf != NULL && "Buy more RAM lool!!"); + FILE *f = fopen(path, "rb"); + if (f == NULL) { + nob_log(NOB_ERROR, "Could not open %s for reading: %s", path, strerror(errno)); + nob_return_defer(false); + } + + size_t n = fread(buf, 1, buf_size, f); + while (n > 0) { + nob_sb_append_buf(sb, buf, n); + n = fread(buf, 1, buf_size, f); + } + if (ferror(f)) { + nob_log(NOB_ERROR, "Could not read %s: %s\n", path, strerror(errno)); + nob_return_defer(false); + } + +defer: + NOB_FREE(buf); + if (f) fclose(f); + return result; +} + +Nob_String_View nob_sv_chop_by_space(Nob_String_View *sv) +{ + size_t i = 0; + while (i < sv->count && !isspace(sv->data[i])) { + i += 1; + } + + Nob_String_View result = nob_sv_from_parts(sv->data, i); + + if (i < sv->count) { + sv->count -= i + 1; + sv->data += i + 1; + } else { + sv->count -= i; + sv->data += i; + } + + return result; +} + +Nob_String_View nob_sv_chop_by_delim(Nob_String_View *sv, char delim) +{ + size_t i = 0; + while (i < sv->count && sv->data[i] != delim) { + i += 1; + } + + Nob_String_View result = nob_sv_from_parts(sv->data, i); + + if (i < sv->count) { + sv->count -= i + 1; + sv->data += i + 1; + } else { + sv->count -= i; + sv->data += i; + } + + return result; +} + +Nob_String_View nob_sv_from_parts(const char *data, size_t count) +{ + Nob_String_View sv; + sv.count = count; + sv.data = data; + return sv; +} + +Nob_String_View nob_sv_trim_left(Nob_String_View sv) +{ + size_t i = 0; + while (i < sv.count && isspace(sv.data[i])) { + i += 1; + } + + return nob_sv_from_parts(sv.data + i, sv.count - i); +} + +Nob_String_View nob_sv_trim_right(Nob_String_View sv) +{ + size_t i = 0; + while (i < sv.count && isspace(sv.data[sv.count - 1 - i])) { + i += 1; + } + + return nob_sv_from_parts(sv.data, sv.count - i); +} + +Nob_String_View nob_sv_trim(Nob_String_View sv) +{ + return nob_sv_trim_right(nob_sv_trim_left(sv)); +} + +Nob_String_View nob_sv_from_cstr(const char *cstr) +{ + return nob_sv_from_parts(cstr, strlen(cstr)); +} + +bool nob_sv_eq(Nob_String_View a, Nob_String_View b) +{ + if (a.count != b.count) { + return false; + } else { + return memcmp(a.data, b.data, a.count) == 0; + } +} + +// RETURNS: +// 0 - file does not exists +// 1 - file exists +// -1 - error while checking if file exists. The error is logged +int nob_file_exists(const char *file_path) +{ +#if _WIN32 + // TODO: distinguish between "does not exists" and other errors + DWORD dwAttrib = GetFileAttributesA(file_path); + return dwAttrib != INVALID_FILE_ATTRIBUTES; +#else + struct stat statbuf; + if (stat(file_path, &statbuf) < 0) { + if (errno == ENOENT) return 0; + nob_log(NOB_ERROR, "Could not check if file %s exists: %s", file_path, strerror(errno)); + return -1; + } + return 1; +#endif +} + +// minirent.h SOURCE BEGIN //////////////////////////////////////// +#ifdef _WIN32 +struct DIR +{ + HANDLE hFind; + WIN32_FIND_DATA data; + struct dirent *dirent; +}; + +DIR *opendir(const char *dirpath) +{ + assert(dirpath); + + char buffer[MAX_PATH]; + snprintf(buffer, MAX_PATH, "%s\\*", dirpath); + + DIR *dir = (DIR*)calloc(1, sizeof(DIR)); + + dir->hFind = FindFirstFile(buffer, &dir->data); + if (dir->hFind == INVALID_HANDLE_VALUE) { + // TODO: opendir should set errno accordingly on FindFirstFile fail + // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror + errno = ENOSYS; + goto fail; + } + + return dir; + +fail: + if (dir) { + free(dir); + } + + return NULL; +} + +struct dirent *readdir(DIR *dirp) +{ + assert(dirp); + + if (dirp->dirent == NULL) { + dirp->dirent = (struct dirent*)calloc(1, sizeof(struct dirent)); + } else { + if(!FindNextFile(dirp->hFind, &dirp->data)) { + if (GetLastError() != ERROR_NO_MORE_FILES) { + // TODO: readdir should set errno accordingly on FindNextFile fail + // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror + errno = ENOSYS; + } + + return NULL; + } + } + + memset(dirp->dirent->d_name, 0, sizeof(dirp->dirent->d_name)); + + strncpy( + dirp->dirent->d_name, + dirp->data.cFileName, + sizeof(dirp->dirent->d_name) - 1); + + return dirp->dirent; +} + +int closedir(DIR *dirp) +{ + assert(dirp); + + if(!FindClose(dirp->hFind)) { + // TODO: closedir should set errno accordingly on FindClose fail + // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror + errno = ENOSYS; + return -1; + } + + if (dirp->dirent) { + free(dirp->dirent); + } + free(dirp); + + return 0; +} +#endif // _WIN32 +// minirent.h SOURCE END //////////////////////////////////////// + +#endif diff --git a/raylib-src/old-raygui-src/raygui.c b/raylib-src/old-raygui-src/raygui.c new file mode 100644 index 0000000..631ee15 --- /dev/null +++ b/raylib-src/old-raygui-src/raygui.c @@ -0,0 +1,5540 @@ +/******************************************************************************************* +* +* raygui v4.1-dev - A simple and easy-to-use immediate-mode gui library +* +* DESCRIPTION: +* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +* available as a standalone library, as long as input and drawing functions are provided. +* +* FEATURES: +* - Immediate-mode gui, minimal retained data +* - +25 controls provided (basic and advanced) +* - Styling system for colors, font and metrics +* - Icons supported, embedded as a 1-bit icons pack +* - Standalone mode option (custom input/graphics backend) +* - Multiple support tools provided for raygui development +* +* POSSIBLE IMPROVEMENTS: +* - Better standalone mode API for easy plug of custom backends +* - Externalize required inputs, allow user easier customization +* +* LIMITATIONS: +* - No editable multi-line word-wraped text box supported +* - No auto-layout mechanism, up to the user to define controls position and size +* - Standalone mode requires library modification and some user work to plug another backend +* +* NOTES: +* - WARNING: GuiLoadStyle() and GuiLoadStyle{Custom}() functions, allocate memory for +* font atlas recs and glyphs, freeing that memory is (usually) up to the user, +* no unload function is explicitly provided... but note that GuiLoadStyleDefault() unloads +* by default any previously loaded font (texture, recs, glyphs). +* - Global UI alpha (guiAlpha) is applied inside GuiDrawRectangle() and GuiDrawText() functions +* +* CONTROLS PROVIDED: +* # Container/separators Controls +* - WindowBox --> StatusBar, Panel +* - GroupBox --> Line +* - Line +* - Panel --> StatusBar +* - ScrollPanel --> StatusBar +* - TabBar --> Button +* +* # Basic Controls +* - Label +* - LabelButton --> Label +* - Button +* - Toggle +* - ToggleGroup --> Toggle +* - ToggleSlider +* - CheckBox +* - ComboBox +* - DropdownBox +* - TextBox +* - ValueBox --> TextBox +* - Spinner --> Button, ValueBox +* - Slider +* - SliderBar --> Slider +* - ProgressBar +* - StatusBar +* - DummyRec +* - Grid +* +* # Advance Controls +* - ListView +* - ColorPicker --> ColorPanel, ColorBarHue +* - MessageBox --> Window, Label, Button +* - TextInputBox --> Window, Label, TextBox, Button +* +* It also provides a set of functions for styling the controls based on its properties (size, color). +* +* +* 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 +* recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one +* +* The global style array size is fixed and depends on the number of controls and properties: +* +* static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)]; +* +* guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +* +* Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style +* used for all controls, when any of those base values is set, it is automatically populated to all +* controls, so, specific control values overwriting generic style should be set after base values. +* +* After the first BASE set we have the EXTENDED properties (by default guiStyle[16..23]), those +* properties are actually common to all controls and can not be overwritten individually (like BASE ones) +* Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR +* +* Custom control properties can be defined using the EXTENDED properties for each independent control. +* +* TOOL: rGuiStyler is a visual tool to customize raygui style: github.com/raysan5/rguistyler +* +* +* 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 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. +* +* When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set. +* +* The global icons array size is fixed and depends on the number of icons and size: +* +* static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS]; +* +* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB +* +* TOOL: rGuiIcons is a visual tool to customize/create raygui icons: github.com/raysan5/rguiicons +* +* RAYGUI LAYOUT: +* raygui currently does not provide an auto-layout mechanism like other libraries, +* layouts must be defined manually on controls drawing, providing the right bounds Rectangle for it. +* +* TOOL: rGuiLayout is a visual tool to create raygui layouts: github.com/raysan5/rguilayout +* +* CONFIGURATION: +* #define RAYGUI_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYGUI_STANDALONE +* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined +* internally in the library and input management and drawing functions must be provided by +* the user (check library implementation for further details). +* +* #define RAYGUI_NO_ICONS +* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB) +* +* #define RAYGUI_CUSTOM_ICONS +* Includes custom ricons.h header defining a set of custom icons, +* this file can be generated using rGuiIcons tool +* +* #define RAYGUI_DEBUG_RECS_BOUNDS +* Draw control bounds rectangles for debug +* +* #define RAYGUI_DEBUG_TEXT_BOUNDS +* Draw text bounds rectangles for debug +* +* VERSIONS HISTORY: +* 4.1-dev (2024) Current dev version... +* ADDED: guiControlExclusiveMode and guiControlExclusiveRec for exclusive modes +* +* 4.0 (12-Sep-2023) ADDED: GuiToggleSlider() +* ADDED: GuiColorPickerHSV() and GuiColorPanelHSV() +* ADDED: Multiple new icons, mostly compiler related +* ADDED: New DEFAULT properties: TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE +* ADDED: New enum values: GuiTextAlignment, GuiTextAlignmentVertical, GuiTextWrapMode +* ADDED: Support loading styles with custom font charset from external file +* REDESIGNED: GuiTextBox(), support mouse cursor positioning +* REDESIGNED: GuiDrawText(), support multiline and word-wrap modes (read only) +* REDESIGNED: GuiProgressBar() to be more visual, progress affects border color +* REDESIGNED: Global alpha consideration moved to GuiDrawRectangle() and GuiDrawText() +* REDESIGNED: GuiScrollPanel(), get parameters by reference and return result value +* REDESIGNED: GuiToggleGroup(), get parameters by reference and return result value +* REDESIGNED: GuiComboBox(), get parameters by reference and return result value +* REDESIGNED: GuiCheckBox(), get parameters by reference and return result value +* REDESIGNED: GuiSlider(), get parameters by reference and return result value +* REDESIGNED: GuiSliderBar(), get parameters by reference and return result value +* REDESIGNED: GuiProgressBar(), get parameters by reference and return result value +* REDESIGNED: GuiListView(), get parameters by reference and return result value +* REDESIGNED: GuiColorPicker(), get parameters by reference and return result value +* REDESIGNED: GuiColorPanel(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarAlpha(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarHue(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), added extra parameter +* REDESIGNED: GuiListViewEx(), change parameters order +* REDESIGNED: All controls return result as int value +* REVIEWED: GuiScrollPanel() to avoid smallish scroll-bars +* REVIEWED: All examples and specially controls_test_suite +* RENAMED: gui_file_dialog module to gui_window_file_dialog +* UPDATED: All styles to include ISO-8859-15 charset (as much as possible) +* +* 3.6 (10-May-2023) ADDED: New icon: SAND_TIMER +* ADDED: GuiLoadStyleFromMemory() (binary only) +* REVIEWED: GuiScrollBar() horizontal movement key +* REVIEWED: GuiTextBox() crash on cursor movement +* REVIEWED: GuiTextBox(), additional inputs support +* REVIEWED: GuiLabelButton(), avoid text cut +* REVIEWED: GuiTextInputBox(), password input +* REVIEWED: Local GetCodepointNext(), aligned with raylib +* REDESIGNED: GuiSlider*()/GuiScrollBar() to support out-of-bounds +* +* 3.5 (20-Apr-2023) ADDED: GuiTabBar(), based on GuiToggle() +* ADDED: Helper functions to split text in separate lines +* ADDED: Multiple new icons, useful for code editing tools +* REMOVED: Unneeded icon editing functions +* REMOVED: GuiTextBoxMulti(), very limited and broken +* REMOVED: MeasureTextEx() dependency, logic directly implemented +* REMOVED: DrawTextEx() dependency, logic directly implemented +* REVIEWED: GuiScrollBar(), improve mouse-click behaviour +* REVIEWED: Library header info, more info, better organized +* REDESIGNED: GuiTextBox() to support cursor movement +* REDESIGNED: GuiDrawText() to divide drawing by lines +* +* 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 +* +* 2.9 (17-Mar-2021) REMOVED: Tooltip API +* 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle() +* 2.7 (20-Feb-2020) ADDED: Possible tooltips API +* 2.6 (09-Sep-2019) ADDED: GuiTextInputBox() +* REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox() +* REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle() +* Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties +* ADDED: 8 new custom styles ready to use +* Multiple minor tweaks and bugs corrected +* +* 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner() +* 2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed +* Refactor all controls drawing mechanism to use control state +* 2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls +* 2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string +* REDESIGNED: Style system (breaking change) +* 2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts +* REVIEWED: GuiComboBox(), GuiListView()... +* 1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()... +a 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout +* 1.5 (21-Jun-2017) Working in an improved styles system +* 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones) +* 1.3 (12-Jun-2017) Complete redesign of style system +* 1.1 (01-Jun-2017) Complete review of the library +* 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria. +* 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria. +* 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria. +* +* DEPENDENCIES: +* raylib 5.0 - Inputs reading (keyboard/mouse), shapes drawing, font loading and text drawing +* +* STANDALONE MODE: +* By default raygui depends on raylib mostly for the inputs and the drawing functionality but that dependency can be disabled +* with the config flag RAYGUI_STANDALONE. In that case is up to the user to provide another backend to cover library needs. +* +* The following functions should be redefined for a custom backend: +* +* - Vector2 GetMousePosition(void); +* - float GetMouseWheelMove(void); +* - bool IsMouseButtonDown(int button); +* - bool IsMouseButtonPressed(int button); +* - bool IsMouseButtonReleased(int button); +* - bool IsKeyDown(int key); +* - bool IsKeyPressed(int key); +* - int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +* +* - void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +* - void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +* +* - Font GetFontDefault(void); // -- GuiLoadStyleDefault() +* - Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle() +* - Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +* - void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) +* - char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +* - void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data +* - const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs +* - int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +* - void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list +* - unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +* +* CONTRIBUTORS: +* Ramon Santamaria: Supervision, review, redesign, update and maintenance +* Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019) +* Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018) +* Adria Arranz: Testing and implementation of additional controls (2018) +* Jordi Jorba: Testing and implementation of additional controls (2018) +* Albert Martos: Review and testing of the library (2015) +* Ian Eito: Review and testing of the library (2015) +* Kevin Gato: Initial implementation of basic components (2014) +* Daniel Nicolas: Initial implementation of basic components (2014) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2024 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYGUI_H +#define RAYGUI_H + +#define RAYGUI_VERSION_MAJOR 4 +#define RAYGUI_VERSION_MINOR 1 +#define RAYGUI_VERSION_PATCH 0 +#define RAYGUI_VERSION "4.1-dev" + +#if !defined(RAYGUI_STANDALONE) + #include +#endif + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RAYGUIAPI + #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +// Allow custom memory allocators +#ifndef RAYGUI_MALLOC + #define RAYGUI_MALLOC(sz) malloc(sz) +#endif +#ifndef RAYGUI_CALLOC + #define RAYGUI_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RAYGUI_FREE + #define RAYGUI_FREE(p) free(p) +#endif + +// 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 +// NOTE: Some types are required for RAYGUI_STANDALONE usage +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + #ifndef __cplusplus + // Boolean type + #ifndef true + typedef enum { false, true } bool; + #endif + #endif + + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; + + // Vector3 type // -- ConvertHSVtoRGB(), ConvertRGBtoHSV() + typedef struct Vector3 { + float x; + float y; + float z; + } Vector3; + + // Color type, RGBA (32bit) + typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; + } Color; + + // Rectangle type + typedef struct Rectangle { + float x; + float y; + float width; + float height; + } Rectangle; + + // TODO: Texture2D type is very coupled to raylib, required by Font type + // It should be redesigned to be provided by user + typedef struct Texture2D { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Texture2D; + + // Image, pixel data stored in CPU memory (RAM) + typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Image; + + // GlyphInfo, font characters glyphs info + typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data + } GlyphInfo; + + // TODO: Font type is very coupled to raylib, mostly required by GuiLoadStyle() + // It should be redesigned to be provided by user + typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data + } Font; +#endif + +// Style property +// NOTE: Used when exporting style as code for convenience +typedef struct GuiStyleProp { + unsigned short controlId; // Control identifier + unsigned short propertyId; // Property identifier + int propertyValue; // Property value +} GuiStyleProp; + +/* +// Controls text style -NOT USED- +// NOTE: Text style is defined by control +typedef struct GuiTextStyle { + unsigned int size; + int charSpacing; + int lineSpacing; + int alignmentH; + int alignmentV; + int padding; +} GuiTextStyle; +*/ + +// Gui control state +typedef enum { + STATE_NORMAL = 0, + STATE_FOCUSED, + STATE_PRESSED, + STATE_DISABLED +} GuiState; + +// Gui control text alignment +typedef enum { + TEXT_ALIGN_LEFT = 0, + TEXT_ALIGN_CENTER, + TEXT_ALIGN_RIGHT +} GuiTextAlignment; + +// Gui control text alignment vertical +// NOTE: Text vertical position inside the text bounds +typedef enum { + TEXT_ALIGN_TOP = 0, + TEXT_ALIGN_MIDDLE, + TEXT_ALIGN_BOTTOM +} GuiTextAlignmentVertical; + +// Gui control text wrap mode +// NOTE: Useful for multiline text +typedef enum { + TEXT_WRAP_NONE = 0, + TEXT_WRAP_CHAR, + TEXT_WRAP_WORD +} GuiTextWrapMode; + +// Gui controls +typedef enum { + // Default -> populates to all controls when set + DEFAULT = 0, + + // Basic controls + LABEL, // Used also for: LABELBUTTON + BUTTON, + TOGGLE, // Used also for: TOGGLEGROUP + SLIDER, // Used also for: SLIDERBAR, TOGGLESLIDER + PROGRESSBAR, + CHECKBOX, + COMBOBOX, + DROPDOWNBOX, + TEXTBOX, // Used also for: TEXTBOXMULTI + VALUEBOX, + SPINNER, // Uses: BUTTON, VALUEBOX + LISTVIEW, + COLORPICKER, + SCROLLBAR, + STATUSBAR +} GuiControl; + +// Gui base properties for every control +// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties) +typedef enum { + BORDER_COLOR_NORMAL = 0, // Control border color in STATE_NORMAL + BASE_COLOR_NORMAL, // Control base color in STATE_NORMAL + TEXT_COLOR_NORMAL, // Control text color in STATE_NORMAL + BORDER_COLOR_FOCUSED, // Control border color in STATE_FOCUSED + BASE_COLOR_FOCUSED, // Control base color in STATE_FOCUSED + TEXT_COLOR_FOCUSED, // Control text color in STATE_FOCUSED + BORDER_COLOR_PRESSED, // Control border color in STATE_PRESSED + BASE_COLOR_PRESSED, // Control base color in STATE_PRESSED + TEXT_COLOR_PRESSED, // Control text color in STATE_PRESSED + BORDER_COLOR_DISABLED, // Control border color in STATE_DISABLED + BASE_COLOR_DISABLED, // Control base color in STATE_DISABLED + TEXT_COLOR_DISABLED, // Control text color in STATE_DISABLED + BORDER_WIDTH, // Control border size, 0 for no border + //TEXT_SIZE, // Control text size (glyphs max height) -> GLOBAL for all controls + //TEXT_SPACING, // Control text spacing between glyphs -> GLOBAL for all controls + //TEXT_LINE_SPACING // Control text spacing between lines -> GLOBAL for all controls + TEXT_PADDING, // Control text padding, not considering border + TEXT_ALIGNMENT, // Control text horizontal alignment inside control text bound (after border and padding) + //TEXT_WRAP_MODE // Control text wrap-mode inside text bounds -> GLOBAL for all controls +} GuiControlProperty; + +// TODO: Which text styling properties should be global or per-control? +// At this moment TEXT_PADDING and TEXT_ALIGNMENT is configured and saved per control while +// TEXT_SIZE, TEXT_SPACING, TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE are global and +// should be configured by user as needed while defining the UI layout + +// Gui extended properties depend on control +// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default, max 8 properties) +//---------------------------------------------------------------------------------- +// DEFAULT extended properties +// NOTE: Those properties are common to all controls or global +// WARNING: We only have 8 slots for those properties by default!!! -> New global control: TEXT? +typedef enum { + TEXT_SIZE = 16, // Text size (glyphs max height) + TEXT_SPACING, // Text spacing between glyphs + LINE_COLOR, // Line control color + BACKGROUND_COLOR, // Background color + TEXT_LINE_SPACING, // Text spacing between lines + TEXT_ALIGNMENT_VERTICAL, // Text vertical alignment inside text bounds (after border and padding) + TEXT_WRAP_MODE // Text wrap-mode inside text bounds + //TEXT_DECORATION // Text decoration: 0-None, 1-Underline, 2-Line-through, 3-Overline + //TEXT_DECORATION_THICK // Text decoration line thickness +} GuiDefaultProperty; + +// Other possible text properties: +// TEXT_WEIGHT // Normal, Italic, Bold -> Requires specific font change +// TEXT_INDENT // Text indentation -> Now using TEXT_PADDING... + +// Label +//typedef enum { } GuiLabelProperty; + +// Button/Spinner +//typedef enum { } GuiButtonProperty; + +// Toggle/ToggleGroup +typedef enum { + GROUP_PADDING = 16, // ToggleGroup separation between toggles +} GuiToggleProperty; + +// Slider/SliderBar +typedef enum { + SLIDER_WIDTH = 16, // Slider size of internal bar + SLIDER_PADDING // Slider/SliderBar internal bar padding +} GuiSliderProperty; + +// ProgressBar +typedef enum { + PROGRESS_PADDING = 16, // ProgressBar internal padding +} GuiProgressBarProperty; + +// ScrollBar +typedef enum { + ARROWS_SIZE = 16, // ScrollBar arrows size + ARROWS_VISIBLE, // ScrollBar arrows visible + SCROLL_SLIDER_PADDING, // ScrollBar slider internal padding + SCROLL_SLIDER_SIZE, // ScrollBar slider size + SCROLL_PADDING, // ScrollBar scroll padding from arrows + SCROLL_SPEED, // ScrollBar scrolling speed +} GuiScrollBarProperty; + +// CheckBox +typedef enum { + 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_READONLY = 16, // TextBox in read-only mode: 0-text editable, 1-text no-editable +} 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, // ListView items height + LIST_ITEMS_SPACING, // ListView items separation + SCROLLBAR_WIDTH, // ListView scrollbar size (usually width) + SCROLLBAR_SIDE, // ListView scrollbar side (0-SCROLLBAR_LEFT_SIDE, 1-SCROLLBAR_RIGHT_SIDE) +} GuiListViewProperty; + +// ColorPicker +typedef enum { + COLOR_SELECTOR_SIZE = 16, + 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 +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module Functions Declaration +//---------------------------------------------------------------------------------- + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Global gui state control functions +RAYGUIAPI void GuiEnable(void); // Enable gui controls (global state) +RAYGUIAPI void GuiDisable(void); // Disable gui controls (global state) +RAYGUIAPI void GuiLock(void); // Lock gui controls (global state) +RAYGUIAPI void GuiUnlock(void); // Unlock gui controls (global state) +RAYGUIAPI bool GuiIsLocked(void); // Check if gui is locked (global state) +RAYGUIAPI void GuiSetAlpha(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f +RAYGUIAPI void GuiSetState(int state); // Set gui state (global state) +RAYGUIAPI int GuiGetState(void); // Get gui state (global state) + +// Font set/get functions +RAYGUIAPI void GuiSetFont(Font font); // Set gui custom font (global state) +RAYGUIAPI Font GuiGetFont(void); // Get gui custom font (global state) + +// Style set/get functions +RAYGUIAPI void GuiSetStyle(int control, int property, int value); // Set one style property +RAYGUIAPI int GuiGetStyle(int control, int property); // Get one style property + +// 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 + +// Tooltips management functions +RAYGUIAPI void GuiEnableTooltip(void); // Enable gui tooltips (global state) +RAYGUIAPI void GuiDisableTooltip(void); // Disable gui tooltips (global state) +RAYGUIAPI void GuiSetTooltip(const char *tooltip); // Set tooltip string + +// Icons functionality +RAYGUIAPI const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported) +#if !defined(RAYGUI_NO_ICONS) +RAYGUIAPI void GuiSetIconScale(int scale); // Set default icon drawing size +RAYGUIAPI unsigned int *GuiGetIcons(void); // Get raygui icons data pointer +RAYGUIAPI char **GuiLoadIcons(const char *fileName, bool loadIconsName); // Load raygui icons file (.rgi) into internal icons data +RAYGUIAPI void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color); // Draw icon using pixel size at specified position +#endif + +// Controls +//---------------------------------------------------------------------------------------------------------- +// Container/separator controls, useful for controls organization +RAYGUIAPI int GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed +RAYGUIAPI int GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name +RAYGUIAPI int GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text +RAYGUIAPI int GuiPanel(Rectangle bounds, const char *text); // Panel control, useful to group controls +RAYGUIAPI int GuiTabBar(Rectangle bounds, const char **text, int count, int *active); // Tab Bar control, returns TAB to be closed or -1 +RAYGUIAPI int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view); // Scroll Panel control + +// Basic controls set +RAYGUIAPI int GuiLabel(Rectangle bounds, const char *text); // Label control +RAYGUIAPI int GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked +RAYGUIAPI int GuiLabelButton(Rectangle bounds, const char *text); // Label button control, returns true when clicked +RAYGUIAPI int GuiToggle(Rectangle bounds, const char *text, bool *active); // Toggle Button control +RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int *active); // Toggle Group control +RAYGUIAPI int GuiToggleSlider(Rectangle bounds, const char *text, int *active); // Toggle Slider control +RAYGUIAPI int GuiCheckBox(Rectangle bounds, const char *text, bool *checked); // Check Box control, returns true when active +RAYGUIAPI int GuiComboBox(Rectangle bounds, const char *text, int *active); // Combo Box control + +RAYGUIAPI int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control +RAYGUIAPI int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control +RAYGUIAPI int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers +RAYGUIAPI int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text + +RAYGUIAPI int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider control +RAYGUIAPI int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control +RAYGUIAPI int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Progress Bar control +RAYGUIAPI int GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text +RAYGUIAPI int GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders +RAYGUIAPI int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell); // Grid control + +// Advance controls set +RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active); // List View control +RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus); // 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, int textMaxSize, bool *secretViewActive); // Text Input Box control, ask for text, supports secret +RAYGUIAPI int GuiColorPicker(Rectangle bounds, const char *text, Color *color); // Color Picker control (multiple color controls) +RAYGUIAPI int GuiColorPanel(Rectangle bounds, const char *text, Color *color); // Color Panel control +RAYGUIAPI int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha); // Color Bar Alpha control +RAYGUIAPI int GuiColorBarHue(Rectangle bounds, const char *text, float *value); // Color Bar Hue control +RAYGUIAPI int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Picker control that avoids conversion to RGB on each call (multiple color controls) +RAYGUIAPI int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Panel control that updates Hue-Saturation-Value color value, used by GuiColorPickerHSV() +//---------------------------------------------------------------------------------------------------------- + +#if !defined(RAYGUI_NO_ICONS) + +#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_CPU = 206, + ICON_ROM = 207, + ICON_STEP_OVER = 208, + ICON_STEP_INTO = 209, + ICON_STEP_OUT = 210, + ICON_RESTART = 211, + ICON_BREAKPOINT_ON = 212, + ICON_BREAKPOINT_OFF = 213, + ICON_BURGER_MENU = 214, + ICON_CASE_SENSITIVE = 215, + ICON_REG_EXP = 216, + ICON_FOLDER = 217, + ICON_FILE = 218, + ICON_SAND_TIMER = 219, + ICON_WARNING = 220, + ICON_HELP_BOX = 221, + ICON_INFO_BOX = 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) +} // Prevents name mangling of functions +#endif + +#endif // RAYGUI_H + +/*********************************************************************************** +* +* RAYGUI IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RAYGUI_IMPLEMENTATION) + +#include // Required for: FILE, fopen(), fclose(), fprintf(), feof(), fscanf(), vsprintf() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: malloc(), calloc(), free() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: strlen() [GuiTextBox(), GuiValueBox()], memset(), memcpy() +#include // Required for: va_list, va_start(), vfprintf(), va_end() [TextFormat()] +#include // Required for: roundf() [GuiColorPicker()] + +#ifdef __cplusplus + #define RAYGUI_CLITERAL(name) name +#else + #define RAYGUI_CLITERAL(name) (name) +#endif + +// Check if two rectangles are equal, used to validate a slider bounds as an id +#ifndef CHECK_BOUNDS_ID + #define CHECK_BOUNDS_ID(src, dst) ((src.x == dst.x) && (src.y == dst.y) && (src.width == dst.width) && (src.height == dst.height)) +#endif + +#if !defined(RAYGUI_NO_ICONS) && !defined(RAYGUI_CUSTOM_ICONS) + +// 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 +// 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) +// +// 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 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[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, 0x47c2483c, 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, 0x3bf27be2, 0x0bfe1bfa, 0x000007fe, // ICON_CUBE_FACE_BOTTOM + 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // ICON_CUBE_FACE_RIGHT + 0x7fe00000, 0x6fe85ff0, 0x781e77e4, 0x7be27be2, 0x7be27be2, 0x24127be2, 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 + 0x0aa00000, 0x1ff80aa0, 0x1068700e, 0x1008706e, 0x1008700e, 0x1008700e, 0x0aa01ff8, 0x00000aa0, // ICON_CPU + 0x07e00000, 0x04201db8, 0x04a01c38, 0x04a01d38, 0x04a01d38, 0x04a01d38, 0x04201d38, 0x000007e0, // ICON_ROM + 0x00000000, 0x03c00000, 0x3c382ff0, 0x3c04380c, 0x01800000, 0x03c003c0, 0x00000180, 0x00000000, // ICON_STEP_OVER + 0x01800000, 0x01800180, 0x01800180, 0x03c007e0, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_INTO + 0x01800000, 0x07e003c0, 0x01800180, 0x01800180, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_OUT + 0x00000000, 0x0ff003c0, 0x181c1c34, 0x303c301c, 0x30003000, 0x1c301800, 0x03c00ff0, 0x00000000, // ICON_RESTART + 0x00000000, 0x00000000, 0x07e003c0, 0x0ff00ff0, 0x0ff00ff0, 0x03c007e0, 0x00000000, 0x00000000, // ICON_BREAKPOINT_ON + 0x00000000, 0x00000000, 0x042003c0, 0x08100810, 0x08100810, 0x03c00420, 0x00000000, 0x00000000, // ICON_BREAKPOINT_OFF + 0x00000000, 0x00000000, 0x1ff81ff8, 0x1ff80000, 0x00001ff8, 0x1ff81ff8, 0x00000000, 0x00000000, // ICON_BURGER_MENU + 0x00000000, 0x00000000, 0x00880070, 0x0c880088, 0x1e8810f8, 0x3e881288, 0x00000000, 0x00000000, // ICON_CASE_SENSITIVE + 0x00000000, 0x02000000, 0x07000a80, 0x07001fc0, 0x02000a80, 0x00300030, 0x00000000, 0x00000000, // ICON_REG_EXP + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_FOLDER + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x00003ffc, // ICON_FILE + 0x1ff00000, 0x20082008, 0x17d02fe8, 0x05400ba0, 0x09200540, 0x23881010, 0x2fe827c8, 0x00001ff0, // ICON_SAND_TIMER + 0x01800000, 0x02400240, 0x05a00420, 0x09900990, 0x11881188, 0x21842004, 0x40024182, 0x00003ffc, // ICON_WARNING + 0x7ffe0000, 0x4ff24002, 0x4c324ff2, 0x4f824c02, 0x41824f82, 0x41824002, 0x40024182, 0x00007ffe, // ICON_HELP_BOX + 0x7ffe0000, 0x41824002, 0x40024182, 0x41824182, 0x41824182, 0x41824182, 0x40024182, 0x00007ffe, // ICON_INFO_BOX + 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 +}; + +// NOTE: A pointer to current icons array should be defined +static unsigned int *guiIconsPtr = guiIcons; + +#endif // !RAYGUI_NO_ICONS && !RAYGUI_CUSTOM_ICONS + +#ifndef RAYGUI_ICON_SIZE + #define RAYGUI_ICON_SIZE 0 +#endif + +// WARNING: Those values define the total size of the style data array, +// if changed, previous saved styles could become incompatible +#define RAYGUI_MAX_CONTROLS 16 // Maximum number of controls +#define RAYGUI_MAX_PROPS_BASE 16 // Maximum number of base properties +#define RAYGUI_MAX_PROPS_EXTENDED 8 // Maximum number of extended properties + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// Gui control property style color element +typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement; + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +static 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 controls transparency + +static unsigned int guiIconScale = 1; // Gui icon default scale (if icons enabled) + +static bool guiTooltip = false; // Tooltip enabled/disabled +static const char *guiTooltipPtr = NULL; // Tooltip string pointer (string provided by user) + +static bool guiControlExclusiveMode = false; // Gui control exclusive mode (no inputs processed except current control) +static Rectangle guiControlExclusiveRec = { 0 }; // Gui control exclusive bounds rectangle, used as an unique identifier + +static int textBoxCursorIndex = 0; // Cursor index, shared by all GuiTextBox*() +//static int blinkCursorFrameCounter = 0; // Frame counter for cursor blinking +static int autoCursorCooldownCounter = 0; // Cooldown frame counter for automatic cursor movement on key-down +static int autoCursorDelayCounter = 0; // Delay frame counter for automatic cursor movement + +//---------------------------------------------------------------------------------- +// Style data array for all gui style properties (allocated on data segment by default) +// +// NOTE 1: First set of BASE properties are generic to all controls but could be individually +// overwritten per control, first set of EXTENDED properties are generic to all controls and +// can not be overwritten individually but custom EXTENDED properties can be used by control +// +// NOTE 2: A new style set could be loaded over this array using GuiLoadStyle(), +// but default gui style could always be recovered with GuiLoadStyleDefault() +// +// guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +//---------------------------------------------------------------------------------- +static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)] = { 0 }; + +static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization + +//---------------------------------------------------------------------------------- +// Standalone Mode Functions Declaration +// +// NOTE: raygui depend on some raylib input and drawing functions +// To use raygui as standalone library, below functions must be defined by the user +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + +#define KEY_RIGHT 262 +#define KEY_LEFT 263 +#define KEY_DOWN 264 +#define KEY_UP 265 +#define KEY_BACKSPACE 259 +#define KEY_ENTER 257 + +#define MOUSE_LEFT_BUTTON 0 + +// Input required functions +//------------------------------------------------------------------------------- +static Vector2 GetMousePosition(void); +static float GetMouseWheelMove(void); +static bool IsMouseButtonDown(int button); +static bool IsMouseButtonPressed(int button); +static bool IsMouseButtonReleased(int button); + +static bool IsKeyDown(int key); +static bool IsKeyPressed(int key); +static int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +//------------------------------------------------------------------------------- + +// Drawing required functions +//------------------------------------------------------------------------------- +static void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +static void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +//------------------------------------------------------------------------------- + +// Text required functions +//------------------------------------------------------------------------------- +static Font GetFontDefault(void); // -- GuiLoadStyleDefault() +static Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle(), load font + +static Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +static void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) + +static char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +static void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data + +static const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs + +static int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +static void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list + +static unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +//------------------------------------------------------------------------------- + +// raylib functions already implemented in raygui +//------------------------------------------------------------------------------- +static Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value +static int ColorToInt(Color color); // Returns hexadecimal value for a Color +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +static const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed' +static const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +static int TextToInteger(const char *text); // Get integer value from text + +static int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded text +static const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode codepoint into UTF-8 text (char array size returned as parameter) + +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw rectangle vertical gradient +//------------------------------------------------------------------------------- + +#endif // RAYGUI_STANDALONE + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize); // Load style from memory (binary only) + +static int GetTextWidth(const char *text); // Gui get text width using gui font and style +static Rectangle GetTextBounds(int control, Rectangle bounds); // Get text bounds considering control bounds +static const char *GetTextIcon(const char *text, int *iconId); // Get text icon if provided and move text cursor + +static void GuiDrawText(const char *text, Rectangle textBounds, 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, char delimiter, 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() +static void GuiTooltip(Rectangle controlRec); // Draw tooltip using control rec position + +static Color GuiFade(Color color, float alpha); // Fade color by an alpha factor + +//---------------------------------------------------------------------------------- +// Gui Setup Functions Definition +//---------------------------------------------------------------------------------- +// Enable gui global state +// 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 +// 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; } + +// Unlock gui global state +void GuiUnlock(void) { guiLocked = false; } + +// Check if gui is locked (global state) +bool GuiIsLocked(void) { return guiLocked; } + +// Set gui controls alpha global state +void GuiSetAlpha(float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + guiAlpha = alpha; +} + +// Set gui state (global state) +void GuiSetState(int state) { guiState = (GuiState)state; } + +// Get gui state (global state) +int GuiGetState(void) { return guiState; } + +// Set custom gui font +// NOTE: Font loading/unloading is external to raygui +void GuiSetFont(Font font) +{ + if (font.texture.id > 0) + { + // NOTE: If we try to setup a font but default style has not been + // lazily loaded before, it will be overwritten, so we need to force + // default style loading first + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + guiFont = font; + } +} + +// Get custom gui font +Font GuiGetFont(void) +{ + return guiFont; +} + +// Set control style property value +void GuiSetStyle(int control, int property, int value) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + + // Default properties are propagated to all controls + if ((control == 0) && (property < RAYGUI_MAX_PROPS_BASE)) + { + for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) guiStyle[i*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + } +} + +// Get control style property value +int GuiGetStyle(int control, int property) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + return guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property]; +} + +//---------------------------------------------------------------------------------- +// Gui Controls Functions Definition +//---------------------------------------------------------------------------------- + +// Window Box control +int GuiWindowBox(Rectangle bounds, const char *title) +{ + // Window title bar height (including borders) + // NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox() + #if !defined(RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT) + #define RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT 24 + #endif + + int result = 0; + //GuiState state = guiState; + + 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 + 1 }; + Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20, + statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 }; + + // Update control + //-------------------------------------------------------------------- + // NOTE: Logic is directly managed by button + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiStatusBar(statusBar, title); // Draw window header as status bar + GuiPanel(windowPanel, 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, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + result = GuiButton(closeButtonRec, "x"); +#else + result = GuiButton(closeButtonRec, GuiIconText(ICON_CROSS_SMALL, NULL)); +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + //-------------------------------------------------------------------- + + return result; // Window close button clicked: result = 1 +} + +// Group Box control with text name +int GuiGroupBox(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_GROUPBOX_LINE_THICK) + #define RAYGUI_GROUPBOX_LINE_THICK 1 + #endif + + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, RAYGUI_GROUPBOX_LINE_THICK }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + + GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y - GuiGetStyle(DEFAULT, TEXT_SIZE)/2, bounds.width, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) }, text); + //-------------------------------------------------------------------- + + return result; +} + +// Line control +int GuiLine(Rectangle bounds, const char *text) +{ + #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 + + int result = 0; + GuiState state = guiState; + + Color color = GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)); + + // Draw control + //-------------------------------------------------------------------- + if (text == NULL) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, bounds.width, 1 }, 0, BLANK, color); + else + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text) + 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 + 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); + } + //-------------------------------------------------------------------- + + return result; +} + +// Panel control +int GuiPanel(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_PANEL_BORDER_WIDTH) + #define RAYGUI_PANEL_BORDER_WIDTH 1 + #endif + + int result = 0; + 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 + //-------------------------------------------------------------------- + if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar + + GuiDrawRectangle(bounds, RAYGUI_PANEL_BORDER_WIDTH, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), + GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR))); + //-------------------------------------------------------------------- + + return result; +} + +// Tab Bar control +// NOTE: Using GuiToggle() for the TABS +int GuiTabBar(Rectangle bounds, const char **text, int count, int *active) +{ + #define RAYGUI_TABBAR_ITEM_WIDTH 160 + + int result = -1; + //GuiState state = guiState; + + Rectangle tabBounds = { bounds.x, bounds.y, RAYGUI_TABBAR_ITEM_WIDTH, bounds.height }; + + if (*active < 0) *active = 0; + else if (*active > count - 1) *active = count - 1; + + int offsetX = 0; // Required in case tabs go out of screen + offsetX = (*active + 2)*RAYGUI_TABBAR_ITEM_WIDTH - GetScreenWidth(); + if (offsetX < 0) offsetX = 0; + + bool toggle = false; // Required for individual toggles + + // Draw control + //-------------------------------------------------------------------- + for (int i = 0; i < count; i++) + { + tabBounds.x = bounds.x + (RAYGUI_TABBAR_ITEM_WIDTH + 4)*i - offsetX; + + if (tabBounds.x < GetScreenWidth()) + { + // Draw tabs as toggle controls + int textAlignment = GuiGetStyle(TOGGLE, TEXT_ALIGNMENT); + int textPadding = GuiGetStyle(TOGGLE, TEXT_PADDING); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(TOGGLE, TEXT_PADDING, 8); + + if (i == (*active)) + { + toggle = true; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + } + else + { + toggle = false; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + if (toggle) *active = i; + } + + // Close tab with middle mouse button pressed + if (CheckCollisionPointRec(GetMousePosition(), tabBounds) && IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) result = i; + + GuiSetStyle(TOGGLE, TEXT_PADDING, textPadding); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, textAlignment); + + // Draw tab close button + // NOTE: Only draw close button for current tab: if (CheckCollisionPointRec(mousePosition, tabBounds)) + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, "x")) result = i; +#else + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, GuiIconText(ICON_CROSS_SMALL, NULL))) result = i; +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + } + } + + // Draw tab-bar bottom line + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, 1 }, 0, BLANK, GetColor(GuiGetStyle(TOGGLE, BORDER_COLOR_NORMAL))); + //-------------------------------------------------------------------- + + return result; // Return as result the current TAB closing requested +} + +// Scroll Panel control +int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view) +{ + #define RAYGUI_MIN_SCROLLBAR_WIDTH 40 + #define RAYGUI_MIN_SCROLLBAR_HEIGHT 40 + #define RAYGUI_MIN_MOUSE_WHEEL_SPEED 20 + + int result = 0; + GuiState state = guiState; + + Rectangle temp = { 0 }; + if (view == NULL) view = &temp; + + 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; + + // Recheck to account for the other scrollbar being visible + if (!hasHorizontalScrollBar) hasHorizontalScrollBar = (hasVerticalScrollBar && (content.width > (bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + if (!hasVerticalScrollBar) hasVerticalScrollBar = (hasHorizontalScrollBar && (content.height > (bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + + 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) + }; + + // Make sure scroll bars have a minimum width/height + if (horizontalScrollBar.width < RAYGUI_MIN_SCROLLBAR_WIDTH) horizontalScrollBar.width = RAYGUI_MIN_SCROLLBAR_WIDTH; + if (verticalScrollBar.height < RAYGUI_MIN_SCROLLBAR_HEIGHT) verticalScrollBar.height = RAYGUI_MIN_SCROLLBAR_HEIGHT; + + // Calculate view area (area without the scrollbars) + *view = (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? + RAYGUI_CLITERAL(Rectangle){ bounds.x + verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth } : + RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth }; + + // Clip view area to the actual content size + if (view->width > content.width) view->width = content.width; + if (view->height > content.height) view->height = content.height; + + 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.0f : -1.0f; + float verticalMax = hasVerticalScrollBar? content.height - bounds.height + (float)horizontalScrollBarWidth + (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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); + if (IsKeyDown(KEY_LEFT)) scrollPos.x += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } + + if (hasVerticalScrollBar) + { + if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } +#endif + float wheelMove = GetMouseWheelMove(); + + // Set scrolling speed with mouse wheel based on ratio between bounds and content + Vector2 mouseWheelSpeed = { content.width / bounds.width, content.height / bounds.height }; + if (mouseWheelSpeed.x < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.x = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + if (mouseWheelSpeed.y < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.y = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + + // Horizontal and vertical scrolling with mouse wheel + if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_LEFT_SHIFT))) scrollPos.x += wheelMove*mouseWheelSpeed.x; + else scrollPos.y += wheelMove*mouseWheelSpeed.y; // Vertical scroll + } + } + + // Normalize scroll values + if (scrollPos.x > -horizontalMin) scrollPos.x = -horizontalMin; + if (scrollPos.x < -horizontalMax) scrollPos.x = -horizontalMax; + if (scrollPos.y > -verticalMin) scrollPos.y = -verticalMin; + if (scrollPos.y < -verticalMax) scrollPos.y = -verticalMax; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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 + const int slider = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + + // Draw horizontal scrollbar if visible + if (hasHorizontalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content width and the widget width + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)/(int)content.width)*((int)bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth))); + scrollPos.x = (float)-GuiScrollBar(horizontalScrollBar, (int)-scrollPos.x, (int)horizontalMin, (int)horizontalMax); + } + else scrollPos.x = 0.0f; + + // Draw vertical scrollbar if visible + if (hasVerticalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content height and the widget height + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)/(int)content.height)*((int)bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth))); + scrollPos.y = (float)-GuiScrollBar(verticalScrollBar, (int)-scrollPos.y, (int)verticalMin, (int)verticalMax); + } + 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 }; + GuiDrawRectangle(corner, 0, BLANK, GetColor(GuiGetStyle(LISTVIEW, TEXT + (state*3)))); + } + + // Draw scrollbar lines depending on current state + GuiDrawRectangle(bounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + (state*3))), BLANK); + + // Set scrollbar slider size back to the way it was before + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider); + //-------------------------------------------------------------------- + + if (scroll != NULL) *scroll = scrollPos; + + return result; +} + +// Label control +int GuiLabel(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + //... + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Button control, returns true when clicked +int GuiButton(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), GetColor(GuiGetStyle(BUTTON, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), GetColor(GuiGetStyle(BUTTON, TEXT + (state*3)))); + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //------------------------------------------------------------------ + + return result; // Button pressed: result = 1 +} + +// Label button control +int GuiLabelButton(Rectangle bounds, const char *text) +{ + GuiState state = guiState; + bool pressed = false; + + // NOTE: We force bounds.width to be all text + float textWidth = (float)GetTextWidth(text); + if ((bounds.width - 2*GuiGetStyle(LABEL, BORDER_WIDTH) - 2*GuiGetStyle(LABEL, TEXT_PADDING)) < textWidth) bounds.width = textWidth + 2*GuiGetStyle(LABEL, BORDER_WIDTH) + 2*GuiGetStyle(LABEL, TEXT_PADDING) + 2; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return pressed; +} + +// Toggle Button control +int GuiToggle(Rectangle bounds, const char *text, bool *active) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (active == NULL) active = &temp; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check toggle button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_NORMAL; + *active = !(*active); + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_NORMAL) + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, ((*active)? BORDER_COLOR_PRESSED : (BORDER + state*3)))), GetColor(GuiGetStyle(TOGGLE, ((*active)? BASE_COLOR_PRESSED : (BASE + state*3))))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, ((*active)? TEXT_COLOR_PRESSED : (TEXT + state*3))))); + } + else + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + state*3)), GetColor(GuiGetStyle(TOGGLE, BASE + state*3))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, TEXT + state*3))); + } + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; +} + +// Toggle Group control +int GuiToggleGroup(Rectangle bounds, const char *text, int *active) +{ + #if !defined(RAYGUI_TOGGLEGROUP_MAX_ITEMS) + #define RAYGUI_TOGGLEGROUP_MAX_ITEMS 32 + #endif + + int result = 0; + float initBoundsX = bounds.x; + + int temp = 0; + if (active == NULL) active = &temp; + + bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int rows[RAYGUI_TOGGLEGROUP_MAX_ITEMS] = { 0 }; + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, rows); + + int prevRow = rows[0]; + + for (int i = 0; i < itemCount; i++) + { + if (prevRow != rows[i]) + { + bounds.x = initBoundsX; + bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING)); + prevRow = rows[i]; + } + + if (i == (*active)) + { + toggle = true; + GuiToggle(bounds, items[i], &toggle); + } + else + { + toggle = false; + GuiToggle(bounds, items[i], &toggle); + if (toggle) *active = i; + } + + bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING)); + } + + return result; +} + +// Toggle Slider control extended +int GuiToggleSlider(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + //bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle slider = { + 0, // Calculated later depending on the active toggle + bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + (bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - (itemCount + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING))/itemCount, + bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + (*active)++; + result = 1; + } + else state = STATE_FOCUSED; + } + + if ((*active) && (state != STATE_FOCUSED)) state = STATE_PRESSED; + } + + if (*active >= itemCount) *active = 0; + slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH) + (*active + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING) + (*active)*slider.width; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + (state*3))), + GetColor(GuiGetStyle(TOGGLE, BASE_COLOR_NORMAL))); + + // Draw internal slider + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + + // Draw text in slider + if (text != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = slider.x + slider.width/2 - textBounds.width/2; + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(items[*active], textBounds, GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, TEXT + (state*3))), guiAlpha)); + } + //-------------------------------------------------------------------- + + return result; +} + +// Check Box control, returns 1 when state changed +int GuiCheckBox(Rectangle bounds, const char *text, bool *checked) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (checked == NULL) checked = &temp; + + Rectangle textBounds = { 0 }; + + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + Rectangle totalBounds = { + (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT)? textBounds.x : bounds.x, + bounds.y, + bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING), + bounds.height, + }; + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, totalBounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + *checked = !(*checked); + result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), GetColor(GuiGetStyle(CHECKBOX, BORDER + (state*3))), BLANK); + + if (*checked) + { + Rectangle check = { bounds.x + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.y + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.width - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)), + bounds.height - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)) }; + GuiDrawRectangle(check, 0, BLANK, GetColor(GuiGetStyle(CHECKBOX, TEXT + state*3))); + } + + GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Combo Box control +int GuiComboBox(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING)); + + 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) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + if (*active < 0) *active = 0; + else if (*active > (itemCount - 1)) *active = itemCount - 1; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds) || + CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + *active += 1; + if (*active >= itemCount) *active = 0; // Cyclic combobox + } + + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + // Draw combo box main + GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), GetColor(GuiGetStyle(COMBOBOX, BORDER + (state*3))), GetColor(GuiGetStyle(COMBOBOX, BASE + (state*3)))); + GuiDrawText(items[*active], GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(COMBOBOX, TEXT + (state*3)))); + + // Draw selector using a custom button + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + GuiButton(selector, TextFormat("%i/%i", *active + 1, itemCount)); + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign); + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + //-------------------------------------------------------------------- + + return result; +} + +// Dropdown Box control +// NOTE: Returns mouse click +int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode) +{ + int result = 0; + GuiState state = guiState; + + int itemSelected = *active; + int itemFocused = -1; + + // Get substrings items from text (items pointers, lengths and count) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle boundsOpen = bounds; + boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + Rectangle itemBounds = bounds; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // Check if mouse has been pressed or released outside limits + if (!CheckCollisionPointRec(mousePoint, boundsOpen)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + + // Check if already selected item has been pressed again + if (CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + + // Check focused and selected item + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = i; + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + itemSelected = i; + result = 1; // Item selected + } + break; + } + } + + itemBounds = bounds; + } + else + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + result = 1; + state = STATE_PRESSED; + } + else state = STATE_FOCUSED; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (editMode) GuiPanel(boundsOpen, NULL); + + GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER + state*3)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE + state*3))); + GuiDrawText(items[itemSelected], GetTextBounds(DROPDOWNBOX, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + state*3))); + + if (editMode) + { + // Draw visible items + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (i == itemSelected) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED))); + } + else if (i == itemFocused) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED))); + } + else GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL))); + } + } + + // Draw arrows (using icon if available) +#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 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#else + GuiDrawText("#120#", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 6, 10, 10 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); // ICON_ARROW_DOWN_FILL +#endif + //-------------------------------------------------------------------- + + *active = itemSelected; + + // TODO: Use result to return more internal states: mouse-press out-of-bounds, mouse-press over selected-item... + return result; // Mouse click: result = 1 +} + +// Text Box control +// NOTE: Returns true on ENTER pressed (useful for data validation) +int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode) +{ + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN 40 // Frames to wait for autocursor movement + #endif + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY 1 // Frames delay for autocursor movement + #endif + + int result = 0; + GuiState state = guiState; + + bool multiline = false; // TODO: Consider multiline text input + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); + + Rectangle textBounds = GetTextBounds(TEXTBOX, bounds); + int textWidth = GetTextWidth(text) - GetTextWidth(text + textBoxCursorIndex); + int textIndexOffset = 0; // Text index offset to start drawing in the box + + // Cursor rectangle + // NOTE: Position X value should be updated + Rectangle cursor = { + textBounds.x + textWidth + GuiGetStyle(DEFAULT, TEXT_SPACING), + textBounds.y + textBounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE), + 2, + (float)GuiGetStyle(DEFAULT, TEXT_SIZE)*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); + + // Mouse cursor rectangle + // NOTE: Initialized outside of screen + Rectangle mouseCursor = cursor; + mouseCursor.x = -1; + mouseCursor.width = 1; + + // Auto-cursor movement logic + // NOTE: Cursor moves automatically when key down after some time + if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_UP) || IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_BACKSPACE) || IsKeyDown(KEY_DELETE)) autoCursorCooldownCounter++; + else + { + autoCursorCooldownCounter = 0; // GLOBAL: Cursor cooldown counter + autoCursorDelayCounter = 0; // GLOBAL: Cursor delay counter + } + + // Blink-cursor frame counter + //if (!autoCursorMode) blinkCursorFrameCounter++; + //else blinkCursorFrameCounter = 0; + + // Update control + //-------------------------------------------------------------------- + // WARNING: Text editing is only supported under certain conditions: + if ((state != STATE_DISABLED) && // Control not disabled + !GuiGetStyle(TEXTBOX, TEXT_READONLY) && // TextBox not on read-only mode + !guiLocked && // Gui not locked + !guiControlExclusiveMode && // No gui slider on dragging + (wrapMode == TEXT_WRAP_NONE)) // No wrap mode + { + Vector2 mousePosition = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // If text does not fit in the textbox and current cursor position is out of bounds, + // we add an index offset to text for drawing only what requires depending on cursor + while (textWidth >= textBounds.width) + { + int nextCodepointSize = 0; + GetCodepointNext(text + textIndexOffset, &nextCodepointSize); + + textIndexOffset += nextCodepointSize; + + textWidth = GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex); + } + + int textLength = (int)strlen(text); // Get current text length + int codepoint = GetCharPressed(); // Get Unicode codepoint + if (multiline && IsKeyPressed(KEY_ENTER)) codepoint = (int)'\n'; + + if (textBoxCursorIndex > textLength) textBoxCursorIndex = textLength; + + // Encode codepoint as UTF-8 + int codepointSize = 0; + const char *charEncoded = CodepointToUTF8(codepoint, &codepointSize); + + // Add codepoint to text, at current cursor position + // NOTE: Make sure we do not overflow buffer size + if (((multiline && (codepoint == (int)'\n')) || (codepoint >= 32)) && ((textLength + codepointSize) < textSize)) + { + // Move forward data from cursor position + for (int i = (textLength + codepointSize); i > textBoxCursorIndex; i--) text[i] = text[i - codepointSize]; + + // Add new codepoint in current cursor position + for (int i = 0; i < codepointSize; i++) text[textBoxCursorIndex + i] = charEncoded[i]; + + textBoxCursorIndex += codepointSize; + textLength += codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + + // Move cursor to start + if ((textLength > 0) && IsKeyPressed(KEY_HOME)) textBoxCursorIndex = 0; + + // Move cursor to end + if ((textLength > textBoxCursorIndex) && IsKeyPressed(KEY_END)) textBoxCursorIndex = textLength; + + // Delete codepoint from text, after current cursor position + if ((textLength > textBoxCursorIndex) && (IsKeyPressed(KEY_DELETE) || (IsKeyDown(KEY_DELETE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_DELETE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + // Move backward text from cursor position + for (int i = textBoxCursorIndex; i < textLength; i++) text[i] = text[i + nextCodepointSize]; + + textLength -= codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Delete codepoint from text, before current cursor position + if ((textLength > 0) && (IsKeyPressed(KEY_BACKSPACE) || (IsKeyDown(KEY_BACKSPACE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_BACKSPACE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + // Move backward text from cursor position + for (int i = (textBoxCursorIndex - prevCodepointSize); i < textLength; i++) text[i] = text[i + prevCodepointSize]; + + // Prevent cursor index from decrementing past 0 + if (textBoxCursorIndex > 0) + { + textBoxCursorIndex -= codepointSize; + textLength -= codepointSize; + } + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Move cursor position with keys + if (IsKeyPressed(KEY_LEFT) || (IsKeyDown(KEY_LEFT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_LEFT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + if (textBoxCursorIndex >= prevCodepointSize) textBoxCursorIndex -= prevCodepointSize; + } + } + else if (IsKeyPressed(KEY_RIGHT) || (IsKeyDown(KEY_RIGHT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_RIGHT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + if ((textBoxCursorIndex + nextCodepointSize) <= textLength) textBoxCursorIndex += nextCodepointSize; + } + } + + // Move cursor position with mouse + if (CheckCollisionPointRec(mousePosition, textBounds)) // Mouse hover text + { + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/(float)guiFont.baseSize; + int codepointIndex = 0; + float glyphWidth = 0.0f; + float widthToMouseX = 0; + int mouseCursorIndex = 0; + + for (int i = textIndexOffset; i < textLength; i++) + { + codepoint = GetCodepointNext(&text[i], &codepointSize); + codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + if (mousePosition.x <= (textBounds.x + (widthToMouseX + glyphWidth/2))) + { + mouseCursor.x = textBounds.x + widthToMouseX; + mouseCursorIndex = i; + break; + } + + widthToMouseX += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + + // Check if mouse cursor is at the last position + int textEndWidth = GetTextWidth(text + textIndexOffset); + if (GetMousePosition().x >= (textBounds.x + textEndWidth - glyphWidth/2)) + { + mouseCursor.x = textBounds.x + textEndWidth; + mouseCursorIndex = (int)strlen(text); + } + + // Place cursor at required index on mouse click + if ((mouseCursor.x >= 0) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + cursor.x = mouseCursor.x; + textBoxCursorIndex = mouseCursorIndex; + } + } + else mouseCursor.x = -1; + + // Recalculate cursor position.y depending on textBoxCursorIndex + cursor.x = bounds.x + GuiGetStyle(TEXTBOX, TEXT_PADDING) + GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex) + GuiGetStyle(DEFAULT, TEXT_SPACING); + //if (multiline) cursor.y = GetTextLines() + + // Finish text editing on ENTER or mouse click outside bounds + if ((!multiline && IsKeyPressed(KEY_ENTER)) || + (!CheckCollisionPointRec(mousePosition, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) + { + textBoxCursorIndex = 0; // GLOBAL: Reset the shared cursor index + result = 1; + } + } + else + { + if (CheckCollisionPointRec(mousePosition, bounds)) + { + state = STATE_FOCUSED; + + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + textBoxCursorIndex = (int)strlen(text); // GLOBAL: Place cursor index to the end of current text + result = 1; + } + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_PRESSED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))); + } + else if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))); + } + else GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), BLANK); + + // Draw text considering index offset if required + // NOTE: Text index offset depends on cursor position + GuiDrawText(text + textIndexOffset, textBounds, GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode && !GuiGetStyle(TEXTBOX, TEXT_READONLY)) + { + //if (autoCursorMode || ((blinkCursorFrameCounter/40)%2 == 0)) + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + + // Draw mouse position cursor (if required) + if (mouseCursor.x >= 0) GuiDrawRectangle(mouseCursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + } + else if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; // Mouse button pressed: result = 1 +} + +/* +// Text Box control with multiple lines and word-wrap +// NOTE: This text-box is readonly, no editing supported by default +bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode) +{ + bool pressed = false; + + GuiSetStyle(TEXTBOX, TEXT_READONLY, 1); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_WORD); // WARNING: If wrap mode enabled, text editing is not supported + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_TOP); + + // TODO: Implement methods to calculate cursor position properly + pressed = GuiTextBox(bounds, text, textSize, editMode); + + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_NONE); + GuiSetStyle(TEXTBOX, TEXT_READONLY, 0); + + return pressed; +} +*/ + +// Spinner control, returns selected value +int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + int result = 1; + GuiState state = guiState; + + int tempValue = *value; + + 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 }; + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check spinner state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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; + if (tempValue > maxValue) tempValue = maxValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + result = GuiValueBox(spinner, NULL, &tempValue, minValue, maxValue, editMode); + + // Draw value selector custom buttons + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH)); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, 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) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + *value = tempValue; + return result; +} + +// Value Box control, updates input text with numbers +// NOTE: Requires static variables: frameCounter +int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + #if !defined(RAYGUI_VALUEBOX_MAX_CHARS) + #define RAYGUI_VALUEBOX_MAX_CHARS 32 + #endif + + int result = 0; + GuiState state = guiState; + + char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + sprintf(textValue, "%i", *value); + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + bool valueHasChanged = false; + + if (editMode) + { + state = STATE_PRESSED; + + int keyCount = (int)strlen(textValue); + + // Only allow keys in range [48..57] + if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS) + { + if (GetTextWidth(textValue) < bounds.width) + { + int key = GetCharPressed(); + if ((key >= 48) && (key <= 57)) + { + textValue[keyCount] = (char)key; + keyCount++; + valueHasChanged = true; + } + } + } + + // Delete text + if (keyCount > 0) + { + if (IsKeyPressed(KEY_BACKSPACE)) + { + keyCount--; + textValue[keyCount] = '\0'; + valueHasChanged = true; + } + } + + 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))) + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + result = 1; + } + } + else + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + Color baseColor = BLANK; + if (state == STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED)); + else if (state == STATE_DISABLED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED)); + + GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), baseColor); + GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode) + { + // NOTE: ValueBox internal text is always centered + Rectangle cursor = { bounds.x + GetTextWidth(textValue)/2 + bounds.width/2 + 1, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) }; + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED))); + } + + // Draw text label if provided + GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Slider control with pro parameters +// NOTE: Other GuiSlider*() controls use this one +int GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue, int sliderWidth) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + float oldValue = *value; + + Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + if (!CheckCollisionPointRec(mousePoint, slider)) + { + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else state = STATE_FOCUSED; + } + + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + } + + // Control value change check + if (oldValue == *value) result = 0; + else result = 1; + + // Slider bar limits check + int sliderValue = (int)(((*value - minValue)/(maxValue - minValue))*(bounds.width - sliderWidth - GuiGetStyle(SLIDER, BORDER_WIDTH))); + if (sliderWidth > 0) // Slider + { + slider.x += sliderValue; + slider.width = (float)sliderWidth; + if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH); + else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH); + } + else if (sliderWidth == 0) // SliderBar + { + slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH); + slider.width = (float)sliderValue; + if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), GetColor(GuiGetStyle(SLIDER, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + + // Draw slider internal bar (depends on state) + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_PRESSED))); + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Slider control extended, returns selected value and has text +int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH)); +} + +// Slider Bar control extended, returns selected value +int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, 0); +} + +// Progress Bar control extended, shows current progress value +int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + + // Progress bar + Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), + bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0, + bounds.height - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) - 2*GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if (*value > maxValue) *value = maxValue; + + // WARNING: Working with floats could lead to rounding issues + if ((state != STATE_DISABLED)) progress.width = (float)(*value/(maxValue - minValue))*bounds.width - ((*value >= maxValue)? (float)(2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)) : 0.0f); + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(PROGRESSBAR, BORDER + (state*3))), BLANK); + } + else + { + if (*value > minValue) + { + // Draw progress bar with colored border, more visual + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + } + else GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + + if (*value >= maxValue) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + progress.width + 1, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + else + { + // Draw borders not yet reached by value + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y + bounds.height - 1, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + } + + // Draw slider internal progress bar (depends on state) + GuiDrawRectangle(progress, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED))); + } + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Status Bar control +int GuiStatusBar(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(STATUSBAR, BORDER + (state*3))), GetColor(GuiGetStyle(STATUSBAR, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), GetColor(GuiGetStyle(STATUSBAR, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Dummy rectangle control, intended for placeholding +int GuiDummyRec(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + GuiDrawText(text, GetTextBounds(DEFAULT, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(BUTTON, (state != STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED))); + //------------------------------------------------------------------ + + return result; +} + +// List View control +int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active) +{ + int result = 0; + int itemCount = 0; + const char **items = NULL; + + if (text != NULL) items = GuiTextSplit(text, ';', &itemCount, NULL); + + result = GuiListViewEx(bounds, items, itemCount, scrollIndex, active, NULL); + + return result; +} + +// List View control with extended parameters +int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus) +{ + int result = 0; + GuiState state = guiState; + + int itemFocused = (focus == NULL)? -1 : *focus; + int itemSelected = (active == NULL)? -1 : *active; + + // Check if we need a scroll bar + bool useScrollBar = false; + 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_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_SPACING)); + if (visibleItems > count) visibleItems = count; + + int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex; + if ((startIndex < 0) || (startIndex > (count - visibleItems))) startIndex = 0; + int endIndex = startIndex + visibleItems; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check mouse inside list view + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Check focused and selected item + for (int i = 0; i < visibleItems; i++) + { + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = startIndex + i; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + if (itemSelected == (startIndex + i)) itemSelected = -1; + else itemSelected = startIndex + i; + } + break; + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + int wheelMove = (int)GetMouseWheelMove(); + startIndex -= wheelMove; + + if (startIndex < 0) startIndex = 0; + else if (startIndex > (count - visibleItems)) startIndex = count - visibleItems; + + endIndex = startIndex + visibleItems; + if (endIndex > count) endIndex = count; + } + } + else itemFocused = -1; + + // Reset item rectangle y to [0] + itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background + + // Draw visible items + for (int i = 0; ((i < visibleItems) && (text != NULL)); i++) + { + if (state == STATE_DISABLED) + { + if ((startIndex + i) == itemSelected) GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED))); + + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED))); + } + else + { + if (((startIndex + i) == itemSelected) && (active != NULL)) + { + // Draw item selected + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED))); + } + else if (((startIndex + i) == itemFocused)) // && (focus != NULL)) // NOTE: We want items focused, despite not returned! + { + // Draw item focused + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED))); + } + else + { + // Draw item normal + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL))); + } + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + Rectangle scrollBarBounds = { + bounds.x + bounds.width - GuiGetStyle(LISTVIEW, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.y + GuiGetStyle(LISTVIEW, BORDER_WIDTH), (float)GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) + }; + + // Calculate percentage of visible items and apply same percentage to scrollbar + float percentVisible = (float)(endIndex - startIndex)/count; + float sliderSize = bounds.height*percentVisible; + + int prevSliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); // Save default slider size + int prevScrollSpeed = GuiGetStyle(SCROLLBAR, SCROLL_SPEED); // Save default scroll speed + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)sliderSize); // Change slider size + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems); // Change scroll speed + + startIndex = GuiScrollBar(scrollBarBounds, startIndex, 0, count - visibleItems); + + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed); // Reset scroll speed to default + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize); // Reset slider size to default + } + //-------------------------------------------------------------------- + + if (active != NULL) *active = itemSelected; + if (focus != NULL) *focus = itemFocused; + if (scrollIndex != NULL) *scrollIndex = startIndex; + + return result; +} + +// Color Panel control - Color (RGBA) variant. +int GuiColorPanel(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Vector3 vcolor = { (float)color->r/255.0f, (float)color->g/255.0f, (float)color->b/255.0f }; + Vector3 hsv = ConvertRGBtoHSV(vcolor); + Vector3 prevHsv = hsv; // workaround to see if GuiColorPanelHSV modifies the hsv. + + GuiColorPanelHSV(bounds, text, &hsv); + + // Check if the hsv was changed, only then change the color. + // This is necessary, because the Color->HSV->Color conversion has precision errors. + // Thus the assignment from HSV to Color should only be made, if the HSV has a new user-entered value. + // Otherwise GuiColorPanel would often modify it's color without user input. + // TODO: GuiColorPanelHSV could return 1 if the slider was dragged, to simplify this check. + if (hsv.x != prevHsv.x || hsv.y != prevHsv.y || hsv.z != prevHsv.z) + { + Vector3 rgb = ConvertHSVtoRGB(hsv); + + // NOTE: Vector3ToColor() only available on raylib 1.8.1 + *color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x), + (unsigned char)(255.0f*rgb.y), + (unsigned char)(255.0f*rgb.z), + color->a }; + } + return result; +} + +// Color Bar Alpha control +// NOTE: Returns alpha value normalized [0..1] +int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +{ + #if !defined(RAYGUI_COLORBARALPHA_CHECKED_SIZE) + #define RAYGUI_COLORBARALPHA_CHECKED_SIZE 10 + #endif + + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + *alpha = (mousePoint.x - bounds.x)/bounds.width; + if (*alpha <= 0.0f) *alpha = 0.0f; + if (*alpha >= 1.0f) *alpha = 1.0f; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *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 = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + + // Draw alpha bar: checked background + if (state != STATE_DISABLED) + { + 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*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(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.4f) : Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.4f)); + } + } + + DrawRectangleGradientEx(bounds, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha)); + } + else DrawRectangleGradientEx(bounds, Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw alpha bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Bar Hue control +// Returns hue value normalized [0..1] +// NOTE: Other similar bars (for reference): +// Color GuiColorBarSat() [WHITE->color] +// Color GuiColorBarValue() [BLACK->color], HSV/HSL +// float GuiColorBarLuminance() [BLACK->WHITE] +int GuiColorBarHue(Rectangle bounds, const char *text, float *hue) +{ + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + 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 + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *hue = (mousePoint.y - bounds.y)*360/bounds.height; + if (*hue <= 0.0f) *hue = 0.0f; + if (*hue >= 359.0f) *hue = 359.0f; + + } + else state = STATE_FOCUSED; + + /*if (IsKeyDown(KEY_UP)) + { + hue -= 2.0f; + if (hue <= 0.0f) hue = 0.0f; + } + else if (IsKeyDown(KEY_DOWN)) + { + hue += 2.0f; + if (hue >= 360.0f) hue = 360.0f; + }*/ + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state != STATE_DISABLED) + { + // Draw hue bar:color bars + // TODO: Use directly DrawRectangleGradientEx(bounds, color1, color2, color2, color1); + 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)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw hue bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Picker control +// NOTE: It's divided in multiple controls: +// Color GuiColorPanel(Rectangle bounds, Color color) +// float GuiColorBarAlpha(Rectangle bounds, float alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanel() size +// NOTE: this picker converts RGB to HSV, which can cause the Hue control to jump. If you have this problem, consider using the HSV variant instead +int GuiColorPicker(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Color temp = { 200, 0, 0, 255 }; + if (color == NULL) color = &temp; + + 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) }; + + // NOTE: this conversion can cause low hue-resolution, if the r, g and b value are very similar, which causes the hue bar to shift around when only the GuiColorPanel is used. + Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ (*color).r/255.0f, (*color).g/255.0f, (*color).b/255.0f }); + + GuiColorBarHue(boundsHue, NULL, &hsv.x); + + //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f); + Vector3 rgb = ConvertHSVtoRGB(hsv); + + *color = RAYGUI_CLITERAL(Color){ (unsigned char)roundf(rgb.x*255.0f), (unsigned char)roundf(rgb.y*255.0f), (unsigned char)roundf(rgb.z*255.0f), (*color).a }; + + return result; +} + +// Color Picker control that avoids conversion to RGB and back to HSV on each call, thus avoiding jittering. +// The user can call ConvertHSVtoRGB() to convert *colorHsv value to RGB. +// NOTE: It's divided in multiple controls: +// int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +// int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanelHSV() size +int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + + Vector3 tempHsv = { 0 }; + + if (colorHsv == NULL) + { + const Vector3 tempColor = { 200.0f/255.0f, 0.0f, 0.0f }; + tempHsv = ConvertRGBtoHSV(tempColor); + colorHsv = &tempHsv; + } + + GuiColorPanelHSV(bounds, NULL, colorHsv); + + const Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height }; + + GuiColorBarHue(boundsHue, NULL, &colorHsv->x); + + return result; +} + +// Color Panel control - HSV variant +int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + GuiState state = guiState; + Vector2 pickerSelector = { 0 }; + + const Color colWhite = { 255, 255, 255, 255 }; + const Color colBlack = { 0, 0, 0, 255 }; + + pickerSelector.x = bounds.x + (float)colorHsv->y*bounds.width; // HSV: Saturation + pickerSelector.y = bounds.y + (1.0f - (float)colorHsv->z)*bounds.height; // HSV: Value + + Vector3 maxHue = { colorHsv->x, 1.0f, 1.0f }; + Vector3 rgbHue = ConvertHSVtoRGB(maxHue); + Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x), + (unsigned char)(255.0f*rgbHue.y), + (unsigned char)(255.0f*rgbHue.z), 255 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + pickerSelector = mousePoint; + + if (pickerSelector.x < bounds.x) pickerSelector.x = bounds.x; + if (pickerSelector.x > bounds.x + bounds.width) pickerSelector.x = bounds.x + bounds.width; + if (pickerSelector.y < bounds.y) pickerSelector.y = bounds.y; + if (pickerSelector.y > bounds.y + bounds.height) pickerSelector.y = bounds.y + bounds.height; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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)); + + // Draw color picker: selector + Rectangle selector = { pickerSelector.x - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, pickerSelector.y - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE) }; + GuiDrawRectangle(selector, 0, BLANK, colWhite); + } + else + { + DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.6f), guiAlpha)); + } + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + //-------------------------------------------------------------------- + + return result; +} + +// Message Box control +int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons) +{ + #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 result = -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 + 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; + + int textWidth = GetTextWidth(message) + 2; + + Rectangle textBounds = { 0 }; + textBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.width = bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*2; + textBounds.height = bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 3*RAYGUI_MESSAGEBOX_BUTTON_PADDING - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + + prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment); + //-------------------------------------------------------------------- + + return result; +} + +// Text Input Box control, ask for text +int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, bool *secretViewActive) +{ + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT 24 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_PADDING) + #define RAYGUI_TEXTINPUTBOX_BUTTON_PADDING 12 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_HEIGHT 26 + #endif + + // Used to enable text edit mode + // WARNING: No more than one GuiTextInputBox() should be open at the same time + static bool textEditMode = false; + + int result = -1; + + int buttonCount = 0; + const char **buttonsText = GuiTextSplit(buttons, ';', &buttonCount, NULL); + Rectangle buttonBounds = { 0 }; + 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 - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - 2*RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + + Rectangle textBounds = { 0 }; + if (message != NULL) + { + int textSize = GetTextWidth(message) + 2; + + textBounds.x = bounds.x + bounds.width/2 - textSize/2; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + messageInputHeight/4 - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + textBounds.width = (float)textSize; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + } + + Rectangle textBoxBounds = { 0 }; + 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 - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*2; + textBoxBounds.height = RAYGUI_TEXTINPUTBOX_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + // Draw message if available + if (message != NULL) + { + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + } + + 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; + + 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, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + if (result >= 0) textEditMode = false; + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment); + //-------------------------------------------------------------------- + + return result; // Result is the pressed button index +} + +// Grid control +// NOTE: Returns grid mouse-hover selected cell +// About drawing lines at subpixel spacing, simple put, not easy solution: +// https://stackoverflow.com/questions/4435450/2d-opengl-drawing-lines-that-dont-exactly-fit-pixel-raster +int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell) +{ + // Grid lines alpha amount + #if !defined(RAYGUI_GRID_ALPHA) + #define RAYGUI_GRID_ALPHA 0.15f + #endif + + int result = 0; + GuiState state = guiState; + + Vector2 mousePoint = GetMousePosition(); + Vector2 currentMouseCell = { -1, -1 }; + + float spaceWidth = spacing/(float)subdivs; + int linesV = (int)(bounds.width/spaceWidth) + 1; + int linesH = (int)(bounds.height/spaceWidth) + 1; + + int color = GuiGetStyle(DEFAULT, LINE_COLOR); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + // NOTE: Cell values must be the upper left of the cell the mouse is in + currentMouseCell.x = floorf((mousePoint.x - bounds.x)/spacing); + currentMouseCell.y = floorf((mousePoint.y - bounds.y)/spacing); + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) color = GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED); + + if (subdivs > 0) + { + // Draw vertical grid lines + for (int i = 0; i < linesV; i++) + { + Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height }; + GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(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)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(color), RAYGUI_GRID_ALPHA)); + } + } + + if (mouseCell != NULL) *mouseCell = currentMouseCell; + return result; +} + +//---------------------------------------------------------------------------------- +// Tooltip management functions +// NOTE: Tooltips requires some global variables: tooltipPtr +//---------------------------------------------------------------------------------- +// Enable gui tooltips (global state) +void GuiEnableTooltip(void) { guiTooltip = true; } + +// Disable gui tooltips (global state) +void GuiDisableTooltip(void) { guiTooltip = false; } + +// Set tooltip string +void GuiSetTooltip(const char *tooltip) { guiTooltipPtr = tooltip; } + +//---------------------------------------------------------------------------------- +// Styles loading functions +//---------------------------------------------------------------------------------- + +// 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; + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + // Try reading the files as text file first + FILE *rgsFile = fopen(fileName, "rt"); + + if (rgsFile != NULL) + { + char buffer[MAX_LINE_BUFFER_SIZE] = { 0 }; + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + + if (buffer[0] == '#') + { + int controlId = 0; + int propertyId = 0; + unsigned int propertyValue = 0; + + while (!feof(rgsFile)) + { + switch (buffer[0]) + { + case 'p': + { + // Style property: p + + sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue); + GuiSetStyle(controlId, propertyId, (int)propertyValue); + + } break; + case 'f': + { + // Style font: f + + int fontSize = 0; + char charmapFileName[256] = { 0 }; + char fontFileName[256] = { 0 }; + sscanf(buffer, "f %d %s %[^\r\n]s", &fontSize, charmapFileName, fontFileName); + + Font font = { 0 }; + int *codepoints = NULL; + int codepointCount = 0; + + if (charmapFileName[0] != '0') + { + // Load text data from file + // NOTE: Expected an UTF-8 array of codepoints, no separation + char *textData = LoadFileText(TextFormat("%s/%s", GetDirectoryPath(fileName), charmapFileName)); + codepoints = LoadCodepoints(textData, &codepointCount); + UnloadFileText(textData); + } + + if (fontFileName[0] != '\0') + { + // In case a font is already loaded and it is not default internal font, unload it + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + + if (codepointCount > 0) font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, codepoints, codepointCount); + else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0); // Default to 95 standard codepoints + } + + // If font texture not properly loaded, revert to default font and size/spacing + if (font.texture.id == 0) + { + font = GetFontDefault(); + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); + } + + UnloadCodepoints(codepoints); + + if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font); + + } break; + default: break; + } + + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + } + } + else tryBinary = true; + + fclose(rgsFile); + } + + if (tryBinary) + { + rgsFile = fopen(fileName, "rb"); + + if (rgsFile != NULL) + { + fseek(rgsFile, 0, SEEK_END); + int fileDataSize = ftell(rgsFile); + fseek(rgsFile, 0, SEEK_SET); + + if (fileDataSize > 0) + { + unsigned char *fileData = (unsigned char *)RAYGUI_MALLOC(fileDataSize*sizeof(unsigned char)); + fread(fileData, sizeof(unsigned char), fileDataSize, rgsFile); + + GuiLoadStyleFromMemory(fileData, fileDataSize); + + RAYGUI_FREE(fileData); + } + + fclose(rgsFile); + } + } +} + +// Load style default over global style +void GuiLoadStyleDefault(void) +{ + // We set this variable first to avoid cyclic function calls + // when calling GuiSetStyle() and GuiGetStyle() + guiStyleLoaded = true; + + // Initialize default LIGHT style property values + // WARNING: Default value are applied to all controls on set but + // they can be overwritten later on for every custom control + GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, 0x838383ff); + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0xc9c9c9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, 0x686868ff); + GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, 0x5bb2d9ff); + GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, 0xc9effeff); + GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, 0x6c9bbcff); + GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, 0x0492c7ff); + GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, 0x97e8ffff); + GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, 0x368bafff); + GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, 0xb5c1c2ff); + GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, 0xe6e9e9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, 0xaeb7b8ff); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); + GuiSetStyle(DEFAULT, TEXT_PADDING, 0); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + // Initialize default extended property values + // NOTE: By default, extended property values are initialized to 0 + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, LINE_COLOR, 0x90abb5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0xf5f5f5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, TEXT_LINE_SPACING, 15); // DEFAULT, 15 pixels between lines + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); // DEFAULT, text aligned vertically to middle of text-bounds + + // Initialize control-specific property values + // NOTE: Those properties are in default list but require specific values by control type + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 2); + GuiSetStyle(SLIDER, TEXT_PADDING, 4); + GuiSetStyle(PROGRESSBAR, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, TEXT_ALIGN_RIGHT); + GuiSetStyle(DROPDOWNBOX, TEXT_PADDING, 0); + GuiSetStyle(DROPDOWNBOX, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiSetStyle(TEXTBOX, TEXT_PADDING, 4); + GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(VALUEBOX, TEXT_PADDING, 0); + GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(SPINNER, TEXT_PADDING, 0); + 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 + GuiSetStyle(TOGGLE, GROUP_PADDING, 2); + 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, 32); + GuiSetStyle(COMBOBOX, COMBO_BUTTON_SPACING, 2); + GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16); + GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING, 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, 12); + GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 28); + GuiSetStyle(LISTVIEW, LIST_ITEMS_SPACING, 2); + GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 12); + GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE); + 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); + + if (guiFont.texture.id != GetFontDefault().texture.id) + { + // Unload previous font texture + UnloadTexture(guiFont.texture); + RL_FREE(guiFont.recs); + RL_FREE(guiFont.glyphs); + guiFont.recs = NULL; + guiFont.glyphs = NULL; + + // Setup default raylib font + guiFont = GetFontDefault(); + + // NOTE: Default raylib font character 95 is a white square + Rectangle whiteChar = guiFont.recs[95]; + + // NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding on MSAA filtering + SetShapesTexture(guiFont.texture, RAYGUI_CLITERAL(Rectangle){ whiteChar.x + 1, whiteChar.y + 1, whiteChar.width - 2, whiteChar.height - 2 }); + } +} + +// Get text with icon id prepended +// NOTE: Useful to add icons by name id (enum) instead of +// a number that can change between ricon versions +const char *GuiIconText(int iconId, const char *text) +{ +#if defined(RAYGUI_NO_ICONS) + return NULL; +#else + static char buffer[1024] = { 0 }; + static char iconBuffer[16] = { 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); + + return iconBuffer; + } +#endif +} + +#if !defined(RAYGUI_NO_ICONS) +// Get full icons data pointer +unsigned int *GuiGetIcons(void) { return guiIconsPtr; } + +// Load raygui icons file (.rgi) +// NOTE: In case nameIds are required, they can be requested with loadIconsName, +// 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) +{ + // Style File Structure (.rgi) + // ------------------------------------------------------ + // Offset | Size | Type | Description + // ------------------------------------------------------ + // 0 | 4 | char | Signature: "rGI " + // 4 | 2 | short | Version: 100 + // 6 | 2 | short | reserved + + // 8 | 2 | short | Num icons (N) + // 10 | 2 | short | Icons size (Options: 16, 32, 64) (S) + + // Icons name id (32 bytes per name id) + // foreach (icon) + // { + // 12+32*i | 32 | char | Icon NameId + // } + + // Icons data: One bit per pixel, stored as unsigned int array (depends on icon size) + // S*S pixels/32bit per unsigned int = K unsigned int per icon + // foreach (icon) + // { + // ... | K | unsigned int | Icon Data + // } + + FILE *rgiFile = fopen(fileName, "rb"); + + char **guiIconsName = NULL; + + if (rgiFile != NULL) + { + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + short iconCount = 0; + short iconSize = 0; + + fread(signature, 1, 4, rgiFile); + fread(&version, sizeof(short), 1, rgiFile); + fread(&reserved, sizeof(short), 1, rgiFile); + fread(&iconCount, sizeof(short), 1, rgiFile); + fread(&iconSize, sizeof(short), 1, rgiFile); + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'I') && + (signature[3] == ' ')) + { + if (loadIconsName) + { + guiIconsName = (char **)RAYGUI_MALLOC(iconCount*sizeof(char **)); + for (int i = 0; i < iconCount; i++) + { + guiIconsName[i] = (char *)RAYGUI_MALLOC(RAYGUI_ICON_MAX_NAME_LENGTH); + fread(guiIconsName[i], 1, RAYGUI_ICON_MAX_NAME_LENGTH, rgiFile); + } + } + else fseek(rgiFile, iconCount*RAYGUI_ICON_MAX_NAME_LENGTH, SEEK_CUR); + + // Read icons data directly over internal icons array + fread(guiIconsPtr, sizeof(unsigned int), iconCount*(iconSize*iconSize/32), rgiFile); + } + + fclose(rgiFile); + } + + return guiIconsName; +} + +// Draw selected icon using rectangles pixel-by-pixel +void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color) +{ + #define BIT_CHECK(a,b) ((a) & (1u<<(b))) + + 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(guiIconsPtr[iconId*RAYGUI_ICON_DATA_ELEMENTS + i], k)) + { + #if !defined(RAYGUI_STANDALONE) + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ (float)posX + (k%RAYGUI_ICON_SIZE)*pixelSize, (float)posY + y*pixelSize, (float)pixelSize, (float)pixelSize }, 0, BLANK, color); + #endif + } + + if ((k == 15) || (k == 31)) y++; + } + } +} + +// Set icon drawing size +void GuiSetIconScale(int scale) +{ + if (scale >= 1) guiIconScale = scale; +} + +#endif // !RAYGUI_NO_ICONS + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- + +// Load style from memory +// WARNING: Binary files only +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize) +{ + unsigned char *fileDataPtr = (unsigned char *)fileData; + + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + int propertyCount = 0; + + memcpy(signature, fileDataPtr, 4); + memcpy(&version, fileDataPtr + 4, sizeof(short)); + memcpy(&reserved, fileDataPtr + 4 + 2, sizeof(short)); + memcpy(&propertyCount, fileDataPtr + 4 + 2 + 2, sizeof(int)); + fileDataPtr += 12; + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'S') && + (signature[3] == ' ')) + { + short controlId = 0; + short propertyId = 0; + unsigned int propertyValue = 0; + + for (int i = 0; i < propertyCount; i++) + { + memcpy(&controlId, fileDataPtr, sizeof(short)); + memcpy(&propertyId, fileDataPtr + 2, sizeof(short)); + memcpy(&propertyValue, fileDataPtr + 2 + 2, sizeof(unsigned int)); + fileDataPtr += 8; + + if (controlId == 0) // DEFAULT control + { + // If a DEFAULT property is loaded, it is propagated to all controls + // NOTE: All DEFAULT properties should be defined first in the file + GuiSetStyle(0, (int)propertyId, propertyValue); + + if (propertyId < RAYGUI_MAX_PROPS_BASE) for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) GuiSetStyle(i, (int)propertyId, propertyValue); + } + else GuiSetStyle((int)controlId, (int)propertyId, propertyValue); + } + + // Font loading is highly dependant on raylib API to load font data and image + +#if !defined(RAYGUI_STANDALONE) + // Load custom font if available + int fontDataSize = 0; + memcpy(&fontDataSize, fileDataPtr, sizeof(int)); + fileDataPtr += 4; + + if (fontDataSize > 0) + { + Font font = { 0 }; + int fontType = 0; // 0-Normal, 1-SDF + + memcpy(&font.baseSize, fileDataPtr, sizeof(int)); + memcpy(&font.glyphCount, fileDataPtr + 4, sizeof(int)); + memcpy(&fontType, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + // Load font white rectangle + Rectangle fontWhiteRec = { 0 }; + memcpy(&fontWhiteRec, fileDataPtr, sizeof(Rectangle)); + fileDataPtr += 16; + + // Load font image parameters + int fontImageUncompSize = 0; + int fontImageCompSize = 0; + memcpy(&fontImageUncompSize, fileDataPtr, sizeof(int)); + memcpy(&fontImageCompSize, fileDataPtr + 4, sizeof(int)); + fileDataPtr += 8; + + Image imFont = { 0 }; + imFont.mipmaps = 1; + memcpy(&imFont.width, fileDataPtr, sizeof(int)); + memcpy(&imFont.height, fileDataPtr + 4, sizeof(int)); + memcpy(&imFont.format, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + if ((fontImageCompSize > 0) && (fontImageCompSize != fontImageUncompSize)) + { + // Compressed font atlas image data (DEFLATE), it requires DecompressData() + int dataUncompSize = 0; + unsigned char *compData = (unsigned char *)RAYGUI_MALLOC(fontImageCompSize); + memcpy(compData, fileDataPtr, fontImageCompSize); + fileDataPtr += fontImageCompSize; + + imFont.data = DecompressData(compData, fontImageCompSize, &dataUncompSize); + + // Security check, dataUncompSize must match the provided fontImageUncompSize + if (dataUncompSize != fontImageUncompSize) RAYGUI_LOG("WARNING: Uncompressed font atlas image data could be corrupted"); + + RAYGUI_FREE(compData); + } + else + { + // Font atlas image data is not compressed + imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageUncompSize); + memcpy(imFont.data, fileDataPtr, fontImageUncompSize); + fileDataPtr += fontImageUncompSize; + } + + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + font.texture = LoadTextureFromImage(imFont); + + RAYGUI_FREE(imFont.data); + + // Validate font atlas texture was loaded correctly + if (font.texture.id != 0) + { + // Load font recs data + int recsDataSize = font.glyphCount*sizeof(Rectangle); + int recsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed recs data + memcpy(&recsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + if ((recsDataCompressedSize > 0) && (recsDataCompressedSize != recsDataSize)) + { + // Recs data is compressed, uncompress it + unsigned char *recsDataCompressed = (unsigned char *)RAYGUI_MALLOC(recsDataCompressedSize); + + memcpy(recsDataCompressed, fileDataPtr, recsDataCompressedSize); + fileDataPtr += recsDataCompressedSize; + + int recsDataUncompSize = 0; + font.recs = (Rectangle *)DecompressData(recsDataCompressed, recsDataCompressedSize, &recsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (recsDataUncompSize != recsDataSize) RAYGUI_LOG("WARNING: Uncompressed font recs data could be corrupted"); + + RAYGUI_FREE(recsDataCompressed); + } + else + { + // Recs data is uncompressed + font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle)); + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.recs[i], fileDataPtr, sizeof(Rectangle)); + fileDataPtr += sizeof(Rectangle); + } + } + + // Load font glyphs info data + int glyphsDataSize = font.glyphCount*16; // 16 bytes data per glyph + int glyphsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed glyphs data + memcpy(&glyphsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + // Allocate required glyphs space to fill with data + font.glyphs = (GlyphInfo *)RAYGUI_CALLOC(font.glyphCount, sizeof(GlyphInfo)); + + if ((glyphsDataCompressedSize > 0) && (glyphsDataCompressedSize != glyphsDataSize)) + { + // Glyphs data is compressed, uncompress it + unsigned char *glypsDataCompressed = (unsigned char *)RAYGUI_MALLOC(glyphsDataCompressedSize); + + memcpy(glypsDataCompressed, fileDataPtr, glyphsDataCompressedSize); + fileDataPtr += glyphsDataCompressedSize; + + int glyphsDataUncompSize = 0; + unsigned char *glyphsDataUncomp = DecompressData(glypsDataCompressed, glyphsDataCompressedSize, &glyphsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (glyphsDataUncompSize != glyphsDataSize) RAYGUI_LOG("WARNING: Uncompressed font glyphs data could be corrupted"); + + unsigned char *glyphsDataUncompPtr = glyphsDataUncomp; + + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, glyphsDataUncompPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, glyphsDataUncompPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, glyphsDataUncompPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, glyphsDataUncompPtr + 12, sizeof(int)); + glyphsDataUncompPtr += 16; + } + + RAYGUI_FREE(glypsDataCompressed); + RAYGUI_FREE(glyphsDataUncomp); + } + else + { + // Glyphs data is uncompressed + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, fileDataPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, fileDataPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, fileDataPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, fileDataPtr + 12, sizeof(int)); + fileDataPtr += 16; + } + } + } + else font = GetFontDefault(); // Fallback in case of errors loading font atlas texture + + GuiSetFont(font); + + // Set font texture source rectangle to be used as white texture to draw shapes + // NOTE: It makes possible to draw shapes and text (full UI) in a single draw call + if ((fontWhiteRec.x > 0) && + (fontWhiteRec.y > 0) && + (fontWhiteRec.width > 0) && + (fontWhiteRec.height > 0)) SetShapesTexture(font.texture, fontWhiteRec); + } +#endif + } +} + +// Gui get text width considering icon +static int GetTextWidth(const char *text) +{ + #if !defined(ICON_TEXT_PADDING) + #define ICON_TEXT_PADDING 4 + #endif + + Vector2 textSize = { 0 }; + int textIconOffset = 0; + + if ((text != NULL) && (text[0] != '\0')) + { + if (text[0] == '#') + { + for (int i = 1; (i < 5) && (text[i] != '\0'); i++) + { + if (text[i] == '#') + { + textIconOffset = i; + break; + } + } + } + + text += textIconOffset; + + // Make sure guiFont is set, GuiGetStyle() initializes it lazynessly + float fontSize = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + + // Custom MeasureText() implementation + if ((guiFont.texture.id > 0) && (text != NULL)) + { + // Get size in bytes of text, considering end of line and line break + int size = 0; + for (int i = 0; i < MAX_LINE_BUFFER_SIZE; i++) + { + if ((text[i] != '\0') && (text[i] != '\n')) size++; + else break; + } + + float scaleFactor = fontSize/(float)guiFont.baseSize; + textSize.y = (float)guiFont.baseSize*scaleFactor; + float glyphWidth = 0.0f; + + for (int i = 0, codepointSize = 0; i < size; i += codepointSize) + { + int codepoint = GetCodepointNext(&text[i], &codepointSize); + int codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + textSize.x += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (textIconOffset > 0) textSize.x += (RAYGUI_ICON_SIZE - ICON_TEXT_PADDING); + } + + return (int)textSize.x; +} + +// Get text bounds considering control bounds +static Rectangle GetTextBounds(int control, Rectangle bounds) +{ + Rectangle textBounds = bounds; + + textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH); + textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH) + GuiGetStyle(control, TEXT_PADDING); + textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); + textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); // NOTE: Text is processed line per line! + + // Depending on control, TEXT_PADDING and TEXT_ALIGNMENT properties could affect the text-bounds + switch (control) + { + case COMBOBOX: + case DROPDOWNBOX: + case LISTVIEW: + // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW + case SLIDER: + case CHECKBOX: + case VALUEBOX: + case SPINNER: + // TODO: More special cases (label on side): SLIDER, CHECKBOX, VALUEBOX, SPINNER + default: + { + // TODO: WARNING: TEXT_ALIGNMENT is already considered in GuiDrawText() + if (GuiGetStyle(control, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING); + else textBounds.x += GuiGetStyle(control, TEXT_PADDING); + } + break; + } + + return textBounds; +} + +// Get text icon if provided and move text cursor +// NOTE: We support up to 999 values for iconId +static const char *GetTextIcon(const char *text, int *iconId) +{ +#if !defined(RAYGUI_NO_ICONS) + *iconId = -1; + if (text[0] == '#') // Maybe we have an icon! + { + char iconValue[4] = { 0 }; // Maximum length for icon value: 3 digits + '\0' + + int pos = 1; + while ((pos < 4) && (text[pos] >= '0') && (text[pos] <= '9')) + { + iconValue[pos - 1] = text[pos]; + pos++; + } + + if (text[pos] == '#') + { + *iconId = TextToInteger(iconValue); + + // Move text pointer after icon + // WARNING: If only icon provided, it could point to EOL character: '\0' + if (*iconId >= 0) text += (pos + 1); + } + } +#endif + + return text; +} + +// Get text divided into lines (by line-breaks '\n') +const char **GetTextLines(const char *text, int *count) +{ + #define RAYGUI_MAX_TEXT_LINES 128 + + static const char *lines[RAYGUI_MAX_TEXT_LINES] = { 0 }; + for (int i = 0; i < RAYGUI_MAX_TEXT_LINES; i++) lines[i] = NULL; // Init NULL pointers to substrings + + int textSize = (int)strlen(text); + + lines[0] = text; + int len = 0; + *count = 1; + //int lineSize = 0; // Stores current line size, not returned + + for (int i = 0, k = 0; (i < textSize) && (*count < RAYGUI_MAX_TEXT_LINES); i++) + { + if (text[i] == '\n') + { + //lineSize = len; + k++; + lines[k] = &text[i + 1]; // WARNING: next value is valid? + len = 0; + *count += 1; + } + else len++; + } + + //lines[*count - 1].size = len; + + return lines; +} + +// Get text width to next space for provided string +static float GetNextSpaceWidth(const char *text, int *nextSpaceIndex) +{ + float width = 0; + int codepointByteCount = 0; + int codepoint = 0; + int index = 0; + float glyphWidth = 0; + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + for (int i = 0; text[i] != '\0'; i++) + { + if (text[i] != ' ') + { + codepoint = GetCodepoint(&text[i], &codepointByteCount); + index = GetGlyphIndex(guiFont, codepoint); + glyphWidth = (guiFont.glyphs[index].advanceX == 0)? guiFont.recs[index].width*scaleFactor : guiFont.glyphs[index].advanceX*scaleFactor; + width += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + else + { + *nextSpaceIndex = i; + break; + } + } + + return width; +} + +// Gui draw text using default font +static void GuiDrawText(const char *text, Rectangle textBounds, int alignment, Color tint) +{ + #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')) return; // Security check + + // PROCEDURE: + // - Text is processed line per line + // - For every line, horizontal alignment is defined + // - For all text, vertical alignment is defined (multiline text only) + // - For every line, wordwrap mode is checked (useful for GuitextBox(), read-only) + + // Get text lines (using '\n' as delimiter) to be processed individually + // WARNING: We can't use GuiTextSplit() function because it can be already used + // before the GuiDrawText() call and its buffer is static, it would be overriden :( + int lineCount = 0; + const char **lines = GetTextLines(text, &lineCount); + + // Text style variables + //int alignment = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT); + int alignmentVertical = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL); + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); // Wrap-mode only available in read-only mode, no for text editing + + // TODO: WARNING: This totalHeight is not valid for vertical alignment in case of word-wrap + float totalHeight = (float)(lineCount*GuiGetStyle(DEFAULT, TEXT_SIZE) + (lineCount - 1)*GuiGetStyle(DEFAULT, TEXT_SIZE)/2); + float posOffsetY = 0.0f; + + for (int i = 0; i < lineCount; i++) + { + int iconId = 0; + lines[i] = GetTextIcon(lines[i], &iconId); // Check text for icon and move cursor + + // Get text position depending on alignment and iconId + //--------------------------------------------------------------------------------- + Vector2 textBoundsPosition = { textBounds.x, textBounds.y }; + float textBoundsWidthOffset = 0.0f; + + // NOTE: We get text size after icon has been processed + // WARNING: GetTextWidth() also processes text icon to get width! -> Really needed? + int textSizeX = GetTextWidth(lines[i]); + + // If text requires an icon, add size to measure + if (iconId >= 0) + { + textSizeX += RAYGUI_ICON_SIZE*guiIconScale; + + // WARNING: If only icon provided, text could be pointing to EOF character: '\0' +#if !defined(RAYGUI_NO_ICONS) + if ((lines[i] != NULL) && (lines[i][0] != '\0')) textSizeX += ICON_TEXT_PADDING; +#endif + } + + // Check guiTextAlign global variables + switch (alignment) + { + case TEXT_ALIGN_LEFT: textBoundsPosition.x = textBounds.x; break; + case TEXT_ALIGN_CENTER: textBoundsPosition.x = textBounds.x + textBounds.width/2 - textSizeX/2; break; + case TEXT_ALIGN_RIGHT: textBoundsPosition.x = textBounds.x + textBounds.width - textSizeX; break; + default: break; + } + + if (textSizeX > textBounds.width && (lines[i] != NULL) && (lines[i][0] != '\0')) textBoundsPosition.x = textBounds.x; + + switch (alignmentVertical) + { + // Only valid in case of wordWrap = 0; + case TEXT_ALIGN_TOP: textBoundsPosition.y = textBounds.y + posOffsetY; break; + case TEXT_ALIGN_MIDDLE: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height/2 - totalHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + case TEXT_ALIGN_BOTTOM: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height - totalHeight + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + default: break; + } + + // NOTE: Make sure we get pixel-perfect coordinates, + // In case of decimals we got weird text positioning + textBoundsPosition.x = (float)((int)textBoundsPosition.x); + textBoundsPosition.y = (float)((int)textBoundsPosition.y); + //--------------------------------------------------------------------------------- + + // Draw text (with icon if available) + //--------------------------------------------------------------------------------- +#if !defined(RAYGUI_NO_ICONS) + if (iconId >= 0) + { + // NOTE: We consider icon height, probably different than text size + GuiDrawIcon(iconId, (int)textBoundsPosition.x, (int)(textBounds.y + textBounds.height/2 - RAYGUI_ICON_SIZE*guiIconScale/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height)), guiIconScale, tint); + textBoundsPosition.x += (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + textBoundsWidthOffset = (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + } +#endif + // Get size in bytes of text, + // considering end of line and line break + int lineSize = 0; + for (int c = 0; (lines[i][c] != '\0') && (lines[i][c] != '\n') && (lines[i][c] != '\r'); c++, lineSize++){ } + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + int lastSpaceIndex = 0; + bool tempWrapCharMode = false; + + int textOffsetY = 0; + float textOffsetX = 0.0f; + float glyphWidth = 0; + + float ellipsisWidth = GetTextWidth("..."); + bool overflowReached = false; + for (int c = 0, codepointSize = 0; c < lineSize; c += codepointSize) + { + int codepoint = GetCodepointNext(&lines[i][c], &codepointSize); + int index = GetGlyphIndex(guiFont, codepoint); + + // NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f) + // but we need to draw all of the bad bytes using the '?' symbol moving one byte + if (codepoint == 0x3f) codepointSize = 1; // TODO: Review not recognized codepoints size + + // Get glyph width to check if it goes out of bounds + if (guiFont.glyphs[index].advanceX == 0) glyphWidth = ((float)guiFont.recs[index].width*scaleFactor); + else glyphWidth = (float)guiFont.glyphs[index].advanceX*scaleFactor; + + // Wrap mode text measuring, to validate if + // it can be drawn or a new line is required + if (wrapMode == TEXT_WRAP_CHAR) + { + // Jump to next line if current character reach end of the box limits + if ((textOffsetX + glyphWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + + if (tempWrapCharMode) // Wrap at char level when too long words + { + wrapMode = TEXT_WRAP_WORD; + tempWrapCharMode = false; + } + } + } + else if (wrapMode == TEXT_WRAP_WORD) + { + if (codepoint == 32) lastSpaceIndex = c; + + // Get width to next space in line + int nextSpaceIndex = 0; + float nextSpaceWidth = GetNextSpaceWidth(lines[i] + c, &nextSpaceIndex); + + int nextSpaceIndex2 = 0; + float nextWordSize = GetNextSpaceWidth(lines[i] + lastSpaceIndex + 1, &nextSpaceIndex2); + + if (nextWordSize > textBounds.width - textBoundsWidthOffset) + { + // Considering the case the next word is longer than bounds + tempWrapCharMode = true; + wrapMode = TEXT_WRAP_CHAR; + } + else if ((textOffsetX + nextSpaceWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + } + + if (codepoint == '\n') break; // WARNING: Lines are already processed manually, no need to keep drawing after this codepoint + else + { + // TODO: There are multiple types of spaces in Unicode, + // maybe it's a good idea to add support for more: http://jkorpela.fi/chars/spaces.html + if ((codepoint != ' ') && (codepoint != '\t')) // Do not draw codepoints with no glyph + { + if (wrapMode == TEXT_WRAP_NONE) + { + // Draw only required text glyphs fitting the textBounds.width + if (textSizeX > textBounds.width) + { + if (textOffsetX <= (textBounds.width - glyphWidth - textBoundsWidthOffset - ellipsisWidth)) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + else if (!overflowReached) + { + overflowReached = true; + + for (int j = 0; j < ellipsisWidth; j += ellipsisWidth/3) + { + DrawTextCodepoint(guiFont, '.', RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX + j, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + else + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) + { + // Draw only glyphs inside the bounds + if ((textBoundsPosition.y + textOffsetY) <= (textBounds.y + textBounds.height - GuiGetStyle(DEFAULT, TEXT_SIZE))) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + + if (guiFont.glyphs[index].advanceX == 0) textOffsetX += ((float)guiFont.recs[index].width*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + else textOffsetX += ((float)guiFont.glyphs[index].advanceX*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (wrapMode == TEXT_WRAP_NONE) posOffsetY += (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) posOffsetY += (textOffsetY + (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING)); + //--------------------------------------------------------------------------------- + } + +#if defined(RAYGUI_DEBUG_TEXT_BOUNDS) + GuiDrawRectangle(textBounds, 0, WHITE, Fade(BLUE, 0.4f)); +#endif +} + +// Gui draw rectangle using default raygui plain style with borders +static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color) +{ + if (color.a > 0) + { + // Draw rectangle filled with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, GuiFade(color, guiAlpha)); + } + + if (borderWidth > 0) + { + // Draw rectangle border lines with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + } + +#if defined(RAYGUI_DEBUG_RECS_BOUNDS) + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, Fade(RED, 0.4f)); +#endif +} + +// Draw tooltip using control bounds +static void GuiTooltip(Rectangle controlRec) +{ + if (!guiLocked && guiTooltip && (guiTooltipPtr != NULL) && !guiControlExclusiveMode) + { + Vector2 textSize = MeasureTextEx(GuiGetFont(), guiTooltipPtr, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + + if ((controlRec.x + textSize.x + 16) > GetScreenWidth()) controlRec.x -= (textSize.x + 16 - controlRec.width); + + GuiPanel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, NULL); + + int textPadding = GuiGetStyle(LABEL, TEXT_PADDING); + int textAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_PADDING, 0); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, guiTooltipPtr); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, textAlignment); + GuiSetStyle(LABEL, TEXT_PADDING, textPadding); + } +} + +// Split controls text into multiple strings +// Also check for multiple columns (required by GuiToggleGroup()) +static const char **GuiTextSplit(const char *text, char delimiter, 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 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 + + // TODO: HACK: GuiTextSplit() - Review how textRows are returned to user + // textRow is an externally provided array of integers that stores row number for every splitted string + + #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 }; // String pointers array (points to buffer data) + static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 }; // Buffer data (text input copy with '\0' added) + memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE); + + result[0] = buffer; + int counter = 1; + + if (textRow != NULL) textRow[0] = 0; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if ((buffer[i] == delimiter) || (buffer[i] == '\n')) + { + result[counter] = buffer + i + 1; + + if (textRow != NULL) + { + if (buffer[i] == '\n') textRow[counter] = textRow[counter - 1] + 1; + else textRow[counter] = textRow[counter - 1]; + } + + buffer[i] = '\0'; // Set an end of string at this point + + counter++; + if (counter > RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + + *count = counter; + + return result; +} + +// Convert color data from RGB to HSV +// NOTE: Color data should be passed normalized +static Vector3 ConvertRGBtoHSV(Vector3 rgb) +{ + Vector3 hsv = { 0 }; + float min = 0.0f; + float max = 0.0f; + float delta = 0.0f; + + min = (rgb.x < rgb.y)? rgb.x : rgb.y; + min = (min < rgb.z)? min : rgb.z; + + max = (rgb.x > rgb.y)? rgb.x : rgb.y; + max = (max > rgb.z)? max : rgb.z; + + hsv.z = max; // Value + delta = max - min; + + if (delta < 0.00001f) + { + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + if (max > 0.0f) + { + // NOTE: If max is 0, this divide would cause a crash + hsv.y = (delta/max); // Saturation + } + else + { + // NOTE: If max is 0, then r = g = b = 0, s = 0, h is undefined + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + // NOTE: Comparing float values could not work properly + if (rgb.x >= max) hsv.x = (rgb.y - rgb.z)/delta; // Between yellow & magenta + else + { + if (rgb.y >= max) hsv.x = 2.0f + (rgb.z - rgb.x)/delta; // Between cyan & yellow + else hsv.x = 4.0f + (rgb.x - rgb.y)/delta; // Between magenta & cyan + } + + hsv.x *= 60.0f; // Convert to degrees + + if (hsv.x < 0.0f) hsv.x += 360.0f; + + return hsv; +} + +// Convert color data from HSV to RGB +// NOTE: Color data should be passed normalized +static Vector3 ConvertHSVtoRGB(Vector3 hsv) +{ + Vector3 rgb = { 0 }; + float hh = 0.0f, p = 0.0f, q = 0.0f, t = 0.0f, ff = 0.0f; + long i = 0; + + // NOTE: Comparing float values could not work properly + if (hsv.y <= 0.0f) + { + rgb.x = hsv.z; + rgb.y = hsv.z; + rgb.z = hsv.z; + return rgb; + } + + hh = hsv.x; + if (hh >= 360.0f) hh = 0.0f; + hh /= 60.0f; + + i = (long)hh; + ff = hh - i; + p = hsv.z*(1.0f - hsv.y); + q = hsv.z*(1.0f - (hsv.y*ff)); + t = hsv.z*(1.0f - (hsv.y*(1.0f - ff))); + + switch (i) + { + case 0: + { + rgb.x = hsv.z; + rgb.y = t; + rgb.z = p; + } break; + case 1: + { + rgb.x = q; + rgb.y = hsv.z; + rgb.z = p; + } break; + case 2: + { + rgb.x = p; + rgb.y = hsv.z; + rgb.z = t; + } break; + case 3: + { + rgb.x = p; + rgb.y = q; + rgb.z = hsv.z; + } break; + case 4: + { + rgb.x = t; + rgb.y = p; + rgb.z = hsv.z; + } break; + case 5: + default: + { + rgb.x = hsv.z; + rgb.y = p; + rgb.z = q; + } break; + } + + return rgb; +} + +// 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; + + int valueRange = maxValue - minValue; + if (valueRange <= 0) valueRange = 1; + + int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + if (sliderSize < 1) sliderSize = 1; // TODO: Consider a minimum 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) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.height)? ((int)scrollbar.height - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + scrollbar.y + (int)(((float)(value - minValue)/valueRange)*(scrollbar.height - sliderSize)), + bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)), + (float)sliderSize }; + } + else // horizontal + { + 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)) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.width)? ((int)scrollbar.width - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + scrollbar.x + (int)(((float)(value - minValue)/valueRange)*(scrollbar.width - sliderSize)), + bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + (float)sliderSize, + bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)) }; + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && + !CheckCollisionPointRec(mousePoint, arrowUpLeft) && + !CheckCollisionPointRec(mousePoint, arrowDownRight)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Handle mouse wheel + int wheel = (int)GetMouseWheelMove(); + if (wheel != 0) value += wheel; + + // Handle mouse button down + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + // Check arrows click + if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) value -= valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) value += valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (!CheckCollisionPointRec(mousePoint, slider)) + { + // If click on scrollbar position but not on slider, place slider directly on that position + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + + state = STATE_PRESSED; + } + + // Keyboard control on mouse hover scrollbar + /* + if (isVertical) + { + if (IsKeyDown(KEY_DOWN)) value += 5; + else if (IsKeyDown(KEY_UP)) value -= 5; + } + else + { + if (IsKeyDown(KEY_RIGHT)) value += 5; + else if (IsKeyDown(KEY_LEFT)) value -= 5; + } + */ + } + + // Normalize value + if (value > maxValue) value = maxValue; + if (value < minValue) value = minValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED))); // Draw the background + + GuiDrawRectangle(scrollbar, 0, BLANK, GetColor(GuiGetStyle(BUTTON, BASE_COLOR_NORMAL))); // Draw the scrollbar active area background + GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BORDER + state*3))); // 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, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); + GuiDrawText(isVertical? "v" : ">", + RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // 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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // ICON_ARROW_DOWN_FILL / ICON_ARROW_RIGHT_FILL +#endif + } + //-------------------------------------------------------------------- + + return value; +} + +// Color fade-in or fade-out, alpha goes from 0.0f to 1.0f +// WARNING: It multiplies current alpha by alpha scale factor +static Color GuiFade(Color color, float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + Color result = { color.r, color.g, color.b, (unsigned char)(color.a*alpha) }; + + return result; +} + +#if defined(RAYGUI_STANDALONE) +// Returns a Color struct from hexadecimal value +static Color GetColor(int hexValue) +{ + Color color; + + color.r = (unsigned char)(hexValue >> 24) & 0xFF; + color.g = (unsigned char)(hexValue >> 16) & 0xFF; + color.b = (unsigned char)(hexValue >> 8) & 0xFF; + color.a = (unsigned char)hexValue & 0xFF; + + return color; +} + +// Returns hexadecimal value for a Color +static int ColorToInt(Color color) +{ + return (((int)color.r << 24) | ((int)color.g << 16) | ((int)color.b << 8) | (int)color.a); +} + +// Check if point is inside rectangle +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec) +{ + bool collision = false; + + if ((point.x >= rec.x) && (point.x <= (rec.x + rec.width)) && + (point.y >= rec.y) && (point.y <= (rec.y + rec.height))) collision = true; + + return collision; +} + +// Formatting of text with variables to 'embed' +static const char *TextFormat(const char *text, ...) +{ + #if !defined(RAYGUI_TEXTFORMAT_MAX_SIZE) + #define RAYGUI_TEXTFORMAT_MAX_SIZE 256 + #endif + + static char buffer[RAYGUI_TEXTFORMAT_MAX_SIZE]; + + va_list args; + va_start(args, text); + vsprintf(buffer, text, args); + va_end(args); + + return buffer; +} + +// Draw rectangle with vertical gradient fill color +// NOTE: This function is only used by GuiColorPicker() +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2) +{ + Rectangle bounds = { (float)posX, (float)posY, (float)width, (float)height }; + DrawRectangleGradientEx(bounds, color1, color2, color2, color1); +} + +// 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 RAYGUI_TEXTSPLIT_MAX_ITEMS + // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE + + #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; + + if (text != NULL) + { + counter = 1; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if (buffer[i] == delimiter) + { + buffer[i] = '\0'; // Set an end of string at this point + result[counter] = buffer + i + 1; + counter++; + + if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + } + + *count = counter; + return result; +} + +// Get integer value from text +// NOTE: This function replaces atoi() [stdlib.h] +static int TextToInteger(const char *text) +{ + int value = 0; + int sign = 1; + + if ((text[0] == '+') || (text[0] == '-')) + { + if (text[0] == '-') sign = -1; + text++; + } + + for (int i = 0; ((text[i] >= '0') && (text[i] <= '9')); ++i) value = value*10 + (int)(text[i] - '0'); + + return value*sign; +} + +// Encode codepoint into UTF-8 text (char array size returned as parameter) +static const char *CodepointToUTF8(int codepoint, int *byteSize) +{ + static char utf8[6] = { 0 }; + int size = 0; + + if (codepoint <= 0x7f) + { + utf8[0] = (char)codepoint; + size = 1; + } + else if (codepoint <= 0x7ff) + { + utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0); + utf8[1] = (char)((codepoint & 0x3f) | 0x80); + size = 2; + } + else if (codepoint <= 0xffff) + { + utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0); + utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[2] = (char)((codepoint & 0x3f) | 0x80); + size = 3; + } + else if (codepoint <= 0x10ffff) + { + utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0); + utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80); + utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[3] = (char)((codepoint & 0x3f) | 0x80); + size = 4; + } + + *byteSize = size; + + return utf8; +} + +// Get next codepoint in a UTF-8 encoded text, scanning until '\0' is found +// When a invalid UTF-8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned +// Total number of bytes processed are returned as a parameter +// NOTE: the standard says U+FFFD should be returned in case of errors +// but that character is not supported by the default font in raylib +static int GetCodepointNext(const char *text, int *codepointSize) +{ + const char *ptr = text; + int codepoint = 0x3f; // Codepoint (defaults to '?') + *codepointSize = 1; + + // Get current codepoint and bytes processed + if (0xf0 == (0xf8 & ptr[0])) + { + // 4 byte UTF-8 codepoint + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]); + *codepointSize = 4; + } + else if (0xe0 == (0xf0 & ptr[0])) + { + // 3 byte UTF-8 codepoint */ + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]); + *codepointSize = 3; + } + else if (0xc0 == (0xe0 & ptr[0])) + { + // 2 byte UTF-8 codepoint + if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } //10xxxxxx checks + codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]); + *codepointSize = 2; + } + else if (0x00 == (0x80 & ptr[0])) + { + // 1 byte UTF-8 codepoint + codepoint = ptr[0]; + *codepointSize = 1; + } + + return codepoint; +} +#endif // RAYGUI_STANDALONE + +#endif // RAYGUI_IMPLEMENTATION diff --git a/raylib-src/old-raygui-src/raygui.h b/raylib-src/old-raygui-src/raygui.h new file mode 100644 index 0000000..5c0bc60 --- /dev/null +++ b/raylib-src/old-raygui-src/raygui.h @@ -0,0 +1,5540 @@ +/******************************************************************************************* +* +* raygui v4.1-dev - A simple and easy-to-use immediate-mode gui library +* +* DESCRIPTION: +* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +* available as a standalone library, as long as input and drawing functions are provided. +* +* FEATURES: +* - Immediate-mode gui, minimal retained data +* - +25 controls provided (basic and advanced) +* - Styling system for colors, font and metrics +* - Icons supported, embedded as a 1-bit icons pack +* - Standalone mode option (custom input/graphics backend) +* - Multiple support tools provided for raygui development +* +* POSSIBLE IMPROVEMENTS: +* - Better standalone mode API for easy plug of custom backends +* - Externalize required inputs, allow user easier customization +* +* LIMITATIONS: +* - No editable multi-line word-wraped text box supported +* - No auto-layout mechanism, up to the user to define controls position and size +* - Standalone mode requires library modification and some user work to plug another backend +* +* NOTES: +* - WARNING: GuiLoadStyle() and GuiLoadStyle{Custom}() functions, allocate memory for +* font atlas recs and glyphs, freeing that memory is (usually) up to the user, +* no unload function is explicitly provided... but note that GuiLoadStyleDefault() unloads +* by default any previously loaded font (texture, recs, glyphs). +* - Global UI alpha (guiAlpha) is applied inside GuiDrawRectangle() and GuiDrawText() functions +* +* CONTROLS PROVIDED: +* # Container/separators Controls +* - WindowBox --> StatusBar, Panel +* - GroupBox --> Line +* - Line +* - Panel --> StatusBar +* - ScrollPanel --> StatusBar +* - TabBar --> Button +* +* # Basic Controls +* - Label +* - LabelButton --> Label +* - Button +* - Toggle +* - ToggleGroup --> Toggle +* - ToggleSlider +* - CheckBox +* - ComboBox +* - DropdownBox +* - TextBox +* - ValueBox --> TextBox +* - Spinner --> Button, ValueBox +* - Slider +* - SliderBar --> Slider +* - ProgressBar +* - StatusBar +* - DummyRec +* - Grid +* +* # Advance Controls +* - ListView +* - ColorPicker --> ColorPanel, ColorBarHue +* - MessageBox --> Window, Label, Button +* - TextInputBox --> Window, Label, TextBox, Button +* +* It also provides a set of functions for styling the controls based on its properties (size, color). +* +* +* 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 +* recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one +* +* The global style array size is fixed and depends on the number of controls and properties: +* +* static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)]; +* +* guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +* +* Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style +* used for all controls, when any of those base values is set, it is automatically populated to all +* controls, so, specific control values overwriting generic style should be set after base values. +* +* After the first BASE set we have the EXTENDED properties (by default guiStyle[16..23]), those +* properties are actually common to all controls and can not be overwritten individually (like BASE ones) +* Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR +* +* Custom control properties can be defined using the EXTENDED properties for each independent control. +* +* TOOL: rGuiStyler is a visual tool to customize raygui style: github.com/raysan5/rguistyler +* +* +* 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 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. +* +* When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set. +* +* The global icons array size is fixed and depends on the number of icons and size: +* +* static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS]; +* +* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB +* +* TOOL: rGuiIcons is a visual tool to customize/create raygui icons: github.com/raysan5/rguiicons +* +* RAYGUI LAYOUT: +* raygui currently does not provide an auto-layout mechanism like other libraries, +* layouts must be defined manually on controls drawing, providing the right bounds Rectangle for it. +* +* TOOL: rGuiLayout is a visual tool to create raygui layouts: github.com/raysan5/rguilayout +* +* CONFIGURATION: +* #define RAYGUI_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYGUI_STANDALONE +* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined +* internally in the library and input management and drawing functions must be provided by +* the user (check library implementation for further details). +* +* #define RAYGUI_NO_ICONS +* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB) +* +* #define RAYGUI_CUSTOM_ICONS +* Includes custom ricons.h header defining a set of custom icons, +* this file can be generated using rGuiIcons tool +* +* #define RAYGUI_DEBUG_RECS_BOUNDS +* Draw control bounds rectangles for debug +* +* #define RAYGUI_DEBUG_TEXT_BOUNDS +* Draw text bounds rectangles for debug +* +* VERSIONS HISTORY: +* 4.1-dev (2024) Current dev version... +* ADDED: guiControlExclusiveMode and guiControlExclusiveRec for exclusive modes +* +* 4.0 (12-Sep-2023) ADDED: GuiToggleSlider() +* ADDED: GuiColorPickerHSV() and GuiColorPanelHSV() +* ADDED: Multiple new icons, mostly compiler related +* ADDED: New DEFAULT properties: TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE +* ADDED: New enum values: GuiTextAlignment, GuiTextAlignmentVertical, GuiTextWrapMode +* ADDED: Support loading styles with custom font charset from external file +* REDESIGNED: GuiTextBox(), support mouse cursor positioning +* REDESIGNED: GuiDrawText(), support multiline and word-wrap modes (read only) +* REDESIGNED: GuiProgressBar() to be more visual, progress affects border color +* REDESIGNED: Global alpha consideration moved to GuiDrawRectangle() and GuiDrawText() +* REDESIGNED: GuiScrollPanel(), get parameters by reference and return result value +* REDESIGNED: GuiToggleGroup(), get parameters by reference and return result value +* REDESIGNED: GuiComboBox(), get parameters by reference and return result value +* REDESIGNED: GuiCheckBox(), get parameters by reference and return result value +* REDESIGNED: GuiSlider(), get parameters by reference and return result value +* REDESIGNED: GuiSliderBar(), get parameters by reference and return result value +* REDESIGNED: GuiProgressBar(), get parameters by reference and return result value +* REDESIGNED: GuiListView(), get parameters by reference and return result value +* REDESIGNED: GuiColorPicker(), get parameters by reference and return result value +* REDESIGNED: GuiColorPanel(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarAlpha(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarHue(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), added extra parameter +* REDESIGNED: GuiListViewEx(), change parameters order +* REDESIGNED: All controls return result as int value +* REVIEWED: GuiScrollPanel() to avoid smallish scroll-bars +* REVIEWED: All examples and specially controls_test_suite +* RENAMED: gui_file_dialog module to gui_window_file_dialog +* UPDATED: All styles to include ISO-8859-15 charset (as much as possible) +* +* 3.6 (10-May-2023) ADDED: New icon: SAND_TIMER +* ADDED: GuiLoadStyleFromMemory() (binary only) +* REVIEWED: GuiScrollBar() horizontal movement key +* REVIEWED: GuiTextBox() crash on cursor movement +* REVIEWED: GuiTextBox(), additional inputs support +* REVIEWED: GuiLabelButton(), avoid text cut +* REVIEWED: GuiTextInputBox(), password input +* REVIEWED: Local GetCodepointNext(), aligned with raylib +* REDESIGNED: GuiSlider*()/GuiScrollBar() to support out-of-bounds +* +* 3.5 (20-Apr-2023) ADDED: GuiTabBar(), based on GuiToggle() +* ADDED: Helper functions to split text in separate lines +* ADDED: Multiple new icons, useful for code editing tools +* REMOVED: Unneeded icon editing functions +* REMOVED: GuiTextBoxMulti(), very limited and broken +* REMOVED: MeasureTextEx() dependency, logic directly implemented +* REMOVED: DrawTextEx() dependency, logic directly implemented +* REVIEWED: GuiScrollBar(), improve mouse-click behaviour +* REVIEWED: Library header info, more info, better organized +* REDESIGNED: GuiTextBox() to support cursor movement +* REDESIGNED: GuiDrawText() to divide drawing by lines +* +* 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 +* +* 2.9 (17-Mar-2021) REMOVED: Tooltip API +* 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle() +* 2.7 (20-Feb-2020) ADDED: Possible tooltips API +* 2.6 (09-Sep-2019) ADDED: GuiTextInputBox() +* REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox() +* REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle() +* Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties +* ADDED: 8 new custom styles ready to use +* Multiple minor tweaks and bugs corrected +* +* 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner() +* 2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed +* Refactor all controls drawing mechanism to use control state +* 2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls +* 2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string +* REDESIGNED: Style system (breaking change) +* 2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts +* REVIEWED: GuiComboBox(), GuiListView()... +* 1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()... +* 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout +* 1.5 (21-Jun-2017) Working in an improved styles system +* 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones) +* 1.3 (12-Jun-2017) Complete redesign of style system +* 1.1 (01-Jun-2017) Complete review of the library +* 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria. +* 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria. +* 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria. +* +* DEPENDENCIES: +* raylib 5.0 - Inputs reading (keyboard/mouse), shapes drawing, font loading and text drawing +* +* STANDALONE MODE: +* By default raygui depends on raylib mostly for the inputs and the drawing functionality but that dependency can be disabled +* with the config flag RAYGUI_STANDALONE. In that case is up to the user to provide another backend to cover library needs. +* +* The following functions should be redefined for a custom backend: +* +* - Vector2 GetMousePosition(void); +* - float GetMouseWheelMove(void); +* - bool IsMouseButtonDown(int button); +* - bool IsMouseButtonPressed(int button); +* - bool IsMouseButtonReleased(int button); +* - bool IsKeyDown(int key); +* - bool IsKeyPressed(int key); +* - int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +* +* - void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +* - void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +* +* - Font GetFontDefault(void); // -- GuiLoadStyleDefault() +* - Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle() +* - Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +* - void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) +* - char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +* - void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data +* - const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs +* - int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +* - void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list +* - unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +* +* CONTRIBUTORS: +* Ramon Santamaria: Supervision, review, redesign, update and maintenance +* Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019) +* Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018) +* Adria Arranz: Testing and implementation of additional controls (2018) +* Jordi Jorba: Testing and implementation of additional controls (2018) +* Albert Martos: Review and testing of the library (2015) +* Ian Eito: Review and testing of the library (2015) +* Kevin Gato: Initial implementation of basic components (2014) +* Daniel Nicolas: Initial implementation of basic components (2014) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2024 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYGUI_H +#define RAYGUI_H + +#define RAYGUI_VERSION_MAJOR 4 +#define RAYGUI_VERSION_MINOR 1 +#define RAYGUI_VERSION_PATCH 0 +#define RAYGUI_VERSION "4.1-dev" + +#if !defined(RAYGUI_STANDALONE) + #include "raylib.h" +#endif + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RAYGUIAPI + #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +// Allow custom memory allocators +#ifndef RAYGUI_MALLOC + #define RAYGUI_MALLOC(sz) malloc(sz) +#endif +#ifndef RAYGUI_CALLOC + #define RAYGUI_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RAYGUI_FREE + #define RAYGUI_FREE(p) free(p) +#endif + +// 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 +// NOTE: Some types are required for RAYGUI_STANDALONE usage +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + #ifndef __cplusplus + // Boolean type + #ifndef true + typedef enum { false, true } bool; + #endif + #endif + + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; + + // Vector3 type // -- ConvertHSVtoRGB(), ConvertRGBtoHSV() + typedef struct Vector3 { + float x; + float y; + float z; + } Vector3; + + // Color type, RGBA (32bit) + typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; + } Color; + + // Rectangle type + typedef struct Rectangle { + float x; + float y; + float width; + float height; + } Rectangle; + + // TODO: Texture2D type is very coupled to raylib, required by Font type + // It should be redesigned to be provided by user + typedef struct Texture2D { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Texture2D; + + // Image, pixel data stored in CPU memory (RAM) + typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Image; + + // GlyphInfo, font characters glyphs info + typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data + } GlyphInfo; + + // TODO: Font type is very coupled to raylib, mostly required by GuiLoadStyle() + // It should be redesigned to be provided by user + typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data + } Font; +#endif + +// Style property +// NOTE: Used when exporting style as code for convenience +typedef struct GuiStyleProp { + unsigned short controlId; // Control identifier + unsigned short propertyId; // Property identifier + int propertyValue; // Property value +} GuiStyleProp; + +/* +// Controls text style -NOT USED- +// NOTE: Text style is defined by control +typedef struct GuiTextStyle { + unsigned int size; + int charSpacing; + int lineSpacing; + int alignmentH; + int alignmentV; + int padding; +} GuiTextStyle; +*/ + +// Gui control state +typedef enum { + STATE_NORMAL = 0, + STATE_FOCUSED, + STATE_PRESSED, + STATE_DISABLED +} GuiState; + +// Gui control text alignment +typedef enum { + TEXT_ALIGN_LEFT = 0, + TEXT_ALIGN_CENTER, + TEXT_ALIGN_RIGHT +} GuiTextAlignment; + +// Gui control text alignment vertical +// NOTE: Text vertical position inside the text bounds +typedef enum { + TEXT_ALIGN_TOP = 0, + TEXT_ALIGN_MIDDLE, + TEXT_ALIGN_BOTTOM +} GuiTextAlignmentVertical; + +// Gui control text wrap mode +// NOTE: Useful for multiline text +typedef enum { + TEXT_WRAP_NONE = 0, + TEXT_WRAP_CHAR, + TEXT_WRAP_WORD +} GuiTextWrapMode; + +// Gui controls +typedef enum { + // Default -> populates to all controls when set + DEFAULT = 0, + + // Basic controls + LABEL, // Used also for: LABELBUTTON + BUTTON, + TOGGLE, // Used also for: TOGGLEGROUP + SLIDER, // Used also for: SLIDERBAR, TOGGLESLIDER + PROGRESSBAR, + CHECKBOX, + COMBOBOX, + DROPDOWNBOX, + TEXTBOX, // Used also for: TEXTBOXMULTI + VALUEBOX, + SPINNER, // Uses: BUTTON, VALUEBOX + LISTVIEW, + COLORPICKER, + SCROLLBAR, + STATUSBAR +} GuiControl; + +// Gui base properties for every control +// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties) +typedef enum { + BORDER_COLOR_NORMAL = 0, // Control border color in STATE_NORMAL + BASE_COLOR_NORMAL, // Control base color in STATE_NORMAL + TEXT_COLOR_NORMAL, // Control text color in STATE_NORMAL + BORDER_COLOR_FOCUSED, // Control border color in STATE_FOCUSED + BASE_COLOR_FOCUSED, // Control base color in STATE_FOCUSED + TEXT_COLOR_FOCUSED, // Control text color in STATE_FOCUSED + BORDER_COLOR_PRESSED, // Control border color in STATE_PRESSED + BASE_COLOR_PRESSED, // Control base color in STATE_PRESSED + TEXT_COLOR_PRESSED, // Control text color in STATE_PRESSED + BORDER_COLOR_DISABLED, // Control border color in STATE_DISABLED + BASE_COLOR_DISABLED, // Control base color in STATE_DISABLED + TEXT_COLOR_DISABLED, // Control text color in STATE_DISABLED + BORDER_WIDTH, // Control border size, 0 for no border + //TEXT_SIZE, // Control text size (glyphs max height) -> GLOBAL for all controls + //TEXT_SPACING, // Control text spacing between glyphs -> GLOBAL for all controls + //TEXT_LINE_SPACING // Control text spacing between lines -> GLOBAL for all controls + TEXT_PADDING, // Control text padding, not considering border + TEXT_ALIGNMENT, // Control text horizontal alignment inside control text bound (after border and padding) + //TEXT_WRAP_MODE // Control text wrap-mode inside text bounds -> GLOBAL for all controls +} GuiControlProperty; + +// TODO: Which text styling properties should be global or per-control? +// At this moment TEXT_PADDING and TEXT_ALIGNMENT is configured and saved per control while +// TEXT_SIZE, TEXT_SPACING, TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE are global and +// should be configured by user as needed while defining the UI layout + +// Gui extended properties depend on control +// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default, max 8 properties) +//---------------------------------------------------------------------------------- +// DEFAULT extended properties +// NOTE: Those properties are common to all controls or global +// WARNING: We only have 8 slots for those properties by default!!! -> New global control: TEXT? +typedef enum { + TEXT_SIZE = 16, // Text size (glyphs max height) + TEXT_SPACING, // Text spacing between glyphs + LINE_COLOR, // Line control color + BACKGROUND_COLOR, // Background color + TEXT_LINE_SPACING, // Text spacing between lines + TEXT_ALIGNMENT_VERTICAL, // Text vertical alignment inside text bounds (after border and padding) + TEXT_WRAP_MODE // Text wrap-mode inside text bounds + //TEXT_DECORATION // Text decoration: 0-None, 1-Underline, 2-Line-through, 3-Overline + //TEXT_DECORATION_THICK // Text decoration line thickness +} GuiDefaultProperty; + +// Other possible text properties: +// TEXT_WEIGHT // Normal, Italic, Bold -> Requires specific font change +// TEXT_INDENT // Text indentation -> Now using TEXT_PADDING... + +// Label +//typedef enum { } GuiLabelProperty; + +// Button/Spinner +//typedef enum { } GuiButtonProperty; + +// Toggle/ToggleGroup +typedef enum { + GROUP_PADDING = 16, // ToggleGroup separation between toggles +} GuiToggleProperty; + +// Slider/SliderBar +typedef enum { + SLIDER_WIDTH = 16, // Slider size of internal bar + SLIDER_PADDING // Slider/SliderBar internal bar padding +} GuiSliderProperty; + +// ProgressBar +typedef enum { + PROGRESS_PADDING = 16, // ProgressBar internal padding +} GuiProgressBarProperty; + +// ScrollBar +typedef enum { + ARROWS_SIZE = 16, // ScrollBar arrows size + ARROWS_VISIBLE, // ScrollBar arrows visible + SCROLL_SLIDER_PADDING, // ScrollBar slider internal padding + SCROLL_SLIDER_SIZE, // ScrollBar slider size + SCROLL_PADDING, // ScrollBar scroll padding from arrows + SCROLL_SPEED, // ScrollBar scrolling speed +} GuiScrollBarProperty; + +// CheckBox +typedef enum { + 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_READONLY = 16, // TextBox in read-only mode: 0-text editable, 1-text no-editable +} 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, // ListView items height + LIST_ITEMS_SPACING, // ListView items separation + SCROLLBAR_WIDTH, // ListView scrollbar size (usually width) + SCROLLBAR_SIDE, // ListView scrollbar side (0-SCROLLBAR_LEFT_SIDE, 1-SCROLLBAR_RIGHT_SIDE) +} GuiListViewProperty; + +// ColorPicker +typedef enum { + COLOR_SELECTOR_SIZE = 16, + 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 +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module Functions Declaration +//---------------------------------------------------------------------------------- + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Global gui state control functions +RAYGUIAPI void GuiEnable(void); // Enable gui controls (global state) +RAYGUIAPI void GuiDisable(void); // Disable gui controls (global state) +RAYGUIAPI void GuiLock(void); // Lock gui controls (global state) +RAYGUIAPI void GuiUnlock(void); // Unlock gui controls (global state) +RAYGUIAPI bool GuiIsLocked(void); // Check if gui is locked (global state) +RAYGUIAPI void GuiSetAlpha(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f +RAYGUIAPI void GuiSetState(int state); // Set gui state (global state) +RAYGUIAPI int GuiGetState(void); // Get gui state (global state) + +// Font set/get functions +RAYGUIAPI void GuiSetFont(Font font); // Set gui custom font (global state) +RAYGUIAPI Font GuiGetFont(void); // Get gui custom font (global state) + +// Style set/get functions +RAYGUIAPI void GuiSetStyle(int control, int property, int value); // Set one style property +RAYGUIAPI int GuiGetStyle(int control, int property); // Get one style property + +// 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 + +// Tooltips management functions +RAYGUIAPI void GuiEnableTooltip(void); // Enable gui tooltips (global state) +RAYGUIAPI void GuiDisableTooltip(void); // Disable gui tooltips (global state) +RAYGUIAPI void GuiSetTooltip(const char *tooltip); // Set tooltip string + +// Icons functionality +RAYGUIAPI const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported) +#if !defined(RAYGUI_NO_ICONS) +RAYGUIAPI void GuiSetIconScale(int scale); // Set default icon drawing size +RAYGUIAPI unsigned int *GuiGetIcons(void); // Get raygui icons data pointer +RAYGUIAPI char **GuiLoadIcons(const char *fileName, bool loadIconsName); // Load raygui icons file (.rgi) into internal icons data +RAYGUIAPI void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color); // Draw icon using pixel size at specified position +#endif + +// Controls +//---------------------------------------------------------------------------------------------------------- +// Container/separator controls, useful for controls organization +RAYGUIAPI int GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed +RAYGUIAPI int GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name +RAYGUIAPI int GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text +RAYGUIAPI int GuiPanel(Rectangle bounds, const char *text); // Panel control, useful to group controls +RAYGUIAPI int GuiTabBar(Rectangle bounds, const char **text, int count, int *active); // Tab Bar control, returns TAB to be closed or -1 +RAYGUIAPI int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view); // Scroll Panel control + +// Basic controls set +RAYGUIAPI int GuiLabel(Rectangle bounds, const char *text); // Label control +RAYGUIAPI int GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked +RAYGUIAPI int GuiLabelButton(Rectangle bounds, const char *text); // Label button control, returns true when clicked +RAYGUIAPI int GuiToggle(Rectangle bounds, const char *text, bool *active); // Toggle Button control +RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int *active); // Toggle Group control +RAYGUIAPI int GuiToggleSlider(Rectangle bounds, const char *text, int *active); // Toggle Slider control +RAYGUIAPI int GuiCheckBox(Rectangle bounds, const char *text, bool *checked); // Check Box control, returns true when active +RAYGUIAPI int GuiComboBox(Rectangle bounds, const char *text, int *active); // Combo Box control + +RAYGUIAPI int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control +RAYGUIAPI int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control +RAYGUIAPI int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers +RAYGUIAPI int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text + +RAYGUIAPI int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider control +RAYGUIAPI int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control +RAYGUIAPI int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Progress Bar control +RAYGUIAPI int GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text +RAYGUIAPI int GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders +RAYGUIAPI int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell); // Grid control + +// Advance controls set +RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active); // List View control +RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus); // 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, int textMaxSize, bool *secretViewActive); // Text Input Box control, ask for text, supports secret +RAYGUIAPI int GuiColorPicker(Rectangle bounds, const char *text, Color *color); // Color Picker control (multiple color controls) +RAYGUIAPI int GuiColorPanel(Rectangle bounds, const char *text, Color *color); // Color Panel control +RAYGUIAPI int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha); // Color Bar Alpha control +RAYGUIAPI int GuiColorBarHue(Rectangle bounds, const char *text, float *value); // Color Bar Hue control +RAYGUIAPI int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Picker control that avoids conversion to RGB on each call (multiple color controls) +RAYGUIAPI int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Panel control that updates Hue-Saturation-Value color value, used by GuiColorPickerHSV() +//---------------------------------------------------------------------------------------------------------- + +#if !defined(RAYGUI_NO_ICONS) + +#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_CPU = 206, + ICON_ROM = 207, + ICON_STEP_OVER = 208, + ICON_STEP_INTO = 209, + ICON_STEP_OUT = 210, + ICON_RESTART = 211, + ICON_BREAKPOINT_ON = 212, + ICON_BREAKPOINT_OFF = 213, + ICON_BURGER_MENU = 214, + ICON_CASE_SENSITIVE = 215, + ICON_REG_EXP = 216, + ICON_FOLDER = 217, + ICON_FILE = 218, + ICON_SAND_TIMER = 219, + ICON_WARNING = 220, + ICON_HELP_BOX = 221, + ICON_INFO_BOX = 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) +} // Prevents name mangling of functions +#endif + +#endif // RAYGUI_H + +/*********************************************************************************** +* +* RAYGUI IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RAYGUI_IMPLEMENTATION) + +#include // Required for: FILE, fopen(), fclose(), fprintf(), feof(), fscanf(), vsprintf() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: malloc(), calloc(), free() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: strlen() [GuiTextBox(), GuiValueBox()], memset(), memcpy() +#include // Required for: va_list, va_start(), vfprintf(), va_end() [TextFormat()] +#include // Required for: roundf() [GuiColorPicker()] + +#ifdef __cplusplus + #define RAYGUI_CLITERAL(name) name +#else + #define RAYGUI_CLITERAL(name) (name) +#endif + +// Check if two rectangles are equal, used to validate a slider bounds as an id +#ifndef CHECK_BOUNDS_ID + #define CHECK_BOUNDS_ID(src, dst) ((src.x == dst.x) && (src.y == dst.y) && (src.width == dst.width) && (src.height == dst.height)) +#endif + +#if !defined(RAYGUI_NO_ICONS) && !defined(RAYGUI_CUSTOM_ICONS) + +// 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 +// 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) +// +// 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 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[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, 0x47c2483c, 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, 0x3bf27be2, 0x0bfe1bfa, 0x000007fe, // ICON_CUBE_FACE_BOTTOM + 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // ICON_CUBE_FACE_RIGHT + 0x7fe00000, 0x6fe85ff0, 0x781e77e4, 0x7be27be2, 0x7be27be2, 0x24127be2, 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 + 0x0aa00000, 0x1ff80aa0, 0x1068700e, 0x1008706e, 0x1008700e, 0x1008700e, 0x0aa01ff8, 0x00000aa0, // ICON_CPU + 0x07e00000, 0x04201db8, 0x04a01c38, 0x04a01d38, 0x04a01d38, 0x04a01d38, 0x04201d38, 0x000007e0, // ICON_ROM + 0x00000000, 0x03c00000, 0x3c382ff0, 0x3c04380c, 0x01800000, 0x03c003c0, 0x00000180, 0x00000000, // ICON_STEP_OVER + 0x01800000, 0x01800180, 0x01800180, 0x03c007e0, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_INTO + 0x01800000, 0x07e003c0, 0x01800180, 0x01800180, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_OUT + 0x00000000, 0x0ff003c0, 0x181c1c34, 0x303c301c, 0x30003000, 0x1c301800, 0x03c00ff0, 0x00000000, // ICON_RESTART + 0x00000000, 0x00000000, 0x07e003c0, 0x0ff00ff0, 0x0ff00ff0, 0x03c007e0, 0x00000000, 0x00000000, // ICON_BREAKPOINT_ON + 0x00000000, 0x00000000, 0x042003c0, 0x08100810, 0x08100810, 0x03c00420, 0x00000000, 0x00000000, // ICON_BREAKPOINT_OFF + 0x00000000, 0x00000000, 0x1ff81ff8, 0x1ff80000, 0x00001ff8, 0x1ff81ff8, 0x00000000, 0x00000000, // ICON_BURGER_MENU + 0x00000000, 0x00000000, 0x00880070, 0x0c880088, 0x1e8810f8, 0x3e881288, 0x00000000, 0x00000000, // ICON_CASE_SENSITIVE + 0x00000000, 0x02000000, 0x07000a80, 0x07001fc0, 0x02000a80, 0x00300030, 0x00000000, 0x00000000, // ICON_REG_EXP + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_FOLDER + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x00003ffc, // ICON_FILE + 0x1ff00000, 0x20082008, 0x17d02fe8, 0x05400ba0, 0x09200540, 0x23881010, 0x2fe827c8, 0x00001ff0, // ICON_SAND_TIMER + 0x01800000, 0x02400240, 0x05a00420, 0x09900990, 0x11881188, 0x21842004, 0x40024182, 0x00003ffc, // ICON_WARNING + 0x7ffe0000, 0x4ff24002, 0x4c324ff2, 0x4f824c02, 0x41824f82, 0x41824002, 0x40024182, 0x00007ffe, // ICON_HELP_BOX + 0x7ffe0000, 0x41824002, 0x40024182, 0x41824182, 0x41824182, 0x41824182, 0x40024182, 0x00007ffe, // ICON_INFO_BOX + 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 +}; + +// NOTE: A pointer to current icons array should be defined +static unsigned int *guiIconsPtr = guiIcons; + +#endif // !RAYGUI_NO_ICONS && !RAYGUI_CUSTOM_ICONS + +#ifndef RAYGUI_ICON_SIZE + #define RAYGUI_ICON_SIZE 0 +#endif + +// WARNING: Those values define the total size of the style data array, +// if changed, previous saved styles could become incompatible +#define RAYGUI_MAX_CONTROLS 16 // Maximum number of controls +#define RAYGUI_MAX_PROPS_BASE 16 // Maximum number of base properties +#define RAYGUI_MAX_PROPS_EXTENDED 8 // Maximum number of extended properties + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// Gui control property style color element +typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement; + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +static 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 controls transparency + +static unsigned int guiIconScale = 1; // Gui icon default scale (if icons enabled) + +static bool guiTooltip = false; // Tooltip enabled/disabled +static const char *guiTooltipPtr = NULL; // Tooltip string pointer (string provided by user) + +static bool guiControlExclusiveMode = false; // Gui control exclusive mode (no inputs processed except current control) +static Rectangle guiControlExclusiveRec = { 0 }; // Gui control exclusive bounds rectangle, used as an unique identifier + +static int textBoxCursorIndex = 0; // Cursor index, shared by all GuiTextBox*() +//static int blinkCursorFrameCounter = 0; // Frame counter for cursor blinking +static int autoCursorCooldownCounter = 0; // Cooldown frame counter for automatic cursor movement on key-down +static int autoCursorDelayCounter = 0; // Delay frame counter for automatic cursor movement + +//---------------------------------------------------------------------------------- +// Style data array for all gui style properties (allocated on data segment by default) +// +// NOTE 1: First set of BASE properties are generic to all controls but could be individually +// overwritten per control, first set of EXTENDED properties are generic to all controls and +// can not be overwritten individually but custom EXTENDED properties can be used by control +// +// NOTE 2: A new style set could be loaded over this array using GuiLoadStyle(), +// but default gui style could always be recovered with GuiLoadStyleDefault() +// +// guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +//---------------------------------------------------------------------------------- +static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)] = { 0 }; + +static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization + +//---------------------------------------------------------------------------------- +// Standalone Mode Functions Declaration +// +// NOTE: raygui depend on some raylib input and drawing functions +// To use raygui as standalone library, below functions must be defined by the user +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + +#define KEY_RIGHT 262 +#define KEY_LEFT 263 +#define KEY_DOWN 264 +#define KEY_UP 265 +#define KEY_BACKSPACE 259 +#define KEY_ENTER 257 + +#define MOUSE_LEFT_BUTTON 0 + +// Input required functions +//------------------------------------------------------------------------------- +static Vector2 GetMousePosition(void); +static float GetMouseWheelMove(void); +static bool IsMouseButtonDown(int button); +static bool IsMouseButtonPressed(int button); +static bool IsMouseButtonReleased(int button); + +static bool IsKeyDown(int key); +static bool IsKeyPressed(int key); +static int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +//------------------------------------------------------------------------------- + +// Drawing required functions +//------------------------------------------------------------------------------- +static void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +static void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +//------------------------------------------------------------------------------- + +// Text required functions +//------------------------------------------------------------------------------- +static Font GetFontDefault(void); // -- GuiLoadStyleDefault() +static Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle(), load font + +static Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +static void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) + +static char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +static void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data + +static const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs + +static int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +static void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list + +static unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +//------------------------------------------------------------------------------- + +// raylib functions already implemented in raygui +//------------------------------------------------------------------------------- +static Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value +static int ColorToInt(Color color); // Returns hexadecimal value for a Color +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +static const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed' +static const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +static int TextToInteger(const char *text); // Get integer value from text + +static int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded text +static const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode codepoint into UTF-8 text (char array size returned as parameter) + +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw rectangle vertical gradient +//------------------------------------------------------------------------------- + +#endif // RAYGUI_STANDALONE + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize); // Load style from memory (binary only) + +static int GetTextWidth(const char *text); // Gui get text width using gui font and style +static Rectangle GetTextBounds(int control, Rectangle bounds); // Get text bounds considering control bounds +static const char *GetTextIcon(const char *text, int *iconId); // Get text icon if provided and move text cursor + +static void GuiDrawText(const char *text, Rectangle textBounds, 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, char delimiter, 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() +static void GuiTooltip(Rectangle controlRec); // Draw tooltip using control rec position + +static Color GuiFade(Color color, float alpha); // Fade color by an alpha factor + +//---------------------------------------------------------------------------------- +// Gui Setup Functions Definition +//---------------------------------------------------------------------------------- +// Enable gui global state +// 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 +// 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; } + +// Unlock gui global state +void GuiUnlock(void) { guiLocked = false; } + +// Check if gui is locked (global state) +bool GuiIsLocked(void) { return guiLocked; } + +// Set gui controls alpha global state +void GuiSetAlpha(float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + guiAlpha = alpha; +} + +// Set gui state (global state) +void GuiSetState(int state) { guiState = (GuiState)state; } + +// Get gui state (global state) +int GuiGetState(void) { return guiState; } + +// Set custom gui font +// NOTE: Font loading/unloading is external to raygui +void GuiSetFont(Font font) +{ + if (font.texture.id > 0) + { + // NOTE: If we try to setup a font but default style has not been + // lazily loaded before, it will be overwritten, so we need to force + // default style loading first + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + guiFont = font; + } +} + +// Get custom gui font +Font GuiGetFont(void) +{ + return guiFont; +} + +// Set control style property value +void GuiSetStyle(int control, int property, int value) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + + // Default properties are propagated to all controls + if ((control == 0) && (property < RAYGUI_MAX_PROPS_BASE)) + { + for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) guiStyle[i*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + } +} + +// Get control style property value +int GuiGetStyle(int control, int property) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + return guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property]; +} + +//---------------------------------------------------------------------------------- +// Gui Controls Functions Definition +//---------------------------------------------------------------------------------- + +// Window Box control +int GuiWindowBox(Rectangle bounds, const char *title) +{ + // Window title bar height (including borders) + // NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox() + #if !defined(RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT) + #define RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT 24 + #endif + + int result = 0; + //GuiState state = guiState; + + 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 + 1 }; + Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20, + statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 }; + + // Update control + //-------------------------------------------------------------------- + // NOTE: Logic is directly managed by button + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiStatusBar(statusBar, title); // Draw window header as status bar + GuiPanel(windowPanel, 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, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + result = GuiButton(closeButtonRec, "x"); +#else + result = GuiButton(closeButtonRec, GuiIconText(ICON_CROSS_SMALL, NULL)); +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + //-------------------------------------------------------------------- + + return result; // Window close button clicked: result = 1 +} + +// Group Box control with text name +int GuiGroupBox(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_GROUPBOX_LINE_THICK) + #define RAYGUI_GROUPBOX_LINE_THICK 1 + #endif + + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, RAYGUI_GROUPBOX_LINE_THICK }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + + GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y - GuiGetStyle(DEFAULT, TEXT_SIZE)/2, bounds.width, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) }, text); + //-------------------------------------------------------------------- + + return result; +} + +// Line control +int GuiLine(Rectangle bounds, const char *text) +{ + #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 + + int result = 0; + GuiState state = guiState; + + Color color = GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)); + + // Draw control + //-------------------------------------------------------------------- + if (text == NULL) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, bounds.width, 1 }, 0, BLANK, color); + else + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text) + 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 + 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); + } + //-------------------------------------------------------------------- + + return result; +} + +// Panel control +int GuiPanel(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_PANEL_BORDER_WIDTH) + #define RAYGUI_PANEL_BORDER_WIDTH 1 + #endif + + int result = 0; + 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 + //-------------------------------------------------------------------- + if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar + + GuiDrawRectangle(bounds, RAYGUI_PANEL_BORDER_WIDTH, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), + GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR))); + //-------------------------------------------------------------------- + + return result; +} + +// Tab Bar control +// NOTE: Using GuiToggle() for the TABS +int GuiTabBar(Rectangle bounds, const char **text, int count, int *active) +{ + #define RAYGUI_TABBAR_ITEM_WIDTH 160 + + int result = -1; + //GuiState state = guiState; + + Rectangle tabBounds = { bounds.x, bounds.y, RAYGUI_TABBAR_ITEM_WIDTH, bounds.height }; + + if (*active < 0) *active = 0; + else if (*active > count - 1) *active = count - 1; + + int offsetX = 0; // Required in case tabs go out of screen + offsetX = (*active + 2)*RAYGUI_TABBAR_ITEM_WIDTH - GetScreenWidth(); + if (offsetX < 0) offsetX = 0; + + bool toggle = false; // Required for individual toggles + + // Draw control + //-------------------------------------------------------------------- + for (int i = 0; i < count; i++) + { + tabBounds.x = bounds.x + (RAYGUI_TABBAR_ITEM_WIDTH + 4)*i - offsetX; + + if (tabBounds.x < GetScreenWidth()) + { + // Draw tabs as toggle controls + int textAlignment = GuiGetStyle(TOGGLE, TEXT_ALIGNMENT); + int textPadding = GuiGetStyle(TOGGLE, TEXT_PADDING); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(TOGGLE, TEXT_PADDING, 8); + + if (i == (*active)) + { + toggle = true; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + } + else + { + toggle = false; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + if (toggle) *active = i; + } + + // Close tab with middle mouse button pressed + if (CheckCollisionPointRec(GetMousePosition(), tabBounds) && IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) result = i; + + GuiSetStyle(TOGGLE, TEXT_PADDING, textPadding); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, textAlignment); + + // Draw tab close button + // NOTE: Only draw close button for current tab: if (CheckCollisionPointRec(mousePosition, tabBounds)) + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, "x")) result = i; +#else + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, GuiIconText(ICON_CROSS_SMALL, NULL))) result = i; +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + } + } + + // Draw tab-bar bottom line + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, 1 }, 0, BLANK, GetColor(GuiGetStyle(TOGGLE, BORDER_COLOR_NORMAL))); + //-------------------------------------------------------------------- + + return result; // Return as result the current TAB closing requested +} + +// Scroll Panel control +int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view) +{ + #define RAYGUI_MIN_SCROLLBAR_WIDTH 40 + #define RAYGUI_MIN_SCROLLBAR_HEIGHT 40 + #define RAYGUI_MIN_MOUSE_WHEEL_SPEED 20 + + int result = 0; + GuiState state = guiState; + + Rectangle temp = { 0 }; + if (view == NULL) view = &temp; + + 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; + + // Recheck to account for the other scrollbar being visible + if (!hasHorizontalScrollBar) hasHorizontalScrollBar = (hasVerticalScrollBar && (content.width > (bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + if (!hasVerticalScrollBar) hasVerticalScrollBar = (hasHorizontalScrollBar && (content.height > (bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + + 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) + }; + + // Make sure scroll bars have a minimum width/height + if (horizontalScrollBar.width < RAYGUI_MIN_SCROLLBAR_WIDTH) horizontalScrollBar.width = RAYGUI_MIN_SCROLLBAR_WIDTH; + if (verticalScrollBar.height < RAYGUI_MIN_SCROLLBAR_HEIGHT) verticalScrollBar.height = RAYGUI_MIN_SCROLLBAR_HEIGHT; + + // Calculate view area (area without the scrollbars) + *view = (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? + RAYGUI_CLITERAL(Rectangle){ bounds.x + verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth } : + RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth }; + + // Clip view area to the actual content size + if (view->width > content.width) view->width = content.width; + if (view->height > content.height) view->height = content.height; + + 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.0f : -1.0f; + float verticalMax = hasVerticalScrollBar? content.height - bounds.height + (float)horizontalScrollBarWidth + (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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); + if (IsKeyDown(KEY_LEFT)) scrollPos.x += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } + + if (hasVerticalScrollBar) + { + if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } +#endif + float wheelMove = GetMouseWheelMove(); + + // Set scrolling speed with mouse wheel based on ratio between bounds and content + Vector2 mouseWheelSpeed = { content.width / bounds.width, content.height / bounds.height }; + if (mouseWheelSpeed.x < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.x = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + if (mouseWheelSpeed.y < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.y = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + + // Horizontal and vertical scrolling with mouse wheel + if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_LEFT_SHIFT))) scrollPos.x += wheelMove*mouseWheelSpeed.x; + else scrollPos.y += wheelMove*mouseWheelSpeed.y; // Vertical scroll + } + } + + // Normalize scroll values + if (scrollPos.x > -horizontalMin) scrollPos.x = -horizontalMin; + if (scrollPos.x < -horizontalMax) scrollPos.x = -horizontalMax; + if (scrollPos.y > -verticalMin) scrollPos.y = -verticalMin; + if (scrollPos.y < -verticalMax) scrollPos.y = -verticalMax; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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 + const int slider = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + + // Draw horizontal scrollbar if visible + if (hasHorizontalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content width and the widget width + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)/(int)content.width)*((int)bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth))); + scrollPos.x = (float)-GuiScrollBar(horizontalScrollBar, (int)-scrollPos.x, (int)horizontalMin, (int)horizontalMax); + } + else scrollPos.x = 0.0f; + + // Draw vertical scrollbar if visible + if (hasVerticalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content height and the widget height + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)/(int)content.height)*((int)bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth))); + scrollPos.y = (float)-GuiScrollBar(verticalScrollBar, (int)-scrollPos.y, (int)verticalMin, (int)verticalMax); + } + 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 }; + GuiDrawRectangle(corner, 0, BLANK, GetColor(GuiGetStyle(LISTVIEW, TEXT + (state*3)))); + } + + // Draw scrollbar lines depending on current state + GuiDrawRectangle(bounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + (state*3))), BLANK); + + // Set scrollbar slider size back to the way it was before + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider); + //-------------------------------------------------------------------- + + if (scroll != NULL) *scroll = scrollPos; + + return result; +} + +// Label control +int GuiLabel(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + //... + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Button control, returns true when clicked +int GuiButton(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), GetColor(GuiGetStyle(BUTTON, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), GetColor(GuiGetStyle(BUTTON, TEXT + (state*3)))); + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //------------------------------------------------------------------ + + return result; // Button pressed: result = 1 +} + +// Label button control +int GuiLabelButton(Rectangle bounds, const char *text) +{ + GuiState state = guiState; + bool pressed = false; + + // NOTE: We force bounds.width to be all text + float textWidth = (float)GetTextWidth(text); + if ((bounds.width - 2*GuiGetStyle(LABEL, BORDER_WIDTH) - 2*GuiGetStyle(LABEL, TEXT_PADDING)) < textWidth) bounds.width = textWidth + 2*GuiGetStyle(LABEL, BORDER_WIDTH) + 2*GuiGetStyle(LABEL, TEXT_PADDING) + 2; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return pressed; +} + +// Toggle Button control +int GuiToggle(Rectangle bounds, const char *text, bool *active) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (active == NULL) active = &temp; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check toggle button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_NORMAL; + *active = !(*active); + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_NORMAL) + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, ((*active)? BORDER_COLOR_PRESSED : (BORDER + state*3)))), GetColor(GuiGetStyle(TOGGLE, ((*active)? BASE_COLOR_PRESSED : (BASE + state*3))))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, ((*active)? TEXT_COLOR_PRESSED : (TEXT + state*3))))); + } + else + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + state*3)), GetColor(GuiGetStyle(TOGGLE, BASE + state*3))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, TEXT + state*3))); + } + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; +} + +// Toggle Group control +int GuiToggleGroup(Rectangle bounds, const char *text, int *active) +{ + #if !defined(RAYGUI_TOGGLEGROUP_MAX_ITEMS) + #define RAYGUI_TOGGLEGROUP_MAX_ITEMS 32 + #endif + + int result = 0; + float initBoundsX = bounds.x; + + int temp = 0; + if (active == NULL) active = &temp; + + bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int rows[RAYGUI_TOGGLEGROUP_MAX_ITEMS] = { 0 }; + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, rows); + + int prevRow = rows[0]; + + for (int i = 0; i < itemCount; i++) + { + if (prevRow != rows[i]) + { + bounds.x = initBoundsX; + bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING)); + prevRow = rows[i]; + } + + if (i == (*active)) + { + toggle = true; + GuiToggle(bounds, items[i], &toggle); + } + else + { + toggle = false; + GuiToggle(bounds, items[i], &toggle); + if (toggle) *active = i; + } + + bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING)); + } + + return result; +} + +// Toggle Slider control extended +int GuiToggleSlider(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + //bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle slider = { + 0, // Calculated later depending on the active toggle + bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + (bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - (itemCount + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING))/itemCount, + bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + (*active)++; + result = 1; + } + else state = STATE_FOCUSED; + } + + if ((*active) && (state != STATE_FOCUSED)) state = STATE_PRESSED; + } + + if (*active >= itemCount) *active = 0; + slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH) + (*active + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING) + (*active)*slider.width; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + (state*3))), + GetColor(GuiGetStyle(TOGGLE, BASE_COLOR_NORMAL))); + + // Draw internal slider + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + + // Draw text in slider + if (text != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = slider.x + slider.width/2 - textBounds.width/2; + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(items[*active], textBounds, GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, TEXT + (state*3))), guiAlpha)); + } + //-------------------------------------------------------------------- + + return result; +} + +// Check Box control, returns 1 when state changed +int GuiCheckBox(Rectangle bounds, const char *text, bool *checked) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (checked == NULL) checked = &temp; + + Rectangle textBounds = { 0 }; + + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + Rectangle totalBounds = { + (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT)? textBounds.x : bounds.x, + bounds.y, + bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING), + bounds.height, + }; + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, totalBounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + *checked = !(*checked); + result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), GetColor(GuiGetStyle(CHECKBOX, BORDER + (state*3))), BLANK); + + if (*checked) + { + Rectangle check = { bounds.x + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.y + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.width - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)), + bounds.height - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)) }; + GuiDrawRectangle(check, 0, BLANK, GetColor(GuiGetStyle(CHECKBOX, TEXT + state*3))); + } + + GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Combo Box control +int GuiComboBox(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING)); + + 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) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + if (*active < 0) *active = 0; + else if (*active > (itemCount - 1)) *active = itemCount - 1; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds) || + CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + *active += 1; + if (*active >= itemCount) *active = 0; // Cyclic combobox + } + + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + // Draw combo box main + GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), GetColor(GuiGetStyle(COMBOBOX, BORDER + (state*3))), GetColor(GuiGetStyle(COMBOBOX, BASE + (state*3)))); + GuiDrawText(items[*active], GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(COMBOBOX, TEXT + (state*3)))); + + // Draw selector using a custom button + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + GuiButton(selector, TextFormat("%i/%i", *active + 1, itemCount)); + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign); + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + //-------------------------------------------------------------------- + + return result; +} + +// Dropdown Box control +// NOTE: Returns mouse click +int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode) +{ + int result = 0; + GuiState state = guiState; + + int itemSelected = *active; + int itemFocused = -1; + + // Get substrings items from text (items pointers, lengths and count) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle boundsOpen = bounds; + boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + Rectangle itemBounds = bounds; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // Check if mouse has been pressed or released outside limits + if (!CheckCollisionPointRec(mousePoint, boundsOpen)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + + // Check if already selected item has been pressed again + if (CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + + // Check focused and selected item + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = i; + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + itemSelected = i; + result = 1; // Item selected + } + break; + } + } + + itemBounds = bounds; + } + else + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + result = 1; + state = STATE_PRESSED; + } + else state = STATE_FOCUSED; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (editMode) GuiPanel(boundsOpen, NULL); + + GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER + state*3)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE + state*3))); + GuiDrawText(items[itemSelected], GetTextBounds(DROPDOWNBOX, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + state*3))); + + if (editMode) + { + // Draw visible items + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (i == itemSelected) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED))); + } + else if (i == itemFocused) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED))); + } + else GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL))); + } + } + + // Draw arrows (using icon if available) +#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 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#else + GuiDrawText("#120#", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 6, 10, 10 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); // ICON_ARROW_DOWN_FILL +#endif + //-------------------------------------------------------------------- + + *active = itemSelected; + + // TODO: Use result to return more internal states: mouse-press out-of-bounds, mouse-press over selected-item... + return result; // Mouse click: result = 1 +} + +// Text Box control +// NOTE: Returns true on ENTER pressed (useful for data validation) +int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode) +{ + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN 40 // Frames to wait for autocursor movement + #endif + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY 1 // Frames delay for autocursor movement + #endif + + int result = 0; + GuiState state = guiState; + + bool multiline = false; // TODO: Consider multiline text input + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); + + Rectangle textBounds = GetTextBounds(TEXTBOX, bounds); + int textWidth = GetTextWidth(text) - GetTextWidth(text + textBoxCursorIndex); + int textIndexOffset = 0; // Text index offset to start drawing in the box + + // Cursor rectangle + // NOTE: Position X value should be updated + Rectangle cursor = { + textBounds.x + textWidth + GuiGetStyle(DEFAULT, TEXT_SPACING), + textBounds.y + textBounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE), + 2, + (float)GuiGetStyle(DEFAULT, TEXT_SIZE)*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); + + // Mouse cursor rectangle + // NOTE: Initialized outside of screen + Rectangle mouseCursor = cursor; + mouseCursor.x = -1; + mouseCursor.width = 1; + + // Auto-cursor movement logic + // NOTE: Cursor moves automatically when key down after some time + if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_UP) || IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_BACKSPACE) || IsKeyDown(KEY_DELETE)) autoCursorCooldownCounter++; + else + { + autoCursorCooldownCounter = 0; // GLOBAL: Cursor cooldown counter + autoCursorDelayCounter = 0; // GLOBAL: Cursor delay counter + } + + // Blink-cursor frame counter + //if (!autoCursorMode) blinkCursorFrameCounter++; + //else blinkCursorFrameCounter = 0; + + // Update control + //-------------------------------------------------------------------- + // WARNING: Text editing is only supported under certain conditions: + if ((state != STATE_DISABLED) && // Control not disabled + !GuiGetStyle(TEXTBOX, TEXT_READONLY) && // TextBox not on read-only mode + !guiLocked && // Gui not locked + !guiControlExclusiveMode && // No gui slider on dragging + (wrapMode == TEXT_WRAP_NONE)) // No wrap mode + { + Vector2 mousePosition = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // If text does not fit in the textbox and current cursor position is out of bounds, + // we add an index offset to text for drawing only what requires depending on cursor + while (textWidth >= textBounds.width) + { + int nextCodepointSize = 0; + GetCodepointNext(text + textIndexOffset, &nextCodepointSize); + + textIndexOffset += nextCodepointSize; + + textWidth = GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex); + } + + int textLength = (int)strlen(text); // Get current text length + int codepoint = GetCharPressed(); // Get Unicode codepoint + if (multiline && IsKeyPressed(KEY_ENTER)) codepoint = (int)'\n'; + + if (textBoxCursorIndex > textLength) textBoxCursorIndex = textLength; + + // Encode codepoint as UTF-8 + int codepointSize = 0; + const char *charEncoded = CodepointToUTF8(codepoint, &codepointSize); + + // Add codepoint to text, at current cursor position + // NOTE: Make sure we do not overflow buffer size + if (((multiline && (codepoint == (int)'\n')) || (codepoint >= 32)) && ((textLength + codepointSize) < textSize)) + { + // Move forward data from cursor position + for (int i = (textLength + codepointSize); i > textBoxCursorIndex; i--) text[i] = text[i - codepointSize]; + + // Add new codepoint in current cursor position + for (int i = 0; i < codepointSize; i++) text[textBoxCursorIndex + i] = charEncoded[i]; + + textBoxCursorIndex += codepointSize; + textLength += codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + + // Move cursor to start + if ((textLength > 0) && IsKeyPressed(KEY_HOME)) textBoxCursorIndex = 0; + + // Move cursor to end + if ((textLength > textBoxCursorIndex) && IsKeyPressed(KEY_END)) textBoxCursorIndex = textLength; + + // Delete codepoint from text, after current cursor position + if ((textLength > textBoxCursorIndex) && (IsKeyPressed(KEY_DELETE) || (IsKeyDown(KEY_DELETE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_DELETE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + // Move backward text from cursor position + for (int i = textBoxCursorIndex; i < textLength; i++) text[i] = text[i + nextCodepointSize]; + + textLength -= codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Delete codepoint from text, before current cursor position + if ((textLength > 0) && (IsKeyPressed(KEY_BACKSPACE) || (IsKeyDown(KEY_BACKSPACE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_BACKSPACE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + // Move backward text from cursor position + for (int i = (textBoxCursorIndex - prevCodepointSize); i < textLength; i++) text[i] = text[i + prevCodepointSize]; + + // Prevent cursor index from decrementing past 0 + if (textBoxCursorIndex > 0) + { + textBoxCursorIndex -= codepointSize; + textLength -= codepointSize; + } + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Move cursor position with keys + if (IsKeyPressed(KEY_LEFT) || (IsKeyDown(KEY_LEFT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_LEFT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + if (textBoxCursorIndex >= prevCodepointSize) textBoxCursorIndex -= prevCodepointSize; + } + } + else if (IsKeyPressed(KEY_RIGHT) || (IsKeyDown(KEY_RIGHT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_RIGHT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + if ((textBoxCursorIndex + nextCodepointSize) <= textLength) textBoxCursorIndex += nextCodepointSize; + } + } + + // Move cursor position with mouse + if (CheckCollisionPointRec(mousePosition, textBounds)) // Mouse hover text + { + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/(float)guiFont.baseSize; + int codepointIndex = 0; + float glyphWidth = 0.0f; + float widthToMouseX = 0; + int mouseCursorIndex = 0; + + for (int i = textIndexOffset; i < textLength; i++) + { + codepoint = GetCodepointNext(&text[i], &codepointSize); + codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + if (mousePosition.x <= (textBounds.x + (widthToMouseX + glyphWidth/2))) + { + mouseCursor.x = textBounds.x + widthToMouseX; + mouseCursorIndex = i; + break; + } + + widthToMouseX += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + + // Check if mouse cursor is at the last position + int textEndWidth = GetTextWidth(text + textIndexOffset); + if (GetMousePosition().x >= (textBounds.x + textEndWidth - glyphWidth/2)) + { + mouseCursor.x = textBounds.x + textEndWidth; + mouseCursorIndex = (int)strlen(text); + } + + // Place cursor at required index on mouse click + if ((mouseCursor.x >= 0) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + cursor.x = mouseCursor.x; + textBoxCursorIndex = mouseCursorIndex; + } + } + else mouseCursor.x = -1; + + // Recalculate cursor position.y depending on textBoxCursorIndex + cursor.x = bounds.x + GuiGetStyle(TEXTBOX, TEXT_PADDING) + GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex) + GuiGetStyle(DEFAULT, TEXT_SPACING); + //if (multiline) cursor.y = GetTextLines() + + // Finish text editing on ENTER or mouse click outside bounds + if ((!multiline && IsKeyPressed(KEY_ENTER)) || + (!CheckCollisionPointRec(mousePosition, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) + { + textBoxCursorIndex = 0; // GLOBAL: Reset the shared cursor index + result = 1; + } + } + else + { + if (CheckCollisionPointRec(mousePosition, bounds)) + { + state = STATE_FOCUSED; + + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + textBoxCursorIndex = (int)strlen(text); // GLOBAL: Place cursor index to the end of current text + result = 1; + } + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_PRESSED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))); + } + else if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))); + } + else GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), BLANK); + + // Draw text considering index offset if required + // NOTE: Text index offset depends on cursor position + GuiDrawText(text + textIndexOffset, textBounds, GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode && !GuiGetStyle(TEXTBOX, TEXT_READONLY)) + { + //if (autoCursorMode || ((blinkCursorFrameCounter/40)%2 == 0)) + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + + // Draw mouse position cursor (if required) + if (mouseCursor.x >= 0) GuiDrawRectangle(mouseCursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + } + else if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; // Mouse button pressed: result = 1 +} + +/* +// Text Box control with multiple lines and word-wrap +// NOTE: This text-box is readonly, no editing supported by default +bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode) +{ + bool pressed = false; + + GuiSetStyle(TEXTBOX, TEXT_READONLY, 1); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_WORD); // WARNING: If wrap mode enabled, text editing is not supported + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_TOP); + + // TODO: Implement methods to calculate cursor position properly + pressed = GuiTextBox(bounds, text, textSize, editMode); + + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_NONE); + GuiSetStyle(TEXTBOX, TEXT_READONLY, 0); + + return pressed; +} +*/ + +// Spinner control, returns selected value +int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + int result = 1; + GuiState state = guiState; + + int tempValue = *value; + + 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 }; + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check spinner state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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; + if (tempValue > maxValue) tempValue = maxValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + result = GuiValueBox(spinner, NULL, &tempValue, minValue, maxValue, editMode); + + // Draw value selector custom buttons + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH)); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, 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) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + *value = tempValue; + return result; +} + +// Value Box control, updates input text with numbers +// NOTE: Requires static variables: frameCounter +int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + #if !defined(RAYGUI_VALUEBOX_MAX_CHARS) + #define RAYGUI_VALUEBOX_MAX_CHARS 32 + #endif + + int result = 0; + GuiState state = guiState; + + char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + sprintf(textValue, "%i", *value); + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + bool valueHasChanged = false; + + if (editMode) + { + state = STATE_PRESSED; + + int keyCount = (int)strlen(textValue); + + // Only allow keys in range [48..57] + if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS) + { + if (GetTextWidth(textValue) < bounds.width) + { + int key = GetCharPressed(); + if ((key >= 48) && (key <= 57)) + { + textValue[keyCount] = (char)key; + keyCount++; + valueHasChanged = true; + } + } + } + + // Delete text + if (keyCount > 0) + { + if (IsKeyPressed(KEY_BACKSPACE)) + { + keyCount--; + textValue[keyCount] = '\0'; + valueHasChanged = true; + } + } + + 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))) + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + result = 1; + } + } + else + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + Color baseColor = BLANK; + if (state == STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED)); + else if (state == STATE_DISABLED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED)); + + GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), baseColor); + GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode) + { + // NOTE: ValueBox internal text is always centered + Rectangle cursor = { bounds.x + GetTextWidth(textValue)/2 + bounds.width/2 + 1, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) }; + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED))); + } + + // Draw text label if provided + GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Slider control with pro parameters +// NOTE: Other GuiSlider*() controls use this one +int GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue, int sliderWidth) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + float oldValue = *value; + + Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + if (!CheckCollisionPointRec(mousePoint, slider)) + { + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else state = STATE_FOCUSED; + } + + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + } + + // Control value change check + if (oldValue == *value) result = 0; + else result = 1; + + // Slider bar limits check + int sliderValue = (int)(((*value - minValue)/(maxValue - minValue))*(bounds.width - sliderWidth - GuiGetStyle(SLIDER, BORDER_WIDTH))); + if (sliderWidth > 0) // Slider + { + slider.x += sliderValue; + slider.width = (float)sliderWidth; + if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH); + else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH); + } + else if (sliderWidth == 0) // SliderBar + { + slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH); + slider.width = (float)sliderValue; + if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), GetColor(GuiGetStyle(SLIDER, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + + // Draw slider internal bar (depends on state) + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_PRESSED))); + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Slider control extended, returns selected value and has text +int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH)); +} + +// Slider Bar control extended, returns selected value +int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, 0); +} + +// Progress Bar control extended, shows current progress value +int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + + // Progress bar + Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), + bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0, + bounds.height - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) - 2*GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if (*value > maxValue) *value = maxValue; + + // WARNING: Working with floats could lead to rounding issues + if ((state != STATE_DISABLED)) progress.width = (float)(*value/(maxValue - minValue))*bounds.width - ((*value >= maxValue)? (float)(2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)) : 0.0f); + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(PROGRESSBAR, BORDER + (state*3))), BLANK); + } + else + { + if (*value > minValue) + { + // Draw progress bar with colored border, more visual + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + } + else GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + + if (*value >= maxValue) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + progress.width + 1, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + else + { + // Draw borders not yet reached by value + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y + bounds.height - 1, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + } + + // Draw slider internal progress bar (depends on state) + GuiDrawRectangle(progress, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED))); + } + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Status Bar control +int GuiStatusBar(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(STATUSBAR, BORDER + (state*3))), GetColor(GuiGetStyle(STATUSBAR, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), GetColor(GuiGetStyle(STATUSBAR, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Dummy rectangle control, intended for placeholding +int GuiDummyRec(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + GuiDrawText(text, GetTextBounds(DEFAULT, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(BUTTON, (state != STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED))); + //------------------------------------------------------------------ + + return result; +} + +// List View control +int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active) +{ + int result = 0; + int itemCount = 0; + const char **items = NULL; + + if (text != NULL) items = GuiTextSplit(text, ';', &itemCount, NULL); + + result = GuiListViewEx(bounds, items, itemCount, scrollIndex, active, NULL); + + return result; +} + +// List View control with extended parameters +int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus) +{ + int result = 0; + GuiState state = guiState; + + int itemFocused = (focus == NULL)? -1 : *focus; + int itemSelected = (active == NULL)? -1 : *active; + + // Check if we need a scroll bar + bool useScrollBar = false; + 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_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_SPACING)); + if (visibleItems > count) visibleItems = count; + + int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex; + if ((startIndex < 0) || (startIndex > (count - visibleItems))) startIndex = 0; + int endIndex = startIndex + visibleItems; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check mouse inside list view + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Check focused and selected item + for (int i = 0; i < visibleItems; i++) + { + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = startIndex + i; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + if (itemSelected == (startIndex + i)) itemSelected = -1; + else itemSelected = startIndex + i; + } + break; + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + int wheelMove = (int)GetMouseWheelMove(); + startIndex -= wheelMove; + + if (startIndex < 0) startIndex = 0; + else if (startIndex > (count - visibleItems)) startIndex = count - visibleItems; + + endIndex = startIndex + visibleItems; + if (endIndex > count) endIndex = count; + } + } + else itemFocused = -1; + + // Reset item rectangle y to [0] + itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background + + // Draw visible items + for (int i = 0; ((i < visibleItems) && (text != NULL)); i++) + { + if (state == STATE_DISABLED) + { + if ((startIndex + i) == itemSelected) GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED))); + + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED))); + } + else + { + if (((startIndex + i) == itemSelected) && (active != NULL)) + { + // Draw item selected + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED))); + } + else if (((startIndex + i) == itemFocused)) // && (focus != NULL)) // NOTE: We want items focused, despite not returned! + { + // Draw item focused + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED))); + } + else + { + // Draw item normal + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL))); + } + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + Rectangle scrollBarBounds = { + bounds.x + bounds.width - GuiGetStyle(LISTVIEW, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.y + GuiGetStyle(LISTVIEW, BORDER_WIDTH), (float)GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) + }; + + // Calculate percentage of visible items and apply same percentage to scrollbar + float percentVisible = (float)(endIndex - startIndex)/count; + float sliderSize = bounds.height*percentVisible; + + int prevSliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); // Save default slider size + int prevScrollSpeed = GuiGetStyle(SCROLLBAR, SCROLL_SPEED); // Save default scroll speed + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)sliderSize); // Change slider size + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems); // Change scroll speed + + startIndex = GuiScrollBar(scrollBarBounds, startIndex, 0, count - visibleItems); + + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed); // Reset scroll speed to default + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize); // Reset slider size to default + } + //-------------------------------------------------------------------- + + if (active != NULL) *active = itemSelected; + if (focus != NULL) *focus = itemFocused; + if (scrollIndex != NULL) *scrollIndex = startIndex; + + return result; +} + +// Color Panel control - Color (RGBA) variant. +int GuiColorPanel(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Vector3 vcolor = { (float)color->r/255.0f, (float)color->g/255.0f, (float)color->b/255.0f }; + Vector3 hsv = ConvertRGBtoHSV(vcolor); + Vector3 prevHsv = hsv; // workaround to see if GuiColorPanelHSV modifies the hsv. + + GuiColorPanelHSV(bounds, text, &hsv); + + // Check if the hsv was changed, only then change the color. + // This is necessary, because the Color->HSV->Color conversion has precision errors. + // Thus the assignment from HSV to Color should only be made, if the HSV has a new user-entered value. + // Otherwise GuiColorPanel would often modify it's color without user input. + // TODO: GuiColorPanelHSV could return 1 if the slider was dragged, to simplify this check. + if (hsv.x != prevHsv.x || hsv.y != prevHsv.y || hsv.z != prevHsv.z) + { + Vector3 rgb = ConvertHSVtoRGB(hsv); + + // NOTE: Vector3ToColor() only available on raylib 1.8.1 + *color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x), + (unsigned char)(255.0f*rgb.y), + (unsigned char)(255.0f*rgb.z), + color->a }; + } + return result; +} + +// Color Bar Alpha control +// NOTE: Returns alpha value normalized [0..1] +int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +{ + #if !defined(RAYGUI_COLORBARALPHA_CHECKED_SIZE) + #define RAYGUI_COLORBARALPHA_CHECKED_SIZE 10 + #endif + + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + *alpha = (mousePoint.x - bounds.x)/bounds.width; + if (*alpha <= 0.0f) *alpha = 0.0f; + if (*alpha >= 1.0f) *alpha = 1.0f; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *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 = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + + // Draw alpha bar: checked background + if (state != STATE_DISABLED) + { + 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*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(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.4f) : Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.4f)); + } + } + + DrawRectangleGradientEx(bounds, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha)); + } + else DrawRectangleGradientEx(bounds, Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw alpha bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Bar Hue control +// Returns hue value normalized [0..1] +// NOTE: Other similar bars (for reference): +// Color GuiColorBarSat() [WHITE->color] +// Color GuiColorBarValue() [BLACK->color], HSV/HSL +// float GuiColorBarLuminance() [BLACK->WHITE] +int GuiColorBarHue(Rectangle bounds, const char *text, float *hue) +{ + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + 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 + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *hue = (mousePoint.y - bounds.y)*360/bounds.height; + if (*hue <= 0.0f) *hue = 0.0f; + if (*hue >= 359.0f) *hue = 359.0f; + + } + else state = STATE_FOCUSED; + + /*if (IsKeyDown(KEY_UP)) + { + hue -= 2.0f; + if (hue <= 0.0f) hue = 0.0f; + } + else if (IsKeyDown(KEY_DOWN)) + { + hue += 2.0f; + if (hue >= 360.0f) hue = 360.0f; + }*/ + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state != STATE_DISABLED) + { + // Draw hue bar:color bars + // TODO: Use directly DrawRectangleGradientEx(bounds, color1, color2, color2, color1); + 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)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw hue bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Picker control +// NOTE: It's divided in multiple controls: +// Color GuiColorPanel(Rectangle bounds, Color color) +// float GuiColorBarAlpha(Rectangle bounds, float alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanel() size +// NOTE: this picker converts RGB to HSV, which can cause the Hue control to jump. If you have this problem, consider using the HSV variant instead +int GuiColorPicker(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Color temp = { 200, 0, 0, 255 }; + if (color == NULL) color = &temp; + + 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) }; + + // NOTE: this conversion can cause low hue-resolution, if the r, g and b value are very similar, which causes the hue bar to shift around when only the GuiColorPanel is used. + Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ (*color).r/255.0f, (*color).g/255.0f, (*color).b/255.0f }); + + GuiColorBarHue(boundsHue, NULL, &hsv.x); + + //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f); + Vector3 rgb = ConvertHSVtoRGB(hsv); + + *color = RAYGUI_CLITERAL(Color){ (unsigned char)roundf(rgb.x*255.0f), (unsigned char)roundf(rgb.y*255.0f), (unsigned char)roundf(rgb.z*255.0f), (*color).a }; + + return result; +} + +// Color Picker control that avoids conversion to RGB and back to HSV on each call, thus avoiding jittering. +// The user can call ConvertHSVtoRGB() to convert *colorHsv value to RGB. +// NOTE: It's divided in multiple controls: +// int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +// int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanelHSV() size +int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + + Vector3 tempHsv = { 0 }; + + if (colorHsv == NULL) + { + const Vector3 tempColor = { 200.0f/255.0f, 0.0f, 0.0f }; + tempHsv = ConvertRGBtoHSV(tempColor); + colorHsv = &tempHsv; + } + + GuiColorPanelHSV(bounds, NULL, colorHsv); + + const Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height }; + + GuiColorBarHue(boundsHue, NULL, &colorHsv->x); + + return result; +} + +// Color Panel control - HSV variant +int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + GuiState state = guiState; + Vector2 pickerSelector = { 0 }; + + const Color colWhite = { 255, 255, 255, 255 }; + const Color colBlack = { 0, 0, 0, 255 }; + + pickerSelector.x = bounds.x + (float)colorHsv->y*bounds.width; // HSV: Saturation + pickerSelector.y = bounds.y + (1.0f - (float)colorHsv->z)*bounds.height; // HSV: Value + + Vector3 maxHue = { colorHsv->x, 1.0f, 1.0f }; + Vector3 rgbHue = ConvertHSVtoRGB(maxHue); + Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x), + (unsigned char)(255.0f*rgbHue.y), + (unsigned char)(255.0f*rgbHue.z), 255 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + pickerSelector = mousePoint; + + if (pickerSelector.x < bounds.x) pickerSelector.x = bounds.x; + if (pickerSelector.x > bounds.x + bounds.width) pickerSelector.x = bounds.x + bounds.width; + if (pickerSelector.y < bounds.y) pickerSelector.y = bounds.y; + if (pickerSelector.y > bounds.y + bounds.height) pickerSelector.y = bounds.y + bounds.height; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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)); + + // Draw color picker: selector + Rectangle selector = { pickerSelector.x - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, pickerSelector.y - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE) }; + GuiDrawRectangle(selector, 0, BLANK, colWhite); + } + else + { + DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.6f), guiAlpha)); + } + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + //-------------------------------------------------------------------- + + return result; +} + +// Message Box control +int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons) +{ + #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 result = -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 + 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; + + int textWidth = GetTextWidth(message) + 2; + + Rectangle textBounds = { 0 }; + textBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.width = bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*2; + textBounds.height = bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 3*RAYGUI_MESSAGEBOX_BUTTON_PADDING - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + + prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment); + //-------------------------------------------------------------------- + + return result; +} + +// Text Input Box control, ask for text +int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, bool *secretViewActive) +{ + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT 24 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_PADDING) + #define RAYGUI_TEXTINPUTBOX_BUTTON_PADDING 12 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_HEIGHT 26 + #endif + + // Used to enable text edit mode + // WARNING: No more than one GuiTextInputBox() should be open at the same time + static bool textEditMode = false; + + int result = -1; + + int buttonCount = 0; + const char **buttonsText = GuiTextSplit(buttons, ';', &buttonCount, NULL); + Rectangle buttonBounds = { 0 }; + 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 - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - 2*RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + + Rectangle textBounds = { 0 }; + if (message != NULL) + { + int textSize = GetTextWidth(message) + 2; + + textBounds.x = bounds.x + bounds.width/2 - textSize/2; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + messageInputHeight/4 - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + textBounds.width = (float)textSize; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + } + + Rectangle textBoxBounds = { 0 }; + 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 - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*2; + textBoxBounds.height = RAYGUI_TEXTINPUTBOX_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + // Draw message if available + if (message != NULL) + { + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + } + + 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; + + 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, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + if (result >= 0) textEditMode = false; + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment); + //-------------------------------------------------------------------- + + return result; // Result is the pressed button index +} + +// Grid control +// NOTE: Returns grid mouse-hover selected cell +// About drawing lines at subpixel spacing, simple put, not easy solution: +// https://stackoverflow.com/questions/4435450/2d-opengl-drawing-lines-that-dont-exactly-fit-pixel-raster +int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell) +{ + // Grid lines alpha amount + #if !defined(RAYGUI_GRID_ALPHA) + #define RAYGUI_GRID_ALPHA 0.15f + #endif + + int result = 0; + GuiState state = guiState; + + Vector2 mousePoint = GetMousePosition(); + Vector2 currentMouseCell = { -1, -1 }; + + float spaceWidth = spacing/(float)subdivs; + int linesV = (int)(bounds.width/spaceWidth) + 1; + int linesH = (int)(bounds.height/spaceWidth) + 1; + + int color = GuiGetStyle(DEFAULT, LINE_COLOR); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + // NOTE: Cell values must be the upper left of the cell the mouse is in + currentMouseCell.x = floorf((mousePoint.x - bounds.x)/spacing); + currentMouseCell.y = floorf((mousePoint.y - bounds.y)/spacing); + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) color = GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED); + + if (subdivs > 0) + { + // Draw vertical grid lines + for (int i = 0; i < linesV; i++) + { + Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height }; + GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(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)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(color), RAYGUI_GRID_ALPHA)); + } + } + + if (mouseCell != NULL) *mouseCell = currentMouseCell; + return result; +} + +//---------------------------------------------------------------------------------- +// Tooltip management functions +// NOTE: Tooltips requires some global variables: tooltipPtr +//---------------------------------------------------------------------------------- +// Enable gui tooltips (global state) +void GuiEnableTooltip(void) { guiTooltip = true; } + +// Disable gui tooltips (global state) +void GuiDisableTooltip(void) { guiTooltip = false; } + +// Set tooltip string +void GuiSetTooltip(const char *tooltip) { guiTooltipPtr = tooltip; } + +//---------------------------------------------------------------------------------- +// Styles loading functions +//---------------------------------------------------------------------------------- + +// 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; + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + // Try reading the files as text file first + FILE *rgsFile = fopen(fileName, "rt"); + + if (rgsFile != NULL) + { + char buffer[MAX_LINE_BUFFER_SIZE] = { 0 }; + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + + if (buffer[0] == '#') + { + int controlId = 0; + int propertyId = 0; + unsigned int propertyValue = 0; + + while (!feof(rgsFile)) + { + switch (buffer[0]) + { + case 'p': + { + // Style property: p + + sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue); + GuiSetStyle(controlId, propertyId, (int)propertyValue); + + } break; + case 'f': + { + // Style font: f + + int fontSize = 0; + char charmapFileName[256] = { 0 }; + char fontFileName[256] = { 0 }; + sscanf(buffer, "f %d %s %[^\r\n]s", &fontSize, charmapFileName, fontFileName); + + Font font = { 0 }; + int *codepoints = NULL; + int codepointCount = 0; + + if (charmapFileName[0] != '0') + { + // Load text data from file + // NOTE: Expected an UTF-8 array of codepoints, no separation + char *textData = LoadFileText(TextFormat("%s/%s", GetDirectoryPath(fileName), charmapFileName)); + codepoints = LoadCodepoints(textData, &codepointCount); + UnloadFileText(textData); + } + + if (fontFileName[0] != '\0') + { + // In case a font is already loaded and it is not default internal font, unload it + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + + if (codepointCount > 0) font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, codepoints, codepointCount); + else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0); // Default to 95 standard codepoints + } + + // If font texture not properly loaded, revert to default font and size/spacing + if (font.texture.id == 0) + { + font = GetFontDefault(); + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); + } + + UnloadCodepoints(codepoints); + + if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font); + + } break; + default: break; + } + + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + } + } + else tryBinary = true; + + fclose(rgsFile); + } + + if (tryBinary) + { + rgsFile = fopen(fileName, "rb"); + + if (rgsFile != NULL) + { + fseek(rgsFile, 0, SEEK_END); + int fileDataSize = ftell(rgsFile); + fseek(rgsFile, 0, SEEK_SET); + + if (fileDataSize > 0) + { + unsigned char *fileData = (unsigned char *)RAYGUI_MALLOC(fileDataSize*sizeof(unsigned char)); + fread(fileData, sizeof(unsigned char), fileDataSize, rgsFile); + + GuiLoadStyleFromMemory(fileData, fileDataSize); + + RAYGUI_FREE(fileData); + } + + fclose(rgsFile); + } + } +} + +// Load style default over global style +void GuiLoadStyleDefault(void) +{ + // We set this variable first to avoid cyclic function calls + // when calling GuiSetStyle() and GuiGetStyle() + guiStyleLoaded = true; + + // Initialize default LIGHT style property values + // WARNING: Default value are applied to all controls on set but + // they can be overwritten later on for every custom control + GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, 0x838383ff); + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0xc9c9c9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, 0x686868ff); + GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, 0x5bb2d9ff); + GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, 0xc9effeff); + GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, 0x6c9bbcff); + GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, 0x0492c7ff); + GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, 0x97e8ffff); + GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, 0x368bafff); + GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, 0xb5c1c2ff); + GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, 0xe6e9e9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, 0xaeb7b8ff); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); + GuiSetStyle(DEFAULT, TEXT_PADDING, 0); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + // Initialize default extended property values + // NOTE: By default, extended property values are initialized to 0 + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, LINE_COLOR, 0x90abb5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0xf5f5f5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, TEXT_LINE_SPACING, 15); // DEFAULT, 15 pixels between lines + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); // DEFAULT, text aligned vertically to middle of text-bounds + + // Initialize control-specific property values + // NOTE: Those properties are in default list but require specific values by control type + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 2); + GuiSetStyle(SLIDER, TEXT_PADDING, 4); + GuiSetStyle(PROGRESSBAR, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, TEXT_ALIGN_RIGHT); + GuiSetStyle(DROPDOWNBOX, TEXT_PADDING, 0); + GuiSetStyle(DROPDOWNBOX, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiSetStyle(TEXTBOX, TEXT_PADDING, 4); + GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(VALUEBOX, TEXT_PADDING, 0); + GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(SPINNER, TEXT_PADDING, 0); + 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 + GuiSetStyle(TOGGLE, GROUP_PADDING, 2); + 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, 32); + GuiSetStyle(COMBOBOX, COMBO_BUTTON_SPACING, 2); + GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16); + GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING, 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, 12); + GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 28); + GuiSetStyle(LISTVIEW, LIST_ITEMS_SPACING, 2); + GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 12); + GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE); + 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); + + if (guiFont.texture.id != GetFontDefault().texture.id) + { + // Unload previous font texture + UnloadTexture(guiFont.texture); + RL_FREE(guiFont.recs); + RL_FREE(guiFont.glyphs); + guiFont.recs = NULL; + guiFont.glyphs = NULL; + + // Setup default raylib font + guiFont = GetFontDefault(); + + // NOTE: Default raylib font character 95 is a white square + Rectangle whiteChar = guiFont.recs[95]; + + // NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding on MSAA filtering + SetShapesTexture(guiFont.texture, RAYGUI_CLITERAL(Rectangle){ whiteChar.x + 1, whiteChar.y + 1, whiteChar.width - 2, whiteChar.height - 2 }); + } +} + +// Get text with icon id prepended +// NOTE: Useful to add icons by name id (enum) instead of +// a number that can change between ricon versions +const char *GuiIconText(int iconId, const char *text) +{ +#if defined(RAYGUI_NO_ICONS) + return NULL; +#else + static char buffer[1024] = { 0 }; + static char iconBuffer[16] = { 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); + + return iconBuffer; + } +#endif +} + +#if !defined(RAYGUI_NO_ICONS) +// Get full icons data pointer +unsigned int *GuiGetIcons(void) { return guiIconsPtr; } + +// Load raygui icons file (.rgi) +// NOTE: In case nameIds are required, they can be requested with loadIconsName, +// 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) +{ + // Style File Structure (.rgi) + // ------------------------------------------------------ + // Offset | Size | Type | Description + // ------------------------------------------------------ + // 0 | 4 | char | Signature: "rGI " + // 4 | 2 | short | Version: 100 + // 6 | 2 | short | reserved + + // 8 | 2 | short | Num icons (N) + // 10 | 2 | short | Icons size (Options: 16, 32, 64) (S) + + // Icons name id (32 bytes per name id) + // foreach (icon) + // { + // 12+32*i | 32 | char | Icon NameId + // } + + // Icons data: One bit per pixel, stored as unsigned int array (depends on icon size) + // S*S pixels/32bit per unsigned int = K unsigned int per icon + // foreach (icon) + // { + // ... | K | unsigned int | Icon Data + // } + + FILE *rgiFile = fopen(fileName, "rb"); + + char **guiIconsName = NULL; + + if (rgiFile != NULL) + { + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + short iconCount = 0; + short iconSize = 0; + + fread(signature, 1, 4, rgiFile); + fread(&version, sizeof(short), 1, rgiFile); + fread(&reserved, sizeof(short), 1, rgiFile); + fread(&iconCount, sizeof(short), 1, rgiFile); + fread(&iconSize, sizeof(short), 1, rgiFile); + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'I') && + (signature[3] == ' ')) + { + if (loadIconsName) + { + guiIconsName = (char **)RAYGUI_MALLOC(iconCount*sizeof(char **)); + for (int i = 0; i < iconCount; i++) + { + guiIconsName[i] = (char *)RAYGUI_MALLOC(RAYGUI_ICON_MAX_NAME_LENGTH); + fread(guiIconsName[i], 1, RAYGUI_ICON_MAX_NAME_LENGTH, rgiFile); + } + } + else fseek(rgiFile, iconCount*RAYGUI_ICON_MAX_NAME_LENGTH, SEEK_CUR); + + // Read icons data directly over internal icons array + fread(guiIconsPtr, sizeof(unsigned int), iconCount*(iconSize*iconSize/32), rgiFile); + } + + fclose(rgiFile); + } + + return guiIconsName; +} + +// Draw selected icon using rectangles pixel-by-pixel +void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color) +{ + #define BIT_CHECK(a,b) ((a) & (1u<<(b))) + + 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(guiIconsPtr[iconId*RAYGUI_ICON_DATA_ELEMENTS + i], k)) + { + #if !defined(RAYGUI_STANDALONE) + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ (float)posX + (k%RAYGUI_ICON_SIZE)*pixelSize, (float)posY + y*pixelSize, (float)pixelSize, (float)pixelSize }, 0, BLANK, color); + #endif + } + + if ((k == 15) || (k == 31)) y++; + } + } +} + +// Set icon drawing size +void GuiSetIconScale(int scale) +{ + if (scale >= 1) guiIconScale = scale; +} + +#endif // !RAYGUI_NO_ICONS + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- + +// Load style from memory +// WARNING: Binary files only +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize) +{ + unsigned char *fileDataPtr = (unsigned char *)fileData; + + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + int propertyCount = 0; + + memcpy(signature, fileDataPtr, 4); + memcpy(&version, fileDataPtr + 4, sizeof(short)); + memcpy(&reserved, fileDataPtr + 4 + 2, sizeof(short)); + memcpy(&propertyCount, fileDataPtr + 4 + 2 + 2, sizeof(int)); + fileDataPtr += 12; + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'S') && + (signature[3] == ' ')) + { + short controlId = 0; + short propertyId = 0; + unsigned int propertyValue = 0; + + for (int i = 0; i < propertyCount; i++) + { + memcpy(&controlId, fileDataPtr, sizeof(short)); + memcpy(&propertyId, fileDataPtr + 2, sizeof(short)); + memcpy(&propertyValue, fileDataPtr + 2 + 2, sizeof(unsigned int)); + fileDataPtr += 8; + + if (controlId == 0) // DEFAULT control + { + // If a DEFAULT property is loaded, it is propagated to all controls + // NOTE: All DEFAULT properties should be defined first in the file + GuiSetStyle(0, (int)propertyId, propertyValue); + + if (propertyId < RAYGUI_MAX_PROPS_BASE) for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) GuiSetStyle(i, (int)propertyId, propertyValue); + } + else GuiSetStyle((int)controlId, (int)propertyId, propertyValue); + } + + // Font loading is highly dependant on raylib API to load font data and image + +#if !defined(RAYGUI_STANDALONE) + // Load custom font if available + int fontDataSize = 0; + memcpy(&fontDataSize, fileDataPtr, sizeof(int)); + fileDataPtr += 4; + + if (fontDataSize > 0) + { + Font font = { 0 }; + int fontType = 0; // 0-Normal, 1-SDF + + memcpy(&font.baseSize, fileDataPtr, sizeof(int)); + memcpy(&font.glyphCount, fileDataPtr + 4, sizeof(int)); + memcpy(&fontType, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + // Load font white rectangle + Rectangle fontWhiteRec = { 0 }; + memcpy(&fontWhiteRec, fileDataPtr, sizeof(Rectangle)); + fileDataPtr += 16; + + // Load font image parameters + int fontImageUncompSize = 0; + int fontImageCompSize = 0; + memcpy(&fontImageUncompSize, fileDataPtr, sizeof(int)); + memcpy(&fontImageCompSize, fileDataPtr + 4, sizeof(int)); + fileDataPtr += 8; + + Image imFont = { 0 }; + imFont.mipmaps = 1; + memcpy(&imFont.width, fileDataPtr, sizeof(int)); + memcpy(&imFont.height, fileDataPtr + 4, sizeof(int)); + memcpy(&imFont.format, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + if ((fontImageCompSize > 0) && (fontImageCompSize != fontImageUncompSize)) + { + // Compressed font atlas image data (DEFLATE), it requires DecompressData() + int dataUncompSize = 0; + unsigned char *compData = (unsigned char *)RAYGUI_MALLOC(fontImageCompSize); + memcpy(compData, fileDataPtr, fontImageCompSize); + fileDataPtr += fontImageCompSize; + + imFont.data = DecompressData(compData, fontImageCompSize, &dataUncompSize); + + // Security check, dataUncompSize must match the provided fontImageUncompSize + if (dataUncompSize != fontImageUncompSize) RAYGUI_LOG("WARNING: Uncompressed font atlas image data could be corrupted"); + + RAYGUI_FREE(compData); + } + else + { + // Font atlas image data is not compressed + imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageUncompSize); + memcpy(imFont.data, fileDataPtr, fontImageUncompSize); + fileDataPtr += fontImageUncompSize; + } + + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + font.texture = LoadTextureFromImage(imFont); + + RAYGUI_FREE(imFont.data); + + // Validate font atlas texture was loaded correctly + if (font.texture.id != 0) + { + // Load font recs data + int recsDataSize = font.glyphCount*sizeof(Rectangle); + int recsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed recs data + memcpy(&recsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + if ((recsDataCompressedSize > 0) && (recsDataCompressedSize != recsDataSize)) + { + // Recs data is compressed, uncompress it + unsigned char *recsDataCompressed = (unsigned char *)RAYGUI_MALLOC(recsDataCompressedSize); + + memcpy(recsDataCompressed, fileDataPtr, recsDataCompressedSize); + fileDataPtr += recsDataCompressedSize; + + int recsDataUncompSize = 0; + font.recs = (Rectangle *)DecompressData(recsDataCompressed, recsDataCompressedSize, &recsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (recsDataUncompSize != recsDataSize) RAYGUI_LOG("WARNING: Uncompressed font recs data could be corrupted"); + + RAYGUI_FREE(recsDataCompressed); + } + else + { + // Recs data is uncompressed + font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle)); + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.recs[i], fileDataPtr, sizeof(Rectangle)); + fileDataPtr += sizeof(Rectangle); + } + } + + // Load font glyphs info data + int glyphsDataSize = font.glyphCount*16; // 16 bytes data per glyph + int glyphsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed glyphs data + memcpy(&glyphsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + // Allocate required glyphs space to fill with data + font.glyphs = (GlyphInfo *)RAYGUI_CALLOC(font.glyphCount, sizeof(GlyphInfo)); + + if ((glyphsDataCompressedSize > 0) && (glyphsDataCompressedSize != glyphsDataSize)) + { + // Glyphs data is compressed, uncompress it + unsigned char *glypsDataCompressed = (unsigned char *)RAYGUI_MALLOC(glyphsDataCompressedSize); + + memcpy(glypsDataCompressed, fileDataPtr, glyphsDataCompressedSize); + fileDataPtr += glyphsDataCompressedSize; + + int glyphsDataUncompSize = 0; + unsigned char *glyphsDataUncomp = DecompressData(glypsDataCompressed, glyphsDataCompressedSize, &glyphsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (glyphsDataUncompSize != glyphsDataSize) RAYGUI_LOG("WARNING: Uncompressed font glyphs data could be corrupted"); + + unsigned char *glyphsDataUncompPtr = glyphsDataUncomp; + + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, glyphsDataUncompPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, glyphsDataUncompPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, glyphsDataUncompPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, glyphsDataUncompPtr + 12, sizeof(int)); + glyphsDataUncompPtr += 16; + } + + RAYGUI_FREE(glypsDataCompressed); + RAYGUI_FREE(glyphsDataUncomp); + } + else + { + // Glyphs data is uncompressed + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, fileDataPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, fileDataPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, fileDataPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, fileDataPtr + 12, sizeof(int)); + fileDataPtr += 16; + } + } + } + else font = GetFontDefault(); // Fallback in case of errors loading font atlas texture + + GuiSetFont(font); + + // Set font texture source rectangle to be used as white texture to draw shapes + // NOTE: It makes possible to draw shapes and text (full UI) in a single draw call + if ((fontWhiteRec.x > 0) && + (fontWhiteRec.y > 0) && + (fontWhiteRec.width > 0) && + (fontWhiteRec.height > 0)) SetShapesTexture(font.texture, fontWhiteRec); + } +#endif + } +} + +// Gui get text width considering icon +static int GetTextWidth(const char *text) +{ + #if !defined(ICON_TEXT_PADDING) + #define ICON_TEXT_PADDING 4 + #endif + + Vector2 textSize = { 0 }; + int textIconOffset = 0; + + if ((text != NULL) && (text[0] != '\0')) + { + if (text[0] == '#') + { + for (int i = 1; (i < 5) && (text[i] != '\0'); i++) + { + if (text[i] == '#') + { + textIconOffset = i; + break; + } + } + } + + text += textIconOffset; + + // Make sure guiFont is set, GuiGetStyle() initializes it lazynessly + float fontSize = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + + // Custom MeasureText() implementation + if ((guiFont.texture.id > 0) && (text != NULL)) + { + // Get size in bytes of text, considering end of line and line break + int size = 0; + for (int i = 0; i < MAX_LINE_BUFFER_SIZE; i++) + { + if ((text[i] != '\0') && (text[i] != '\n')) size++; + else break; + } + + float scaleFactor = fontSize/(float)guiFont.baseSize; + textSize.y = (float)guiFont.baseSize*scaleFactor; + float glyphWidth = 0.0f; + + for (int i = 0, codepointSize = 0; i < size; i += codepointSize) + { + int codepoint = GetCodepointNext(&text[i], &codepointSize); + int codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + textSize.x += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (textIconOffset > 0) textSize.x += (RAYGUI_ICON_SIZE - ICON_TEXT_PADDING); + } + + return (int)textSize.x; +} + +// Get text bounds considering control bounds +static Rectangle GetTextBounds(int control, Rectangle bounds) +{ + Rectangle textBounds = bounds; + + textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH); + textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH) + GuiGetStyle(control, TEXT_PADDING); + textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); + textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); // NOTE: Text is processed line per line! + + // Depending on control, TEXT_PADDING and TEXT_ALIGNMENT properties could affect the text-bounds + switch (control) + { + case COMBOBOX: + case DROPDOWNBOX: + case LISTVIEW: + // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW + case SLIDER: + case CHECKBOX: + case VALUEBOX: + case SPINNER: + // TODO: More special cases (label on side): SLIDER, CHECKBOX, VALUEBOX, SPINNER + default: + { + // TODO: WARNING: TEXT_ALIGNMENT is already considered in GuiDrawText() + if (GuiGetStyle(control, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING); + else textBounds.x += GuiGetStyle(control, TEXT_PADDING); + } + break; + } + + return textBounds; +} + +// Get text icon if provided and move text cursor +// NOTE: We support up to 999 values for iconId +static const char *GetTextIcon(const char *text, int *iconId) +{ +#if !defined(RAYGUI_NO_ICONS) + *iconId = -1; + if (text[0] == '#') // Maybe we have an icon! + { + char iconValue[4] = { 0 }; // Maximum length for icon value: 3 digits + '\0' + + int pos = 1; + while ((pos < 4) && (text[pos] >= '0') && (text[pos] <= '9')) + { + iconValue[pos - 1] = text[pos]; + pos++; + } + + if (text[pos] == '#') + { + *iconId = TextToInteger(iconValue); + + // Move text pointer after icon + // WARNING: If only icon provided, it could point to EOL character: '\0' + if (*iconId >= 0) text += (pos + 1); + } + } +#endif + + return text; +} + +// Get text divided into lines (by line-breaks '\n') +const char **GetTextLines(const char *text, int *count) +{ + #define RAYGUI_MAX_TEXT_LINES 128 + + static const char *lines[RAYGUI_MAX_TEXT_LINES] = { 0 }; + for (int i = 0; i < RAYGUI_MAX_TEXT_LINES; i++) lines[i] = NULL; // Init NULL pointers to substrings + + int textSize = (int)strlen(text); + + lines[0] = text; + int len = 0; + *count = 1; + //int lineSize = 0; // Stores current line size, not returned + + for (int i = 0, k = 0; (i < textSize) && (*count < RAYGUI_MAX_TEXT_LINES); i++) + { + if (text[i] == '\n') + { + //lineSize = len; + k++; + lines[k] = &text[i + 1]; // WARNING: next value is valid? + len = 0; + *count += 1; + } + else len++; + } + + //lines[*count - 1].size = len; + + return lines; +} + +// Get text width to next space for provided string +static float GetNextSpaceWidth(const char *text, int *nextSpaceIndex) +{ + float width = 0; + int codepointByteCount = 0; + int codepoint = 0; + int index = 0; + float glyphWidth = 0; + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + for (int i = 0; text[i] != '\0'; i++) + { + if (text[i] != ' ') + { + codepoint = GetCodepoint(&text[i], &codepointByteCount); + index = GetGlyphIndex(guiFont, codepoint); + glyphWidth = (guiFont.glyphs[index].advanceX == 0)? guiFont.recs[index].width*scaleFactor : guiFont.glyphs[index].advanceX*scaleFactor; + width += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + else + { + *nextSpaceIndex = i; + break; + } + } + + return width; +} + +// Gui draw text using default font +static void GuiDrawText(const char *text, Rectangle textBounds, int alignment, Color tint) +{ + #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')) return; // Security check + + // PROCEDURE: + // - Text is processed line per line + // - For every line, horizontal alignment is defined + // - For all text, vertical alignment is defined (multiline text only) + // - For every line, wordwrap mode is checked (useful for GuitextBox(), read-only) + + // Get text lines (using '\n' as delimiter) to be processed individually + // WARNING: We can't use GuiTextSplit() function because it can be already used + // before the GuiDrawText() call and its buffer is static, it would be overriden :( + int lineCount = 0; + const char **lines = GetTextLines(text, &lineCount); + + // Text style variables + //int alignment = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT); + int alignmentVertical = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL); + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); // Wrap-mode only available in read-only mode, no for text editing + + // TODO: WARNING: This totalHeight is not valid for vertical alignment in case of word-wrap + float totalHeight = (float)(lineCount*GuiGetStyle(DEFAULT, TEXT_SIZE) + (lineCount - 1)*GuiGetStyle(DEFAULT, TEXT_SIZE)/2); + float posOffsetY = 0.0f; + + for (int i = 0; i < lineCount; i++) + { + int iconId = 0; + lines[i] = GetTextIcon(lines[i], &iconId); // Check text for icon and move cursor + + // Get text position depending on alignment and iconId + //--------------------------------------------------------------------------------- + Vector2 textBoundsPosition = { textBounds.x, textBounds.y }; + float textBoundsWidthOffset = 0.0f; + + // NOTE: We get text size after icon has been processed + // WARNING: GetTextWidth() also processes text icon to get width! -> Really needed? + int textSizeX = GetTextWidth(lines[i]); + + // If text requires an icon, add size to measure + if (iconId >= 0) + { + textSizeX += RAYGUI_ICON_SIZE*guiIconScale; + + // WARNING: If only icon provided, text could be pointing to EOF character: '\0' +#if !defined(RAYGUI_NO_ICONS) + if ((lines[i] != NULL) && (lines[i][0] != '\0')) textSizeX += ICON_TEXT_PADDING; +#endif + } + + // Check guiTextAlign global variables + switch (alignment) + { + case TEXT_ALIGN_LEFT: textBoundsPosition.x = textBounds.x; break; + case TEXT_ALIGN_CENTER: textBoundsPosition.x = textBounds.x + textBounds.width/2 - textSizeX/2; break; + case TEXT_ALIGN_RIGHT: textBoundsPosition.x = textBounds.x + textBounds.width - textSizeX; break; + default: break; + } + + if (textSizeX > textBounds.width && (lines[i] != NULL) && (lines[i][0] != '\0')) textBoundsPosition.x = textBounds.x; + + switch (alignmentVertical) + { + // Only valid in case of wordWrap = 0; + case TEXT_ALIGN_TOP: textBoundsPosition.y = textBounds.y + posOffsetY; break; + case TEXT_ALIGN_MIDDLE: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height/2 - totalHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + case TEXT_ALIGN_BOTTOM: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height - totalHeight + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + default: break; + } + + // NOTE: Make sure we get pixel-perfect coordinates, + // In case of decimals we got weird text positioning + textBoundsPosition.x = (float)((int)textBoundsPosition.x); + textBoundsPosition.y = (float)((int)textBoundsPosition.y); + //--------------------------------------------------------------------------------- + + // Draw text (with icon if available) + //--------------------------------------------------------------------------------- +#if !defined(RAYGUI_NO_ICONS) + if (iconId >= 0) + { + // NOTE: We consider icon height, probably different than text size + GuiDrawIcon(iconId, (int)textBoundsPosition.x, (int)(textBounds.y + textBounds.height/2 - RAYGUI_ICON_SIZE*guiIconScale/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height)), guiIconScale, tint); + textBoundsPosition.x += (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + textBoundsWidthOffset = (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + } +#endif + // Get size in bytes of text, + // considering end of line and line break + int lineSize = 0; + for (int c = 0; (lines[i][c] != '\0') && (lines[i][c] != '\n') && (lines[i][c] != '\r'); c++, lineSize++){ } + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + int lastSpaceIndex = 0; + bool tempWrapCharMode = false; + + int textOffsetY = 0; + float textOffsetX = 0.0f; + float glyphWidth = 0; + + float ellipsisWidth = GetTextWidth("..."); + bool overflowReached = false; + for (int c = 0, codepointSize = 0; c < lineSize; c += codepointSize) + { + int codepoint = GetCodepointNext(&lines[i][c], &codepointSize); + int index = GetGlyphIndex(guiFont, codepoint); + + // NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f) + // but we need to draw all of the bad bytes using the '?' symbol moving one byte + if (codepoint == 0x3f) codepointSize = 1; // TODO: Review not recognized codepoints size + + // Get glyph width to check if it goes out of bounds + if (guiFont.glyphs[index].advanceX == 0) glyphWidth = ((float)guiFont.recs[index].width*scaleFactor); + else glyphWidth = (float)guiFont.glyphs[index].advanceX*scaleFactor; + + // Wrap mode text measuring, to validate if + // it can be drawn or a new line is required + if (wrapMode == TEXT_WRAP_CHAR) + { + // Jump to next line if current character reach end of the box limits + if ((textOffsetX + glyphWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + + if (tempWrapCharMode) // Wrap at char level when too long words + { + wrapMode = TEXT_WRAP_WORD; + tempWrapCharMode = false; + } + } + } + else if (wrapMode == TEXT_WRAP_WORD) + { + if (codepoint == 32) lastSpaceIndex = c; + + // Get width to next space in line + int nextSpaceIndex = 0; + float nextSpaceWidth = GetNextSpaceWidth(lines[i] + c, &nextSpaceIndex); + + int nextSpaceIndex2 = 0; + float nextWordSize = GetNextSpaceWidth(lines[i] + lastSpaceIndex + 1, &nextSpaceIndex2); + + if (nextWordSize > textBounds.width - textBoundsWidthOffset) + { + // Considering the case the next word is longer than bounds + tempWrapCharMode = true; + wrapMode = TEXT_WRAP_CHAR; + } + else if ((textOffsetX + nextSpaceWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + } + + if (codepoint == '\n') break; // WARNING: Lines are already processed manually, no need to keep drawing after this codepoint + else + { + // TODO: There are multiple types of spaces in Unicode, + // maybe it's a good idea to add support for more: http://jkorpela.fi/chars/spaces.html + if ((codepoint != ' ') && (codepoint != '\t')) // Do not draw codepoints with no glyph + { + if (wrapMode == TEXT_WRAP_NONE) + { + // Draw only required text glyphs fitting the textBounds.width + if (textSizeX > textBounds.width) + { + if (textOffsetX <= (textBounds.width - glyphWidth - textBoundsWidthOffset - ellipsisWidth)) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + else if (!overflowReached) + { + overflowReached = true; + + for (int j = 0; j < ellipsisWidth; j += ellipsisWidth/3) + { + DrawTextCodepoint(guiFont, '.', RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX + j, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + else + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) + { + // Draw only glyphs inside the bounds + if ((textBoundsPosition.y + textOffsetY) <= (textBounds.y + textBounds.height - GuiGetStyle(DEFAULT, TEXT_SIZE))) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + + if (guiFont.glyphs[index].advanceX == 0) textOffsetX += ((float)guiFont.recs[index].width*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + else textOffsetX += ((float)guiFont.glyphs[index].advanceX*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (wrapMode == TEXT_WRAP_NONE) posOffsetY += (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) posOffsetY += (textOffsetY + (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING)); + //--------------------------------------------------------------------------------- + } + +#if defined(RAYGUI_DEBUG_TEXT_BOUNDS) + GuiDrawRectangle(textBounds, 0, WHITE, Fade(BLUE, 0.4f)); +#endif +} + +// Gui draw rectangle using default raygui plain style with borders +static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color) +{ + if (color.a > 0) + { + // Draw rectangle filled with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, GuiFade(color, guiAlpha)); + } + + if (borderWidth > 0) + { + // Draw rectangle border lines with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + } + +#if defined(RAYGUI_DEBUG_RECS_BOUNDS) + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, Fade(RED, 0.4f)); +#endif +} + +// Draw tooltip using control bounds +static void GuiTooltip(Rectangle controlRec) +{ + if (!guiLocked && guiTooltip && (guiTooltipPtr != NULL) && !guiControlExclusiveMode) + { + Vector2 textSize = MeasureTextEx(GuiGetFont(), guiTooltipPtr, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + + if ((controlRec.x + textSize.x + 16) > GetScreenWidth()) controlRec.x -= (textSize.x + 16 - controlRec.width); + + GuiPanel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, NULL); + + int textPadding = GuiGetStyle(LABEL, TEXT_PADDING); + int textAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_PADDING, 0); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, guiTooltipPtr); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, textAlignment); + GuiSetStyle(LABEL, TEXT_PADDING, textPadding); + } +} + +// Split controls text into multiple strings +// Also check for multiple columns (required by GuiToggleGroup()) +static const char **GuiTextSplit(const char *text, char delimiter, 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 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 + + // TODO: HACK: GuiTextSplit() - Review how textRows are returned to user + // textRow is an externally provided array of integers that stores row number for every splitted string + + #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 }; // String pointers array (points to buffer data) + static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 }; // Buffer data (text input copy with '\0' added) + memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE); + + result[0] = buffer; + int counter = 1; + + if (textRow != NULL) textRow[0] = 0; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if ((buffer[i] == delimiter) || (buffer[i] == '\n')) + { + result[counter] = buffer + i + 1; + + if (textRow != NULL) + { + if (buffer[i] == '\n') textRow[counter] = textRow[counter - 1] + 1; + else textRow[counter] = textRow[counter - 1]; + } + + buffer[i] = '\0'; // Set an end of string at this point + + counter++; + if (counter > RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + + *count = counter; + + return result; +} + +// Convert color data from RGB to HSV +// NOTE: Color data should be passed normalized +static Vector3 ConvertRGBtoHSV(Vector3 rgb) +{ + Vector3 hsv = { 0 }; + float min = 0.0f; + float max = 0.0f; + float delta = 0.0f; + + min = (rgb.x < rgb.y)? rgb.x : rgb.y; + min = (min < rgb.z)? min : rgb.z; + + max = (rgb.x > rgb.y)? rgb.x : rgb.y; + max = (max > rgb.z)? max : rgb.z; + + hsv.z = max; // Value + delta = max - min; + + if (delta < 0.00001f) + { + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + if (max > 0.0f) + { + // NOTE: If max is 0, this divide would cause a crash + hsv.y = (delta/max); // Saturation + } + else + { + // NOTE: If max is 0, then r = g = b = 0, s = 0, h is undefined + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + // NOTE: Comparing float values could not work properly + if (rgb.x >= max) hsv.x = (rgb.y - rgb.z)/delta; // Between yellow & magenta + else + { + if (rgb.y >= max) hsv.x = 2.0f + (rgb.z - rgb.x)/delta; // Between cyan & yellow + else hsv.x = 4.0f + (rgb.x - rgb.y)/delta; // Between magenta & cyan + } + + hsv.x *= 60.0f; // Convert to degrees + + if (hsv.x < 0.0f) hsv.x += 360.0f; + + return hsv; +} + +// Convert color data from HSV to RGB +// NOTE: Color data should be passed normalized +static Vector3 ConvertHSVtoRGB(Vector3 hsv) +{ + Vector3 rgb = { 0 }; + float hh = 0.0f, p = 0.0f, q = 0.0f, t = 0.0f, ff = 0.0f; + long i = 0; + + // NOTE: Comparing float values could not work properly + if (hsv.y <= 0.0f) + { + rgb.x = hsv.z; + rgb.y = hsv.z; + rgb.z = hsv.z; + return rgb; + } + + hh = hsv.x; + if (hh >= 360.0f) hh = 0.0f; + hh /= 60.0f; + + i = (long)hh; + ff = hh - i; + p = hsv.z*(1.0f - hsv.y); + q = hsv.z*(1.0f - (hsv.y*ff)); + t = hsv.z*(1.0f - (hsv.y*(1.0f - ff))); + + switch (i) + { + case 0: + { + rgb.x = hsv.z; + rgb.y = t; + rgb.z = p; + } break; + case 1: + { + rgb.x = q; + rgb.y = hsv.z; + rgb.z = p; + } break; + case 2: + { + rgb.x = p; + rgb.y = hsv.z; + rgb.z = t; + } break; + case 3: + { + rgb.x = p; + rgb.y = q; + rgb.z = hsv.z; + } break; + case 4: + { + rgb.x = t; + rgb.y = p; + rgb.z = hsv.z; + } break; + case 5: + default: + { + rgb.x = hsv.z; + rgb.y = p; + rgb.z = q; + } break; + } + + return rgb; +} + +// 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; + + int valueRange = maxValue - minValue; + if (valueRange <= 0) valueRange = 1; + + int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + if (sliderSize < 1) sliderSize = 1; // TODO: Consider a minimum 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) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.height)? ((int)scrollbar.height - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + scrollbar.y + (int)(((float)(value - minValue)/valueRange)*(scrollbar.height - sliderSize)), + bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)), + (float)sliderSize }; + } + else // horizontal + { + 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)) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.width)? ((int)scrollbar.width - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + scrollbar.x + (int)(((float)(value - minValue)/valueRange)*(scrollbar.width - sliderSize)), + bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + (float)sliderSize, + bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)) }; + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && + !CheckCollisionPointRec(mousePoint, arrowUpLeft) && + !CheckCollisionPointRec(mousePoint, arrowDownRight)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Handle mouse wheel + int wheel = (int)GetMouseWheelMove(); + if (wheel != 0) value += wheel; + + // Handle mouse button down + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + // Check arrows click + if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) value -= valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) value += valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (!CheckCollisionPointRec(mousePoint, slider)) + { + // If click on scrollbar position but not on slider, place slider directly on that position + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + + state = STATE_PRESSED; + } + + // Keyboard control on mouse hover scrollbar + /* + if (isVertical) + { + if (IsKeyDown(KEY_DOWN)) value += 5; + else if (IsKeyDown(KEY_UP)) value -= 5; + } + else + { + if (IsKeyDown(KEY_RIGHT)) value += 5; + else if (IsKeyDown(KEY_LEFT)) value -= 5; + } + */ + } + + // Normalize value + if (value > maxValue) value = maxValue; + if (value < minValue) value = minValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED))); // Draw the background + + GuiDrawRectangle(scrollbar, 0, BLANK, GetColor(GuiGetStyle(BUTTON, BASE_COLOR_NORMAL))); // Draw the scrollbar active area background + GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BORDER + state*3))); // 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, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); + GuiDrawText(isVertical? "v" : ">", + RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // 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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // ICON_ARROW_DOWN_FILL / ICON_ARROW_RIGHT_FILL +#endif + } + //-------------------------------------------------------------------- + + return value; +} + +// Color fade-in or fade-out, alpha goes from 0.0f to 1.0f +// WARNING: It multiplies current alpha by alpha scale factor +static Color GuiFade(Color color, float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + Color result = { color.r, color.g, color.b, (unsigned char)(color.a*alpha) }; + + return result; +} + +#if defined(RAYGUI_STANDALONE) +// Returns a Color struct from hexadecimal value +static Color GetColor(int hexValue) +{ + Color color; + + color.r = (unsigned char)(hexValue >> 24) & 0xFF; + color.g = (unsigned char)(hexValue >> 16) & 0xFF; + color.b = (unsigned char)(hexValue >> 8) & 0xFF; + color.a = (unsigned char)hexValue & 0xFF; + + return color; +} + +// Returns hexadecimal value for a Color +static int ColorToInt(Color color) +{ + return (((int)color.r << 24) | ((int)color.g << 16) | ((int)color.b << 8) | (int)color.a); +} + +// Check if point is inside rectangle +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec) +{ + bool collision = false; + + if ((point.x >= rec.x) && (point.x <= (rec.x + rec.width)) && + (point.y >= rec.y) && (point.y <= (rec.y + rec.height))) collision = true; + + return collision; +} + +// Formatting of text with variables to 'embed' +static const char *TextFormat(const char *text, ...) +{ + #if !defined(RAYGUI_TEXTFORMAT_MAX_SIZE) + #define RAYGUI_TEXTFORMAT_MAX_SIZE 256 + #endif + + static char buffer[RAYGUI_TEXTFORMAT_MAX_SIZE]; + + va_list args; + va_start(args, text); + vsprintf(buffer, text, args); + va_end(args); + + return buffer; +} + +// Draw rectangle with vertical gradient fill color +// NOTE: This function is only used by GuiColorPicker() +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2) +{ + Rectangle bounds = { (float)posX, (float)posY, (float)width, (float)height }; + DrawRectangleGradientEx(bounds, color1, color2, color2, color1); +} + +// 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 RAYGUI_TEXTSPLIT_MAX_ITEMS + // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE + + #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; + + if (text != NULL) + { + counter = 1; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if (buffer[i] == delimiter) + { + buffer[i] = '\0'; // Set an end of string at this point + result[counter] = buffer + i + 1; + counter++; + + if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + } + + *count = counter; + return result; +} + +// Get integer value from text +// NOTE: This function replaces atoi() [stdlib.h] +static int TextToInteger(const char *text) +{ + int value = 0; + int sign = 1; + + if ((text[0] == '+') || (text[0] == '-')) + { + if (text[0] == '-') sign = -1; + text++; + } + + for (int i = 0; ((text[i] >= '0') && (text[i] <= '9')); ++i) value = value*10 + (int)(text[i] - '0'); + + return value*sign; +} + +// Encode codepoint into UTF-8 text (char array size returned as parameter) +static const char *CodepointToUTF8(int codepoint, int *byteSize) +{ + static char utf8[6] = { 0 }; + int size = 0; + + if (codepoint <= 0x7f) + { + utf8[0] = (char)codepoint; + size = 1; + } + else if (codepoint <= 0x7ff) + { + utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0); + utf8[1] = (char)((codepoint & 0x3f) | 0x80); + size = 2; + } + else if (codepoint <= 0xffff) + { + utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0); + utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[2] = (char)((codepoint & 0x3f) | 0x80); + size = 3; + } + else if (codepoint <= 0x10ffff) + { + utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0); + utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80); + utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[3] = (char)((codepoint & 0x3f) | 0x80); + size = 4; + } + + *byteSize = size; + + return utf8; +} + +// Get next codepoint in a UTF-8 encoded text, scanning until '\0' is found +// When a invalid UTF-8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned +// Total number of bytes processed are returned as a parameter +// NOTE: the standard says U+FFFD should be returned in case of errors +// but that character is not supported by the default font in raylib +static int GetCodepointNext(const char *text, int *codepointSize) +{ + const char *ptr = text; + int codepoint = 0x3f; // Codepoint (defaults to '?') + *codepointSize = 1; + + // Get current codepoint and bytes processed + if (0xf0 == (0xf8 & ptr[0])) + { + // 4 byte UTF-8 codepoint + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]); + *codepointSize = 4; + } + else if (0xe0 == (0xf0 & ptr[0])) + { + // 3 byte UTF-8 codepoint */ + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]); + *codepointSize = 3; + } + else if (0xc0 == (0xe0 & ptr[0])) + { + // 2 byte UTF-8 codepoint + if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } //10xxxxxx checks + codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]); + *codepointSize = 2; + } + else if (0x00 == (0x80 & ptr[0])) + { + // 1 byte UTF-8 codepoint + codepoint = ptr[0]; + *codepointSize = 1; + } + + return codepoint; +} +#endif // RAYGUI_STANDALONE + +#endif // RAYGUI_IMPLEMENTATION diff --git a/raylib-src/old-raygui-src/raygui.so b/raylib-src/old-raygui-src/raygui.so new file mode 100755 index 0000000000000000000000000000000000000000..7ffcb0770bd8ddf5792ac3b100285c5dbc461f19 GIT binary patch literal 1320304 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%0A8);{WLLb!$18_@cDp#as4FFSE>6x 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�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%0A9}jnl-oWVam%qyXNP}WI@Bu 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ˋ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 literal 0 HcmV?d00001 diff --git a/raylib-src/raylib-5.0_linux_amd64.tar.gz b/raylib-src/raylib-5.0_linux_amd64.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..598bf53761e935c78c3f609335795615f4bd5c6a GIT binary patch literal 1840378 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ÇYftpyj;1)%9iLLn-^z`ZtwRiHZ=E2PJMOn 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 z zO~pX3sc@L=>ksKuFR8#+7Y+R(egE!)^gZV-=`$=*=Kq)YK(ADg(y~|B^;Demk{;Kz4v=s z)BDAZVomSy#aBlDuCD3*=Umh4K=ZC-O|P2jsn_(%WUrbNKF9aEivS=q>KuvQof1e+ z7$g(Dr~z8fD;D9lq$vw$_on%{pqH-=-l!6_-WO5b${O5hDp_~=BCAJP8+qL1;NskHjeWW4g#cW1-+ z>bv$-)#|$;i2m`on_f3vXX4B6m~Ix}KM>hjkfX1nuliD2qBjx(`Vm$5ya@&aNCOj1 zt7R$s5u>YUaakxHqMTeqN9f_mz*1=MS3Eoie|L=LH{+2#iG_N0x-2fu&Qkc6F@X3A zdF36%*G;pP*xO<0T|6GG0MR+J+`L9tYws$1Rq~wH-qp%$@8ao>9+N~g9T(rx83a&J zl}eg+^_|;AeqpGY5G7PrufjFToDmAx>9jO29>Zj#{G!-M(t(@e{iko3{Jf>) zXh4F0m9#MdD zh`R`4o*`*5HwtNv+b2^>l^v9{Thh)qOcwJEaAg zdDV{jQoh^IZG-6u)VoB3Kht=zyjeuOVZH_2P6u^b-H2{?Eu=bY?2fxDYy6bmm8+%Q zl|x^fN0rW=CvE=JzjrzmcULC&g!;L1GtYY~cX@Lp!D>Lpp^;Ru{!+5nE~h;)AeT0= zO4~5?b#&%S%=`?2dIuYT?Qh#-K27&B~bevRxv_rQBkCUPuy4az9${V+9uImovbmD+=)PU!% zbtz{nZpbY%W1M}y^8<$#-6ypO2E&NNxn!^3&6PTp%VP!HG^bA8oR~lo6_GmEMMu#d zBA}ce;JM3O%Grhuc}+BAizm~ZoWu9G&v9XzqJEp^HIf!HZjKkGDH5hB8er3WJey22 zY>uO8iu!GuOcE7gpY72!MZz>i18kZEUi$GQ7p4jCw`qEk$TY7cd10DxVVdv(Hq8&I z4*HxVN7ID&+cdi$B;^>AJenq4m?qpu)2OM)VHFiwBvX<1cs=4Cbf6+)V|$-`q^1u( zvJA?&hsw|&oFxwqQv>=WBzy?D1P_6_PQgQ8GDDfeLz;Li_dN}5shLIovUHXg{<2y4 z%Vw_#%vKBc7aGq$a8$ERrRG$b#2lGPDws4&O=27mI&i1sy1tmq3C?6qG7<#CFTwSSeta-H(y+E(+VbF0TdEkM`TUf@l_nKQuobGhwy zbN=ZdJfm>b`SvHzeBBG-U67sooef_E{FoVzv+_1N7k*T!IsfwAc@MF$LSFquIwD(_ ztD|fG@aEZ_Ot&@??>N@Q#p1cyy4+a04KfT5*4EvPclhFAiF2W4GnB&;^NZsY`D@>n z(=6{6a$k@$0mTS&;E9p)BWqjCbk;Ss54u(IV5N=40cJYuT4~PD%(hwB2lK#1Phh*4 z;Y(J22AWrcmjvhc+@1H7)V#3unpRHLiOamChEC-dh=IkX#$rmB94qebq~@CV70YFG z!MB@6=aru;*S!|8=bnaL(ig7g|Y+#5)^R$`Ou`7E79$A1mE-Ds;r~>g;~&iao!C zx}vPFSjkbY$LS2+5V}&&gVt(MYv9~?`YW`&0yM_@P+q-Sc?q_uTzQ~HyfZ>KEeMah zEN=#3CsCWgpxPbPxlK{0QL9!EVAg>Ks_D99Xo!hB7HXF#QN8plokveUYE*28-x6cR z&B{0rh*x8m(q+pH@$dn{_keoqaUU#rBg9^|f9@-qRUTqMIwbG2&FHEXg zRdvPoIONtI+|9wiK{?5Fl2ORdwH^4E?JJ`V-3(DV#2Q5JEbo{bQ zd^Bvs)?JZMr+VNxjEw z+m*YtU4m`8upL-23{ww;FvC7pUJoT5Mq?Uru?Dwhhod#WakeIWTD83_8P$3~7!>cF zZ-lf_^teW)$2G#UiIMPZy|64kTZ_*|@@H#>nRycJj7l}f^49In?sPif? zEy`^*ax+Ikx((A%;LVUeZlqh{nF+^#ljcleVQ1jQPPPuv+IpH%GIkL09;{EWXM6MO zGc`8<3)(!%+2)9u0nk_R?sRT^Zf~@{ReURPVf`v@{e7#psjPn&Ss#rqoBsjX{BuIw z*d0F4v+}=b?0k9+{^c~ErxdHAIT zznJ(TF7pnFFJX{whR+G{bhZI`M;oLM3hy|MY2h6wc-r+4>CQQDnT5(Z5?liTcadF^ zi`01KA|IiPEOd5}-6~iB$uPdEU8O|hDy5!W<)c1;B0&ZU@R>;R86BV!E3brF>__A< z;;v5aLPv!QopOYZd)&K@QSu!bLLNd0IV!xT6#D-W;XZbeo+{wvhyo`^5PHzCO~Q{# zCFqG%U}$Qj0z(2?8o67QfGa$TK66UARtA3Q6kjs&%W3>#5?{`UF9t|=z!R8v9$e=O zNZ$$R3nD!Z(qCcP#M50oJ$x+uTZ-tD=F-6|=wJ>`_Lv| z)H_T(O`XGq%URInv~Kqfy4}OxAd}*JR*mzm_uzch-1!cz`tUn(zQz4_KENcMa5kTu z5HU?Soe$0kV%8$Y?YI)JgwMOd+rIp6yz>pMcP`XSqII^0C7Qug`M@m0vp3)H4;K+kg_uYSM;chyI$9I z-FsM(b3LoBQD!FO!6OooM*t-W3d|6MAg>{Tnfw1$-IGj`33=eYIEQp~SO5QCUG;tS zSM_xLwJcGa>gyPV<9YP4aJ)*&g9Z!Cu`T#20}`KE5ag{<{MhwT3`e#7R8qrmS&JJk z=ShTZ1y5!qV0bdkJB#dnmOkUuAY9hsm&{ z(%_bP5+|y)JUJV{{!ooJeHD>D`ur6DG66tw4M0%~X)~k)TKXPH2etG>3wg+oX{hFV zAbmxQ{34_^iZhkcc1V6D9LWoKKU>zujeo{d{n&=&nCdU$3nJ#*A+^0@=Z+u-n{9!- z5rMqCEsz0eHsPuU%(WQgDGbXy!?3(949jKgOx5mWQ;0BR%N*GKZC3w z>6bN9G;5^Trjw$IkpdD2EI6!b&5k#^!;aqf{~0apU_|ls*cD{7FocoC(_^nNyM-l; zFo%2NASUWW(MZ$OEz-0n&fIX~6UJ|Qk-lr3O z^~@1z-HIN%tKM>NE#uxxUF4oen?7s5hJ5D~bZQi23wrq5 zKt{6&B%FyPv}q(n4#Mdi!OxfolW@3YfK|Av)6ouee1g$&Q8Ey70wd;d?bm=1G1*&0 zjh7P4xpZFc(s{X`@e&e8EjW>HP0&L1ixMl6g`yXNCg$V#Im*~0MoMzCu%UHa#D=aQ+!(YVl=HhP#Ar9N7Eja=z1y%`avCDiJCp9>ZzWDFUCWm4 z{Rrcf$UDZP<_Bxb@n7-W3E)3o*cn1bip)~^z7m}mW^Ti^L8vw767Y3qIY>X=faZ?DpCiXHb%Euw-Bho(H6sx_+hG;M7A^h^)B?n+ zL}J5*MuE#{_=1JZI02e>p`iv;brB6!vCnAvH?#x#;-?)@%c*Rq(mo72S4g3O?No|; zF8eM4(%p3lX#k#8H#O4GuF!F;T@E7dKbYKymb*`w3Qid6g2YZ1;oIwNcCxaZjE!A5 z>U)NqJ_VnFcz$a=jUX1&UaV9T8y`XJ0*FPm7xQRhfwYdr{N#fUq}-ZRB}kFgxKk;Y zWIKOeAB@hlE`Tw4lm^BTqgsLS`=dA*Z{x@Dca36ToXAhpqWLie&;R|wSk9M0+$b=1 zfGQn~wId^gu>*YQV04zG>q&57}b#)7=JUe6&PRQ z@lWo3ogY~|6aeG9{4{MDKc?XMzdsnw2uAY_17ipH(82iNtv%`)heZ&(&@rrZG=81h zlb-S2)K0)?b;jeY$Dl7&9L*Q3`pN2zxEh)skm(hK=Fd}GLo=5_(>fV9TW8S3$kdBd z8dEtm2VYKQ&}4u$HECC4jkj`)-gGNlNIj6BjyaslF^cD*4cq(K*_I#x&C>{hQiNt1 zUTf4)ql2>vVbYAK!7at@EO&75m7BVjZR(0f*5KUmwmNCGsxpUi;a{--0pf)LA}Ngx5f`Q7%m3coNWc$(Pl$Qt6qAl-b?e|V0kp_rBi-dV*>bo zPSSV6_}b@SK?8DE*Fi6hK?BA=sfBbIlYF>UYWFahjFtmz zTq2p}!VgG1HPI-EfVJ;OtbNX54!z;McXMq3bq$*X;m@%VJbp_cEe*3t6WghQb*ZfT z{F>NOhOwN6l#yJ)Vq7s_yA#o02OVbmQDQrU!3Ji*105rtW6^dVHo#tG=X>(hHt?8k zcGH#=MpWb(E5^5A>=G8^#0Y*%!1OzIOA`w*VuFj8fhXsPE$wA?y&;X~F9zMUKn!pp zBby8W7Y+FsN1ok3~YV2QNy&u7jC+iiv3P>-Z))U%-D1QWBbS zA=Op|v~K?cMzsp)`F%^^8sDaUfVQVQJmgBR?+bhZL|vlWYZ8?@+%4XqZ=a4kl(&fB z&hAYh;_tc$TJd$+3VH4uNNSe+Xvuvh0lN292E$E_b~-iCvR5uZ6E&(i@wBmJQ+Tpw z7^K^7BOj*2uja&cQ>01FiRq@uRrRiLiQ(-fd?Vmmger*%A38-KW!b(?NqJzXM#?XT zc1X(d5Gl*ML(1O|?Ua=3hejghnxUMO#Y1~b%Hcz=OUj#uc1%hmFGL#8Z%;~|ABbi7 zosja-kPs=44*6Fl<&nrDuHKNcyA1PppJ7d1U|3sDw(Tsw6H<=b(A9(H+M+N z7el0cu{)&fcXOwtY)*f3skQXA2=eH*%&kw}1{7y(I zC51?tneS8 ze5tB6HJ@hGWQ%S&HQyejQS&c@!l;Q0_$$Vmpe_u)0FVrh(Tb;?ld*On zCnL{qPez^}h-LYmknw|oAu^T>>>3%1S-dD9w~*0j3@4-LK9zt|K0rB41?^M}@a5;_FnQZfRwH*MHA$k? zt$}}Yd*HXzT}qc0sNQ z*;2w~?lz@sD5d4@GbZJP(OEc7D^|ni(on3`WSKTw=r${@!g!Rj;}UT^jLsZ?Y>fLf z7GFV(jU598%Na=Sh!r3~)D_U;pT8JQDgd4)Q!td&VB2nJ)wt~^hE;HDXK zE0k3R{tqN9akz&$Q~nSr=Xpk+7yIAbOh!7|nVzK?!g#iT@!7kXp*>*eAQUPo+8& zXJRGa%`5q-&MTR!7-CP&5U5fJ31?y%yZR!AA0eA7-StsaU5{0_hzB=rgOBj?LXCO$ z7%{%M%`~iad5>I!5-yjNKp(Qkb(OWj?e)+Go03@@JYB)sK;8{)Fn?ZiP@ENti(GKp z54fSZLQJd3mxY2CF5c;~s#|eIZIIdssc%Wb)MWL6Y}vVi z=PU>2mk8CE1>n3t-J(uO@Y0$<5J~+wbWnJCN~);dKL=${ho~;IqRruMJ+P-5^$PZ+JvA_1MHMO}lX z^u{!UlU4r<+6wB3!EnGFVK|%?361>JDkRJ51|b1Cx{1k3a7^Z1&_?03E|dyonPg<# zOmMhz7b|`vDa1GHiXZ5YH7zRFAXN{&X@w+62qrknc=W}w*XgET)k4d!Phl;;s*JV# z8W^T|AAhtNf$<<_zreHS@$5fg_K$h?Ak03&aWk1`zX=EL?T=yrM<8xOa4-IrFT`7& zZwZ?aFV2m^JFM^Z(NnCGjbq;y;P*EYvak~Szb8vgFm5~{(^~JVv8>Kf1|xB6t)Y00 zJT}g4@IO0tBHZ7B#sn)E=4u|~YBq5-l2RgI1wiFI30;9Y2i(q)4_VikS&C+ymLOb| z%wLiR@La-X&N8xQ{xGbWH)zdlz-C6!LNg<+6IZsH$W>WmoWZm;n zVa}=1jv&dbaQmY`e+()7WiqPmgONs;Sk#%hDhD~7E>Jo0A^Dg^EiU9(!d|SRP$<$o ziV_6H^FW8MIGN!DJI%d%MLgtT)jJ6^B^sHgWMJq%)*kN*Zy7LB`CGyp;qAi0E2YEW zJy%Gz(vw~SV|}%V-9@c}tkr*MyLv}CS=EFNM}rVI0eU1A1SRJ@qlD44#miq>%%`8d z4epgBr#+}bu|!%X8ZRpT;Iq&8X0Z^&3j|qIP8%)esT(U0t;E zT6B9mWZes(4{W^#wq9;{l|yZ%0M9C!%gDMvK<;R-;u>JC;rO#M{ILz4u(BN63C)MJ z4#*l(yaZ2ernBb58aREAz?F6c&xDHr^9@GqPaXf41cj1>32=X$9v|5E{lVDaHHx>t z;*TXSyU1T%80c2N&lfc~T!^{tZxZ3T4wBdLZpGC{eg(&oR%0b_zwiuD0G=?H>^>HQ!Gko1FVpu0B&wDA*$x5I=6`Jk#n~2GYXv&2$fTEi zna}}2QOHa9q`tr4Z&A*r%}|?3>v0Tw_hp%Gc@O(?=W@L2S{J(N(tCKvS*!=_0vyM+ z5#+T`U}QPAP^dvnJ?CZ69iQ}vKv2`h_873vmxOfdeDF7pBV^rk1EICw7pl>_!5I7+ z!nj2E0@nrus_Wo5#TnmMnpni1nXF^qiUK|hKSxz+0WQ{=rp8%mkuVpX%lu$w^aPof z2sjY+y^BTU5B5oMM-TRk;;;wvVTch;peS6x*B7&tYw)<^St+jIuND9>_ciQ-vnIu+!$dtVU0m)X4-cg}z>%Um^@= z?sFlE9tY7)!iOwlgOG|D#{Du>-7Acm%rUU-RbA0auJgyhKok3@Yk*nXh4)oi7la%rmtwU=zvF zHesAh3$S$b&)C|~|4yJ=8hI*?Zn?lykI^k(V=7NrKtJ;GYgu#)jw>n(tVZs4kT3Kj z8Fjt7kKeP9ZaIyhp?|JnhmR0Kaz(*=ng}FaS`tQh3D9=^v8#e4xWPkO5=JsXEeXw> zbPchmuoHdOdKaKX$yd+v}>U1L>@#JZu?Y(@Y#=JFfS0WLiVbm2TX zPv#T~EBG*rkJ;b~_v$R7AZbGi@HF`FhTL1In?=4C zx8fTChbw;;dJf21<@=cRLZ-myFlgM(Cw!)l*`RSX9K4roY)n~;+533*nZL2@To~SY z4`R0BF`D;~;_)UZ#D5+z=N*X2+a;NU&z=yS@d;)(d7x6H!G;=8^9rh|<7)oI)r>(k z>zSHUMi@bw59SY3tp{Qz#vjP5lFZvzo^-e*T0t`XBHi9_Si+4!q=|WgOp5Nr`hZij zRgg&0WFzylY>yQS4CB^j@eAo1BPKv4CYUSo6Gr>NE#Te&&Z$AovyP+63a%`js(Fkc zAFtB1Q?-y^Sj*lB6lpA}P}UoHbpHxvgU-8LAz2ATlR_u3o0eVv5>Q@@FPgVvRg0fs z<MwG)BWSn9GTCBUC88_z|;Ff;Lbss9FevG zD;$Jjo44O|*4F3uK=vt~9mTV~nBDLo%sVgFqPB73RyJ07J;28}Esy7$htn}Yr$o=t zv!E^Q`9wo7(Jh*{!2{Ll4}*jxp#qYqRIk?Gf4_5 zrcThJRf|>)+G3TWMacr%feD>ps;E_pRu(NHDk?%EsI`D;A!8ia^@+Pac30PRcXe@h zwLE+^EqwqgEeI44ET}LcywSF_wE50CcP1~2>wf?Je*cf(kLJ#O-*eAB_uO;OIal6> zV+8!g4lnG%3O$pYj>F{xaRvBlY=Wb);w*^p3OJh(F$&_#^C8B`-`u0m8cr&(uZ|7i>P(d29 zk~jrM%d{h{-~jS`G1XnmFW)ScZIl%2%K}g=esPV7qTNc`z3b8puCnysy18}NNA|#6 zui5~Z^D8T1PE$2uPQ~YdIscqUi1j;69>tRX%9592^7AbDDNG*ElAmSC{0c~(1IY|N zmBd-FdE+ay5z}5^!16I*?LlA>{Nxu1SOmnt3k0ke7_g>V0{_O4at9~d0u(98UpjMs z7^@Ty<>ZL~wQ>z=p?akG$V(et=zH~;GcZt;&myPpTu^ef%snK^HT?2=sjRut{Ia2K zz<8Vc(@Jj& zO~Ch<%9`Cu?n`v~QSLi}n3_&F02R9AV{W-k3aVzeQoaLLUDw&tK<#lek8Q&=zm=$%o>8P7?&@FGLLzl0Pb17pvh+Bz=TZtdr>{2q%0?aDn z_PZS0AOD9Wx6<2QfdR5b_r2+I)XqJOkGR-ez!SJ~w!4D+jW;R9FPOs%aev5w?IAn# z43L4qSaVJjP&=i->}xwIrmC6CHlc z7DwaL+mW=*|EDM)k-Ky1#J~izkh4}$9^j<1dbd)#=%n0~(<&`*9%iz~R>=$5}^COH6e^BHhbHp6H_X2}uq9>8O`qhT&UM>RJVm}#jwj?6hC zpC9@)9gWiN0YbX^`7?>~{pO!U`Q8EUNPXf)AdCT|0Z8A&17cxOX7qbH|LAK(xcQt5 zAPnac3g2d<~dGrxj zKrF8&Eez9R!4qkq=GzrUt@ zfj`h0yJCdo3#JPs_d!L~j_m>$6lD(Og}nj?yr^K#X%uB7r!Fhxo##8md3ObTB*XLJ z5zO~7wrue7x*Vg4U&?lNJf=A)55E+}10;VC17mWJr|E+AH#w9{c8)$hN6Q2o#UAXE?ICci}L zj>yed(B2K~`4x2RG0{%UFBjn`1>00E+ol39(1|&aJ`|37R~|izw{in>pCPL^D?iL* zFPL*NoHOUS9Y1+)W_y2t7$ryT{MW7^P9gl7?_)YFS8NeJVSC>p$@K3(5QDG>Mbl?} z(Hj{rkIqI3q&Vs=%v`=b{4Op&JTRCAdHgJw{03sS&^Ue`aSOlS8;KC!gnkV8Rp|d&st5d}rKPT4soiR?V5tU@j z97GYJ(TAZ@6tWcmibNZsKOTxiCMd<1&=&-Z6d)J;4FJY=zVeBK2?84roKsiPEXe8C zMN3BGim%I_pp+YR3648JG7gtqesx~>ue$I z0@%sM2F!jzt`lVy4yZRk5?`HevaY-#L{rpFQ#6s}qBnN?PQZr* zDbA{meATZZAlJa`3|Nz92$&b@gG8W(M0)h~6CyH*uSD7_n+d%bzJ_k>=_||oaal+( z6S@VkMXjC!(Gxgvr;GgZ@34mXIdJq|!@q$zsVNaewLdI!H`FM| zUqhA4Ag^4@if{C!3;gn(^0)B!BzG8yi270?dqY64Vp80Ly>Ni(0p`x?IL245HsOAX zb;4Oj85{9+n&#doB5n}Q!if?nffalFIJq{iLo!q5tZL_%+-IVLv=y)u#~3YqiI39^q9R4Yj{zo5{04TNZ~M`%^X0p=>wF4)mYOjZ zIxinqKe!c7pec=*B&Qe`4>E*0=>}l!yum=IL~fnPR}UBcc?|_zgq)f9YK)F`PlN>6 zt3+;>$ZZuJFciLW6-s`NN!)(9Q{q|$U(b2`;zdaA0#>`L%=(<0+kJgxH&(nRzT#O% z_|HKDTID9F{D<%#G2d%_=4&W0=^Zgc-rb?u5nO(2c|YE%Gm!Gt`4dEcz6J9MjW8xG0LRpEK2PS6bt0!=N$)uGrQ<=8V zfnK^Hv-(0%0v{%YPFxM$g`e3RbsYjY1|u6lEh;{lA@>toLLc;MBlrtyyvYqB*97f} z51lB&wjNmfGLDHm0W~~nbUqXr3}L?dOTm98R^#$DaH8YL6JLfNpsk=ByL}isac3`e zTYTtfLN!OJBhH7~p_-#mjo-qimO5m_qED<1U8whH(0|_}bF4>OdlGuo)bk5_1gR!~ zH9be5cd8*I_r!s?yys^?tQ9mNc(;dc=^+Npxeb=WNwySf|4d8ahlv9XYT6BKDg60n z{B4b?7LiH_kk@c1LFr@}aZTm+kuJGI-i)tl;$qH4`D}rYDSX)Y7wh=y9rz?|pnqVN z1-RNwxe0IRM0+Xbp6EF0IYSxG0fSt%A-a1N+e-oK3IJfa>Vw_57kKO=C3$=XT^clC zK2#J7uyX_?=0es?^+;EQ)I(6v4b&nN*~VO%UB>gvD=D+DrhiaH{-FeKEX(Z${PISJ z$}h$lK#9AdD#BO(lU0zRS3nnQ)ah(~c_|Db)2?6pz;C*NWiRb$g&b4iC=EaJLLPB}B(h91 zqnXZzNP$I8(j%pXYj8&5r%Xw?f@QioT5=n{?J3DSrJQ;=ZluEzrKs$C$k?(c%`l#? zwrBZ9+u;m?AQb3q;*|G>FK#s35jNpXoMK(X7Uz{?79IfsR6==Sl-zSrD05)5>}y zMohqr&%`PY%>k+u_c<*>_v<*<7SDZAJgi)ZJQY3G1jq<|*HZfPOMYjd+ks3+Im~$F za~kphdW=F8sM>F2!{ZmRsOO(8t=;5C*qmmOwc3+uqgekE=jtdk`u#0DObYu+yy)BF3=O?cIgH|~yO-hCmS zNwqD2PG&B?JJ?I5AcD&zj~%`WVWYYnro8w{15W%9{5$#z^*riU!+3xGrEa;+1qU(2 zItk__&-+DaIh!eqGA}|y3FO;5c1dOJ61NLSi((1B+I$XQ?H**{np!#qqxoFF`D{2$ zAsZ(-I=yY-NAPM@xrvPqj{Z}i4=IM^(X8{TVezzZsK^0$ruR3dbBPcLg>6zJr+}~YT8OVthr}#|jiiyiI>|I8!=)5*1TdJu z%K-_@{L;?uD5m%4m)cPnR&Fl=^vdO*;ZBmyi=UCllAI%eQ9yhrCar$H@)F3Xt?tkn zOzZF^yrK&*iuI>AiDDgtANAl!)cibwR2g@%$`uxz)O5R`%#IY5)uO^eY4}paheS9W z9E*tV=7Mf+Jrwj<350M^n7=9fJ#;8nDd@$#Zhm=95!V=9vQ=B?qyR@hdi+~5jmv;e z=R&8+@jNysm8IK({kCyzR$wD&Fh;OhZk?lH?(xuz#0fwX0xqG-6bmX>!0v(-&XbgU z6O2a;WWo@hf+4IA4~5?MOPa_o?|vA-88CpgZf=vC+k$mP2eD)R7vZ+VK{OR{8$#FO zqu+7BdbWQbz#2-}b}Hh;0nE*PnFzBl!n;p}S*Vc)>c)WrQ&5@NpJ|btW}utGBY|KJ zLjKTxj>xsObQ;YA6PL!f(1)|34=rx4&dt@kxdyD+V_mHe`?K)Q#C|jvaa%(-^b*C& z1rXukm9Kmr_>6$r4m1fB)+}su%wt3j53z3f6FVMX!?&J>1`N9UbTq)?{Q`%VhrmL@ z3E>%xaQbH2XK|jh-DNZFQyGE5U2XpB;SG4pwSdtLz3US0@<@3@&-5f<%hr_tfGxR* zEzSE+!58&s@nv0~_|mT@9&mYl<>VA5pkQF4F1Vo!MRJb@PJ*Nb^_FG<0~Wp!2*b21 z4M2)UUlm8$x7>9qW$*NE!ul)>aP>OiTwDVHE|2r1eHsPX-@==5W15u=FC=22TThZE zh=r@Tl_tWij5fOEM!vd#jcVqXH~5kNG{UE^jmOWi5quHa4G{XqZ9=t2s1zynOSr@G z)dsy(sM1I?R1)5e)tmSwe?a~Qi9mc4{U|eQ&DUn47C8De>Yu~_QwL0m9rz48fLdjx zK)-FQaaNzC+{*bPT*cX1kF=s%ypdnBkJEdrH)9NKV*6xC_@CHe;3>v%tiw~|JKR6k z;eNh0F0R8V`e$@F?9)V_CjHZ_kB)t&z-P0nfAzzAKpHETI94Bybp{~5pV(V{xc&PY zuHG+wxO#j_V!SC1Jn`{nJ>HZUpQ6Vb6XW~wOOR*9wCF&Lp(@6Zm4t2vB3iX$-nmj) zU4tla5w^Do5-gIcnkNnj%2-Y`x$W7aqu8F#4hDi;TND@%Cy})-CEX$^Vw%Cl)qIBg z8*D5n{4;n5NU(&UO%Lq!zHT#Lc^&F8`MQn3{jm_N{%eq;I;H`yw#;R^DFe1#hW=AcfZT2njY`OgQKWKfX5 zRc`APXkcN zRJlP?rqDHFfyC{=-#j=eHNeK6D=MD5dWy>01v>W$jE#Gbu`Q^Ims9UnuDo(f8qndl zsgI<{GFCCyYNs*?zKUl_#XJ|!p1v@LIV^5cjwW@Q0J{Wp%XYgMm}bum?d*w;7yvrE zJ(zf4E36(0TQbrYQI>M3&YpCB@PJ!G21GCd#7lmqOZyi2`! zHfaxfE|O$tmMHI)xCTk~!a1T9BC=`fNKOe=q_Zk+j#jZZ;gtR^ozlBui%2jI!DTnR zMuOw(L^?b|phOQ$)dMs1z$`s5j|D1e6V=0hEeyfmM5Ft&pT(UfEk>Ddk$n3)QNt(a z#KIs7NrNGiy!N>C_o|H*nUZ`&nSj`PCM+6@Pke47$M(}B-ott?@m>TfDz{Ih1uY-h z)aEcRouAFbU?*(eg9I6dOzi&dV~!9DrL*Cw0Iiaj2wE4<(NE0*W~DMsx+YySiMfxX z!}Pm`gu}Ebw}?4w1-V_=v{#fr^kqT+73;ME*Gb*KsEd z^rfgpDIW^%O%+r3uI6ZMhBoa%MWJQW<@|AQAf=2I$B2wGYJ--nEK~_0wfoLwJEl~` z&Ynawrc}gKGB{MXLO%q#kv>pV)kxoK$Z!q6SHL%7q`?xyPKy?v4q+RG8!GK*VL+K^ z2F$w#mgT?d(+o<1$*nxZ0YmheNvm!KR43Q+)h7RoW~>rr2X05$y9@0OC<1WNw)$-B z+G1da3mV{QX^e#9{5TR zq!yJ$CMX|{W*I)su#j-ks%~eJ!k17u8FC{k&MJxCA|Z*FHv_%5sK5Ias$V>nq5hTy zY^omuMOEK>ENDgZ6vo05J5vfgZIEDjr>HZ2MPj}AzoD+KeneZ=M66?%E9|byC2tnw zFI4AEy^+y{UMmU-92joD9=)En`s*S*{0 zy%;}L_#AzYXDC!SmsNO~USarsh`g6Y4va=FgUIUN+A#9u!-EW1$1U+KljrRh#XSLTZ;4259C~r@Hx@(nNHnqVCOY!EfiqP%Qw`%Rpy&5suO?Z%U_EH*) z^I@Hqu4VDvODO)zX#79%)-wK@N#o(g+3SwZR9ZiDXy8vu! z6ariOL$G{v=(-@~T^98nMxE0S71&LDctflJ zWVQuHpOa7~$X8x^N|`T^!L%T7=R$wwIt)FGp?VCJ-AG##21_s);KwTImpaz*OBW&5 zpp1Kc+-L$TumvUkC#^jZD`{L@06$2a zD{FXpFy#9T*O<^=n8$eld*|l5lsEGM_OKjQ(_##6+JkzByI5Nepr9`K&5_Z@=Ro6f zaI}?QeAI|S*k)R$a>J&*z?Ww$6F9Wh+SJBm9r?QWb-K`4xj5f~D)oZDa`Ckg!r$wV zcE=>K+fYSc5zstyq#)M=*Pai-EK=czbwQ#Ffp7}&Ei=M2DoDP`cqc``Msq`dF%T|2 z7-0180Ueiaz+377O++GmD0N3K!6j>f2iUH{e3!f!M;%IGTiDgCvNbdG%8nUP>Nk@t z4-&c=-#5b83(%O7L2rb_h-YY1n~>VztG762+HDmV!z6pRvm9qb4w0{J!>C4A;MbPW zUIUrSW{DRcM}>1_F?)0B9i{ecz7k&%7zKwdz7qF$(GljCx|wL+4y*|(c|kDK!28j( zOi-NM7(*5^c)N%m9lTLVUyk<{)8*ATIa1jMU?iVgiqqqN7XLcxJXWb}eOxR~8O#m8 z;<#Ims1*~Sw^cLkS>7~MenNx4C4WbJD23A)T`|M?Mqm0>g}sq5g`O(xB{F|mA%f#b zRr~x94i%^~U->)M|Ir4%aw(#u!PR(kZ_d`ZDmj$l@M9S+$CS&+<1-*XO>S8q}yq zh=^>IdU*G`$|l)`2Jw~afHIW7lAl0+knV)n;Mj+b2SRwlGZ@1cj@RJ8SGIPs9k2wV z!rx(tV~L~9o;3Wt0X{?j(sKRaBzzL&!aV$32Wg6V0S6I_XCQh93UjM!=2@g=(4WQE zY0Ewnv;I9=GFMAAgdPL%(CG^^Y=sO$Va|WT;XtaN-Vy)B`(rHO+7nu(lS-F>20OA^5#TO%j`c%Dc!Pi`6(PR5*q##H zW8te&<*pWg`Ul(K({1m^HOVatk47S-x?5F)OjFq&REjs5B*!=l|4bV~Ixr_=f?~c5 zVzTGhu$B6QjIDc}QlH9@0@nc3rJg+lm@n>9H&>Q{>P%JJU|Wc;A(M!VLW6du`c^$Y z4krj}36Y-^;IRH}L=KDdRABo0BN0mXjFJKmWw@0w_pM1YgzB`?A3^ERCyXRrQ$_F{ zaj!Nnm$L66@J;gnxC80~sI;Uet9&RaJ(X1C*ga6idP#XIe>G{GDkGX}(+uhh2eqzz zASoZ?;c9gj5xo)5W2#q6<*U$?GW;A=_c^QXt$TFL@DR;-C`0t$2jw2-BxO!M4&#be z^qjP23`~Gweio3YTFLQH_T1Lh3~Gmn`W--EduzfUj$sOdUqafL!6cj@naP3(GuBYj zY5_!Iz`hWI*P%*c{z9CFRn*ykXIL2MR%}IZ59Sx6`Ue#Yp#O?M?m{7uzZeVrof_XS zU2$8M3;1wHE&m*O7b#mKaVlZ~|IFX%yB>4p)C#^HyeHMpHkIVB4bJmyN8+okM!!1+ zDhx7IKI%Pyf&iGgnJHZ87#W*Blo47-T01F~J_6m0sla;I^fJocB+%tf=sLD#-NUjt zG0W>(mOoRLdQIq@ax=?v31)ec{5b5hcNUGud z642LX?~iev9s^lFr6bwzq1SAR(a{3$e;5Vp@`2F9C*iPda>dJier`)>wV*r;xXX4) zF2>7nx4poP;$=7L8zt-xO|(0xSHpl^fmcwx>ylr=l?z|3>>SL2qC;a$B&U5$Fx~DS^I8fp^K{m%Hr~ar-MqFE+B~sf%%xgYA$cMpnMURXSI+vr7uS~^NgBXKmzL0Ao-Mz@D|6h!)709rc)N^no z1MJM#?5PN%66%qii^dO!V4{DL%G%YUJK02MQ;l`7AZW7D6T$=~pC;QCxL&>NPR((^ zr)Z`H6CWLJB1kM6NUG5p6cU=H$Dz3pc3J(C6CM5FJN7Bpl@2m6PmsO?7Ip3AOjnm; zs$3&}s9I#JhO;*893ToBvP>+JcNYPLkwcQaUESQx5Yt9(dd5tp{qa z0*m|W_sNzSxOWd|iLj2CjWAQ(C1+HpxEqW1{>_epBZdh@?b@|U48RM8tSMbCfkh-)oD1* zP%nm|+H5h@(*}E|T_5Zh>X~DcE;~l1;HK0gAD2CLE7FgIkz}XfNbu4EIU2gOKsy41 zJ8+%USg7qug%<6X{M4bW>5b#K&o)BuErR^5ubcDc;$p$t;wW(0Ks+pULZ`74aq9&D z;no(j?zV^)w}Ac&qK5PEo1y(uM;b)?ZTRO_LwLv-*Vy~V@m0$pLEeQu`uBCcDCQtz zEBwA}WN!q2FC3{0&C($>=2lU1@s-Dsds{pK{*EaYM2L79HsdkkO-`5h9dzkXb(4io z{#F=7mJJE!(~Q*Kj3S4?c(V{V2Uhp(S-#r-!TlyV2p>0D_~k8JEl{i%iQGI#zqk>) z1>X@=!n3Kjq~j**v=QOm$g_&o-(Lc;jZOkGRBllulw8di<+kVZl|S`27#5VnzGE$gvpUVtZa>psnTe<@5jmY=nZFIu zh6|}Z$Y;V7UWP)Q?lis%mm*eias-}?`eE=W1;?AmKr0--m}Hp?uV)|EXxV%6HIe7- zS)*R|)nTmpQ24#rnuL1IxrY7iYq*-wX~fnSWCO*Drat4K*RW$9dE(IyuIBYy#ldX`0vhbS$t zktK9{+5JZ>A=FI?dssqxETNetxLH-*w?z|Hu!KUEuqT%AMmMU&03LV-AO$cnj|oc3 zV3u=bET@N6VP*+$#uDyg2|qnf35#M0V_Cuhmhf;aA%`XWz!HjM2{x9nn8JAg*8{onk&cVu7@a=|8tf&ktO~b z6E9{_6IhfRq6B$E=nNKnIg7m(Gj?`HP%jurhy`W2cLu z)6?b3QZx^U(yYC#RQ?G@v#S1R&=$7m49&3%3IsF~iAL~%8L*=H#VDV_BZrck;i%`I zo6*U9&;Q+YnqC zi>-+T*TjNNv3kFV#Wu(4{W=!g8mqSrek?5beJrTPDmxGh9*I@@Hd73I zl8=B1yqJ%@fOAA~Krkz!5wdp5Ti9;aF4v>U8(y8=swpQ-zy;FEFBdF;l;yBlp=DgB z35X=WydL<_N=C56iMI%HNRV4kgSz`0(I}hY?cKo1q4Lt#J!E`>S@`9xaN;Tz`Q=B7 z%G%+lO>=w1PqB$DA1=){oeYE)i9wo1>@X^OA@(0(EPenN*TQkyOQjX87< zYNDUMTJJEZ(&NJF&^H0U;yL^8==Vdi&*xWsVt>P+SJ!L_-zh0+m;WKnu-bh#v;Uh( zYQCEvLHoay?g&=&f>y!r^n&i+n5R4P_?K$=>Wv-Sr^^$`x>j;DdDZX(5VS~+X3x~= z4vY8LbjK{C_rP?=JhON2^u_`>Dus7JlP|srOSQa{uI zxf#D0__F!sGt5OmGUQ!=C-btI>+TTZ=(n2a^R84pb*-UeO*3)-Kv%!T2|MVy#Vwyu zoDr8&UTJpAd-!S&HH(>o8RRJNUyZ?wDL9+M@Fgs4bqHQxqP8Hd@f%t82y~+cWEu3;47~p>HcFTk*`iI zsBHIqBOhs2;iCo>1+k-YbFj^l(=2i|uXgnMvF}`Bl)yRp>b0WW1d(D+lOAgf{~q?Q z#~+~m>z{@C4*JMpA`+F4&;uAa#n86`lbhT3OJ=!}W|`3*N17(|M!E`L-b?8Q4BGsIcnJE348XrBDexB$S}&%P{s$BdErLSo`FY)mie@uh@<~a~ zx8rSwMUuZ1<+>vI%Y?hzlHoN%BZvEj&?qp`L!&_Iz-n+e?)S{<*(EbqPx#%ceY5)w z?;I3<4bATT1$p_(fhoXY5`{;JYXG|y$hTt+g>4a9ov4W)Cp$Vp2mCf5`ZMALN65G4 zp)tkc-3BJp&6BsYYl!~ZrRbYx+EFI@IxYOtuW4LP+8^BkWH$7T05_>&W=8q*#K0`8 z=s3<-4rby8gN3hLL%ZTUa{$F2*)mFVBmDAiE&}U2HH9?gh@#*KMfn8s=}Xo#2NK!L zfy6GkfnSbdxAbHe662NfrVk?w14-ZUH-QWbKR3|TW-*7ssr|3db91?GT7-Y&}R2<|nXM8TaWmspEX8}f4K zcIYWuDf`qk8>yDsr?c~q$Zl~duY4eMJM&a9Z!k%X_!YSmrpvkh>5Zb_7>VfqA5_g- z1u%T+0vt&z|AzOzM_fv}D0jLP(TVP=&*K++$X|sU*!42&vu>{C`p9nJ1+#qzxp|-R zD+WxLB{TdtPM39$5&auZ)g{T)hLt*BwBAa|E>_S?&V(4@^ zn_uxDWS(J!UnoDr934PEDjMRR*h=0ikYUMY-ZB12g$FzoD#DhSPX{i96+CosFc%7* zu&^HYW1buiaZj{_9!{)c$}gz`x?+rWg?ZgrAF?M_H0T%h#S+(--8~6aZ0z|3RX|cd z1g};V>&@EG%RO;Gm3vMHRIOA$1n17sJnUrwkvr!SYU!cH3qWf~Yq&8aFt!07wsTLZk z{u@G}bQEMU^NP)|%$~lF>35 zRo1IsWdX~R5t7az|RPQeA3}wzo3_0wZ<;l3Ylit$OIjcv_HQDGj^O*b4Sd+hi2?wu!pLj zc6A}W^4vp!Tzknz6MEBf35@vny)dkCDK~wLot)+lob8599DD9$cd$&;OTVCr zotvX~uked-h~B}rYLNsLSWlOc)2$D6Xk6n>1t?(qch#x4UVhs7+5}uok-Ww!e<^%M zT_eY33A1%fl6!GhQU>Epscv~Us>iUI`hfhzvnO|^xvsg;dsZK?-*j2hq8sVbp#K#x zQ0h#qL)-LGP+zsfYZ3w%IsuWLf%||5Xh)|~?H8~U2p&seLG5MEvDzrs^N1ktgvbM= z5+MR^G_m+Q#ww#pF&~dB?;#1&?qNKmX7{L>_6+aeLJu%@=H98)<(;DtS!dd9;Yq-v zRZNh|cEA~bg5ntgBw+OG2L1FtL9u>7VhDVlJ>xEPE7vcsZ^7gIKn}eQaJwY#gy`7g z{T9JZAk>@|H8^x_%kbGr2T)fGQ#Jbx-!n_`2{Ou)upFx{C-ij zWb`jf7#W?>M;H9RWN}`5>CY0zm4ksWK6B#qgz=8+qlEFHD^DSescd;X=FkY^f3^48 z*xvi(vBbT1`Kf#FXSDa)Jdd7!?;WR%z80y#JFsi$`|mrnwjYn}znOfs)g-SA?y+#| zrVDaHUBtm#No-z{%a)Lh|zvied6N(^Nskv=NJZEcJ8SganUc@i0h907aMUy*3aUb zbODU`td5_-xAUU-);;tTe0%jS0up!K|Gka)yq_UAYcKj=kel*Br>^z4e#u&&aM7t7 zaSyYXguOUn{bi%3{%AnpeassP3b)mh-;iR>B-9}yFAM<#=??*u&OQswz^J3@p7v=G zNKRF%MiQ>Vx)C&tW1o;*;+WG$pF4qr^tQbp6Mq+H2X z-@EyP454AT^m+%Qp3{Mm{~2lxJE%_=qrQmEJ9;I9hnwJGWozXoganK}9Y+5w8~w9v z^v|-Qtuh8X=Wv9nDwD-h2A#F71laUsD&Oe;7XNUhyVspw_bs{igX0v!G-a?NI2|zfHmh9b|7Y-} z4)6T(zlZO`7qC9bW4ecHYN7I&1H(_JA*$OjBk4_~IHVX_qbhqCy9_5_)bNzI19f&R zVtYlG4VAz&s*Dlubfd8VAw4NJBYA#rKid{M8AU6-bidDtFP$Ykn@O3HJ$)0+J;Pcv5t?@G|UWOTP%_*5Ib zGj4ZOm+tN&ai07G8~F`Y>9p4wY`x@V6FszP1J>Tc{4~^slJS>naIQ2mTx9SL8dqj?TzgKl&FOpG8Tfh} z+vC>$PxiPKCr-b|{g9Eg!Lx2fcep;`?Lru`{jEcN?M%e3=;qd;N+%LFx4R8qo8F$j z_p6U+&Fby3u}c9{tdaj}=-TQ$b?p5$=L0pUMydheY_F9~vj&6R=SF8($FpO7bqKMG zl$HOQ#?b0-C!&=Qvvk$t+YiDN(*=L}aXAaD&KK9fG_I=5rAGoSXqnN zCr$KqW_VM5T?KsQZ}FVlnT1~h@a6cm-^~1u`nou#Pvv{6*x;G(Ygix#=A?^`c7ZQ! z7szdf!Clr)`lAPNsnxsj*^<48`EOm_9SMvp9wU|%U&B}a1GPyZID)l+!QtMkd{0d@ zv&S8MHD|)c9?pbybahD@z0}3_LG=u^E5dr?j^h#og)o8w&vdPyoq~6Fpm4?*e1+Zf zG>aT#fO+(;8>eJmi#j^61ZN$fJ_0S!`WPAB9l;aBIf8OW#HAG9Zk!%8nA!bnv-fzT z(|~3u;YD$EWS`It-bykzF9ZG5$4^jrM; z-S!c07-~faCgjsYzdl*S!UHk}w8B^H20z(yMjJ({8H`|X}l<_^I0S!ZF6TYC_o(kce zCd7`)t>@}`f{nayEqlp17i0M48w&X9USA^zA?1m4@W?o4zkVFyD_=L^%9&};T|NDQ zM;~*uZRmkB(L+GG-OX&V?xfFRyIK350N>=75KR^>QdyHf{R~Ai!m&3O&z8#sv{_8` zTTPPUvFEMI(h*paJB~|#$6!Q|Yw$cN@XI}Rn1FTs@}t21WC-#Xa!1Yv;2|>6&w3Nx z=pWNKqr-G7L*oS4n&q!Tx6}21p()swAuRk3aK#{|wuT;I(ke4rNSl2puJ;UZcjD_{T?) zcgCW!*0Bxd3woVO30G9MW4zybffJxnRJL}k-+G3iNM@NFVb++6%4){@(@h~6EAiE3 z2@AS!nEP>|B962O3p)9^A7GR2vbBP5{etn(ny9#pB0)9CK?j`tXFY`*(w+q4VY(oIZ5h1lslv~N|YbCySCCK$6KG22>1o5P5W5p#RUW^FJL!3MlJGg@Z zd8|ME0v*bN+yKik18UwjPRYFsn%P#UWd2^@!hk^gol0g{$O#uJqpKmc0%ApZXRzm@ z;KB1Thwr-^Ak|eC7Dvr|FORRhiM;FV7%PjfP_;OtJ z7W5I9vq=c5HmAJRnbU|~<#L*wN^Z8Oc#Xn>UK79g0=&Ca=4fAO^fg!edaDo2DBwRk z=&Lsde=v_%GGE8*3^8@5ka|e)eN`a(^Unw^>m_Hnxoj1bZIHNaK;6GtOix<$^QUu~ z&n}DiFw8HB8Re1T6lMwp9OpA&w%7A)fM!UWFrk=w|q% zX4v{TuuII8D#qy(rK-_M2+<{UHjT_B8N&l7i@HKLnb3blkFS$^JdKtmzB&6leT@pf z-a-750PW1v@Q#eQO7{SAnWcSQPhU=*T?1le7xXMndm;QkCv=*7&H~S=cf-=4n1@$D9e}Y~yz+1zz z9%xr!&Q0Px4zjC%=1%|>7swe9X#j*!dslRn+HL$2Mv0!{TxFX8AZNqs*^duwrZ4E~ z^#}{g?dfQ%%vZM3Lfb4X{Go@^V4zo2az7ud zjDD2slD7sU7X=TW&vp6s+>q0S4%x^cQAvNLz<;&qho=3|vVXRzz@I1jC&H&>^!1pT zP8%0;bDe_Y3x3H~1A72_$w|_vQMvGjSSO9FQ|V_z*bE&uu?}0Y!znB+|Lo8N1oVQQ z0?$S8cY)_d7%2p5_^RQU08`;>yCF1$rUwA&l*2->+YFS(G*QJ2qq})+3PUXoqrTCmyQ9e{qbI8nX5xB0gN;%(&ehS7b)?uN~ zku3RVnL-z65Bz4(g)_~6Xi_v(gll%1HBQh#!i6N!0y$U!f-EDyPEP$L1*A*N#3Se{x_=2)ULTx5vK&$z4baS&-_02O*Av|zabm99eTkzG_e)yj2?x>jb zNpkF?`P67shwtd3F0I{&zx7o$6%WOn3S)u|GE~)gZ-+I7$M@fAr(LM&78s&i?uw3b zdJ4O*hC+csnkx)^{PkMA#CII*(%zb|B)m28t@>*{Z}?mMoHz*O=HG=kit=LI#rU7$Xn!fq8uzrkk%I4OX5Yfl5WiwwPcm_hg_woTt&CH zl5{KAsJc?jg(k`E$b5O9dgSq5dbOg24!8Yad{g06cgBFEa~Jf|C7+OwlOwpIq#KM9 zJm2kGg)a{QNrO2{b*2H~-k|2Up*(+3z=KD=bk-xu0NW;QP<+j)Xr~%To2D@c(5nPMO;m7}r?-kHA#C`Ow0dIz_|X&zQFi&|NkQ}J~fts@tvIn#-7Li7ht^j$v7~U4kR#c z?$-w;o8gip_(mdb)7kR+HxhjAW`ZX!~>GXfATcYEMlZ0lu`XX z2D*F ziP}v2$k2l(joWl=n%@sKS>;X82dH%$U-=1oZw(9wOn2vWx*g3GKLGzw(L$0SWg@T+ z&j&-dc7mDnOnU3%gL3Q?V=jJ{haHl>C8+RyP1?Cp~g}GHBMxqCk=6C^|5&{!XqSr=zXG4;M z%B>MMYUw+b=j_}9Jj|@cvz^VE(?;CR`Pwk~=Z4|9Xpk*@CAp)E4YG+1a+5wtA#Rj) zu~DwnM!7Tm4@pTo`_VMR>d(o*XT;)BbWxjk1MJ6v&A_bpW&%S&Et9_G}jt> zSa7b9zi=blD>1})=T2?X(eI2h;*Lk~lw%DZy5$j3JANiDWZe02@i z1es5%<*sNg4GFc>&eUqj*}Un8)R}$Opk5d){1fTa*C_My*a#ko^!(=$d|RRwXAh1} zv!_2jy{PQR8VjL%2)Kmm9bVSh!iQML5tLA zCjWx8P@Kw(VOu6J!eaSQRwyeu;e>zQ6GVGK=^yMbKQ$)0;2eEbW{Sp^HB;Blpd%t8Mp;f zP|f0+f}LjuPh6DKq?i{dqRHqOdy-%B7RnLFo;1>e{ibRMzvL*VJrOK?8kx`hvL@~= zL+?0sZ;`ikwBYk`RwE5TDl0sR*Dz(9q_UsfT(4Sr0aLA-$d#Prb_$LI{F0qUdg)8Z zIV3FX#g;@kjPW<^ire32omB4Vdw+Z9_EY7;T?-(@fB zqby&&fyVy}n%-C3Hwfd(^OfkYJlX~RIT>B;%pwyy7r(p)rgYc?HAf=`Lr$HnCdJfq z9ise|;OMT%t7@tE2lP2qwGsM1 z_9VVYHnxxcU*1>$LplQd0s!p2?bHei{JFmj_IjXz26oy#Vv ztXWbjI@O`=T?}(2pK4(YT#|K43un-LOC{Q;;6jwjj!O@;FaPT!Q>0+;6>@8^^P-%F z2iiXv1e0`J-W3BoQIaBM5+|&DY(f78!Ya&yA|zYrSBM8cUzgmPb3|^a+A;qhu^L08 zQ4#8jT)QA2TG&G?W9jjZNMvER5k=}t_c24{Po}4_#s#?tZxB|{!yS(86^8|1&r<%m zZ_z^A*AwBN`&}o6&f%9fLx|{~YCQ1^NZ-6$^jEFR~~x?szwN?4lLTO=o?N-I1$W)!%HCLWLCO?jE2zY zbgJflcbaxgm|_HUqv$3TaF5?nbNz_Dc)De5TzBtZ}At zHz&73<_2^uB9(QjPd76yBlJ{EG~_N6d@}#tStuDPZSIPiKR!rlb)uJ9v=|x+Q{n#r_w<@YP@VZ$7KQKlf}=OH3EF)IlO9 zukjb2Bl_o_>ympL3NtLI(rgWgl~etN=QR|b4=r5)ta0IBI@2{2X5s_p_L9%i3`}cq zUOOy=&x-Anhz9s={O85?J6L!kN54Q7Qt#u%t{h~pxj&El6qBgh@FfXw07 z=?zTu&+F?<@!mszSp|O~?GIUQc`u@L(^=^44j4yt3g~nk;wwWZ$?U73>LBkQ5uvAh zPTRk|H?#gxb8ia86HlA-6D?=xarRo%)TwY}Tg8lAzP^%Z42cy1YpG;+9;;Rizg1mogS42|}EG029YtwrU^Xy83)rPIQ8rpXC$)CECB;9x~ z4#)3gVK;Rbpp&OIwlXcF5zyfPbqA(-Ut}}sZ=a@lTU1KT8g5fLt>ORMqA{HRS?c=E zo<8JbcmH_GrbBY4u9$?(nWXf3ijeG%VJIZqsxDkdLbBE=@j|lC*?iY{FG&)TU5mci z68RUX)+ry2la!qceMX-lbl$kS7tS85)xRI_qsJqU^8>AR_*0Asw?TOnFHL^(9l{%^ zy~>@iJ@0@-5o`wSO34JNIr&FZ@t2G}wUwVYk?uFzNe0HN&NrP6n0sphYy;L|OW?W)}bq?88Nc$3g z*R$V}b?jIFKM-jEUyTgd6ZfYX$!Nl z&sUGOaL2T}E}Mu4EV_;wDFS^fYlob9w9zY9+V4vwdGI&x{tRSx)Z9qO$KX^N{#@wZ6Qi zXSRskaj9$vWE~#d6Oqh6pK*=`BU?$YfhYVjs{8otnnkvd8 z1j>c@FSYy{64`*^gcz8&lJ(JvLYxHLEP>zB+8BP81|clk)8Q-Fhba?Y%CT2tuE*;L z-R~tv^VMtBocPG-au%_9#9CU_S%eX|!l&U_0l9L~_NE$=G zbX<|M*jFh+4E|a^W_$H|TJ#w-ObZSqcJoIRi(m$gPToRLLRfyKF4)->;fqs3R3*eB z)S4(KR6cnvbr;YsNZ?OrpqdQeDG{+}1L?2Uo`=T5!sRp~DB-K)96R}{DG}8Eg6>%v zEbC(93-61_AYlW*D4j-_K{+!KI&bUH*+D6Y0%NAy2_EINN=Dlgz=7S%g?>%0 z?+Y3@pv^k+P5x4y{S6Xg9ey-QGsADanwiuY3VLWBJ>+NBvD2$CnhWF0jvt@-zZ>7* z`xxJXOaE8ndwxg!_+Z|TQq}*>FcnaUti(3dB~hJKK*>eeN;_W_I!?-4;V|-QM-T8IP4L|_Rxw`=Ae1^4^Hp%} zl8%g3GKW@e88jsg-|ZYldW)mYKeHXK>h3vZJN!5c zx5LA*9YUR>NB6lKF4W7#?S{TAYW13Et9|T-F1;M=hKFD`#1`^T-B~Wtv&A;UA*}W* zl4?)b48vVL(arE6Y=&5S?x}m>8a*4^3)vorwPv2W6)w~B!dCbbz6qIBrIzh6%J%>F zt?)KUJ}$_c1bH2L_(Sg_X!8YUj66yHwMCSFZ4>25>7raX!!6%jAkUTLo85Sikp)pR z8w)**$uHE{|H7$^*S|q(TwG&d{~8PDk;Asaa{5{vd#!ZwA7a6G_1ueJj75GB3r0QC zEnXH4y%tR_)Q%{HbV51C+fs&Hlm@>83$yW0USr`z)|F!Xk>{4kHfG4 z7cZc{=zr}lW`wgMmdcm|dG1I_o-|eaxK59>$dhIOPzn$pTFGTp^0nC5>3F6k{)Q4? z>?=`{SNws%_sYBUvlPegmTByL)I?o=rLxb&xt>$v5D*#g=jJTpVS^2DKsl zv^2wXe%PM5S0Cd`n<E90)Zc!&0AS||BFr#zl>*@M*c=NY{HHG?Ac`;}c0C`p#6InUkegFr)qCEB~og>=_q$wET1(wj_2KTf2Qfs-k(u%MX=H zzK>Zq?~wu&LP6c(p}mp7ZL{>4z=}VhzWV3raS_I&N>1$=N#9fD2G5!Lpw4skM#B5B z{*;voO;X-)EBk4Iu7>7DA~7inz7+jA8&ia@M9p)gYG3<$;R{uDtJ=M(j@xJPmH6ae zz&Q_}^}u%y1Gmqr+QIwr1qsJ?ehH?IRjl}6;ByNN^ngr7IjVSEJQOcXKBX4WNTXE> zwwa}zRw?ibj!RPVYxS{>6y-hY1EMy(@EA!+b6lNfSbffgB*x0VfW%neUzlc42jc9= zht(%mbVb7HSnfPYFP9Q~!Spny$K@z{{}Hub<*(dwotWU!ENZKyc;mo45sz&0)x~Q30RC;ywsfN&c z0Z$9c@jYvFiCQiD`B=SpPahW+|A)Z3`=J3fLb}#VnR(%bNI#2gW07c)s6)E(U;h(Ge^7G@r0?FP%cxJ?U?!l)6Yy>d8nd#XRR0 zRc-Xl)USgi#f=J)#r6zlG~veg_(U|U-KwVkJtiu-lZC1$#=P(0biIY!G-pcKE)%sVwAFUDO5Z=UnLm@U3M&X(*gLL~b@&0PdOa$?6@-mr`zvSlnsAA}lA4xO6}$qV$P z*5oAb<=!(BJml1=zuBH}(=|2fz2KDlo6}z$MeVbc5tBAs>2~hCjxKx;q;jz# zW)w~qN#tLyOCK0p1dt(LuW+QkvLu|Xkq?^jUAfT{an?rTtd#;)EWk=u{F_bNMATW} zSS{1~8`wQ?*T-EE=GO4Y$F%v_!k0_v>E)2hci?~@wc7a{H`GL)w6tn+wKbZH{woNQ z1sWtL>X3}PjIuIFlE!wODsAiIiU~P+bgzpF5fgnqY4hix=t9KFlyHySPcGOZ>faAX ztwgd!@*VWg3ldiIfPZKgh~eoheeDGah`9g#F7~JvQ)-QS>^VGw6=+HZ^Udsb7wDYD;K?F#S8*Qvq#G*EV%O#Pf<%Uaf0Jy|+qmdG0Q36KuRitsL@z$0 zh7@oOqm)zx&kK)DhV*--pbKtMhV}rkDfq$vSi4Q#ZYD_v+ zDcNWRxNM116;GC)vhJ)jJp}-lKxn^75se6FAeR9LfNs^sFOdp2% zy3g9^WRP}hkd7JXpMsy+Oikz~6fSLW(zUJJ!7uN^m-K@BjOwQM7+wOg$;8#0vGPu& z+Bu!^F7%$i1tqqVQ=OCv2D&2VtI=`46{{Z+JR{8z+5o92fZ&HU zJ#NPC2_!HrZ4yX=I=R`&XP<=ZlTREM_>!&1`P^E;?}Q4oTQF7Rvrim%@{>E`Q#n3+ zYcx?rL2_K85$^=x{}(8=gSZ-qGYP&1&c$sO9mhSxW5Q~IpInDUYXMw!{IC=obeLas z6T7lWF=F>`B5ewRbK|4f@6o&kt9DcznC|2cZ-lmowvYf4;W_zhc6%{&C$#>JHWPKM z5x%4qOB}=!Gwl`(e~;m5!2a^pjrhG5zX2-Mb@)|-U+B`j5h{Z24DEz)1BBZld<1gU zPRHu_p(=!f>^5R(Tal9c9HSPYbI5E^#D_JqX5RFwY4$UQ#M@w7MYB4BdL!Bo1w5j7FNc0Z7|g`y`1 zDG6B%dkkx}*nHFsZy~&dtts}Vn}K)}z(E^(!zwfMN6w)8jU=i2OYsIZ2+U zBqehp5!1K}kWvu^$0WFx+oE+^7?L9v$20{XtBuLL)w%2RmBeR%N%G`$CQn9bu`TTj z3*DQ1#qKK5StN5}sq$;PBIKwN{vU&kpF=;@)$bu|aCjpmG(+hjOIYbWxQ>|X%b`tB z(>nNG69=U=fKU*h8}yslf{o7$gJCg-)@Ox6v#$8lOlb_=>L3OP$crQ?jz1S{Tp z5_mG=+K8?#|2UJco|AlaX2EfYuUb!ru8kbZz`0`d019le=M2&YMCIe~9;V+#YD;pS zD9=JwK)XEaROFO?4msx`a?YTG_EvVCAg>nzG2?0E^1m>|97+9#8UF$o_2mA9d`)zX zl&>dkh(?LzeLV}kjPDQbx5=%57f1s$01+j5TQHP?+MoC$Yk{^c6IQ|E{1Or-^3~|2 zy%@Ebe}X^>U%dgMOZn<`@H3Sm*tAeJ7sJDPLLm_*9j_(tr0z{=V3#`D(l579qgA~J! zw@jy^^8voQZ1AL49jrJa(zS7~+{kKKN9yNp*#O%_pJT}Q4`TrC zs6zlQi|+VgQ38jw$5nQcdY?nRuSaR{uO+#Tp587}rd65484V^w!#EE98{xkxf>3um zzVnRytjwU>#yr#nY-=s9+m}qVZiyh});MaP4mOw~P#pdnBUn8Axm$i1HixHS4Bk_D zt^YKPk>r*R6+1~HwFMQZW%OYz*Rc!TggLqGE$wKElx@icBxTwua>r$0skHs~Ew)fn znv8UBp7NoQabvC8Zw>td%9#LF0UdD+8t#dXA3T#|3kn8p{=6TnZpf=t%r@A|eh1xc z)bv*@>SuqT#WUg#h~kGGnY$1;n(HC__yX)lK7>MZ@CgI1mvDO2OnauMjGiW~2*=ZV zTRC3;0$rWb%v2bniLk<^bn@97;%JvfHZ7>}DsLuI;f8}7?6%_-`>)70j=cv>kD$qU z0em`^sD4IYR6qHOHDQiQaE>HoNnrbsH^USa0DFuEpb3*x{YQ=Pqn3ow5usr zJcKWAmCCvyt4R%LS+jtpdrVa3X#Vt_%A*mtoNssGfvN4)4qT+0@EvBk9vEVVn$7iH z5w0F0zl}zHicxh@#%~-y(7ZP~jqoMzHM`|DeAHVSWwv|Y2G|!E_$3ugmpvQR@bwcn zy4y9dLoW(k(nFb$316Z@U0+Et1NV|U5npS|%mD^87hQ(uH0bwwbl=AhU8`C{#9hG0 zox0C#Gf=!c*Q#URj^{fDrrU|iO|z#1R#-h&$4tAe;y~5GC!P!M_0@5rBkZ}rQEInT z9IM(f?+~8El^GFw?nJSh!Yy=Zk4Sx7Ofy6|j10#9=qp`sh*2Tvjw&;r6eLMGmMDpe-nwJ%e0dRU>`sRy^Lq#ft~Z%^BtnS zz%vG8s33aW0l;P(DmJ6`aX#YXNVhWjw`kD2ycoaA&)`n^u#;bY(p45=*Nm+#NFWGGE%$sDRy5xJ*cE1LW`asgk;tuNU?xgiUQf9{6O1>Kmd}S4t>6U-;&4=Us zlfL;@gU3_gCo>2-@U6k#1`paq|4bx+?c{h#?(ogGaq|ZU#-;l@)8=0}SCDHYWsoNw zm2S+>NL=&vkv2&gG46~6A;ynz*bJ|S__Dlqk35N0J6)m~i#2o+nukP7u14|PD!t$vR1Qhr-91(VD-T2t^<_g3 z7>SCKzSrcGF^~@U*`(FP)!>V`OYQsWrpK;Is2x?}6?9nuZ@$!c;pZE`DS zN#IwE^zGxPJ38iWpDxI@@Yk`~{dG6ZZjCnl;2xu|%fv4!N7p%sE8%lcN)xydQg5^d zcN-lo{E}Z&)n|+}51hM4pWlH!5F`4h4eW(qjI?58gd#@|46nv_$$Yi87&x!F{DJj=>Sz$YaT+`8t3ISW5eNxY{ z26Loij(;TP=#4)+PDwd>0FYE;E@9{=4Bdg|$OFyn zZC}~Uv`3i;!L3{w;?oS_*+8N?`z4Sl$FiCC2x|_~%i( z@It@%x&i)k@ZZ=Vz79;SG7dKTOgmq>nB1e)VRz?-fU9toiB$$Srvd?Wm2Jh+=fszW z2=N>YnczHa46lH>v`&$mrU%tC_!Tv=qquF*xG_Xj*3rowYT#D{<=S9ZKi{5s(8xukE5ZQ35S#Y|*!y>)7UZzitW@;<1NcVV)w_P7m&f_BLwyQ8g}Q(`aH` zo1rp#SuVx5=Z5(7QJq#jol9&gW!Y$r=heXzLg#z2rmRU#eG}IdU;VXj4CGcUsC*R)&p<_(aI!#_p?gUGt%%&)XZ;c38FaS@TX1+i$3MWYNS z<$+k$aXs)RS2{MX2Rh0{M_1URjc�@#@GlBp;JgY(LZIb65e`Rt&`Lu#&x2R&vWv zv6AEs43f*wG^)F_^y*kT7fUy*pK0kY|J2uz{&X^~lP_plANuKMhBXUHko=y9*XN=Wd{m^OtNo1?|%A5M3Mi?*vl_G`G)8=1|j{Hoe zc02sH!T)q$x2<9%dDwp1lt4#5djUv~wI7k5p@~UvVbW22C<8hfnQM#8wM4E{pI*f5 zb$x5HT!GPc^>sJ^3P3-BS2KH3e4YKh!+;acP2pdxfnR$+@5ss;Pd?t{qG)8L-F%iaR(OXyjN3kyle^MNix^$#fu`l*-P2X zUc4wuH+#>ZY~&tzGzHns(gA#hHIqylv*DqZBZZQ7H%m9O5Ex>c07ZTca#2R5_ZS!i^Q z?@%I#bre1C^2@hywNlwebRGl{Jeh;?NMo4WYwM>yeg@&I}TKuW+Xs1w4b6Tt0G zF@B8kR{)+kWqgG=Q{EO@?#@YNNjRg~(sr*DeD*@Ca`668*;+BPw#7H|{q5?Tbg znW}6P;G~h$$XCxql_V8&WrBl>URFvjA)$>^VA5^&imk3}2}{F0C8I%oM; zTu>@oTcn7JIesH2<^MWl4WTUycl0wn)-6224tHM(emJTeh0;)6Qh6qFj}~tN-caI1 zZf#sy_&$B%y5z#fq{2pICpTf|QO2O$6cHUq`6ZXpJA){SmRpjlJ{dPIfuCH%bijXR zV0~9W1B)wvx{;l>bloYXPZ?UmkZ$XV4rxnbwJyc2;Q4zajH(!o40MBwdcgVI8hkO= z$pwX#ShK(yaPl`diT>2&?y-6pzez?=S~aYLx4`gPSa~?KHVJ+gmo#y#JR2UYxn{f` z+k$^KLsafMtizaGhmo*QRD_7&fT_es(wy{|J1}rg#}R(Xoe&d4OyK_!a4k4AH1kLm z^`XVrntDpds1&e8xoi6#NgNS?_4^TJ57NPfuf8cZGngF~PpBSWVe~a{KBPZR2h3AN z0Z{`YT~!+^_UNlRS0)*?ZOHrAFc}_~pN5`-?Is{F@IM`Pmh8~yP+t-7&vHb)@+BgB zKPwZ<67bz44^pUU_Nf4_X%UZohW=l@a{<%nfGvWwI`Ao2S6L4+&`Xw(SQSW$68Pq{nA^{Gi|nihyyB zM&8{iIMzY9MQ{L0x`W{sI37E>9>+F(l&j*HE{sE*J>n{>FH$lWF{OqNVa;P>d?oIY z3nMK24+C9BeUEE(H`)Hs%`$xLXQ~1S#+(h>HBkpMiNj}kojJ{PQ6%U$MOJ*rTMYbD!;sd={NgI#ts265mna-|yeWR|kV_HaWG$p6>?Sg3EGH)ddzZIiP z)$_DMNB6NplCO?)E4df2)b3uEx{0N>j)Rk3u2KD7i~fW~Yd!z?WD?Y|Q>(PBztw8c zdcX7}seRtok+3w&7xld~LsL)oC2n#DhE=um{;z4L=@#T4<;_J^2l>i6^Ln{Kb0*GamSOGK32hrc278A7OWk$;pAS zIHVMhFp!&uwQ*LjgFf7ggPTH9i{dNNP-q>A7x&Rhx#0@BNDT7Tr~|1ZH%q%*OVi~! zf*&7SPb8_Zga0Hb>DO`_Pwl`paUIw+^fVp#Z0PAb@XpXaI>0Y~)S`$Z3`nP>z_}

f|a2KS_-HlsKN!muL=vRGsYecXFWF9&GV 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 z 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%0Dll{7859 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ΜotEy?0xQ_9(PN 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�tfm@6?N1BVbTS`y1d+YBEUi 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

Y6;jIJ$|Ec6yXew*A!aKHH+c*=j*9N*b~t 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 z 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�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 literal 0 HcmV?d00001 diff --git a/raylib-src/raylib-5.0_linux_amd64/CHANGELOG b/raylib-src/raylib-5.0_linux_amd64/CHANGELOG new file mode 100644 index 0000000..77df794 --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/CHANGELOG @@ -0,0 +1,2128 @@ +changelog +--------- + +Current Release: raylib 5.0 (18 November 2023) + +------------------------------------------------------------------------- +Release: raylib 5.0 - 10th Anniversary Edition (18 November 2023) +------------------------------------------------------------------------- +KEY CHANGES: + - REDESIGNED: rcore module platform-split, by @ubkp, @michaelfiber, @Bigfoot71, @raysan5 + - ADDED: New platform backend supported: SDL + - ADDED: New platform backend supported: Nintendo Switch (closed source) + - ADDED: New Splines drawing and evaluation API + - ADDED: New pseudo-random numbers generator: rprand + - ADDED: Automation Events System API + - UPDATED: raygui 4.0: New version of this immediate-mode gui system for tools development with raylib + +Detailed changes: +[rcore] ADDED: RAYLIB_VERSION_* values to raylib.h (#2856) by @RobLoach +[rcore] ADDED: IsKeyPressedRepeat() on PLATFORM_DESKTOP (#3245) by @actondev +[rcore] ADDED: SetWindowTitle() for PLATFORM_WEB (#3222) by @VitusVeit +[rcore] ADDED: FLAG_WINDOW_RESIZABLE for web (#3305) by @Peter0x44 +[rcore] ADDED: SetWindowMaxSize() for desktop and web (#3309) by @ubkp +[rcore] ADDED: SetMouseCursor() for PLATFORM_WEB (#3414) by @BeardedBread +[rcore] ADDED: LoadRandomSequence()/UnloadRandomSequence() by @raysan5 +[rcore] REMOVED: PLATFORM_RPI (#3232) by @michaelfiber +[rcore] REVIEWED: GetFileLength(), added comment (#3262) by @raysan5 +[rcore] REVIEWED: Default shaders precission issue on PLATFORM_WEB (#3261) by @branc116 +[rcore] REVIEWED: IsKey*() key validation checks (#3256) by @n77y +[rcore] REVIEWED: SetClipboardText() for PLATFORM_WEB (#3257) by @ubkp +[rcore] REVIEWED: Check if Ctrl modifier is among the currently set modifiers (#3230) by @mohad12211 +[rcore] REVIEWED: Android app black screen when reopening by @Bigfoot71 +[rcore] REVIEWED: Warnings when casting int to floats (#3218) by @JeffM2501 +[rcore] REVIEWED: GetCurrentMonitor() detection inconsistency issue (#3215) by @ubkp +[rcore] REVIEWED: SetWindowMonitor() to no longer force fullscreen (#3209) by @ubkp +[rcore] REVIEWED: Fix mouse wheel not working in PLATFORM_RPI or PLATFORM_DRM (#3193) by @ubkp +[rcore] REVIEWED: GetMonitorName() description (#3184) (#3189) by @danilwhale +[rcore] REVIEWED: BeginScissorMode(), identify rendering to texture (#3510) by @gulrak +[rcore] REVIEWED: Window flags order (#3114) by @lesleyrs +[rcore] REVIEWED: Full movement for right analog stick (#3095) by @PixelPhobicGames +[rcore] REVIEWED: Fix Android app freeze after calling CloseWindow() (#3067) by @Bigfoot71 +[rcore] REVIEWED: Lazy loading of default font used on image drawing (no InitWindow) by @raysan5 +[rcore] REVIEWED: Minor tweaks to raylib events automation system @raysan5 +[rcore] REVIEWED: GetCurrentMonitor() bugfix (#3058) by @hamyyy +[rcore] REVIEWED: Update CORE.Input.Touch.pointCount (#3024) by @raysan5 +[rcore] REVIEWED: Mouse offset and scaling must be considered also on web! +[rcore] REVIEWED: CompressData(), possible stack overflow +[rcore] REVIEWED: GetWorldToScreenEx() (#3351) by @Brian-ED +[rcore] REVIEWED: Fix GetMouseDelta() issue for Android (#3404) by @Bigfoot71 +[rcore] REVIEWED: GetFPS(), reset FPS averages when window is inited (#3445) by @JeffM2501 +[rcore] REVIEWED: GetCurrentMonitor(), check window center position by @M374LX +[rcore] REVIEWED: GetRender*() issue on macOS highDPI (#3367) by @raysan5 +[rcore] REVIEWED: ScanDirectoryFiles*(), paths building slashes sides (#3507) +[rlgl] ADDED: Experimental support for OpenGL ES 3.0 by @raysan5 +[rlgl] ADDED: Support 16-Bit HDR textures (#3220) by @Not-Nik +[rlgl] ADDED: rlEnablePointMode() (#3490) by @JettMonstersGoBoom +[rlgl] ADDED: rlBlitFramebuffer(), required for deferred render +[rlgl] REVIEWED: LoadModel(), removed cube fallback mechanism (#3459) +[rlgl] REVIEWED: Improved support for ES3/WebGL2 (#3107) by @chemaguerra +[rlgl] REVIEWED: OpenGL 2.1 half floats support as part of an extension by @Not-Nik +[rlgl] REVIEWED: Avoid shader attribute not found log by @raysan5 +[rlgl] REVIEWED: Avoid tracelog about not found uniforms (#3003) by @raysan5 +[rlgl] REVIEWED: rLoadTexture() UBSAN complaints #1891 (#3321) by @Codom +[rlgl] REVIEWED: glInternalFormat as unsigned int +[rlgl] REVIEWED: OpenGL ES 3.0 support +[rshapes] ADDED: Spline drawing functions by @raysan5 +[rshapes] ADDED: GetSplinePoint*() functions for spline evaluation by @raysan5 +[rshapes] ADDED: DrawCircleLinesV() for consistency (#3452) by @Peter0x44 +[rshapes] REVIEWED: DrawSplineCatmullRom() by @raysan5 +[rshapes] REVIEWED: Minor fix in DrawLineBezier* (#3006) by @eternalStudent +[rshapes] REVIEWED: GetCollisionRec(), more performant (#3052) by @manuel5975p +[rshapes] REVIEWED: Fix off-by-one error in CheckCollisionPointRec() (#3022) by @dbechrd +[rtextures] ADDED: Basic SVG loading support (#2738) by @bXi +[rtextures] ADDED: Support 16-Bit HDR textures (#3220) by @Not-Nik +[rtextures] ADDED: ExportImageToMemory() by @raysan5 +[rtextures] ADDED: ImageRotate() (#3078) by @danemadsen +[rtextures] ADDED: GenImageGradientSquare() (#3077) by @danemadsen +[rtextures] ADDED: GenImageLinearGradient() by @danemadsen +[rtextures] REMOVED: GenImageGradientH() and GenImageGradientV() by @danemadsen +[rtextures] REVIEWED: LoadImageSvg() by @raysan5 +[rtextures] REVIEWED: Uninitialized thread-locals in stbi (#3282) (#3283) by @jbarthelmes +[rtextures] REVIEWED: ImageDrawRectangleRec(), validate drawing inside bounds by @JeffM2501 +[rtextures] REVIEWED: LoadTextureCubemap() for manual layouts (#3204) by @Not-Nik +[rtextures] REVIEWED: Optimization of ImageDrawRectangleRec() (#3185) by @smalltimewizard +[rtextures] REVIEWED: ImageRotate() formatting by @raysan5 +[rtextures] REVIEWED: GenImagePerlinNoise(), clamp values (#3071) by @raysan5 +[rtextures] REVIEWED: Packing logic error in GenImageFontAtlas() (#2979) by @hanaxar +[rtextures] REVIEWED: Calculate exact image size in GenImageFontAtlas() (#2963) by @hanaxar +[rtextures] REVIEWED: ImageDrawRectangleRec() (#3027) by @raysan5 +[rtextures] REVIEWED: ImageDraw() source clipping when drawing beyond top left (#3306) by @RobLoach +[rtextures] REVIEWED: UnloadRenderTexture(), additional checks +[rtextures] REVIEWED: Fixed compressed DDS texture loading issues (#3483) by @JaanDev +[rtext] ADDED: Font altas white rectangle and flag SUPPORT_FONT_ATLAS_WHITE_REC by @raysan5 +[rtext] ADDED: SetTextLineSpacing() to define line breaks text drawing spacing by @raysan5 +[rtext] RENAMED: LoadFont*() parameter names for consistency and coherence by @raysan5 +[rtext] REVIEWED: GetCodepointCount(), ignore unused return value of GetCodepointNext by @ashn-dot-dev +[rtext] REVIEWED: TextFormat() warn user if buffer overflow occured (#3399) by @Murlocohol +[rtext] REVIEWED: TextFormat(), added "..." for truncation (#3366) by @raysan5 +[rtext] REVIEWED: GetGlyphIndex() (#3000) by @raysan5 +[rtext] REVIEWED: GetCodepointNext() to return default value by @chocolate42 +[rtext] REVIEWED: TextToPascal() issue when first char is uppercase +[rmodels] ADDED: ModelAnimation.name field, initially with GLTF animation names by @alfredbaudisch +[rmodels] REDESIGNED: LoadOBJ(), avoid mesh splitting by materials, fix (#3398) by @raysan5 +[rmodels] REVIEWED: Support .vox model files version 200 (#3097) by @Bigfoot71 +[rmodels] REVIEWED: Materials loading (#3126) @raysan5 +[rmodels] REVIEWED: DrawBillboardPro() to allow source of negative size (#3197) by @bohonghuang +[rmodels] REVIEWED: glTF loading segfault in animNormals memcpy by @charles-l +[rmodels] REVIEWED: LoadModelAnimationsGLTF(), free fileData after use (#3065) by @crynux +[rmodels] REVIEWED: GenMeshCubicmap(), correction of values (#3032) by @Bigfoot71 +[rmodels] REVIEWED: DrawMesh() to avoid UBSAN complaining (#1891) +[rmodels] REVIEWED: GenMeshPlane() when resX != resZ (#3425) by @neyrox, @s-yablonskiy +[rmodels] REVIEWED: GetModelBoundingBox() (#3485) +[raudio] ADDED: LoadSoundAlias() by @JeffM2501 +[raudio] ADDED: Missing structure on standalone mode (#3160) by @raysan5 +[raudio] ADDED: GetMasterVolume() (#3434) by @rexim +[raudio] REVIEWED: Comments about sample format to AttachAudioStreamProcessor() (#3188) by @AlbertoGP +[raudio] REVIEWED: Documented buffer format for audio processors (#3186) by @AlbertoGP +[raudio] REVIEWED: ExportWaveAsCode() file saving by @RadsammyT +[raudio] REVIEWED: Fix warning on discarded const qualifier (#2967) by @RobLoach +[raudio] REVIEWED: Move mutex initialization before ma_device_start() (#3325) by @Bigfoot71 +[raudio] REVIEWED: Fix UpdateSound() parameter name (#3405) by @KislyjKisel +[raudio] REVIEWED: Fix QOA seeking (#3494) by @veins1 +[rcamera] REVIEWED: File-macros for consistency (#3161) by @raysan5 +[rcamera] REVIEWED: Support analog stick camera controls (#3066) by @PixelPhobicGames +[rcamera] REVIEWED: CameraMoveToTarget(), ensure distance is greater than 0 (#3031) by @kolunmi +[rcamera] REVIEWED: Exposing rcamera functions to the dll (#3355) by @JeffM2501 +[raymath] ADDED: Vector3Projection() and Vector3Rejection() (#3263) by @Dial0 +[raymath] ADDED: EPSILON macro to each function requiring it (#3330) by @Brian-ED +[raymath] REVIEWED: Usage of 'sinf()' and 'cosf()' to be correct (#3181) by @RokasPuzonas +[raymath] REVIEWED: Slightly optimized Vector3Normalize() (#2982) by @RicoP +[raymath] REVIEWED: Comment to clarify raymath semantics by @raysan5 +[raymath] REVIEWED: Comment about Matrix conventions by @raysan5 +[raymath] REVIEWED: Vector2Angle() and Vector2LineAngle() (#3396) by @Murlocohol +[rgestures] REVIEWED: Optimize and simplify the gesture system (#3190) by @ubkp +[rgestures] REVIEWED: GESTURE_DRAG and GESTURE_SWIPE_* issues (mostly) for web (#3183) by @ubkp +[rgestures] REVIEWED: Touch pointCount for web (#3163) by @ubkp +[rgestures] REVIEWED: IsGestureDetected() parameter type +[utils] ADDED: Security checks to file reading (memory allocations) by @raysan5 +[utils] REVIEWED: LoadFileData() potential issues with dataSize +[examples] ADDED: shaders_lightmap (#3043) by @nullstare +[examples] ADDED: core_2d_camera_split_screen (#3298) by @gabrielssanches +[examples] ADDED: LoadSoundAlias() usage example (#3223) by @JeffM2501 +[examples] ADDED: textures_tiling (#3353) by @luis605 +[examples] ADDED: shader_deferred_render (#3496) by @27justin +[examples] RENAMED: 2d_camera examples for consistency +[examples] REVIEWED: Text examples SetTextLineSpacing() to multiline examples by @raysan5 +[examples] REVIEWED: examples/shapes/shapes_collision_area.c help instructions (#3279) by @asdqwe +[examples] REVIEWED: examples/shaders/shaders_texture_outline.c help instructions (#3278) by @asdqwe +[examples] REVIEWED: examples/others/easings_testbed.c help instructions and small twe… by @asdqwe +[examples] REVIEWED: example/audio/audio_module_player.c help instructions and small b… by @asdqwe +[examples] REVIEWED: example/models/models_loading_m3d.c controls (#3269) by @asdqwe +[examples] REVIEWED: example/models/models_loading_gltf.c controls (#3268) by @asdqwe +[examples] REVIEWED: text_unicode.c example crashing (#3250) by @ubkp +[examples] REVIEWED: rlgl_standalone.c compilation issue (#3242) by @ubkp +[examples] REVIEWED: core_input_gestures for Web (#3172) by @ubkp +[examples] REVIEWED: core_input_gamepad (#3110) by @iacore +[examples] REVIEWED: examples using raygui to raygui 4.0 by @raysan5 +[examples] REVIEWED: Julia set shader example (#3467) by @joshcol9232 +[build] ADDED: CMake option for SUPPORT_CUSTOM_FRAME_CONTROL (#3221) by @ubkp +[build] ADDED: New BORDERLESS_WINDOWED_MODE for PLATFORM_DESKTOP (#3216) by @ubkp +[build] ADDED: New examples to VS2022 solution by @raysan5 +[build] REVIEWED: Updated Makefile and Makefile.Web, include new examples +[build] REVIEWED: Fix CMake extraneous -lglfw (#3266) by @iacore +[build] REVIEWED: Add missing cmake options (#3267) by @asdqwe +[build] REVIEWED: Match CMakeOptions.txt options default values (#3258) by @asdqwe +[build] REVIEWED: Add build.zig options for individual modules (#3254) by @actondev +[build] REVIEWED: build.zig to work with cross-compiling (#3225) by @yujiri8 +[build] REVIEWED: Makefile build on PLATFORM_ANDROID, soname (#3211) by @ndytts +[build] REVIEWED: src/Makefile, fix misleading indentation (#3202) by @ashn-dot-dev +[build] REVIEWED: build.zig: Support for building with PLAFORM_DRM (#3191) by @jakubvf +[build] REVIEWED: Update CMakeOptions.txt by @raysan5 +[build] REVIEWED: fix: cmake option "OPENGL_VERSION" doesn't work (#3170) by @royqh1979 +[build] REVIEWED: Add error if raylib.h is included in a C++98 program (#3093) by @Peter0x44 +[build] REVIEWED: Cross compilation for PLATFORM_DRM (#3091) by @TheLastBilly +[build] REVIEWED: build.zigm fixed cross-compiling from Linux (#3090)by @yujiri8 +[build] REVIEWED: Enhanced cmake part for OpenBSD (#3086) by @rayit +[build] REVIEWED: Fixed compile on OpenBSD (#3085)by @rayit +[build] REVIEWED: CMake project example: fix a couple of typos (#3014) by @benjamin-thomas +[build] REVIEWED: Fix warnings in raylib for MSVC (#3004) by @JeffM2501 +[build] REVIEWED: Update cmake example project (#3062) by @lesleyrs +[build] REVIEWED: Update build.zig be be able to build with current zig master (#3064) by @ryupold +[build] REVIEWED: VSCode project template (#3048) by @Shoozza +[build] REVIEWED: Fixed broken build.zig files. Now works with latest stable compiler (… by @Gamer-Kold +[build] REVIEWED: Fix missing symbol when rglfw.c on BSD platforms (#2968) by @Koromix +[build] REVIEWED: Update Makefile comment to indicate arm64 as a supported Linux deskto… @ashn-dot-dev +[build] REVIEWED: Update Makefile : clean raygui.c & physac.c (#3296) by @SuperUserNameMan +[build] REVIEWED: Update webassembly.yml and linux.yml +[build] REVIEWED: Update zig build system to zig version 0.11.0 (#3393) by @purple4pur +[build] REVIEWED: Fix for latest zig master (#3037) by @star-tek-mb +[build] REVIEWED: Examples Makefile to use Makefile.Web when building for web (#3449) by @keithstellyes +[build] REVIEWED: build.zig updates for 0.11.0 release. (#3501) by @cabarger +[build] REVIEWED: Support OpenGL ES 3.0 building on Web platform +[build] REVIEWED: Fix warnings in Visual Studio (#3512) by @JeffM2501 +[build] REVIEWED: OpenGL ES 3.0 flags on CMakeOptions (#3514) by @awfulcooking +[bindings] ADDED: fortran-raylib +[bindings] ADDED: raylib-raku to bindings (#3299) by @vushu +[bindings] ADDED: claw-raylib to BINDINGS.md (#3310) by @bohonghuang +[bindings] ADDED: vaiorabbit/raylib-bindings (#3318) by @wilsonsilva +[bindings] ADDED: TurboRaylib (#3317) by @turborium +[bindings] ADDED: raylib-ffi to bindings list (#3164) by @ewpratten +[bindings] ADDED: raylib-pkpy-bindings (#3361) by @blueloveTH +[bindings] ADDED: Raylib.lean to BINDINGS.md (#3409) by @KislyjKisel +[bindings] UPDATED: BINDINGS.md (#3217) by @joseph-montanez +[bindings] UPDATED: BINDINGS.md to include rayjs (#3212) by @mode777 +[bindings] UPDATED: latest h-raylib version (#3166) by @Anut-py +[bindings] UPDATED: bindbd-raylib3 to raylib 4.5 (#3157) by @o3o +[bindings] UPDATED: Janet bindings supported version update (#3083)by @archydragon +[bindings] UPDATED: BINDINGS.md (raylib-py -> 4.5) (#2992) by @overdev +[bindings] UPDATED: BINDINGS.md (raylib-lua -> 4.5) (#2989) by @TSnake41 +[bindings] UPDATED: raylib-d binding version to 4.5 (#2988) by @schveiguy +[bindings] UPDATED: raylib-freebasic to 4.5 (#2986) by @WIITD +[bindings] UPDATED: BINDINGS.md (#2983) by @jarroddavis68 +[bindings] UPDATED: BINDINGS.md for raylib Odin 4.5 (#2981) by @gingerBill +[bindings] UPDATED: BINDINGS.md (#2980) by @GuvaCode +[bindings] UPDATED: BINDINGS.md (#3002) by @fubark +[bindings] UPDATED: BINDINGS.md (#3053) by @JupiterRider +[bindings] UPDATED: BINDINGS.md (#3050) by @Its-Kenta +[bindings] UPDATED: CL bindings version (#3049) by @shelvick +[bindings] UPDATED: BINDINGS.md (#3026) by @ChrisDill +[bindings] UPDATED: BINDINGS.md (#3023) by @sDos280 +[bindings] UPDATED: BINDINGS.md (#3017) by @Soutaisei +[bindings] UPDATED: Various versions to 4.5 (#2974) by @RobLoach +[bindings] UPDATED: raylib.zig version to 4.5 (#2971) by @ryupold +[bindings] UPDATED: h-raylib version (#2970) by @Anut-py +[bindings] UPDATED: Factor's raylib binding to v4.5 (#3350) by @WraithGlade +[bindings] UPDATED: raylib-ocaml bindings to 4.5 version (#3322) by @tjammer +[bindings] UPDATED: Jaylib binding (#3508) by @glowiak +[external] UPDATED: sdefl and sinfl DEFLATE compression libraries by @raysan5 +[external] UPDATED: miniaudio v0.11.12 --> v0.11.19 by @raysan5 +[external] UPDATED: rl_gputex.h compressed images loading library by @raysan5 +[external] UPDATED: Replaced stb_image_resize.c by stb_image_resize2.h (#3403) by @BabakSamimi +[external] UPDATED: qoi and qoa libraries +[external] UPDATED: stb libraries (required ones) +[external] UPDATED: cgltf and m3d libraries +[external] REVIEWED: msf_gif.h, some warnings +[external] REVIEWED: sinfl external library to avoid ASAN complaints (#3349) by @raysan5 +[misc] ADDED: New task point to issue template about checking the wiki (#3169) by @ubkp +[misc] ADDED: CodeQL for static code analysis (#3476) by @b4yuan +[misc] REVIEWED: Update FAQ.md by @raysan5 +[misc] REVIEWED: Potential code issues reported by CodeQL (#3476) +[misc] REVIEWED: Fix a link in the FAQ (#3082)by @jasonliang-dev +[misc] REVIEWED: New file formats to FAQ (#3079) by @Luramoth +[misc] REVIEWED: Make assets loading extension case insensitive #3008 by @raysan5 +[misc] REVIEWED: Updated web shells open-graph info by @raysan5 + +------------------------------------------------------------------------- +Release: raylib 4.5 (18 March 2023) +------------------------------------------------------------------------- +KEY CHANGES: + - ADDED: Improved ANGLE support on Desktop platforms + - ADDED: rcamera module, simpler and more extendable + - ADDED: Support for M3D models and M3D/GLTF animations + - ADDED: Support QOA audio format (import/export) + - ADDED: rl_gputex module for compressed textures loading + - REDESIGNED: rlgl module for automatic render-batch limits checking + - REDESIGNED: rshapes module to minimize the rlgl dependency + +Detailed changes: +[core] ADDED: RAYLIB_VERSION_* values to raylib.h (#2856) by @RobLoach +[core] ADDED: Basic gamepad support for Android (#2709) by @deniska +[core] ADDED: Support CAPS/NUM lock keys registering if locked +[core] ADDED: _GNU_SOURCE define on Linux (#2729) +[core] ADDED: SetWindowIcons() to set multiple icon image sizes +[core] `WARNING`: RENAMED: Exported raylib version symbol to raylib_version #2671 +[core] REMOVED: Touch points on touch up events on Android (#2711) by @deniska +[core] REVIEWED: Window position setup on InitWindow() (#2732) by @RandomErrorMessage +[core] REVIEWED: Touchscreen input related functions on Android (#2702) by @deniska +[core] REVIEWED: Viewport scaling on Android after context rebind (#2703) by @deniska +[core] REVIEWED: ScanDirectoryFilesRecursively() (#2704) +[core] REVIEWED: Gamepad mappings with latest gamecontrollerdb (#2725) +[core] REVIEWED: Monitor order check on app initialization +[core] REVIEWED: Application monitor when opening (#2728, #2731) by @RandomErrorMessage +[core] REVIEWED: Gestures module to use GetTime() if available (#2733) by @RobLoach +[core] REVIEWED: Resolve GLFW3 some symbols re-definition of windows.h in glfw3native (#2643) by @daipom +[core] REVIEWED: OpenURL(), string buffer too short sometimes +[core] REVIEWED: GetRandomValue() range limit warning (#2800) by @Pere001 +[core] REVIEWED: UnloadDirectoryFiles() +[core] REVIEWED: GetKeyPressed(), out of range issue (#2814) by @daipom +[core] REVIEWED: GetTime(), renamed variable 'time' to 'nanoSeconds' (#2816) by @jtainer +[core] REVIEWED: LoadShaderFromMemory(), issue with shader linkage +[core] REVIEWED: Avoid possible gamepad index as -1 (#2839) +[core] REVIEWED: SetShaderValue*(), avoid setup uniforms for invalid locations +[core] REVIEWED: GetClipboardText() on PLATFORM_WEB, permissions issues +[core] REVIEWED: Initial window position for display-sized fullscreen (#2742) by @daipom +[core] REVIEWED: Sticky touches input (#2857) by @ImazighenGhost +[core] REVIEWED: Enable GetWindowHandle() on macOS (#2915) by @Not-Nik +[core] REVIEWED: Window position always inits centered in current monitor +[core] REVIEWED: IsWindowFocused() to consider Android App state (#2935) +[core] REVIEWED: GetMonitorWidth() and GetMonitorHeight() (#2934) +[core] REVIEWED: GetWindowHandle() to return Linux window (#2938) +[core] REVIEWED: WindowDropCallback(), additional security check (#2943) +[core] REVIEWED: Security checks for emscripten_run_script() (#2954) +[utils] REVIEWED: TraceLog() message size limit overflow +[rcamera] REDESIGNED: New implementation from scratch (#2563) by @Crydsch +[rcamera] REVIEWED: Make orbital camera work as expected (#2926) by @JeffM2501 +[rcamera] REVIEWED: Multiple reviews on the new implementation +[rcamera] ADDED: UpdateCameraPro(), supporting custom user inputs +[rlgl] ADDED: OpenGL ES 2.0 support on PLATFORM_DESKTOP (#2840) by @wtnbgo +[rlgl] ADDED: Separate blending modes for color and alpha, BLEND_CUSTOM_SEPARATE (#2741) +[rlgl] ADDED: rlSetBlendFactorsSeparate and custom blend mode modification checks (#2741) by @pure01fx +[rlgl] ADDED: RL_TEXTURE_MIPMAP_BIAS_RATIO support to `rlTextureParameters()` for OpenGL 3.3 #2674 +[rlgl] ADDED: rlCubemapParameters() (#2862) by @GithubPrankster +[rlgl] ADDED: rlSetCullFace() (#2797) by @jtainer +[rlgl] REMOVED: Mipmaps software generation for OpenGL 1.1 +[rlgl] REVIEWED: Check for extensions before enabling them (#2706) by @Not-Nik +[rlgl] REVIEWED: SSBO usage to avoid long long data types +[rlgl] REVIEWED: Enable DXT compression on __APPLE__ targets (#2694) by @Not-Nik +[rlgl] REVIEWED: enums exposed and description comments +[rlgl] REVIEWED: rlBindImageTexture(), correct data types (#2808) by @planetis-m +[rlgl] REVIEWED: rlMultMatrixf(), use const pointer (#2807) by @planetis-m +[rlgl] REVIEWED: Expose OpenGL blending mode factors and functions/equations +[rlgl] REVIEWED: rLoadTextureDepth(), issue with depth textures on WebGL (#2824) +[rlgl] REVIEWED: rlUnloadFramebuffer() (#2937) +[raymath] ADDED: Vector2LineAngle() (#2887) +[raymath] REVIEWED: Vector2Angle() (#2829, #2832) by @AlxHnr, @planetis-m +[shapes] ADDED: CheckCollisionPointPoly() (#2685) by @acejacek +[shapes] REVIEWED: DrawPixel*(), use RL_QUADS/RL_TRIANGLES (#2750) by @hatkidchan +[shapes] REVIEWED: DrawLineBezier*(), fix bezier line breaking (#2735, #2767) by @nobytesgiven +[textures] ADDED: ColorBrightness() +[textures] ADDED: ColorTint() +[textures] ADDED: ColorContrast() +[textures] ADDED: Support for PNM images (.ppm, .pgm) +[textures] ADDED: GenImagePerlinNoise() +[textures] ADDED: GenImageText(), generate grayscale image from text byte data +[textures] ADDED: ImageDrawCircleLines(), ImageDrawCircleLinesV() (#2713) by @RobLoach +[textures] ADDED: ImageBlurGaussian() (#2770) by @nobytesgiven +[textures] REVIEWED: Image fileformat support: PIC, PNM +[textures] REVIEWED: ImageTextEx() and ImageDrawTextEx() scaling (#2756) by @hatkidchan +[textures] `WARNING`: REMOVED: DrawTextureQuad() +[textures] `WARNING`: REMOVED: DrawTexturePoly(), function moved to example: `textures_polygon` +[textures] `WARNING`: REMOVED: DrawTextureTiled(),function implementation moved to the textures_tiled.c +[text] ADDED: GetCodepointPrevious() +[text] ADDED: UnloadUTF8(), aligned with LoadUTF8() +[text] `WARNING`: RENAMED: TextCodepointsToUTF8() to LoadUTF8() +[text] `WARNING`: RENAMED: GetCodepoint() -> GetCodepointNext() +[text] REDESIGNED: GetCodepointNext() +[text] REVIEWED: MeasureTextEx(), avoid crash on bad data +[text] REVIEWED: UnloadFontData(), avoid crash on invalid font data +[models] ADDED: Support M3D model file format (meshes and materials) (#2648) by @bztsrc +[models] ADDED: Support for M3D animations (#2648) by @bztsrc +[models] ADDED: GLTF animation support (#2844) by @charles-l +[models] ADDED: DrawCapsule() and DrawCapsuleWires() (#2761) by @IanBand +[models] ADDED: LoadMaterials(), MTL files loading, same code as OBJ loader (#2872) by @JeffM2501 +[models] `WARNING`: REMOVED: UnloadModelKeepMeshes() +[models] `WARNING`: REMOVED: DrawCubeTexture(), DrawCubeTextureRec(), functions moved to new example: `models_draw_cube_texture` +[models] REVIEWED: DrawMesh(), using SHADER_LOC_COLOR_SPECULAR as a material map (#2908) by @haved +[models] REVIEWED: LoadM3D() vertex color support (#2878) by @GithubPrankster, @bztsrc +[models] REVIEWED: GenMeshHeightmap() (#2716) +[models] REVIEWED: LoadIQM() (#2676) +[models] REVIEWED: Simplify .vox signature check (#2752) by @CrezyDud +[models] REVIEWED: LoadIQM(), support bone names loading if available (#2882) by @PencilAmazing +[models] REVIEWED: GenMeshTangents(), avoid crash on missing texcoords data (#2927) +[audio] ADDED: Full support for QOA audio file format +[audio] ADDED: Mixed audio processor (#2929) by @hatkidchan +[audio] ADDED: IsWaveReady()`, IsSoundReady(), IsMusicReady() (#2892) by @RobLoach +[audio] `WARNING`: REMOVED: Multichannel audio API: PlaySoundMulti(), StopSoundMulti() +[audio] REVIEWED: Clear PCM buffer state when closing audio device (#2736) by @veins1 +[audio] REVIEWED: Android backend selected (#2118, #2875) by @planetis-m +[audio] REVIEWED: Change default threading model for COM objects in miniaudio +[multi] ADDED: IsShaderReady(), IsImageReady(), IsFontReady() (#2892) by @RobLoach +[multi] ADDED: IsModelReady(), IsMaterialReady(), IsTextureReady(), IsRenderTextureReady() (#2895) by @RobLoach +[multi] REVIEWED: Multiple code/comment typos by @sDos280 +[multi] REVIEWED: Grammar mistakes and typos (#2914) by @stickM4N +[multi] REVIEWED: Use TRACELOG() macro instead of TraceLog() in internal modules (#2881) by @RobLoach +[examples] ADDED: textures_textured_curve (#2821) by @JeffM2501 +[examples] ADDED: models_draw_cube_texture +[examples] ADDED: models_loading_m3d (#2648) by @bztsrc +[examples] ADDED: shaders_write_depth (#2836) by @BugraAlptekinSari +[examples] ADDED: shaders_hybrid_render (#2919) by @BugraAlptekinSari +[examples] REMOVED: audio_multichannel_sound +[examples] RENAMED: Several shaders for naming consistency (#2707) +[examples] RENAMED: lighting_instanced.fs to lighting_instancing.fs (glsl100) (#2805) by @gtrxAC +[examples] REVIEWED: core_custom_logging.c (#2692) by @hartmannathan +[examples] REVIEWED: core_camera_2d_platformer (#2687) by @skylar779 +[examples] REVIEWED: core_input_gamepad.c (#2903) by @planetis-m +[examples] REVIEWED: core_custom_frame_control +[examples] REVIEWED: core_drop_files (#2943) +[examples] REVIEWED: text_rectangle_bounds (#2746) by @SzieberthAdam +[examples] REVIEWED: textures_image_processing, added gaussian blurring (#2775) by @nobytesgiven +[examples] REVIEWED: models_billboard, highlighting rotation and draw order (#2779) by @nobytesgiven +[examples] REVIEWED: core_loading_thread, join thread on completion (#2845) by @planetis-m +[examples] REVIEWED: models_loading_gltf +[examples] REVIEWED: Shader lighting.fs for GLSL120 (#2651) +[examples] REVIEWED: text_codepoints_loading.c +[parser] REVIEWED: raylib-parser Makefile (#2765) by @Peter0x44 +[build] ADDED: Packaging for distros with deb-based and rpm-based packages (#2877) by @KOLANICH +[build] ADDED: Linkage library -latomic on Linux (only required for ARM32) +[build] ADDED: Required frameworks on macOS (#2793) by @SpexGuy +[build] ADDED: WASM support for Zig build (#2901) by @Not-Nik +[build] ADDED: New raylib examples as VS2022 project (to raylib solution) +[build] REVIEWED: config.h format and inconsistencies +[build] REVIEWED: Zig build to latest master, avoid deprecated functions (#2910) by @star-tek-mb +[build] REVIEWED: CMake project template to easily target raylib version (#2700) by @RobLoach +[build] REVIEWED: PATH for PLATFORM_WEB target (#2647) by @futureapricot +[build] REVIEWED: build.zig to let user decide how to set build mode and linker fixes by @InKryption +[build] REVIEWED: Deprecation error on Android API higher than 23 (#2778) by @anggape +[build] REVIEWED: Android x86 Architecture name (#2783) by @IsaacTCB +[build] REVIEWED: examples/build.zig for the latest Zig version (#2786) by @RomanAkberov +[utils] REVIEWED: ExportDataAsCode() data types (#2787) by @RGDTAB +[build] REVIEWED: Makefile emscripten path (#2785) by @Julianiolo +[build] REVIEWED: Several compilation warnings (for strict rules) +[build] REVIEWED: All github workflows using deprecated actions +[build] REVIEWED: CMake when compiling for web (#2820) by @object71 +[build] REVIEWED: DLL build on Windows (#2951) by @Skaytacium +[build] REVIEWED: Avoid MSVC warnings in raylib project (#2871) by @JeffM2501 +[build] REVIEWED: Paths in .bat files to build examples (#2870) by @masoudd +[build] REVIEWED: CMake, use GLVND for old cmake versions (#2826) by @simendsjo +[build] REVIEWED: Makefile, multiple tweaks +[build] REVIEWED: CI action: linux_examples.yml +[build] REVIEWED: CI action: cmake.yml +[bindings] ADDED: h-raylib (Haskell) by @Anut-py +[bindings] ADDED: raylib-c3 (C3) by @Its-Kenta +[bindings] ADDED: raylib-umka (Umka) by @RobLoach +[bindings] ADDED: chez-raylib (Chez Scheme) by @Yunoinsky +[bindings] ADDED: raylib-python-ctypes (Python) by @sDos280 +[bindings] ADDED: claylib (Common Lisp) by @shelvick +[bindings] ADDED: raylib-vapi (Vala) by @lxmcf +[bindings] ADDED: TurboRaylib (Object Pascal) by @turborium +[bindings] ADDED: Kaylib (Kotlin/Native) by @Its-Kenta +[bindings] ADDED: Raylib-Nelua (Nelua) by @Its-Kenta +[bindings] ADDED: Cyber (Cyber) by @fubark +[bindings] ADDED: raylib-sunder (Sunder) by @ashn-dot-dev +[bindings] ADDED: raylib BQN (#2962) by @Brian-ED +[misc] REVIEWED: Update external libraries to latest versions + +------------------------------------------------------------------------- +Release: raylib 4.2 (11 August 2022) +------------------------------------------------------------------------- +KEY CHANGES: + - REMOVED: extras libraries (raygui, physac, rrem, reasings, raudio.h) moved to independent separate repos + - UPDATED: examples: Added creation and update raylib versions and assigned **DIFFICULTY LEVELS**! + - rres 1.0: A custom resource-processing and packaging file format, including tooling and raylib integration examples + - raygui 3.2: New version of the immediate-mode gui system for tools development with raylib + - raylib_parser: Multiple improvements of the raylib parser to automatize bindings generation + - ADDED: New file system API: Reviewed to be more aligned with raylib conventions and one advance function added + - ADDED: New audio stream processors API (_experimental_): Allowing to add custom audio stream data processors using callbacks + +Detailed changes: +[multi] ADDED: Frequently Asked Questions (FAQ.md) +[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] ADDED: Support MOUSE_PASSTHROUGH (#2516) +[core] ADDED: GetMouseWheelMoveV() (#2517) by @schveiguy +[core] `WARNING`: REMOVED: LoadStorageValue() / SaveStorageValue(), moved to example +[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: GetMonitorWidth()/GetMonitorHeight() by @gulrak +[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: IsFileExtension() (#2530) +[camera] REVIEWED: Some camera improvements (#2563) +[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 +[rlgl] REVIEWED: rlGenTextureMipmaps() +[rlgl] REVIEWED: rlTextureParameters() +[raymath] ADDED: Wrap() (#2522) by @Tekkitslime +[raymath] ADDED: Vector2Transform() +[raymath] ADDED: Vector2DistanceSqr() (#2376) by @AnilBK +[raymath] ADDED: Vector3DistanceSqr() (#2376) by @AnilBK +[raymath] ADDED: Vector2ClampValue(), Vector3ClampValue() (#2428) by @saccharineboi +[raymath] ADDED: Vector3RotateByAxisAngle() (#2590) by @Crydsch +[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 +[raymath] REVIEWED: QuaternionFromMatrix(), QuaternionEquals() (#2591) by @kirigirihitomi +[raymath] REVIEWED: MatrixRotate*() (#2595, #2599) by @GoodNike +[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 +[textures] REVIEWED: ColorAlphaBlend() (#2524) by @royqh1979 +[textures] REVIEWED: ImageResize() (#2572) +[textures] REVIEWED: ImageFromImage() (#2594) by @wiertek +[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) +[text] REVIEWED: GenImageFontAtlas() (#2556) +[text] REVIEWED: ExportFontAsCode() to use given font padding (#2525) by @TheTophatDemon +[models] ADDED: Reference code to load bones id and weight data for animations +[models] `WARNING`: REMOVED: GetRayCollisionModel() (#2405) +[models] REMOVED: GenMeshBinormals() +[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() +[audio] REVIEWED: UpdateMusicStream(), reduce dynamic allocations (#2532) by @dbechrd +[audio] REVIEWED: UpdateMusicStream() to support proper stream looping (#2579) by @veins1 +[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: core_window_should_close +[examples] ADDED: core_2d_camera_mouse_zoom (#2583) by @JeffM2501 +[examples] ADDED: shapes_top_down_lights (#2199) by @JeffM2501 +[examples] ADDED: textures_fog_of_war +[examples] ADDED: textures_gif_player +[examples] ADDED: text_codepoints_loading +[examples] ADDED: audio_stream_effects +[examples] REMOVED: core_quat_conversion, not working properly +[examples] REMOVED: raudio_standalone, moved to raudio repo +[examples] RENAMED: textures_rectangle -> textures_sprite_anim +[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 +[examples] REVIEWED: shaders_mesh_instancing, simplified +[examples] REVIEWED: shaders_basic_lighting, rlights.h simplified +[examples] REVIEWED: All examples descriptions, included creation/update raylib versions +[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] ADDED: raylibr (#2611) by @ramiromagno +[bindings] ADDED: Raylib.4.0.Pascal (#2617) by @sysrpl +[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] ADDED: Support DLL compilation with TCC compiler (#2569) by @audinue +[build] ADDED: Missing examples to VS2022 examples solution +[build] REMOVED: VS2019 project (unmaintained) +[build] REMOVED: SUPPORT_MOUSE_CURSOR_POINT config option +[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 +[extras] `WARNING`: REMOVED: physac from raylib sources/examples, use github.com/raysan5/physac +[extras] `WARNING`: REMOVED: raygui from raylib/src/extras, use github.com/raysan5/raygui +[extras] `WARNING`: REMOVED: rmem from raylib/src/extras, moved to github.com/raylib-extras/rmem +[extras] `WARNING`: REMOVED: easings from raylib/src/extras, moved to github.com/raylib-extras/reasings +[extras] `WARNING`: REMOVED: raudio.h from raylib/src, moved to github.com/raysan5/raudio +[misc] REVIEWED: Update some external libraries to latest versions + +------------------------------------------------------------------------- +Release: raylib 4.0 - 8th Anniversary Edition (05 November 2021) +------------------------------------------------------------------------- +KEY CHANGES: + - 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 + - raymath 1.5: Complete review following new conventions, to make it more portable and self-contained + - raygui 3.0: Complete review and official new release, more portable and self-contained, intended for tools development + - raylib_parser: New tool to parse raylib.h and extract all required info into custom output formats (TXT, XML, JSON...) + - Zig and Odin official support + +Detailed changes: +[core] ADDED: Support canvas resizing on web (#1840) by @skylersaleh +[core] ADDED: GetMouseDelta() (#1832) by @adricoin2010 +[core] ADDED: Support additional mouse buttons (#1753) by @lambertwang +[core] ADDED: SetRandomSeed() (#1994) by @TommiSinivuo +[core] ADDED: GetTouchPointId() #1972 +[core] ADDED: EncodeDataBase64() and DecodeDataBase64() +[core] REMOVED: PLATFORM_UWP, difficult to maintain +[core] REMOVED: IsGamepadName() +[core] RENAMED: SwapBuffers() to SwapScreenBuffer() +[core] RENAMED: Wait() to WaitTime() +[core] RENAMED: RayHitInfo to RayCollision (#1781) +[core] RENAMED: GetRayCollisionGround() to GetRayCollisionQuad() (#1781) +[core] REVIEWED: Support mouse wheel on x-axis (#1948) +[core] REVIEWED: DisableCursor() on web by registering an empty mouse click event function in emscripten (#1900) by @grenappels +[core] REVIEWED: LoadShader() and default locations and descriptions +[core] REVIEWED: LoadShaderFromMemory() (#1851) by @Ruminant +[core] REVIEWED: WaitTime(), avoid global variables dependency to make the function is self-contained (#1841) +[core] REVIEWED: SetWindowSize() to work on web (#1847) by @nikki93 +[core] REVIEWED: Raspberry RPI/DRM keyboard blocking render loop (#1879) @luizpestana +[core] REVIEWED: Android multi-touch (#1869) by @humbe +[core] REVIEWED: Implemented GetGamepadName() for emscripten by @nbarkhina +[core] REVIEWED: HighDPI support (#1987) by @ArnaudValensi +[core] REVIEWED: KeyCallback(), register keys independently of the actions +[rlgl] ADDED: GRAPHIC_API_OPENGL_43 +[rlgl] ADDED: rlUpdateVertexBufferElements() (#1915) +[rlgl] ADDED: rlActiveDrawBuffers() (#1911) +[rlgl] ADDED: rlEnableColorBlend()/rlDisableColorBlend() +[rlgl] ADDED: rlGetPixelFormatName() +[rlgl] REVIEWED: rlUpdateVertexBuffer (#1914) by @630Studios +[rlgl] REVIEWED: rlDrawVertexArrayElements() (#1891) +[rlgl] REVIEWED: Wrong normal matrix calculation (#1870) +[raymath] ADDED: Vector3Angle() +[raymath] REVIEWED: QuaternionFromAxisAngle() (#1892) +[raymath] REVIEWED: QuaternionToMatrix() returning transposed result. (#1793) by @object71 +[shapes] ADDED: RenderPolyLinesEx() (#1758) by @lambertwang +[shapes] ADDED: DrawSplineBezierCubic() (#2021) by @SAOMDVN +[textures] ADDED: GetImageColor() #2024 +[textures] REMOVED: GenImagePerlinNoise() +[textures] RENAMED: GetTextureData() to LoadImageFromTexture() +[textures] RENAMED: GetScreenData() to LoadImageFromScreen() +[textures] REVIEWED: ExportImage() to use SaveFileData() (#1779) +[textures] REVIEWED: LoadImageAnim() #2005 +[text] ADDED: Security check in case of not valid font +[text] ADDED: `GetGlyphInfo()` to get glyph info for a specific codepoint +[text] ADDED: `GetGlyphAtlasRec()` to get glyph rectangle within the generated font atlas +[text] ADDED: DrawTextPro() with text rotation support, WARNING: DrawTextPro() requires including `rlgl.h`, before it was only dependant on `textures` module. +[text] ADDED: UnloadCodepoints() to safely free loaded codepoints +[text] REMOVED: DrawTextRec() and DrawTextRecEx(), moved to example, those functions could be very specific depending on user needs so it's better to give the user the full source in case of special requirements instead of allowing a function with +10 input parameters. +[text] RENAMED: struct `CharInfo` to `GlyphInfo`, actually that's the correct naming for the data contained. It contains the character glyph metrics and the glyph image; in the past it also contained rectangle within the font atlas but that data has been moved to `Font` struct directly, so, `GlyphInfo` is a more correct name. +[text] RENAMED: `CodepointToUtf8()` to `CodepointToUTF8()`, capitalization of UTF-8 is the correct form, it would also require de hyphen but it can be omitted in this case. +[text] RENAMED: `TextToUtf8()` to `TextCodepointsToUTF8` for consistency and more detail on the functionality. +[text] RENAMED: GetCodepoints() to LoadCodepoints(), now codepoint array data is loaded dynamically instead of reusing a limited static buffer. +[text] RENAMED: GetNextCodepoint() to GetCodepoint() +[models] ADDED: MagikaVoxel VOX models loading +[models] ADDED: GenMeshCone() (#1903) +[models] ADDED: GetModelBoundingBox() +[models] ADDED: DrawBillboardPro() (#1759) by @nobytesgiven +[models] ADDED: DrawCubeTextureRec() (#2001) by @tdgroot +[models] ADDED: DrawCylinderEx() and DrawCylinderWiresEx() (#2049) by @Horrowind +[models] REMOVED: DrawBillboardEx() +[models] RENAMED: MeshBoundingBox() to GetMeshBoundingBox() +[models] RENAMED: MeshTangents() to GenMeshTangents() +[models] RENAMED: MeshBinormals() to GenMeshBinormals() +[models] REVIEWED: GenMeshTangents() (#1877) by @630Studios +[models] REVIEWED: CheckCollisionBoxSphere() by @Crydsch +[models] REVIEWED: GetRayCollisionQuad() by @Crydsch +[models] REVIEWED: LoadGLTF(), fixed missing transformations and nonroot skinning by @MrDiver +[models] REVIEWED: LoadGLTF(), rewriten from scratch, removed animations support (broken) +[models] REVIEWED: Decouple DrawMesh() and DrawMeshInstanced() (#1958) +[models] REVIEWED: Support vertex color attribute for GLTF and IQM (#1790) by @object71 +[models] REVIEWED: DrawBillboardPro() (#1941) by @GithubPrankster +[models] REDESIGNED: Major review of glTF loading functionality (#1849) by @object71 +[audio] ADDED: SeekMusicStream() (#2006) by @GithubPrankster +[audio] REMOVED: GetAudioStreamBufferSizeDefault() +[audio] RENAMED: InitAudioStream() to LoadAudioStream() +[audio] RENAMED: CloseAudioStream() to UnloadAudioStream() +[audio] RENAMED: IsMusicPlaying() to IsMusicStreamPlaying() +[audio] REVIEWED: ExportWaveAsCode() +[audio] REDESIGNED: Use frameCount on audio instead of sampleCount +[utils] REVIEWED: exit() on LOG_FATAL instead of LOG_ERROR (#1796) +[examples] ADDED: core_custom_frame_control +[examples] ADDED: core_basic_screen_manager +[examples] ADDED: core_split_screen (#1806) by @JeffM2501 +[examples] ADDED: core_smooth_pixelperfect (#1771) by @NotManyIdeasDev +[examples] ADDED: shaders_texture_outline (#1883) by @GoldenThumbs +[examples] ADDED: models_loading_vox (#1940) by @procfxgen +[examples] ADDED: rlgl_compute_shader by @TSnake41 (#2088) +[examples] REMOVED: models_material_pbr +[examples] REMOVED: models_gltf_animation +[examples] REVIEWED: core_3d_picking +[examples] REVIEWED: core_input_mouse +[examples] REVIEWED: core_vr_simulator, RenderTexture usage +[examples] REVIEWED: core_window_letterbox, RenderTexture usage +[examples] REVIEWED: shapes_basic_shapes +[examples] REVIEWED: shapes_logo_raylib_anim +[examples] REVIEWED: textures_to_image +[examples] REVIEWED: text_rectangle_bounds +[examples] REVIEWED: text_unicode +[examples] REVIEWED: text_draw_3d +[examples] REVIEWED: models_loading +[examples] REVIEWED: models_skybox (#1792) (#1778) +[examples] REVIEWED: models_mesh_picking +[examples] REVIEWED: models_yaw_pitch_roll +[examples] REVIEWED: models_rlgl_solar_system +[examples] REVIEWED: shaders_custom_uniform, RenderTexture usage +[examples] REVIEWED: shaders_eratosthenes, RenderTexture usage +[examples] REVIEWED: shaders_julia_set, RenderTexture usage +[examples] REVIEWED: shaders_postprocessing, RenderTexture usage +[examples] REVIEWED: shaders_basic_lighting, simplified (#1865) +[examples] REVIEWED: audio_raw_stream.c +[examples] REVIEWED: raudio_standalone +[examples] REVIEWED: raylib_opengl_interop +[examples] REVIEWED: rlgl_standalone.c +[examples] REVIEWED: Resources licenses +[examples] REVIEWED: models resources reorganization +[templates] REMOVED: Moved to a separate repo: https://github.com/raysan5/raylib-game-template +[build] ADDED: Zig build file (#2014) by @TommiSinivuo +[build] ADDED: Android VS2019 solution (#2013) by @Kronka +[build] REMOVED: VS2017 project, outdated +[build] RENAMED: All raylib modules prefixed with 'r' (core -> rcore) +[build] RENAMED: SUPPORT_MOUSE_CURSOR_NATIVE to SUPPORT_MOUSE_CURSOR_POINT +[build] REVIEWED: examples/examples_template.c +[build] REVIEWED: Makefile to latest Emscripten SDK r23 +[build] REVIEWED: Makefile for latest Android NDK r32 LTS +[build] REVIEWED: raylib resource files +[build] Moved some extra raylib libraries to /extras/ directory +[*] UPDATED: Multiple bindings to latest version +[*] UPDATED: Most external libraries to latest versions (except GLFW) +[*] Multiple code improvements and fixes by multiple contributors! + +------------------------------------------------------------------------- +Release: raylib 3.7 (26 April 2021) +------------------------------------------------------------------------- +KEY CHANGES: + - [rlgl] REDESIGNED: Greater abstraction level, some functionality moved to core module + - [rlgl] REVIEWED: Instancing and stereo rendering + - [core] REDESIGNED: VR simulator, fbo/shader exposed to user + - [utils] ADDED: File access callbacks system + - [models] ADDED: glTF animations support (#1551) by @object71 + - [audio] ADDED: Music streaming support from memory (#1606) by @nezvers + - [*] RENAMED: enum types and enum values for consistency + +Detailed changes: +[core] ADDED: LoadVrStereoConfig() +[core] ADDED: UnloadVrStereoConfig() +[core] ADDED: BeginVrStereoMode() +[core] ADDED: EndVrStereoMode() +[core] ADDED: GetCurrentMonitor() (#1485) by @object71 +[core] ADDED: SetGamepadMappings() (#1506) +[core] RENAMED: struct Camera: camera.type to camera.projection +[core] RENAMED: LoadShaderCode() to LoadShaderFromMemory() (#1690) +[core] RENAMED: SetMatrixProjection() to rlSetMatrixProjection() +[core] RENAMED: SetMatrixModelview() to rlSetMatrixModelview() +[core] RENAMED: GetMatrixModelview() to rlGetMatrixModelview() +[core] RENAMED: GetMatrixProjection() to rlGetMatrixProjection() +[core] RENAMED: GetShaderDefault() to rlGetShaderDefault() +[core] RENAMED: GetTextureDefault() to rlGetTextureDefault() +[core] REMOVED: GetShapesTexture() +[core] REMOVED: GetShapesTextureRec() +[core] REMOVED: GetMouseCursor() +[core] REMOVED: SetTraceLogExit() +[core] REVIEWED: GetFileName() and GetDirectoryPath() (#1534) by @gilzoide +[core] REVIEWED: Wait() to support FreeBSD (#1618) +[core] REVIEWED: HighDPI support on macOS retina (#1510) +[core] REDESIGNED: GetFileExtension(), includes the .dot +[core] REDESIGNED: IsFileExtension(), includes the .dot +[core] REDESIGNED: Compresion API to use sdefl/sinfl libs +[rlgl] ADDED: SUPPORT_GL_DETAILS_INFO config flag +[rlgl] REMOVED: GenTexture*() functions (#721) +[rlgl] REVIEWED: rlLoadShaderDefault() +[rlgl] REDESIGNED: rlLoadExtensions(), more details exposed +[raymath] REVIEWED: QuaternionFromEuler() (#1651) +[raymath] REVIEWED: MatrixRotateZYX() (#1642) +[shapes] ADDED: DrawSplineBezierQuad() (#1468) by @epsilon-phase +[shapes] ADDED: CheckCollisionLines() +[shapes] ADDED: CheckCollisionPointLine() by @mkupiec1 +[shapes] REVIEWED: CheckCollisionPointTriangle() by @mkupiec1 +[shapes] REDESIGNED: SetShapesTexture() +[shapes] REDESIGNED: DrawCircleSector(), to use float params +[shapes] REDESIGNED: DrawCircleSectorLines(), to use float params +[shapes] REDESIGNED: DrawRing(), to use float params +[shapes] REDESIGNED: DrawRingLines(), to use float params +[textures] ADDED: DrawTexturePoly() and example (#1677) by @chriscamacho +[textures] ADDED: UnloadImageColors() for allocs consistency +[textures] RENAMED: GetImageData() to LoadImageColors() +[textures] REVIEWED: ImageClearBackground() and ImageDrawRectangleRec() (#1487) by @JeffM2501 +[textures] REVIEWED: DrawTexturePro() and DrawRectanglePro() transformations (#1632) by @ChrisDill +[text] REDESIGNED: DrawFPS() +[models] ADDED: UploadMesh() (#1529) +[models] ADDED: UpdateMeshBuffer() +[models] ADDED: DrawMesh() +[models] ADDED: DrawMeshInstanced() +[models] ADDED: UnloadModelAnimations() (#1648) by @object71 +[models] REMOVED: DrawGizmo() +[models] REMOVED: LoadMeshes() +[models] REMOVED: MeshNormalsSmooth() +[models] REVIEWED: DrawLine3D() (#1643) +[audio] REVIEWED: Multichannel sound system (#1548) +[audio] REVIEWED: jar_xm library (#1701) by @jmorel33 +[utils] ADDED: SetLoadFileDataCallback() +[utils] ADDED: SetSaveFileDataCallback() +[utils] ADDED: SetLoadFileTextCallback() +[utils] ADDED: SetSaveFileTextCallback() +[examples] ADDED: text_draw_3d (#1689) by @Demizdor +[examples] ADDED: textures_poly (#1677) by @chriscamacho +[examples] ADDED: models_gltf_model (#1551) by @object71 +[examples] RENAMED: shaders_rlgl_mesh_instanced to shaders_mesh_intancing +[examples] REDESIGNED: shaders_rlgl_mesh_instanced by @moliad +[examples] REDESIGNED: core_vr_simulator +[examples] REDESIGNED: models_yaw_pitch_roll +[build] ADDED: Config flag: SUPPORT_STANDARD_FILEIO +[build] ADDED: Config flag: SUPPORT_WINMM_HIGHRES_TIMER (#1641) +[build] ADDED: Config flag: SUPPORT_GL_DETAILS_INFO +[build] ADDED: Examples projects to VS2019 solution +[build] REVIEWED: Makefile to support PLATFORM_RPI (#1580) +[build] REVIEWED: Multiple typecast warnings by @JeffM2501 +[build] REDESIGNED: VS2019 project build paths +[build] REDESIGNED: CMake build system by @object71 +[*] RENAMED: Several functions parameters for consistency +[*] UPDATED: Multiple bindings to latest version +[*] UPDATED: All external libraries to latest versions +[*] Multiple code improvements and fixes by multiple contributors! + +------------------------------------------------------------------------- +Release: raylib 3.5 - 7th Anniversary Edition (25 December 2020) +------------------------------------------------------------------------- +KEY CHANGES: + - [core] ADDED: PLATFORM_DRM to support RPI4 and other devices (#1388) by @kernelkinetic + - [core] REDESIGNED: Window states management system through FLAGS + - [rlgl] ADDED: RenderBatch type and related functions to allow custom batching (internal only) + - [rlgl] REDESIGNED: Framebuffers API to support multiple attachment types (#721) + - [textures] REDESIGNED: Image*() functions, big performance improvements (software rendering) + - [*] REVIEWED: Multiple functions to replace file accesses by memory accesses + - [*] ADDED: GitHub Actions CI to support multiple raylib build configurations + +Detailed changes: +[core] ADDED: SetWindowState() / ClearWindowState() -> New flags added! +[core] ADDED: IsWindowFocused() +[core] ADDED: GetWindowScaleDPI() +[core] ADDED: GetMonitorRefreshRate() (#1289) by @Shylie +[core] ADDED: IsCursorOnScreen() (#1262) by @ChrisDill +[core] ADDED: SetMouseCursor() and GetMouseCursor() for standard Desktop cursors (#1407) by @chances +[core] REMOVED: struct RenderTexture2D: depthTexture variable +[core] REMOVED: HideWindow() / UnhideWindow() -> Use SetWindowState() +[core] REMOVED: DecorateWindow() / UndecorateWindow() -> Use SetWindowState() +[core] RENAMED: GetExtension() to GetFileExtension() +[core] REVIEWED: Several structs to reduce size and padding +[core] REVIEWED: struct Texture maps to Texture2D and TextureCubemap +[core] REVIEWED: ToggleFullscreen() (#1287) +[core] REVIEWED: InitWindow(), support empty title for window (#1323) +[core] REVIEWED: RPI: Mouse movements are bound to the screen resolution (#1392) (#1410) by @kernelkinetic +[core] REVIEWED: GetPrevDirectoryPath() fixes on Unix-like systems (#1246) by @ivan-cx +[core] REPLACED: rgif.h by msf_gif.h for automatic gif recording +[core] REDESIGNED: GetMouseWheelMove() to return float movement for precise scrolling (#1397) by @Doy-lee +[core] REDESIGNED: GetKeyPressed(), and added GetCharPressed() (#1336) +[core] UWP rework with improvements (#1231) by @Rover656 +[core] Gamepad axis bug fixes and improvement (#1228) by @mmalecot +[core] Updated joystick mappings with latest version of gamecontrollerdb (#1381) by @coderoth +[rlgl] Corrected issue with OpenGL 1.1 support +[rlgl] ADDED: rlDrawMeshInstanced() (#1318) by @seanpringle +[rlgl] ADDED: rlCheckErrors (#1321) by @seanpringle +[rlgl] ADDED: BLEND_SET blending mode (#1251) by @RandomErrorMessage +[rlgl] ADDED: rlSetLineWidth(), rlGetLineWidth(), rlEnableSmoothLines(), rlDisableSmoothLines() (#1457) by @JeffM2501 +[rlgl] RENAMED: rlUnproject() to Vector3Unproject() [raymath] +[rlgl] REVIEWED: Replace rlglDraw() calls by DrawRenderBatch() internal calls +[rlgl] REVIEWED: GenTextureCubemap(), use rlgl functionality only +[rlgl] REVIEWED: rlFramebufferAttach() to support texture layers +[rlgl] REVIEWED: GenDrawCube() and GenDrawQuad() +[rlgl] REVIEWED: Issues with vertex batch overflow (#1223) +[rlgl] REVIEWED: rlUpdateTexture(), issue with offsets +[rlgl] REDESIGNED: GenTexture*() to use the new fbo API (#721) +[raymath] ADDED: Normalize() and Remap() functions (#1247) by @NoorWachid +[raymath] ADDED: Vector2Reflect() (#1400) by @daniel-junior-dube +[raymath] ADDED: Vector2LengthSqr() and Vector3LengthSqr() (#1248) by @ThePituLegend +[raymath] ADDED: Vector2MoveTowards() function (#1233) by @anatagawa +[raymath] REVIEWED: Some functions consistency (#1197) by @Not-Nik +[raymath] REVIEWED: QuaternionFromVector3ToVector3() (#1263) by @jvocaturo +[raymath] REVIEWED: MatrixLookAt(), optimized (#1442) by @RandomErrorMessage +[shapes] ADDED: CheckCollisionLines(), by @Elkantor +[text] Avoid [textures] functions dependencies +[text] ADDED: Config flag: SUPPORT_TEXT_MANIPULATION +[text] ADDED: LoadFontFromMemory() (TTF only) (#1327) +[text] ADDED: UnloadFontData() +[text] RENAMED: FormatText() -> TextFormat() +[text] REVIEWED: Font struct, added charsPadding (#1432) +[text] REVIEWED: TextJoin() +[text] REVIEWED: TextReplace() (#1172) +[text] REVIEWED: LoadBMFont() to load data from memory (#1232) +[text] REVIEWED: GenImageFontAtlas(), fixed offset (#1171) +[text] REDESIGNED: LoadFontData(), reviewed input parameters +[text] REDESIGNED: LoadFontDefault(), some code simplifications +[text] REDESIGNED: LoadFontFromImage(), avoid LoadImageEx() +[text] REDESIGNED: LoadFontData(), avoid GenImageColor(), ImageFormat() +[text] REDESIGNED: LoadBMFont(), avoid ImageCopy(), ImageFormat(), ImageAlphaMask() +[textures] Move Color functions from [core] to [textures] module +[textures] ADDED: ColorAlphaBlend() +[textures] ADDED: GetPixelColor() +[textures] ADDED: SetPixelColor() +[textures] ADDED: LoadImageFromMemory() (#1327) +[textures] ADDED: LoadImageAnim() to load animated sequence of images +[textures] ADDED: DrawTextureTiled() (#1291) - @Demizdor +[textures] ADDED: UpdateTextureRec() +[textures] ADDED: UnloadImageColors(), UnloadImagePalette(), UnloadWaveSamples() +[textures] REMOVED: Config flag: SUPPORT_IMAGE_DRAWING +[textures] REMOVED: LoadImageEx() +[textures] REMOVED: LoadImagePro() +[textures] REMOVED: GetImageDataNormalized(), not exposed in the API +[textures] RENAMED: ImageExtractPalette() to GetImagePalette() +[textures] RENAMED: Fade() to ColorAlpha(), added #define for compatibility +[textures] RENAMED: GetImageData() -> LoadImageColors() +[textures] RENAMED: GetImagePalette() -> LoadImagePalette() +[textures] RENAMED: GetWaveData() -> LoadWaveSamples() +[textures] REVIEWED: GetPixelDataSize() to consider compressed data properly +[textures] REVIEWED: GetTextureData(), allow retrieving 32bit float data +[textures] REVIEWED: ImageDrawText*() params order +[textures] REVIEWED: ColorAlphaBlend(), support tint color +[textures] REVIEWED: ColorAlphaBlend(), integers-version, optimized (#1218) +[textures] REVIEWED: ImageDraw(), consider negative source offset properly (#1283) +[textures] REVIEWED: ImageDraw(), optimizations test (#1218) +[textures] REVIEWED: ImageResizeCanvas(), optimization (#1218) +[textures] REVIEWED: ExportImage(), optimized +[textures] REVIEWED: ImageAlphaPremultiply(), optimization +[textures] REVIEWED: ImageAlphaClear(), minor optimization +[textures] REVIEWED: ImageToPOT(), renamed parameter +[textures] REVIEWED: ImageCrop() (#1218) +[textures] REVIEWED: ImageToPOT() (#1218) +[textures] REVIEWED: ImageAlphaCrop() (#1218) +[textures] REVIEWED: ExportImage(), optimized (#1218) +[textures] REDESIGNED: ImageCrop(), optimized (#1218) +[textures] REDESIGNED: ImageRotateCCW(), optimized (#1218) +[textures] REDESIGNED: ImageRotateCW(), optimized (#1218) +[textures] REDESIGNED: ImageFlipHorizontal(), optimized (#1218) +[textures] REDESIGNED: ImageFlipVertical(), optimized (#1218) +[textures] REDESIGNED: ImageResizeCanvas(), optimized (#1218) +[textures] REDESIGNED: ImageDrawPixel(), optimized +[textures] REDESIGNED: ImageDrawLine(), optimized +[textures] REDESIGNED: ImageDraw(), optimized (#1218) +[textures] REDESIGNED: ImageResize(), optimized (#1218) +[textures] REDESIGNED: ImageFromImage(), optimized (#1218) +[textures] REDESIGNED: ImageDraw(), optimization (#1218) +[textures] REDESIGNED: ImageAlphaClear(), optimized (#1218) +[textures] REDESIGNED: ExportImageAsCode() to use memory buffer (#1232) +[textures] REDESIGNED: ColorFromHSV() +[models] ADDED: DrawTriangle3D() and DrawTriangleStrip3D() +[models] ADDED: UnloadModelKeepMeshes() +[models] REVIEWED: LoadModel(), avoid loading texcoords and normals from model if not existent +[models] REVIEWED: GenMeshCubicmap(), added comments and simplification +[models] REVIEWED: GenMeshCubicmap(), fixed generated normals (#1244) by @GoldenThumbs +[models] REVIEWED: GenMeshPoly(), fixed buffer overflow (#1269) by @frithrah +[models] REVIEWED: LoadOBJ(): Allow for multiple materials in obj files (#1408) by @chriscamacho and @codifies +[models] REVIEWED: LoadIQM() materials loading (#1227) by @sikor666 +[models] REVIEWED: LoadGLTF() to read from memory buffer +[models] REVIEWED: UpdateMesh(), fix extra memory allocated when updating color buffer (#1271) by @4yn +[models] REVIEWED: MeshNormalsSmooth() (#1317) by @seanpringle +[models] REVIEWED: DrawGrid() (#1417) +[models] REDESIGNED: ExportMesh() to use memory buffer (#1232) +[models] REDESIGNED: LoadIQM() and LoadModelAnimations() to use memory buffers +[audio] ADDED: LoadWaveFromMemory() (#1327) +[audio] REMOVED: SetMusicLoopCount() +[audio] REVIEWED: Several functions, sampleCount vs frameCount (#1423) +[audio] REVIEWED: SaveWAV() to use memory write insted of file +[audio] REVIEWED: LoadMusicStream(), support WAV music streaming (#1198) +[audio] REVIEWED: Support multiple WAV sampleSize for MusicStream (#1340) +[audio] REVIEWED: SetAudioBufferPitch() +[audio] REDESIGNED: Audio looping system +[audio] REDESIGNED: LoadSound(): Use memory loading (WAV, OGG, MP3, FLAC) (#1312) +[audio] REDESIGNED: ExportWaveAsCode() to use memory buffers +[utils] ADDED: MemAlloc() / MemFree() (#1440) +[utils] ADDED: UnloadFileData() / UnloadFileText() +[utils] REVIEWED: android_fopen() to support SDCard access +[utils] REDESIGNED: SaveFile*() functions to expose file access results (#1420) +[rmem] REVIEWED: MemPool and other allocators optimization (#1211) by @assyrianic +[examples] ADDED: core/core_window_flags +[examples] ADDED: core/core_quat_conversion by @chriscamacho and @codifies +[examples] ADDED: textures/textures_blend_modes (#1261) by @accidentalrebel +[examples] ADDED: textures/textures_draw_tiled (#1291) by @Demizdor +[examples] ADDED: shaders/shaders_hot_reloading (#1198) +[examples] ADDED: shaders/shaders_rlgl_mesh_instanced (#1318) by @seanpringle +[examples] ADDED: shaders/shaders_multi_sampler2d +[examples] ADDED: others/embedded_files_loading +[examples] REVIEWED: textures/textures_raw_data (#1286) +[examples] REVIEWED: textures/textures_sprite_explosion, replace resources +[examples] REVIEWED: textures/textures_particles_blending, replace resources +[examples] REVIEWED: textures/textures_image_processing, support mouse +[examples] REVIEWED: models/models_skybox to work on OpenGL ES 2.0 +[examples] REVIEWED: audio/resources, use open license resources +[examples] REVIEWED: others/raudio_standalone.c +[build] ADDED: New config.h configuration options exposing multiple #define values +[build] REMOVED: ANGLE VS2017 template project +[build] REVIEWED: All MSVC compile warnings +[build] Updated Makefile for web (#1332) by @rfaile313 +[build] Updated build pipelines to use latest emscripten and Android NDK +[build] Updated emscriptem build script to generate .a on WebAssembly +[build] Updated Android build for Linux, supporting ANDROID_NDK at compile time by @branlix3000 +[build] Updated VSCode project template tasks +[build] Updated VS2017.UWP project template by @Rover656 +[build] Updated Android build pipeline +[build] REMOVED: AppVeyor and Travis CI build systems +[*] Moved raysan5/raylib/games to independent repo: raysan5/raylib-games +[*] Replaced several examples resources with more open licensed alternatives +[*] Updated BINDINGS.md with NEW bindings and added raylib version binding! +[*] Updated all external libraries to latest versions +[*] Multiple code improvements and small fixes + +----------------------------------------------- +Release: raylib 3.0 (01 April 2020) +----------------------------------------------- +KEY CHANGES: + - Global context states used on all modules. + - Custom memory allocators for all modules and dependencies. + - Centralized file access system and memory data loading. + - Structures reviewed to reduce size and always be used as pass-by-value. + - Tracelog messages completely reviewed and categorized. + - raudio module reviewed to accomodate new Music struct and new miniaudio. + - text module reviewed to improve fonts generation and text management functions. + - Multiple new examples added and categorized examples table. + - GitHub Actions CI implemented for Windows, Linux and macOS. + +Detailed changes: +[build] ADDED: VS2017.ANGLE project, by @msmshazan +[build] ADDED: VS2017 project support for x64 platform configuration +[build] ADDED: Makefile for Android building on macOS, by @Yunoinsky +[build] ADDED: Makefile for Android building on Linux, by @pamarcos +[build] REMOVED: VS2015 project +[build] REVIEWED: VSCode project +[build] REVIEWED: Makefile build system +[build] REVIEWED: Android building, by @NimbusFox +[build] REVIEWED: Compilation with CLion IDE, by @Rover656 +[build] REVIEWED: Generation of web examples, by @pamarcos +[build] REVIEWED: Makefiles path to 'shell.html', by @niorad +[build] REVIEWED: VS2017 64bit compilation issues, by @spec-chum +[build] REVIEWED: Multiple fixes on projects building, by @ChrisDill, @JuDelCo, @electronstudio +[core] ADDED: Support touch/mouse indistinctly +[core] ADDED: FLAG_WINDOW_ALWAYS_RUN to avoid pause on minimize +[core] ADDED: Config flag SUPPORT_HALFBUSY_WAIT_LOOP +[core] ADDED: RPI mouse cursor point support on native mode +[core] ADDED: GetWorldToScreen2D()- Get screen space position for a 2d camera world space position, by @arvyy +[core] ADDED: GetScreenToWorld2D() - Get world space position for a 2d camera screen space position, by @arvyy +[core] ADDED: GetWorldToScreenEx() - Get size position for a 3d world space position +[core] ADDED: DirectoryExists() - Check if a directory path exists +[core] ADDED: GetPrevDirectoryPath() - Get previous directory path for a given path +[core] ADDED: CompressData() - Compress data (DEFLATE algorythm) +[core] ADDED: DecompressData() - Decompress data (DEFLATE algorythm) +[core] ADDED: GetWindowPosition() - Get window position XY on monitor +[core] ADDED: LoadFileData() - Load file data as byte array (read) +[core] ADDED: SaveFileData() - Save data to file from byte array (write) +[core] ADDED: LoadFileText() - Load text data from file (read), returns a '\0' terminated string +[core] ADDED: SaveFileText() - Save text data to file (write), string must be '\0' terminated +[core] REMOVED: Show raylib logo at initialization +[core] REVIEWED: GetFileName(), security checks +[core] REVIEWED: LoadStorageValue(), by @danimartin82 +[core] REVIEWED: SaveStorageValue(), by @danimartin82 +[core] REVIEWED: IsMouseButtonReleased(), when press/release events come too fast, by @oswjk +[core] REVIEWED: SetWindowMonitor(), by @DropsOfSerenity +[core] REVIEWED: IsFileExtension() to be case-insensitive +[core] REVIEWED: IsFileExtension() when checking no-extension files +[core] REVIEWED: Default font scale filter for HighDPI mode +[core] REVIEWED: Touch input scaling for PLATFORM_WEB +[core] REVIEWED: RPI input system, by @DarkElvenAngel +[core] REVIEWED: RPI input threads issues +[core] REVIEWED: OpenGL extensions loading and freeing +[core] REVIEWED: GetDirectoryPath() +[core] REVIEWED: Camera2D behavior, by @arvyy +[core] REVIEWED: OpenGL ES 2.0 extensions check +[rlgl] ADDED: Flags to allow frustrum culling near/far distance configuration at compile time +[rlgl] ADDED: Flags to sllow MAX_BATCH_BUFFERING config at compile time +[rlgl] ADDED: GetMatrixProjection(), by @chriscamacho +[rlgl] ADDED: rlUpdateMeshAt() - Update vertex or index data on GPU, at index, by @brankoku +[rlgl] REVIEWED: Vertex padding not zeroed for quads, by @kawa-yoiko +[rlgl] REVIEWED: Read texture data as RGBA from FBO on GLES 2.0 +[rlgl] REVIEWED: LoadShaderCode() for const correctness, by @heretique +[rlgl] REVIEWED: rlLoadTexture() +[rlgl] REVIEWED: rlReadTexturePixels() +[rlgl] REVIEWED: rlUpdateMesh() to supports updating indices, by @brankoku +[rlgl] REVIEWED: GenTextureCubemap(), renamed parameters for consistency +[rlgl] REVIEWED: HDR pixels loading +[raymath] ADDED: MatrixRotateXYZ(), by @chriscamacho +[raymath] RENAMED: Vector3Multiply() to Vector3Scale() +[camera] REVIEWED: Free camera pitch, by @chriscamacho +[camera] REVIEWED: Camera not working properly at z-align, by @Ushio +[shapes] ADDED: DrawTriangleStrip() - Draw a triangle strip defined by points +[shapes] ADDED: DrawEllipse() - Draw ellipse +[shapes] ADDED: DrawEllipseLines() - Draw ellipse outline +[shapes] ADDED: DrawPolyLines() - Draw a polygon outline of n sides +[shapes] REVIEWED: DrawPoly() shape rendering, by @AlexHCC +[textures] ADDED: LoadAnimatedGIF() - Load animated GIF file +[textures] ADDED: GetImageAlphaBorder() - Get image alpha border rectangle +[textures] ADDED: ImageFromImage() - Create an image from another image piece +[textures] ADDED: ImageClearBackground(), by @iamsouravgupta +[textures] ADDED: ImageDrawPixel(), by @iamsouravgupta +[textures] ADDED: ImageDrawCircle(), by @iamsouravgupta +[textures] ADDED: ImageDrawLineEx(), by @iamsouravgupta +[textures] ADDED: ImageDrawPixelV(), by @RobLoach +[textures] ADDED: ImageDrawCircleV(), by @RobLoach +[textures] ADDED: ImageDrawLineV(), by @RobLoach +[textures] ADDED: ImageDrawRectangleV(), by @RobLoach +[textures] ADDED: ImageDrawRectangleRec(), by @RobLoach +[textures] REVIEWED: ImageDrawPixel(), by @RobLoach +[textures] REVIEWED: ImageDrawLine(), by @RobLoach +[textures] REVIEWED: ImageDrawCircle(), by @RobLoach +[textures] REVIEWED: ImageDrawRectangle(), by @RobLoach +[textures] REVIEWED: ImageDraw(), now it supports color tint parameter +[textures] REVIEWED: ImageResizeCanvas() +[textures] REVIEWED: ImageCrop() with security checks +[textures] REVIEWED: ImageAlphaMask() +[textures] REVIEWED: ImageDrawRectangleLines() +[textures] REVIEWED: GetImageData() +[text] ADDED: TextCopy() - Copy one string to another, returns bytes copied +[text] ADDED: GetCodepoints() - Get all codepoints in a string +[text] ADDED: CodepointToUtf8() - Encode codepoint into utf8 text +[text] ADDED: DrawTextCodepoint() - Draw one character (codepoint) +[text] RENAMED: LoadDefaultFont() -> LoadFontDefault() +[text] RENAMED: TextCountCodepoints() -> GetCodepointsCount() +[text] REVIEWED: TextFormat(), to support caching, by @brankoku +[text] REVIEWED: LoadFontData(), generate empty image for space character +[text] REVIEWED: TextSplit() +[text] REVIEWED: TextToInteger() +[text] REVIEWED: GetNextCodepoint(), renamed parameters for clarity +[text] REVIEWED: GenImageFontAtlas(), improved atlas size computing +[text] REDESIGNED: struct Font, character rectangles have been moved out from CharInfo to Font +[text] REDESIGNED: struct CharInfo, now includes directly an Image of the glyph +[text] REDESIGNED: GenImageFontAtlas(), additional recs parameter added +[text] REDESIGNED: ImageTextEx(), to avoid font retrieval from GPU +[models] ADDED: Support rlPushMatrix() and rlPopMatrix() on mesh drawing +[models] ADDED: DrawPoint3D() - Draw a point in 3D space, actually a small line, by @ProfJski +[models] ADDED: Multi texture support for materials in GLTF format, by @Gamerfiend, @chriscamacho +[models] REVIEWED: LoadGLTF(), fixed memory leak, by @jubalh +[models] REVIEWED: LoadIQM(), support multiple animations loading, by @culacant +[models] REVIEWED: GetCollisionRayModel(), to avoid pointers +[models] REVIEWED: CheckCollisionRay*(), parameters renamed +[models] REVIEWED: UnloadMesh(), to avoid pointers +[models] REVIEWED: LoadModel(), memory initialization +[models] REVIEWED: UpdateModelAnimation(), added security checks +[models] REVIEWED: Multiple fixes on models loading, by @jubalh +[models] REVIEWED: Normals updated when using animated meshes, by @@las3rlars +[models] REVIEWED: Compilation when the SUPPORT_MESH_GENERATION not set, by @@Elkantor +[raudio] ADDED: Multi-channel audio playing, by @chriscamacho +[raudio] REMOVED: LoadWaveEx() +[raudio] RENAMED: IsAudioBufferProcessed() to IsAudioStreamProcessed() +[raudio] REVIEWED: Ensure .xm playback starts in the right place, by @illegalinstruction +[raudio] REVIEWED: Fix short non-looping sounds, by @jbosh +[raudio] REVIEWED: Modules playing time to full length +[raudio] REDESIGNED: Replaced Music pointer by struct +[raudio] REDESIGNED: Removed sampleLeft from Music struct +[examples] ADDED: core_scissor_test, by @ChrisDill +[examples] ADDED: core_2d_camera_platformer, by @arvyy +[examples] ADDED: textures_mouse_painting, by @ChrisDill +[examples] ADDED: models_waving_cubes, by @codecat +[examples] ADDED: models_solar_system, by @aldrinmartoq +[examples] ADDED: shaders_fog, by @chriscamacho +[examples] ADDED: shaders_texture_waves, by @Anata +[examples] ADDED: shaders_basic_lighting, by @chriscamacho +[examples] ADDED: shaders_simple_mask, by @chriscamacho +[examples] ADDED: audio_multichannel_sound, by @chriscamacho +[examples] ADDED: shaders_spotlight, by @chriscamacho +[examples] RENAMED: text_sprite_font > text_font_spritefont +[examples] RENAMED: text_ttf_loading > text_font_filters +[examples] RENAMED: text_bmfont_ttf > text_font_loading +[examples] REMOVED: models_obj_viewer +[examples] REMOVED: models_solar_system +[examples] REVIEWED: models_obj_loading > models_loading +[examples] REVIEWED: models_materials_pbr, shader issues +[examples] REVIEWED: core_window_letterbox, detailed explanation, by @jotac0 +[examples] REVIEWED: core_window_letterbox, virtual mouse, by @anatagawa +[games] ADDED: GGJ2020 game - RE-PAIR +[*] Misc fixes and tweaks, by @yaram, @oraoto, @zatherz, @piecedigital, @Shylie +[*] Update ALL supported projects (Notepad++, VS2017) +[*] Update ALL external libraries to latest versions (29.Jan.2020) +[*] Update ALL examples and games +[*] Update BINDINGS list + +----------------------------------------------- +Release: raylib 2.5 (May 2019) +----------------------------------------------- +KEY CHANGES: + - [core] Redesigned Gamepad mechanism, now common to all platforms and gamepads + - [core] HighDPI monitors support with automatic content scaling + - [rlgl] Complete module redesign to use one single internal buffer + - [rlgl] VR system redesign to allow custom device parameters and distortion shader + - [shapes] New drawing shapes available: CircleSector, Ring and RectangleRounded + - [text] New text management API (multiple functions) + - [text] Full Unicode support (utf8 text) + - [textures] Cubemap textures support + - [textures] Quad and N-Patch drawing + - [models] Skeletal model animation support + - [models] Support multiple meshes per model + - [models] Support glTF model loading + +Detailed changes: +[build] REVIEWED: Default raylib and examples Makefile +[build] REVIEWED: Notepad++ NppExec scripts +[build] REVIEWED: VS2015 and VS2017 projects +[build] REVIEWED: Android APK build pipeline +[core] Converted most #defined values as enum values +[core] Complete redesign of RPI input system to use evdev events +[core] ADDED: IsWindowResized() - Check if window has been resized +[core] ADDED: IsWindowHidden() - Check if window is currently hidden +[core] ADDED: UnhideWindow() - Show the window +[core] ADDED: HideWindow() - Hide the window +[core] ADDED: GetWindowHandle() - Get native window handle +[core] ADDED: GetMonitorCount() - Get number of connected monitors +[core] ADDED: GetMonitorWidth() - Get primary monitor width +[core] ADDED: GetMonitorHeight() - Get primary monitor height +[core] ADDED: GetMonitorPhysicalWidth() - Get primary monitor physical width in millimetres +[core] ADDED: GetMonitorPhysicalHeight() - Get primary monitor physical height in millimetres +[core] ADDED: GetMonitorName() - Get the human-readable, UTF-8 encoded name of the primary monitor +[core] ADDED: GetClipboardText() - Get clipboard text content +[core] ADDED: SetClipboardText() - Set clipboard text content +[core] ADDED: ColorFromHSV() - Returns a Color from HSV values +[core] ADDED: FileExists() - Check if file exists +[core] ADDED: GetFileNameWithoutExt() - Get filename string without extension (memory should be freed) +[core] ADDED: GetDirectoryFiles() - Get filenames in a directory path (memory should be freed) +[core] ADDED: ClearDirectoryFiles() - Clear directory files paths buffers (free memory) +[core] ADDED: OpenURL() - Open URL with default system browser (if available) +[core] ADDED: SetMouseOffset() - Set mouse offset +[core] ADDED: SetMouseScale() - Set mouse scaling +[core] REMOVED: ShowLogo() - Activate raylib logo at startup (can be done with flags) +[shapes] ADDED: DrawCircleSector() - Draw a piece of a circle +[shapes] ADDED: DrawCircleSectorLines() - Draw circle sector outline +[shapes] ADDED: DrawRing() - Draw ring +[shapes] ADDED: DrawRingLines() - Draw ring outline +[shapes] ADDED: DrawRectangleRounded() - Draw rectangle with rounded edges +[shapes] ADDED: DrawRectangleRoundedLines() - Draw rectangle with rounded edges outline +[shapes] ADDED: SetShapesTexture() - Define default texture used to draw shapes +[textures] REVIEWED: ExportImage() - Reorder function parameters +[textures] REVIEWED: ImageDrawRectangle() - Remove unneeded parameter +[textures] ADDED: ExportImageAsCode() - Export image as code file defining an array of bytes +[textures] ADDED: LoadTextureCubemap() - Load cubemap from image, multiple image cubemap layouts supported +[textures] ADDED: ImageExtractPalette() - Extract color palette from image to maximum size (memory should be freed) +[textures] ADDED: ImageDrawRectangleLines() - Draw rectangle lines within an image +[textures] ADDED: DrawTextureQuad() - Draw texture quad with tiling and offset parameters +[textures] ADDED: DrawTextureNPatch() - Draws a texture (or part of it) that stretches or shrinks nicely +[models] REVIEWED: LoadMesh() -> LoadMeshes() - Support multiple meshes loading +[models] REVIEWED: LoadMaterial() -> LoadMaterials() - Support multiple materials loading +[models] REVIEWED: ExportMesh() - Reorder parameters +[models] ADDED: DrawCubeWiresV() - Draw cube wires (Vector version) +[models] ADDED: GenMeshPoly() - Generate polygonal mesh +[models] ADDED: SetMaterialTexture() - Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...) +[models] ADDED: SetModelMeshMaterial() - Set material for a mesh +[models] ADDED: LoadModelAnimations() - Load model animations from file +[models] ADDED: UpdateModelAnimation() - Update model animation pose +[models] ADDED: UnloadModelAnimation() - Unload animation data +[models] ADDED: IsModelAnimationValid() - Check model animation skeleton match +[rlgl] Improved internal batching mechanism (multibuffering support, triangle texcoords...) +[rlgl] REVIEWED: rlPushMatrix()/rlPopMatrix() - Now works like OpenGL 1.1 +[rlgl] REVIEWED: SetShaderValue() - More generic, now requires uniform type +[rlgl] REMOVED: SetShaderValuei() - Can be acoomplished with new SetShaderValue() +[rlgl] ADDED: SetShaderValueV() - Set shader uniform value vector +[rlgl] ADDED: SetShaderValueTexture() - Set shader uniform value for texture +[rlgl] ADDED: BeginScissorMode() - Begin scissor mode (define screen area for following drawing) +[rlgl] ADDED: EndScissorMode() - End scissor mode +[rlgl] ADDED: SetVrConfiguration() - Set stereo rendering configuration parameters +[rlgl] REVIEWED: InitVrSimulator() - No input parameter required, use SetVrConfiguration() +[text] REVIEWED: LoadFontEx() - Reorder function parameters +[text] REVIEWED: LoadFontData() - Reorder function parameters +[text] REVIEWED: GenImageFontAtlas() - Reorder function parameters +[text] RENAMED: FormatText() -> TextFormat() +[text] RENAMED: SubText() -> TextSubtext() +[text] ADDED: LoadFontFromImage() - Load font from Image (XNA style) +[text] ADDED: DrawTextRec() - Draw text using font inside rectangle limits +[text] ADDED: DrawTextRecEx() - Draw text using font inside rectangle limits with support for text selection +[text] ADDED: TextIsEqual() - Check if two text string are equal +[text] ADDED: TextLength() - Get text length, checks for '\0' ending +[text] ADDED: TextReplace() - Replace text string (memory should be freed!) +[text] ADDED: TextInsert() - Insert text in a position (memory should be freed!) +[text] ADDED: TextJoin() - Join text strings with delimiter +[text] ADDED: TextSplit() - Split text into multiple strings +[text] ADDED: TextAppend() - Append text at specific position and move cursor! +[text] ADDED: TextFindIndex() - Find first text occurrence within a string +[text] ADDED: TextToUpper() - Get upper case version of provided string +[text] ADDED: TextToLower() - Get lower case version of provided string +[text] ADDED: TextToPascal() - Get Pascal case notation version of provided string +[text] ADDED: TextToInteger() - Get integer value from text (negative values not supported) +[raudio] ADDED: ExportWave() - Export wave data to file +[raudio] ADDED: ExportWaveAsCode() - Export wave sample data to code (.h) +[raudio] ADDED: IsAudioStreamPlaying() - Check if audio stream is playing +[raudio] ADDED: SetAudioStreamVolume() - Set volume for audio stream (1.0 is max level) +[raudio] ADDED: SetAudioStreamPitch() - Set pitch for audio stream (1.0 is base level) +[examples] Complete review of full examples collection, many additions +[examples] ADDED: core_custom_logging - Custom trace log system +[examples] ADDED: core_input_multitouch - Multitouch input example +[examples] ADDED: core_window_letterbox - Window adapted to screen +[examples] ADDED: core_loading_thread - Data loading in second thread +[examples] REVIEWED: core_input_gamepad - Adapted to new gamepad system +[examples] REVIEWED: core_vr_simulator - HMD device parameters and distortion shader should be provided +[examples] ADDED: core_window_scale_letterbox - Windows resizing and letterbox content +[examples] ADDED: shapes_rectangle_scaling_mouse - Scale a rectangle with mouse +[examples] ADDED: shapes_draw_circle_sector - Circle sector drawing +[examples] ADDED: shapes_draw_ring - Ring drawing +[examples] ADDED: shapes_draw_rectangle_rounded - Rounded rectangle drawing +[examples] ADDED: shapes_bouncing_ball - Ball bouncing in the screen +[examples] ADDED: shapes_collision_area - Collision detection and drawing +[examples] ADDED: shapes_following_eyes - Some maths on eyes and mouse +[examples] ADDED: shapes_easings_ball_anim - Ball animation +[examples] ADDED: shapes_easings_box_anim - Box animation +[examples] ADDED: shapes_easings_rectangle_array - Rectangles animation +[examples] REVIEWED: shapes_colors_palette - Reviewed color selection and text displaying +[examples] ADDED: textures_background_scrolling - Scrolling and parallaz background effect +[examples] ADDED: textures_image_npatch - Drawing N-Patch based boxes +[examples] ADDED: textures_sprite_button - Sprite button with sound +[examples] ADDED: textures_sprite_explosion - Sprite explosion with sound +[examples] ADDED: textures_bunnymark - Benchmarking test +[examples] ADDED: text_draw_inside_rectangle - Drawing text inside a delimited rectangle box +[examples] ADDED: text_unicode - Multiple languages text drawing +[examples] ADDED: text_rectangle_bound - Fit text inside a rectangle +[examples] REVIEWED: text_bmfont_ttf - Simplified example +[examples] ADDED: models_animation - Animated models loading and animation playing +[examples] ADDED: models_obj_viewer - Draw and drop models viewer +[examples] ADDED: models_rlgl_solar_system - Solar system simulation using rlgl functionality +[examples] ADDED: models_first_person_maze - 3D maze fps +[examples] ADDED: shaders_palette_switch - Switching color palette on shader +[examples] ADDED: shaders_raymarching - Raymarching shader +[examples] ADDED: shaders_texture_drawing - Texture drawing on GPU +[examples] ADDED: shaders_texture_waves - Texture waves on shader +[examples] ADDED: shaders_julia_set - Julia set fractals +[examples] ADDED: shaders_eratosthenes - Prime number visualization shader +[examples] REVIEWED: audio_raw_stream - Mostly rewritten +[games] ADDED: GGJ19 game - Cat vs Roomba +[*] Updated external libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 2.0 (July 2018) +----------------------------------------------- +KEY CHANGES: + - Removed external dependencies (GLFW3 and OpenAL) + - Complete redesign of audio module to use miniaudio library + - Support AppVeyor and Travis CI (continuous integration) building + - Reviewed raymath.h for better consistency and performance (inlining) + - Refactor all #define SUPPORT_* into a single config.h + - Support TCC compiler (32bit and 64bit) + +Detailed changes: +[build] REMOVED: GitHub develop branch +[build] REMOVED: External dependencies GLFW and OpenAL +[build] ADDED: Android 64bit ARM support +[build] ADDED: FreeBSD, OpenBSD, NetBSD, Dragon Fly OS support +[build] ADDED: Universal Windows Platform (UWP) support +[build] ADDED: Wayland Linux desktop support +[build] ADDED: AppVeyor CI for automatic Windows builds +[build] ADDED: Travis CI for automatic Linux/macOS builds +[build] ADDED: rglfw (GLFW3 module) to avoid external dependency +[build] ADDED: VS2017 UWP project +[build] ADDED: Builder project template +[build] ADDED: Compiler memory sanitizer for better debug +[build] ADDED: CMake package target and CI auto-deploy tags +[build] ADDED: DEBUG library building support +[build] ADDED: Notepad++ NppExec scripts +[build] REVIEWED: VS2015 and VS2017 projects +[build] REVIEWED: Android APK build pipeline +[core] REVIEWED: Window creation hints to support transparent windows +[core] Unified InitWindow() between platforms +[core] Export Android main entry point +[core] RENAMED: Begin3dMode() to BeginMode3D() +[core] RENAMED: End3dMode() to EndMode3D() +[core] RENAMED: Begin2dMode() to BeginMode2D() +[core] RENAMED: End2dMode() to EndMode2D() +[core] RENAMED: struct Camera to Camera3D +[core] RENAMED: struct SpriteFont to Font -> plus all required functions! +[core] RENAMED: enum TextureFormat to PixelFormat +[core] REVIEWED: Rectangle params int to float +[core] REVIEWED: timing system for macOS +[core] REMOVED: ColorToFloat() +[core] ADDED: GetCurrentTime() on macOS +[core] ADDED: GetTime() +[core] ADDED: struct Vector4 +[core] ADDED: SetTraceLog() to define trace log messages type +[core] ADDED: GetFileName() to get filename from path string +[core] ADDED: ColorToHSV() +[core] ADDED: ColorNormalize() +[core] ADDED: SetWindowSize() to scale Windows in runtime +[core] ADDED: SetMouseScale() to scale mouse input +[core] ADDED: key definitions - KEY_GRAVE, KEY_SLASH, KEY_BACKSLASH +[core] RENAMED: GetHexValue() to ColorToInt() +[core] REVIEWED: Fade() +[core] REVIEWED: InitWindow() to avoid void pointer (safety) +[core] Support camera 3d orthographic projection mode +[shapes] ADDED: DrawRectangleLinesEx() +[textures] Improved pixel formats support (32bit channels) +[textures] Improved textures support for OpenGL 2.1 +[textures] REMOVED: DrawRectangleT() --> Added support to DrawRectangle() +[textures] ADDED: GetPixelDataSize(); pixel data size in bytes (image or texture) +[textures] ADDED: ImageAlphaClear() --> Clear alpha channel to desired color +[textures] ADDED: ImageAlphaCrop() --> Crop image depending on alpha value +[textures] ADDED: ImageAlphaPremultiply() --> Premultiply alpha channel +[textures] ADDED: ImageDrawRectangle() +[textures] ADDED: ImageMipmaps() +[textures] ADDED: GenImageColor() +[textures] ADDED: GetPixelDataSize() +[textures] ADDED: ImageRotateCW() +[textures] ADDED: ImageRotateCCW() +[textures] ADDED: ImageResizeCanvas() +[textures] ADDED: GetImageDataNormalized() +[textures] REVIEWED: ImageFormat() to use normalized data +[textures] REVIEWED: Manual mipmap generation +[textures] REVIEWED: LoadASTC() +[textures] REVIEWED: GenImagePerlinNoise() +[textures] REVIEWED: ImageTextEx() to support UTF8 basic characters +[textures] REVIEWED: GetTextureData() for RPI - requires some work +[textures] Added new example: text drawing on image +[text] Corrected issue with ttf font y-offset +[text] Support SDF font data generation +[text] ADDED: GenImageFontAtlas() +[text] ADDED: LoadFontData() to load data from TTF file +[text] REMOVED: LoadTTF() internal function +[text] REVIEWED: DrawTextEx() - avoid rendering SPACE character! +[text] RENAMED: GetDefaultFont() to GetFontDefault() +[rlgl] ADDED: rlCheckBufferLimit() +[rlgl] ADDED: LoadShaderCode() +[rlgl] ADDED: GetMatrixModelview() +[rlgl] ADDED: SetVrDistortionShader(Shader shader) +[rlgl] REVIEWED: rlLoadTexture() - added mipmaps support, improved compressed textures loading +[rlgl] REVIEWED: rlReadTexturePixels() +[models] Support 4 components mesh.tangent data +[models] Removed tangents generation from LoadOBJ() +[models] ADDED: MeshTangents() +[models] ADDED: MeshBinormals() +[models] ADDED: ExportMesh() +[models] ADDED: GetCollisionRayModel() +[models] RENAMED: CalculateBoundingBox() to MeshBoundingBox() +[models] REMOVED: GetCollisionRayMesh() - does not consider model transform +[models] REVIEWED: LoadMesh() - fallback to default cube mesh if loading fails +[audio] ADDED: Support for MP3 fileformat +[audio] ADDED: IsAudioStreamPlaying() +[audio] ADDED: SetAudioStreamVolume() +[audio] ADDED: SetAudioStreamPitch() +[utils] Corrected issue with SaveImageAs() +[utils] RENAMED: SaveImageAs() to ExportImage() +[utils] REMOVED: rres support - moved to external library (rres.h) +[shaders] REVIEWED: GLSL 120 shaders +[raymath] ADDED: Vector3RotateByQuaternion() +[raymath] REVIEWED: math usage to reduce temp variables +[raymath] REVIEWED: Avoid pointer-based parameters for API consistency +[physac] REVIEWED: physac.h timing system +[examples] Replaced dwarf model by brand new 3d assets: 3d medieval buildings +[examples] Assets cleaning and some replacements +[games] ADDED: GGJ18 game - transmission mission +[games] REVIEWED: Light my Ritual game - improved gameplay drawing +[*] Updated external libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 1.8.0 (Oct 2017) +----------------------------------------------- +NOTE: + In this release, multiple parts of the library have been reviewed (again) for consistency and simplification. + It exposes more than 30 new functions in comparison with previous version and it improves overall programming experience. + +BIG CHANGES: + - New Image generation functions: Gradient, Checked, Noise, Cellular... + - New Mesh generation functions: Cube, Sphere, Cylinder, Torus, Knot... + - New Shaders and Materials systems to support PBR materials + - Custom Android APK build pipeline with simple Makefile + - Complete review of rlgl layer functionality + - Complete review of raymath functionality + +detailed changes: +[rlgl] RENAMED: rlglLoadTexture() to rlLoadTexture() +[rlgl] RENAMED: rlglLoadRenderTexture() to rlLoadRenderTexture() +[rlgl] RENAMED: rlglUpdateTexture() to rlUpdateTexture() +[rlgl] RENAMED: rlglGenerateMipmaps() to rlGenerateMipmaps() +[rlgl] RENAMED: rlglReadScreenPixels() to rlReadScreenPixels() +[rlgl] RENAMED: rlglReadTexturePixels() to rlReadTexturePixels() +[rlgl] RENAMED: rlglLoadMesh() to rlLoadMesh() +[rlgl] RENAMED: rlglUpdateMesh() to rlUpdateMesh() +[rlgl] RENAMED: rlglDrawMesh() to rlDrawMesh() +[rlgl] RENAMED: rlglUnloadMesh() to rlUnloadMesh() +[rlgl] RENAMED: rlglUnproject() to rlUnproject() +[rlgl] RENAMED: LoadCompressedTexture() to LoadTextureCompressed() +[rlgl] RENAMED: GetDefaultTexture() to GetTextureDefault() +[rlgl] RENAMED: LoadDefaultShader() to LoadShaderDefault() +[rlgl] RENAMED: LoadDefaultShaderLocations() to SetShaderDefaultLocations() +[rlgl] RENAMED: UnloadDefaultShader() to UnLoadShaderDefault() +[rlgl] ADDED: rlGenMapCubemap(), Generate cubemap texture map from HDR texture +[rlgl] ADDED: rlGenMapIrradiance(), Generate irradiance texture map +[rlgl] ADDED: rlGenMapPrefilter(), Generate prefilter texture map +[rlgl] ADDED: rlGenMapBRDF(), Generate BRDF texture map +[rlgl] ADDED: GetVrDeviceInfo(), Get VR device information for some standard devices +[rlgl] REVIEWED: InitVrSimulator(), to accept device parameters as input +[core] ADDED: SetWindowTitle(), Set title for window (only PLATFORM_DESKTOP) +[core] ADDED: GetExtension(), Get file extension +[shapes] REMOVED: DrawRectangleGradient(), replaced by DrawRectangleGradientV() and DrawRectangleGradientH() +[shapes] ADDED: DrawRectangleGradientV(), Draw a vertical-gradient-filled rectangle +[shapes] ADDED: DrawRectangleGradientH(), Draw a horizontal-gradient-filled rectangle +[shapes] ADDED: DrawRectangleGradientEx(), Draw a gradient-filled rectangle with custom vertex colors +[shapes] ADDED: DrawRectangleT(), Draw rectangle using text character +[textures] ADDED: SaveImageAs(), Save image as PNG file +[textures] ADDED: GenImageGradientV(), Generate image: vertical gradient +[textures] ADDED: GenImageGradientH(), Generate image: horizontal gradient +[textures] ADDED: GenImageGradientRadial(), Generate image: radial gradient +[textures] ADDED: GenImageChecked(), Generate image: checked +[textures] ADDED: GenImageWhiteNoise(), Generate image: white noise +[textures] ADDED: GenImagePerlinNoise(), Generate image: perlin noise +[textures] ADDED: GenImageCellular(), Generate image: cellular algorithm. Bigger tileSize means bigger cells +[textures] ADDED: GenTextureCubemap(), Generate cubemap texture from HDR texture +[textures] ADDED: GenTextureIrradiance(), Generate irradiance texture using cubemap data +[textures] ADDED: GenTexturePrefilter(), Generate prefilter texture using cubemap data +[textures] ADDED: GenTextureBRDF(), Generate BRDF texture using cubemap data +[models] REMOVED: LoadMeshEx(), Mesh struct variables can be directly accessed +[models] REMOVED: UpdateMesh(), very ineficient +[models] REMOVED: LoadHeightmap(), use GenMeshHeightmap() and LoadModelFromMesh() +[models] REMOVED: LoadCubicmap(), use GenMeshCubicmap() and LoadModelFromMesh() +[models] RENAMED: LoadDefaultMaterial() to LoadMaterialDefault() +[models] ADDED: GenMeshPlane(), Generate plane mesh (with subdivisions) +[models] ADDED: GenMeshCube(), Generate cuboid mesh +[models] ADDED: GenMeshSphere(), Generate sphere mesh (standard sphere) +[models] ADDED: GenMeshHemiSphere(), Generate half-sphere mesh (no bottom cap) +[models] ADDED: GenMeshCylinder(), Generate cylinder mesh +[models] ADDED: GenMeshTorus(), Generate torus mesh +[models] ADDED: GenMeshKnot(), Generate trefoil knot mesh +[models] ADDED: GenMeshHeightmap(), Generate heightmap mesh from image data +[models] ADDED: GenMeshCubicmap(), Generate cubes-based map mesh from image data +[raymath] REVIEWED: full Matrix functionality to align with GLM in usage +[raymath] RENAMED: Vector3 functions for consistency: Vector*() renamed to Vector3*() +[build] Integrate Android APK building into examples Makefile +[build] Integrate Android APK building into templates Makefiles +[build] Improved Visual Studio 2015 project, folders, references... +[templates] Reviewed the full pack to support Android building +[examples] Reviewed full collection to adapt to raylib changes +[examples] [textures] ADDED: textures_image_generation +[examples] [models] ADDED: models_mesh_generation +[examples] [models] ADDED: models_material_pbr +[examples] [models] ADDED: models_skybox +[examples] [models] ADDED: models_yaw_pitch_roll +[examples] [others] REVIEWED: rlgl_standalone +[examples] [others] REVIEWED: audio_standalone +[github] Moved raylib webpage to own repo: github.com/raysan5/raylib.com +[games] Reviewed game: Koala Seasons +[*] Updated STB libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 1.7.0 (20 May 2017) +----------------------------------------------- +NOTE: + In this new raylib release, multiple parts of the library have been reviewed for consistency and simplification. + It exposes almost 300 functions, around 30 new functions in comparison with previous version and, again, + it sets a stepping stone towards raylib future. + +BIG changes: + - More than 30 new functions added to the library, check list below. + - Support of configuration flags on every raylib module, to customize library build. + - Improved build system for all supported platforms with a unique Makefile to compile sources. + - Complete review of examples and sample games, added new sample material. + - Support automatic GIF recording of current window, just pressing Ctrl+F12 + - Improved library consistency and organization in general. + +other changes: +[core] Added function: SetWindowIcon(), to setup icon by code +[core] Added function: SetWindowMonitor(), to set current display monitor +[core] Added function: SetWindowMinSize(), to set minimum resize size +[core] Added function: TakeScreenshot(), made public to API (also launched internally with F12) +[core] Added function: GetDirectoryPath(), get directory for a given fileName (with path) +[core] Added function: GetWorkingDirectory(), get current working directory +[core] Added function: ChangeDirectory(), change working directory +[core] Added function: TraceLog(), made public to API +[core] Improved timing system to avoid busy wait loop on frame sync: Wait() +[core] Added support for gamepad on HTML5 platform +[core] Support mouse lock, useful for camera system +[core] Review functions description comments +[rlgl] Removed function: GetStandardShader(), removed internal standard shader +[rlgl] Removed function: CreateLight(), removed internal lighting system +[rlgl] Removed function: DestroyLight(), removed internal lighting system +[rlgl] Removed function: InitVrDevice(), removed VR device render, using simulator +[rlgl] Removed function: CloseVrDevice(), removed VR device render, using simulator +[rlgl] Removed function: IsVrDeviceReady(), removed VR device render, using simulator +[rlgl] Removed function: IsVrSimulator(), removed VR device render, using simulator +[rlgl] Added function: InitVrSimulator(), init VR simulator for selected device +[rlgl] Added function: CloseVrSimulator(), close VR simulator for current device +[rlgl] Added function: IsVrSimulatorReady(), detect if VR device is ready +[rlgl] Added function: BeginVrDrawing(), begin VR simulator stereo rendering +[rlgl] Added function: EndVrDrawing(), end VR simulator stereo rendering +[rlgl] Renamed function: ReadTextFile() to LoadText() and exposed to API +[rlgl] Removed internal lighting system and standard shader, moved to example +[rlgl] Removed Oculus Rift support, moved to oculus_rift example +[rlgl] Removed VR device support and replaced by VR simulator +[shapes] Added function: DrawLineEx(), draw line with QUADS, supports custom line thick +[shapes] Added function: DrawLineBezier(), draw a line using cubic-bezier curves in-out +[shapes] Added function: DrawRectanglePro(), draw a color-filled rectangle with pro parameters +[textures] Removed function: LoadImageFromRES(), redesigning custom RRES fileformat +[textures] Removed function: LoadTextureFromRES(), redesigning custom RRES fileformat +[textures] Removed function: LoadTextureEx(), use instead Image -> LoadImagePro(), LoadImageEx() +[textures] Added function: LoadImagePro()), load image from raw data with parameters +[textures] Review TraceLog() message when image file not found +[text] Renamed function: LoadSpriteFontTTF() to LoadSpriteFontEx(), for consistency +[text] Removed rBMF fileformat support, replaced by .png +[text] Refactor SpriteFont struct (better for rres custom fileformat) +[text] Renamed some variables for consistency +[models] Added function: LoadMesh(), load mesh from file +[models] Added function: LoadMeshEx(), load mesh from vertex data +[models] Added function: UnloadMesh(), unload mesh from memory (RAM and/or VRAM) +[models] Added function: GetCollisionRayMesh(), get collision info between ray and mesh +[models] Added function: GetCollisionRayTriangle(), get collision info between ray and triangle +[models] Added function: GetCollisionRayGround(), get collision info between ray and ground plane +[models] Renamed function: LoadModelEx() to LoadModelFromMesh() +[models] Removed function: DrawLight(), removed internal lighting system +[models] Renamed function: LoadModelEx() to LoadModelFromMesh() for consistency +[models] Removed function: LoadStandardMaterial(), removed internal standard shader +[models] Removed function: LoadModelFromRES(), redesigning custom RRES fileformat +[models] Renamed multiple variables for consistency +[audio] Added function: SetMasterVolume(), define listener volume +[audio] Added function: ResumeSound(), resume a paused sound +[audio] Added function: SetMusicLoopCount(), set number of repeats for a music +[audio] Added function: LoadWaveEx(), load wave from raw audio data +[audio] Added function: WaveCrop(), crop wave audio data +[audio] Added function: WaveFormat(), format audio data +[audio] Removed function: LoadSoundFromRES(), redesigning custom RRES fileformat +[audio] Added support for 32bit audio samples +[audio] Preliminary support for multichannel, limited to mono and stereo +[audio] Make sure buffers are ready for update: UpdateMusicStream() +[utils] Replaced function: GetExtension() by IsFileExtension() and made public to API +[utils] Unified function: TraceLog() between Android and other platforms +[utils] Removed internal function: GetNextPOT(), simplified implementation +[raymath] Added function: QuaternionToEuler(), to work with Euler angles +[raymath] Added function: QuaternionFromEuler(), to work with Euler angles +[raymath] Added multiple Vector2 math functions +[build] Integrate Android source building into Makefile +[example] Added example: shapes_lines_bezier +[example] Added example: text_input_box +[github] Moved gh-pages branch to master/docs +[github] Moved rlua.h and Lua examples to own repo: raylib-lua +[games] Reviewed full games collection +[games] New game added to collection: Koala Seasons +[*] Reviewed and improved examples collection (new assets) +[*] Reorganized library functions, structs, enums +[*] Updated STB libraries to latest version + +----------------------------------------------- +Release: raylib 1.6.0 (20 November 2016) +----------------------------------------------- +NOTE: + This new raylib version commemorates raylib 3rd anniversary and represents another complete review of the library. + It includes some interesting new features and is a stepping stone towards raylib future. + +HUGE changes: +[rlua] Lua BINDING: Complete raylib Lua binding, ALL raylib functions ported to Lua plus the +60 code examples. +[audio] COMPLETE REDESIGN: Improved music support and also raw audio data processing and playing, +20 new functions added. +[physac] COMPLETE REWRITE: Improved performance, functionality and simplified usage, moved to own repository and added multiple examples! + +other changes: + +[core] Corrected issue on OSX with HighDPI display +[core] Added flag to allow resizable window +[core] Allow no default font loading +[core] Corrected old issue with mouse buttons on web +[core] Improved gamepad support, unified across platforms +[core] Gamepad id functionality: GetGamepadName(), IsGamepadName() +[core] Gamepad buttons/axis checking functionality: +[core] Reviewed Android key inputs system, unified with desktop +[rlgl] Redesigned lighting shader system +[rlgl] Updated standard shader for better performance +[rlgl] Support alpha on framebuffer: rlglLoadRenderTexture() +[rlgl] Reviewed UpdateVrTracking() to update camera +[rlgl] Added IsVrSimulator() to check for VR simulator +[shapes] Corrected issue on DrawPolyEx() +[textures] Simplified supported image formats support +[textures] Improved text drawing within an image: ImageDrawText() +[textures] Support image alpha mixing: ImageAlphaMask() +[textures] Support textures filtering: SetTextureFilter() +[textures] Support textures wrap modes: SetTextureWrap() +[text] Improved TTF spritefont generation: LoadSpriteFontTTF() +[text] Improved AngelCode fonts support (unordered chars) +[text] Added TraceLog info on image spritefont loading +[text] Improved text measurement: MeasureTextEx() +[models] Improved OBJ loading flexibility +[models] Reviewed functions: DrawLine3D(), DrawCircle3D() +[models] Removed function: ResolveCollisionCubicmap() +[camera] Redesigned camera system and ported to header-only +[camera] Removed function: UpdateCameraPlayer() +[gestures] Redesigned gestures module to header-only +[audio] Simplified Music loading and playing system +[audio] Added trace on audio device closing +[audio] Reviewed Wave struct, improved flexibility +[audio] Support sound data update: UpdateSound() +[audio] Added support for FLAC audio loading/streaming +[raygui] Removed raygui from raylib repo (moved to own repo) +[build] Added OpenAL static library +[build] Added Visual Studio 2015 projects +[build] Support shared/dynamic raylib compilation +[*] Updated LibOVR to SDK version 1.8 +[*] Updated games to latest raylib version +[*] Improved examples and added new ones +[*] Improved Android support + +----------------------------------------------- +Release: raylib 1.5.0 (18 July 2016) +----------------------------------------------- +NOTE: + Probably this new version is the biggest boost of the library ever, lots of parts of the library have been redesigned, + lots of bugs have been solved and some **AMAZING** new features have been added. + +HUGE changes: +[rlgl] OCULUS RIFT CV1: Added support for VR, not oly Oculus Rift CV1 but also stereo rendering simulator (multiplatform). +[rlgl] MATERIALS SYSTEM: Added support for Materials (.mtl) and multiple material properties: diffuse, specular, normal. +[rlgl] LIGHTING SYSTEM: Added support for up to 8 lights of 3 different types: Omni, Directional and Spot. +[physac] REDESIGNED: Improved performance and simplified usage, physic objects now are managed internally in a second thread! +[audio] CHIPTUNES: Added support for module audio music (.xm, .mod) loading and playing. Multiple mixing channels supported. + +other changes: + +[core] Review Android button inputs +[core] Support Android internal data storage +[core] Renamed WorldToScreen() to GetWorldToScreen() +[core] Removed function SetCustomCursor() +[core] Removed functions BeginDrawingEx(), BeginDrawingPro() +[core] Replaced functions InitDisplay() + InitGraphics() with: InitGraphicsDevice() +[core] Added support for field-of-view Y (fovy) on 3d Camera +[core] Added 2D camera mode functions: Begin2dMode() - End2dMode() +[core] Translate mouse inputs to Android touch/gestures internally +[core] Translate mouse inputs as touch inputs in HTML5 +[core] Improved function GetKeyPressed() to support multiple keys (including function keys) +[core] Improved gamepad support, specially for RaspberryPi (including multiple gamepads support) +[rlgl] Support stereo rendering simulation (duplicate draw calls by viewport, optimized) +[rlgl] Added distortion shader (embeded) to support custom VR simulator: shader_distortion.h +[rlgl] Added support for OpenGL 2.1 on desktop +[rlgl] Improved 2D vs 3D drawing system (lines, triangles, quads) +[rlgl] Improved DXT-ETC1 support on HTML5 +[rlgl] Review function: rlglUnproject() +[rlgl] Removed function: rlglInitGraphics(), integrated into rlglInit() +[rlgl] Updated Mesh and Shader structs +[rlgl] Simplified internal (default) dynamic buffers +[rlgl] Added support for indexed and dynamic mesh data +[rlgl] Set fixed vertex attribs location points +[rlgl] Improved mesh data loading support +[rlgl] Added standard shader (embeded) to support materials and lighting: shader_standard.h +[rlgl] Added light functions: CreateLight(), DestroyLight() +[rlgl] Added wire mode functions: rlDisableWireMode(), rlEnableWireMode() +[rlgl] Review function consistency, added: rlglLoadMesh(), rlglUpdateMesh(), rlglDrawMesh(), rlglUnloadMesh() +[rlgl] Replaced SetCustomShader() by: BeginShaderMode() - EndShaderMode() +[rlgl] Replaced SetBlendMode() by: BeginBlendMode() - EndBlendMode() +[rlgl] Added functions to customize internal matrices: SetMatrixProjection(), SetMatrixModelview() +[rlgl] Unified internal shaders to only one default shader +[rlgl] Added support for render to texture (RenderTexture2D): + LoadRenderTexture() - UnloadRenderTexture() + BeginTextureMode() - EndTextureMode() +[rlgl] Removed SetShaderMap*() functions +[rlgl] Redesigned default buffers usage functions: + LoadDefaultBuffers() - UnloadDefaultBuffers() + UpdateDefaultBuffers() - DrawDefaultBuffers() +[shapes] Corrected bug on GetCollisionRec() +[textures] Added support for Nearest-Neighbor image scaling +[textures] Added functions to draw text on image: ImageDrawText(), ImageDrawTextEx() +[text] Reorganized internal functions: Added LoadImageFont() +[text] Security check for unsupported BMFonts +[models] Split mesh creation from model loading on heightmap and cubicmap +[models] Updated BoundingBox collision detections +[models] Added color parameter to DrawBoundigBox() +[models] Removed function: DrawQuad() +[models] Removed function: SetModelTexture() +[models] Redesigned DrawPlane() to use RL_TRIANGLES +[models] Redesigned DrawRectangleV() to use RL_TRIANGLES +[models] Redesign to accomodate new materials system: LoadMaterial() +[models] Added material functions: LoadDefaultMaterial(), LoadStandardMaterial() +[models] Added MTL material loading support: LoadMTL() +[models] Added function: DrawLight() +[audio] Renamed SoundIsPlaying() to IsSoundPlaying() +[audio] Renamed MusicIsPlaying() to IsMusicPlaying() +[audio] Support multiple Music streams (indexed) +[audio] Support multiple mixing channels +[gestures] Improved and reviewed gestures system +[raymath] Added QuaternionInvert() +[raymath] Removed function: PrintMatrix() +[raygui] Ported to header-only library (https://github.com/raysan5/raygui) +[shaders] Added depth drawing shader (requires a depth texture) +[shaders] Reviewed included shaders and added comments +[OpenAL Soft] Updated to latest version (1.17.2) +[GLFW3] Updated to latest version (3.2) +[stb] Updated to latest headers versions +[GLAD] Converted to header only library and simplified to only used extensions +[*] Reorganize library folders: external libs moved to src/external folder +[*] Reorganize src folder for Android library +[*] Review external dependencies usage +[*] Improved Linux and OSX build systems +[*] Lots of tweaks and bugs corrected all around + +----------------------------------------------- +Release: raylib 1.4.0 (22 February 2016) +----------------------------------------------- +NOTE: + This version supposed another big improvement for raylib, including new modules and new features. + More than 30 new functions have been added to previous raylib version. + Around 8 new examples and +10 new game samples have been added. + +BIG changes: +[textures] IMAGE MANIPULATION: Functions to crop, resize, colorize, flip, dither and even draw image-to-image or text-to-image. +[text] SPRITEFONT SUPPORT: Added support for AngelCode fonts (.fnt) and TrueType fonts (.ttf). +[gestures] REDESIGN: Gestures system simplified and prepared to process generic touch events, including mouse events (multiplatform). +[physac] NEW MODULE: Basic 2D physics support, use colliders and rigidbodies; apply forces to physic objects. + +other changes: + +[rlgl] Removed GLEW library dependency, now using GLAD +[rlgl] Implemented alternative to glGetTexImage() on OpenGL ES +[rlgl] Using depth data on batch drawing +[rlgl] Reviewed glReadPixels() function +[core][rlgl] Reviewed raycast system, now 3D picking works +[core] Android: Reviewed Android App cycle, paused if inactive +[shaders] Implemented Blinn-Phong lighting shading model +[textures] Implemented Floyd-Steinberg dithering - ImageDither() +[text] Added line-break support to DrawText() +[text] Added TrueType Fonts support (using stb_truetype) +[models] Implement function: CalculateBoundingBox(Mesh mesh) +[models] Added functions to check Ray collisions +[models] Improve map resolution control on LoadHeightmap() +[camera] Corrected small-glitch on zoom-in with mouse-wheel +[gestures] Implemented SetGesturesEnabled() to enable only some gestures +[gestures] Implemented GetElapsedTime() on Windows system +[gestures] Support mouse gestures for desktop platforms +[raymath] Complete review of the module and converted to header-only +[easings] Added new module for easing animations +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +----------------------------------------------- +Release: raylib 1.3.0 (01 September 2015) +----------------------------------------------- +NOTE: + This version supposed a big boost for raylib, new modules have been added with lots of features. + Most of the modules have been completely reviewed to accomodate to the new features. + Over 50 new functions have been added to previous raylib version. + Most of the examples have been redone and +10 new advanced examples have been added. + +BIG changes: +[rlgl] SHADERS: Support for model shaders and postprocessing shaders (multiple functions) +[textures] FORMATS: Support for multiple internal formats, including compressed formats +[camera] NEW MODULE: Set of cameras for 3d view: Free, Orbital, 1st person, 3rd person +[gestures] NEW MODULE: Gestures system for Android and HTML5 platforms +[raygui] NEW MODULE: Set of IMGUI elements for tools development (experimental) + +other changes: + +[rlgl] Added check for OpenGL supported extensions +[rlgl] Added function SetBlenMode() to select some predefined blending modes +[core] Added support for drop&drag of external files into running program +[core] Added functions ShowCursor(), HideCursor(), IsCursorHidden() +[core] Renamed function SetFlags() to SetConfigFlags() +[shapes] Simplified some functions to improve performance +[textures] Review of Image struct to support multiple data formats +[textures] Added function LoadImageEx() +[textures] Added function LoadImageRaw() +[textures] Added function LoadTextureEx() +[textures] Simplified function parameters LoadTextureFromImage() +[textures] Added function GetImageData() +[textures] Added function GetTextureData() +[textures] Renamed function ConvertToPOT() to ImageConvertToPOT() +[textures] Added function ImageConvertFormat() +[textures] Added function GenTextureMipmaps() +[text] Added support for Latin-1 Extended characters for default font +[text] Redesigned SpriteFont struct, replaced Character struct by Rectangle +[text] Removed function GetFontBaseSize(), use directly spriteFont.size +[models] Review of struct: Model (added shaders support) +[models] Added 3d collision functions (sphere vs sphere vs box vs box) +[models] Added function DrawCubeTexture() +[models] Added function DrawQuad() +[models] Added function DrawRay() +[models] Simplified function DrawPlane() +[models] Removed function DrawPlaneEx() +[models] Simplified function DrawGizmo() +[models] Removed function DrawGizmoEx() +[models] Added function LoadModelEx() +[models] Review of function LoadCubicMap() +[models] Added function ResolveCollisionCubicmap() +[audio] Decopupled from raylib, now this module can be used as standalone +[audio] Added function UpdateMusicStream() +[raymath] Complete review of the module +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +----------------------------------------------- +Release: raylib 1.2.2 (31 December 2014) +----------------------------------------------- +[*] Added support for HTML5 compiling (emscripten, asm.js) +[core] Corrected bug on input handling (keyboard and mouse) +[textures] Renamed function CreateTexture() to LoadTextureFromImage() +[textures] Added function ConvertToPOT() +[rlgl] Added support for color tint on models on GL 3.3+ and ES2 +[rlgl] Added support for normals on models +[models] Corrected bug on DrawBillboard() +[models] Corrected bug on DrawHeightmap() +[models] Renamed LoadCubesmap() to LoadCubicmap() +[audio] Added function LoadSoundFromWave() +[makefile] Added support for Linux and OSX compiling +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +--------------------------------------------------------------- +Update: raylib 1.2.1 (17 October 2014) (Small Fixes Update) +--------------------------------------------------------------- +[core] Added function SetupFlags() to preconfigure raylib Window +[core] Corrected bug on fullscreen mode +[rlgl] rlglDrawmodel() - Added rotation on Y axis +[text] MeasureTextEx() - Corrected bug on measures for default font + +----------------------------------------------- +Release: raylib 1.2 (16 September 2014) +----------------------------------------------- +NOTE: + This version supposed a complete redesign of the [core] module to support Android and Raspberry Pi. + Multiples modules have also been tweaked to accomodate to the new platforms, specially [rlgl] + +[core] Added multiple platforms support: Android and Raspberry Pi +[core] InitWindow() - Complete rewrite and split for Android +[core] InitDisplay() - Internal function added to calculate proper display size +[core] InitGraphics() - Internal function where OpenGL graphics are initialized +[core] Complete refactoring of input functions to accomodate to new platforms +[core] Mouse and Keyboard raw data reading functions added for Raspberry Pi +[core] GetTouchX(), GetTouchY() - Added for Android +[core] Added Android callbacks to process inputs and Android activity commands +[rlgl] Adjusted buffers depending on platform +[rlgl] Added security check in case deployed vertex excess buffer size +[rlgl] Adjusted indices type depending on GL version (int or short) +[rlgl] Fallback to VBOs only usage if VAOs not supported on ES2 +[rlgl] rlglLoadModel() stores vbo ids on new Model struct +[textures] Added support for PKM files (ETC1, ETC2 compression support) +[shapes] DrawRectangleV() - Modified, depending on OGL version uses TRIANGLES or QUADS +[text] LoadSpriteFont() - Modified to use LoadImage() +[models] Minor changes on models loading to accomodate to new Model struct +[audio] PauseMusicStream(), ResumeMusicStream() - Added +[audio] Reduced music buffer size to avoid stalls on Raspberry Pi +[src] Added makefile for Windows and RPI +[src] Added resources file (raylib icon and executable info) +[examples] Added makefile for Windows and RPI +[examples] Renamed and merged with test examples for coherence with module names +[templates] Added multiple templates to be use as a base-code for games + +----------------------------------------------- +Release: raylib 1.1.1 (22 July 2014) +----------------------------------------------- +[core] ShowLogo() - To enable raylib logo animation at startup +[core] Corrected bug with window resizing +[rlgl] Redefined colors arrays to use byte instead of float +[rlgl] Removed double buffer system (no performance improvement) +[rlgl] rlglDraw() - Reorganized buffers drawing order +[rlgl] Corrected bug on screen resizing +[shapes] DrawRectangle() - Use QUADS instead of TRIANGLES +[models] DrawSphereWires() - Corrected some issues +[models] LoadOBJ() - Redesigned to support multiple meshes +[models] LoadCubesMap() - Loading a map as cubes (by pixel color) +[textures] Added security check if file doesn't exist +[text] Corrected bug on SpriteFont loading +[examples] Corrected some 3d examples +[test] Added cubesmap loading test + +----------------------------------------------- +Release: raylib 1.1.0 (19 April 2014) +----------------------------------------------- +NOTE: + This version supposed a complete internal redesign of the library to support OpenGL 3.3+ and OpenGL ES 2.0. + New module [rlgl] has been added to 'translate' immediate mode style functions (i.e. rlVertex3f()) to GL 1.1, 3.3+ or ES2. + Another new module [raymath] has also been added with lot of useful 3D math vector-matrix-quaternion functions. + +[rlgl] New module, abstracts OpenGL rendering (multiple versions support) +[raymath] New module, useful 3D math vector-matrix-quaternion functions +[core] Adapt all OpenGL code (initialization, drawing) to use [rlgl] +[shapes] Rewrite all shapes drawing functions to use [rlgl] +[textures] Adapt texture GPU loading to use [rlgl] +[textures] Added support for DDS images (compressed and uncompressed) +[textures] CreateTexture() - Redesigned to add mipmap automatic generation +[textures] DrawTexturePro() - Redesigned and corrected bugs +[models] Rewrite all 3d-shapes drawing functions to use [rlgl] +[models] Adapt model loading and drawing to use [rlgl] +[models] Model struct updated to include texture id +[models] SetModelTexture() - Added, link a texture to a model +[models] DrawModelEx() - Redesigned with extended parameters +[audio] Added music streaming support (OGG files) +[audio] Added support for OGG files as Sound +[audio] PlayMusicStream() - Added, open a new music stream and play it +[audio] StopMusicStream() - Added, stop music stream playing and close stream +[audio] PauseMusicStream() - Added, pause music stream playing +[audio] MusicIsPlaying() - Added, to check if music is playing +[audio] SetMusicVolume() - Added, set volume for music +[audio] GetMusicTimeLength() - Added, get current music time length (in seconds) +[audio] GetMusicTimePlayed() - Added, get current music time played (in seconds) +[utils] Added log tracing functionality - TraceLog(), TraceLogOpen(), TraceLogClose() +[*] Log tracing messages all around the code + +----------------------------------------------- +Release: raylib 1.0.6 (16 March 2014) +----------------------------------------------- +[core] Removed unused lighting-system code +[core] Removed SetPerspective() function, calculated directly +[core] Unload and reload default font on fullscreen toggle +[core] Corrected bug gamepad buttons checking if no gamepad available +[texture] DrawTextureV() - Added, to draw using Vector2 for position +[texture] LoadTexture() - Redesigned, now uses LoadImage() + CreateTexture() +[text] FormatText() - Corrected memory leak bug +[models] Added Matrix struct and related functions +[models] DrawBillboard() - Reviewed, now it works! +[models] DrawBillboardRec() - Reviewed, now it works! +[tests] Added folder with multiple tests for new functions + +----------------------------------------------- +Update: raylib 1.0.5 (28 January 2014) +----------------------------------------------- +[audio] LoadSound() - Corrected a bug, WAV file was not closed! +[core] GetMouseWheelMove() - Added, check mouse wheel Y movement +[texture] CreateTexture2D() renamed to CreateTexture() +[models] LoadHeightmap() - Added, Heightmap can be loaded as a Model +[tool] rREM updated, now supports (partially) drag and drop of files + +----------------------------------------------- +Release: raylib 1.0.4 (23 January 2014) +----------------------------------------------- +[tool] Published a first alpha version of rREM tool (raylib Resource Embedder) +[core] GetRandomValue() - Bug corrected, now works right +[core] Fade() - Added, fades a color to an alpha percentadge +[core] WriteBitmap() - Moved to new module: utils.c, not used anymore +[core] TakeScreenshot() - Now uses WritePNG() (utils.c) +[utils] New module created with utility functions +[utils] WritePNG() - Write a PNG file (used by TakeScreenshot() on core) +[utils] DecompressData() - Added, used for rRES resource data decompresion +[textures] LoadImageFromRES() - Added, load an image from a rRES resource file +[textures] LoadTextureFromRES() - Added, load a texture from a rRES resource file +[audio] LoadSoundFromRES() - Added, load a sound from a rRES resource file +[audio] IsPlaying() - Added, check if a sound is currently playing +[audio] SetVolume() - Added, set the volume for a sound +[audio] SetPitch() - Added, set the pitch for a sound +[examples] ex06a_color_select completed +[examples] ex06b_logo_anim completed +[examples] ex06c_font select completed + +----------------------------------------------- +Release: raylib 1.0.3 (19 December 2013) +----------------------------------------------- +[fonts] Added 8 rBMF free fonts to be used on projects! +[text] LoadSpriteFont() - Now supports rBMF file loading (raylib Bitmap Font) +[examples] ex05a_sprite_fonts completed +[examples] ex05b_rbmf_fonts completed +[core] InitWindowEx() - InitWindow with extended parameters, resizing option and custom cursor! +[core] GetRandomValue() - Added, returns a random value within a range (int) +[core] SetExitKey() - Added, sets a key to exit program (default is ESC) +[core] Custom cursor not drawn when mouse out of screen +[shapes] CheckCollisionPointRec() - Added, check collision between point and rectangle +[shapes] CheckCollisionPointCircle() - Added, check collision between point and circle +[shapes] CheckCollisionPointTriangle() - Added, check collision between point and triangle +[shapes] DrawPoly() - Added, draw regular polygons of n sides, rotation can be defined! + +----------------------------------------------- +Release: raylib 1.0.2 (1 December 2013) +----------------------------------------------- +[text] GetDefaultFont() - Added, get default SpriteFont to be used on DrawTextEx() +[shapes] CheckCollisionRecs() - Added, check collision between rectangles +[shapes] CheckCollisionCircles() - Added, check collision between circles +[shapes] CheckCollisionCircleRec() - Added, check collision circle-rectangle +[shapes] GetCollisionRec() - Added, get collision rectangle +[textures] CreateTexture2D() - Added, create Texture2D from Image data +[audio] Fixed WAV loading function, now audio works! + +----------------------------------------------- +Update: raylib 1.0.1 (28 November 2013) +----------------------------------------------- +[text] DrawText() - Removed spacing parameter +[text] MeasureText() - Removed spacing parameter +[text] DrawFps() - Renamed to DrawFPS() for coherence with similar function +[core] IsKeyPressed() - Change functionality, check if key pressed once +[core] IsKeyDown() - Added, check if key is being pressed +[core] IsKeyReleased() - Change functionality, check if key released once +[core] IsKeyUp() - Added, check if key is being NOT pressed +[core] IsMouseButtonDown() - Added, check if mouse button is being pressed +[core] IsMouseButtonPressed() - Change functionality, check if mouse button pressed once +[core] IsMouseButtonUp() - Added, check if mouse button is NOT being pressed +[core] IsMouseButtonReleased() - Change functionality, check if mouse button released once +[textures] DrawTexturePro() - Added, texture drawing with 'pro' parameters +[examples] Function changes applied to ALL examples + +----------------------------------------------- +Release: raylib 1.0.0 (18 November 2013) +----------------------------------------------- +* Initial version +* 6 Modules provided: + - core: basic window/context creation functions, input management, timing functions + - shapes: basic shapes drawing functions + - textures: image data loading and conversion to OpenGL textures + - text: text drawing, sprite fonts loading, default font loading + - models: basic 3d shapes drawing, OBJ models loading and drawing + - audio: audio device initialization, WAV files loading and playing diff --git a/raylib-src/raylib-5.0_linux_amd64/LICENSE b/raylib-src/raylib-5.0_linux_amd64/LICENSE new file mode 100644 index 0000000..91da62e --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/LICENSE @@ -0,0 +1,16 @@ +Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) + +This software is provided "as-is", without any express or implied warranty. In no event +will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial +applications, and to alter it and redistribute it freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you + wrote the original software. If you use this software in a product, an acknowledgment + in the product documentation would be appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be misrepresented + as being the original software. + + 3. This notice may not be removed or altered from any source distribution. diff --git a/raylib-src/raylib-5.0_linux_amd64/README.md b/raylib-src/raylib-5.0_linux_amd64/README.md new file mode 100644 index 0000000..9d2b78e --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/README.md @@ -0,0 +1,150 @@ + + +**raylib is a simple and easy-to-use library to enjoy videogames programming.** + +raylib is highly inspired by Borland BGI graphics lib and by XNA framework and it's especially well suited for prototyping, tooling, graphical applications, embedded systems and education. + +*NOTE for ADVENTURERS: raylib is a programming library to enjoy videogames programming; no fancy interface, no visual helpers, no debug button... just coding in the most pure spartan-programmers way.* + +Ready to learn? Jump to [code examples!](https://www.raylib.com/examples.html) + +--- + +
+ +[![GitHub Releases Downloads](https://img.shields.io/github/downloads/raysan5/raylib/total)](https://github.com/raysan5/raylib/releases) +[![GitHub Stars](https://img.shields.io/github/stars/raysan5/raylib?style=flat&label=stars)](https://github.com/raysan5/raylib/stargazers) +[![GitHub commits since tagged version](https://img.shields.io/github/commits-since/raysan5/raylib/4.5.0)](https://github.com/raysan5/raylib/commits/master) +[![GitHub Sponsors](https://img.shields.io/github/sponsors/raysan5?label=sponsors)](https://github.com/sponsors/raysan5) +[![Packaging Status](https://repology.org/badge/tiny-repos/raylib.svg)](https://repology.org/project/raylib/versions) +[![License](https://img.shields.io/badge/license-zlib%2Flibpng-blue.svg)](LICENSE) + +[![Discord Members](https://img.shields.io/discord/426912293134270465.svg?label=Discord&logo=discord)](https://discord.gg/raylib) +[![Subreddit Subscribers](https://img.shields.io/reddit/subreddit-subscribers/raylib?label=reddit%20r%2Fraylib&logo=reddit)](https://www.reddit.com/r/raylib/) +[![Youtube Subscribers](https://img.shields.io/youtube/channel/subscribers/UC8WIBkhYb5sBNqXO1mZ7WSQ?style=flat&label=Youtube&logo=youtube)](https://www.youtube.com/c/raylib) +[![Twitch Status](https://img.shields.io/twitch/status/raysan5?style=flat&label=Twitch&logo=twitch)](https://www.twitch.tv/raysan5) + +[![Windows](https://github.com/raysan5/raylib/workflows/Windows/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AWindows) +[![Linux](https://github.com/raysan5/raylib/workflows/Linux/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3ALinux) +[![macOS](https://github.com/raysan5/raylib/workflows/macOS/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AmacOS) +[![WebAssembly](https://github.com/raysan5/raylib/workflows/WebAssembly/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AWebAssembly) + +[![CMakeBuilds](https://github.com/raysan5/raylib/workflows/CMakeBuilds/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3ACMakeBuilds) +[![Windows Examples](https://github.com/raysan5/raylib/actions/workflows/windows_examples.yml/badge.svg)](https://github.com/raysan5/raylib/actions/workflows/windows_examples.yml) +[![Linux Examples](https://github.com/raysan5/raylib/actions/workflows/linux_examples.yml/badge.svg)](https://github.com/raysan5/raylib/actions/workflows/linux_examples.yml) + +features +-------- + - **NO external dependencies**, all required libraries are [bundled into raylib](https://github.com/raysan5/raylib/tree/master/src/external) + - Multiple platforms supported: **Windows, Linux, MacOS, RPI, Android, HTML5... and more!** + - Written in plain C code (C99) using PascalCase/camelCase notation + - Hardware accelerated with OpenGL (**1.1, 2.1, 3.3, 4.3, ES 2.0, ES 3.0**) + - **Unique OpenGL abstraction layer** (usable as standalone module): [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.h) + - Multiple **Fonts** formats supported (TTF, OTF, Image fonts, AngelCode fonts) + - Multiple texture formats supported, including **compressed formats** (DXT, ETC, ASTC) + - **Full 3D support**, including 3D Shapes, Models, Billboards, Heightmaps and more! + - Flexible Materials system, supporting classic maps and **PBR maps** + - **Animated 3D models** supported (skeletal bones animation) (IQM, M3D, glTF) + - Shaders support, including model shaders and **postprocessing** shaders + - **Powerful math module** for Vector, Matrix and Quaternion operations: [raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h) + - Audio loading and playing with streaming support (WAV, QOA, OGG, MP3, FLAC, XM, MOD) + - **VR stereo rendering** support with configurable HMD device parameters + - Huge examples collection with [+140 code examples](https://github.com/raysan5/raylib/tree/master/examples)! + - Bindings to [+70 programming languages](https://github.com/raysan5/raylib/blob/master/BINDINGS.md)! + - **Free and open source** + +basic example +-------------- +This is a basic raylib example, it creates a window and draws the text `"Congrats! You created your first window!"` in the middle of the screen. Check this example [running live on web here](https://www.raylib.com/examples/core/loader.html?name=core_basic_window). +```c +#include "raylib.h" + +int main(void) +{ + InitWindow(800, 450, "raylib [core] example - basic window"); + + while (!WindowShouldClose()) + { + BeginDrawing(); + ClearBackground(RAYWHITE); + DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); + EndDrawing(); + } + + CloseWindow(); + + return 0; +} +``` + +build and installation +---------------------- + +raylib binary releases for Windows, Linux, macOS, Android and HTML5 are available at the [Github Releases page](https://github.com/raysan5/raylib/releases). + +raylib is also available via multiple [package managers](https://github.com/raysan5/raylib/issues/613) on multiple OS distributions. + +#### Installing and building raylib on multiple platforms + +[raylib Wiki](https://github.com/raysan5/raylib/wiki#development-platforms) contains detailed instructions on building and usage on multiple platforms. + + - [Working on Windows](https://github.com/raysan5/raylib/wiki/Working-on-Windows) + - [Working on macOS](https://github.com/raysan5/raylib/wiki/Working-on-macOS) + - [Working on GNU Linux](https://github.com/raysan5/raylib/wiki/Working-on-GNU-Linux) + - [Working on Chrome OS](https://github.com/raysan5/raylib/wiki/Working-on-Chrome-OS) + - [Working on FreeBSD](https://github.com/raysan5/raylib/wiki/Working-on-FreeBSD) + - [Working on Raspberry Pi](https://github.com/raysan5/raylib/wiki/Working-on-Raspberry-Pi) + - [Working for Android](https://github.com/raysan5/raylib/wiki/Working-for-Android) + - [Working for Web (HTML5)](https://github.com/raysan5/raylib/wiki/Working-for-Web-(HTML5)) + - [Working anywhere with CMake](https://github.com/raysan5/raylib/wiki/Working-with-CMake) + +*Note that the Wiki is open for edit, if you find some issues while building raylib for your target platform, feel free to edit the Wiki or open an issue related to it.* + +#### Setup raylib with multiple IDEs + +raylib has been developed on Windows platform using [Notepad++](https://notepad-plus-plus.org/) and [MinGW GCC](https://www.mingw-w64.org/) compiler but it can be used with other IDEs on multiple platforms. + +[Projects directory](https://github.com/raysan5/raylib/tree/master/projects) contains several ready-to-use **project templates** to build raylib and code examples with multiple IDEs. + +*Note that there are lots of IDEs supported, some of the provided templates could require some review, so please, if you find some issue with a template or you think they could be improved, feel free to send a PR or open a related issue.* + +learning and docs +------------------ + +raylib is designed to be learned using [the examples](https://github.com/raysan5/raylib/tree/master/examples) as the main reference. There is no standard API documentation but there is a [**cheatsheet**](https://www.raylib.com/cheatsheet/cheatsheet.html) containing all the functions available on the library a short description of each one of them, input parameters and result value names should be intuitive enough to understand how each function works. + +Some additional documentation about raylib design can be found in [raylib GitHub Wiki](https://github.com/raysan5/raylib/wiki). Here are the relevant links: + + - [raylib cheatsheet](https://www.raylib.com/cheatsheet/cheatsheet.html) + - [raylib architecture](https://github.com/raysan5/raylib/wiki/raylib-architecture) + - [raylib library design](https://github.com/raysan5/raylib/wiki) + - [raylib examples collection](https://github.com/raysan5/raylib/tree/master/examples) + - [raylib games collection](https://github.com/raysan5/raylib-games) + + +contact and networks +--------------------- + +raylib is present in several networks and raylib community is growing everyday. If you are using raylib and enjoying it, feel free to join us in any of these networks. The most active network is our [Discord server](https://discord.gg/raylib)! :) + + - Webpage: [https://www.raylib.com](https://www.raylib.com) + - Discord: [https://discord.gg/raylib](https://discord.gg/raylib) + - Twitter: [https://www.twitter.com/raysan5](https://www.twitter.com/raysan5) + - Twitch: [https://www.twitch.tv/raysan5](https://www.twitch.tv/raysan5) + - Reddit: [https://www.reddit.com/r/raylib](https://www.reddit.com/r/raylib) + - Patreon: [https://www.patreon.com/raylib](https://www.patreon.com/raylib) + - YouTube: [https://www.youtube.com/channel/raylib](https://www.youtube.com/c/raylib) + +contributors +------------ + + + + + +license +------- + +raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, BSD-like license that allows static linking with closed source software. Check [LICENSE](LICENSE) for further details. + +raylib uses internally some libraries for window/graphics/inputs management and also to support different file formats loading, all those libraries are embedded with and are available in [src/external](https://github.com/raysan5/raylib/tree/master/src/external) directory. Check [raylib dependencies LICENSES](https://github.com/raysan5/raylib/wiki/raylib-dependencies) on [raylib Wiki](https://github.com/raysan5/raylib/wiki) for details. diff --git a/raylib-src/raylib-5.0_linux_amd64/include/raygui.h b/raylib-src/raylib-5.0_linux_amd64/include/raygui.h new file mode 100644 index 0000000..5c0bc60 --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/include/raygui.h @@ -0,0 +1,5540 @@ +/******************************************************************************************* +* +* raygui v4.1-dev - A simple and easy-to-use immediate-mode gui library +* +* DESCRIPTION: +* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +* available as a standalone library, as long as input and drawing functions are provided. +* +* FEATURES: +* - Immediate-mode gui, minimal retained data +* - +25 controls provided (basic and advanced) +* - Styling system for colors, font and metrics +* - Icons supported, embedded as a 1-bit icons pack +* - Standalone mode option (custom input/graphics backend) +* - Multiple support tools provided for raygui development +* +* POSSIBLE IMPROVEMENTS: +* - Better standalone mode API for easy plug of custom backends +* - Externalize required inputs, allow user easier customization +* +* LIMITATIONS: +* - No editable multi-line word-wraped text box supported +* - No auto-layout mechanism, up to the user to define controls position and size +* - Standalone mode requires library modification and some user work to plug another backend +* +* NOTES: +* - WARNING: GuiLoadStyle() and GuiLoadStyle{Custom}() functions, allocate memory for +* font atlas recs and glyphs, freeing that memory is (usually) up to the user, +* no unload function is explicitly provided... but note that GuiLoadStyleDefault() unloads +* by default any previously loaded font (texture, recs, glyphs). +* - Global UI alpha (guiAlpha) is applied inside GuiDrawRectangle() and GuiDrawText() functions +* +* CONTROLS PROVIDED: +* # Container/separators Controls +* - WindowBox --> StatusBar, Panel +* - GroupBox --> Line +* - Line +* - Panel --> StatusBar +* - ScrollPanel --> StatusBar +* - TabBar --> Button +* +* # Basic Controls +* - Label +* - LabelButton --> Label +* - Button +* - Toggle +* - ToggleGroup --> Toggle +* - ToggleSlider +* - CheckBox +* - ComboBox +* - DropdownBox +* - TextBox +* - ValueBox --> TextBox +* - Spinner --> Button, ValueBox +* - Slider +* - SliderBar --> Slider +* - ProgressBar +* - StatusBar +* - DummyRec +* - Grid +* +* # Advance Controls +* - ListView +* - ColorPicker --> ColorPanel, ColorBarHue +* - MessageBox --> Window, Label, Button +* - TextInputBox --> Window, Label, TextBox, Button +* +* It also provides a set of functions for styling the controls based on its properties (size, color). +* +* +* 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 +* recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one +* +* The global style array size is fixed and depends on the number of controls and properties: +* +* static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)]; +* +* guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +* +* Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style +* used for all controls, when any of those base values is set, it is automatically populated to all +* controls, so, specific control values overwriting generic style should be set after base values. +* +* After the first BASE set we have the EXTENDED properties (by default guiStyle[16..23]), those +* properties are actually common to all controls and can not be overwritten individually (like BASE ones) +* Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR +* +* Custom control properties can be defined using the EXTENDED properties for each independent control. +* +* TOOL: rGuiStyler is a visual tool to customize raygui style: github.com/raysan5/rguistyler +* +* +* 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 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. +* +* When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set. +* +* The global icons array size is fixed and depends on the number of icons and size: +* +* static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS]; +* +* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB +* +* TOOL: rGuiIcons is a visual tool to customize/create raygui icons: github.com/raysan5/rguiicons +* +* RAYGUI LAYOUT: +* raygui currently does not provide an auto-layout mechanism like other libraries, +* layouts must be defined manually on controls drawing, providing the right bounds Rectangle for it. +* +* TOOL: rGuiLayout is a visual tool to create raygui layouts: github.com/raysan5/rguilayout +* +* CONFIGURATION: +* #define RAYGUI_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYGUI_STANDALONE +* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined +* internally in the library and input management and drawing functions must be provided by +* the user (check library implementation for further details). +* +* #define RAYGUI_NO_ICONS +* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB) +* +* #define RAYGUI_CUSTOM_ICONS +* Includes custom ricons.h header defining a set of custom icons, +* this file can be generated using rGuiIcons tool +* +* #define RAYGUI_DEBUG_RECS_BOUNDS +* Draw control bounds rectangles for debug +* +* #define RAYGUI_DEBUG_TEXT_BOUNDS +* Draw text bounds rectangles for debug +* +* VERSIONS HISTORY: +* 4.1-dev (2024) Current dev version... +* ADDED: guiControlExclusiveMode and guiControlExclusiveRec for exclusive modes +* +* 4.0 (12-Sep-2023) ADDED: GuiToggleSlider() +* ADDED: GuiColorPickerHSV() and GuiColorPanelHSV() +* ADDED: Multiple new icons, mostly compiler related +* ADDED: New DEFAULT properties: TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE +* ADDED: New enum values: GuiTextAlignment, GuiTextAlignmentVertical, GuiTextWrapMode +* ADDED: Support loading styles with custom font charset from external file +* REDESIGNED: GuiTextBox(), support mouse cursor positioning +* REDESIGNED: GuiDrawText(), support multiline and word-wrap modes (read only) +* REDESIGNED: GuiProgressBar() to be more visual, progress affects border color +* REDESIGNED: Global alpha consideration moved to GuiDrawRectangle() and GuiDrawText() +* REDESIGNED: GuiScrollPanel(), get parameters by reference and return result value +* REDESIGNED: GuiToggleGroup(), get parameters by reference and return result value +* REDESIGNED: GuiComboBox(), get parameters by reference and return result value +* REDESIGNED: GuiCheckBox(), get parameters by reference and return result value +* REDESIGNED: GuiSlider(), get parameters by reference and return result value +* REDESIGNED: GuiSliderBar(), get parameters by reference and return result value +* REDESIGNED: GuiProgressBar(), get parameters by reference and return result value +* REDESIGNED: GuiListView(), get parameters by reference and return result value +* REDESIGNED: GuiColorPicker(), get parameters by reference and return result value +* REDESIGNED: GuiColorPanel(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarAlpha(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarHue(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), added extra parameter +* REDESIGNED: GuiListViewEx(), change parameters order +* REDESIGNED: All controls return result as int value +* REVIEWED: GuiScrollPanel() to avoid smallish scroll-bars +* REVIEWED: All examples and specially controls_test_suite +* RENAMED: gui_file_dialog module to gui_window_file_dialog +* UPDATED: All styles to include ISO-8859-15 charset (as much as possible) +* +* 3.6 (10-May-2023) ADDED: New icon: SAND_TIMER +* ADDED: GuiLoadStyleFromMemory() (binary only) +* REVIEWED: GuiScrollBar() horizontal movement key +* REVIEWED: GuiTextBox() crash on cursor movement +* REVIEWED: GuiTextBox(), additional inputs support +* REVIEWED: GuiLabelButton(), avoid text cut +* REVIEWED: GuiTextInputBox(), password input +* REVIEWED: Local GetCodepointNext(), aligned with raylib +* REDESIGNED: GuiSlider*()/GuiScrollBar() to support out-of-bounds +* +* 3.5 (20-Apr-2023) ADDED: GuiTabBar(), based on GuiToggle() +* ADDED: Helper functions to split text in separate lines +* ADDED: Multiple new icons, useful for code editing tools +* REMOVED: Unneeded icon editing functions +* REMOVED: GuiTextBoxMulti(), very limited and broken +* REMOVED: MeasureTextEx() dependency, logic directly implemented +* REMOVED: DrawTextEx() dependency, logic directly implemented +* REVIEWED: GuiScrollBar(), improve mouse-click behaviour +* REVIEWED: Library header info, more info, better organized +* REDESIGNED: GuiTextBox() to support cursor movement +* REDESIGNED: GuiDrawText() to divide drawing by lines +* +* 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 +* +* 2.9 (17-Mar-2021) REMOVED: Tooltip API +* 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle() +* 2.7 (20-Feb-2020) ADDED: Possible tooltips API +* 2.6 (09-Sep-2019) ADDED: GuiTextInputBox() +* REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox() +* REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle() +* Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties +* ADDED: 8 new custom styles ready to use +* Multiple minor tweaks and bugs corrected +* +* 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner() +* 2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed +* Refactor all controls drawing mechanism to use control state +* 2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls +* 2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string +* REDESIGNED: Style system (breaking change) +* 2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts +* REVIEWED: GuiComboBox(), GuiListView()... +* 1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()... +* 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout +* 1.5 (21-Jun-2017) Working in an improved styles system +* 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones) +* 1.3 (12-Jun-2017) Complete redesign of style system +* 1.1 (01-Jun-2017) Complete review of the library +* 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria. +* 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria. +* 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria. +* +* DEPENDENCIES: +* raylib 5.0 - Inputs reading (keyboard/mouse), shapes drawing, font loading and text drawing +* +* STANDALONE MODE: +* By default raygui depends on raylib mostly for the inputs and the drawing functionality but that dependency can be disabled +* with the config flag RAYGUI_STANDALONE. In that case is up to the user to provide another backend to cover library needs. +* +* The following functions should be redefined for a custom backend: +* +* - Vector2 GetMousePosition(void); +* - float GetMouseWheelMove(void); +* - bool IsMouseButtonDown(int button); +* - bool IsMouseButtonPressed(int button); +* - bool IsMouseButtonReleased(int button); +* - bool IsKeyDown(int key); +* - bool IsKeyPressed(int key); +* - int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +* +* - void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +* - void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +* +* - Font GetFontDefault(void); // -- GuiLoadStyleDefault() +* - Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle() +* - Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +* - void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) +* - char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +* - void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data +* - const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs +* - int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +* - void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list +* - unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +* +* CONTRIBUTORS: +* Ramon Santamaria: Supervision, review, redesign, update and maintenance +* Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019) +* Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018) +* Adria Arranz: Testing and implementation of additional controls (2018) +* Jordi Jorba: Testing and implementation of additional controls (2018) +* Albert Martos: Review and testing of the library (2015) +* Ian Eito: Review and testing of the library (2015) +* Kevin Gato: Initial implementation of basic components (2014) +* Daniel Nicolas: Initial implementation of basic components (2014) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2024 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYGUI_H +#define RAYGUI_H + +#define RAYGUI_VERSION_MAJOR 4 +#define RAYGUI_VERSION_MINOR 1 +#define RAYGUI_VERSION_PATCH 0 +#define RAYGUI_VERSION "4.1-dev" + +#if !defined(RAYGUI_STANDALONE) + #include "raylib.h" +#endif + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RAYGUIAPI + #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +// Allow custom memory allocators +#ifndef RAYGUI_MALLOC + #define RAYGUI_MALLOC(sz) malloc(sz) +#endif +#ifndef RAYGUI_CALLOC + #define RAYGUI_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RAYGUI_FREE + #define RAYGUI_FREE(p) free(p) +#endif + +// 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 +// NOTE: Some types are required for RAYGUI_STANDALONE usage +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + #ifndef __cplusplus + // Boolean type + #ifndef true + typedef enum { false, true } bool; + #endif + #endif + + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; + + // Vector3 type // -- ConvertHSVtoRGB(), ConvertRGBtoHSV() + typedef struct Vector3 { + float x; + float y; + float z; + } Vector3; + + // Color type, RGBA (32bit) + typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; + } Color; + + // Rectangle type + typedef struct Rectangle { + float x; + float y; + float width; + float height; + } Rectangle; + + // TODO: Texture2D type is very coupled to raylib, required by Font type + // It should be redesigned to be provided by user + typedef struct Texture2D { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Texture2D; + + // Image, pixel data stored in CPU memory (RAM) + typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Image; + + // GlyphInfo, font characters glyphs info + typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data + } GlyphInfo; + + // TODO: Font type is very coupled to raylib, mostly required by GuiLoadStyle() + // It should be redesigned to be provided by user + typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data + } Font; +#endif + +// Style property +// NOTE: Used when exporting style as code for convenience +typedef struct GuiStyleProp { + unsigned short controlId; // Control identifier + unsigned short propertyId; // Property identifier + int propertyValue; // Property value +} GuiStyleProp; + +/* +// Controls text style -NOT USED- +// NOTE: Text style is defined by control +typedef struct GuiTextStyle { + unsigned int size; + int charSpacing; + int lineSpacing; + int alignmentH; + int alignmentV; + int padding; +} GuiTextStyle; +*/ + +// Gui control state +typedef enum { + STATE_NORMAL = 0, + STATE_FOCUSED, + STATE_PRESSED, + STATE_DISABLED +} GuiState; + +// Gui control text alignment +typedef enum { + TEXT_ALIGN_LEFT = 0, + TEXT_ALIGN_CENTER, + TEXT_ALIGN_RIGHT +} GuiTextAlignment; + +// Gui control text alignment vertical +// NOTE: Text vertical position inside the text bounds +typedef enum { + TEXT_ALIGN_TOP = 0, + TEXT_ALIGN_MIDDLE, + TEXT_ALIGN_BOTTOM +} GuiTextAlignmentVertical; + +// Gui control text wrap mode +// NOTE: Useful for multiline text +typedef enum { + TEXT_WRAP_NONE = 0, + TEXT_WRAP_CHAR, + TEXT_WRAP_WORD +} GuiTextWrapMode; + +// Gui controls +typedef enum { + // Default -> populates to all controls when set + DEFAULT = 0, + + // Basic controls + LABEL, // Used also for: LABELBUTTON + BUTTON, + TOGGLE, // Used also for: TOGGLEGROUP + SLIDER, // Used also for: SLIDERBAR, TOGGLESLIDER + PROGRESSBAR, + CHECKBOX, + COMBOBOX, + DROPDOWNBOX, + TEXTBOX, // Used also for: TEXTBOXMULTI + VALUEBOX, + SPINNER, // Uses: BUTTON, VALUEBOX + LISTVIEW, + COLORPICKER, + SCROLLBAR, + STATUSBAR +} GuiControl; + +// Gui base properties for every control +// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties) +typedef enum { + BORDER_COLOR_NORMAL = 0, // Control border color in STATE_NORMAL + BASE_COLOR_NORMAL, // Control base color in STATE_NORMAL + TEXT_COLOR_NORMAL, // Control text color in STATE_NORMAL + BORDER_COLOR_FOCUSED, // Control border color in STATE_FOCUSED + BASE_COLOR_FOCUSED, // Control base color in STATE_FOCUSED + TEXT_COLOR_FOCUSED, // Control text color in STATE_FOCUSED + BORDER_COLOR_PRESSED, // Control border color in STATE_PRESSED + BASE_COLOR_PRESSED, // Control base color in STATE_PRESSED + TEXT_COLOR_PRESSED, // Control text color in STATE_PRESSED + BORDER_COLOR_DISABLED, // Control border color in STATE_DISABLED + BASE_COLOR_DISABLED, // Control base color in STATE_DISABLED + TEXT_COLOR_DISABLED, // Control text color in STATE_DISABLED + BORDER_WIDTH, // Control border size, 0 for no border + //TEXT_SIZE, // Control text size (glyphs max height) -> GLOBAL for all controls + //TEXT_SPACING, // Control text spacing between glyphs -> GLOBAL for all controls + //TEXT_LINE_SPACING // Control text spacing between lines -> GLOBAL for all controls + TEXT_PADDING, // Control text padding, not considering border + TEXT_ALIGNMENT, // Control text horizontal alignment inside control text bound (after border and padding) + //TEXT_WRAP_MODE // Control text wrap-mode inside text bounds -> GLOBAL for all controls +} GuiControlProperty; + +// TODO: Which text styling properties should be global or per-control? +// At this moment TEXT_PADDING and TEXT_ALIGNMENT is configured and saved per control while +// TEXT_SIZE, TEXT_SPACING, TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE are global and +// should be configured by user as needed while defining the UI layout + +// Gui extended properties depend on control +// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default, max 8 properties) +//---------------------------------------------------------------------------------- +// DEFAULT extended properties +// NOTE: Those properties are common to all controls or global +// WARNING: We only have 8 slots for those properties by default!!! -> New global control: TEXT? +typedef enum { + TEXT_SIZE = 16, // Text size (glyphs max height) + TEXT_SPACING, // Text spacing between glyphs + LINE_COLOR, // Line control color + BACKGROUND_COLOR, // Background color + TEXT_LINE_SPACING, // Text spacing between lines + TEXT_ALIGNMENT_VERTICAL, // Text vertical alignment inside text bounds (after border and padding) + TEXT_WRAP_MODE // Text wrap-mode inside text bounds + //TEXT_DECORATION // Text decoration: 0-None, 1-Underline, 2-Line-through, 3-Overline + //TEXT_DECORATION_THICK // Text decoration line thickness +} GuiDefaultProperty; + +// Other possible text properties: +// TEXT_WEIGHT // Normal, Italic, Bold -> Requires specific font change +// TEXT_INDENT // Text indentation -> Now using TEXT_PADDING... + +// Label +//typedef enum { } GuiLabelProperty; + +// Button/Spinner +//typedef enum { } GuiButtonProperty; + +// Toggle/ToggleGroup +typedef enum { + GROUP_PADDING = 16, // ToggleGroup separation between toggles +} GuiToggleProperty; + +// Slider/SliderBar +typedef enum { + SLIDER_WIDTH = 16, // Slider size of internal bar + SLIDER_PADDING // Slider/SliderBar internal bar padding +} GuiSliderProperty; + +// ProgressBar +typedef enum { + PROGRESS_PADDING = 16, // ProgressBar internal padding +} GuiProgressBarProperty; + +// ScrollBar +typedef enum { + ARROWS_SIZE = 16, // ScrollBar arrows size + ARROWS_VISIBLE, // ScrollBar arrows visible + SCROLL_SLIDER_PADDING, // ScrollBar slider internal padding + SCROLL_SLIDER_SIZE, // ScrollBar slider size + SCROLL_PADDING, // ScrollBar scroll padding from arrows + SCROLL_SPEED, // ScrollBar scrolling speed +} GuiScrollBarProperty; + +// CheckBox +typedef enum { + 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_READONLY = 16, // TextBox in read-only mode: 0-text editable, 1-text no-editable +} 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, // ListView items height + LIST_ITEMS_SPACING, // ListView items separation + SCROLLBAR_WIDTH, // ListView scrollbar size (usually width) + SCROLLBAR_SIDE, // ListView scrollbar side (0-SCROLLBAR_LEFT_SIDE, 1-SCROLLBAR_RIGHT_SIDE) +} GuiListViewProperty; + +// ColorPicker +typedef enum { + COLOR_SELECTOR_SIZE = 16, + 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 +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module Functions Declaration +//---------------------------------------------------------------------------------- + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Global gui state control functions +RAYGUIAPI void GuiEnable(void); // Enable gui controls (global state) +RAYGUIAPI void GuiDisable(void); // Disable gui controls (global state) +RAYGUIAPI void GuiLock(void); // Lock gui controls (global state) +RAYGUIAPI void GuiUnlock(void); // Unlock gui controls (global state) +RAYGUIAPI bool GuiIsLocked(void); // Check if gui is locked (global state) +RAYGUIAPI void GuiSetAlpha(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f +RAYGUIAPI void GuiSetState(int state); // Set gui state (global state) +RAYGUIAPI int GuiGetState(void); // Get gui state (global state) + +// Font set/get functions +RAYGUIAPI void GuiSetFont(Font font); // Set gui custom font (global state) +RAYGUIAPI Font GuiGetFont(void); // Get gui custom font (global state) + +// Style set/get functions +RAYGUIAPI void GuiSetStyle(int control, int property, int value); // Set one style property +RAYGUIAPI int GuiGetStyle(int control, int property); // Get one style property + +// 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 + +// Tooltips management functions +RAYGUIAPI void GuiEnableTooltip(void); // Enable gui tooltips (global state) +RAYGUIAPI void GuiDisableTooltip(void); // Disable gui tooltips (global state) +RAYGUIAPI void GuiSetTooltip(const char *tooltip); // Set tooltip string + +// Icons functionality +RAYGUIAPI const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported) +#if !defined(RAYGUI_NO_ICONS) +RAYGUIAPI void GuiSetIconScale(int scale); // Set default icon drawing size +RAYGUIAPI unsigned int *GuiGetIcons(void); // Get raygui icons data pointer +RAYGUIAPI char **GuiLoadIcons(const char *fileName, bool loadIconsName); // Load raygui icons file (.rgi) into internal icons data +RAYGUIAPI void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color); // Draw icon using pixel size at specified position +#endif + +// Controls +//---------------------------------------------------------------------------------------------------------- +// Container/separator controls, useful for controls organization +RAYGUIAPI int GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed +RAYGUIAPI int GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name +RAYGUIAPI int GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text +RAYGUIAPI int GuiPanel(Rectangle bounds, const char *text); // Panel control, useful to group controls +RAYGUIAPI int GuiTabBar(Rectangle bounds, const char **text, int count, int *active); // Tab Bar control, returns TAB to be closed or -1 +RAYGUIAPI int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view); // Scroll Panel control + +// Basic controls set +RAYGUIAPI int GuiLabel(Rectangle bounds, const char *text); // Label control +RAYGUIAPI int GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked +RAYGUIAPI int GuiLabelButton(Rectangle bounds, const char *text); // Label button control, returns true when clicked +RAYGUIAPI int GuiToggle(Rectangle bounds, const char *text, bool *active); // Toggle Button control +RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int *active); // Toggle Group control +RAYGUIAPI int GuiToggleSlider(Rectangle bounds, const char *text, int *active); // Toggle Slider control +RAYGUIAPI int GuiCheckBox(Rectangle bounds, const char *text, bool *checked); // Check Box control, returns true when active +RAYGUIAPI int GuiComboBox(Rectangle bounds, const char *text, int *active); // Combo Box control + +RAYGUIAPI int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control +RAYGUIAPI int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control +RAYGUIAPI int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers +RAYGUIAPI int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text + +RAYGUIAPI int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider control +RAYGUIAPI int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control +RAYGUIAPI int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Progress Bar control +RAYGUIAPI int GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text +RAYGUIAPI int GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders +RAYGUIAPI int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell); // Grid control + +// Advance controls set +RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active); // List View control +RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus); // 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, int textMaxSize, bool *secretViewActive); // Text Input Box control, ask for text, supports secret +RAYGUIAPI int GuiColorPicker(Rectangle bounds, const char *text, Color *color); // Color Picker control (multiple color controls) +RAYGUIAPI int GuiColorPanel(Rectangle bounds, const char *text, Color *color); // Color Panel control +RAYGUIAPI int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha); // Color Bar Alpha control +RAYGUIAPI int GuiColorBarHue(Rectangle bounds, const char *text, float *value); // Color Bar Hue control +RAYGUIAPI int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Picker control that avoids conversion to RGB on each call (multiple color controls) +RAYGUIAPI int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Panel control that updates Hue-Saturation-Value color value, used by GuiColorPickerHSV() +//---------------------------------------------------------------------------------------------------------- + +#if !defined(RAYGUI_NO_ICONS) + +#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_CPU = 206, + ICON_ROM = 207, + ICON_STEP_OVER = 208, + ICON_STEP_INTO = 209, + ICON_STEP_OUT = 210, + ICON_RESTART = 211, + ICON_BREAKPOINT_ON = 212, + ICON_BREAKPOINT_OFF = 213, + ICON_BURGER_MENU = 214, + ICON_CASE_SENSITIVE = 215, + ICON_REG_EXP = 216, + ICON_FOLDER = 217, + ICON_FILE = 218, + ICON_SAND_TIMER = 219, + ICON_WARNING = 220, + ICON_HELP_BOX = 221, + ICON_INFO_BOX = 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) +} // Prevents name mangling of functions +#endif + +#endif // RAYGUI_H + +/*********************************************************************************** +* +* RAYGUI IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RAYGUI_IMPLEMENTATION) + +#include // Required for: FILE, fopen(), fclose(), fprintf(), feof(), fscanf(), vsprintf() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: malloc(), calloc(), free() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: strlen() [GuiTextBox(), GuiValueBox()], memset(), memcpy() +#include // Required for: va_list, va_start(), vfprintf(), va_end() [TextFormat()] +#include // Required for: roundf() [GuiColorPicker()] + +#ifdef __cplusplus + #define RAYGUI_CLITERAL(name) name +#else + #define RAYGUI_CLITERAL(name) (name) +#endif + +// Check if two rectangles are equal, used to validate a slider bounds as an id +#ifndef CHECK_BOUNDS_ID + #define CHECK_BOUNDS_ID(src, dst) ((src.x == dst.x) && (src.y == dst.y) && (src.width == dst.width) && (src.height == dst.height)) +#endif + +#if !defined(RAYGUI_NO_ICONS) && !defined(RAYGUI_CUSTOM_ICONS) + +// 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 +// 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) +// +// 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 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[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, 0x47c2483c, 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, 0x3bf27be2, 0x0bfe1bfa, 0x000007fe, // ICON_CUBE_FACE_BOTTOM + 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // ICON_CUBE_FACE_RIGHT + 0x7fe00000, 0x6fe85ff0, 0x781e77e4, 0x7be27be2, 0x7be27be2, 0x24127be2, 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 + 0x0aa00000, 0x1ff80aa0, 0x1068700e, 0x1008706e, 0x1008700e, 0x1008700e, 0x0aa01ff8, 0x00000aa0, // ICON_CPU + 0x07e00000, 0x04201db8, 0x04a01c38, 0x04a01d38, 0x04a01d38, 0x04a01d38, 0x04201d38, 0x000007e0, // ICON_ROM + 0x00000000, 0x03c00000, 0x3c382ff0, 0x3c04380c, 0x01800000, 0x03c003c0, 0x00000180, 0x00000000, // ICON_STEP_OVER + 0x01800000, 0x01800180, 0x01800180, 0x03c007e0, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_INTO + 0x01800000, 0x07e003c0, 0x01800180, 0x01800180, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_OUT + 0x00000000, 0x0ff003c0, 0x181c1c34, 0x303c301c, 0x30003000, 0x1c301800, 0x03c00ff0, 0x00000000, // ICON_RESTART + 0x00000000, 0x00000000, 0x07e003c0, 0x0ff00ff0, 0x0ff00ff0, 0x03c007e0, 0x00000000, 0x00000000, // ICON_BREAKPOINT_ON + 0x00000000, 0x00000000, 0x042003c0, 0x08100810, 0x08100810, 0x03c00420, 0x00000000, 0x00000000, // ICON_BREAKPOINT_OFF + 0x00000000, 0x00000000, 0x1ff81ff8, 0x1ff80000, 0x00001ff8, 0x1ff81ff8, 0x00000000, 0x00000000, // ICON_BURGER_MENU + 0x00000000, 0x00000000, 0x00880070, 0x0c880088, 0x1e8810f8, 0x3e881288, 0x00000000, 0x00000000, // ICON_CASE_SENSITIVE + 0x00000000, 0x02000000, 0x07000a80, 0x07001fc0, 0x02000a80, 0x00300030, 0x00000000, 0x00000000, // ICON_REG_EXP + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_FOLDER + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x00003ffc, // ICON_FILE + 0x1ff00000, 0x20082008, 0x17d02fe8, 0x05400ba0, 0x09200540, 0x23881010, 0x2fe827c8, 0x00001ff0, // ICON_SAND_TIMER + 0x01800000, 0x02400240, 0x05a00420, 0x09900990, 0x11881188, 0x21842004, 0x40024182, 0x00003ffc, // ICON_WARNING + 0x7ffe0000, 0x4ff24002, 0x4c324ff2, 0x4f824c02, 0x41824f82, 0x41824002, 0x40024182, 0x00007ffe, // ICON_HELP_BOX + 0x7ffe0000, 0x41824002, 0x40024182, 0x41824182, 0x41824182, 0x41824182, 0x40024182, 0x00007ffe, // ICON_INFO_BOX + 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 +}; + +// NOTE: A pointer to current icons array should be defined +static unsigned int *guiIconsPtr = guiIcons; + +#endif // !RAYGUI_NO_ICONS && !RAYGUI_CUSTOM_ICONS + +#ifndef RAYGUI_ICON_SIZE + #define RAYGUI_ICON_SIZE 0 +#endif + +// WARNING: Those values define the total size of the style data array, +// if changed, previous saved styles could become incompatible +#define RAYGUI_MAX_CONTROLS 16 // Maximum number of controls +#define RAYGUI_MAX_PROPS_BASE 16 // Maximum number of base properties +#define RAYGUI_MAX_PROPS_EXTENDED 8 // Maximum number of extended properties + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// Gui control property style color element +typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement; + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +static 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 controls transparency + +static unsigned int guiIconScale = 1; // Gui icon default scale (if icons enabled) + +static bool guiTooltip = false; // Tooltip enabled/disabled +static const char *guiTooltipPtr = NULL; // Tooltip string pointer (string provided by user) + +static bool guiControlExclusiveMode = false; // Gui control exclusive mode (no inputs processed except current control) +static Rectangle guiControlExclusiveRec = { 0 }; // Gui control exclusive bounds rectangle, used as an unique identifier + +static int textBoxCursorIndex = 0; // Cursor index, shared by all GuiTextBox*() +//static int blinkCursorFrameCounter = 0; // Frame counter for cursor blinking +static int autoCursorCooldownCounter = 0; // Cooldown frame counter for automatic cursor movement on key-down +static int autoCursorDelayCounter = 0; // Delay frame counter for automatic cursor movement + +//---------------------------------------------------------------------------------- +// Style data array for all gui style properties (allocated on data segment by default) +// +// NOTE 1: First set of BASE properties are generic to all controls but could be individually +// overwritten per control, first set of EXTENDED properties are generic to all controls and +// can not be overwritten individually but custom EXTENDED properties can be used by control +// +// NOTE 2: A new style set could be loaded over this array using GuiLoadStyle(), +// but default gui style could always be recovered with GuiLoadStyleDefault() +// +// guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +//---------------------------------------------------------------------------------- +static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)] = { 0 }; + +static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization + +//---------------------------------------------------------------------------------- +// Standalone Mode Functions Declaration +// +// NOTE: raygui depend on some raylib input and drawing functions +// To use raygui as standalone library, below functions must be defined by the user +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + +#define KEY_RIGHT 262 +#define KEY_LEFT 263 +#define KEY_DOWN 264 +#define KEY_UP 265 +#define KEY_BACKSPACE 259 +#define KEY_ENTER 257 + +#define MOUSE_LEFT_BUTTON 0 + +// Input required functions +//------------------------------------------------------------------------------- +static Vector2 GetMousePosition(void); +static float GetMouseWheelMove(void); +static bool IsMouseButtonDown(int button); +static bool IsMouseButtonPressed(int button); +static bool IsMouseButtonReleased(int button); + +static bool IsKeyDown(int key); +static bool IsKeyPressed(int key); +static int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +//------------------------------------------------------------------------------- + +// Drawing required functions +//------------------------------------------------------------------------------- +static void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +static void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +//------------------------------------------------------------------------------- + +// Text required functions +//------------------------------------------------------------------------------- +static Font GetFontDefault(void); // -- GuiLoadStyleDefault() +static Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle(), load font + +static Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +static void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) + +static char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +static void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data + +static const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs + +static int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +static void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list + +static unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +//------------------------------------------------------------------------------- + +// raylib functions already implemented in raygui +//------------------------------------------------------------------------------- +static Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value +static int ColorToInt(Color color); // Returns hexadecimal value for a Color +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +static const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed' +static const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +static int TextToInteger(const char *text); // Get integer value from text + +static int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded text +static const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode codepoint into UTF-8 text (char array size returned as parameter) + +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw rectangle vertical gradient +//------------------------------------------------------------------------------- + +#endif // RAYGUI_STANDALONE + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize); // Load style from memory (binary only) + +static int GetTextWidth(const char *text); // Gui get text width using gui font and style +static Rectangle GetTextBounds(int control, Rectangle bounds); // Get text bounds considering control bounds +static const char *GetTextIcon(const char *text, int *iconId); // Get text icon if provided and move text cursor + +static void GuiDrawText(const char *text, Rectangle textBounds, 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, char delimiter, 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() +static void GuiTooltip(Rectangle controlRec); // Draw tooltip using control rec position + +static Color GuiFade(Color color, float alpha); // Fade color by an alpha factor + +//---------------------------------------------------------------------------------- +// Gui Setup Functions Definition +//---------------------------------------------------------------------------------- +// Enable gui global state +// 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 +// 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; } + +// Unlock gui global state +void GuiUnlock(void) { guiLocked = false; } + +// Check if gui is locked (global state) +bool GuiIsLocked(void) { return guiLocked; } + +// Set gui controls alpha global state +void GuiSetAlpha(float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + guiAlpha = alpha; +} + +// Set gui state (global state) +void GuiSetState(int state) { guiState = (GuiState)state; } + +// Get gui state (global state) +int GuiGetState(void) { return guiState; } + +// Set custom gui font +// NOTE: Font loading/unloading is external to raygui +void GuiSetFont(Font font) +{ + if (font.texture.id > 0) + { + // NOTE: If we try to setup a font but default style has not been + // lazily loaded before, it will be overwritten, so we need to force + // default style loading first + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + guiFont = font; + } +} + +// Get custom gui font +Font GuiGetFont(void) +{ + return guiFont; +} + +// Set control style property value +void GuiSetStyle(int control, int property, int value) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + + // Default properties are propagated to all controls + if ((control == 0) && (property < RAYGUI_MAX_PROPS_BASE)) + { + for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) guiStyle[i*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + } +} + +// Get control style property value +int GuiGetStyle(int control, int property) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + return guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property]; +} + +//---------------------------------------------------------------------------------- +// Gui Controls Functions Definition +//---------------------------------------------------------------------------------- + +// Window Box control +int GuiWindowBox(Rectangle bounds, const char *title) +{ + // Window title bar height (including borders) + // NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox() + #if !defined(RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT) + #define RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT 24 + #endif + + int result = 0; + //GuiState state = guiState; + + 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 + 1 }; + Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20, + statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 }; + + // Update control + //-------------------------------------------------------------------- + // NOTE: Logic is directly managed by button + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiStatusBar(statusBar, title); // Draw window header as status bar + GuiPanel(windowPanel, 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, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + result = GuiButton(closeButtonRec, "x"); +#else + result = GuiButton(closeButtonRec, GuiIconText(ICON_CROSS_SMALL, NULL)); +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + //-------------------------------------------------------------------- + + return result; // Window close button clicked: result = 1 +} + +// Group Box control with text name +int GuiGroupBox(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_GROUPBOX_LINE_THICK) + #define RAYGUI_GROUPBOX_LINE_THICK 1 + #endif + + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, RAYGUI_GROUPBOX_LINE_THICK }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + + GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y - GuiGetStyle(DEFAULT, TEXT_SIZE)/2, bounds.width, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) }, text); + //-------------------------------------------------------------------- + + return result; +} + +// Line control +int GuiLine(Rectangle bounds, const char *text) +{ + #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 + + int result = 0; + GuiState state = guiState; + + Color color = GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)); + + // Draw control + //-------------------------------------------------------------------- + if (text == NULL) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, bounds.width, 1 }, 0, BLANK, color); + else + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text) + 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 + 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); + } + //-------------------------------------------------------------------- + + return result; +} + +// Panel control +int GuiPanel(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_PANEL_BORDER_WIDTH) + #define RAYGUI_PANEL_BORDER_WIDTH 1 + #endif + + int result = 0; + 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 + //-------------------------------------------------------------------- + if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar + + GuiDrawRectangle(bounds, RAYGUI_PANEL_BORDER_WIDTH, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), + GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR))); + //-------------------------------------------------------------------- + + return result; +} + +// Tab Bar control +// NOTE: Using GuiToggle() for the TABS +int GuiTabBar(Rectangle bounds, const char **text, int count, int *active) +{ + #define RAYGUI_TABBAR_ITEM_WIDTH 160 + + int result = -1; + //GuiState state = guiState; + + Rectangle tabBounds = { bounds.x, bounds.y, RAYGUI_TABBAR_ITEM_WIDTH, bounds.height }; + + if (*active < 0) *active = 0; + else if (*active > count - 1) *active = count - 1; + + int offsetX = 0; // Required in case tabs go out of screen + offsetX = (*active + 2)*RAYGUI_TABBAR_ITEM_WIDTH - GetScreenWidth(); + if (offsetX < 0) offsetX = 0; + + bool toggle = false; // Required for individual toggles + + // Draw control + //-------------------------------------------------------------------- + for (int i = 0; i < count; i++) + { + tabBounds.x = bounds.x + (RAYGUI_TABBAR_ITEM_WIDTH + 4)*i - offsetX; + + if (tabBounds.x < GetScreenWidth()) + { + // Draw tabs as toggle controls + int textAlignment = GuiGetStyle(TOGGLE, TEXT_ALIGNMENT); + int textPadding = GuiGetStyle(TOGGLE, TEXT_PADDING); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(TOGGLE, TEXT_PADDING, 8); + + if (i == (*active)) + { + toggle = true; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + } + else + { + toggle = false; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + if (toggle) *active = i; + } + + // Close tab with middle mouse button pressed + if (CheckCollisionPointRec(GetMousePosition(), tabBounds) && IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) result = i; + + GuiSetStyle(TOGGLE, TEXT_PADDING, textPadding); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, textAlignment); + + // Draw tab close button + // NOTE: Only draw close button for current tab: if (CheckCollisionPointRec(mousePosition, tabBounds)) + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, "x")) result = i; +#else + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, GuiIconText(ICON_CROSS_SMALL, NULL))) result = i; +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + } + } + + // Draw tab-bar bottom line + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, 1 }, 0, BLANK, GetColor(GuiGetStyle(TOGGLE, BORDER_COLOR_NORMAL))); + //-------------------------------------------------------------------- + + return result; // Return as result the current TAB closing requested +} + +// Scroll Panel control +int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view) +{ + #define RAYGUI_MIN_SCROLLBAR_WIDTH 40 + #define RAYGUI_MIN_SCROLLBAR_HEIGHT 40 + #define RAYGUI_MIN_MOUSE_WHEEL_SPEED 20 + + int result = 0; + GuiState state = guiState; + + Rectangle temp = { 0 }; + if (view == NULL) view = &temp; + + 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; + + // Recheck to account for the other scrollbar being visible + if (!hasHorizontalScrollBar) hasHorizontalScrollBar = (hasVerticalScrollBar && (content.width > (bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + if (!hasVerticalScrollBar) hasVerticalScrollBar = (hasHorizontalScrollBar && (content.height > (bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + + 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) + }; + + // Make sure scroll bars have a minimum width/height + if (horizontalScrollBar.width < RAYGUI_MIN_SCROLLBAR_WIDTH) horizontalScrollBar.width = RAYGUI_MIN_SCROLLBAR_WIDTH; + if (verticalScrollBar.height < RAYGUI_MIN_SCROLLBAR_HEIGHT) verticalScrollBar.height = RAYGUI_MIN_SCROLLBAR_HEIGHT; + + // Calculate view area (area without the scrollbars) + *view = (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? + RAYGUI_CLITERAL(Rectangle){ bounds.x + verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth } : + RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth }; + + // Clip view area to the actual content size + if (view->width > content.width) view->width = content.width; + if (view->height > content.height) view->height = content.height; + + 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.0f : -1.0f; + float verticalMax = hasVerticalScrollBar? content.height - bounds.height + (float)horizontalScrollBarWidth + (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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); + if (IsKeyDown(KEY_LEFT)) scrollPos.x += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } + + if (hasVerticalScrollBar) + { + if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } +#endif + float wheelMove = GetMouseWheelMove(); + + // Set scrolling speed with mouse wheel based on ratio between bounds and content + Vector2 mouseWheelSpeed = { content.width / bounds.width, content.height / bounds.height }; + if (mouseWheelSpeed.x < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.x = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + if (mouseWheelSpeed.y < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.y = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + + // Horizontal and vertical scrolling with mouse wheel + if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_LEFT_SHIFT))) scrollPos.x += wheelMove*mouseWheelSpeed.x; + else scrollPos.y += wheelMove*mouseWheelSpeed.y; // Vertical scroll + } + } + + // Normalize scroll values + if (scrollPos.x > -horizontalMin) scrollPos.x = -horizontalMin; + if (scrollPos.x < -horizontalMax) scrollPos.x = -horizontalMax; + if (scrollPos.y > -verticalMin) scrollPos.y = -verticalMin; + if (scrollPos.y < -verticalMax) scrollPos.y = -verticalMax; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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 + const int slider = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + + // Draw horizontal scrollbar if visible + if (hasHorizontalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content width and the widget width + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)/(int)content.width)*((int)bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth))); + scrollPos.x = (float)-GuiScrollBar(horizontalScrollBar, (int)-scrollPos.x, (int)horizontalMin, (int)horizontalMax); + } + else scrollPos.x = 0.0f; + + // Draw vertical scrollbar if visible + if (hasVerticalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content height and the widget height + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)/(int)content.height)*((int)bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth))); + scrollPos.y = (float)-GuiScrollBar(verticalScrollBar, (int)-scrollPos.y, (int)verticalMin, (int)verticalMax); + } + 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 }; + GuiDrawRectangle(corner, 0, BLANK, GetColor(GuiGetStyle(LISTVIEW, TEXT + (state*3)))); + } + + // Draw scrollbar lines depending on current state + GuiDrawRectangle(bounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + (state*3))), BLANK); + + // Set scrollbar slider size back to the way it was before + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider); + //-------------------------------------------------------------------- + + if (scroll != NULL) *scroll = scrollPos; + + return result; +} + +// Label control +int GuiLabel(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + //... + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Button control, returns true when clicked +int GuiButton(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), GetColor(GuiGetStyle(BUTTON, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), GetColor(GuiGetStyle(BUTTON, TEXT + (state*3)))); + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //------------------------------------------------------------------ + + return result; // Button pressed: result = 1 +} + +// Label button control +int GuiLabelButton(Rectangle bounds, const char *text) +{ + GuiState state = guiState; + bool pressed = false; + + // NOTE: We force bounds.width to be all text + float textWidth = (float)GetTextWidth(text); + if ((bounds.width - 2*GuiGetStyle(LABEL, BORDER_WIDTH) - 2*GuiGetStyle(LABEL, TEXT_PADDING)) < textWidth) bounds.width = textWidth + 2*GuiGetStyle(LABEL, BORDER_WIDTH) + 2*GuiGetStyle(LABEL, TEXT_PADDING) + 2; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return pressed; +} + +// Toggle Button control +int GuiToggle(Rectangle bounds, const char *text, bool *active) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (active == NULL) active = &temp; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check toggle button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_NORMAL; + *active = !(*active); + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_NORMAL) + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, ((*active)? BORDER_COLOR_PRESSED : (BORDER + state*3)))), GetColor(GuiGetStyle(TOGGLE, ((*active)? BASE_COLOR_PRESSED : (BASE + state*3))))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, ((*active)? TEXT_COLOR_PRESSED : (TEXT + state*3))))); + } + else + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + state*3)), GetColor(GuiGetStyle(TOGGLE, BASE + state*3))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, TEXT + state*3))); + } + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; +} + +// Toggle Group control +int GuiToggleGroup(Rectangle bounds, const char *text, int *active) +{ + #if !defined(RAYGUI_TOGGLEGROUP_MAX_ITEMS) + #define RAYGUI_TOGGLEGROUP_MAX_ITEMS 32 + #endif + + int result = 0; + float initBoundsX = bounds.x; + + int temp = 0; + if (active == NULL) active = &temp; + + bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int rows[RAYGUI_TOGGLEGROUP_MAX_ITEMS] = { 0 }; + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, rows); + + int prevRow = rows[0]; + + for (int i = 0; i < itemCount; i++) + { + if (prevRow != rows[i]) + { + bounds.x = initBoundsX; + bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING)); + prevRow = rows[i]; + } + + if (i == (*active)) + { + toggle = true; + GuiToggle(bounds, items[i], &toggle); + } + else + { + toggle = false; + GuiToggle(bounds, items[i], &toggle); + if (toggle) *active = i; + } + + bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING)); + } + + return result; +} + +// Toggle Slider control extended +int GuiToggleSlider(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + //bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle slider = { + 0, // Calculated later depending on the active toggle + bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + (bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - (itemCount + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING))/itemCount, + bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + (*active)++; + result = 1; + } + else state = STATE_FOCUSED; + } + + if ((*active) && (state != STATE_FOCUSED)) state = STATE_PRESSED; + } + + if (*active >= itemCount) *active = 0; + slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH) + (*active + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING) + (*active)*slider.width; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + (state*3))), + GetColor(GuiGetStyle(TOGGLE, BASE_COLOR_NORMAL))); + + // Draw internal slider + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + + // Draw text in slider + if (text != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = slider.x + slider.width/2 - textBounds.width/2; + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(items[*active], textBounds, GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, TEXT + (state*3))), guiAlpha)); + } + //-------------------------------------------------------------------- + + return result; +} + +// Check Box control, returns 1 when state changed +int GuiCheckBox(Rectangle bounds, const char *text, bool *checked) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (checked == NULL) checked = &temp; + + Rectangle textBounds = { 0 }; + + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + Rectangle totalBounds = { + (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT)? textBounds.x : bounds.x, + bounds.y, + bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING), + bounds.height, + }; + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, totalBounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + *checked = !(*checked); + result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), GetColor(GuiGetStyle(CHECKBOX, BORDER + (state*3))), BLANK); + + if (*checked) + { + Rectangle check = { bounds.x + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.y + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.width - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)), + bounds.height - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)) }; + GuiDrawRectangle(check, 0, BLANK, GetColor(GuiGetStyle(CHECKBOX, TEXT + state*3))); + } + + GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Combo Box control +int GuiComboBox(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING)); + + 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) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + if (*active < 0) *active = 0; + else if (*active > (itemCount - 1)) *active = itemCount - 1; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds) || + CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + *active += 1; + if (*active >= itemCount) *active = 0; // Cyclic combobox + } + + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + // Draw combo box main + GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), GetColor(GuiGetStyle(COMBOBOX, BORDER + (state*3))), GetColor(GuiGetStyle(COMBOBOX, BASE + (state*3)))); + GuiDrawText(items[*active], GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(COMBOBOX, TEXT + (state*3)))); + + // Draw selector using a custom button + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + GuiButton(selector, TextFormat("%i/%i", *active + 1, itemCount)); + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign); + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + //-------------------------------------------------------------------- + + return result; +} + +// Dropdown Box control +// NOTE: Returns mouse click +int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode) +{ + int result = 0; + GuiState state = guiState; + + int itemSelected = *active; + int itemFocused = -1; + + // Get substrings items from text (items pointers, lengths and count) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle boundsOpen = bounds; + boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + Rectangle itemBounds = bounds; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // Check if mouse has been pressed or released outside limits + if (!CheckCollisionPointRec(mousePoint, boundsOpen)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + + // Check if already selected item has been pressed again + if (CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + + // Check focused and selected item + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = i; + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + itemSelected = i; + result = 1; // Item selected + } + break; + } + } + + itemBounds = bounds; + } + else + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + result = 1; + state = STATE_PRESSED; + } + else state = STATE_FOCUSED; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (editMode) GuiPanel(boundsOpen, NULL); + + GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER + state*3)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE + state*3))); + GuiDrawText(items[itemSelected], GetTextBounds(DROPDOWNBOX, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + state*3))); + + if (editMode) + { + // Draw visible items + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (i == itemSelected) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED))); + } + else if (i == itemFocused) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED))); + } + else GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL))); + } + } + + // Draw arrows (using icon if available) +#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 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#else + GuiDrawText("#120#", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 6, 10, 10 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); // ICON_ARROW_DOWN_FILL +#endif + //-------------------------------------------------------------------- + + *active = itemSelected; + + // TODO: Use result to return more internal states: mouse-press out-of-bounds, mouse-press over selected-item... + return result; // Mouse click: result = 1 +} + +// Text Box control +// NOTE: Returns true on ENTER pressed (useful for data validation) +int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode) +{ + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN 40 // Frames to wait for autocursor movement + #endif + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY 1 // Frames delay for autocursor movement + #endif + + int result = 0; + GuiState state = guiState; + + bool multiline = false; // TODO: Consider multiline text input + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); + + Rectangle textBounds = GetTextBounds(TEXTBOX, bounds); + int textWidth = GetTextWidth(text) - GetTextWidth(text + textBoxCursorIndex); + int textIndexOffset = 0; // Text index offset to start drawing in the box + + // Cursor rectangle + // NOTE: Position X value should be updated + Rectangle cursor = { + textBounds.x + textWidth + GuiGetStyle(DEFAULT, TEXT_SPACING), + textBounds.y + textBounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE), + 2, + (float)GuiGetStyle(DEFAULT, TEXT_SIZE)*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); + + // Mouse cursor rectangle + // NOTE: Initialized outside of screen + Rectangle mouseCursor = cursor; + mouseCursor.x = -1; + mouseCursor.width = 1; + + // Auto-cursor movement logic + // NOTE: Cursor moves automatically when key down after some time + if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_UP) || IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_BACKSPACE) || IsKeyDown(KEY_DELETE)) autoCursorCooldownCounter++; + else + { + autoCursorCooldownCounter = 0; // GLOBAL: Cursor cooldown counter + autoCursorDelayCounter = 0; // GLOBAL: Cursor delay counter + } + + // Blink-cursor frame counter + //if (!autoCursorMode) blinkCursorFrameCounter++; + //else blinkCursorFrameCounter = 0; + + // Update control + //-------------------------------------------------------------------- + // WARNING: Text editing is only supported under certain conditions: + if ((state != STATE_DISABLED) && // Control not disabled + !GuiGetStyle(TEXTBOX, TEXT_READONLY) && // TextBox not on read-only mode + !guiLocked && // Gui not locked + !guiControlExclusiveMode && // No gui slider on dragging + (wrapMode == TEXT_WRAP_NONE)) // No wrap mode + { + Vector2 mousePosition = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // If text does not fit in the textbox and current cursor position is out of bounds, + // we add an index offset to text for drawing only what requires depending on cursor + while (textWidth >= textBounds.width) + { + int nextCodepointSize = 0; + GetCodepointNext(text + textIndexOffset, &nextCodepointSize); + + textIndexOffset += nextCodepointSize; + + textWidth = GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex); + } + + int textLength = (int)strlen(text); // Get current text length + int codepoint = GetCharPressed(); // Get Unicode codepoint + if (multiline && IsKeyPressed(KEY_ENTER)) codepoint = (int)'\n'; + + if (textBoxCursorIndex > textLength) textBoxCursorIndex = textLength; + + // Encode codepoint as UTF-8 + int codepointSize = 0; + const char *charEncoded = CodepointToUTF8(codepoint, &codepointSize); + + // Add codepoint to text, at current cursor position + // NOTE: Make sure we do not overflow buffer size + if (((multiline && (codepoint == (int)'\n')) || (codepoint >= 32)) && ((textLength + codepointSize) < textSize)) + { + // Move forward data from cursor position + for (int i = (textLength + codepointSize); i > textBoxCursorIndex; i--) text[i] = text[i - codepointSize]; + + // Add new codepoint in current cursor position + for (int i = 0; i < codepointSize; i++) text[textBoxCursorIndex + i] = charEncoded[i]; + + textBoxCursorIndex += codepointSize; + textLength += codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + + // Move cursor to start + if ((textLength > 0) && IsKeyPressed(KEY_HOME)) textBoxCursorIndex = 0; + + // Move cursor to end + if ((textLength > textBoxCursorIndex) && IsKeyPressed(KEY_END)) textBoxCursorIndex = textLength; + + // Delete codepoint from text, after current cursor position + if ((textLength > textBoxCursorIndex) && (IsKeyPressed(KEY_DELETE) || (IsKeyDown(KEY_DELETE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_DELETE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + // Move backward text from cursor position + for (int i = textBoxCursorIndex; i < textLength; i++) text[i] = text[i + nextCodepointSize]; + + textLength -= codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Delete codepoint from text, before current cursor position + if ((textLength > 0) && (IsKeyPressed(KEY_BACKSPACE) || (IsKeyDown(KEY_BACKSPACE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_BACKSPACE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + // Move backward text from cursor position + for (int i = (textBoxCursorIndex - prevCodepointSize); i < textLength; i++) text[i] = text[i + prevCodepointSize]; + + // Prevent cursor index from decrementing past 0 + if (textBoxCursorIndex > 0) + { + textBoxCursorIndex -= codepointSize; + textLength -= codepointSize; + } + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Move cursor position with keys + if (IsKeyPressed(KEY_LEFT) || (IsKeyDown(KEY_LEFT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_LEFT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + if (textBoxCursorIndex >= prevCodepointSize) textBoxCursorIndex -= prevCodepointSize; + } + } + else if (IsKeyPressed(KEY_RIGHT) || (IsKeyDown(KEY_RIGHT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_RIGHT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + if ((textBoxCursorIndex + nextCodepointSize) <= textLength) textBoxCursorIndex += nextCodepointSize; + } + } + + // Move cursor position with mouse + if (CheckCollisionPointRec(mousePosition, textBounds)) // Mouse hover text + { + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/(float)guiFont.baseSize; + int codepointIndex = 0; + float glyphWidth = 0.0f; + float widthToMouseX = 0; + int mouseCursorIndex = 0; + + for (int i = textIndexOffset; i < textLength; i++) + { + codepoint = GetCodepointNext(&text[i], &codepointSize); + codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + if (mousePosition.x <= (textBounds.x + (widthToMouseX + glyphWidth/2))) + { + mouseCursor.x = textBounds.x + widthToMouseX; + mouseCursorIndex = i; + break; + } + + widthToMouseX += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + + // Check if mouse cursor is at the last position + int textEndWidth = GetTextWidth(text + textIndexOffset); + if (GetMousePosition().x >= (textBounds.x + textEndWidth - glyphWidth/2)) + { + mouseCursor.x = textBounds.x + textEndWidth; + mouseCursorIndex = (int)strlen(text); + } + + // Place cursor at required index on mouse click + if ((mouseCursor.x >= 0) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + cursor.x = mouseCursor.x; + textBoxCursorIndex = mouseCursorIndex; + } + } + else mouseCursor.x = -1; + + // Recalculate cursor position.y depending on textBoxCursorIndex + cursor.x = bounds.x + GuiGetStyle(TEXTBOX, TEXT_PADDING) + GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex) + GuiGetStyle(DEFAULT, TEXT_SPACING); + //if (multiline) cursor.y = GetTextLines() + + // Finish text editing on ENTER or mouse click outside bounds + if ((!multiline && IsKeyPressed(KEY_ENTER)) || + (!CheckCollisionPointRec(mousePosition, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) + { + textBoxCursorIndex = 0; // GLOBAL: Reset the shared cursor index + result = 1; + } + } + else + { + if (CheckCollisionPointRec(mousePosition, bounds)) + { + state = STATE_FOCUSED; + + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + textBoxCursorIndex = (int)strlen(text); // GLOBAL: Place cursor index to the end of current text + result = 1; + } + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_PRESSED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))); + } + else if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))); + } + else GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), BLANK); + + // Draw text considering index offset if required + // NOTE: Text index offset depends on cursor position + GuiDrawText(text + textIndexOffset, textBounds, GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode && !GuiGetStyle(TEXTBOX, TEXT_READONLY)) + { + //if (autoCursorMode || ((blinkCursorFrameCounter/40)%2 == 0)) + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + + // Draw mouse position cursor (if required) + if (mouseCursor.x >= 0) GuiDrawRectangle(mouseCursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + } + else if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; // Mouse button pressed: result = 1 +} + +/* +// Text Box control with multiple lines and word-wrap +// NOTE: This text-box is readonly, no editing supported by default +bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode) +{ + bool pressed = false; + + GuiSetStyle(TEXTBOX, TEXT_READONLY, 1); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_WORD); // WARNING: If wrap mode enabled, text editing is not supported + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_TOP); + + // TODO: Implement methods to calculate cursor position properly + pressed = GuiTextBox(bounds, text, textSize, editMode); + + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_NONE); + GuiSetStyle(TEXTBOX, TEXT_READONLY, 0); + + return pressed; +} +*/ + +// Spinner control, returns selected value +int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + int result = 1; + GuiState state = guiState; + + int tempValue = *value; + + 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 }; + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check spinner state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + 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; + if (tempValue > maxValue) tempValue = maxValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + result = GuiValueBox(spinner, NULL, &tempValue, minValue, maxValue, editMode); + + // Draw value selector custom buttons + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH)); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, 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) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + *value = tempValue; + return result; +} + +// Value Box control, updates input text with numbers +// NOTE: Requires static variables: frameCounter +int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + #if !defined(RAYGUI_VALUEBOX_MAX_CHARS) + #define RAYGUI_VALUEBOX_MAX_CHARS 32 + #endif + + int result = 0; + GuiState state = guiState; + + char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + sprintf(textValue, "%i", *value); + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + 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) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + bool valueHasChanged = false; + + if (editMode) + { + state = STATE_PRESSED; + + int keyCount = (int)strlen(textValue); + + // Only allow keys in range [48..57] + if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS) + { + if (GetTextWidth(textValue) < bounds.width) + { + int key = GetCharPressed(); + if ((key >= 48) && (key <= 57)) + { + textValue[keyCount] = (char)key; + keyCount++; + valueHasChanged = true; + } + } + } + + // Delete text + if (keyCount > 0) + { + if (IsKeyPressed(KEY_BACKSPACE)) + { + keyCount--; + textValue[keyCount] = '\0'; + valueHasChanged = true; + } + } + + 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))) + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + result = 1; + } + } + else + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + Color baseColor = BLANK; + if (state == STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED)); + else if (state == STATE_DISABLED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED)); + + GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), baseColor); + GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode) + { + // NOTE: ValueBox internal text is always centered + Rectangle cursor = { bounds.x + GetTextWidth(textValue)/2 + bounds.width/2 + 1, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) }; + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED))); + } + + // Draw text label if provided + GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Slider control with pro parameters +// NOTE: Other GuiSlider*() controls use this one +int GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue, int sliderWidth) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + float oldValue = *value; + + Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + if (!CheckCollisionPointRec(mousePoint, slider)) + { + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else state = STATE_FOCUSED; + } + + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + } + + // Control value change check + if (oldValue == *value) result = 0; + else result = 1; + + // Slider bar limits check + int sliderValue = (int)(((*value - minValue)/(maxValue - minValue))*(bounds.width - sliderWidth - GuiGetStyle(SLIDER, BORDER_WIDTH))); + if (sliderWidth > 0) // Slider + { + slider.x += sliderValue; + slider.width = (float)sliderWidth; + if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH); + else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH); + } + else if (sliderWidth == 0) // SliderBar + { + slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH); + slider.width = (float)sliderValue; + if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), GetColor(GuiGetStyle(SLIDER, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + + // Draw slider internal bar (depends on state) + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_PRESSED))); + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Slider control extended, returns selected value and has text +int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH)); +} + +// Slider Bar control extended, returns selected value +int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, 0); +} + +// Progress Bar control extended, shows current progress value +int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + + // Progress bar + Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), + bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0, + bounds.height - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) - 2*GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if (*value > maxValue) *value = maxValue; + + // WARNING: Working with floats could lead to rounding issues + if ((state != STATE_DISABLED)) progress.width = (float)(*value/(maxValue - minValue))*bounds.width - ((*value >= maxValue)? (float)(2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)) : 0.0f); + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(PROGRESSBAR, BORDER + (state*3))), BLANK); + } + else + { + if (*value > minValue) + { + // Draw progress bar with colored border, more visual + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + } + else GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + + if (*value >= maxValue) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + progress.width + 1, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + else + { + // Draw borders not yet reached by value + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y + bounds.height - 1, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + } + + // Draw slider internal progress bar (depends on state) + GuiDrawRectangle(progress, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED))); + } + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Status Bar control +int GuiStatusBar(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(STATUSBAR, BORDER + (state*3))), GetColor(GuiGetStyle(STATUSBAR, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), GetColor(GuiGetStyle(STATUSBAR, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Dummy rectangle control, intended for placeholding +int GuiDummyRec(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + GuiDrawText(text, GetTextBounds(DEFAULT, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(BUTTON, (state != STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED))); + //------------------------------------------------------------------ + + return result; +} + +// List View control +int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active) +{ + int result = 0; + int itemCount = 0; + const char **items = NULL; + + if (text != NULL) items = GuiTextSplit(text, ';', &itemCount, NULL); + + result = GuiListViewEx(bounds, items, itemCount, scrollIndex, active, NULL); + + return result; +} + +// List View control with extended parameters +int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus) +{ + int result = 0; + GuiState state = guiState; + + int itemFocused = (focus == NULL)? -1 : *focus; + int itemSelected = (active == NULL)? -1 : *active; + + // Check if we need a scroll bar + bool useScrollBar = false; + 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_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_SPACING)); + if (visibleItems > count) visibleItems = count; + + int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex; + if ((startIndex < 0) || (startIndex > (count - visibleItems))) startIndex = 0; + int endIndex = startIndex + visibleItems; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check mouse inside list view + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Check focused and selected item + for (int i = 0; i < visibleItems; i++) + { + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = startIndex + i; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + if (itemSelected == (startIndex + i)) itemSelected = -1; + else itemSelected = startIndex + i; + } + break; + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + int wheelMove = (int)GetMouseWheelMove(); + startIndex -= wheelMove; + + if (startIndex < 0) startIndex = 0; + else if (startIndex > (count - visibleItems)) startIndex = count - visibleItems; + + endIndex = startIndex + visibleItems; + if (endIndex > count) endIndex = count; + } + } + else itemFocused = -1; + + // Reset item rectangle y to [0] + itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background + + // Draw visible items + for (int i = 0; ((i < visibleItems) && (text != NULL)); i++) + { + if (state == STATE_DISABLED) + { + if ((startIndex + i) == itemSelected) GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED))); + + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED))); + } + else + { + if (((startIndex + i) == itemSelected) && (active != NULL)) + { + // Draw item selected + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED))); + } + else if (((startIndex + i) == itemFocused)) // && (focus != NULL)) // NOTE: We want items focused, despite not returned! + { + // Draw item focused + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED))); + } + else + { + // Draw item normal + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL))); + } + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + Rectangle scrollBarBounds = { + bounds.x + bounds.width - GuiGetStyle(LISTVIEW, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.y + GuiGetStyle(LISTVIEW, BORDER_WIDTH), (float)GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) + }; + + // Calculate percentage of visible items and apply same percentage to scrollbar + float percentVisible = (float)(endIndex - startIndex)/count; + float sliderSize = bounds.height*percentVisible; + + int prevSliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); // Save default slider size + int prevScrollSpeed = GuiGetStyle(SCROLLBAR, SCROLL_SPEED); // Save default scroll speed + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)sliderSize); // Change slider size + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems); // Change scroll speed + + startIndex = GuiScrollBar(scrollBarBounds, startIndex, 0, count - visibleItems); + + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed); // Reset scroll speed to default + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize); // Reset slider size to default + } + //-------------------------------------------------------------------- + + if (active != NULL) *active = itemSelected; + if (focus != NULL) *focus = itemFocused; + if (scrollIndex != NULL) *scrollIndex = startIndex; + + return result; +} + +// Color Panel control - Color (RGBA) variant. +int GuiColorPanel(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Vector3 vcolor = { (float)color->r/255.0f, (float)color->g/255.0f, (float)color->b/255.0f }; + Vector3 hsv = ConvertRGBtoHSV(vcolor); + Vector3 prevHsv = hsv; // workaround to see if GuiColorPanelHSV modifies the hsv. + + GuiColorPanelHSV(bounds, text, &hsv); + + // Check if the hsv was changed, only then change the color. + // This is necessary, because the Color->HSV->Color conversion has precision errors. + // Thus the assignment from HSV to Color should only be made, if the HSV has a new user-entered value. + // Otherwise GuiColorPanel would often modify it's color without user input. + // TODO: GuiColorPanelHSV could return 1 if the slider was dragged, to simplify this check. + if (hsv.x != prevHsv.x || hsv.y != prevHsv.y || hsv.z != prevHsv.z) + { + Vector3 rgb = ConvertHSVtoRGB(hsv); + + // NOTE: Vector3ToColor() only available on raylib 1.8.1 + *color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x), + (unsigned char)(255.0f*rgb.y), + (unsigned char)(255.0f*rgb.z), + color->a }; + } + return result; +} + +// Color Bar Alpha control +// NOTE: Returns alpha value normalized [0..1] +int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +{ + #if !defined(RAYGUI_COLORBARALPHA_CHECKED_SIZE) + #define RAYGUI_COLORBARALPHA_CHECKED_SIZE 10 + #endif + + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + *alpha = (mousePoint.x - bounds.x)/bounds.width; + if (*alpha <= 0.0f) *alpha = 0.0f; + if (*alpha >= 1.0f) *alpha = 1.0f; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *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 = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + + // Draw alpha bar: checked background + if (state != STATE_DISABLED) + { + 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*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(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.4f) : Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.4f)); + } + } + + DrawRectangleGradientEx(bounds, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha)); + } + else DrawRectangleGradientEx(bounds, Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw alpha bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Bar Hue control +// Returns hue value normalized [0..1] +// NOTE: Other similar bars (for reference): +// Color GuiColorBarSat() [WHITE->color] +// Color GuiColorBarValue() [BLACK->color], HSV/HSL +// float GuiColorBarLuminance() [BLACK->WHITE] +int GuiColorBarHue(Rectangle bounds, const char *text, float *hue) +{ + int result = 0; + 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 != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + 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 + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *hue = (mousePoint.y - bounds.y)*360/bounds.height; + if (*hue <= 0.0f) *hue = 0.0f; + if (*hue >= 359.0f) *hue = 359.0f; + + } + else state = STATE_FOCUSED; + + /*if (IsKeyDown(KEY_UP)) + { + hue -= 2.0f; + if (hue <= 0.0f) hue = 0.0f; + } + else if (IsKeyDown(KEY_DOWN)) + { + hue += 2.0f; + if (hue >= 360.0f) hue = 360.0f; + }*/ + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state != STATE_DISABLED) + { + // Draw hue bar:color bars + // TODO: Use directly DrawRectangleGradientEx(bounds, color1, color2, color2, color1); + 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)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw hue bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Picker control +// NOTE: It's divided in multiple controls: +// Color GuiColorPanel(Rectangle bounds, Color color) +// float GuiColorBarAlpha(Rectangle bounds, float alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanel() size +// NOTE: this picker converts RGB to HSV, which can cause the Hue control to jump. If you have this problem, consider using the HSV variant instead +int GuiColorPicker(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Color temp = { 200, 0, 0, 255 }; + if (color == NULL) color = &temp; + + 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) }; + + // NOTE: this conversion can cause low hue-resolution, if the r, g and b value are very similar, which causes the hue bar to shift around when only the GuiColorPanel is used. + Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ (*color).r/255.0f, (*color).g/255.0f, (*color).b/255.0f }); + + GuiColorBarHue(boundsHue, NULL, &hsv.x); + + //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f); + Vector3 rgb = ConvertHSVtoRGB(hsv); + + *color = RAYGUI_CLITERAL(Color){ (unsigned char)roundf(rgb.x*255.0f), (unsigned char)roundf(rgb.y*255.0f), (unsigned char)roundf(rgb.z*255.0f), (*color).a }; + + return result; +} + +// Color Picker control that avoids conversion to RGB and back to HSV on each call, thus avoiding jittering. +// The user can call ConvertHSVtoRGB() to convert *colorHsv value to RGB. +// NOTE: It's divided in multiple controls: +// int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +// int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanelHSV() size +int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + + Vector3 tempHsv = { 0 }; + + if (colorHsv == NULL) + { + const Vector3 tempColor = { 200.0f/255.0f, 0.0f, 0.0f }; + tempHsv = ConvertRGBtoHSV(tempColor); + colorHsv = &tempHsv; + } + + GuiColorPanelHSV(bounds, NULL, colorHsv); + + const Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height }; + + GuiColorBarHue(boundsHue, NULL, &colorHsv->x); + + return result; +} + +// Color Panel control - HSV variant +int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + GuiState state = guiState; + Vector2 pickerSelector = { 0 }; + + const Color colWhite = { 255, 255, 255, 255 }; + const Color colBlack = { 0, 0, 0, 255 }; + + pickerSelector.x = bounds.x + (float)colorHsv->y*bounds.width; // HSV: Saturation + pickerSelector.y = bounds.y + (1.0f - (float)colorHsv->z)*bounds.height; // HSV: Value + + Vector3 maxHue = { colorHsv->x, 1.0f, 1.0f }; + Vector3 rgbHue = ConvertHSVtoRGB(maxHue); + Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x), + (unsigned char)(255.0f*rgbHue.y), + (unsigned char)(255.0f*rgbHue.z), 255 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + pickerSelector = mousePoint; + + if (pickerSelector.x < bounds.x) pickerSelector.x = bounds.x; + if (pickerSelector.x > bounds.x + bounds.width) pickerSelector.x = bounds.x + bounds.width; + if (pickerSelector.y < bounds.y) pickerSelector.y = bounds.y; + if (pickerSelector.y > bounds.y + bounds.height) pickerSelector.y = bounds.y + bounds.height; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + 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)); + + // Draw color picker: selector + Rectangle selector = { pickerSelector.x - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, pickerSelector.y - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE) }; + GuiDrawRectangle(selector, 0, BLANK, colWhite); + } + else + { + DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.6f), guiAlpha)); + } + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + //-------------------------------------------------------------------- + + return result; +} + +// Message Box control +int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons) +{ + #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 result = -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 + 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; + + int textWidth = GetTextWidth(message) + 2; + + Rectangle textBounds = { 0 }; + textBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.width = bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*2; + textBounds.height = bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 3*RAYGUI_MESSAGEBOX_BUTTON_PADDING - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + + prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment); + //-------------------------------------------------------------------- + + return result; +} + +// Text Input Box control, ask for text +int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, bool *secretViewActive) +{ + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT 24 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_PADDING) + #define RAYGUI_TEXTINPUTBOX_BUTTON_PADDING 12 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_HEIGHT 26 + #endif + + // Used to enable text edit mode + // WARNING: No more than one GuiTextInputBox() should be open at the same time + static bool textEditMode = false; + + int result = -1; + + int buttonCount = 0; + const char **buttonsText = GuiTextSplit(buttons, ';', &buttonCount, NULL); + Rectangle buttonBounds = { 0 }; + 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 - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - 2*RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + + Rectangle textBounds = { 0 }; + if (message != NULL) + { + int textSize = GetTextWidth(message) + 2; + + textBounds.x = bounds.x + bounds.width/2 - textSize/2; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + messageInputHeight/4 - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + textBounds.width = (float)textSize; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + } + + Rectangle textBoxBounds = { 0 }; + 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 - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*2; + textBoxBounds.height = RAYGUI_TEXTINPUTBOX_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + // Draw message if available + if (message != NULL) + { + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + } + + 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; + + 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, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + if (result >= 0) textEditMode = false; + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment); + //-------------------------------------------------------------------- + + return result; // Result is the pressed button index +} + +// Grid control +// NOTE: Returns grid mouse-hover selected cell +// About drawing lines at subpixel spacing, simple put, not easy solution: +// https://stackoverflow.com/questions/4435450/2d-opengl-drawing-lines-that-dont-exactly-fit-pixel-raster +int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell) +{ + // Grid lines alpha amount + #if !defined(RAYGUI_GRID_ALPHA) + #define RAYGUI_GRID_ALPHA 0.15f + #endif + + int result = 0; + GuiState state = guiState; + + Vector2 mousePoint = GetMousePosition(); + Vector2 currentMouseCell = { -1, -1 }; + + float spaceWidth = spacing/(float)subdivs; + int linesV = (int)(bounds.width/spaceWidth) + 1; + int linesH = (int)(bounds.height/spaceWidth) + 1; + + int color = GuiGetStyle(DEFAULT, LINE_COLOR); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + // NOTE: Cell values must be the upper left of the cell the mouse is in + currentMouseCell.x = floorf((mousePoint.x - bounds.x)/spacing); + currentMouseCell.y = floorf((mousePoint.y - bounds.y)/spacing); + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) color = GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED); + + if (subdivs > 0) + { + // Draw vertical grid lines + for (int i = 0; i < linesV; i++) + { + Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height }; + GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(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)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(color), RAYGUI_GRID_ALPHA)); + } + } + + if (mouseCell != NULL) *mouseCell = currentMouseCell; + return result; +} + +//---------------------------------------------------------------------------------- +// Tooltip management functions +// NOTE: Tooltips requires some global variables: tooltipPtr +//---------------------------------------------------------------------------------- +// Enable gui tooltips (global state) +void GuiEnableTooltip(void) { guiTooltip = true; } + +// Disable gui tooltips (global state) +void GuiDisableTooltip(void) { guiTooltip = false; } + +// Set tooltip string +void GuiSetTooltip(const char *tooltip) { guiTooltipPtr = tooltip; } + +//---------------------------------------------------------------------------------- +// Styles loading functions +//---------------------------------------------------------------------------------- + +// 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; + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + // Try reading the files as text file first + FILE *rgsFile = fopen(fileName, "rt"); + + if (rgsFile != NULL) + { + char buffer[MAX_LINE_BUFFER_SIZE] = { 0 }; + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + + if (buffer[0] == '#') + { + int controlId = 0; + int propertyId = 0; + unsigned int propertyValue = 0; + + while (!feof(rgsFile)) + { + switch (buffer[0]) + { + case 'p': + { + // Style property: p + + sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue); + GuiSetStyle(controlId, propertyId, (int)propertyValue); + + } break; + case 'f': + { + // Style font: f + + int fontSize = 0; + char charmapFileName[256] = { 0 }; + char fontFileName[256] = { 0 }; + sscanf(buffer, "f %d %s %[^\r\n]s", &fontSize, charmapFileName, fontFileName); + + Font font = { 0 }; + int *codepoints = NULL; + int codepointCount = 0; + + if (charmapFileName[0] != '0') + { + // Load text data from file + // NOTE: Expected an UTF-8 array of codepoints, no separation + char *textData = LoadFileText(TextFormat("%s/%s", GetDirectoryPath(fileName), charmapFileName)); + codepoints = LoadCodepoints(textData, &codepointCount); + UnloadFileText(textData); + } + + if (fontFileName[0] != '\0') + { + // In case a font is already loaded and it is not default internal font, unload it + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + + if (codepointCount > 0) font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, codepoints, codepointCount); + else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0); // Default to 95 standard codepoints + } + + // If font texture not properly loaded, revert to default font and size/spacing + if (font.texture.id == 0) + { + font = GetFontDefault(); + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); + } + + UnloadCodepoints(codepoints); + + if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font); + + } break; + default: break; + } + + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + } + } + else tryBinary = true; + + fclose(rgsFile); + } + + if (tryBinary) + { + rgsFile = fopen(fileName, "rb"); + + if (rgsFile != NULL) + { + fseek(rgsFile, 0, SEEK_END); + int fileDataSize = ftell(rgsFile); + fseek(rgsFile, 0, SEEK_SET); + + if (fileDataSize > 0) + { + unsigned char *fileData = (unsigned char *)RAYGUI_MALLOC(fileDataSize*sizeof(unsigned char)); + fread(fileData, sizeof(unsigned char), fileDataSize, rgsFile); + + GuiLoadStyleFromMemory(fileData, fileDataSize); + + RAYGUI_FREE(fileData); + } + + fclose(rgsFile); + } + } +} + +// Load style default over global style +void GuiLoadStyleDefault(void) +{ + // We set this variable first to avoid cyclic function calls + // when calling GuiSetStyle() and GuiGetStyle() + guiStyleLoaded = true; + + // Initialize default LIGHT style property values + // WARNING: Default value are applied to all controls on set but + // they can be overwritten later on for every custom control + GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, 0x838383ff); + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0xc9c9c9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, 0x686868ff); + GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, 0x5bb2d9ff); + GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, 0xc9effeff); + GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, 0x6c9bbcff); + GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, 0x0492c7ff); + GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, 0x97e8ffff); + GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, 0x368bafff); + GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, 0xb5c1c2ff); + GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, 0xe6e9e9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, 0xaeb7b8ff); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); + GuiSetStyle(DEFAULT, TEXT_PADDING, 0); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + // Initialize default extended property values + // NOTE: By default, extended property values are initialized to 0 + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, LINE_COLOR, 0x90abb5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0xf5f5f5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, TEXT_LINE_SPACING, 15); // DEFAULT, 15 pixels between lines + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); // DEFAULT, text aligned vertically to middle of text-bounds + + // Initialize control-specific property values + // NOTE: Those properties are in default list but require specific values by control type + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 2); + GuiSetStyle(SLIDER, TEXT_PADDING, 4); + GuiSetStyle(PROGRESSBAR, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, TEXT_ALIGN_RIGHT); + GuiSetStyle(DROPDOWNBOX, TEXT_PADDING, 0); + GuiSetStyle(DROPDOWNBOX, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiSetStyle(TEXTBOX, TEXT_PADDING, 4); + GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(VALUEBOX, TEXT_PADDING, 0); + GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(SPINNER, TEXT_PADDING, 0); + 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 + GuiSetStyle(TOGGLE, GROUP_PADDING, 2); + 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, 32); + GuiSetStyle(COMBOBOX, COMBO_BUTTON_SPACING, 2); + GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16); + GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING, 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, 12); + GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 28); + GuiSetStyle(LISTVIEW, LIST_ITEMS_SPACING, 2); + GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 12); + GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE); + 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); + + if (guiFont.texture.id != GetFontDefault().texture.id) + { + // Unload previous font texture + UnloadTexture(guiFont.texture); + RL_FREE(guiFont.recs); + RL_FREE(guiFont.glyphs); + guiFont.recs = NULL; + guiFont.glyphs = NULL; + + // Setup default raylib font + guiFont = GetFontDefault(); + + // NOTE: Default raylib font character 95 is a white square + Rectangle whiteChar = guiFont.recs[95]; + + // NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding on MSAA filtering + SetShapesTexture(guiFont.texture, RAYGUI_CLITERAL(Rectangle){ whiteChar.x + 1, whiteChar.y + 1, whiteChar.width - 2, whiteChar.height - 2 }); + } +} + +// Get text with icon id prepended +// NOTE: Useful to add icons by name id (enum) instead of +// a number that can change between ricon versions +const char *GuiIconText(int iconId, const char *text) +{ +#if defined(RAYGUI_NO_ICONS) + return NULL; +#else + static char buffer[1024] = { 0 }; + static char iconBuffer[16] = { 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); + + return iconBuffer; + } +#endif +} + +#if !defined(RAYGUI_NO_ICONS) +// Get full icons data pointer +unsigned int *GuiGetIcons(void) { return guiIconsPtr; } + +// Load raygui icons file (.rgi) +// NOTE: In case nameIds are required, they can be requested with loadIconsName, +// 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) +{ + // Style File Structure (.rgi) + // ------------------------------------------------------ + // Offset | Size | Type | Description + // ------------------------------------------------------ + // 0 | 4 | char | Signature: "rGI " + // 4 | 2 | short | Version: 100 + // 6 | 2 | short | reserved + + // 8 | 2 | short | Num icons (N) + // 10 | 2 | short | Icons size (Options: 16, 32, 64) (S) + + // Icons name id (32 bytes per name id) + // foreach (icon) + // { + // 12+32*i | 32 | char | Icon NameId + // } + + // Icons data: One bit per pixel, stored as unsigned int array (depends on icon size) + // S*S pixels/32bit per unsigned int = K unsigned int per icon + // foreach (icon) + // { + // ... | K | unsigned int | Icon Data + // } + + FILE *rgiFile = fopen(fileName, "rb"); + + char **guiIconsName = NULL; + + if (rgiFile != NULL) + { + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + short iconCount = 0; + short iconSize = 0; + + fread(signature, 1, 4, rgiFile); + fread(&version, sizeof(short), 1, rgiFile); + fread(&reserved, sizeof(short), 1, rgiFile); + fread(&iconCount, sizeof(short), 1, rgiFile); + fread(&iconSize, sizeof(short), 1, rgiFile); + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'I') && + (signature[3] == ' ')) + { + if (loadIconsName) + { + guiIconsName = (char **)RAYGUI_MALLOC(iconCount*sizeof(char **)); + for (int i = 0; i < iconCount; i++) + { + guiIconsName[i] = (char *)RAYGUI_MALLOC(RAYGUI_ICON_MAX_NAME_LENGTH); + fread(guiIconsName[i], 1, RAYGUI_ICON_MAX_NAME_LENGTH, rgiFile); + } + } + else fseek(rgiFile, iconCount*RAYGUI_ICON_MAX_NAME_LENGTH, SEEK_CUR); + + // Read icons data directly over internal icons array + fread(guiIconsPtr, sizeof(unsigned int), iconCount*(iconSize*iconSize/32), rgiFile); + } + + fclose(rgiFile); + } + + return guiIconsName; +} + +// Draw selected icon using rectangles pixel-by-pixel +void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color) +{ + #define BIT_CHECK(a,b) ((a) & (1u<<(b))) + + 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(guiIconsPtr[iconId*RAYGUI_ICON_DATA_ELEMENTS + i], k)) + { + #if !defined(RAYGUI_STANDALONE) + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ (float)posX + (k%RAYGUI_ICON_SIZE)*pixelSize, (float)posY + y*pixelSize, (float)pixelSize, (float)pixelSize }, 0, BLANK, color); + #endif + } + + if ((k == 15) || (k == 31)) y++; + } + } +} + +// Set icon drawing size +void GuiSetIconScale(int scale) +{ + if (scale >= 1) guiIconScale = scale; +} + +#endif // !RAYGUI_NO_ICONS + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- + +// Load style from memory +// WARNING: Binary files only +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize) +{ + unsigned char *fileDataPtr = (unsigned char *)fileData; + + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + int propertyCount = 0; + + memcpy(signature, fileDataPtr, 4); + memcpy(&version, fileDataPtr + 4, sizeof(short)); + memcpy(&reserved, fileDataPtr + 4 + 2, sizeof(short)); + memcpy(&propertyCount, fileDataPtr + 4 + 2 + 2, sizeof(int)); + fileDataPtr += 12; + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'S') && + (signature[3] == ' ')) + { + short controlId = 0; + short propertyId = 0; + unsigned int propertyValue = 0; + + for (int i = 0; i < propertyCount; i++) + { + memcpy(&controlId, fileDataPtr, sizeof(short)); + memcpy(&propertyId, fileDataPtr + 2, sizeof(short)); + memcpy(&propertyValue, fileDataPtr + 2 + 2, sizeof(unsigned int)); + fileDataPtr += 8; + + if (controlId == 0) // DEFAULT control + { + // If a DEFAULT property is loaded, it is propagated to all controls + // NOTE: All DEFAULT properties should be defined first in the file + GuiSetStyle(0, (int)propertyId, propertyValue); + + if (propertyId < RAYGUI_MAX_PROPS_BASE) for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) GuiSetStyle(i, (int)propertyId, propertyValue); + } + else GuiSetStyle((int)controlId, (int)propertyId, propertyValue); + } + + // Font loading is highly dependant on raylib API to load font data and image + +#if !defined(RAYGUI_STANDALONE) + // Load custom font if available + int fontDataSize = 0; + memcpy(&fontDataSize, fileDataPtr, sizeof(int)); + fileDataPtr += 4; + + if (fontDataSize > 0) + { + Font font = { 0 }; + int fontType = 0; // 0-Normal, 1-SDF + + memcpy(&font.baseSize, fileDataPtr, sizeof(int)); + memcpy(&font.glyphCount, fileDataPtr + 4, sizeof(int)); + memcpy(&fontType, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + // Load font white rectangle + Rectangle fontWhiteRec = { 0 }; + memcpy(&fontWhiteRec, fileDataPtr, sizeof(Rectangle)); + fileDataPtr += 16; + + // Load font image parameters + int fontImageUncompSize = 0; + int fontImageCompSize = 0; + memcpy(&fontImageUncompSize, fileDataPtr, sizeof(int)); + memcpy(&fontImageCompSize, fileDataPtr + 4, sizeof(int)); + fileDataPtr += 8; + + Image imFont = { 0 }; + imFont.mipmaps = 1; + memcpy(&imFont.width, fileDataPtr, sizeof(int)); + memcpy(&imFont.height, fileDataPtr + 4, sizeof(int)); + memcpy(&imFont.format, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + if ((fontImageCompSize > 0) && (fontImageCompSize != fontImageUncompSize)) + { + // Compressed font atlas image data (DEFLATE), it requires DecompressData() + int dataUncompSize = 0; + unsigned char *compData = (unsigned char *)RAYGUI_MALLOC(fontImageCompSize); + memcpy(compData, fileDataPtr, fontImageCompSize); + fileDataPtr += fontImageCompSize; + + imFont.data = DecompressData(compData, fontImageCompSize, &dataUncompSize); + + // Security check, dataUncompSize must match the provided fontImageUncompSize + if (dataUncompSize != fontImageUncompSize) RAYGUI_LOG("WARNING: Uncompressed font atlas image data could be corrupted"); + + RAYGUI_FREE(compData); + } + else + { + // Font atlas image data is not compressed + imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageUncompSize); + memcpy(imFont.data, fileDataPtr, fontImageUncompSize); + fileDataPtr += fontImageUncompSize; + } + + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + font.texture = LoadTextureFromImage(imFont); + + RAYGUI_FREE(imFont.data); + + // Validate font atlas texture was loaded correctly + if (font.texture.id != 0) + { + // Load font recs data + int recsDataSize = font.glyphCount*sizeof(Rectangle); + int recsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed recs data + memcpy(&recsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + if ((recsDataCompressedSize > 0) && (recsDataCompressedSize != recsDataSize)) + { + // Recs data is compressed, uncompress it + unsigned char *recsDataCompressed = (unsigned char *)RAYGUI_MALLOC(recsDataCompressedSize); + + memcpy(recsDataCompressed, fileDataPtr, recsDataCompressedSize); + fileDataPtr += recsDataCompressedSize; + + int recsDataUncompSize = 0; + font.recs = (Rectangle *)DecompressData(recsDataCompressed, recsDataCompressedSize, &recsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (recsDataUncompSize != recsDataSize) RAYGUI_LOG("WARNING: Uncompressed font recs data could be corrupted"); + + RAYGUI_FREE(recsDataCompressed); + } + else + { + // Recs data is uncompressed + font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle)); + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.recs[i], fileDataPtr, sizeof(Rectangle)); + fileDataPtr += sizeof(Rectangle); + } + } + + // Load font glyphs info data + int glyphsDataSize = font.glyphCount*16; // 16 bytes data per glyph + int glyphsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed glyphs data + memcpy(&glyphsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + // Allocate required glyphs space to fill with data + font.glyphs = (GlyphInfo *)RAYGUI_CALLOC(font.glyphCount, sizeof(GlyphInfo)); + + if ((glyphsDataCompressedSize > 0) && (glyphsDataCompressedSize != glyphsDataSize)) + { + // Glyphs data is compressed, uncompress it + unsigned char *glypsDataCompressed = (unsigned char *)RAYGUI_MALLOC(glyphsDataCompressedSize); + + memcpy(glypsDataCompressed, fileDataPtr, glyphsDataCompressedSize); + fileDataPtr += glyphsDataCompressedSize; + + int glyphsDataUncompSize = 0; + unsigned char *glyphsDataUncomp = DecompressData(glypsDataCompressed, glyphsDataCompressedSize, &glyphsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (glyphsDataUncompSize != glyphsDataSize) RAYGUI_LOG("WARNING: Uncompressed font glyphs data could be corrupted"); + + unsigned char *glyphsDataUncompPtr = glyphsDataUncomp; + + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, glyphsDataUncompPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, glyphsDataUncompPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, glyphsDataUncompPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, glyphsDataUncompPtr + 12, sizeof(int)); + glyphsDataUncompPtr += 16; + } + + RAYGUI_FREE(glypsDataCompressed); + RAYGUI_FREE(glyphsDataUncomp); + } + else + { + // Glyphs data is uncompressed + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, fileDataPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, fileDataPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, fileDataPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, fileDataPtr + 12, sizeof(int)); + fileDataPtr += 16; + } + } + } + else font = GetFontDefault(); // Fallback in case of errors loading font atlas texture + + GuiSetFont(font); + + // Set font texture source rectangle to be used as white texture to draw shapes + // NOTE: It makes possible to draw shapes and text (full UI) in a single draw call + if ((fontWhiteRec.x > 0) && + (fontWhiteRec.y > 0) && + (fontWhiteRec.width > 0) && + (fontWhiteRec.height > 0)) SetShapesTexture(font.texture, fontWhiteRec); + } +#endif + } +} + +// Gui get text width considering icon +static int GetTextWidth(const char *text) +{ + #if !defined(ICON_TEXT_PADDING) + #define ICON_TEXT_PADDING 4 + #endif + + Vector2 textSize = { 0 }; + int textIconOffset = 0; + + if ((text != NULL) && (text[0] != '\0')) + { + if (text[0] == '#') + { + for (int i = 1; (i < 5) && (text[i] != '\0'); i++) + { + if (text[i] == '#') + { + textIconOffset = i; + break; + } + } + } + + text += textIconOffset; + + // Make sure guiFont is set, GuiGetStyle() initializes it lazynessly + float fontSize = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + + // Custom MeasureText() implementation + if ((guiFont.texture.id > 0) && (text != NULL)) + { + // Get size in bytes of text, considering end of line and line break + int size = 0; + for (int i = 0; i < MAX_LINE_BUFFER_SIZE; i++) + { + if ((text[i] != '\0') && (text[i] != '\n')) size++; + else break; + } + + float scaleFactor = fontSize/(float)guiFont.baseSize; + textSize.y = (float)guiFont.baseSize*scaleFactor; + float glyphWidth = 0.0f; + + for (int i = 0, codepointSize = 0; i < size; i += codepointSize) + { + int codepoint = GetCodepointNext(&text[i], &codepointSize); + int codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + textSize.x += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (textIconOffset > 0) textSize.x += (RAYGUI_ICON_SIZE - ICON_TEXT_PADDING); + } + + return (int)textSize.x; +} + +// Get text bounds considering control bounds +static Rectangle GetTextBounds(int control, Rectangle bounds) +{ + Rectangle textBounds = bounds; + + textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH); + textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH) + GuiGetStyle(control, TEXT_PADDING); + textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); + textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); // NOTE: Text is processed line per line! + + // Depending on control, TEXT_PADDING and TEXT_ALIGNMENT properties could affect the text-bounds + switch (control) + { + case COMBOBOX: + case DROPDOWNBOX: + case LISTVIEW: + // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW + case SLIDER: + case CHECKBOX: + case VALUEBOX: + case SPINNER: + // TODO: More special cases (label on side): SLIDER, CHECKBOX, VALUEBOX, SPINNER + default: + { + // TODO: WARNING: TEXT_ALIGNMENT is already considered in GuiDrawText() + if (GuiGetStyle(control, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING); + else textBounds.x += GuiGetStyle(control, TEXT_PADDING); + } + break; + } + + return textBounds; +} + +// Get text icon if provided and move text cursor +// NOTE: We support up to 999 values for iconId +static const char *GetTextIcon(const char *text, int *iconId) +{ +#if !defined(RAYGUI_NO_ICONS) + *iconId = -1; + if (text[0] == '#') // Maybe we have an icon! + { + char iconValue[4] = { 0 }; // Maximum length for icon value: 3 digits + '\0' + + int pos = 1; + while ((pos < 4) && (text[pos] >= '0') && (text[pos] <= '9')) + { + iconValue[pos - 1] = text[pos]; + pos++; + } + + if (text[pos] == '#') + { + *iconId = TextToInteger(iconValue); + + // Move text pointer after icon + // WARNING: If only icon provided, it could point to EOL character: '\0' + if (*iconId >= 0) text += (pos + 1); + } + } +#endif + + return text; +} + +// Get text divided into lines (by line-breaks '\n') +const char **GetTextLines(const char *text, int *count) +{ + #define RAYGUI_MAX_TEXT_LINES 128 + + static const char *lines[RAYGUI_MAX_TEXT_LINES] = { 0 }; + for (int i = 0; i < RAYGUI_MAX_TEXT_LINES; i++) lines[i] = NULL; // Init NULL pointers to substrings + + int textSize = (int)strlen(text); + + lines[0] = text; + int len = 0; + *count = 1; + //int lineSize = 0; // Stores current line size, not returned + + for (int i = 0, k = 0; (i < textSize) && (*count < RAYGUI_MAX_TEXT_LINES); i++) + { + if (text[i] == '\n') + { + //lineSize = len; + k++; + lines[k] = &text[i + 1]; // WARNING: next value is valid? + len = 0; + *count += 1; + } + else len++; + } + + //lines[*count - 1].size = len; + + return lines; +} + +// Get text width to next space for provided string +static float GetNextSpaceWidth(const char *text, int *nextSpaceIndex) +{ + float width = 0; + int codepointByteCount = 0; + int codepoint = 0; + int index = 0; + float glyphWidth = 0; + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + for (int i = 0; text[i] != '\0'; i++) + { + if (text[i] != ' ') + { + codepoint = GetCodepoint(&text[i], &codepointByteCount); + index = GetGlyphIndex(guiFont, codepoint); + glyphWidth = (guiFont.glyphs[index].advanceX == 0)? guiFont.recs[index].width*scaleFactor : guiFont.glyphs[index].advanceX*scaleFactor; + width += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + else + { + *nextSpaceIndex = i; + break; + } + } + + return width; +} + +// Gui draw text using default font +static void GuiDrawText(const char *text, Rectangle textBounds, int alignment, Color tint) +{ + #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')) return; // Security check + + // PROCEDURE: + // - Text is processed line per line + // - For every line, horizontal alignment is defined + // - For all text, vertical alignment is defined (multiline text only) + // - For every line, wordwrap mode is checked (useful for GuitextBox(), read-only) + + // Get text lines (using '\n' as delimiter) to be processed individually + // WARNING: We can't use GuiTextSplit() function because it can be already used + // before the GuiDrawText() call and its buffer is static, it would be overriden :( + int lineCount = 0; + const char **lines = GetTextLines(text, &lineCount); + + // Text style variables + //int alignment = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT); + int alignmentVertical = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL); + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); // Wrap-mode only available in read-only mode, no for text editing + + // TODO: WARNING: This totalHeight is not valid for vertical alignment in case of word-wrap + float totalHeight = (float)(lineCount*GuiGetStyle(DEFAULT, TEXT_SIZE) + (lineCount - 1)*GuiGetStyle(DEFAULT, TEXT_SIZE)/2); + float posOffsetY = 0.0f; + + for (int i = 0; i < lineCount; i++) + { + int iconId = 0; + lines[i] = GetTextIcon(lines[i], &iconId); // Check text for icon and move cursor + + // Get text position depending on alignment and iconId + //--------------------------------------------------------------------------------- + Vector2 textBoundsPosition = { textBounds.x, textBounds.y }; + float textBoundsWidthOffset = 0.0f; + + // NOTE: We get text size after icon has been processed + // WARNING: GetTextWidth() also processes text icon to get width! -> Really needed? + int textSizeX = GetTextWidth(lines[i]); + + // If text requires an icon, add size to measure + if (iconId >= 0) + { + textSizeX += RAYGUI_ICON_SIZE*guiIconScale; + + // WARNING: If only icon provided, text could be pointing to EOF character: '\0' +#if !defined(RAYGUI_NO_ICONS) + if ((lines[i] != NULL) && (lines[i][0] != '\0')) textSizeX += ICON_TEXT_PADDING; +#endif + } + + // Check guiTextAlign global variables + switch (alignment) + { + case TEXT_ALIGN_LEFT: textBoundsPosition.x = textBounds.x; break; + case TEXT_ALIGN_CENTER: textBoundsPosition.x = textBounds.x + textBounds.width/2 - textSizeX/2; break; + case TEXT_ALIGN_RIGHT: textBoundsPosition.x = textBounds.x + textBounds.width - textSizeX; break; + default: break; + } + + if (textSizeX > textBounds.width && (lines[i] != NULL) && (lines[i][0] != '\0')) textBoundsPosition.x = textBounds.x; + + switch (alignmentVertical) + { + // Only valid in case of wordWrap = 0; + case TEXT_ALIGN_TOP: textBoundsPosition.y = textBounds.y + posOffsetY; break; + case TEXT_ALIGN_MIDDLE: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height/2 - totalHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + case TEXT_ALIGN_BOTTOM: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height - totalHeight + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + default: break; + } + + // NOTE: Make sure we get pixel-perfect coordinates, + // In case of decimals we got weird text positioning + textBoundsPosition.x = (float)((int)textBoundsPosition.x); + textBoundsPosition.y = (float)((int)textBoundsPosition.y); + //--------------------------------------------------------------------------------- + + // Draw text (with icon if available) + //--------------------------------------------------------------------------------- +#if !defined(RAYGUI_NO_ICONS) + if (iconId >= 0) + { + // NOTE: We consider icon height, probably different than text size + GuiDrawIcon(iconId, (int)textBoundsPosition.x, (int)(textBounds.y + textBounds.height/2 - RAYGUI_ICON_SIZE*guiIconScale/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height)), guiIconScale, tint); + textBoundsPosition.x += (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + textBoundsWidthOffset = (RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + } +#endif + // Get size in bytes of text, + // considering end of line and line break + int lineSize = 0; + for (int c = 0; (lines[i][c] != '\0') && (lines[i][c] != '\n') && (lines[i][c] != '\r'); c++, lineSize++){ } + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + int lastSpaceIndex = 0; + bool tempWrapCharMode = false; + + int textOffsetY = 0; + float textOffsetX = 0.0f; + float glyphWidth = 0; + + float ellipsisWidth = GetTextWidth("..."); + bool overflowReached = false; + for (int c = 0, codepointSize = 0; c < lineSize; c += codepointSize) + { + int codepoint = GetCodepointNext(&lines[i][c], &codepointSize); + int index = GetGlyphIndex(guiFont, codepoint); + + // NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f) + // but we need to draw all of the bad bytes using the '?' symbol moving one byte + if (codepoint == 0x3f) codepointSize = 1; // TODO: Review not recognized codepoints size + + // Get glyph width to check if it goes out of bounds + if (guiFont.glyphs[index].advanceX == 0) glyphWidth = ((float)guiFont.recs[index].width*scaleFactor); + else glyphWidth = (float)guiFont.glyphs[index].advanceX*scaleFactor; + + // Wrap mode text measuring, to validate if + // it can be drawn or a new line is required + if (wrapMode == TEXT_WRAP_CHAR) + { + // Jump to next line if current character reach end of the box limits + if ((textOffsetX + glyphWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + + if (tempWrapCharMode) // Wrap at char level when too long words + { + wrapMode = TEXT_WRAP_WORD; + tempWrapCharMode = false; + } + } + } + else if (wrapMode == TEXT_WRAP_WORD) + { + if (codepoint == 32) lastSpaceIndex = c; + + // Get width to next space in line + int nextSpaceIndex = 0; + float nextSpaceWidth = GetNextSpaceWidth(lines[i] + c, &nextSpaceIndex); + + int nextSpaceIndex2 = 0; + float nextWordSize = GetNextSpaceWidth(lines[i] + lastSpaceIndex + 1, &nextSpaceIndex2); + + if (nextWordSize > textBounds.width - textBoundsWidthOffset) + { + // Considering the case the next word is longer than bounds + tempWrapCharMode = true; + wrapMode = TEXT_WRAP_CHAR; + } + else if ((textOffsetX + nextSpaceWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + } + + if (codepoint == '\n') break; // WARNING: Lines are already processed manually, no need to keep drawing after this codepoint + else + { + // TODO: There are multiple types of spaces in Unicode, + // maybe it's a good idea to add support for more: http://jkorpela.fi/chars/spaces.html + if ((codepoint != ' ') && (codepoint != '\t')) // Do not draw codepoints with no glyph + { + if (wrapMode == TEXT_WRAP_NONE) + { + // Draw only required text glyphs fitting the textBounds.width + if (textSizeX > textBounds.width) + { + if (textOffsetX <= (textBounds.width - glyphWidth - textBoundsWidthOffset - ellipsisWidth)) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + else if (!overflowReached) + { + overflowReached = true; + + for (int j = 0; j < ellipsisWidth; j += ellipsisWidth/3) + { + DrawTextCodepoint(guiFont, '.', RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX + j, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + else + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) + { + // Draw only glyphs inside the bounds + if ((textBoundsPosition.y + textOffsetY) <= (textBounds.y + textBounds.height - GuiGetStyle(DEFAULT, TEXT_SIZE))) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + + if (guiFont.glyphs[index].advanceX == 0) textOffsetX += ((float)guiFont.recs[index].width*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + else textOffsetX += ((float)guiFont.glyphs[index].advanceX*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (wrapMode == TEXT_WRAP_NONE) posOffsetY += (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) posOffsetY += (textOffsetY + (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING)); + //--------------------------------------------------------------------------------- + } + +#if defined(RAYGUI_DEBUG_TEXT_BOUNDS) + GuiDrawRectangle(textBounds, 0, WHITE, Fade(BLUE, 0.4f)); +#endif +} + +// Gui draw rectangle using default raygui plain style with borders +static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color) +{ + if (color.a > 0) + { + // Draw rectangle filled with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, GuiFade(color, guiAlpha)); + } + + if (borderWidth > 0) + { + // Draw rectangle border lines with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + } + +#if defined(RAYGUI_DEBUG_RECS_BOUNDS) + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, Fade(RED, 0.4f)); +#endif +} + +// Draw tooltip using control bounds +static void GuiTooltip(Rectangle controlRec) +{ + if (!guiLocked && guiTooltip && (guiTooltipPtr != NULL) && !guiControlExclusiveMode) + { + Vector2 textSize = MeasureTextEx(GuiGetFont(), guiTooltipPtr, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + + if ((controlRec.x + textSize.x + 16) > GetScreenWidth()) controlRec.x -= (textSize.x + 16 - controlRec.width); + + GuiPanel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, NULL); + + int textPadding = GuiGetStyle(LABEL, TEXT_PADDING); + int textAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_PADDING, 0); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, guiTooltipPtr); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, textAlignment); + GuiSetStyle(LABEL, TEXT_PADDING, textPadding); + } +} + +// Split controls text into multiple strings +// Also check for multiple columns (required by GuiToggleGroup()) +static const char **GuiTextSplit(const char *text, char delimiter, 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 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 + + // TODO: HACK: GuiTextSplit() - Review how textRows are returned to user + // textRow is an externally provided array of integers that stores row number for every splitted string + + #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 }; // String pointers array (points to buffer data) + static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 }; // Buffer data (text input copy with '\0' added) + memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE); + + result[0] = buffer; + int counter = 1; + + if (textRow != NULL) textRow[0] = 0; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if ((buffer[i] == delimiter) || (buffer[i] == '\n')) + { + result[counter] = buffer + i + 1; + + if (textRow != NULL) + { + if (buffer[i] == '\n') textRow[counter] = textRow[counter - 1] + 1; + else textRow[counter] = textRow[counter - 1]; + } + + buffer[i] = '\0'; // Set an end of string at this point + + counter++; + if (counter > RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + + *count = counter; + + return result; +} + +// Convert color data from RGB to HSV +// NOTE: Color data should be passed normalized +static Vector3 ConvertRGBtoHSV(Vector3 rgb) +{ + Vector3 hsv = { 0 }; + float min = 0.0f; + float max = 0.0f; + float delta = 0.0f; + + min = (rgb.x < rgb.y)? rgb.x : rgb.y; + min = (min < rgb.z)? min : rgb.z; + + max = (rgb.x > rgb.y)? rgb.x : rgb.y; + max = (max > rgb.z)? max : rgb.z; + + hsv.z = max; // Value + delta = max - min; + + if (delta < 0.00001f) + { + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + if (max > 0.0f) + { + // NOTE: If max is 0, this divide would cause a crash + hsv.y = (delta/max); // Saturation + } + else + { + // NOTE: If max is 0, then r = g = b = 0, s = 0, h is undefined + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + // NOTE: Comparing float values could not work properly + if (rgb.x >= max) hsv.x = (rgb.y - rgb.z)/delta; // Between yellow & magenta + else + { + if (rgb.y >= max) hsv.x = 2.0f + (rgb.z - rgb.x)/delta; // Between cyan & yellow + else hsv.x = 4.0f + (rgb.x - rgb.y)/delta; // Between magenta & cyan + } + + hsv.x *= 60.0f; // Convert to degrees + + if (hsv.x < 0.0f) hsv.x += 360.0f; + + return hsv; +} + +// Convert color data from HSV to RGB +// NOTE: Color data should be passed normalized +static Vector3 ConvertHSVtoRGB(Vector3 hsv) +{ + Vector3 rgb = { 0 }; + float hh = 0.0f, p = 0.0f, q = 0.0f, t = 0.0f, ff = 0.0f; + long i = 0; + + // NOTE: Comparing float values could not work properly + if (hsv.y <= 0.0f) + { + rgb.x = hsv.z; + rgb.y = hsv.z; + rgb.z = hsv.z; + return rgb; + } + + hh = hsv.x; + if (hh >= 360.0f) hh = 0.0f; + hh /= 60.0f; + + i = (long)hh; + ff = hh - i; + p = hsv.z*(1.0f - hsv.y); + q = hsv.z*(1.0f - (hsv.y*ff)); + t = hsv.z*(1.0f - (hsv.y*(1.0f - ff))); + + switch (i) + { + case 0: + { + rgb.x = hsv.z; + rgb.y = t; + rgb.z = p; + } break; + case 1: + { + rgb.x = q; + rgb.y = hsv.z; + rgb.z = p; + } break; + case 2: + { + rgb.x = p; + rgb.y = hsv.z; + rgb.z = t; + } break; + case 3: + { + rgb.x = p; + rgb.y = q; + rgb.z = hsv.z; + } break; + case 4: + { + rgb.x = t; + rgb.y = p; + rgb.z = hsv.z; + } break; + case 5: + default: + { + rgb.x = hsv.z; + rgb.y = p; + rgb.z = q; + } break; + } + + return rgb; +} + +// 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; + + int valueRange = maxValue - minValue; + if (valueRange <= 0) valueRange = 1; + + int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + if (sliderSize < 1) sliderSize = 1; // TODO: Consider a minimum 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) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.height)? ((int)scrollbar.height - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + scrollbar.y + (int)(((float)(value - minValue)/valueRange)*(scrollbar.height - sliderSize)), + bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)), + (float)sliderSize }; + } + else // horizontal + { + 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)) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.width)? ((int)scrollbar.width - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + scrollbar.x + (int)(((float)(value - minValue)/valueRange)*(scrollbar.width - sliderSize)), + bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + (float)sliderSize, + bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)) }; + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && + !CheckCollisionPointRec(mousePoint, arrowUpLeft) && + !CheckCollisionPointRec(mousePoint, arrowDownRight)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Handle mouse wheel + int wheel = (int)GetMouseWheelMove(); + if (wheel != 0) value += wheel; + + // Handle mouse button down + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + // Check arrows click + if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) value -= valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) value += valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (!CheckCollisionPointRec(mousePoint, slider)) + { + // If click on scrollbar position but not on slider, place slider directly on that position + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + + state = STATE_PRESSED; + } + + // Keyboard control on mouse hover scrollbar + /* + if (isVertical) + { + if (IsKeyDown(KEY_DOWN)) value += 5; + else if (IsKeyDown(KEY_UP)) value -= 5; + } + else + { + if (IsKeyDown(KEY_RIGHT)) value += 5; + else if (IsKeyDown(KEY_LEFT)) value -= 5; + } + */ + } + + // Normalize value + if (value > maxValue) value = maxValue; + if (value < minValue) value = minValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED))); // Draw the background + + GuiDrawRectangle(scrollbar, 0, BLANK, GetColor(GuiGetStyle(BUTTON, BASE_COLOR_NORMAL))); // Draw the scrollbar active area background + GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BORDER + state*3))); // 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, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); + GuiDrawText(isVertical? "v" : ">", + RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // 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, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // ICON_ARROW_DOWN_FILL / ICON_ARROW_RIGHT_FILL +#endif + } + //-------------------------------------------------------------------- + + return value; +} + +// Color fade-in or fade-out, alpha goes from 0.0f to 1.0f +// WARNING: It multiplies current alpha by alpha scale factor +static Color GuiFade(Color color, float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + Color result = { color.r, color.g, color.b, (unsigned char)(color.a*alpha) }; + + return result; +} + +#if defined(RAYGUI_STANDALONE) +// Returns a Color struct from hexadecimal value +static Color GetColor(int hexValue) +{ + Color color; + + color.r = (unsigned char)(hexValue >> 24) & 0xFF; + color.g = (unsigned char)(hexValue >> 16) & 0xFF; + color.b = (unsigned char)(hexValue >> 8) & 0xFF; + color.a = (unsigned char)hexValue & 0xFF; + + return color; +} + +// Returns hexadecimal value for a Color +static int ColorToInt(Color color) +{ + return (((int)color.r << 24) | ((int)color.g << 16) | ((int)color.b << 8) | (int)color.a); +} + +// Check if point is inside rectangle +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec) +{ + bool collision = false; + + if ((point.x >= rec.x) && (point.x <= (rec.x + rec.width)) && + (point.y >= rec.y) && (point.y <= (rec.y + rec.height))) collision = true; + + return collision; +} + +// Formatting of text with variables to 'embed' +static const char *TextFormat(const char *text, ...) +{ + #if !defined(RAYGUI_TEXTFORMAT_MAX_SIZE) + #define RAYGUI_TEXTFORMAT_MAX_SIZE 256 + #endif + + static char buffer[RAYGUI_TEXTFORMAT_MAX_SIZE]; + + va_list args; + va_start(args, text); + vsprintf(buffer, text, args); + va_end(args); + + return buffer; +} + +// Draw rectangle with vertical gradient fill color +// NOTE: This function is only used by GuiColorPicker() +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2) +{ + Rectangle bounds = { (float)posX, (float)posY, (float)width, (float)height }; + DrawRectangleGradientEx(bounds, color1, color2, color2, color1); +} + +// 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 RAYGUI_TEXTSPLIT_MAX_ITEMS + // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE + + #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; + + if (text != NULL) + { + counter = 1; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if (buffer[i] == delimiter) + { + buffer[i] = '\0'; // Set an end of string at this point + result[counter] = buffer + i + 1; + counter++; + + if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + } + + *count = counter; + return result; +} + +// Get integer value from text +// NOTE: This function replaces atoi() [stdlib.h] +static int TextToInteger(const char *text) +{ + int value = 0; + int sign = 1; + + if ((text[0] == '+') || (text[0] == '-')) + { + if (text[0] == '-') sign = -1; + text++; + } + + for (int i = 0; ((text[i] >= '0') && (text[i] <= '9')); ++i) value = value*10 + (int)(text[i] - '0'); + + return value*sign; +} + +// Encode codepoint into UTF-8 text (char array size returned as parameter) +static const char *CodepointToUTF8(int codepoint, int *byteSize) +{ + static char utf8[6] = { 0 }; + int size = 0; + + if (codepoint <= 0x7f) + { + utf8[0] = (char)codepoint; + size = 1; + } + else if (codepoint <= 0x7ff) + { + utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0); + utf8[1] = (char)((codepoint & 0x3f) | 0x80); + size = 2; + } + else if (codepoint <= 0xffff) + { + utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0); + utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[2] = (char)((codepoint & 0x3f) | 0x80); + size = 3; + } + else if (codepoint <= 0x10ffff) + { + utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0); + utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80); + utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[3] = (char)((codepoint & 0x3f) | 0x80); + size = 4; + } + + *byteSize = size; + + return utf8; +} + +// Get next codepoint in a UTF-8 encoded text, scanning until '\0' is found +// When a invalid UTF-8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned +// Total number of bytes processed are returned as a parameter +// NOTE: the standard says U+FFFD should be returned in case of errors +// but that character is not supported by the default font in raylib +static int GetCodepointNext(const char *text, int *codepointSize) +{ + const char *ptr = text; + int codepoint = 0x3f; // Codepoint (defaults to '?') + *codepointSize = 1; + + // Get current codepoint and bytes processed + if (0xf0 == (0xf8 & ptr[0])) + { + // 4 byte UTF-8 codepoint + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]); + *codepointSize = 4; + } + else if (0xe0 == (0xf0 & ptr[0])) + { + // 3 byte UTF-8 codepoint */ + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]); + *codepointSize = 3; + } + else if (0xc0 == (0xe0 & ptr[0])) + { + // 2 byte UTF-8 codepoint + if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } //10xxxxxx checks + codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]); + *codepointSize = 2; + } + else if (0x00 == (0x80 & ptr[0])) + { + // 1 byte UTF-8 codepoint + codepoint = ptr[0]; + *codepointSize = 1; + } + + return codepoint; +} +#endif // RAYGUI_STANDALONE + +#endif // RAYGUI_IMPLEMENTATION diff --git a/raylib-src/raylib-5.0_linux_amd64/include/raylib.h b/raylib-src/raylib-5.0_linux_amd64/include/raylib.h new file mode 100644 index 0000000..1c4c4a0 --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/include/raylib.h @@ -0,0 +1,1662 @@ +/********************************************************************************************** +* +* raylib v5.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +* +* FEATURES: +* - NO external dependencies, all required libraries included with raylib +* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, +* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. +* - Written in plain C code (C99) in PascalCase/camelCase notation +* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) +* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] +* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +* - Flexible Materials system, supporting classic maps and PBR maps +* - Animated 3D models supported (skeletal bones animation) (IQM) +* - Shaders support, including Model shaders and Postprocessing shaders +* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] +* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +* - VR stereo rendering with configurable HMD device parameters +* - Bindings to multiple programming languages available! +* +* NOTES: +* - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] +* - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) +* - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) +* - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) +* +* DEPENDENCIES (included): +* [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) +* [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) +* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management +* +* OPTIONAL DEPENDENCIES (included): +* [rcore] msf_gif (Miles Fogle) for GIF recording +* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm +* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm +* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) +* [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms +* [rtext] stb_truetype (Sean Barret) for ttf fonts loading +* [rtext] stb_rect_pack (Sean Barret) for rectangles packing +* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation +* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) +* [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) +* [raudio] dr_wav (David Reid) for WAV audio file loading +* [raudio] dr_flac (David Reid) for FLAC audio file loading +* [raudio] dr_mp3 (David Reid) for MP3 audio file loading +* [raudio] stb_vorbis (Sean Barret) for OGG audio loading +* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +* +* +* LICENSE: zlib/libpng +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYLIB_H +#define RAYLIB_H + +#include // Required for: va_list - Only used by TraceLogCallback + +#define RAYLIB_VERSION_MAJOR 5 +#define RAYLIB_VERSION_MINOR 0 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_VERSION "5.0" + +// 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) + #if defined(__TINYC__) + #define __declspec(x) __attribute__((x)) + #endif + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Some basic Defines +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Allow custom memory allocators +// NOTE: Require recompiling raylib sources +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(ptr,sz) realloc(ptr,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(ptr) free(ptr) +#endif + +// NOTE: MSVC C++ compiler does not support compound literals (C99 feature) +// Plain structures in C++ (without constructors) can be initialized with { } +// This is called aggregate initialization (C++11 feature) +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// Some compilers (mostly macos clang) default to C++98, +// where aggregate initialization can't be used +// So, give a more clear error stating how to fix this +#if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L) + #error "C++11 or later is required. Add -std=c++11" +#endif + +// NOTE: We set some defines with some data types declared by raylib +// Other modules (raymath, rlgl) also require some of those types, so, +// to be able to use those other modules as standalone (not depending on raylib) +// this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) + typedef enum bool { false = 0, true = !false } bool; + #define RL_BOOL_TYPE +#endif + +// Vector2, 2 components +typedef struct Vector2 { + float x; // Vector x component + float y; // Vector y component +} Vector2; + +// Vector3, 3 components +typedef struct Vector3 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component +} Vector3; + +// Vector4, 4 components +typedef struct Vector4 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component + float w; // Vector w component +} Vector4; + +// Quaternion, 4 components (Vector4 alias) +typedef Vector4 Quaternion; + +// Matrix, 4x4 components, column major, OpenGL style, right-handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; + +// Color, 4 components, R8G8B8A8 (32bit) +typedef struct Color { + unsigned char r; // Color red value + unsigned char g; // Color green value + unsigned char b; // Color blue value + unsigned char a; // Color alpha value +} Color; + +// Rectangle, 4 components +typedef struct Rectangle { + float x; // Rectangle top-left corner position x + float y; // Rectangle top-left corner position y + float width; // Rectangle width + float height; // Rectangle height +} Rectangle; + +// Image, pixel data stored in CPU memory (RAM) +typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Image; + +// Texture, tex data stored in GPU memory (VRAM) +typedef struct Texture { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Texture; + +// Texture2D, same as Texture +typedef Texture Texture2D; + +// TextureCubemap, same as Texture +typedef Texture TextureCubemap; + +// RenderTexture, fbo for texture rendering +typedef struct RenderTexture { + unsigned int id; // OpenGL framebuffer object id + Texture texture; // Color buffer attachment texture + Texture depth; // Depth buffer attachment texture +} RenderTexture; + +// RenderTexture2D, same as RenderTexture +typedef RenderTexture RenderTexture2D; + +// NPatchInfo, n-patch layout info +typedef struct NPatchInfo { + Rectangle source; // Texture source rectangle + int left; // Left border offset + int top; // Top border offset + int right; // Right border offset + int bottom; // Bottom border offset + int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 +} NPatchInfo; + +// GlyphInfo, font characters glyphs info +typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data +} GlyphInfo; + +// Font, font texture and GlyphInfo array data +typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data +} Font; + +// Camera, defines position/orientation in 3d space +typedef struct Camera3D { + Vector3 position; // Camera position + Vector3 target; // Camera target it looks-at + Vector3 up; // Camera up vector (rotation over its axis) + float fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic + int projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC +} Camera3D; + +typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D + +// Camera2D, defines position/orientation in 2d space +typedef struct Camera2D { + Vector2 offset; // Camera offset (displacement from target) + Vector2 target; // Camera target (rotation and zoom origin) + float rotation; // Camera rotation in degrees + float zoom; // Camera zoom (scaling), should be 1.0f by default +} Camera2D; + +// Mesh, vertex data and vao/vbo +typedef struct Mesh { + int vertexCount; // Number of vertices stored in arrays + int triangleCount; // Number of triangles stored (indexed or not) + + // Vertex attributes data + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + float *texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) + float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) + + // Animation vertex data + float *animVertices; // Animated vertex positions (after bones transformations) + float *animNormals; // Animated normals (after bones transformations) + unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) + float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) + + // OpenGL identifiers + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) +} Mesh; + +// Shader +typedef struct Shader { + unsigned int id; // Shader program id + int *locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS) +} Shader; + +// MaterialMap +typedef struct MaterialMap { + Texture2D texture; // Material map texture + Color color; // Material map color + float value; // Material map value +} MaterialMap; + +// Material, includes shader and maps +typedef struct Material { + Shader shader; // Material shader + MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS) + float params[4]; // Material generic parameters (if required) +} Material; + +// Transform, vertex transformation data +typedef struct Transform { + Vector3 translation; // Translation + Quaternion rotation; // Rotation + Vector3 scale; // Scale +} Transform; + +// Bone, skeletal animation bone +typedef struct BoneInfo { + char name[32]; // Bone name + int parent; // Bone parent +} BoneInfo; + +// Model, meshes, materials and animation data +typedef struct Model { + Matrix transform; // Local transform matrix + + int meshCount; // Number of meshes + int materialCount; // Number of materials + Mesh *meshes; // Meshes array + Material *materials; // Materials array + int *meshMaterial; // Mesh material number + + // Animation data + int boneCount; // Number of bones + BoneInfo *bones; // Bones information (skeleton) + Transform *bindPose; // Bones base transformation (pose) +} Model; + +// ModelAnimation +typedef struct ModelAnimation { + int boneCount; // Number of bones + int frameCount; // Number of animation frames + BoneInfo *bones; // Bones information (skeleton) + Transform **framePoses; // Poses array by frame + char name[32]; // Animation name +} ModelAnimation; + +// Ray, ray for raycasting +typedef struct Ray { + Vector3 position; // Ray position (origin) + Vector3 direction; // Ray direction +} Ray; + +// RayCollision, ray hit information +typedef struct RayCollision { + bool hit; // Did the ray hit something? + float distance; // Distance to the nearest hit + Vector3 point; // Point of the nearest hit + Vector3 normal; // Surface normal of hit +} RayCollision; + +// BoundingBox +typedef struct BoundingBox { + Vector3 min; // Minimum vertex box-corner + Vector3 max; // Maximum vertex box-corner +} BoundingBox; + +// Wave, audio wave data +typedef struct Wave { + unsigned int frameCount; // Total number of frames (considering channels) + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) + void *data; // Buffer data pointer +} Wave; + +// Opaque structs declaration +// NOTE: Actual structs are defined internally in raudio module +typedef struct rAudioBuffer rAudioBuffer; +typedef struct rAudioProcessor rAudioProcessor; + +// AudioStream, custom audio stream +typedef struct AudioStream { + rAudioBuffer *buffer; // Pointer to internal data used by the audio system + rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects + + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) +} AudioStream; + +// Sound +typedef struct Sound { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) +} Sound; + +// Music, audio stream, anything longer than ~10 seconds should be streamed +typedef struct Music { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) + bool looping; // Music looping enable + + int ctxType; // Type of music context (audio filetype) + void *ctxData; // Audio context data, depends on type +} Music; + +// VrDeviceInfo, Head-Mounted-Display device parameters +typedef struct VrDeviceInfo { + int hResolution; // Horizontal resolution in pixels + int vResolution; // Vertical resolution in pixels + float hScreenSize; // Horizontal size in meters + float vScreenSize; // Vertical size in meters + float vScreenCenter; // Screen center in meters + float eyeToScreenDistance; // Distance between eye and display in meters + float lensSeparationDistance; // Lens separation distance in meters + float interpupillaryDistance; // IPD (distance between pupils) in meters + float lensDistortionValues[4]; // Lens distortion constant parameters + float chromaAbCorrection[4]; // Chromatic aberration correction parameters +} VrDeviceInfo; + +// VrStereoConfig, VR stereo rendering configuration for simulator +typedef struct VrStereoConfig { + Matrix projection[2]; // VR projection matrices (per eye) + Matrix viewOffset[2]; // VR view offset matrices (per eye) + float leftLensCenter[2]; // VR left lens center + float rightLensCenter[2]; // VR right lens center + float leftScreenCenter[2]; // VR left screen center + float rightScreenCenter[2]; // VR right screen center + float scale[2]; // VR distortion scale + float scaleIn[2]; // VR distortion scale in +} VrStereoConfig; + +// File path list +typedef struct FilePathList { + unsigned int capacity; // Filepaths max entries + unsigned int count; // Filepaths entries count + char **paths; // Filepaths entries +} FilePathList; + +// Automation event +typedef struct AutomationEvent { + unsigned int frame; // Event frame + unsigned int type; // Event type (AutomationEventType) + int params[4]; // Event parameters (if required) +} AutomationEvent; + +// Automation event list +typedef struct AutomationEventList { + unsigned int capacity; // Events max entries (MAX_AUTOMATION_EVENTS) + unsigned int count; // Events entries count + AutomationEvent *events; // Events entries +} AutomationEventList; + +//---------------------------------------------------------------------------------- +// Enumerators Definition +//---------------------------------------------------------------------------------- +// System/Window config flags +// NOTE: Every bit registers one state (use it with bit masks) +// By default all flags are set to 0 +typedef enum { + FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU + FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen + FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window + FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons) + FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window + FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify) + FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor) + FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused + FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top + FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized + FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer + FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI + FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED + FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode + FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X + FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D) +} ConfigFlags; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + LOG_ALL = 0, // Display all logs + LOG_TRACE, // Trace logging, intended for internal use only + LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + LOG_INFO, // Info logging, used for program execution info + LOG_WARNING, // Warning logging, used on recoverable failures + LOG_ERROR, // Error logging, used on unrecoverable failures + LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + LOG_NONE // Disable logging +} TraceLogLevel; + +// Keyboard keys (US keyboard layout) +// NOTE: Use GetKeyPressed() to allow redefining +// required keys for alternative layouts +typedef enum { + KEY_NULL = 0, // Key: NULL, used for no key pressed + // Alphanumeric keys + KEY_APOSTROPHE = 39, // Key: ' + KEY_COMMA = 44, // Key: , + KEY_MINUS = 45, // Key: - + KEY_PERIOD = 46, // Key: . + KEY_SLASH = 47, // Key: / + KEY_ZERO = 48, // Key: 0 + KEY_ONE = 49, // Key: 1 + KEY_TWO = 50, // Key: 2 + KEY_THREE = 51, // Key: 3 + KEY_FOUR = 52, // Key: 4 + KEY_FIVE = 53, // Key: 5 + KEY_SIX = 54, // Key: 6 + KEY_SEVEN = 55, // Key: 7 + KEY_EIGHT = 56, // Key: 8 + KEY_NINE = 57, // Key: 9 + KEY_SEMICOLON = 59, // Key: ; + KEY_EQUAL = 61, // Key: = + KEY_A = 65, // Key: A | a + KEY_B = 66, // Key: B | b + KEY_C = 67, // Key: C | c + KEY_D = 68, // Key: D | d + KEY_E = 69, // Key: E | e + KEY_F = 70, // Key: F | f + KEY_G = 71, // Key: G | g + KEY_H = 72, // Key: H | h + KEY_I = 73, // Key: I | i + KEY_J = 74, // Key: J | j + KEY_K = 75, // Key: K | k + KEY_L = 76, // Key: L | l + KEY_M = 77, // Key: M | m + KEY_N = 78, // Key: N | n + KEY_O = 79, // Key: O | o + KEY_P = 80, // Key: P | p + KEY_Q = 81, // Key: Q | q + KEY_R = 82, // Key: R | r + KEY_S = 83, // Key: S | s + KEY_T = 84, // Key: T | t + KEY_U = 85, // Key: U | u + KEY_V = 86, // Key: V | v + KEY_W = 87, // Key: W | w + KEY_X = 88, // Key: X | x + KEY_Y = 89, // Key: Y | y + KEY_Z = 90, // Key: Z | z + KEY_LEFT_BRACKET = 91, // Key: [ + KEY_BACKSLASH = 92, // Key: '\' + KEY_RIGHT_BRACKET = 93, // Key: ] + KEY_GRAVE = 96, // Key: ` + // Function keys + KEY_SPACE = 32, // Key: Space + KEY_ESCAPE = 256, // Key: Esc + KEY_ENTER = 257, // Key: Enter + KEY_TAB = 258, // Key: Tab + KEY_BACKSPACE = 259, // Key: Backspace + KEY_INSERT = 260, // Key: Ins + KEY_DELETE = 261, // Key: Del + KEY_RIGHT = 262, // Key: Cursor right + KEY_LEFT = 263, // Key: Cursor left + KEY_DOWN = 264, // Key: Cursor down + KEY_UP = 265, // Key: Cursor up + KEY_PAGE_UP = 266, // Key: Page up + KEY_PAGE_DOWN = 267, // Key: Page down + KEY_HOME = 268, // Key: Home + KEY_END = 269, // Key: End + KEY_CAPS_LOCK = 280, // Key: Caps lock + KEY_SCROLL_LOCK = 281, // Key: Scroll down + KEY_NUM_LOCK = 282, // Key: Num lock + KEY_PRINT_SCREEN = 283, // Key: Print screen + KEY_PAUSE = 284, // Key: Pause + KEY_F1 = 290, // Key: F1 + KEY_F2 = 291, // Key: F2 + KEY_F3 = 292, // Key: F3 + KEY_F4 = 293, // Key: F4 + KEY_F5 = 294, // Key: F5 + KEY_F6 = 295, // Key: F6 + KEY_F7 = 296, // Key: F7 + KEY_F8 = 297, // Key: F8 + KEY_F9 = 298, // Key: F9 + KEY_F10 = 299, // Key: F10 + KEY_F11 = 300, // Key: F11 + KEY_F12 = 301, // Key: F12 + KEY_LEFT_SHIFT = 340, // Key: Shift left + KEY_LEFT_CONTROL = 341, // Key: Control left + KEY_LEFT_ALT = 342, // Key: Alt left + KEY_LEFT_SUPER = 343, // Key: Super left + KEY_RIGHT_SHIFT = 344, // Key: Shift right + KEY_RIGHT_CONTROL = 345, // Key: Control right + KEY_RIGHT_ALT = 346, // Key: Alt right + KEY_RIGHT_SUPER = 347, // Key: Super right + KEY_KB_MENU = 348, // Key: KB menu + // Keypad keys + KEY_KP_0 = 320, // Key: Keypad 0 + KEY_KP_1 = 321, // Key: Keypad 1 + KEY_KP_2 = 322, // Key: Keypad 2 + KEY_KP_3 = 323, // Key: Keypad 3 + KEY_KP_4 = 324, // Key: Keypad 4 + KEY_KP_5 = 325, // Key: Keypad 5 + KEY_KP_6 = 326, // Key: Keypad 6 + KEY_KP_7 = 327, // Key: Keypad 7 + KEY_KP_8 = 328, // Key: Keypad 8 + KEY_KP_9 = 329, // Key: Keypad 9 + KEY_KP_DECIMAL = 330, // Key: Keypad . + KEY_KP_DIVIDE = 331, // Key: Keypad / + KEY_KP_MULTIPLY = 332, // Key: Keypad * + KEY_KP_SUBTRACT = 333, // Key: Keypad - + KEY_KP_ADD = 334, // Key: Keypad + + KEY_KP_ENTER = 335, // Key: Keypad Enter + KEY_KP_EQUAL = 336, // Key: Keypad = + // Android key buttons + KEY_BACK = 4, // Key: Android back button + KEY_MENU = 82, // Key: Android menu button + KEY_VOLUME_UP = 24, // Key: Android volume up button + KEY_VOLUME_DOWN = 25 // Key: Android volume down button +} KeyboardKey; + +// Add backwards compatibility support for deprecated names +#define MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT +#define MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT +#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE + +// Mouse buttons +typedef enum { + MOUSE_BUTTON_LEFT = 0, // Mouse button left + MOUSE_BUTTON_RIGHT = 1, // Mouse button right + MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel) + MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device) + MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device) + MOUSE_BUTTON_FORWARD = 5, // Mouse button forward (advanced mouse device) + MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device) +} MouseButton; + +// Mouse cursor +typedef enum { + MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape + MOUSE_CURSOR_ARROW = 1, // Arrow shape + MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape + MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape + MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor + MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape + MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_ALL = 9, // The omnidirectional resize/move cursor shape + MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape +} MouseCursor; + +// Gamepad buttons +typedef enum { + GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking + GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button + GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button + GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button + GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button + GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) + GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X) + GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) + GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) + GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button + GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button + GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select) + GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) + GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start) + GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left + GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right +} GamepadButton; + +// Gamepad axis +typedef enum { + GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis + GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis + GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis + GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis + GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1] + GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1] +} GamepadAxis; + +// Material map index +typedef enum { + MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE) + MATERIAL_MAP_METALNESS, // Metalness material (same as: MATERIAL_MAP_SPECULAR) + MATERIAL_MAP_NORMAL, // Normal material + MATERIAL_MAP_ROUGHNESS, // Roughness material + MATERIAL_MAP_OCCLUSION, // Ambient occlusion material + MATERIAL_MAP_EMISSION, // Emission material + MATERIAL_MAP_HEIGHT, // Heightmap material + MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_BRDF // Brdf material +} MaterialMapIndex; + +#define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO +#define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS + +// Shader location index +typedef enum { + SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) + SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) + SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} ShaderLocationIndex; + +#define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO +#define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + SHADER_UNIFORM_INT, // Shader uniform type: int + SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} ShaderUniformDataType; + +// Shader attribute data types +typedef enum { + SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} ShaderAttributeDataType; + +// Pixel formats +// NOTE: Support depends on OpenGL version and platform +typedef enum { + PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} PixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + TEXTURE_FILTER_BILINEAR, // Linear filtering + TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} TextureFilter; + +// Texture parameters: wrap mode +typedef enum { + TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode + TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode + TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode + TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode +} TextureWrap; + +// Cubemap layouts +typedef enum { + CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type + CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces + CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by a horizontal line with faces + CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces + CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces + CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirrectangular map) +} CubemapLayout; + +// Font type, defines generation method +typedef enum { + FONT_DEFAULT = 0, // Default font generation, anti-aliased + FONT_BITMAP, // Bitmap font generation, no anti-aliasing + FONT_SDF // SDF font generation, requires external shader +} FontType; + +// Color blending modes (pre-defined) +typedef enum { + BLEND_ALPHA = 0, // Blend textures considering alpha (default) + BLEND_ADDITIVE, // Blend textures adding colors + BLEND_MULTIPLIED, // Blend textures multiplying colors + BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + BLEND_CUSTOM_SEPARATE // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate()) +} BlendMode; + +// Gesture +// NOTE: Provided as bit-wise flags to enable only desired gestures +typedef enum { + GESTURE_NONE = 0, // No gesture + GESTURE_TAP = 1, // Tap gesture + GESTURE_DOUBLETAP = 2, // Double tap gesture + GESTURE_HOLD = 4, // Hold gesture + GESTURE_DRAG = 8, // Drag gesture + GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture + GESTURE_SWIPE_LEFT = 32, // Swipe left gesture + GESTURE_SWIPE_UP = 64, // Swipe up gesture + GESTURE_SWIPE_DOWN = 128, // Swipe down gesture + GESTURE_PINCH_IN = 256, // Pinch in gesture + GESTURE_PINCH_OUT = 512 // Pinch out gesture +} Gesture; + +// Camera system modes +typedef enum { + CAMERA_CUSTOM = 0, // Custom camera + CAMERA_FREE, // Free camera + CAMERA_ORBITAL, // Orbital camera + CAMERA_FIRST_PERSON, // First person camera + CAMERA_THIRD_PERSON // Third person camera +} CameraMode; + +// Camera projection +typedef enum { + CAMERA_PERSPECTIVE = 0, // Perspective projection + CAMERA_ORTHOGRAPHIC // Orthographic projection +} CameraProjection; + +// N-patch layout +typedef enum { + NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles + NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles + NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles +} NPatchLayout; + +// Callbacks to hook some internal functions +// WARNING: These callbacks are intended for advance users +typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages +typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data +typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize); // FileIO: Save binary data +typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool WindowShouldClose(void); // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked) +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void ToggleBorderlessWindowed(void); // Toggle window state: borderless windowed (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void SetWindowIcon(Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowIcons(Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowMaxSize(int width, int height); // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void SetWindowFocused(void); // Set window focused (only PLATFORM_DESKTOP) +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetCurrentMonitor(void); // Get current connected monitor +RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor) +RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor) +RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres +RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres +RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate +RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor +RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor +RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the specified monitor +RLAPI void SetClipboardText(const char *text); // Set clipboard text content +RLAPI const char *GetClipboardText(void); // Get clipboard text content +RLAPI void EnableEventWaiting(void); // Enable waiting for events on EndDrawing(), no automatic event polling +RLAPI void DisableEventWaiting(void); // Disable waiting for events on EndDrawing(), automatic events polling + +// Cursor-related functions +RLAPI void ShowCursor(void); // Shows cursor +RLAPI void HideCursor(void); // Hides cursor +RLAPI bool IsCursorHidden(void); // Check if cursor is not visible +RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) +RLAPI void DisableCursor(void); // Disables cursor (lock cursor) +RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the screen + +// Drawing-related functions +RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) +RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing +RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering) +RLAPI void BeginMode2D(Camera2D camera); // Begin 2D mode with custom camera (2D) +RLAPI void EndMode2D(void); // Ends 2D mode with custom camera +RLAPI void BeginMode3D(Camera3D camera); // Begin 3D mode with custom camera (3D) +RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode +RLAPI void BeginTextureMode(RenderTexture2D target); // Begin drawing to render texture +RLAPI void EndTextureMode(void); // Ends drawing to render texture +RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing +RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) +RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom) +RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) +RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) +RLAPI void EndScissorMode(void); // End scissor mode +RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator) +RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator) + +// VR stereo config functions for VR simulator +RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters +RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config + +// Shader management functions +// NOTE: Shader functionality is not available on OpenGL 1.1 +RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations +RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations +RLAPI bool IsShaderReady(Shader shader); // Check if a shader is ready +RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location +RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location +RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value +RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector +RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4) +RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d) +RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) + +// Screen-space-related functions +RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from mouse position +RLAPI Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix) +RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix +RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position +RLAPI Vector2 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 + +// Timing-related functions +RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) +RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() +RLAPI int GetFPS(void); // Get current FPS + +// Custom frame control functions +// NOTE: Those functions are intended for advance users that want full control over the frame processing +// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() +// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL +RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) +RLAPI void PollInputEvents(void); // Register all input events +RLAPI void WaitTime(double seconds); // Wait for some time (halt program execution) + +// Random values generation functions +RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated +RLAPI void UnloadRandomSequence(int *sequence); // Unload random values sequence + +// Misc. functions +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +// NOTE: Following functions implemented in module [utils] +//------------------------------------------------------------------ +RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator +RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator +RLAPI void MemFree(void *ptr); // Internal memory free + +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read) +RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success +RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success +RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() +RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success +//------------------------------------------------------------------ + +// File system functions +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string) +RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success +RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory +RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths +RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan +RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths +RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window +RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths +RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths +RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) + +// Compression/Encoding functionality +RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree() +RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree() +RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be MemFree() +RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be MemFree() + +// Automation events functionality +RLAPI AutomationEventList LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS +RLAPI void UnloadAutomationEventList(AutomationEventList *list); // Unload automation events list from file +RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName); // Export automation events list as text file +RLAPI void SetAutomationEventList(AutomationEventList *list); // Set automation event list to record to +RLAPI void SetAutomationEventBaseFrame(int frame); // Set automation event internal base frame to start recording +RLAPI void StartAutomationEventRecording(void); // Start recording automation events (AutomationEventList must be set) +RLAPI void StopAutomationEventRecording(void); // Stop recording automation events +RLAPI void PlayAutomationEvent(AutomationEvent event); // Play a recorded automation event + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool IsKeyPressedRepeat(int key); // Check if a key has been pressed again (Only PLATFORM_DESKTOP) +RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Get mouse position X +RLAPI int GetMouseY(void); // Get mouse position Y +RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger +RLAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y +RLAPI void SetMouseCursor(int cursor); // Set mouse cursor + +// Input-related functions: touch +RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) +RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) +RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) +RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index +RLAPI int GetTouchPointCount(void); // Get number of touch points + +//------------------------------------------------------------------------------------ +// Gestures and Touch Handling Functions (Module: rgestures) +//------------------------------------------------------------------------------------ +RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +RLAPI bool IsGestureDetected(unsigned int gesture); // Check if a gesture have been detected +RLAPI int GetGestureDetected(void); // Get latest detected gesture +RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds +RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector +RLAPI float GetGestureDragAngle(void); // Get gesture drag angle +RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta +RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle + +//------------------------------------------------------------------------------------ +// Camera System Functions (Module: rcamera) +//------------------------------------------------------------------------------------ +RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode +RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation + +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ +// Set texture and rectangle to be used on shapes drawing +// NOTE: It can be useful when using basic shapes and one single font, +// defining a font char white rectangle would allow drawing everything in a single draw call +RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing + +// Basic shapes drawing functions +RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel +RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) +RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (using gl lines) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line (using triangles/quads) +RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence (using gl lines) +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw line segment cubic-bezier in-out interpolation +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color); // Draw circle outline (Vector version) +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// Splines drawing functions +RLAPI void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Linear, minimum 2 points +RLAPI void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: B-Spline, minimum 4 points +RLAPI void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Catmull-Rom, minimum 4 points +RLAPI void DrawSplineBezierQuadratic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...] +RLAPI void DrawSplineBezierCubic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...] +RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color); // Draw spline segment: Linear, 2 points +RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points +RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points +RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point +RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points + +// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] +RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t); // Get (evaluate) spline point: Linear +RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: B-Spline +RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: Catmull-Rom +RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t); // Get (evaluate) spline point: Quadratic Bezier +RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t); // Get (evaluate) spline point: Cubic Bezier + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices +RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference +RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] +RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision + +//------------------------------------------------------------------------------------ +// Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ + +// Image loading functions +// NOTE: These functions do not require GPU access +RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +RLAPI Image LoadImageSvg(const char *fileNameOrString, int width, int height); // Load image from SVG file data or string with specified size +RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' +RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data +RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) +RLAPI bool IsImageReady(Image image); // Check if an image is ready +RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) +RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success +RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize); // Export image to memory buffer +RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end); // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer); // Generate image: square gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells +RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data + +// Image manipulation functions +RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece +RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) +RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format +RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) +RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value +RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color +RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image +RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel +RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation +RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color +RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image +RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +RLAPI void ImageFlipVertical(Image *image); // Flip image vertically +RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally +RLAPI void ImageRotate(Image *image, int degrees); // Rotate image by input angle in degrees (-359 to 359) +RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg +RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg +RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint +RLAPI void ImageColorInvert(Image *image); // Modify image color: invert +RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale +RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color +RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit) +RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit) +RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors() +RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette() +RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle +RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position + +// Image drawing functions +// NOTE: Image software-rendering functions (CPU) +RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color +RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image +RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) +RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image +RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) +RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image +RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) +RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image +RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) +RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) +RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image +RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) +RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) +RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) + +// Texture loading functions +// NOTE: These functions require GPU access +RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data +RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported +RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +RLAPI bool IsTextureReady(Texture2D texture); // Check if a texture is ready +RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) +RLAPI bool IsRenderTextureReady(RenderTexture2D target); // Check if a render texture is ready +RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data +RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data + +// Texture configuration functions +RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture +RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode +RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode + +// Texture drawing functions +RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely + +// Color/pixel related functions +RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color +RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1] +RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] +RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] +RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] +RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color +RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f +RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f +RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint +RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value +RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format +RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer +RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format + +//------------------------------------------------------------------------------------ +// Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ + +// Font loading/unloading functions +RLAPI Font GetFontDefault(void); // Get the default Font +RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool IsFontReady(Font font); // Check if a font is ready +RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) +RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// Text font info functions +RLAPI void SetTextLineSpacing(int spacing); // Set vertical line spacing when drawing with line-breaks +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// Text codepoints management functions (unicode characters) +RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array +RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array +RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter +RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory +RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string +RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) + +// Text strings management functions (no UTF-8 strings, only byte chars) +// NOTE: Some strings allocate memory internally for returned strings, just be careful! +RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending +RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) +RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string +RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) +RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) +RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string +RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string +RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string +RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) + +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Basic geometric 3D shapes drawing functions +RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line +RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space +RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube +RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires +RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) +RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos +RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos +RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos +RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos +RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ +RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line +RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) + +//------------------------------------------------------------------------------------ +// Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Model management functions +RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) +RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) +RLAPI bool IsModelReady(Model model); // Check if a model is ready +RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) +RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) + +// Model drawing functions +RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters +RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) +RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters +RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) +RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture +RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source +RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation + +// Mesh management functions +RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids +RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index +RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU +RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform +RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms +RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success +RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits +RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents + +// Mesh generation functions +RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh +RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh +RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh +RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data +RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data + +// Material loading/unloading functions +RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +RLAPI bool IsMaterialReady(Material material); // Check if a material is ready +RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) +RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh + +// Model animations loading/unloading functions +RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount); // Unload animation array data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) +RLAPI float GetMasterVolume(void); // Get master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI bool IsWaveReady(Wave wave); // Checks if wave data is ready +RLAPI Sound LoadSound(const char *fileName); // Load sound from file +RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data +RLAPI Sound LoadSoundAlias(Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data +RLAPI bool IsSoundReady(Sound sound); // Checks if a sound is ready +RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data +RLAPI void UnloadWave(Wave wave); // Unload wave data +RLAPI void UnloadSound(Sound sound); // Unload sound +RLAPI void UnloadSoundAlias(Sound alias); // Unload a sound alias (does not deallocate sample data) +RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success +RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success + +// Wave/Sound management functions +RLAPI void PlaySound(Sound sound); // Play a sound +RLAPI void StopSound(Sound sound); // Stop playing a sound +RLAPI void PauseSound(Sound sound); // Pause a sound +RLAPI void ResumeSound(Sound sound); // Resume a paused sound +RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing +RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center) +RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave +RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range +RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array +RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples() + +// Music management functions +RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file +RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data +RLAPI bool IsMusicReady(Music music); // Checks if a music stream is ready +RLAPI void UnloadMusicStream(Music music); // Unload music stream +RLAPI void PlayMusicStream(Music music); // Start music playing +RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing +RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming +RLAPI void StopMusicStream(Music music); // Stop music playing +RLAPI void PauseMusicStream(Music music); // Pause music playing +RLAPI void ResumeMusicStream(Music music); // Resume playing paused music +RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds) +RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) +RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) +RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center) +RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) +RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) + +// AudioStream management functions +RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) +RLAPI bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready +RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory +RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data +RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream +RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream +RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream +RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing +RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream +RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) +RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams +RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data + +RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as s +RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream + +RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as s +RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/raylib-src/raylib-5.0_linux_amd64/include/raymath.h b/raylib-src/raylib-5.0_linux_amd64/include/raymath.h new file mode 100644 index 0000000..ff60170 --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/include/raymath.h @@ -0,0 +1,2190 @@ +/********************************************************************************************** +* +* raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions +* +* CONVENTIONS: +* - Matrix structure is defined as row-major (memory layout) but parameters naming AND all +* math operations performed by the library consider the structure as it was column-major +* It is like transposed versions of the matrices are used for all the maths +* It benefits some functions making them cache-friendly and also avoids matrix +* transpositions sometimes required by OpenGL +* Example: In memory order, row0 is [m0 m4 m8 m12] but in semantic math row0 is [m0 m1 m2 m3] +* - Functions are always self-contained, no function use another raymath function inside, +* required code is directly re-implemented inside +* - Functions input parameters are always received by value (2 unavoidable exceptions) +* - Functions use always a "result" variable for return +* - Functions are always defined inline +* - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience) +* - No compound literals used to make sure libray is compatible with C++ +* +* CONFIGURATION: +* #define RAYMATH_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 RAYMATH_STATIC_INLINE +* Define static inline functions code, so #include header suffices for use. +* This may use up lots of memory. +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYMATH_H +#define RAYMATH_H + +#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE) + #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" +#endif + +// Function specifiers definition +#if defined(RAYMATH_IMPLEMENTATION) + #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) + #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). + #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) + #define RMAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RMAPI extern inline // Provide external definition + #endif +#elif defined(RAYMATH_STATIC_INLINE) + #define RMAPI static inline // Functions may be inlined, no external out-of-line definition +#else + #if defined(__TINYC__) + #define RMAPI static inline // plain inline not supported by tinycc (See issue #435) + #else + #define RMAPI inline // Functions may be inlined or external definition used + #endif +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif + +#ifndef EPSILON + #define EPSILON 0.000001f +#endif + +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif + +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Get float vector for Matrix +#ifndef MatrixToFloat + #define MatrixToFloat(mat) (MatrixToFloatV(mat).v) +#endif + +// Get float vector for Vector3 +#ifndef Vector3ToFloat + #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if !defined(RL_VECTOR2_TYPE) +// Vector2 type +typedef struct Vector2 { + float x; + float y; +} Vector2; +#define RL_VECTOR2_TYPE +#endif + +#if !defined(RL_VECTOR3_TYPE) +// Vector3 type +typedef struct Vector3 { + float x; + float y; + float z; +} Vector3; +#define RL_VECTOR3_TYPE +#endif + +#if !defined(RL_VECTOR4_TYPE) +// Vector4 type +typedef struct Vector4 { + float x; + float y; + float z; + float w; +} Vector4; +#define RL_VECTOR4_TYPE +#endif + +#if !defined(RL_QUATERNION_TYPE) +// Quaternion type +typedef Vector4 Quaternion; +#define RL_QUATERNION_TYPE +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix type (OpenGL style 4x4 - right handed, column major) +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// NOTE: Helper types to be used instead of array return types for *ToFloat functions +typedef struct float3 { + float v[3]; +} float3; + +typedef struct float16 { + float v[16]; +} float16; + +#include // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Utils math +//---------------------------------------------------------------------------------- + +// Clamp float value +RMAPI float Clamp(float value, float min, float max) +{ + float result = (value < min)? min : value; + + if (result > max) result = max; + + return result; +} + +// Calculate linear interpolation between two floats +RMAPI float Lerp(float start, float end, float amount) +{ + float result = start + amount*(end - start); + + return result; +} + +// Normalize input value within input range +RMAPI float Normalize(float value, float start, float end) +{ + float result = (value - start)/(end - start); + + return result; +} + +// Remap input value within input range to output range +RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) +{ + float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart; + + return result; +} + +// Wrap input value from min to max +RMAPI float Wrap(float value, float min, float max) +{ + float result = value - (max - min)*floorf((value - min)/(max - min)); + + return result; +} + +// Check whether two given floats are almost equal +RMAPI int FloatEquals(float x, float y) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y)))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector2 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector2 Vector2Zero(void) +{ + Vector2 result = { 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector2 Vector2One(void) +{ + Vector2 result = { 1.0f, 1.0f }; + + return result; +} + +// Add two vectors (v1 + v2) +RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x + v2.x, v1.y + v2.y }; + + return result; +} + +// Add vector and float value +RMAPI Vector2 Vector2AddValue(Vector2 v, float add) +{ + Vector2 result = { v.x + add, v.y + add }; + + return result; +} + +// Subtract two vectors (v1 - v2) +RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x - v2.x, v1.y - v2.y }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub) +{ + Vector2 result = { v.x - sub, v.y - sub }; + + return result; +} + +// Calculate vector length +RMAPI float Vector2Length(Vector2 v) +{ + float result = sqrtf((v.x*v.x) + (v.y*v.y)); + + return result; +} + +// Calculate vector square length +RMAPI float Vector2LengthSqr(Vector2 v) +{ + float result = (v.x*v.x) + (v.y*v.y); + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector2Distance(Vector2 v1, Vector2 v2) +{ + float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2) +{ + float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate angle between two vectors +// NOTE: Angle is calculated from origin point (0, 0) +RMAPI float Vector2Angle(Vector2 v1, Vector2 v2) +{ + float result = 0.0f; + + float dot = v1.x*v2.x + v1.y*v2.y; + float det = v1.x*v2.y - v1.y*v2.x; + + result = atan2f(det, dot); + + return result; +} + +// Calculate angle defined by a two vectors line +// NOTE: Parameters need to be normalized +// Current implementation should be aligned with glm::angle +RMAPI float Vector2LineAngle(Vector2 start, Vector2 end) +{ + float result = 0.0f; + + // TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior + result = -atan2f(end.y - start.y, end.x - start.x); + + return result; +} + +// Scale vector (multiply by value) +RMAPI Vector2 Vector2Scale(Vector2 v, float scale) +{ + Vector2 result = { v.x*scale, v.y*scale }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x*v2.x, v1.y*v2.y }; + + return result; +} + +// Negate vector +RMAPI Vector2 Vector2Negate(Vector2 v) +{ + Vector2 result = { -v.x, -v.y }; + + return result; +} + +// Divide vector by vector +RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x/v2.x, v1.y/v2.y }; + + return result; +} + +// Normalize provided vector +RMAPI Vector2 Vector2Normalize(Vector2 v) +{ + Vector2 result = { 0 }; + float length = sqrtf((v.x*v.x) + (v.y*v.y)); + + if (length > 0) + { + float ilength = 1.0f/length; + result.x = v.x*ilength; + result.y = v.y*ilength; + } + + return result; +} + +// Transforms a Vector2 by a given Matrix +RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat) +{ + Vector2 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = 0; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount) +{ + Vector2 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal) +{ + Vector2 result = { 0 }; + + float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + + return result; +} + +// Rotate vector by angle +RMAPI Vector2 Vector2Rotate(Vector2 v, float angle) +{ + Vector2 result = { 0 }; + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.x = v.x*cosres - v.y*sinres; + result.y = v.x*sinres + v.y*cosres; + + return result; +} + +// Move Vector towards target +RMAPI Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) +{ + Vector2 result = { 0 }; + + float dx = target.x - v.x; + float dy = target.y - v.y; + float value = (dx*dx) + (dy*dy); + + if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target; + + float dist = sqrtf(value); + + result.x = v.x + dx/dist*maxDistance; + result.y = v.y + dy/dist*maxDistance; + + return result; +} + +// Invert the given vector +RMAPI Vector2 Vector2Invert(Vector2 v) +{ + Vector2 result = { 1.0f/v.x, 1.0f/v.y }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max) +{ + Vector2 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + + return result; +} + +// Clamp the magnitude of the vector between two min and max values +RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max) +{ + Vector2 result = v; + + float length = (v.x*v.x) + (v.y*v.y); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector2Equals(Vector2 p, Vector2 q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector3 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector3 Vector3Zero(void) +{ + Vector3 result = { 0.0f, 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector3 Vector3One(void) +{ + Vector3 result = { 1.0f, 1.0f, 1.0f }; + + return result; +} + +// Add two vectors +RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; + + return result; +} + +// Add vector and float value +RMAPI Vector3 Vector3AddValue(Vector3 v, float add) +{ + Vector3 result = { v.x + add, v.y + add, v.z + add }; + + return result; +} + +// Subtract two vectors +RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub) +{ + Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; + + return result; +} + +// Multiply vector by scalar +RMAPI Vector3 Vector3Scale(Vector3 v, float scalar) +{ + Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; + + return result; +} + +// Calculate two vectors cross product +RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + + return result; +} + +// Calculate one vector perpendicular vector +RMAPI Vector3 Vector3Perpendicular(Vector3 v) +{ + Vector3 result = { 0 }; + + float min = (float) fabs(v.x); + Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; + + if (fabsf(v.y) < min) + { + min = (float) fabs(v.y); + Vector3 tmp = {0.0f, 1.0f, 0.0f}; + cardinalAxis = tmp; + } + + if (fabsf(v.z) < min) + { + Vector3 tmp = {0.0f, 0.0f, 1.0f}; + cardinalAxis = tmp; + } + + // Cross product between vectors + result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y; + result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z; + result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x; + + return result; +} + +// Calculate vector length +RMAPI float Vector3Length(const Vector3 v) +{ + float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + + return result; +} + +// Calculate vector square length +RMAPI float Vector3LengthSqr(const Vector3 v) +{ + float result = v.x*v.x + v.y*v.y + v.z*v.z; + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector3Distance(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = sqrtf(dx*dx + dy*dy + dz*dz); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = dx*dx + dy*dy + dz*dz; + + return result; +} + +// Calculate angle between two vectors +RMAPI float Vector3Angle(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z); + float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + result = atan2f(len, dot); + + return result; +} + +// Negate provided vector (invert direction) +RMAPI Vector3 Vector3Negate(Vector3 v) +{ + Vector3 result = { -v.x, -v.y, -v.z }; + + return result; +} + +// Divide vector by vector +RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; + + return result; +} + +// Normalize provided vector +RMAPI Vector3 Vector3Normalize(Vector3 v) +{ + Vector3 result = v; + + float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length != 0.0f) + { + float ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + } + + return result; +} + +//Calculate the projection of the vector v1 on to v2 +RMAPI Vector3 Vector3Project(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); + + float mag = v1dv2/v2dv2; + + result.x = v2.x*mag; + result.y = v2.y*mag; + result.z = v2.z*mag; + + return result; +} + +//Calculate the rejection of the vector v1 on to v2 +RMAPI Vector3 Vector3Reject(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); + + float mag = v1dv2/v2dv2; + + result.x = v1.x - (v2.x*mag); + result.y = v1.y - (v2.y*mag); + result.z = v1.z - (v2.z*mag); + + return result; +} + +// Orthonormalize provided vectors +// Makes vectors normalized and orthogonal to each other +// Gram-Schmidt function implementation +RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) +{ + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(*v1); + Vector3 v = *v1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + v1->x *= ilength; + v1->y *= ilength; + v1->z *= ilength; + + // Vector3CrossProduct(*v1, *v2) + Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x }; + + // Vector3Normalize(vn1); + v = vn1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vn1.x *= ilength; + vn1.y *= ilength; + vn1.z *= ilength; + + // Vector3CrossProduct(vn1, *v1) + Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x }; + + *v2 = vn2; +} + +// Transforms a Vector3 by a given Matrix +RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat) +{ + Vector3 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = v.z; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; + + return result; +} + +// Transform a vector by quaternion rotation +RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q) +{ + Vector3 result = { 0 }; + + result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); + result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); + result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); + + return result; +} + +// Rotates a vector around an axis +RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle) +{ + // Using Euler-Rodrigues Formula + // Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula + + Vector3 result = v; + + // Vector3Normalize(axis); + float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f / length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + angle /= 2.0f; + float a = sinf(angle); + float b = axis.x*a; + float c = axis.y*a; + float d = axis.z*a; + a = cosf(angle); + Vector3 w = { b, c, d }; + + // Vector3CrossProduct(w, v) + Vector3 wv = { w.y*v.z - w.z*v.y, w.z*v.x - w.x*v.z, w.x*v.y - w.y*v.x }; + + // Vector3CrossProduct(w, wv) + Vector3 wwv = { w.y*wv.z - w.z*wv.y, w.z*wv.x - w.x*wv.z, w.x*wv.y - w.y*wv.x }; + + // Vector3Scale(wv, 2*a) + a *= 2; + wv.x *= a; + wv.y *= a; + wv.z *= a; + + // Vector3Scale(wwv, 2) + wwv.x *= 2; + wwv.y *= 2; + wwv.z *= 2; + + result.x += wv.x; + result.y += wv.y; + result.z += wv.z; + + result.x += wwv.x; + result.y += wwv.y; + result.z += wwv.z; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount) +{ + Vector3 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + result.z = v1.z + amount*(v2.z - v1.z); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal) +{ + Vector3 result = { 0 }; + + // I is the original vector + // N is the normal of the incident plane + // R = I - (2*N*(DotProduct[I, N])) + + float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z); + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + result.z = v.z - (2.0f*normal.z)*dotProduct; + + return result; +} + +// Get min value for each pair of components +RMAPI Vector3 Vector3Min(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + + return result; +} + +// Get max value for each pair of components +RMAPI Vector3 Vector3Max(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + + return result; +} + +// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) +// NOTE: Assumes P is on the plane of the triangle +RMAPI Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) +{ + Vector3 result = { 0 }; + + Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // Vector3Subtract(b, a) + Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // Vector3Subtract(c, a) + Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // Vector3Subtract(p, a) + float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z); // Vector3DotProduct(v0, v0) + float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z); // Vector3DotProduct(v0, v1) + float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z); // Vector3DotProduct(v1, v1) + float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z); // Vector3DotProduct(v2, v0) + float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z); // Vector3DotProduct(v2, v1) + + float denom = d00*d11 - d01*d01; + + result.y = (d11*d20 - d01*d21)/denom; + result.z = (d00*d21 - d01*d20)/denom; + result.x = 1.0f - (result.z + result.y); + + return result; +} + +// Projects a Vector3 from screen space into object space +// NOTE: We are avoiding calling other raymath functions despite available +RMAPI Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view) +{ + Vector3 result = { 0 }; + + // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it + Matrix matViewProj = { // MatrixMultiply(view, projection); + view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12, + view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13, + view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14, + view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15, + view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12, + view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13, + view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14, + view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15, + view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12, + view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13, + view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14, + view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15, + view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12, + view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13, + view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14, + view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 }; + + // Calculate inverted matrix -> MatrixInvert(matViewProj); + // Cache the matrix values (speed optimization) + float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; + float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; + float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; + float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + Matrix matViewProjInv = { + (a11*b11 - a12*b10 + a13*b09)*invDet, + (-a01*b11 + a02*b10 - a03*b09)*invDet, + (a31*b05 - a32*b04 + a33*b03)*invDet, + (-a21*b05 + a22*b04 - a23*b03)*invDet, + (-a10*b11 + a12*b08 - a13*b07)*invDet, + (a00*b11 - a02*b08 + a03*b07)*invDet, + (-a30*b05 + a32*b02 - a33*b01)*invDet, + (a20*b05 - a22*b02 + a23*b01)*invDet, + (a10*b10 - a11*b08 + a13*b06)*invDet, + (-a00*b10 + a01*b08 - a03*b06)*invDet, + (a30*b04 - a31*b02 + a33*b00)*invDet, + (-a20*b04 + a21*b02 - a23*b00)*invDet, + (-a10*b09 + a11*b07 - a12*b06)*invDet, + (a00*b09 - a01*b07 + a02*b06)*invDet, + (-a30*b03 + a31*b01 - a32*b00)*invDet, + (a20*b03 - a21*b01 + a22*b00)*invDet }; + + // Create quaternion from source point + Quaternion quat = { source.x, source.y, source.z, 1.0f }; + + // Multiply quat point by unprojecte matrix + Quaternion qtransformed = { // QuaternionTransform(quat, matViewProjInv) + matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w, + matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w, + matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w, + matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w }; + + // Normalized world points in vectors + result.x = qtransformed.x/qtransformed.w; + result.y = qtransformed.y/qtransformed.w; + result.z = qtransformed.z/qtransformed.w; + + return result; +} + +// Get Vector3 as float array +RMAPI float3 Vector3ToFloatV(Vector3 v) +{ + float3 buffer = { 0 }; + + buffer.v[0] = v.x; + buffer.v[1] = v.y; + buffer.v[2] = v.z; + + return buffer; +} + +// Invert the given vector +RMAPI Vector3 Vector3Invert(Vector3 v) +{ + Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max) +{ + Vector3 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + result.z = fminf(max.z, fmaxf(min.z, v.z)); + + return result; +} + +// Clamp the magnitude of the vector between two values +RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max) +{ + Vector3 result = v; + + float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector3Equals(Vector3 p, Vector3 q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))); + + return result; +} + +// Compute the direction of a refracted ray +// v: normalized direction of the incoming ray +// n: normalized normal vector of the interface of two optical media +// r: ratio of the refractive index of the medium from where the ray comes +// to the refractive index of the medium on the other side of the surface +RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r) +{ + Vector3 result = { 0 }; + + float dot = v.x*n.x + v.y*n.y + v.z*n.z; + float d = 1.0f - r*r*(1.0f - dot*dot); + + if (d >= 0.0f) + { + d = sqrtf(d); + v.x = r*v.x - (r*dot + d)*n.x; + v.y = r*v.y - (r*dot + d)*n.y; + v.z = r*v.z - (r*dot + d)*n.z; + + result = v; + } + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix math +//---------------------------------------------------------------------------------- + +// Compute matrix determinant +RMAPI float MatrixDeterminant(Matrix mat) +{ + float result = 0.0f; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; + + return result; +} + +// Get the trace of the matrix (sum of the values along the diagonal) +RMAPI float MatrixTrace(Matrix mat) +{ + float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); + + return result; +} + +// Transposes provided matrix +RMAPI Matrix MatrixTranspose(Matrix mat) +{ + Matrix result = { 0 }; + + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; + + return result; +} + +// Invert provided matrix +RMAPI Matrix MatrixInvert(Matrix mat) +{ + Matrix result = { 0 }; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; + result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; + result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; + result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; + result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; + result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; + result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; + result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; + result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; + result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; + result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; + result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; + result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; + result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; + result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; + result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; + + return result; +} + +// Get identity matrix +RMAPI Matrix MatrixIdentity(void) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Add two matrices +RMAPI Matrix MatrixAdd(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; + + return result; +} + +// Subtract two matrices (left - right) +RMAPI Matrix MatrixSubtract(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +RMAPI Matrix MatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +// Get translation matrix +RMAPI Matrix MatrixTranslate(float x, float y, float z) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Create rotation matrix from axis and angle +// NOTE: Angle should be provided in radians +RMAPI Matrix MatrixRotate(Vector3 axis, float angle) +{ + Matrix result = { 0 }; + + float x = axis.x, y = axis.y, z = axis.z; + + float lengthSquared = x*x + y*y + z*z; + + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float ilength = 1.0f/sqrtf(lengthSquared); + x *= ilength; + y *= ilength; + z *= ilength; + } + + float sinres = sinf(angle); + float cosres = cosf(angle); + float t = 1.0f - cosres; + + result.m0 = x*x*t + cosres; + result.m1 = y*x*t + z*sinres; + result.m2 = z*x*t - y*sinres; + result.m3 = 0.0f; + + result.m4 = x*y*t - z*sinres; + result.m5 = y*y*t + cosres; + result.m6 = z*y*t + x*sinres; + result.m7 = 0.0f; + + result.m8 = x*z*t + y*sinres; + result.m9 = y*z*t - x*sinres; + result.m10 = z*z*t + cosres; + result.m11 = 0.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = 0.0f; + result.m15 = 1.0f; + + return result; +} + +// Get x-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateX(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m5 = cosres; + result.m6 = sinres; + result.m9 = -sinres; + result.m10 = cosres; + + return result; +} + +// Get y-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateY(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m2 = -sinres; + result.m8 = sinres; + result.m10 = cosres; + + return result; +} + +// Get z-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZ(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m1 = sinres; + result.m4 = -sinres; + result.m5 = cosres; + + return result; +} + + +// Get xyz-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateXYZ(Vector3 angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosz = cosf(-angle.z); + float sinz = sinf(-angle.z); + float cosy = cosf(-angle.y); + float siny = sinf(-angle.y); + float cosx = cosf(-angle.x); + float sinx = sinf(-angle.x); + + result.m0 = cosz*cosy; + result.m1 = (cosz*siny*sinx) - (sinz*cosx); + result.m2 = (cosz*siny*cosx) + (sinz*sinx); + + result.m4 = sinz*cosy; + result.m5 = (sinz*siny*sinx) + (cosz*cosx); + result.m6 = (sinz*siny*cosx) - (cosz*sinx); + + result.m8 = -siny; + result.m9 = cosy*sinx; + result.m10= cosy*cosx; + + return result; +} + +// Get zyx-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZYX(Vector3 angle) +{ + Matrix result = { 0 }; + + float cz = cosf(angle.z); + float sz = sinf(angle.z); + float cy = cosf(angle.y); + float sy = sinf(angle.y); + float cx = cosf(angle.x); + float sx = sinf(angle.x); + + result.m0 = cz*cy; + result.m4 = cz*sy*sx - cx*sz; + result.m8 = sz*sx + cz*cx*sy; + result.m12 = 0; + + result.m1 = cy*sz; + result.m5 = cz*cx + sz*sy*sx; + result.m9 = cx*sz*sy - cz*sx; + result.m13 = 0; + + result.m2 = -sy; + result.m6 = cy*sx; + result.m10 = cy*cx; + result.m14 = 0; + + result.m3 = 0; + result.m7 = 0; + result.m11 = 0; + result.m15 = 1; + + return result; +} + +// Get scaling matrix +RMAPI Matrix MatrixScale(float x, float y, float z) +{ + Matrix result = { x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Get perspective projection matrix +RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + + result.m4 = 0.0f; + result.m5 = ((float)near*2.0f)/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + result.m15 = 0.0f; + + return result; +} + +// Get perspective projection matrix +// NOTE: Fovy angle must be provided in radians +RMAPI Matrix MatrixPerspective(double fovY, double aspect, double nearPlane, double farPlane) +{ + Matrix result = { 0 }; + + double top = nearPlane*tan(fovY*0.5); + double bottom = -top; + double right = top*aspect; + double left = -right; + + // MatrixFrustum(-right, right, -top, top, near, far); + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); + + result.m0 = ((float)nearPlane*2.0f)/rl; + result.m5 = ((float)nearPlane*2.0f)/tb; + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)farPlane + (float)nearPlane)/fn; + result.m11 = -1.0f; + result.m14 = -((float)farPlane*(float)nearPlane*2.0f)/fn; + + return result; +} + +// Get orthographic projection matrix +RMAPI Matrix MatrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); + + result.m0 = 2.0f/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + result.m4 = 0.0f; + result.m5 = 2.0f/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + result.m8 = 0.0f; + result.m9 = 0.0f; + result.m10 = -2.0f/fn; + result.m11 = 0.0f; + result.m12 = -((float)left + (float)right)/rl; + result.m13 = -((float)top + (float)bottom)/tb; + result.m14 = -((float)farPlane + (float)nearPlane)/fn; + result.m15 = 1.0f; + + return result; +} + +// Get camera look-at matrix (view matrix) +RMAPI Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up) +{ + Matrix result = { 0 }; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Subtract(eye, target) + Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; + + // Vector3Normalize(vz) + Vector3 v = vz; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vz.x *= ilength; + vz.y *= ilength; + vz.z *= ilength; + + // Vector3CrossProduct(up, vz) + Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x }; + + // Vector3Normalize(x) + v = vx; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vx.x *= ilength; + vx.y *= ilength; + vx.z *= ilength; + + // Vector3CrossProduct(vz, vx) + Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x }; + + result.m0 = vx.x; + result.m1 = vy.x; + result.m2 = vz.x; + result.m3 = 0.0f; + result.m4 = vx.y; + result.m5 = vy.y; + result.m6 = vz.y; + result.m7 = 0.0f; + result.m8 = vx.z; + result.m9 = vy.z; + result.m10 = vz.z; + result.m11 = 0.0f; + result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z); // Vector3DotProduct(vx, eye) + result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z); // Vector3DotProduct(vy, eye) + result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z); // Vector3DotProduct(vz, eye) + result.m15 = 1.0f; + + return result; +} + +// Get float array of matrix data +RMAPI float16 MatrixToFloatV(Matrix mat) +{ + float16 result = { 0 }; + + result.v[0] = mat.m0; + result.v[1] = mat.m1; + result.v[2] = mat.m2; + result.v[3] = mat.m3; + result.v[4] = mat.m4; + result.v[5] = mat.m5; + result.v[6] = mat.m6; + result.v[7] = mat.m7; + result.v[8] = mat.m8; + result.v[9] = mat.m9; + result.v[10] = mat.m10; + result.v[11] = mat.m11; + result.v[12] = mat.m12; + result.v[13] = mat.m13; + result.v[14] = mat.m14; + result.v[15] = mat.m15; + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Quaternion math +//---------------------------------------------------------------------------------- + +// Add two quaternions +RMAPI Quaternion QuaternionAdd(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; + + return result; +} + +// Add quaternion and float value +RMAPI Quaternion QuaternionAddValue(Quaternion q, float add) +{ + Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; + + return result; +} + +// Subtract two quaternions +RMAPI Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; + + return result; +} + +// Subtract quaternion and float value +RMAPI Quaternion QuaternionSubtractValue(Quaternion q, float sub) +{ + Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; + + return result; +} + +// Get identity quaternion +RMAPI Quaternion QuaternionIdentity(void) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Computes the length of a quaternion +RMAPI float QuaternionLength(Quaternion q) +{ + float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + + return result; +} + +// Normalize provided quaternion +RMAPI Quaternion QuaternionNormalize(Quaternion q) +{ + Quaternion result = { 0 }; + + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Invert provided quaternion +RMAPI Quaternion QuaternionInvert(Quaternion q) +{ + Quaternion result = q; + + float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w; + + if (lengthSq != 0.0f) + { + float invLength = 1.0f/lengthSq; + + result.x *= -invLength; + result.y *= -invLength; + result.z *= -invLength; + result.w *= invLength; + } + + return result; +} + +// Calculate two quaternion multiplication +RMAPI Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2) +{ + Quaternion result = { 0 }; + + float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; + float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; + + result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; + + return result; +} + +// Scale quaternion by float value +RMAPI Quaternion QuaternionScale(Quaternion q, float mul) +{ + Quaternion result = { 0 }; + + result.x = q.x*mul; + result.y = q.y*mul; + result.z = q.z*mul; + result.w = q.w*mul; + + return result; +} + +// Divide two quaternions +RMAPI Quaternion QuaternionDivide(Quaternion q1, Quaternion q2) +{ + Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w }; + + return result; +} + +// Calculate linear interpolation between two quaternions +RMAPI Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + return result; +} + +// Calculate slerp-optimized interpolation between two quaternions +RMAPI Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + // QuaternionLerp(q1, q2, amount) + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + // QuaternionNormalize(q); + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Calculates spherical linear interpolation between two quaternions +RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; + + if (cosHalfTheta < 0) + { + q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w; + cosHalfTheta = -cosHalfTheta; + } + + if (fabsf(cosHalfTheta) >= 1.0f) result = q1; + else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount); + else + { + float halfTheta = acosf(cosHalfTheta); + float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); + + if (fabsf(sinHalfTheta) < EPSILON) + { + result.x = (q1.x*0.5f + q2.x*0.5f); + result.y = (q1.y*0.5f + q2.y*0.5f); + result.z = (q1.z*0.5f + q2.z*0.5f); + result.w = (q1.w*0.5f + q2.w*0.5f); + } + else + { + float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; + float ratioB = sinf(amount*halfTheta)/sinHalfTheta; + + result.x = (q1.x*ratioA + q2.x*ratioB); + result.y = (q1.y*ratioA + q2.y*ratioB); + result.z = (q1.z*ratioA + q2.z*ratioB); + result.w = (q1.w*ratioA + q2.w*ratioB); + } + } + + return result; +} + +// Calculate quaternion based on the rotation from one vector to another +RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to) +{ + Quaternion result = { 0 }; + + float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z); // Vector3DotProduct(from, to) + Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // Vector3CrossProduct(from, to) + + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0f + cos2Theta; + + // QuaternionNormalize(q); + // NOTE: Normalize to essentially nlerp the original and identity to 0.5 + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Get a quaternion for a given rotation matrix +RMAPI Quaternion QuaternionFromMatrix(Matrix mat) +{ + Quaternion result = { 0 }; + + float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; + float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; + float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; + float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; + + int biggestIndex = 0; + float fourBiggestSquaredMinus1 = fourWSquaredMinus1; + if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourXSquaredMinus1; + biggestIndex = 1; + } + + if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourYSquaredMinus1; + biggestIndex = 2; + } + + if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourZSquaredMinus1; + biggestIndex = 3; + } + + float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f)*0.5f; + float mult = 0.25f / biggestVal; + + switch (biggestIndex) + { + case 0: + result.w = biggestVal; + result.x = (mat.m6 - mat.m9)*mult; + result.y = (mat.m8 - mat.m2)*mult; + result.z = (mat.m1 - mat.m4)*mult; + break; + case 1: + result.x = biggestVal; + result.w = (mat.m6 - mat.m9)*mult; + result.y = (mat.m1 + mat.m4)*mult; + result.z = (mat.m8 + mat.m2)*mult; + break; + case 2: + result.y = biggestVal; + result.w = (mat.m8 - mat.m2)*mult; + result.x = (mat.m1 + mat.m4)*mult; + result.z = (mat.m6 + mat.m9)*mult; + break; + case 3: + result.z = biggestVal; + result.w = (mat.m1 - mat.m4)*mult; + result.x = (mat.m8 + mat.m2)*mult; + result.y = (mat.m6 + mat.m9)*mult; + break; + } + + return result; +} + +// Get a matrix for a given quaternion +RMAPI Matrix QuaternionToMatrix(Quaternion q) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float a2 = q.x*q.x; + float b2 = q.y*q.y; + float c2 = q.z*q.z; + float ac = q.x*q.z; + float ab = q.x*q.y; + float bc = q.y*q.z; + float ad = q.w*q.x; + float bd = q.w*q.y; + float cd = q.w*q.z; + + result.m0 = 1 - 2*(b2 + c2); + result.m1 = 2*(ab + cd); + result.m2 = 2*(ac - bd); + + result.m4 = 2*(ab - cd); + result.m5 = 1 - 2*(a2 + c2); + result.m6 = 2*(bc + ad); + + result.m8 = 2*(ac + bd); + result.m9 = 2*(bc - ad); + result.m10 = 1 - 2*(a2 + b2); + + return result; +} + +// Get rotation quaternion for an angle and axis +// NOTE: Angle must be provided in radians +RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + + if (axisLength != 0.0f) + { + angle *= 0.5f; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(axis) + Vector3 v = axis; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + float sinres = sinf(angle); + float cosres = cosf(angle); + + result.x = axis.x*sinres; + result.y = axis.y*sinres; + result.z = axis.z*sinres; + result.w = cosres; + + // QuaternionNormalize(q); + Quaternion q = result; + length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + } + + return result; +} + +// Get the rotation angle and axis for a given quaternion +RMAPI void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) +{ + if (fabsf(q.w) > 1.0f) + { + // QuaternionNormalize(q); + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + q.x = q.x*ilength; + q.y = q.y*ilength; + q.z = q.z*ilength; + q.w = q.w*ilength; + } + + Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; + float resAngle = 2.0f*acosf(q.w); + float den = sqrtf(1.0f - q.w*q.w); + + if (den > EPSILON) + { + resAxis.x = q.x/den; + resAxis.y = q.y/den; + resAxis.z = q.z/den; + } + else + { + // This occurs when the angle is zero. + // Not a problem: just set an arbitrary normalized axis. + resAxis.x = 1.0f; + } + + *outAxis = resAxis; + *outAngle = resAngle; +} + +// Get the quaternion equivalent to Euler angles +// NOTE: Rotation order is ZYX +RMAPI Quaternion QuaternionFromEuler(float pitch, float yaw, float roll) +{ + Quaternion result = { 0 }; + + float x0 = cosf(pitch*0.5f); + float x1 = sinf(pitch*0.5f); + float y0 = cosf(yaw*0.5f); + float y1 = sinf(yaw*0.5f); + float z0 = cosf(roll*0.5f); + float z1 = sinf(roll*0.5f); + + result.x = x1*y0*z0 - x0*y1*z1; + result.y = x0*y1*z0 + x1*y0*z1; + result.z = x0*y0*z1 - x1*y1*z0; + result.w = x0*y0*z0 + x1*y1*z1; + + return result; +} + +// Get the Euler angles equivalent to quaternion (roll, pitch, yaw) +// NOTE: Angles are returned in a Vector3 struct in radians +RMAPI Vector3 QuaternionToEuler(Quaternion q) +{ + Vector3 result = { 0 }; + + // Roll (x-axis rotation) + float x0 = 2.0f*(q.w*q.x + q.y*q.z); + float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); + result.x = atan2f(x0, x1); + + // Pitch (y-axis rotation) + float y0 = 2.0f*(q.w*q.y - q.z*q.x); + y0 = y0 > 1.0f ? 1.0f : y0; + y0 = y0 < -1.0f ? -1.0f : y0; + result.y = asinf(y0); + + // Yaw (z-axis rotation) + float z0 = 2.0f*(q.w*q.z + q.x*q.y); + float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); + result.z = atan2f(z0, z1); + + return result; +} + +// Transform a quaternion given a transformation matrix +RMAPI Quaternion QuaternionTransform(Quaternion q, Matrix mat) +{ + Quaternion result = { 0 }; + + result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; + result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; + result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; + result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; + + return result; +} + +// Check whether two given quaternions are almost equal +RMAPI int QuaternionEquals(Quaternion p, Quaternion q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = (((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))) || + (((fabsf(p.x + q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y + q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z + q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w + q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))); + + return result; +} + +#endif // RAYMATH_H diff --git a/raylib-src/raylib-5.0_linux_amd64/include/rlgl.h b/raylib-src/raylib-5.0_linux_amd64/include/rlgl.h new file mode 100644 index 0000000..6cf9c7e --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/include/rlgl.h @@ -0,0 +1,4859 @@ +/********************************************************************************************** +* +* rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* DESCRIPTION: +* An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) +* that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...) +* +* ADDITIONAL NOTES: +* When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are +* initialized on rlglInit() to accumulate vertex data. +* +* When an internal state change is required all the stored vertex data is renderer in batch, +* additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch. +* +* Some resources are also loaded for convenience, here the complete list: +* - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data +* - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8 +* - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs) +* +* Internal buffer (and resources) must be manually unloaded calling rlglClose(). +* +* CONFIGURATION: +* #define GRAPHICS_API_OPENGL_11 +* #define GRAPHICS_API_OPENGL_21 +* #define GRAPHICS_API_OPENGL_33 +* #define GRAPHICS_API_OPENGL_43 +* #define GRAPHICS_API_OPENGL_ES2 +* #define GRAPHICS_API_OPENGL_ES3 +* Use selected OpenGL graphics backend, should be supported by platform +* Those preprocessor defines are only used on rlgl module, if OpenGL version is +* required by any other module, use rlGetVersion() to check it +* +* #define RLGL_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 RLGL_RENDER_TEXTURES_HINT +* Enable framebuffer objects (fbo) support (enabled by default) +* Some GPUs could not support them despite the OpenGL version +* +* #define RLGL_SHOW_GL_DETAILS_INFO +* Show OpenGL extensions and capabilities detailed logs on init +* +* #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT +* Enable debug context (only available on OpenGL 4.3) +* +* rlgl capabilities could be customized just defining some internal +* values before library inclusion (default values listed): +* +* #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits +* #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +* #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +* #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +* +* #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack +* #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +* #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance +* #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance +* +* When loading a shader, the following vertex attributes and uniform +* location names are tried to be set automatically: +* +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +* +* DEPENDENCIES: +* - OpenGL libraries (depending on platform and OpenGL version selected) +* - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RLGL_H +#define RLGL_H + +#define RLGL_VERSION "4.5" + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +// Support TRACELOG macros +#ifndef TRACELOG + #define TRACELOG(level, ...) (void)0 + #define TRACELOGD(...) (void)0 +#endif + +// Allow custom memory allocators +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(n,sz) realloc(n,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(p) free(p) +#endif + +// Security check in case no GRAPHICS_API_OPENGL_* defined +#if !defined(GRAPHICS_API_OPENGL_11) && \ + !defined(GRAPHICS_API_OPENGL_21) && \ + !defined(GRAPHICS_API_OPENGL_33) && \ + !defined(GRAPHICS_API_OPENGL_43) && \ + !defined(GRAPHICS_API_OPENGL_ES2) && \ + !defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_33 +#endif + +// Security check in case multiple GRAPHICS_API_OPENGL_* defined +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_21) + #undef GRAPHICS_API_OPENGL_21 + #endif + #if defined(GRAPHICS_API_OPENGL_33) + #undef GRAPHICS_API_OPENGL_33 + #endif + #if defined(GRAPHICS_API_OPENGL_43) + #undef GRAPHICS_API_OPENGL_43 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + #undef GRAPHICS_API_OPENGL_ES2 + #endif +#endif + +// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality +// WARNING: Specific parts are checked with #if defines +#if defined(GRAPHICS_API_OPENGL_21) + #define GRAPHICS_API_OPENGL_33 +#endif + +// OpenGL 4.3 uses OpenGL 3.3 Core functionality +#if defined(GRAPHICS_API_OPENGL_43) + #define GRAPHICS_API_OPENGL_33 +#endif + +// OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more) +#if defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_ES2 +#endif + +// Support framebuffer objects by default +// NOTE: Some driver implementation do not support it, despite they should +#define RLGL_RENDER_TEXTURES_HINT + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- + +// Default internal render batch elements limits +#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // This is the maximum amount of elements (quads) per batch + // NOTE: Be careful with text, every letter maps to a quad + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + // We reduce memory sizes for embedded systems (RPI and HTML5) + // NOTE: On HTML5 (emscripten) this is allocated on heap, + // by default it's only 16MB!...just take care... + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048 + #endif +#endif +#ifndef RL_DEFAULT_BATCH_BUFFERS + #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +#endif +#ifndef RL_DEFAULT_BATCH_DRAWCALLS + #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +#endif +#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS + #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +#endif + +// Internal Matrix stack +#ifndef RL_MAX_MATRIX_STACK_SIZE + #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack +#endif + +// Shader limits +#ifndef RL_MAX_SHADER_LOCATIONS + #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +#endif + +// Projection matrix culling +#ifndef RL_CULL_DISTANCE_NEAR + #define RL_CULL_DISTANCE_NEAR 0.01 // Default near cull distance +#endif +#ifndef RL_CULL_DISTANCE_FAR + #define RL_CULL_DISTANCE_FAR 1000.0 // Default far cull distance +#endif + +// Texture parameters (equivalent to OpenGL defines) +#define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S +#define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T +#define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER +#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER + +#define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST +#define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR +#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier) +#define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier) + +#define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT +#define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE +#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT +#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT + +// Matrix modes (equivalent to OpenGL) +#define RL_MODELVIEW 0x1700 // GL_MODELVIEW +#define RL_PROJECTION 0x1701 // GL_PROJECTION +#define RL_TEXTURE 0x1702 // GL_TEXTURE + +// Primitive assembly draw modes +#define RL_LINES 0x0001 // GL_LINES +#define RL_TRIANGLES 0x0004 // GL_TRIANGLES +#define RL_QUADS 0x0007 // GL_QUADS + +// GL equivalent data types +#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE +#define RL_FLOAT 0x1406 // GL_FLOAT + +// GL buffer usage hint +#define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW +#define RL_STREAM_READ 0x88E1 // GL_STREAM_READ +#define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY +#define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW +#define RL_STATIC_READ 0x88E5 // GL_STATIC_READ +#define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY +#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW +#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ +#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY + +// GL Shader type +#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER +#define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER +#define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER + +// GL blending factors +#define RL_ZERO 0 // GL_ZERO +#define RL_ONE 1 // GL_ONE +#define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR +#define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR +#define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA +#define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA +#define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA +#define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA +#define RL_DST_COLOR 0x0306 // GL_DST_COLOR +#define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR +#define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE +#define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR +#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR +#define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA +#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA + +// GL blending functions/equations +#define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD +#define RL_MIN 0x8007 // GL_MIN +#define RL_MAX 0x8008 // GL_MAX +#define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT +#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT +#define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION +#define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION) +#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA +#define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB +#define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB +#define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA +#define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA +#define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR + + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE) + // Boolean type +typedef enum bool { false = 0, true = !false } bool; +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix, 4x4 components, column major, OpenGL style, right handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// Dynamic vertex buffers (position + texcoords + colors + indices arrays) +typedef struct rlVertexBuffer { + int elementCount; // Number of elements in the buffer (QUADS) + + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data) +} rlVertexBuffer; + +// Draw call type +// NOTE: Only texture changes register a new draw, other state-change-related elements are not +// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any +// of those state-change happens (this is done in core module) +typedef struct rlDrawCall { + int mode; // Drawing mode: LINES, TRIANGLES, QUADS + int vertexCount; // Number of vertex of the draw + int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES) + //unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId + //unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId + unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes + + //Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default + //Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default +} rlDrawCall; + +// rlRenderBatch type +typedef struct rlRenderBatch { + int bufferCount; // Number of vertex buffers (multi-buffering support) + int currentBuffer; // Current buffer tracking in case of multi-buffering + rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data + + rlDrawCall *draws; // Draw calls array, depends on textureId + int drawCounter; // Draw calls counter + float currentDepth; // Current depth value for next draw +} rlRenderBatch; + +// OpenGL version +typedef enum { + RL_OPENGL_11 = 1, // OpenGL 1.1 + RL_OPENGL_21, // OpenGL 2.1 (GLSL 120) + RL_OPENGL_33, // OpenGL 3.3 (GLSL 330) + RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330) + RL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100) + RL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es) +} rlGlVersion; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + RL_LOG_ALL = 0, // Display all logs + RL_LOG_TRACE, // Trace logging, intended for internal use only + RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + RL_LOG_INFO, // Info logging, used for program execution info + RL_LOG_WARNING, // Warning logging, used on recoverable failures + RL_LOG_ERROR, // Error logging, used on unrecoverable failures + RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + RL_LOG_NONE // Disable logging +} rlTraceLogLevel; + +// Texture pixel formats +// NOTE: Support depends on OpenGL version +typedef enum { + RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} rlPixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + RL_TEXTURE_FILTER_BILINEAR, // Linear filtering + RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} rlTextureFilter; + +// Color blending modes (pre-defined) +typedef enum { + RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) + RL_BLEND_ADDITIVE, // Blend textures adding colors + 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_PREMULTIPLY, // Blend premultiplied textures considering alpha + RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate()) +} rlBlendMode; + +// Shader location point type +typedef enum { + RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) + RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) + RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} rlShaderLocationIndex; + +#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO +#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + RL_SHADER_UNIFORM_INT, // Shader uniform type: int + RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} rlShaderUniformDataType; + +// Shader attribute data types +typedef enum { + RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} rlShaderAttributeDataType; + +// Framebuffer attachment type +// NOTE: By default up to 8 color channels defined, but it can be more +typedef enum { + RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0 + RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7 + RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth + RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil +} rlFramebufferAttachType; + +// Framebuffer texture attachment type +typedef enum { + RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5, // Framebuffer texture attachment type: cubemap, -Z side + RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d + RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer +} rlFramebufferAttachTextureType; + +// Face culling mode +typedef enum { + RL_CULL_FACE_FRONT = 0, + RL_CULL_FACE_BACK +} rlCullMode; + +//------------------------------------------------------------------------------------ +// Functions Declaration - Matrix operations +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +RLAPI void rlMatrixMode(int mode); // Choose the current matrix to be transformed +RLAPI void rlPushMatrix(void); // Push the current matrix to stack +RLAPI void rlPopMatrix(void); // Pop latest inserted matrix from stack +RLAPI void rlLoadIdentity(void); // Reset current matrix to identity matrix +RLAPI void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix +RLAPI void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix +RLAPI void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix +RLAPI void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix +RLAPI void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlViewport(int x, int y, int width, int height); // Set the viewport area + +//------------------------------------------------------------------------------------ +// Functions Declaration - Vertex level operations +//------------------------------------------------------------------------------------ +RLAPI void rlBegin(int mode); // Initialize drawing mode (how to organize vertex) +RLAPI void rlEnd(void); // Finish vertex providing +RLAPI void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int +RLAPI void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float +RLAPI void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float +RLAPI void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float +RLAPI void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float +RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte +RLAPI void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float +RLAPI void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float + +//------------------------------------------------------------------------------------ +// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) +// NOTE: This functions are used to completely abstract raylib code from OpenGL layer, +// some of them are direct wrappers over OpenGL calls, some others are custom +//------------------------------------------------------------------------------------ + +// Vertex buffers state +RLAPI bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported) +RLAPI void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported) +RLAPI void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO) +RLAPI void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO) +RLAPI void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element) +RLAPI void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element) +RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index +RLAPI void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index +#if defined(GRAPHICS_API_OPENGL_11) +RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer +RLAPI void rlDisableStatePointer(int vertexAttribType); // Disable attribute state pointer +#endif + +// Textures state +RLAPI void rlActiveTextureSlot(int slot); // Select and active a texture slot +RLAPI void rlEnableTexture(unsigned int id); // Enable texture +RLAPI void rlDisableTexture(void); // Disable texture +RLAPI void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap +RLAPI void rlDisableTextureCubemap(void); // Disable texture cubemap +RLAPI void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap) +RLAPI void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap) + +// Shader state +RLAPI void rlEnableShader(unsigned int id); // Enable shader program +RLAPI void rlDisableShader(void); // Disable shader program + +// Framebuffer state +RLAPI void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo) +RLAPI void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer +RLAPI void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers +RLAPI void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask); // Blit active framebuffer to main framebuffer + +// General render state +RLAPI void rlEnableColorBlend(void); // Enable color blending +RLAPI void rlDisableColorBlend(void); // Disable color blending +RLAPI void rlEnableDepthTest(void); // Enable depth test +RLAPI void rlDisableDepthTest(void); // Disable depth test +RLAPI void rlEnableDepthMask(void); // Enable depth write +RLAPI void rlDisableDepthMask(void); // Disable depth write +RLAPI void rlEnableBackfaceCulling(void); // Enable backface culling +RLAPI void rlDisableBackfaceCulling(void); // Disable backface culling +RLAPI void rlSetCullFace(int mode); // Set face culling mode +RLAPI void rlEnableScissorTest(void); // Enable scissor test +RLAPI void rlDisableScissorTest(void); // Disable scissor test +RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test +RLAPI void rlEnableWireMode(void); // Enable wire mode +RLAPI void rlEnablePointMode(void); // Enable point mode +RLAPI void rlDisableWireMode(void); // Disable wire mode ( and point ) maybe rename +RLAPI void rlSetLineWidth(float width); // Set the line drawing width +RLAPI float rlGetLineWidth(void); // Get the line drawing width +RLAPI void rlEnableSmoothLines(void); // Enable line aliasing +RLAPI void rlDisableSmoothLines(void); // Disable line aliasing +RLAPI void rlEnableStereoRender(void); // Enable stereo rendering +RLAPI void rlDisableStereoRender(void); // Disable stereo rendering +RLAPI bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled + +RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color +RLAPI void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth) +RLAPI void rlCheckErrors(void); // Check and log OpenGL error codes +RLAPI void rlSetBlendMode(int mode); // Set blending mode +RLAPI void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors) +RLAPI void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors) + +//------------------------------------------------------------------------------------ +// Functions Declaration - rlgl functionality +//------------------------------------------------------------------------------------ +// rlgl initialization functions +RLAPI void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states) +RLAPI void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures) +RLAPI void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required) +RLAPI int rlGetVersion(void); // Get current OpenGL version +RLAPI void rlSetFramebufferWidth(int width); // Set current framebuffer width +RLAPI int rlGetFramebufferWidth(void); // Get default framebuffer width +RLAPI void rlSetFramebufferHeight(int height); // Set current framebuffer height +RLAPI int rlGetFramebufferHeight(void); // Get default framebuffer height + +RLAPI unsigned int rlGetTextureIdDefault(void); // Get default texture id +RLAPI unsigned int rlGetShaderIdDefault(void); // Get default shader id +RLAPI int *rlGetShaderLocsDefault(void); // Get default shader locations + +// Render batch management +// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode +// but this render batch API is exposed in case of custom batches are required +RLAPI rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system +RLAPI void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system +RLAPI void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset) +RLAPI void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal) +RLAPI void rlDrawRenderBatchActive(void); // Update and draw internal render batch +RLAPI bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex + +RLAPI void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits + +//------------------------------------------------------------------------------------------------------------------------ + +// Vertex buffers management +RLAPI unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported +RLAPI unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer attribute +RLAPI unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load a new attributes element buffer +RLAPI void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update GPU buffer with new data +RLAPI void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements with new data +RLAPI void rlUnloadVertexArray(unsigned int vaoId); +RLAPI void rlUnloadVertexBuffer(unsigned int vboId); +RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer); +RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor); +RLAPI void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value +RLAPI void rlDrawVertexArray(int offset, int count); +RLAPI void rlDrawVertexArrayElements(int offset, int count, const void *buffer); +RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances); +RLAPI void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); + +// Textures management +RLAPI unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU +RLAPI unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo) +RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size, int format); // Load texture cubemap +RLAPI void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data +RLAPI void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats +RLAPI const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format +RLAPI void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory +RLAPI void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture +RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data +RLAPI unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer) + +// Framebuffer management (fbo) +RLAPI unsigned int rlLoadFramebuffer(int width, int height); // Load an empty framebuffer +RLAPI void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer +RLAPI bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete +RLAPI void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU + +// Shaders management +RLAPI unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings +RLAPI unsigned int rlCompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER) +RLAPI unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program +RLAPI void rlUnloadShaderProgram(unsigned int id); // Unload shader program +RLAPI int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform +RLAPI int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute +RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform +RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix +RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler +RLAPI void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations) + +// Compute shader management +RLAPI unsigned int rlLoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program +RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline) + +// Shader buffer storage object management (ssbo) +RLAPI unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO) +RLAPI void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO) +RLAPI void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data +RLAPI void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer +RLAPI void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU) +RLAPI void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers +RLAPI unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size + +// Buffer management +RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture + +// Matrix state management +RLAPI Matrix rlGetMatrixModelview(void); // Get internal modelview matrix +RLAPI Matrix rlGetMatrixProjection(void); // Get internal projection matrix +RLAPI Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix +RLAPI Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye) +RLAPI void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) +RLAPI void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) +RLAPI void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering +RLAPI void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering + +// Quick and dirty cube/quad buffers load->draw->unload +RLAPI void rlLoadDrawCube(void); // Load and draw a cube +RLAPI void rlLoadDrawQuad(void); // Load and draw a quad + +#if defined(__cplusplus) +} +#endif + +#endif // RLGL_H + +/*********************************************************************************** +* +* RLGL IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RLGL_IMPLEMENTATION) + +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(__APPLE__) + #include // OpenGL 1.1 library for OSX + #include // OpenGL extensions library + #else + // APIENTRY for OpenGL function pointer declarations is required + #if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #endif + // WINGDIAPI definition. Some Windows OpenGL headers need it + #if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #endif + + #include // OpenGL 1.1 library + #endif +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + #define GLAD_MALLOC RL_MALLOC + #define GLAD_FREE RL_FREE + + #define GLAD_GL_IMPLEMENTATION + #include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers +#endif + +#if defined(GRAPHICS_API_OPENGL_ES3) + #include // OpenGL ES 3.0 library + #define GL_GLEXT_PROTOTYPES + #include // OpenGL ES 2.0 extensions library +#elif defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP, + // in that case, functions are loaded from a custom glad for OpenGL ES 2.0 + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + #define GLAD_GLES2_IMPLEMENTATION + #include "external/glad_gles2.h" + #else + #define GL_GLEXT_PROTOTYPES + //#include // EGL library -> not required, platform layer + #include // OpenGL ES 2.0 library + #include // OpenGL ES 2.0 extensions library + #endif + + // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi + // provided headers (despite being defined in official Khronos GLES2 headers) + #if defined(PLATFORM_DRM) + typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); + #endif +#endif + +#include // Required for: malloc(), free() +#include // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading] +#include // Required for: sqrtf(), sinf(), cosf(), floor(), log() + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +#ifndef GL_SHADING_LANGUAGE_VERSION + #define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#endif + +#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 +#endif +#ifndef GL_ETC1_RGB8_OES + #define GL_ETC1_RGB8_OES 0x8D64 +#endif +#ifndef GL_COMPRESSED_RGB8_ETC2 + #define GL_COMPRESSED_RGB8_ETC2 0x9274 +#endif +#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC + #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 +#endif +#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 +#endif +#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR + #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR + #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 +#endif + +#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF +#endif +#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + #define GL_UNSIGNED_SHORT_5_6_5 0x8363 + #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 + #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + #define GL_LUMINANCE 0x1909 + #define GL_LUMINANCE_ALPHA 0x190A +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + #define glClearDepth glClearDepthf + #if !defined(GRAPHICS_API_OPENGL_ES3) + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER + #endif +#endif + +// Default shader vertex attribute names to set location points +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION + #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL + #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR + #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +#endif + +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW + #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION + #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR + #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +typedef struct rlglData { + rlRenderBatch *currentBatch; // Current render batch + rlRenderBatch defaultBatch; // Default internal render batch + + struct { + int vertexCounter; // Current active render batch vertex counter (generic, used for all batches) + float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*()) + float normalx, normaly, normalz; // Current active normal (added on glVertex*()) + unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*()) + + int currentMatrixMode; // Current matrix mode + Matrix *currentMatrix; // Current matrix pointer + Matrix modelview; // Default modelview matrix + Matrix projection; // Default projection matrix + Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate, rlScale + bool transformRequired; // Require transform matrix application to current draw-call vertex (if required) + Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop + int stackCounter; // Matrix stack counter + + unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader) + unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]; // Active texture ids to be enabled on batch drawing (0 active by default) + unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program) + unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program) + unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture + int *defaultShaderLocs; // Default shader locations pointer to be used on rendering + unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId) + int *currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs) + + bool stereoRender; // Stereo rendering flag + Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices + Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices + + // Blending variables + int currentBlendMode; // Blending mode active + int glBlendSrcFactor; // Blending source factor + int glBlendDstFactor; // Blending destination factor + int glBlendEquation; // Blending equation + int glBlendSrcFactorRGB; // Blending source RGB factor + int glBlendDestFactorRGB; // Blending destination RGB factor + int glBlendSrcFactorAlpha; // Blending source alpha factor + int glBlendDestFactorAlpha; // Blending destination alpha factor + int glBlendEquationRGB; // Blending equation for RGB + int glBlendEquationAlpha; // Blending equation for alpha + bool glCustomBlendModeModified; // Custom blending factor and equation modification status + + int framebufferWidth; // Current framebuffer width + int framebufferHeight; // Current framebuffer height + + } State; // Renderer state + struct { + bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object) + bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays) + bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot) + bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture) + bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture) + bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float) + bool texFloat16; // half float textures support (16 bit per channel) (GL_OES_texture_half_float) + bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc) + bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1) + bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility) + bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc) + bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr) + bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp) + bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic) + bool computeShader; // Compute shaders support (GL_ARB_compute_shader) + bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object) + + float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f) + int maxDepthBits; // Maximum bits for depth component + + } ExtSupported; // Extensions supported flags +} rlglData; + +typedef void *(*rlglLoadProc)(const char *name); // OpenGL extension functions loader signature (same as GLADloadproc) + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static rlglData RLGL = { 0 }; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +#if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3) +// NOTE: VAO functionality is exposed through extensions (OES) +static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL; +static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL; +static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL; + +// NOTE: Instancing functionality could also be available through extension +static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL; +static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL; +static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL; +#endif + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static void rlLoadShaderDefault(void); // Load default shader +static void rlUnloadShaderDefault(void); // Unload default shader +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +static const char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name +#endif // RLGL_SHOW_GL_DETAILS_INFO +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +static int rlGetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture) + +// Auxiliar matrix math functions +static Matrix rlMatrixIdentity(void); // Get identity matrix +static Matrix rlMatrixMultiply(Matrix left, Matrix right); // Multiply two matrices + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix operations +//---------------------------------------------------------------------------------- + +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlMatrixMode(int mode) +{ + switch (mode) + { + case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break; + case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break; + case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break; + default: break; + } +} + +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + glFrustum(left, right, bottom, top, znear, zfar); +} + +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + glOrtho(left, right, bottom, top, znear, zfar); +} + +void rlPushMatrix(void) { glPushMatrix(); } +void rlPopMatrix(void) { glPopMatrix(); } +void rlLoadIdentity(void) { glLoadIdentity(); } +void rlTranslatef(float x, float y, float z) { glTranslatef(x, y, z); } +void rlRotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); } +void rlScalef(float x, float y, float z) { glScalef(x, y, z); } +void rlMultMatrixf(const float *matf) { glMultMatrixf(matf); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Choose the current matrix to be transformed +void rlMatrixMode(int mode) +{ + if (mode == RL_PROJECTION) RLGL.State.currentMatrix = &RLGL.State.projection; + else if (mode == RL_MODELVIEW) RLGL.State.currentMatrix = &RLGL.State.modelview; + //else if (mode == RL_TEXTURE) // Not supported + + RLGL.State.currentMatrixMode = mode; +} + +// Push the current matrix into RLGL.State.stack +void rlPushMatrix(void) +{ + if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)"); + + if (RLGL.State.currentMatrixMode == RL_MODELVIEW) + { + RLGL.State.transformRequired = true; + RLGL.State.currentMatrix = &RLGL.State.transform; + } + + RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix; + RLGL.State.stackCounter++; +} + +// Pop lattest inserted matrix from RLGL.State.stack +void rlPopMatrix(void) +{ + if (RLGL.State.stackCounter > 0) + { + Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1]; + *RLGL.State.currentMatrix = mat; + RLGL.State.stackCounter--; + } + + if ((RLGL.State.stackCounter == 0) && (RLGL.State.currentMatrixMode == RL_MODELVIEW)) + { + RLGL.State.currentMatrix = &RLGL.State.modelview; + RLGL.State.transformRequired = false; + } +} + +// Reset current matrix to identity matrix +void rlLoadIdentity(void) +{ + *RLGL.State.currentMatrix = rlMatrixIdentity(); +} + +// Multiply the current matrix by a translation matrix +void rlTranslatef(float x, float y, float z) +{ + Matrix matTranslation = { + 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a rotation matrix +// NOTE: The provided angle must be in degrees +void rlRotatef(float angle, float x, float y, float z) +{ + Matrix matRotation = rlMatrixIdentity(); + + // Axis vector (x, y, z) normalization + float lengthSquared = x*x + y*y + z*z; + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float inverseLength = 1.0f/sqrtf(lengthSquared); + x *= inverseLength; + y *= inverseLength; + z *= inverseLength; + } + + // Rotation matrix generation + float sinres = sinf(DEG2RAD*angle); + float cosres = cosf(DEG2RAD*angle); + float t = 1.0f - cosres; + + matRotation.m0 = x*x*t + cosres; + matRotation.m1 = y*x*t + z*sinres; + matRotation.m2 = z*x*t - y*sinres; + matRotation.m3 = 0.0f; + + matRotation.m4 = x*y*t - z*sinres; + matRotation.m5 = y*y*t + cosres; + matRotation.m6 = z*y*t + x*sinres; + matRotation.m7 = 0.0f; + + matRotation.m8 = x*z*t + y*sinres; + matRotation.m9 = y*z*t - x*sinres; + matRotation.m10 = z*z*t + cosres; + matRotation.m11 = 0.0f; + + matRotation.m12 = 0.0f; + matRotation.m13 = 0.0f; + matRotation.m14 = 0.0f; + matRotation.m15 = 1.0f; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a scaling matrix +void rlScalef(float x, float y, float z) +{ + Matrix matScale = { + x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by another matrix +void rlMultMatrixf(const float *matf) +{ + // Matrix creation from array + Matrix mat = { matf[0], matf[4], matf[8], matf[12], + matf[1], matf[5], matf[9], matf[13], + matf[2], matf[6], matf[10], matf[14], + matf[3], matf[7], matf[11], matf[15] }; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, mat); +} + +// Multiply the current matrix by a perspective matrix generated by parameters +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + Matrix matFrustum = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matFrustum.m0 = ((float) znear*2.0f)/rl; + matFrustum.m1 = 0.0f; + matFrustum.m2 = 0.0f; + matFrustum.m3 = 0.0f; + + matFrustum.m4 = 0.0f; + matFrustum.m5 = ((float) znear*2.0f)/tb; + matFrustum.m6 = 0.0f; + matFrustum.m7 = 0.0f; + + matFrustum.m8 = ((float)right + (float)left)/rl; + matFrustum.m9 = ((float)top + (float)bottom)/tb; + matFrustum.m10 = -((float)zfar + (float)znear)/fn; + matFrustum.m11 = -1.0f; + + matFrustum.m12 = 0.0f; + matFrustum.m13 = 0.0f; + matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn; + matFrustum.m15 = 0.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum); +} + +// Multiply the current matrix by an orthographic matrix generated by parameters +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + // NOTE: If left-right and top-botton values are equal it could create a division by zero, + // response to it is platform/compiler dependant + Matrix matOrtho = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matOrtho.m0 = 2.0f/rl; + matOrtho.m1 = 0.0f; + matOrtho.m2 = 0.0f; + matOrtho.m3 = 0.0f; + matOrtho.m4 = 0.0f; + matOrtho.m5 = 2.0f/tb; + matOrtho.m6 = 0.0f; + matOrtho.m7 = 0.0f; + matOrtho.m8 = 0.0f; + matOrtho.m9 = 0.0f; + matOrtho.m10 = -2.0f/fn; + matOrtho.m11 = 0.0f; + matOrtho.m12 = -((float)left + (float)right)/rl; + matOrtho.m13 = -((float)top + (float)bottom)/tb; + matOrtho.m14 = -((float)zfar + (float)znear)/fn; + matOrtho.m15 = 1.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho); +} +#endif + +// Set the viewport area (transformation from normalized device coordinates to window coordinates) +// NOTE: We store current viewport dimensions +void rlViewport(int x, int y, int width, int height) +{ + glViewport(x, y, width, height); +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vertex level operations +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlBegin(int mode) +{ + switch (mode) + { + case RL_LINES: glBegin(GL_LINES); break; + case RL_TRIANGLES: glBegin(GL_TRIANGLES); break; + case RL_QUADS: glBegin(GL_QUADS); break; + default: break; + } +} + +void rlEnd() { glEnd(); } +void rlVertex2i(int x, int y) { glVertex2i(x, y); } +void rlVertex2f(float x, float y) { glVertex2f(x, y); } +void rlVertex3f(float x, float y, float z) { glVertex3f(x, y, z); } +void rlTexCoord2f(float x, float y) { glTexCoord2f(x, y); } +void rlNormal3f(float x, float y, float z) { glNormal3f(x, y, z); } +void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); } +void rlColor3f(float x, float y, float z) { glColor3f(x, y, z); } +void rlColor4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Initialize drawing mode (how to organize vertex) +void rlBegin(int mode) +{ + // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS + // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId; + } +} + +// Finish vertex providing +void rlEnd(void) +{ + // NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values, + // as well as depth buffer bit-depth (16bit or 24bit or 32bit) + // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits) + RLGL.currentBatch->currentDepth += (1.0f/20000.0f); +} + +// Define one vertex (position) +// NOTE: Vertex position data is the basic information required for drawing +void rlVertex3f(float x, float y, float z) +{ + float tx = x; + float ty = y; + float tz = z; + + // Transform provided vector if required + if (RLGL.State.transformRequired) + { + tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12; + ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13; + tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14; + } + + // WARNING: We can't break primitives when launching a new batch. + // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices. + // We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4 + if (RLGL.State.vertexCounter > (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4)) + { + if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%2 == 0)) + { + // Reached the maximum number of vertices for RL_LINES drawing + // Launch a draw call but keep current state for next vertices comming + // NOTE: We add +1 vertex to the check for security + rlCheckRenderBatchLimit(2 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0)) + { + rlCheckRenderBatchLimit(3 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_QUADS) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4 == 0)) + { + rlCheckRenderBatchLimit(4 + 1); + } + } + + // Add vertices + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter] = tx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 1] = ty; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 2] = tz; + + // Add current texcoord + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter] = RLGL.State.texcoordx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy; + + // WARNING: By default rlVertexBuffer struct does not store normals + + // Add current color + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter] = RLGL.State.colorr; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 1] = RLGL.State.colorg; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 2] = RLGL.State.colorb; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 3] = RLGL.State.colora; + + RLGL.State.vertexCounter++; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++; +} + +// Define one vertex (position) +void rlVertex2f(float x, float y) +{ + rlVertex3f(x, y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (position) +void rlVertex2i(int x, int y) +{ + rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (texture coordinate) +// NOTE: Texture coordinates are limited to QUADS only +void rlTexCoord2f(float x, float y) +{ + RLGL.State.texcoordx = x; + RLGL.State.texcoordy = y; +} + +// Define one vertex (normal) +// NOTE: Normals limited to TRIANGLES only? +void rlNormal3f(float x, float y, float z) +{ + RLGL.State.normalx = x; + RLGL.State.normaly = y; + RLGL.State.normalz = z; +} + +// Define one vertex (color) +void rlColor4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + RLGL.State.colorr = x; + RLGL.State.colorg = y; + RLGL.State.colorb = z; + RLGL.State.colora = w; +} + +// Define one vertex (color) +void rlColor4f(float r, float g, float b, float a) +{ + rlColor4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255)); +} + +// Define one vertex (color) +void rlColor3f(float x, float y, float z) +{ + rlColor4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255); +} + +#endif + +//-------------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2) +//-------------------------------------------------------------------------------------- + +// Set current texture to use +void rlSetTexture(unsigned int id) +{ + if (id == 0) + { +#if defined(GRAPHICS_API_OPENGL_11) + rlDisableTexture(); +#else + // NOTE: If quads batch limit is reached, we force a draw call and next batch starts + if (RLGL.State.vertexCounter >= + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4) + { + rlDrawRenderBatch(RLGL.currentBatch); + } +#endif + } + else + { +#if defined(GRAPHICS_API_OPENGL_11) + rlEnableTexture(id); +#else + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = id; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + } +#endif + } +} + +// Select and active a texture slot +void rlActiveTextureSlot(int slot) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glActiveTexture(GL_TEXTURE0 + slot); +#endif +} + +// Enable texture +void rlEnableTexture(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, id); +} + +// Disable texture +void rlDisableTexture(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Enable texture cubemap +void rlEnableTextureCubemap(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); +#endif +} + +// Disable texture cubemap +void rlDisableTextureCubemap(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Set texture parameters (wrap mode/filter mode) +void rlTextureParameters(unsigned int id, int param, int value) +{ + glBindTexture(GL_TEXTURE_2D, id); + +#if !defined(GRAPHICS_API_OPENGL_11) + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); +#endif + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); +#endif + } + else glTexParameteri(GL_TEXTURE_2D, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); +#endif + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Set cubemap parameters (wrap mode/filter mode) +void rlCubemapParameters(unsigned int id, int param, int value) +{ +#if !defined(GRAPHICS_API_OPENGL_11) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); + } + else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Enable shader program +void rlEnableShader(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(id); +#endif +} + +// Disable shader program +void rlDisableShader(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(0); +#endif +} + +// Enable rendering to texture (fbo) +void rlEnableFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); +#endif +} + +// Disable rendering to texture +void rlDisableFramebuffer(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Blit active framebuffer to main framebuffer +void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask, GL_NEAREST); +#endif +} + +// Activate multiple draw color buffers +// NOTE: One color buffer is always active by default +void rlActiveDrawBuffers(int count) +{ +#if ((defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT)) + // NOTE: Maximum number of draw buffers supported is implementation dependant, + // it can be queried with glGet*() but it must be at least 8 + //GLint maxDrawBuffers = 0; + //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); + + if (count > 0) + { + if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8"); + else + { + unsigned int buffers[8] = { +#if defined(GRAPHICS_API_OPENGL_ES3) + GL_COLOR_ATTACHMENT0_EXT, + GL_COLOR_ATTACHMENT1_EXT, + GL_COLOR_ATTACHMENT2_EXT, + GL_COLOR_ATTACHMENT3_EXT, + GL_COLOR_ATTACHMENT4_EXT, + GL_COLOR_ATTACHMENT5_EXT, + GL_COLOR_ATTACHMENT6_EXT, + GL_COLOR_ATTACHMENT7_EXT, +#else + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, +#endif + }; + +#if defined(GRAPHICS_API_OPENGL_ES3) + glDrawBuffersEXT(count, buffers); +#else + glDrawBuffers(count, buffers); +#endif + } + } + else TRACELOG(LOG_WARNING, "GL: One color buffer active by default"); +#endif +} + +//---------------------------------------------------------------------------------- +// General render state configuration +//---------------------------------------------------------------------------------- + +// Enable color blending +void rlEnableColorBlend(void) { glEnable(GL_BLEND); } + +// Disable color blending +void rlDisableColorBlend(void) { glDisable(GL_BLEND); } + +// Enable depth test +void rlEnableDepthTest(void) { glEnable(GL_DEPTH_TEST); } + +// Disable depth test +void rlDisableDepthTest(void) { glDisable(GL_DEPTH_TEST); } + +// Enable depth write +void rlEnableDepthMask(void) { glDepthMask(GL_TRUE); } + +// Disable depth write +void rlDisableDepthMask(void) { glDepthMask(GL_FALSE); } + +// Enable backface culling +void rlEnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); } + +// Disable backface culling +void rlDisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); } + +// Set face culling mode +void rlSetCullFace(int mode) +{ + switch (mode) + { + case RL_CULL_FACE_BACK: glCullFace(GL_BACK); break; + case RL_CULL_FACE_FRONT: glCullFace(GL_FRONT); break; + default: break; + } +} + +// Enable scissor test +void rlEnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); } + +// Disable scissor test +void rlDisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); } + +// Scissor test +void rlScissor(int x, int y, int width, int height) { glScissor(x, y, width, height); } + +// Enable wire mode +void rlEnableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); +#endif +} + +void rlEnablePointMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); + glEnable(GL_PROGRAM_POINT_SIZE); +#endif +} +// Disable wire mode +void rlDisableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); +#endif +} + +// Set the line drawing width +void rlSetLineWidth(float width) { glLineWidth(width); } + +// Get the line drawing width +float rlGetLineWidth(void) +{ + float width = 0; + glGetFloatv(GL_LINE_WIDTH, &width); + return width; +} + +// Enable line aliasing +void rlEnableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_LINE_SMOOTH); +#endif +} + +// Disable line aliasing +void rlDisableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_LINE_SMOOTH); +#endif +} + +// Enable stereo rendering +void rlEnableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = true; +#endif +} + +// Disable stereo rendering +void rlDisableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = false; +#endif +} + +// Check if stereo render is enabled +bool rlIsStereoRenderEnabled(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + return RLGL.State.stereoRender; +#else + return false; +#endif +} + +// Clear color buffer with color +void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a) +{ + // Color values clamp to 0.0f(0) and 1.0f(255) + float cr = (float)r/255; + float cg = (float)g/255; + float cb = (float)b/255; + float ca = (float)a/255; + + glClearColor(cr, cg, cb, ca); +} + +// Clear used screen buffers (color and depth) +void rlClearScreenBuffers(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is used for 3D) + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used... +} + +// Check and log OpenGL error codes +void rlCheckErrors() +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + int check = 1; + while (check) + { + const GLenum err = glGetError(); + switch (err) + { + case GL_NO_ERROR: check = 0; break; + case 0x0500: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break; + case 0x0501: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break; + case 0x0502: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break; + case 0x0503: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break; + case 0x0504: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break; + case 0x0505: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break; + case 0x0506: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break; + default: TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break; + } + } +#endif +} + +// Set blend mode +void rlSetBlendMode(int mode) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified)) + { + rlDrawRenderBatch(RLGL.currentBatch); + + switch (mode) + { + case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + 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_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() + glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation); + + } break; + case RL_BLEND_CUSTOM_SEPARATE: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate() + glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha); + glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha); + + } break; + default: break; + } + + RLGL.State.currentBlendMode = mode; + RLGL.State.glCustomBlendModeModified = false; + } +#endif +} + +// Set blending mode factor and equation +void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactor != glSrcFactor) || + (RLGL.State.glBlendDstFactor != glDstFactor) || + (RLGL.State.glBlendEquation != glEquation)) + { + RLGL.State.glBlendSrcFactor = glSrcFactor; + RLGL.State.glBlendDstFactor = glDstFactor; + RLGL.State.glBlendEquation = glEquation; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +// Set blending mode factor and equation separately for RGB and alpha +void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactorRGB != glSrcRGB) || + (RLGL.State.glBlendDestFactorRGB != glDstRGB) || + (RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha) || + (RLGL.State.glBlendDestFactorAlpha != glDstAlpha) || + (RLGL.State.glBlendEquationRGB != glEqRGB) || + (RLGL.State.glBlendEquationAlpha != glEqAlpha)) + { + RLGL.State.glBlendSrcFactorRGB = glSrcRGB; + RLGL.State.glBlendDestFactorRGB = glDstRGB; + RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha; + RLGL.State.glBlendDestFactorAlpha = glDstAlpha; + RLGL.State.glBlendEquationRGB = glEqRGB; + RLGL.State.glBlendEquationAlpha = glEqAlpha; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL Debug +//---------------------------------------------------------------------------------- +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) +static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) +{ + // Ignore non-significant error/warning codes (NVidia drivers) + // NOTE: Here there are the details with a sample output: + // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low) + // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4) + // will use VIDEO memory as the source for buffer object operations. (severity: low) + // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium) + // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have + // a defined base level and cannot be used for texture mapping. (severity: low) + if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return; + + const char *msgSource = NULL; + switch (source) + { + case GL_DEBUG_SOURCE_API: msgSource = "API"; break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break; + case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break; + case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break; + case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break; + default: break; + } + + const char *msgType = NULL; + switch (type) + { + case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break; + case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break; + case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break; + case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break; + case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break; + case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break; + default: break; + } + + const char *msgSeverity = "DEFAULT"; + switch (severity) + { + case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break; + case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break; + case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break; + case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break; + default: break; + } + + TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message); + TRACELOG(LOG_WARNING, " > Type: %s", msgType); + TRACELOG(LOG_WARNING, " > Source = %s", msgSource); + TRACELOG(LOG_WARNING, " > Severity = %s", msgSeverity); +} +#endif + +//---------------------------------------------------------------------------------- +// Module Functions Definition - rlgl functionality +//---------------------------------------------------------------------------------- + +// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states +void rlglInit(int width, int height) +{ + // Enable OpenGL debug context if required +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) + if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL)) + { + glDebugMessageCallback(rlDebugMessageCallback, 0); + // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); + + // Debug context options: + // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints + // - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + } +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Init default white texture + unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes) + RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); + + if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture"); + + // Init default Shader (customized for GL 3.3 and ES2) + // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs + rlLoadShaderDefault(); + RLGL.State.currentShaderId = RLGL.State.defaultShaderId; + RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs; + + // Init default vertex arrays buffers + RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS); + RLGL.currentBatch = &RLGL.defaultBatch; + + // Init stack matrices (emulating OpenGL 1.1) + for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity(); + + // Init internal matrices + RLGL.State.transform = rlMatrixIdentity(); + RLGL.State.projection = rlMatrixIdentity(); + RLGL.State.modelview = rlMatrixIdentity(); + RLGL.State.currentMatrix = &RLGL.State.modelview; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + + // Initialize OpenGL default states + //---------------------------------------------------------- + // Init state: Depth test + glDepthFunc(GL_LEQUAL); // Type of depth testing to apply + glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D) + + // Init state: Blending mode + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed) + glEnable(GL_BLEND); // Enable color blending (required to work with transparencies) + + // Init state: Culling + // NOTE: All shapes/models triangles are drawn CCW + glCullFace(GL_BACK); // Cull the back face (default) + glFrontFace(GL_CCW); // Front face are defined counter clockwise (default) + glEnable(GL_CULL_FACE); // Enable backface culling + + // Init state: Cubemap seamless +#if defined(GRAPHICS_API_OPENGL_33) + glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // Seamless cubemaps (not supported on OpenGL ES 2.0) +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + // Init state: Color hints (deprecated in OpenGL 3.0+) + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Improve quality of color and texture coordinate interpolation + glShadeModel(GL_SMOOTH); // Smooth shading between vertex (vertex colors interpolation) +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Store screen size into global variables + RLGL.State.framebufferWidth = width; + RLGL.State.framebufferHeight = height; + + TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully"); + //---------------------------------------------------------- +#endif + + // Init state: Color/Depth buffers clear + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set clear color (black) + glClearDepth(1.0f); // Set clear depth value (default) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers (depth buffer required for 3D) +} + +// Vertex Buffer Object deinitialization (memory free) +void rlglClose(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlUnloadRenderBatch(RLGL.defaultBatch); + + rlUnloadShaderDefault(); // Unload default shader + + glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId); +#endif +} + +// Load OpenGL extensions +// NOTE: External loader function must be provided +void rlLoadExtensions(void *loader) +{ +#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21 + // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions) + if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully"); + + // Get number of supported extensions + GLint numExt = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Get supported extensions list + // WARNING: glGetStringi() not available on OpenGL 2.1 + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", glGetStringi(GL_EXTENSIONS, i)); +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + // Register supported extensions flags + // Optional OpenGL 2.1 extensions + RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object; + RLGL.ExtSupported.instancing = (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays); + RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two; + RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float; + RLGL.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float; + RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic; + RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp; +#else + // Register supported extensions flags + // OpenGL 3.3 extensions supported by default (core) + RLGL.ExtSupported.vao = true; + RLGL.ExtSupported.instancing = true; + RLGL.ExtSupported.texNPOT = true; + RLGL.ExtSupported.texFloat32 = true; + RLGL.ExtSupported.texFloat16 = true; + RLGL.ExtSupported.texDepth = true; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = true; + RLGL.ExtSupported.texMirrorClamp = true; +#endif + + // Optional OpenGL 3.3 extensions + RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr; + RLGL.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT + RLGL.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC + #if defined(GRAPHICS_API_OPENGL_43) + RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader; + RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object; + #endif + +#endif // GRAPHICS_API_OPENGL_33 + +#if defined(GRAPHICS_API_OPENGL_ES3) + // Register supported extensions flags + // OpenGL ES 3.0 extensions supported by default (or it should be) + RLGL.ExtSupported.vao = true; + RLGL.ExtSupported.instancing = true; + RLGL.ExtSupported.texNPOT = true; + RLGL.ExtSupported.texFloat32 = true; + RLGL.ExtSupported.texFloat16 = true; + RLGL.ExtSupported.texDepth = true; + RLGL.ExtSupported.texDepthWebGL = true; + RLGL.ExtSupported.maxDepthBits = 24; + RLGL.ExtSupported.texAnisoFilter = true; + RLGL.ExtSupported.texMirrorClamp = true; + // TODO: Check for additional OpenGL ES 3.0 supported extensions: + //RLGL.ExtSupported.texCompDXT = true; + //RLGL.ExtSupported.texCompETC1 = true; + //RLGL.ExtSupported.texCompETC2 = true; + //RLGL.ExtSupported.texCompPVRT = true; + //RLGL.ExtSupported.texCompASTC = true; + //RLGL.ExtSupported.maxAnisotropyLevel = true; + //RLGL.ExtSupported.computeShader = true; + //RLGL.ExtSupported.ssbo = true; + +#elif defined(GRAPHICS_API_OPENGL_ES2) + + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + // TODO: Support GLAD loader for OpenGL ES 3.0 + if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully"); + #endif + + // Get supported extensions list + GLint numExt = 0; + const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB) + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); // One big const string + + // NOTE: We have to duplicate string because glGetString() returns a const string + int size = strlen(extensions) + 1; // Get extensions string size in bytes + char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char)); + strcpy(extensionsDup, extensions); + extList[numExt] = extensionsDup; + + for (int i = 0; i < size; i++) + { + if (extensionsDup[i] == ' ') + { + extensionsDup[i] = '\0'; + numExt++; + extList[numExt] = &extensionsDup[i + 1]; + } + } + + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", extList[i]); +#endif + + // Check required extensions + for (int i = 0; i < numExt; i++) + { + // Check VAO support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0) + { + // The extension is supported by our hardware and driver, try to get related functions pointers + // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... + glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glGenVertexArraysOES"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)("glBindVertexArrayOES"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glDeleteVertexArraysOES"); + //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted + + if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true; + } + + // Check instanced rendering support + if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0) // Web ANGLE + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedANGLE"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorANGLE"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + else + { + if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0) && // Standard EXT + (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0)) + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorEXT"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + } + + // Check NPOT textures support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL.ExtSupported.texNPOT = true; + + // Check texture float support + if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true; + if (strcmp(extList[i], (const char *)"GL_OES_texture_half_float") == 0) RLGL.ExtSupported.texFloat16 = true; + + // Check depth texture support + if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL.ExtSupported.texDepth = true; + if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format + if (RLGL.ExtSupported.texDepthWebGL) RLGL.ExtSupported.texDepth = true; + + if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL + if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL + + // Check texture compression support: DXT + if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true; + + // Check texture compression support: ETC1 + if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL.ExtSupported.texCompETC1 = true; + + // Check texture compression support: ETC2/EAC + if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL.ExtSupported.texCompETC2 = true; + + // Check texture compression support: PVR + if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL.ExtSupported.texCompPVRT = true; + + // Check texture compression support: ASTC + if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL.ExtSupported.texCompASTC = true; + + // Check anisotropic texture filter support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL.ExtSupported.texAnisoFilter = true; + + // Check clamp mirror wrap mode support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL.ExtSupported.texMirrorClamp = true; + } + + // Free extensions pointers + RL_FREE(extList); + RL_FREE(extensionsDup); // Duplicated string must be deallocated +#endif // GRAPHICS_API_OPENGL_ES2 + + // Check OpenGL information and capabilities + //------------------------------------------------------------------------------ + // Show current OpenGL and GLSL version + TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:"); + TRACELOG(RL_LOG_INFO, " > Vendor: %s", glGetString(GL_VENDOR)); + TRACELOG(RL_LOG_INFO, " > Renderer: %s", glGetString(GL_RENDERER)); + TRACELOG(RL_LOG_INFO, " > Version: %s", glGetString(GL_VERSION)); + TRACELOG(RL_LOG_INFO, " > GLSL: %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Anisotropy levels capability is an extension + #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + #endif + glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Show some OpenGL GPU capabilities + TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:"); + GLint capability = 0; + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability); + glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability); + #if !defined(GRAPHICS_API_OPENGL_ES2) + glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability); + glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability); + if (RLGL.ExtSupported.texAnisoFilter) TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel); + #endif + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability); + TRACELOG(RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability); + GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint)); + glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats); + for (int i = 0; i < capability; i++) TRACELOG(RL_LOG_INFO, " %s", rlGetCompressedFormatName(compFormats[i])); + RL_FREE(compFormats); + +#if defined(GRAPHICS_API_OPENGL_43) + glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability); + glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability); +#endif // GRAPHICS_API_OPENGL_43 +#else // RLGL_SHOW_GL_DETAILS_INFO + + // Show some basic info about GL supported features + if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully"); + else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported"); + if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported"); + else TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)"); + if (RLGL.ExtSupported.texCompDXT) TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported"); + if (RLGL.ExtSupported.texCompETC1) TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported"); + if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported"); + if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported"); + if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported"); + if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported"); + if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported"); +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +} + +// Get current OpenGL version +int rlGetVersion(void) +{ + int glVersion = 0; +#if defined(GRAPHICS_API_OPENGL_11) + glVersion = RL_OPENGL_11; +#endif +#if defined(GRAPHICS_API_OPENGL_21) + glVersion = RL_OPENGL_21; +#elif defined(GRAPHICS_API_OPENGL_43) + glVersion = RL_OPENGL_43; +#elif defined(GRAPHICS_API_OPENGL_33) + glVersion = RL_OPENGL_33; +#endif +#if defined(GRAPHICS_API_OPENGL_ES3) + glVersion = RL_OPENGL_ES_30; +#elif defined(GRAPHICS_API_OPENGL_ES2) + glVersion = RL_OPENGL_ES_20; +#endif + + return glVersion; +} + +// Set current framebuffer width +void rlSetFramebufferWidth(int width) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferWidth = width; +#endif +} + +// Set current framebuffer height +void rlSetFramebufferHeight(int height) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferHeight = height; +#endif +} + +// Get default framebuffer width +int rlGetFramebufferWidth(void) +{ + int width = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + width = RLGL.State.framebufferWidth; +#endif + return width; +} + +// Get default framebuffer height +int rlGetFramebufferHeight(void) +{ + int height = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + height = RLGL.State.framebufferHeight; +#endif + return height; +} + +// Get default internal texture (white texture) +// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 +unsigned int rlGetTextureIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultTextureId; +#endif + return id; +} + +// Get default shader id +unsigned int rlGetShaderIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultShaderId; +#endif + return id; +} + +// Get default shader locs +int *rlGetShaderLocsDefault(void) +{ + int *locs = NULL; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + locs = RLGL.State.defaultShaderLocs; +#endif + return locs; +} + +// Render batch management +//------------------------------------------------------------------------------------------------ +// Load render batch +rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements) +{ + rlRenderBatch batch = { 0 }; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes) + //-------------------------------------------------------------------------------------------- + batch.vertexBuffer = (rlVertexBuffer *)RL_MALLOC(numBuffers*sizeof(rlVertexBuffer)); + + for (int i = 0; i < numBuffers; i++) + { + batch.vertexBuffer[i].elementCount = bufferElements; + + batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float)); // 3 float by vertex, 4 vertex by quad + batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float)); // 2 float by texcoord, 4 texcoord by quad + batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char)); // 4 float by color, 4 colors by quad +#if defined(GRAPHICS_API_OPENGL_33) + batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int)); // 6 int by quad (indices) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short)); // 6 int by quad (indices) +#endif + + for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f; + for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f; + for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0; + + int k = 0; + + // Indices can be initialized right now + for (int j = 0; j < (6*bufferElements); j += 6) + { + batch.vertexBuffer[i].indices[j] = 4*k; + batch.vertexBuffer[i].indices[j + 1] = 4*k + 1; + batch.vertexBuffer[i].indices[j + 2] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 3] = 4*k; + batch.vertexBuffer[i].indices[j + 4] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 5] = 4*k + 3; + + k++; + } + + RLGL.State.vertexCounter = 0; + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)"); + //-------------------------------------------------------------------------------------------- + + // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs + //-------------------------------------------------------------------------------------------- + for (int i = 0; i < numBuffers; i++) + { + if (RLGL.ExtSupported.vao) + { + // Initialize Quads VAO + glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId); + glBindVertexArray(batch.vertexBuffer[i].vaoId); + } + + // Quads - Vertex buffers binding and attributes enable + // Vertex position buffer (shader-location = 0) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + + // Vertex texcoord buffer (shader-location = 1) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + + // Vertex color buffer (shader-location = 3) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + + // Fill index buffer + glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]); +#if defined(GRAPHICS_API_OPENGL_33) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)"); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + //-------------------------------------------------------------------------------------------- + + // Init draw calls tracking system + //-------------------------------------------------------------------------------------------- + batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall)); + + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch.draws[i].mode = RL_QUADS; + batch.draws[i].vertexCount = 0; + batch.draws[i].vertexAlignment = 0; + //batch.draws[i].vaoId = 0; + //batch.draws[i].shaderId = 0; + batch.draws[i].textureId = RLGL.State.defaultTextureId; + //batch.draws[i].RLGL.State.projection = rlMatrixIdentity(); + //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity(); + } + + batch.bufferCount = numBuffers; // Record buffer count + batch.drawCounter = 1; // Reset draws counter + batch.currentDepth = -1.0f; // Reset depth value + //-------------------------------------------------------------------------------------------- +#endif + + return batch; +} + +// Unload default internal buffers vertex data from CPU and GPU +void rlUnloadRenderBatch(rlRenderBatch batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Unbind everything + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + // Unload all vertex buffers data + for (int i = 0; i < batch.bufferCount; i++) + { + // Unbind VAO attribs data + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(batch.vertexBuffer[i].vaoId); + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + glDisableVertexAttribArray(2); + glDisableVertexAttribArray(3); + glBindVertexArray(0); + } + + // Delete VBOs from GPU (VRAM) + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]); + + // Delete VAOs from GPU (VRAM) + if (RLGL.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId); + + // Free vertex arrays memory from CPU (RAM) + RL_FREE(batch.vertexBuffer[i].vertices); + RL_FREE(batch.vertexBuffer[i].texcoords); + RL_FREE(batch.vertexBuffer[i].colors); + RL_FREE(batch.vertexBuffer[i].indices); + } + + // Unload arrays + RL_FREE(batch.vertexBuffer); + RL_FREE(batch.draws); +#endif +} + +// Draw render batch +// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer) +void rlDrawRenderBatch(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Update batch vertex buffers + //------------------------------------------------------------------------------------------------------------ + // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) + // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (use a change detector flag?) + if (RLGL.State.vertexCounter > 0) + { + // Activate elements VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + + // Vertex positions buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer + + // Texture coordinates buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer + + // Colors buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer + + // NOTE: glMapBuffer() causes sync issue. + // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. + // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). + // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new + // allocated pointer immediately even if GPU is still working with the previous data. + + // Another option: map the buffer object into client's memory + // Probably this code could be moved somewhere else... + // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); + // if (batch->vertexBuffer[batch->currentBuffer].vertices) + // { + // Update vertex data + // } + // glUnmapBuffer(GL_ARRAY_BUFFER); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + } + //------------------------------------------------------------------------------------------------------------ + + // Draw batch vertex buffers (considering VR stereo if required) + //------------------------------------------------------------------------------------------------------------ + Matrix matProjection = RLGL.State.projection; + Matrix matModelView = RLGL.State.modelview; + + int eyeCount = 1; + if (RLGL.State.stereoRender) eyeCount = 2; + + for (int eye = 0; eye < eyeCount; eye++) + { + if (eyeCount == 2) + { + // Setup current eye viewport (half screen width) + rlViewport(eye*RLGL.State.framebufferWidth/2, 0, RLGL.State.framebufferWidth/2, RLGL.State.framebufferHeight); + + // Set current eye view offset to modelview matrix + rlSetMatrixModelview(rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye])); + // Set current eye projection matrix + rlSetMatrixProjection(RLGL.State.projectionStereo[eye]); + } + + // Draw buffers + if (RLGL.State.vertexCounter > 0) + { + // Set current shader and upload current MVP matrix + glUseProgram(RLGL.State.currentShaderId); + + // Create modelview-projection matrix and upload to shader + Matrix matMVP = rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection); + float matMVPfloat[16] = { + matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3, + matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7, + matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11, + matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15 + }; + glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, matMVPfloat); + + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + else + { + // Bind vertex attrib: position (shader-location = 0) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + + // Bind vertex attrib: texcoord (shader-location = 1) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + + // Bind vertex attrib: color (shader-location = 3) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]); + } + + // Setup some default shader values + glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f); + glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0 + + // Activate additional sampler textures + // Those additional textures will be common for all draw calls of the batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] > 0) + { + glActiveTexture(GL_TEXTURE0 + 1 + i); + glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]); + } + } + + // Activate default sampler2D texture0 (one texture is always active for default batch shader) + // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls + glActiveTexture(GL_TEXTURE0); + + for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++) + { + // Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default + glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId); + + if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount); + else + { +#if defined(GRAPHICS_API_OPENGL_33) + // We need to define the number of indices to be processed: elementCount*6 + // NOTE: The final parameter tells the GPU the offset in bytes from the + // start of the index buffer to the location of the first index to process + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint))); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort))); +#endif + } + + vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment); + } + + if (!RLGL.ExtSupported.vao) + { + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } + + glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures + } + + if (RLGL.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO + + glUseProgram(0); // Unbind shader program + } + + // Restore viewport to default measures + if (eyeCount == 2) rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight); + //------------------------------------------------------------------------------------------------------------ + + // Reset batch buffers + //------------------------------------------------------------------------------------------------------------ + // Reset vertex counter for next frame + RLGL.State.vertexCounter = 0; + + // Reset depth for next draw + batch->currentDepth = -1.0f; + + // Restore projection/modelview matrices + RLGL.State.projection = matProjection; + RLGL.State.modelview = matModelView; + + // Reset RLGL.currentBatch->draws array + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch->draws[i].mode = RL_QUADS; + batch->draws[i].vertexCount = 0; + batch->draws[i].textureId = RLGL.State.defaultTextureId; + } + + // Reset active texture units for next batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0; + + // Reset draws counter to one draw for the batch + batch->drawCounter = 1; + //------------------------------------------------------------------------------------------------------------ + + // Change to next buffer in the list (in case of multi-buffering) + batch->currentBuffer++; + if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0; +#endif +} + +// Set the active render batch for rlgl +void rlSetRenderBatchActive(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); + + if (batch != NULL) RLGL.currentBatch = batch; + else RLGL.currentBatch = &RLGL.defaultBatch; +#endif +} + +// Update and draw internal render batch +void rlDrawRenderBatchActive(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside +#endif +} + +// Check internal buffer overflow for a given number of vertex +// and force a rlRenderBatch draw call if required +bool rlCheckRenderBatchLimit(int vCount) +{ + bool overflow = false; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.vertexCounter + vCount) >= + (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)) + { + overflow = true; + + // Store current primitive drawing mode and texture id + int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode; + int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId; + + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside + + // Restore state of last batch so we can continue adding vertices + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture; + } +#endif + + return overflow; +} + +// Textures data management +//----------------------------------------------------------------------------------------- +// Convert image data to OpenGL texture (returns OpenGL valid Id) +unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount) +{ + unsigned int id = 0; + + glBindTexture(GL_TEXTURE_2D, 0); // Free any old binding + + // Check texture format support by OpenGL 1.1 (compressed textures not supported) +#if defined(GRAPHICS_API_OPENGL_11) + if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats"); + return id; + } +#else + if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) || + (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported"); + return id; + } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((!RLGL.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB)) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported"); + return id; + } +#endif +#endif // GRAPHICS_API_OPENGL_11 + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(1, &id); // Generate texture id + + glBindTexture(GL_TEXTURE_2D, id); + + int mipWidth = width; + int mipHeight = height; + int mipOffset = 0; // Mipmap data offset, only used for tracelog + + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned char *dataPtr = NULL; + if (data != NULL) dataPtr = (unsigned char *)data; + + // Load the different mipmap levels + for (int i = 0; i < mipmapCount; i++) + { + unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset); + + if (glInternalFormat != 0) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, dataPtr); +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + + mipWidth /= 2; + mipHeight /= 2; + mipOffset += mipSize; // Increment offset position to next mipmap + if (data != NULL) dataPtr += mipSize; // Increment data pointer to next mipmap + + // Security check for NPOT textures + if (mipWidth < 1) mipWidth = 1; + if (mipHeight < 1) mipHeight = 1; + } + + // Texture parameters configuration + // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used +#if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used + if (RLGL.ExtSupported.texNPOT) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis + } + else + { + // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work! + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis + } +#else + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis +#endif + + // Magnification and minification filters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + +#if defined(GRAPHICS_API_OPENGL_33) + if (mipmapCount > 1) + { + // Activate Trilinear filtering if mipmaps are available + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + } +#endif + + // At this point we have the texture loaded in GPU and texture parameters configured + + // NOTE: If mipmaps were not in data, they are not generated automatically + + // Unbind current texture + glBindTexture(GL_TEXTURE_2D, 0); + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, rlGetPixelFormatName(format), mipmapCount); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture"); + + return id; +} + +// Load depth texture/renderbuffer (to be attached to fbo) +// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions +unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // In case depth textures not supported, we force renderbuffer usage + if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true; + + // NOTE: We let the implementation to choose the best bit-depth + // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F + unsigned int glInternalFormat = GL_DEPTH_COMPONENT; + +#if (defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_ES3)) + // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT) + // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities + if (!RLGL.ExtSupported.texDepthWebGL || useRenderBuffer) + { + if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES; + else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES; + else glInternalFormat = GL_DEPTH_COMPONENT16; + } +#endif + + if (!useRenderBuffer && RLGL.ExtSupported.texDepth) + { + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + glBindTexture(GL_TEXTURE_2D, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully"); + } + else + { + // Create the renderbuffer that will serve as the depth attachment for the framebuffer + // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices + glGenRenderbuffers(1, &id); + glBindRenderbuffer(GL_RENDERBUFFER, id); + glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height); + + glBindRenderbuffer(GL_RENDERBUFFER, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16); + } +#endif + + return id; +} + +// Load texture cubemap +// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other), +// expected the following convention: +X, -X, +Y, -Y, +Z, -Z +unsigned int rlLoadTextureCubemap(const void *data, int size, int format) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int dataSize = rlGetPixelDataSize(size, size, format); + + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if (glInternalFormat != 0) + { + // Load cubemap faces + for (unsigned int i = 0; i < 6; i++) + { + if (data == NULL) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) + || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) + TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format"); + } + else + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize); + else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize); + } + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + } + + // Set cubemap texture sampling parameters + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +#if defined(GRAPHICS_API_OPENGL_33) + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0 +#endif + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture"); + + return id; +} + +// Update already loaded texture in GPU with new data +// NOTE: We don't know safely if internal texture format is the expected one... +void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data) +{ + glBindTexture(GL_TEXTURE_2D, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format); +} + +// Get OpenGL internal formats and data type from raylib PixelFormat +void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType) +{ + *glInternalFormat = 0; + *glFormat = 0; + *glType = 0; + + switch (format) + { + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + #if !defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_ES3) + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F_EXT; *glFormat = GL_RED_EXT; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F_EXT; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F_EXT; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F_EXT; *glFormat = GL_RED_EXT; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F_EXT; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F_EXT; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #else + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + #if defined(GRAPHICS_API_OPENGL_21) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_ARB; break; + #else // defined(GRAPHICS_API_OPENGL_ES2) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + #endif + #endif + #endif + #elif defined(GRAPHICS_API_OPENGL_33) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F; *glFormat = GL_RED; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #endif + #if !defined(GRAPHICS_API_OPENGL_11) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + #endif + default: TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break; + } +} + +// Unload texture from GPU memory +void rlUnloadTexture(unsigned int id) +{ + glDeleteTextures(1, &id); +} + +// Generate mipmap data for selected texture +// NOTE: Only supports GPU mipmap generation +void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_2D, id); + + // Check if texture is power-of-two (POT) + bool texIsPOT = false; + + if (((width > 0) && ((width & (width - 1)) == 0)) && + ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true; + + if ((texIsPOT) || (RLGL.ExtSupported.texNPOT)) + { + //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE + glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically + + #define MIN(a,b) (((a)<(b))? (a):(b)) + #define MAX(a,b) (((a)>(b))? (a):(b)) + + *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2)); + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id); + + glBindTexture(GL_TEXTURE_2D, 0); +#else + TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id); +#endif +} + + +// Read texture pixel data +void *rlReadTexturePixels(unsigned int id, int width, int height, int format) +{ + void *pixels = NULL; + +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + glBindTexture(GL_TEXTURE_2D, id); + + // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0) + // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE + //int width, height, format; + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); + + // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding. + // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting. + // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.) + // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.) + glPixelStorei(GL_PACK_ALIGNMENT, 1); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + unsigned int size = rlGetPixelDataSize(width, height, format); + + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + pixels = RL_MALLOC(size); + glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format); + + glBindTexture(GL_TEXTURE_2D, 0); +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + // glGetTexImage() is not available on OpenGL ES 2.0 + // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id. + // Two possible Options: + // 1 - Bind texture to color fbo attachment and glReadPixels() + // 2 - Create an fbo, activate it, render quad with texture, glReadPixels() + // We are using Option 1, just need to care for texture format on retrieval + // NOTE: This behaviour could be conditioned by graphic driver... + unsigned int fboId = rlLoadFramebuffer(width, height); + + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + glBindTexture(GL_TEXTURE_2D, 0); + + // Attach our texture to FBO + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0); + + // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format + pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)); + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + // Clean up temporal fbo + rlUnloadFramebuffer(fboId); +#endif + + return pixels; +} + +// Read screen pixel data (color buffer) +unsigned char *rlReadScreenPixels(int width, int height) +{ + unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char)); + + // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer + // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly! + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData); + + // Flip image vertically! + unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char)); + + for (int y = height - 1; y >= 0; y--) + { + for (int x = 0; x < (width*4); x++) + { + imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line + + // Set alpha component value to 255 (no trasparent image retrieval) + // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! + if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255; + } + } + + RL_FREE(screenData); + + return imgData; // NOTE: image data should be freed +} + +// Framebuffer management (fbo) +//----------------------------------------------------------------------------------------- +// Load a framebuffer to be used for rendering +// NOTE: No textures attached +unsigned int rlLoadFramebuffer(int width, int height) +{ + unsigned int fboId = 0; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glGenFramebuffers(1, &fboId); // Create the framebuffer object + glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer +#endif + + return fboId; +} + +// Attach color buffer texture to an fbo (unloads previous attachment) +// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture +void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + + switch (attachType) + { + case RL_ATTACHMENT_COLOR_CHANNEL0: + case RL_ATTACHMENT_COLOR_CHANNEL1: + case RL_ATTACHMENT_COLOR_CHANNEL2: + case RL_ATTACHMENT_COLOR_CHANNEL3: + case RL_ATTACHMENT_COLOR_CHANNEL4: + case RL_ATTACHMENT_COLOR_CHANNEL5: + case RL_ATTACHMENT_COLOR_CHANNEL6: + case RL_ATTACHMENT_COLOR_CHANNEL7: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId); + else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel); + + } break; + case RL_ATTACHMENT_DEPTH: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + case RL_ATTACHMENT_STENCIL: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + default: break; + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Verify render texture is complete +bool rlFramebufferComplete(unsigned int id) +{ + bool result = false; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); + + GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); + + if (status != GL_FRAMEBUFFER_COMPLETE) + { + switch (status) + { + case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break; + case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break; +#if defined(GRAPHICS_API_OPENGL_ES2) + case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break; +#endif + case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break; + default: break; + } + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + result = (status == GL_FRAMEBUFFER_COMPLETE); +#endif + + return result; +} + +// Unload framebuffer from GPU memory +// NOTE: All attached textures/cubemaps/renderbuffers are also deleted +void rlUnloadFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + // Query depth attachment to automatically delete texture/renderbuffer + int depthType = 0, depthId = 0; + glBindFramebuffer(GL_FRAMEBUFFER, id); // Bind framebuffer to query depth texture type + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType); + + // TODO: Review warning retrieving object name in WebGL + // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name + // https://registry.khronos.org/webgl/specs/latest/1.0/ + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId); + + unsigned int depthIdU = (unsigned int)depthId; + if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU); + else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU); + + // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer, + // the texture image is automatically detached from the currently bound framebuffer. + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glDeleteFramebuffers(1, &id); + + TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id); +#endif +} + +// Vertex data management +//----------------------------------------------------------------------------------------- +// Load a new attributes buffer +unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Load a new attributes element buffer +unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Enable vertex buffer (VBO) +void rlEnableVertexBuffer(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer (VBO) +void rlDisableVertexBuffer(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, 0); +#endif +} + +// Enable vertex buffer element (VBO element) +void rlEnableVertexBufferElement(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer element (VBO element) +void rlDisableVertexBufferElement(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +#endif +} + +// Update vertex buffer with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Update vertex buffer elements with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Enable vertex array object (VAO) +bool rlEnableVertexArray(unsigned int vaoId) +{ + bool result = false; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(vaoId); + result = true; + } +#endif + return result; +} + +// Disable vertex array object (VAO) +void rlDisableVertexArray(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) glBindVertexArray(0); +#endif +} + +// Enable vertex attribute index +void rlEnableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glEnableVertexAttribArray(index); +#endif +} + +// Disable vertex attribute index +void rlDisableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDisableVertexAttribArray(index); +#endif +} + +// Draw vertex array +void rlDrawVertexArray(int offset, int count) +{ + glDrawArrays(GL_TRIANGLES, offset, count); +} + +// Draw vertex array elements +void rlDrawVertexArrayElements(int offset, int count, const void *buffer) +{ + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; + + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr); +} + +// Draw vertex array instanced +void rlDrawVertexArrayInstanced(int offset, int count, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances); +#endif +} + +// Draw vertex array elements instanced +void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; + + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr, instances); +#endif +} + +#if defined(GRAPHICS_API_OPENGL_11) +// Enable vertex state pointer +void rlEnableStatePointer(int vertexAttribType, void *buffer) +{ + if (buffer != NULL) glEnableClientState(vertexAttribType); + switch (vertexAttribType) + { + case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break; + case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break; + case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break; + case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break; + //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors + default: break; + } +} + +// Disable vertex state pointer +void rlDisableStatePointer(int vertexAttribType) +{ + glDisableClientState(vertexAttribType); +} +#endif + +// Load vertex array object (VAO) +unsigned int rlLoadVertexArray(void) +{ + unsigned int vaoId = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glGenVertexArrays(1, &vaoId); + } +#endif + return vaoId; +} + +// Set vertex attribute +void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribPointer(index, compSize, type, normalized, stride, pointer); +#endif +} + +// Set vertex attribute divisor +void rlSetVertexAttributeDivisor(unsigned int index, int divisor) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribDivisor(index, divisor); +#endif +} + +// Unload vertex array object (VAO) +void rlUnloadVertexArray(unsigned int vaoId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(0); + glDeleteVertexArrays(1, &vaoId); + TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId); + } +#endif +} + +// Unload vertex buffer (VBO) +void rlUnloadVertexBuffer(unsigned int vboId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteBuffers(1, &vboId); + //TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)"); +#endif +} + +// Shaders management +//----------------------------------------------------------------------------------------------- +// Load shader from code strings +// NOTE: If shader string is NULL, using default vertex/fragment shaders +unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int vertexShaderId = 0; + unsigned int fragmentShaderId = 0; + + // Compile vertex shader (if provided) + if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER); + // In case no vertex shader was provided or compilation failed, we use default vertex shader + if (vertexShaderId == 0) vertexShaderId = RLGL.State.defaultVShaderId; + + // Compile fragment shader (if provided) + if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER); + // In case no fragment shader was provided or compilation failed, we use default fragment shader + if (fragmentShaderId == 0) fragmentShaderId = RLGL.State.defaultFShaderId; + + // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id + if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId; + else + { + // One of or both shader are new, we need to compile a new shader program + id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId); + + // We can detach and delete vertex/fragment shaders (if not default ones) + // NOTE: We detach shader before deletion to make sure memory is freed + if (vertexShaderId != RLGL.State.defaultVShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, vertexShaderId); + glDeleteShader(vertexShaderId); + } + if (fragmentShaderId != RLGL.State.defaultFShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, fragmentShaderId); + glDeleteShader(fragmentShaderId); + } + + // In case shader program loading failed, we assign default shader + if (id == 0) + { + // In case shader loading fails, we return the default shader + TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader"); + id = RLGL.State.defaultShaderId; + } + /* + else + { + // Get available shader uniforms + // NOTE: This information is useful for debug... + int uniformCount = -1; + glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount); + + for (int i = 0; i < uniformCount; i++) + { + int namelen = -1; + int num = -1; + char name[256] = { 0 }; // Assume no variable names longer than 256 + GLenum type = GL_ZERO; + + // Get the name of the uniforms + glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name); + + name[namelen] = 0; + TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name)); + } + } + */ + } +#endif + + return id; +} + +// Compile custom shader and return shader id +unsigned int rlCompileShader(const char *shaderCode, int type) +{ + unsigned int shader = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + shader = glCreateShader(type); + glShaderSource(shader, 1, &shaderCode, NULL); + + GLint success = 0; + glCompileShader(shader); + glGetShaderiv(shader, GL_COMPILE_STATUS, &success); + + if (success == GL_FALSE) + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break; + #endif + default: break; + } + + int maxLength = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetShaderInfoLog(shader, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log); + RL_FREE(log); + } + } + else + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break; + #endif + default: break; + } + } +#endif + + return shader; +} + +// Load custom shader strings and return program id +unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + GLint success = 0; + program = glCreateProgram(); + + glAttachShader(program, vShaderId); + glAttachShader(program, fShaderId); + + // NOTE: Default attribute shader locations must be Bound before linking + glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION); + glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD); + glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL); + glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR); + glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT); + glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2); + + // NOTE: If some attrib name is no found on the shader, it locations becomes -1 + + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program); + } +#endif + return program; +} + +// Unload shader program +void rlUnloadShaderProgram(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteProgram(id); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id); +#endif +} + +// Get shader location uniform +int rlGetLocationUniform(unsigned int shaderId, const char *uniformName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetUniformLocation(shaderId, uniformName); + + //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName); + //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location); +#endif + return location; +} + +// Get shader location attribute +int rlGetLocationAttrib(unsigned int shaderId, const char *attribName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetAttribLocation(shaderId, attribName); + + //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName); + //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location); +#endif + return location; +} + +// Set shader value uniform +void rlSetUniform(int locIndex, const void *value, int uniformType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (uniformType) + { + case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized"); + } +#endif +} + +// Set shader value attribute +void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (attribType) + { + case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized"); + } +#endif +} + +// Set shader value uniform matrix +void rlSetUniformMatrix(int locIndex, Matrix mat) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + float matfloat[16] = { + mat.m0, mat.m1, mat.m2, mat.m3, + mat.m4, mat.m5, mat.m6, mat.m7, + mat.m8, mat.m9, mat.m10, mat.m11, + mat.m12, mat.m13, mat.m14, mat.m15 + }; + glUniformMatrix4fv(locIndex, 1, false, matfloat); +#endif +} + +// Set shader value uniform sampler +void rlSetUniformSampler(int locIndex, unsigned int textureId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Check if texture is already active + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL.State.activeTextureId[i] == textureId) return; + + // Register a new active texture for the internal batch system + // NOTE: Default texture is always activated as GL_TEXTURE0 + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] == 0) + { + glUniform1i(locIndex, 1 + i); // Activate new texture unit + RLGL.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing + break; + } + } +#endif +} + +// Set shader currently active (id and locations) +void rlSetShader(unsigned int id, int *locs) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.State.currentShaderId != id) + { + rlDrawRenderBatch(RLGL.currentBatch); + RLGL.State.currentShaderId = id; + RLGL.State.currentShaderLocs = locs; + } +#endif +} + +// Load compute shader program +unsigned int rlLoadComputeShaderProgram(unsigned int shaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + GLint success = 0; + program = glCreateProgram(); + glAttachShader(program, shaderId); + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program); + } +#endif + + return program; +} + +// Dispatch compute shader (equivalent to *draw* for graphics pilepine) +void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDispatchCompute(groupX, groupY, groupZ); +#endif +} + +// Load shader storage buffer object (SSBO) +unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint) +{ + unsigned int ssbo = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glGenBuffers(1, &ssbo); + glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo); + glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY); + if (data == NULL) glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL); // Clear buffer data to 0 + glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); +#endif + + return ssbo; +} + +// Unload shader storage buffer object (SSBO) +void rlUnloadShaderBuffer(unsigned int ssboId) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDeleteBuffers(1, &ssboId); +#endif +} + +// Update SSBO buffer data +void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data); +#endif +} + +// Get SSBO buffer size +unsigned int rlGetShaderBufferSize(unsigned int id) +{ + long long size = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size); +#endif + + return (size > 0)? (unsigned int)size : 0; +} + +// Read SSBO buffer data (GPU->CPU) +void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest); +#endif +} + +// Bind SSBO buffer +void rlBindShaderBuffer(unsigned int id, unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id); +#endif +} + +// Copy SSBO buffer data +void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_COPY_READ_BUFFER, srcId); + glBindBuffer(GL_COPY_WRITE_BUFFER, destId); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count); +#endif +} + +// Bind image texture +void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly) +{ +#if defined(GRAPHICS_API_OPENGL_43) + unsigned int glInternalFormat = 0, glFormat = 0, glType = 0; + + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + glBindImageTexture(index, id, 0, 0, 0, readonly? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat); +#endif +} + +// Matrix state management +//----------------------------------------------------------------------------------------- +// Get internal modelview matrix +Matrix rlGetMatrixModelview(void) +{ + Matrix matrix = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_MODELVIEW_MATRIX, mat); + matrix.m0 = mat[0]; + matrix.m1 = mat[1]; + matrix.m2 = mat[2]; + matrix.m3 = mat[3]; + matrix.m4 = mat[4]; + matrix.m5 = mat[5]; + matrix.m6 = mat[6]; + matrix.m7 = mat[7]; + matrix.m8 = mat[8]; + matrix.m9 = mat[9]; + matrix.m10 = mat[10]; + matrix.m11 = mat[11]; + matrix.m12 = mat[12]; + matrix.m13 = mat[13]; + matrix.m14 = mat[14]; + matrix.m15 = mat[15]; +#else + matrix = RLGL.State.modelview; +#endif + return matrix; +} + +// Get internal projection matrix +Matrix rlGetMatrixProjection(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_PROJECTION_MATRIX,mat); + Matrix m; + m.m0 = mat[0]; + m.m1 = mat[1]; + m.m2 = mat[2]; + m.m3 = mat[3]; + m.m4 = mat[4]; + m.m5 = mat[5]; + m.m6 = mat[6]; + m.m7 = mat[7]; + m.m8 = mat[8]; + m.m9 = mat[9]; + m.m10 = mat[10]; + m.m11 = mat[11]; + m.m12 = mat[12]; + m.m13 = mat[13]; + m.m14 = mat[14]; + m.m15 = mat[15]; + return m; +#else + return RLGL.State.projection; +#endif +} + +// Get internal accumulated transform matrix +Matrix rlGetMatrixTransform(void) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // TODO: Consider possible transform matrices in the RLGL.State.stack + // Is this the right order? or should we start with the first stored matrix instead of the last one? + //Matrix matStackTransform = rlMatrixIdentity(); + //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform); + mat = RLGL.State.transform; +#endif + return mat; +} + +// Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixProjectionStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.projectionStereo[eye]; +#endif + return mat; +} + +// Get internal view offset matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.viewOffsetStereo[eye]; +#endif + return mat; +} + +// Set a custom modelview matrix (replaces internal modelview matrix) +void rlSetMatrixModelview(Matrix view) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.modelview = view; +#endif +} + +// Set a custom projection matrix (replaces internal projection matrix) +void rlSetMatrixProjection(Matrix projection) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projection = projection; +#endif +} + +// Set eyes projection matrices for stereo rendering +void rlSetMatrixProjectionStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projectionStereo[0] = right; + RLGL.State.projectionStereo[1] = left; +#endif +} + +// Set eyes view offsets matrices for stereo rendering +void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.viewOffsetStereo[0] = right; + RLGL.State.viewOffsetStereo[1] = left; +#endif +} + +// Load and draw a quad in NDC +void rlLoadDrawQuad(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int quadVAO = 0; + unsigned int quadVBO = 0; + + float vertices[] = { + // Positions Texcoords + -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &quadVAO); + glBindVertexArray(quadVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &quadVBO); + glBindBuffer(GL_ARRAY_BUFFER, quadVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, texcoords) + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords + + // Draw quad + glBindVertexArray(quadVAO); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + glBindVertexArray(0); + + // Delete buffers (VBO and VAO) + glDeleteBuffers(1, &quadVBO); + glDeleteVertexArrays(1, &quadVAO); +#endif +} + +// Load and draw a cube in NDC +void rlLoadDrawCube(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int cubeVAO = 0; + unsigned int cubeVBO = 0; + + float vertices[] = { + // Positions Normals Texcoords + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &cubeVAO); + glBindVertexArray(cubeVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &cubeVBO); + glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, normals, texcoords) + glBindVertexArray(cubeVAO); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + + // Draw cube + glBindVertexArray(cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); + glBindVertexArray(0); + + // Delete VBO and VAO + glDeleteBuffers(1, &cubeVBO); + glDeleteVertexArrays(1, &cubeVAO); +#endif +} + +// Get name string for pixel format +const char *rlGetPixelFormatName(unsigned int format) +{ + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break; // 8 bit per pixel (no alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break; // 8*2 bpp (2 channels) + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break; // 16 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break; // 24 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break; // 16 bpp (1 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break; // 16 bpp (4 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break; // 32 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break; // 32 bpp (1 channel - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break; // 32*3 bpp (3 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break; // 32*4 bpp (4 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: return "R16"; break; // 16 bpp (1 channel - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: return "R16G16B16"; break; // 16*3 bpp (3 channels - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: return "R16G16B16A16"; break; // 16*4 bpp (4 channels - half float) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break; // 4 bpp (no alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break; // 4 bpp (1 bit alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break; // 2 bpp + default: return "UNKNOWN"; break; + } +} + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Load default shader (just vertex positioning and texture coloring) +// NOTE: This shader program is used for internal buffers +// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlLoadShaderDefault(void) +{ + RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int)); + + // NOTE: All locations must be reseted to -1 (no location) + for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1; + + // Vertex shader directly defined, no external file required + const char *defaultVShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec3 vertexPosition; \n" + "in vec2 vertexTexCoord; \n" + "in vec4 vertexColor; \n" + "out vec2 fragTexCoord; \n" + "out vec4 fragColor; \n" +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) (on some browsers) + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#endif + "uniform mat4 mvp; \n" + "void main() \n" + "{ \n" + " fragTexCoord = vertexTexCoord; \n" + " fragColor = vertexColor; \n" + " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" + "} \n"; + + // Fragment shader directly defined, no external file required + const char *defaultFShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec2 fragTexCoord; \n" + "in vec4 fragColor; \n" + "out vec4 finalColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture(texture0, fragTexCoord); \n" + " finalColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif + + // NOTE: Compiled vertex/fragment shaders are not deleted, + // they are kept for re-use as default shaders in case some shader loading fails + RLGL.State.defaultVShaderId = rlCompileShader(defaultVShaderCode, GL_VERTEX_SHADER); // Compile default vertex shader + RLGL.State.defaultFShaderId = rlCompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER); // Compile default fragment shader + + RLGL.State.defaultShaderId = rlLoadShaderProgram(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId); + + if (RLGL.State.defaultShaderId > 0) + { + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId); + + // Set default shader locations: attributes locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexPosition"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexTexCoord"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexColor"); + + // Set default shader locations: uniform locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(RLGL.State.defaultShaderId, "mvp"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "colDiffuse"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "texture0"); + } + else TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId); +} + +// Unload default shader +// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlUnloadShaderDefault(void) +{ + glUseProgram(0); + + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId); + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId); + glDeleteShader(RLGL.State.defaultVShaderId); + glDeleteShader(RLGL.State.defaultFShaderId); + + glDeleteProgram(RLGL.State.defaultShaderId); + + RL_FREE(RLGL.State.defaultShaderLocs); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId); +} + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +// Get compressed format official GL identifier name +static const char *rlGetCompressedFormatName(int format) +{ + switch (format) + { + // GL_EXT_texture_compression_s3tc + case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break; + case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break; + case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break; + case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break; + // GL_3DFX_texture_compression_FXT1 + case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break; + case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break; + // GL_IMG_texture_compression_pvrtc + case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break; + case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break; + case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break; + case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break; + // GL_OES_compressed_ETC1_RGB8_texture + case 0x8D64: return "GL_ETC1_RGB8_OES"; break; + // GL_ARB_texture_compression_rgtc + case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break; + case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break; + case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break; + case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break; + // GL_ARB_texture_compression_bptc + case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break; + case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break; + case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break; + case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break; + // GL_ARB_ES3_compatibility + case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break; + case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break; + case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break; + case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break; + case 0x9270: return "GL_COMPRESSED_R11_EAC"; break; + case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break; + case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break; + case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break; + // GL_KHR_texture_compression_astc_hdr + case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break; + case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break; + case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break; + case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break; + case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break; + case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break; + case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break; + case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break; + case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break; + case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break; + case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break; + case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break; + case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break; + case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break; + case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break; + case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break; + case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break; + case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break; + case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break; + case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break; + case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break; + case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break; + case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break; + case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break; + case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break; + case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break; + case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break; + case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break; + default: return "GL_COMPRESSED_UNKNOWN"; break; + } +} +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +// Get pixel data size in bytes (image or texture) +// NOTE: Size depends on pixel format +static int rlGetPixelDataSize(int width, int height, int format) +{ + int dataSize = 0; // Size in bytes + int bpp = 0; // Bits per pixel + + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: bpp = 16*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: bpp = 16*4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break; + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break; + default: break; + } + + dataSize = width*height*bpp/8; // Total data size in bytes + + // Most compressed formats works on 4x4 blocks, + // if texture is smaller, minimum dataSize is 8 or 16 + if ((width < 4) && (height < 4)) + { + if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8; + else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16; + } + + return dataSize; +} + +// Auxiliar math functions + +// Get identity matrix +static Matrix rlMatrixIdentity(void) +{ + Matrix result = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +static Matrix rlMatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +#endif // RLGL_IMPLEMENTATION diff --git a/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.a b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.a new file mode 100644 index 0000000000000000000000000000000000000000..69791ca5d2a3bf4a5231d9ef76803817601e6d99 GIT binary patch literal 2908626 zcmeFa4V2tRbtl?m53y_p#jBG_SvQ0u>r)Q>T z)VODQ=nqN5bFj4|1D#>W$C5|h9`@_KbKdUB?uLDb#A_2LXe>a6u*5bYA&^Z7%ZF_7 z%>#@v*8AOi>*H4a>)#^-2_dx4v8La?n>Q?>#;Z3#n+>w`D_M&UT|E^a_ z`K|xG=9(SXUw`9`HxSV;T~;VOuTvQLm7gE}Kh(j{28K2;w1J@w3~gX&14A1a+Q85T zhBh#?fuRiyZD42vLmL>{z|aPUHZZh-p$!aeU}ytF8+aBraOuqdQTT5D|FYdr6^8#0 zbuhF6Zv(}59WDHQ`~Qlc`i;Uj{eSBXg)4^t4|OoKfuRk2huOeYomUlx{||NWcijel z^vdrk4F4bMU}ytF8yMQa&<2J!FtmZ84Ge8yXahqV7}~(l28K2;w1J@w3~gX&1K)8r zuz#vluI`_z-ZpV)dh*s=synLJ7Z#hf`RZbGPqV%}zpuAEX90Vg^;$bf>}@q$A*5Vi z=^hDarn~j!xkl5$D9eFb=S~OcHJkftb9I|$4!T$d=o}0bO;c6}iWYB*2}WlT3- z<(leXtGT+^T0YR4cc4S{+I-l01Y!Oi%V&D7(dl@78ynMBV?f$&49LrD)xD!^`C7rEJ#DblIBjLuYQw`;2bWTIJLsxNmPY=3<@&Isc@NX@NmezFr) z$Ta`03k#jPvpvvQ;d~_(5E5tAw$rLDs`t2SNva5s8nNtP%_{PwsxSbvg^k<7N^{-D zQL8cw+}m1OY1ccQIyGNL`7zGxKby}>6yUPjNuqN&+uWWxS}I_`GTYir*OpeA^}Vg5 z^)`)6S!L|9lssVsQvyRKUfHX48?EJljJoP{eFcMB*ID<0UbEZCnwta1?Z(#S`=R9@ zfnA>q;jV*5;G>BezSy$fQ(tT>|6H%$UUd+3(r~bnRJqozIU1gdpmq(E&L+gJ7YUFG zXw)5WVtGC&5?w9I21t|#Eh;olJ${(?xTtqJL?kNUEWoX^uc(u~+j@oYUKZgYlN}Mq zW}WN=RXR{x3Gs)QmmDazxSifbDRsNGxg*m@YV&@or(qNDc4Ky`HJ3F!YmKq-Q3q%= z>mjeb?KrWHE+Q0QOqi9pEZ)m)^>(*@Ttw#q*A_@!B5HA&oO5%a zWn^R$ZkCY)A6{-OwA!vl1ZPdw=S5m)dxA;m5(rb<$>oI>d;wL4LHO1OvGC2(3VgcN zYkLpSkp~=%%yFZF*kA(3$iM;)T3y`h)yxDo8a=O#TqA-)G{ToO*@^66vJ=_>T&X)F zl9U>hQxhAja&B@^x30tpqmdoXiE#i|R||1tqXWbwJ7X?8y<$wJoiUf4UPXpvJmxZ< z;W8d`8P9Op6?55@;j$~{vMa;oKn+92@oY5&o)t{sx~NV(P~28)Hs-VAhqjs>&c6~7Q-8l7DF{u08WZA zo)%-*EwjnG?7GEUjb^^`|9=i+1i}jNFm2Z+=M-~j&rI# zG}tjA@IE;7D(u5A#7#=4ZY75wTti}Q=eEY7bSv$(0+syA3H zOcaIF4!~MK4NoZ(jxSuSQXgnz+*ETbB(IA0RT~8(y9ez%~AYa+QLY$kj!pf z$XW}X&L%s0uANaPRP9J7ywsrp`{ggldyBf#M~9hc_N9+Z;UxU{$X?4LVyh`rFZS755Nl zP6o6yLj*`nG@c;>BqrLGAp*n^1&y@B2^N8K$UWzfK99fm&jWhprHAkw{#p}32Jg8? z;I#ZoeIb3G{JYYw&!qSD13t>*58-LwVsclGlLAD#VR9RCSC0EKndiTZd;f(tGiCCN z_GJ7v+2nGkTU(y1JC~18cB?Fd#NZ-31ID!XG+T3b-hx@$_Om2`H_;e9C~GIkrVE^e zS94sIXm9{G=KRLj!FFQ_e$dhSp*pJA?gqKg@kKF~jpk3T3JsT8Ps?u;HyarIZ?84F z)2sf7%WTx- zV9n%p!>(}pa$rrXhFb6Og9nM?+Yeh9N++2e*=%*Nzj3s6C)yy?muw~no);>|`^`Jc zN))SKiyTiOUE^h&dE7Ec`MGRIzP}KO$mNa;jT!I+)OJ$_{18K@K+fL?tP={PEIm6#IY&eN$uxf0iCKGvG=CC~@WYD&PvpQq>_O^O-bYo#LZzWg;rKE~+ZU-ZS za5foZ+-RFYxGZ`=FE@@h)XAVm9aNKj3{Ubps3!g(L*Ar!FlQDcc)Em~+2kP4Cb3=b ziWZ98Pzh_!I6t-(gYy`>LFg15U_+=ruE}B?MEXspc-LL@tTo?g<21oa77nCYT!yF4 zm_fn~ulo&qdw>#Y3f(!A(MgK#B=aQZ-FBO%A8o4Rw^ALzbvXm^+nf#%llU!2L!x#c4P=+|v>YJjV)mQ73Js;( zhswpMJ-Q%IRt&d4mBVZNcpk4@_;I!48Sxt!)@=!tl_?(9Q`_+(AxLbwupX3^l_Gq}<*UgWVy zuaStL(Ba}3pb%s@px#)~+p798z$zhoP!<&(4hKfHbwtHr+i)K?2WxI*1#>-jP5Fj& z2UWIID^F5LD}aqd@|{3u3s_oBIq72@Zj1W1sP^WZJhP+y64=K#z z$J-d5Qwx8f5oO4$h2JuWGUQp5^4g*tYAOvenJFQO&XX`PaU}EW6OJ^28vJtz2Fsu( zf>eHW!jeSmDJF+ti}Llfmgb<&Wl{uNXke?{Th$;q{YjRuC(|4PuY*H%#GZCcT#5-& z@vAZkgAC_16B`*#Xd%?~90@!Kr=!E}B%57QH;G2)+3~Cq%rbr&h`_Go0Pe@z2%IMO z16x3@Y%_rS5hMbqx!Zj?69;W$HA5|1s8O>U{$qH`Gjf|y6fN;1CSJnH<)bD7NQ_)tM~sV%#G{qA zZPh#yxd!54^g%4I&q>|EM21_oZdaEFx=w5`4sG|aV}eA>rknL(YlW?AKQ>m}aqdA} z!pK5RT$~&j@>vD-Pqop2dWdp^(?;Lf^LCZZn33F9MsC_}r;*(1M$a3O1R52tyfkJq zA2pRinL_MtrX8?KhxSw_rgv87(AP0E&NdKavFe61!Q%KR!kdXK7(e%{9zrw;qOwEQ zILZsM&(e*d>H=-4%j*M(%T@u_WsK<7727B`3i55C<=gF#5)M-^z*@Nl(O$FeD`8gde7Kb$3y zVX<)+fj)yEyv&*~+y&2~wZ2pbgO6E1UY|!K!(f6uw1<1wH@2*_TOLzI7L6!3W$t!( z4WU8*Rn)pb1-2fL8LBlVTv;+kbq!jCi*Z{y@+sU{7Lzy=a*M#2f^OjsE=G66JW-6r zZh;P>NLdigJEf@vJ{?a&Ju0k*5lMhSqYda@8I!T`FrfnE@oxczlPDZ6|DQ zHN40qonFxSSvs{o<2ABmPcQ9!_T>7G^GAz3)A5yjW~rSkzmQ%Kx)UrQ<}qZLg@qdt z{4mnVIP!|T%Bwuv5JAj{izrd6gn*zCBZ9b+6q0iUYa9{F!`0`vcz`DV!eeI zMB1xn(_)wH!^)K~gSAp&7D=z83?$&mTTvJ#JG0I7>BYM1HPu;(jL_90bXPWcs-51f z+4yk%C49R;ubyoMy*q2Cr(m#HY*srf4gWIB^a=tguygw=bLvJ_3FKMn85LF+R&Lmp zhifc%f%IaUKnPlTDCIylgWy#~h*{3fV=-|iqid6I2MSXhvq&vTgeA`Tc?Xxfb5LGF z=9i0Th5_X=Hb3+DpuB_}kab|Wh)x)kdDozF37KCmLJ0=cm$5o?x?vSGMI04jspC2s zc+_|bn&2Hbm!;0(9W{`lj$6ip({g9p!jMOepr8r4W3^jqC%5kK&RwY1$gOi8lkwE} zu?e$NPdz5gs?Rd3ujIEwwj$UWu)v)+yEzTVSUtglvZ_n;W(p0O?nsvW4e!aw-=Y1E2&2s>MCmy`!sKVtPH>nhaF{}rb_OF%Zb>_H z>x3{irKW)2&fGd7lr1+?Zk-U$mYXTJPIw+5FVlE#oe=zyn<=+W2v^F@lv^hRx8-Ka ztrOlF$jcP?n?YkBR4F%8Zk-Uol$$BHPS{|}&6Haw-0!DMdN^y%&EYvcoGY54&bUAR z;UraxgzVDhDYo(z+{WuG5LQK5I=D`}^J=zqbp=8cwq^oek}Uw52Z@MGS4T#sYSX+V zuj={7fDAh!Tqi zin_tcFyHG5M`=056vrBs#q*CHddV+Tg|Lxzg;RuV<4X%D9n)!qdre8h`6$SEn%P{8 zl{5bgQmiEbrU#WWU>Jam`(|QSG7!qVb|l%f?EzV-EzdXg3I{L~j~#N6+-_MDv@P;P z=)l~7mTJn&M^Ob z6p%@c91IuIW2q}6*39~lt!x|xb$<*f)h67_9+5VdF^c;aIfLFjDL7?O(ldE9^V=7G z-FqR3z-}iy=`0acSG7yeEjF7x$fja4jKj!rF?7&QfiFhF;NX-!;T>gFxh#6;VDxw{ z+HOAN^S2cFMOccU6pSWWF=K16Dp(@7SLU_AS}fj}ONeVM)!T{1OP6-)S6bMEMW800 z&$2q5!W6<=^n??m)_z+8tvevOKm&3o(41S_Lr>oD8DR6WX-r#bc-@W{P&B1#9)@Bz z2tTs^3>Gu8$Wo>v06N{v0MTp_Tsn_EAPf z?H=z?F!dHAK@%!k33t5n-ZNA@gLnvT0y$6te?M^O<#oDdnj&zOp%IM>hT#Yo3_Uti zup|r-TKNG+n{kN9&7!@JAWN`d(3qXNFNKJ_Qi4f1$P%a~z~l)QuFiCpU~v{A@&pU! z@*qpDVB>j$g-a~Wj9zq8))%634S?Qt%gxoB9e^5;Z9r*wCnS$&zW8~z5H1~q8s`~l z=ywEJ@}U6 z^mr5=t4FlC+`wAGNQ|C4j98&J&s{jHW;0LE;M>_pLQ1pfIeP3YkWI3gnK;1Imyhrx zFYwV;5#Sjv-|EL#nvJ1Op}(b0W(Jiao`yo zjh{0|TT~s5nI70LYaL7TAr};vI<%5pe!;;h#a1eWzB8tBM`N8s`@{KZ(Vf)1ILLGa zmrJVLELCp9Jmk^r$#S&85pLD4m^;iI^4jQh8*`n6*TkE^);Ln`INmO3!bz>p^=8Sl z3T>pLv9ve5f(A&Lj8R*-?yt61!j?2tv#=h#K-1!l1>Fh;KbKLwZ54__mf+?@HtSS2 zTVW(PWe!#xJFdSzXoL*GuASGf&|`;jApsYnh}}3o+LL&6a{I&DTlr>T>`-I2M>+!S z1ydQx~wfRt47Pru7q6buK_;^JNSA$j>b4eD4Y^i}a zw2!ALu*Ks)JwScc7O~Wz&sc~as@+z#J|CSogoO3^YP-IIH?ot(EMpgNrF9GcSWFX%8l!{3j*wP8cA|o@S3BcfZzP&% zfGue?KoIm|3rq$CDg3_HBA+T5&m@7FPr;5R zfD0*@CXC)$Rpf(1A{8O&Z=bi$2&363RQe%TMIb9&#kZ3|YStR7GHDW(Us23RXvmK8 zK=jVR=y8q48eH+$f&rriicsp6QY8xvP;ry3=jh?lkXo1Ec9$Ev&4V{ORp#)SPKD4c zO?0QimgeSqOUKc0fg>*@msnY%9mX-EE$@nCm=_a;9S724AHLRA<^>DRugYJwU(WF!z>BBX21gTDZ0)^XF_t8oCDP? z9P!R1@y4r@UYs9g5R=os=v!Bt6W=EDxqi+POz|-X~ zWO!{x6jP1GBV8>hIAN)6ur}cLw;S^@ z4Z$M1Y_mWZX(}x`?aXGSOzhVNQUzfc12Az(E_NdnR$t@`uS%OUA z2y+X)T+j@PuprI*)^_(uOV{{dt<#w~g6pD-M*=YIGf)Sx_Rl?n#&Q3ODudV<@Y%ae z=AUo1f&rc#leEb*iY}uDOyo0d@|~^#(QdTbc%=1J_9IvwjXeaH5IZofPS8XOs66n|c@-J~}L1ON9gEyi*l?Evy{u-nco{0=di1uLrh+Y}l zi*J(BK9VENBBtRl*)Nw`dCeP3p(r8Hq+AtmM@XcxP7#5JUjs31t7uRvqB_inINMG5 zK{_cMrk7f+?h%4hTN)lA&=6v5uD4`qpeREqUVc^p$w(&c{dt?1o@>|L;Uxj-OCS7M zRFVUdb4%j(0OqX(#9kf(Ep^8UdO$)p?6{uj;(Th)oRmq)H%Vh?rA{6vSV2Px;t;Bd zO?Q}_FV`1p=;p#g%sdI4YRz>#ElDm4-9u0EAot(rjmIRPFdftYP0AJqd57|RrZVF&yMm&qcuP7|V@7|5MB0-{bD!e2_3KC8hfg`@L% zGIpiV+a3uj9o&zMC_!q>OIF@WS3tB3f8!J3Q3@){3an`~(38ppp>gB@$y&kTpxtb_ z4(OSI4cT!xh=PtM4>K7+qcAO4~rs~U!_%^ss3@5KC1Muc;%OZuE--qf8O?s!^CV4erQwQ)>ND@KYh6V(YxTDILRE9U!#wlUXe#2rEEWkKragVY@_3)4UU zGMiU=z7%N}-;#pmc5rzYZ-!bCWJxaAsaEUGlGBA%yKjD~W{?t9dyuPr78H{@4SG`3 zgFL{SsE3(m@BpV`50d)(wCO7zz-H=`w=`)y^Xcg*y|3L`GS)fMGCveKp+$iTIMd32 zh|c#IU))S91tsc<9wZ5vW+1ekv_PJR=Vxpl^YDJG`LRmsh{HW!nCut`nf@FOkPDbf z2Y?V3FV)p_07{?tc@H8U{z!(Bp^kJfrs;MKQ#Q>8#7_W+5xir6AL2Esz-i{N#2x}_ zpNPq4S~IowVjZ(S7xl8*G4tzSgO-{CJ=AJ8eTn3Hn09hfn4uHHox#YWN3sK1Sn4cP z7aI%JS^C{daJU~UV#_3yhsFLme-73|4z%F?wb}}R@34^X=kh?P5D=zrMWht%bvpWe ztvP&xg$-8(lv_|_N~SP=uUVy?RGvikVtm?cta!k|BdeVT+>w~j!ZR6YMuR~eqQ>=X z*d<0%B-Mflga^p-!AYtf9d^#P&?m`x=AID%(2&RW_S*Ets0w^U^K<%GZAEWqQN9`6 zfuO%;JgLCQ%RPLSl>7$iLUuSRpcm0wmnJ+vF_ zl(>gO@+b~cxPi=BtI+Wlq#y-w5QE?3G8XHsazy%Jsm9fE_9jVhX0j@DXh|Bhv;woD zFU^r2OsPU6!)2M#Gz=w0}&`z+yDwMI|l%h#`&#XibYpu^3Fh@eY=O z;uk~BvX2+PK1NYkp-0uVZ|&{!;( zeIS#|0Ete7Vo!n}aW8lv%tf$blX|a&8<00S?Cwt%Vzz!@8p4GgvD?U0R60tUi7%wF zi)$DS_pn3wlr?^v`B<(uMQPn^_zmpst#)&MrX@{3f#}N!lmSRKp`U4Sc7Pz6%=P;Y zPE!`%OSJ4NM8ph!qN(b!Sjgh;iLnXq7pmCN+aN2#Mdv@9S~Ka@+kw` zszWdfw5(LMj4)h$j9W^6p39Y3_an2SA+;3 z0H|7}93oL>xU5v(;*Z zgfd@RUqw6P5+_XtK5Z>1uiHiFm=o6!37DmfNR?0lt%w(ZELUGPEuNh3 zWoQXTD~KiXEGF?29ziUX0veeVL`kHeA`b)ZpxX1Vm$_fgKd~r8cy?A$DYd zp&tqi`7i=D>$C)fi2lqLv zN3f=@w|P^HnXtB4BfjR5E;IV_d175a^|-Pa>zC*aI6p&J{DM&z_lP}CJC7?Lcn8m>e_Mj6; zBhE3L?gP7w>yM=*XtP{aiYg!&5t#A@ADxVH+n!q?Wl!Fg&dBifurQA-c3 zu5=N!=PBu8=n|Hs8YV53g;Y~Ti4gWSyJyUoMwhB`oPfhT-1WoifF7U0i@eye_LL3U z>7xgM+wfEsT)uxK7rPT^DLBkVb6{28#BsHp?KPS>4&bLL+Z~y3J80>_FyPTJEnWa`0{hhy6?+UG#~482jWC zU>@dwm2hg|Q$%YQL{pe4m>U7jrsiaaA$rS>0R`D*;NLhR6b}Jmhz#J+T{t$9vYtPA zJE(FDK7<7ix?2pMh8@tube1K>nDWM#FunZ<9Hd*Q%Q_OA2}4IAY%ku5;@}3$hw55j zA^GYX@7a27u;6yz$XBH!Im&RwFhDsq9hBRvW-ErtEeKAXFGM!DA*aAZJB+3U0k1Vp z0XBJ?Pm|WdltPNfNhDT8a8SV8SXk4()T&&n2J&y&4Yy`6X;;X)(LFLC)+7PKtnzI( zIX5vW@^aB0CS@a5u|7ADeKHYv0Eak{t_*=)xtgR|dYKe2sLXF!gPH^ttC-w^Z9kl* z?t?E^;3k=AO=8{6KmCC{CrNV-G;gUZ)3?b_Lc7EaU03E@d)jmijHZF_PgfeT^V)6W zo{Xf}{M1k0uqPW~TKd6;At|Urr7VuN4f(XsS>z!c6|0V^f0wYggqpGePynI)@-`s| zY-0*SdWTCM;yGt;4IjERmNwHmc0X4UCPB(25+$0-Gi zh6!OyeFOc6S<-J`n8w&{qel*kVWb-;n8Mol=wZE!Pahts_uAN;#+HGG(#q=?eXWq5 zhcNCRvXBE)#rEH*=VI$)xu|%QoU(jx#g_y+9{z24&G5!pjI{vAhRw z=K?~Px=mQL;*LJ0lC;T5iXh!hLp<72L&5u-t1CzNhNv4+sCTXKTLo5G4#MY?CJUA! zHa{0lP0j^KSS9^Lv)#xRgVl>p-3)_R#nJ{?Rye->g1 zEqfyb!U+o876$G^G=o%y5HqdAKuLKsttooc!?gveR{0gAKA4VGEi=QYP@}$QMjqC% z3_POZ!!!GCH0o9AaX(Qy5fDrM0aZDijEzRgw@{U>qSg4%FgiE0IGQRBU@HV$B2+z) zsuUOG3gBjPDYp~vAQ+#HHn0KDHbDV)_z>n^vynkCRs^;_$i_5$x`qg#1l-b-Tq*h( z&Ov=BlW#Z|Yzp;RD$&*k{eZFCpZh2T#}>h6Z;aeXQqW>KLMqdmKL|N#2{|FN3-L1( zN_DZhaIC=pqP0w@10AEF%k+*5!bD8~h-irYhbPMlM{=47ggbWZ@Qftz1^fL8D2?XW zBcFz$)iqj<9HKlXZU9RrM~cSsP!1CJr8r!P0}K(6(rCGis3D(3$x?~tUX2o-N#Q8u zM9?n7A&Nih7(sBjjS69n>(D}N;wU2MZP@(8xs`)DnRV4UYgDEZocN@A>i(^#;h$D4avV)q; zbcE2|bMTKPNgi2NCBk_p@Ok@%|$36Mf5cmRx`vl3Q8eVe@n8`V};5l0+nn0 z-RHP?j{P!&M%bi~>EQgQX~`9MF9ySU zTPilWY#OK3uGfU68yv{;oC%R#ad*O?iS24_>h?UGIvVm|uTL0RxXgVX?qn8*Au-Ak z9@DE!vn|tTmXjIHW^nz7^CMx zqK4rb0S?pKukw-Vh&aahJei5j&J0d?H&_yo6G*kJc z88nEo>3o7?GWq7Y0?1DtnQkQ70wK}n0WC+T69f$?xo!JFS0TVrxCV11X^1%1R$IbM zIn|5+(|C>yq+z6E??gx$h!kMs-Gf?cpqagenq|Pa4ZF30`;^hnT^=L;kL%Y$HcP+f-0D+tL|n_<4Is_?v6!_aBR@nK~Hc9Qh6G~?nfGB#}y2zbhyve zbsSj_>3pV1(n#ADF*Y)r7%e*1b`nsK1HjI;>6nPJO(rRT6B}1t6(~!2R zus~vnb5A%W!;)}N00fLK&*K(`Lcj(fYM_6B$Q4b&;N)bCQq?7s#jXO=2=+x|l(@Yy zl-$$+X59@6)x_M(m4w2R;iqO`x+QIP+8be((2s@1omWW^qg1Y- zBEkMkV3M{F7sqNVWQ3@alL0`G?~9@wxZef zbiz}yK1CTjb#n-C^8!=zbP zS}@9Cs9aE>#w9}Ah6*LFx4GG5b75t~_ZU`n2L6qzQDzNqdum~Z!TsQ^)020Irv23I zWJfW1`jH!@wpC3_Vq;D%6KULCUD}EFN9O2Ajmrc_yTwF(#+Bs8Oe{ZylGH#6WAFHB zwv`lw=Pm5SdYZsa9n)K<57awmbxM47TH4NVG6=&@QgTQsfm;EBA1IQQg_XeO!14lO zNsZgJSzhAF1;VzgvI#j);$&K`P@sp}%=61d$3&!;Z8w=pB2)yV3EenF!CKI{@h&?I zNTeVi$3cw~m?aPVaUwUW!q3utZ3W9M1+i|KH3=yQ0~L-`x_;k~n#z?7%Q4yPLP?{9 zgL8u&%DP2@cVJ1%h|y3Q4t(5*+OkUQ=<0%x)1+yCwc1x;D-KKq{3x%38K)!O4YAg=LGvsjzjI+EPlG~VK{%j$& z=A7oweZ%0SpCG!@S~_;}8uKuL!fmbNRX)u1NAL?r3)3y2DMAGXL=^kbN9^eddN2hS zR&|ti90RW-*{js$JGBKm7AtT9y}gV5UxMT3ih&|TM_`TRqw<4-6^N*bU2ZdQz$*CH z3O#;EIPOZQ9(@`JF{+$KC`ji>K>_Q0aZy7$2yCsdbQ(V~vfy%dYDenxZH!V0Nia;!<)d4OGs?}|t)tet z*g1N!OcjXU!)qK3>n&3oX^5>}qS5BirUAz|FZWNH0@*SJRpT}{6xc{afJl~Mw_RUoHJa5smvJLHi(a8`ASB>- zHtQI0XIou*CM25;vCZ@Rd=`3c#@LNS*v=1(6G3+HzHzC*_LBr(lw=f|&-X}u38&%Q z!zk7U%OiTwfPV5`y!kB=Y9?WCWJO8xmsTu2nHe#m=rW1kq+j$fu3VpUDM3!N1c>UP zJd#j9RW@q{%-bYPw!J2qrDlkws;%I7&j=^KeFiLg(SF369uuIy^tL`<*v01p4)Gft zhgWET#Cq+BiH)V7W|c)b7-N6fJ&t)3j3e3jg&I11wDDC8=F>&vC)jW~4U=Fx$;NPE zAhBGK1(%9VUL&RyVqg^4WbrfNBru3rP~jHG0YqE`g_rY=3!>`y;mZ(e>q872X%dJy zQ`~pfWPE6bFtBAR8S4sqwn2Wg`b~l?#3GDE7)%8w8$xW;TY9+1F7FI?Ws~)#)NdUd z@^C2h(U;hmlXRCv+e3F%;eqaH@w*UQi4ew8&(J#r5hH8@ zrf^=p3C^7g&Ko77c*ov)Z8PRU>+wfj~=iSnmoY zNvr^Z!M7ldK!o!t!P*intxXec8?S?5n#8x_?70q#BLti~uAwkYl0iqPtSwnmzHCV! z!)^f8KvJE?B3-_sN>X(35gg39{2t1wa)7D92%tCSTN6!z@xWvCy*=XPp%fZ_>N)H#5EU)oS+NUnM>d+mP<0ACYg4? z=Lm313noEf4&?VC&db%N6JoJYphX4Z!LhlN#Q)&+PjC~yH#wu^G$fOVrcVx@&Ng82emej zwdm#ZC93zEQaS87pmDLTGW>~%*(wk;JEVn4Bd z_hd+8VW-mwj`K+f$Q07Zh7T=+m-q`iRr+q1*o!J7gY%P)*%l&QLm7w|rI{Teyvz2^ zG0#e(RX0;bnS=!M7v1?+3`p$Ul60o|dS?zkK86p@LN5=#3N#+^iffkab9%LX{ z>OuCAp*EE?Lk8S+Tw^BBe}0y9l{XF>w8=G(i50Jwa9))wGqRgpOO4}I-y~Hd0YQ2< z5+l*1Pa9<^fapU3q{<$kcw%=Ncc<&Pr=%FqW9umaMoFOn2B0Lc5HEs-co_^NErj9~ zNTJ~97LgbN$dZ^2L=`ug@PrOEfr8|S;VTe|;o;}n>8~m^3xmAKTR~B}}-Y8%@6R;iZqX#l`ZZ9z>lk!S2 zp|lK3%gU&%q&t%m?1UGWSVDovPOQ|eHaUs6=(N5VmMejjM*9?AR|&NwWx^mIm&A06 z+mVFk0n2Ef=`z;BP+vPvCe^^0bR8Y%P^yHML7Agv#sqTgw5!j^{+KdqQ@~=45-3&M zSbehzRWU4+nW0JDFvbhd$+W5*XQe8@V&MstDnD(ZL>-hK*Ad$(b4M};VW63E3_Mv= zgY%^sK)SZ71XbUadhO1PFapfTBH*Mbg7T6`IxUFjuH?YJ!jXD2+ff`mBaOo(1#(y~ zlLMv2a%d_^Np_@>mdwF3k~vILGKck&IZ#?MhmIt}PI_%MwpIbA83~Sjv153PfPFgR zKx_j5QOvh_Dv>Ni5dfG1N3b!C1ufR#0k&h=3^b!K15c{U;L;T`NRozrQk5bQuZa~b zvxQ)ABvS^rLg5yfS{NuvO9h%F$$k{lN(fO2SspHH2p#V5EUN+339YPH@+Z)8a^TB062X0iRC))S_$bq&Waov z-uGf}N>E676wZ(pp`4MMZBwDf?M&Rl0xRsiQUI2hBm+b(GBBuvVD!N{ys!k$Z7e{r zm7i$4Bn_!E@PKlu>~fF}!SYHZJ!9XA4I!V=AObcL`-zOaV%ToBA|g)n{Ng#H0dpm0 zbJ~)Mc;P6h#h=+2B-NHg#K}B_wovWRQQbh%E|8SCa!^_ocPiQdyV zTOJK@cz7Yx={YaT%){Gq^YFIpJUr!34K|c71tyzr0DRGB^DxT{dk!4%BH4i~j% zU@fxGoaFhea!?u8c2eB(aDi;8jJcyB<;)woNGF4EI6#%-FDn-Bt_MY#-86F&o}K11 zcq%iPl#&$E-IceRq%vK8D>Ax^f>xqXU3!R;&lF%qIL9YVCOIRN5jTG5Ny}dMLh_*g zGFj&;!fZ1}qo^m(=*6Rw{-Z~yT}Y273!oQYsIplop&Iy>n8uMTnHKO_37u7ah##!; zkai1Ydt&?&En9yD+N3zktl6;_nZ#nhSH2gH8s}4yJ|e7EV-CveG9pMSG(nTqYJzC6 zY7-f@&~KC@qhvURyp%FZC)HT}6N;^K77<(=^OC{P{6Y6g<7^bOpMq6!oTr*dPjt@t zO?C)PnIy2Hd9(1%VsXX+j#Q!yJ|eWqkf&)zi_B*lcr|c>*uhiTs&L0RhCJ33xoPy! zZUUZciUmXpxK^{Hd7K%Q=wh|m8Auq`G#JSfS_|;DVxC2^ogy|#8q3O7g?7(q@Jysh#|lzNDU*P2gwuM0>ifm=~+WZ!)Z;x?*?KJ(%uYsA$l6$uhuyY zMCYy9uh?ihGB~VH)j7Tu&rxe05jo=NWW5d-# z(y<^K5O&l(N@yDx$IkhD(?$%=Bi4LL%9NNGvPw!vu}?W*AJOH5k1VN&cq-#8sBoS^ zILnFpFU9M4T6HQz!kVPV^O=HA@~*c}@;c?RM0VEm9r;hmy9#8cVHBAk^-_$-A(1 zaj~I;V55gkwg~C`lO)>vC^8b+j&9~enyFoXCI+V8l0BH8+ETn@5_QdV16d9x`caM) zLLe1nWI+(se6w!DcTMMq)4{JNF`0_LAX$B{%0;l4*gU4Ms-R%K<*HFuD@KKCBvB9+ zwTDfy6vbOzv9+vsUGuIa+q4B?MEO|X1)-ec-ZcETB= zR#Rx40@2NDY&|+I>|g3~hz*9NMSOT`OFGZbMAfEb^2~CG$g`lRZL{C2g~3WK2Sa^p zKrL8X`IQuB1~-tlt|P9!Z$)M+fXzu*=GH8!N*6*)e9ggKO0hX8%4LJlwJxb)Q*cWk zTyaTd3ydTiCT+KpFwzg&!DJiDv4^BK_*%_LzC^Dwv- zWv)GCGLag+-G?TYB=+`y0mObm>qonQYc#3_xMUL$5M!b27X{?Jz~fEnWX7C!6EJ79 zK32eWt7hA}$x@AyZmOJSy5J@nG}Z-`BEnSDtkf3amIkEUbF4!1@Lsoh6jUPie|TqQ z5DoU6cpqyJO`Zkj7soJ~rQ*cQ>n=b`Lx zf1QW-_c^0gAm#J>%Ap8uyP3gW8bu!nrr=se1rEeja4oq4>q;oFtq;o%`{VJ7Tb3Uf zF{&YLh8U>&BQ{u z+e8lWG2CgO28fqJ4sNUE0G_V{k&njrw7Wgo7Y{I)0nAf{kS@T`=NL)k02u92J6yuf z94={SE4^l?P9$;NJi^z-!xH6qB_*BIkQugln!Mik!6Nakg#v zQ zb=pY_?v8id!XZN+4Z0b;)lddOdNDU?GdR7l*{T4hwZ}+wj1@1x)7(vt#2C0Gecr-i z%Zz!W<-m+U;)sasVIUcqg<6FVqzxDB14&6gsR4XorVFt%X<|G&RKsc97FEOn7?E9Y zTPgZy*H$Xyvui7p@q!w`&|XL*D0wct5nPAnqxN(|sqLo71K5)OS!z^97w+si`&9!= z+|o3J|Ai@DXfH_dUhE4}Ja5_JEHl5Gnx?$)t|1aUTY9$y&(W&%q~s);lfx?bLPl1r z2E1?~`%D?0em2XXXxodP$4KhX?qzR06rc3jQa+pVb7)y*X8L6>NRA*flE!q&=8B0fv`o9C zOP6YfN0x3drK!gNvt|iR@86P4I@^|H(u=oLo}FpTrf*JN6|=Mmoile`_XtKe^6z}u9OpzNYj6fKK zZ#k$h$1xzT63jN+!$yvct#w&UL|hihD$9EM5SK6s{yL~AW}n5eGDx@#YQEmZO=KI# z3c*}i27}!^g_TE0xIk}!UJ;SBTx>*#dj&ZK()_FxqqK~u#^`emJ;3T=tGF3 zsdnk*eP<~)YaV!Zl`)8j!TC`lo52T|umsjaVwP5lqs9p`k+cCo>{f$ypJP^${bumi zmNE$6Mi~?psMZV_eCR3R!;%f$E@?|AjN}QCR+td#B{5N2sfuZoWusw!n@2-EYl?_S z@pW*^)B!w42lDJFj3UL(!7V!n@a!DOv!mFH6gvmE>>R+eb0E)-nYk;$i1EA*}fIWK?;+13{;4J$9=-CHg&tAebQVpjt zmbC&UIZ&?)?(8yO8YHq%q782EI@&ChY3(guB?NJXTPPQPu?CaP9ZWw_7uF~*IHqcf ztM*|URlX~l0n-pEz(ssncO@@J21)r$$*K?qO^mIEo+>8#pg~w=Aw=x#L}&?biGXH1 zO0m~&gaXsxjrmadDvA@e!$1NO&kp~Fsm-I<5S5Oryha-{2%7qOK=y=cH-TEfA%P``HAj8cA%s9hk(s1T8v4VZLl}F(FiE_1= zhci~Qd#2E{^M)xfqBA%AJy8HK6z=_ifGmPCZ39n;c(K@`LJ(28fKj=~t8^#)q0g;I zq%b^!fUh3d8};rjO(kVxAPI9(JwjznLI)M)44-!BEumKh73D}gIMZcB1ftd*!3&m! z5^eg*GaCbyFaWJpU@tqne0DSl5R^k-a(2`iAW;VQnjL8t%C!2Pv!~5KEnj_G$7_gq zXEBz47DEbJLK#^M<*`GG=O03dCUGm-NuP(~d|Tf<_IxgomiY2x8dyQL6LEmvzL+XA z%V+WNWEoMoa?*69UF@mTr;|ml)F320>;xW$sQKbTs&sKweHskKMLE_$1nIzf66rTU zbs>chP_35`L>Iy<5HXzrgC;&=u^Mz$QvM*VYJ8e2=~Jztr7_q8;ot_|`PCr^iootH zDv)f2Du83+N5qIZ@1Mmv)KXq$4B~Vpix19|G@B4*F_SK7%uL84TL$j=Cr=fGE$NYE z@}VXkk$0lxDe?~EJcZ|>;+H+zGsvK+0V#}4za4Kf@4Rz$P1X+?e&KEi`DpLwUIks|MgvAAT zIYKBx40L3)P!~vOT@d1OQ zUITeJ$~V9f@(i{l;s!Bw4#!(3y{&cvO}R6!k}o|6MY*zGlh2li<9rzpO6AMJ+48bp zk;m|n;G9UY^iWm&mIOKSDQ3sE=5YZe-WG6ft)yPU z7tq?PCMY}yo>L#4Rgq+C#QUoF9+N3I+GfS=vK$0HT_qAlISiDV$vb1df(q@Ou?$)o z*h>`$%zCjh7$;YZF(u2ZVYa6>iJ+IOw?EKP*FVA5{bgH#7k)1*s8DZ7uNMLep8o8YL#QD5F z6PR3%$d${{D=Ov)OfE;@97nH6*Dwy`<#ixmpab=8*kz2sfjSPf*lWz2$9F`_3l!8b z7l7=tNC6SCrSZmpfbm6<_dp=!QI8dAW8CcgiUs|B4S>}n|tkB@ZgCtIkyM?>H3OXX!Xrx3hZBO4H^C=)T}XK1Nz zM+?e1`QmE;l`t}uQ$FFOX}BW%i9z{DwJw;hys5OeYi!uy^}gjKG701_T*a)Utu?(D zrh`xTW!i@;h;Kmyg$)4vm67?FgVE2kB-C7N6Vfvy^qn;&xk066w3ODpocIPlq zA|9BftEVu&{Om5I6iw|-IcczQvl31(=#5NIk&mIgViY=$|F{^J%Q1%?!*7;eq!V%I zn|KDwmYo{$eC2XUd@Y$|z)%-48$cQH%$>v{j=6N6pLqyKl*>NhEAjbKi964z9a(D+B~3g6_?F+@^l6C3Va;pI6bL?3*6Y!p_k7J21eTo zq#J&vLJZPisE90-KAUR8Nh}YB;W5N+8{g|gFHj8d96r7zE$=TWFh0MIFG3;$kcI#S z#}^Q10mfE=i&#-u!%U`zbT+)9MYl9NX>7Z7EC=JI&mpk$mlB7xj9o{0$6Oa^w)D|K5EMW6qcY%!*KN#J$yJB-3p

vcA&SX}z36wdvu*h5qhoP`3_W&G-zItrhjwo35G-5ge zyCY?iu+DoIoLbO1ca2SgDJ z-`JR;aYh$61#Rl|;bk6*LJ(}=KIy_V9-;!NEGB3!9<16qeIk*2=>g=U&jgZcTinS|0MX&Ok z8bN*;iEL{@gADgd=A=`vq@Y+Tc%N*w(9gZ};tc<2BRtCLYufZdUsDUg=k9x*#+qtNb=07SLG#bqjh3^zCW5W@Yo{c!=MND<=F@T#2uSXkMaS ztbxmXO(ls^xehdr*XK=>gqb2tdk!CD|7WciU1R>c-u}Q}`7Qt6uxl4%UcBS_T{rO0 zU%Kq>iK%@Tjf@oRe*m5$g?~_}tUrfRYd02(C&xz%g~QX8 zwNGuU^uJc=f2p$ZV!~DWpFRKn%KG=q?~8^|*2z#0Lwopc?-y(D*!By*c>1&+L-u3v z8IB>}yRON4_?7!W)=DWJ4zc=iof4kQ9&6k$2*DJRDz3iFa zysm~E$Y&q=r$hhryWKw>js(Mz;Jan#BHF=WNo{;mU*qZu#xW*WcKEu)HyJhql z+WOGehqg{O@a^=u6Lae?4)=QgrpBg(wud`w-*KmdiB|mIFB{dVt;{O$I_#GL)Z!@Zbv z8zgk~;fsfB@ZlQ#+pq>tTj&t_t(w6Tef`9@_ng{E#5Ww){&}JMkK_)-la>Bg%zozi zN7MxfWT2quXGw1FS#pMq-&r;H7N$zy|Z42{m41-CBL;SaD zh#zWlsLA1S_q%JkJM8nrKEHLJ|E3+-Zm(C9*a97L1AC;99?U^4|?ROuCu=EzW!H)mkc4*HOhB%It@MA7_oDvBCed%V?usWr`<-KP&t~{Z z(`Ib;J7tt9o_x-5OES@Vi|9b#;+^QUo{Ym6&n&i^U&(%12)# z>>BXXYfoKOeC=!CL-Ze=+F);Ha&Gi>QzNHda{eO^Tto0Di*I>X@huN;lrFjV-Nnhx z%_lEjJAZNUSN|R7S$hUQ--w@Uk8fZ5>LqX6j-SPS51oF1ew_Q62Y!kEJovyp^yl{k z_&X0=PpSX-z|HjM-#>ux*uuH*djLC`g>%300RAnUd(H#6nx9kh-PfVayT|&Eu08R* zwWmgoz2<&maGKdXe(U-3=O4HV>BlGV>vX06(DO5ZhhBd78EiWdR+ zv;Z&n`LB-hzc9*wlgr;4^$fOq2G>Lku8$bp>=}?+UN%2=VNOt`-c!8x&ybkmI=u&Vy7d|`dW1o!ljNd0 zxm;8ymy4>zxyD>BR7rACm0T{WlFLOk;#}8Kjmli3mrIRKqvW#G=oEh5HO93$L$%qD zl3&&xJI)4+ih%AeF!~&)QJ0sU9J`16#~q)8Fz;dlYAFz0aSY|d%r9pkahMuIrJy_F zu*qrS{(8${6CB>h1XM#1T(N%_bJ(sppn?Ghl#${zAzm!0WbezGU0l^60k8+9e}v zuO7YR?z5-+kCfL(U%PSn^LM|m^F!xu=x?rH{;TEPn@3;Rf2@D`n>H>l?Ed_*AMHQX ze|Y!%j(&8bG*aq6RO-Kb-}=?Rx^MT@Zz}HFJojE;A1n7q-*mckTj_9V1`hOzPyHIk zwo?De$^N_NE9;{#xE30(^iPhx4&WW9D*aDB@N3itmH%AYIDYZkC!e0U_f+xZzhR=! zmo{!bKeh4l*Nm1oZa=?1Qri7c31fKw)Y|CDk;>ZU=;ZD{>Ye=q&=%Itj~x9cm5uV) z=mS{J6c|=s-`>BrJo16HO%R_N-TlYMJ`LvGDIUr!WV~ z_EWo0m-?s6#eE;1=znHc7OW96B*F;iC5+v(@y@5Ddr7r)>yn_+2QxYoajHKXqnw zjpTn<`8kD=$B%+jY2%e6<^H>OKiR!*_n&ru8127r{qnWa=Hr)@`k&jkK8l}bFPqrC zc?{{#_n+Cgd*mD%`IeFXyQem;UN5abxBum-jnTK3)~`SDiNe!RT>m|#6Cb5tggFaKAPy!3tjUH_`G@v|dSyT8!Aq0)cP z?k9^UtC)gIyC3cTVE?P@yVf^9a~ULEzkD6S?S5bJwIyKtUoH3F2caJSX(U(~{YTG? zzMd+)_7KeFPdcAH16w24V9$xMw~`!dXD>c}xH9)hrT>X@-{0R{d*K^KHf|nS8-2}1 zm9-~E?tSd|jS#B;Fse-kvxdKGr$$7`{+Z2BUUunM` zl@ZQ2zpneeh20PJKG}cd++&cqO!@HlX8K!NdwS&PPgFLh#zrd}Gh>w!y3aF}jqb^9 z>mwKMd3xj&-V;YBtE@dVTG{=+-V+n|e!6(_|D=o?zkHr0DBd^qoWlCd>u=s@kMz5* zzqx5k7!V)LQr_L**D^q$RAmu!rlI$e3&_uuui zcR#TDQ~$PdF{3I%QRzQY**yEBl^u^%-uA%9KX&!f{yW}YDZT|}L+~GF__-@~eBbX+ zKJrGuA0mBjKJjCKW1{=fr|$i77Xvsuj_WsXyXUl@P*>fW2(O5 zo|Ay%H=K|wUiUgnbMKc8Rq;3Pc_jfcUscwBptAn_N`E_ME6iBmv(3*hYoFSV4_B!X zt~|C4!`u3cD(m~VRjxZ*S$p!5SMOcF6to1w-YxDkJZ# z^k200?i>3=g3R7_?!-D|yEB~fdh4pUQO5FhPn7z9Qrdj_;sbLZ+kEQcsoftb-tq`Q zl{2GbWFk{@U!ZA?eEF$9etw3{3v=ICx&Jteuy^~^$d@YppWM4q{&=Ck_o{RE$|x>V zCcecr)qm%S^DpWZ3a|bt?r8TuRy_G{!LQQ)qm4b766ZJZxvtMt)_%b^269+*7yPFVT*(t{-4xouxA{8e{`SXDa=_66s)Op!|s` zNZ9`@2AVJYPUS0)VnV&_d}a6hyZ-~!_q^)-HNE$qdq@iSKKXO`{WR{Mdk+7hb(`qx zwB0)UdS(6Y?Uj4acb{XF@XOZ+se?N8i+5D+{csoU`B#C(a^@6i7s9;%BVT#s$M?fZsrU^ZC*Jl1Np7}pHh2gT5e@oW8oj>%s@vH1R z+J4>V`une<`fRgIF*K%_8lQ^@`(K~z|9_?a2l{_{_7(_N`K{9W)hEAvdVB95_5X71 z6Gb%g+210eKe%~z`wPxvh*gbOCcF6T+2e$_#Frwmd2aj0=*7h7+}qf>>wm5PrL&(U zzo!2Vv86J|U_E37r`KP*tuR{nnd!qLg}Z+QLqcWa@;~nXzn25n|Ml(om&OJr392@W zNj0G_8O@F#zW3d|LzTIAnSthACog&jR8ctb%vG?%?ki3_^F#FaE;llbVgyPYd8 z57GEEdh)T}od&o2znwzH9)XUX21)k^*S>mD@4k>X%xdJ^{}sZJYvkM;N?$&;z581U z%t>Ib>3!nyRcN9jvq@#{$^P#?@Q&}1;qU~>^!QOiqoMwg`cGwD83q}T)VBDBM}V}x zUH?my{SO%7*Y5vsz!bVa{rmK1659XJB%HKHofhMgLT3y?k<8>BLvh-wlVD{wWm? zJUX%a&wsguo(HeHyz#ceJ?Ix3S6*7){h_;mwhX`X4P!9v^;<_buH07I{r*=UE^WMQ zwEyz4?dAT5%h&x8eqH_eB&@;q@w?I;!J>b8F#7Jn=z9jEPYg!?%faZ^4Mz9V==G_w zE6eM5ja^mV{pc@$f4P5nwA_Esbr1Cq7bbRppm_3=XeRi&#gl)DA1`2)ub(`*t#DDH zwEIkP<6%J84?wpg(06g;OEf5L+yv$SRdM4I8k9B;j!qEf2Pv@|YAM`s%wTH)gJaJb!iFnbO;6uIZDo zeG(S5S6BLvR<8T=J;nPj-*Mw*#d~*xZ)x{a#gpeC#RUBrAqZ9u@TEsko8J3eWlOu? z1H&MhP~p;bo8|ri8j7#A-KA7LEhRqwaWJD1!Ya_&^6_y?ydYoGfUyyJP@CQst; z|H$T(7vZ7;ar`Yyz>W{v;`YnCKW>Qo4|9P$$rayz<gD){Pc1;c3L}+`*F5;!&x7Mt9=mF4 z<98nXUHsm-@4>e`uTZ-Gd6elI60ZLct?-Y2?)>@5jo1Fg?+N|3$&EMN1j5OU|9%s) zmF~wZ3wr!h>7O|}3F7-HGj>t#dGM0o2SuS*+&G9fK08wR8EU-V$54eU@24C>^kHx= z^uE^;VY%M>1bo&jY5JWRyS6m)CzZLgm5n!#eFQ6n2X1D`o|sZz-o{NoS(yW6WgQ#A zJfO1E#92tLjsL=$DE$FOw8FVtXuIT<)Ct#~y14k-&j7Z2v-_f(i}!sQ%f#O+tp7m& ztJiH}0lAJv;%Rh`y-!!LBlE?LnSVZV-9sDuNBTbihZSqu;z^p8`!J8+y^=&L7w>yl zf3yF`y!G5;W3p1bzc-KFCG4^UC1 z{-dSMzkW_>?cL8W_h0(-MtS>lDc1zR=wWM5U3Tn`%l+4L=C!9TD!zs`-PfMDco+p0=6qmQk zxp!k~{(0QGQ{rk)ZJcDj*4#1XT{(g=Ygb|93&pow`PvbPj)nW$li%0-80Q1Q8!sV) zFBRYN#@A9WFeE=iUmNay1o+oJ2#XxqG)BZu47gqb%NSr3M|*#cPAlpB}lVa8G6P)7Ol=bMx!P%_o2Cx_9=QW7{^$ z|Fy7DzU1P~k6gTav$*kTXld=PvF(N8Z_=>D+k#X5XQujJIs3^ca2SJ0sPH!W#{eG# za2?(4#1qu@9w1#C%>9D77TY)){2u@=Vc+CwJ`*yuuLltOHLt$0vhh#B0j4`YhL)Qc znH+gX@xF-yR65F?lg!2BxdVABYwyGs)yI1uu23rhSGf+$vkz7<7Grbn4ez3+rG5g+5V=tV#cz*1f(jS1TfFWW##;+@< z`eS2{zZrlM1o~+>G{rZbD&BYM#MjS5wZBjQ6mR*TC@!P0`yRInBX&mY{{UcVegEja zr+U@N^_RTv$BOrzc^&%v2fy;j>-Jx?fQ_2h?Z3FPc4l<4|B|V>|25VBXk~rZ7!NuJ zM*i`2|FeWDS5Ay#?t?l1G#aqDu?xb}cqZ+3at>Ya@q_q>*V5N*@)SV}+fL-1g3G9+&T$=c}H2(&qgS--TKS9Pzxb*lgI61vpW z*u8k&PoWu0Yd4J*Ui|@HSoA-5@x;?ul@{;Ao^f6^UP6pdkL>=%!rgy-?%#mwS82Q{ zt-tBPw>tTL2sD#tcz7b?q&=LgDrfF_lDsrZZybj!^2sMF*WqQa%@dmibnMN?FYdpa z#~?a(IK$F1EtXK^8Tc)r=VSYj917))u>mWOW9?IS@R!rOV^>Y~{|xR1=E2c1h5A`qcUPVE_BYzD;s)7r%p36J7&5W$I+coZgvTPwtAT$>9LxZwDKWbi}?NJCnZo3_aSh1M2z(LKH)0^|te8=s$)1-v0FDtspX;Br zPpQ^cW?un1^IBruYl+NGX?QM0*2qeO91N9tBMcQ^De-58qoKX=XF`A8bt&>Pj_N3P z;H2c7b#zbJG3_1gHc@DBuL8(HW%|5d_m=ik&oa%HW!?>^5|==6cEfTUnRSWDFL_-* z!I`A7wQ4L%gmL|6Nz%RB#NDs-)lc4(d8pp|$~%bN!YCrlqI9K)xP*i_vzfB|)mmNHr+Iu&wP?|)1Qu~3E zy&Hat2f4Yu<41<3RqpBwZ%~9aGPCaNl3LWvyOuf*KfvO|J|x%Y%RJo zmO<*T`cb0u9CSYGm%XfoQ6kgv@1i4=!pYJD?OF5yYrnrb===4BJ2!~lP&k_AxBXdy z29_lzx5lfyzt*IxhSxM?wkK#`Wn<=T5#a)wUqAV^#TPIqS3)tBUDuYt;=m@WyA~zi zmhir^Eiw6(@1M?6*(RvuoHC?v6CV%_Cmxf1gDELW!2kLxymJ{Gu`(;IROeL9I^#6f zYm%pGz_V0OGHl15BI0Q~kG@Pr#;iYoSaq#?RnhG)Kq^-;f!q}|{fWX&A3EZf?dlg` z<_I!(MP#6N#J3R6SPurQ9MwjDIBEiik#~+XiJBBd)dh}Z;Fu9OQi0>5z%e&)ToO1I zI!8x*sT}+zd)YvA&Jtw##h+xeq+Y9su0Z&;3c8K6sjgy~l+rhf@V7F+>n9ipAW+b}KL7-0DH-mw2ai*i`Miu3@jT$F!Xxrj5#l+;zi|4q_ z#ycD16_38K{E@{UPiFeNzDE66f%hsy5BE;a@ zV1;DADq?~%O%SZNQ3qjp^_eHNQtwRMRKW^pkCsd`kkPHC^}kWEiOk#ekG_D#upZO@7^jsU|1U3yMu;uad#R?(1oB{8`rUa=@Uu-V$O=!5K7 z(3I>KDG+D&IGUE()X+Kp2lZWxzE3M3q}kdsPfUJ&(aY249AYc3XL}_Yr3+ z{sz=MpUAAA)>T#uk`m+gB)nB0ukYDWiB_z>{UxvA*ntGPF3MI`=goPw9`#pdPyM50 z^;9XizF&H`3ShcQ8cVZm%`e&4ka@rmz5@{0+2jYjj^kmMDc?>cwz zQx7DLeTG#~+ehl#drPO!d8j_~kSg4nxXyJZozjrmQU9rD>L(xaI#M(=k$ERE?oBGB zYP?iGd7XFt?-8tB#W|ZYz1c&QWu04ppY=Ulkop1p;`BM28oQdVt8B<@TSbaNx8upe ztlnnFfxqmhW+f46Vc9OJO_S{v@e+lZb?|P?R6v=yo8cXI{@rw|5u+CD|+F zl7yPogzrYg99)fV?UFr$tfWau;=}TuGz_?3A#^0fN74KQOBG zR>sZ0fY(#eGuX(aL6MPpJTevgwv0`}BV)7kj(C#%+FwRm&6Rs2Ij>Y(RBk&ShJyE> z{bA50s>nv^LI3W5fGzeCEt)`q4mZ&21C-zw9yEB{L+I%r{Q`1)Z^%U^9hGxKUvf)vL%+*Wb2bRfuXdg<%7T50<|>xb;8!H?hW>}V(=aK8l&1#YPY zlU>)vZ~P>6=(;Ih0}_&%zV#(Ys^Z0~+xBZ2Xu(}S6q{RL!d}0kHoK@Bm7?p1)fRP3 z7`2`)0AkAd{RjW|AN}8d@_%phfB)J4{TKiD*ZNhdx8oq|I?MV4kqX`6*Z017BRH!! z-PPSvY29-ipZ;eKs8M(L>FY=<(SQlpITz66T9ey-(v81{9-K%AtHl`2;hRIjiD zM;0ZLU6yg8Yc49EsVvdgNde}l{q_EzC~u7p?S&mr8tJb_uehm9)ntLldVQen2{qXQ zBm>spCEd*35O>Kv`t+}7p{Dtzp=*4Z1jy?@N9Bx_1SJieuk1gsvP6mU{DNUd{aVK} zcR(H$j!f>T_#x$XB}XMoH+gq{d2q#Xnxc}E_qOfnN{=3$m^|QhagM@rcy62eqBTCj zYN0$|*r7aQY;qm=aBI5#KxONSZ_(lw$6RpK5|yBhzeKs3(T=BJmo ztwzBs3C^sZ>a9wAyQFk;BP*I3jt;?IlH;CC;;WS~eJYEX%qDbM*WGhan0uzN^iZ-B zef7AflI?F-dDmY_qR-JgK~JrGJLmp4+#G&T^-+#A zW?mL9w>~RT#hef0R21>TD3Z}Cg;;xb8AW+_9;4$$)h4wZyW!Z?J=-`>WQS~Cs7W5X zdV1!g(=)TmsTS)QJ-Cowf}3U&nk8`3Ia+aq z=U6yMdfwnL*Qkc?zE}yJB+w9}H?lK8*#(Rf=lnf%D86$+Tj<=HbKc9@1s~w2aD3nS z^*;}t^Ol9qW3LXK-^_&0-~1qSF1#*uzI}b@9P^{l`RkvC&dvV^#70x5ZrBBi zgA)RsB}RiWaI|W)5&!f|uTw45uQUpBM9%4^L}o8q%S7gt{_CG6V`tDmGs?eWk_Yf- z#Q++M0i0S4;J9J{*{6zBvacAxuZjU&Qw-qS#Q+k;06tv|U{o=H?OTfAp}QEs-xdQ{ zTnyk_#Q>%h1NcNSfP+sKY35VK0PZRV@K?nEE-wb~^J16WcFV0JNpvx)(XEe3Gt(IU-!x){LS#Q<(D25?0&fNvB7_+l}Ds$u~99w~x{ zM~VUbYcYTuivcVs2Jn?)0G}@gP*DtE;Nc>8*ia1MABq92C3pJ#Q^@e7{Dis0UUm)NHd=)25?U?fS(itSXc~TRxyA-Cis0eVVgUbE4B&^w04^y8aDFj>(~1EcUkqT^gGKQ0Krw)SEC!G%1~9i6z_elj zpD70LfnoqJZY+X_HN^n_Z!v&n#Q-iU25@#UfRl;=9C@HfGq)B4xHk%L9y=GGYv2yh zC(p~gUf=bl!SlLW*P&@S+tes%xXRC){7&2Jfhxvd#;0zi5>65De9k%ghhgYvbI!Rr z=XE*fgE{Ai{vu5F`#I-jIp<&HocHFO&*z+tKMHfWm(_nzvz)W>XJP2wIp@Kg^US{v z0p9$Z(D{dd8#>E>5jxv)&W$@RZ8J9Ex^|0x9MxGi)(lXDK{oS**Z5TGUJeDd}%^ia-u^S_3nPvxA~{aYCNwwz9r z);_7E^&`Qly3Ff?Q6nUdOiugvFx~Q;bFZAaEK(z6QCO4tUP4_Z+V2P}QS%?6^VB<| zmGC^V;%$sC2*_DR>_{@8co3#{2&pddM-N@$ZSkbLr;4r*!}IQIsor zB<}kjAiR#twU7B;i?@IR6svVX-1M$U1KE%8>!B9_1WcjxpieDRlug_SOzF)VD9cf)kjbH1f?$oUqp z<18Yw4O=+~GCa2RU$P$R%kzab~_#>cMuAgYisSPUnO~!!-#gU$S-dYy8^w*-X5KBvy*Ab%#^sZn8XD@ z4hlZx=dqr1Nv$!Rxa1T($N0JT@3K2^UZ!;&6y95^J5^&FCcky*|8YfSXXM)bCGyY1 zxzJtaU7xb!GImzajV>@a^dOqId^S+oPaP?c#posfK#HM*3!D#fK&3!$Wc$g5@S%et z`ym%TwCwCZ9X9x(C1l?`6glds3wg;57U#}7gi_QHLw`8qH_HY~IY!&+EgLM+??;{S zHO|-i2NdmRAUnkWlul48+xD}B=98EF$ue_T9`gfZJUtxdEKBxm8>3^Neukx+eVxZX zZ^0-pR)@{a1z)c8Vo3~cF8ErF7n^~l%?00_;Kfo2E|WO3Z&q7>RlQ0z%AHaixMsao z5kmpd8r$tPRnjdAb+ubI2xRf$W~)(`TOM_FjH-e{vFBMiNuNu~^qp(AdoQYxJ5{Og zj4FMTvh!M5hkeq@g_szvyo5?u&c(oKrq z{}$kk(45xe{j}R%7;ISG(cOBYv*4ysPXXTY$(rjZXPzdCxnymXYc`Vf>4VY~(P(C_ zjgq}uEH|g0&=8{)nECCIfn@CSHm|05+1aI23EnOUT8Q(YAYK6C1%;(C(Bjp~&|HsK zyOlIsNaOHM_)~&?hDfZ@HNTDR>NTWEoBiSr>klr#{2Wy3k9uq)ZA-kBgfdFKI#-aF z!s27>mUxHY$WrB5^!;8fiBj7w_9kM<@D}C9AK}jvo|bjtv`h}WjwR;@l!weRV}qFp zYiCDX{Y>&(EwPdKA~^{%+o;a@Ge4H>Zj0ZBC!lLPl)g|a+Ez2 z%5E~sR-ZuG@9n4m!|cpO2>4Xo_xbdDl}frJ-c7z&ZG<6BcyB%r%+O8`(IGE zz%N+i)xxH}`YNrO7a!|k81QW9#7JkKH#;Hg&=^FA%9{@WVlK#-@|sEJMlV*JnO7i} zs_f-VoJMg2_t;M!V=By*NH>fd!A}~goOn&Zj~a9Qh|shjdy)SeaHOXATw>?>p#^yo z@pSIevxD9XxzZ=R*jV-59Qv-s`tEyhrFq7cE~D?bcl4gwk)NRd8*IB;e=VhIUhGWV zTmdro1?sz7e6BP{eRrGRtKSRzZUvAdb0srJEfOw_;L2mHbL!~GX_N)N6LL}#&ZL|Z z%-JYsnK@_3>H4%uPS65uN>1imoM}1B&3TcW)#hxGv(}t*<(y>Bd2)(P!cXMXjGMs3 zKF;yxTqx%hb4KQhK`fjf?cbkEKIp|NsNRB^^qTSE1sBk3-1H%A4!zbApU}UBU2((f zQp31L4!8cyeHj>G82#KlS1HkTKK9T3U10xWulDV|Uitv$UcCkZ1VEAZY4o_~Gm=1gGOEf?oA%*AlAf$xS}9V3M=lWT26? zkdd>B-(YmwID{AQs6gsPZx+mWw%B!xi3AL@9Fxqvar6Um^SkX#I{u*%IupDnX|D(%rQfg+9J4pMM1Cik0pf0Ig$>w;J;fhV^Nl;C6>U zNNsuxC%$(%NTDrOsy3^!$kl3WX67JPXnk9uS0yr+B|E3i$gJ;q?c~z+55LnnwGr#( zub*7n`>>nOR%zX4Q<{A`XD0pZI_na9y-Jg)kjq|#2)6S3$lj#)xkn_Z$@v2^{}uJ(7h7s5T(D{7Y= zIp(%siK$bf99{p+PRMc{h-2N#VAc(e5=AQim-VQ5ggIbFk{!u0Ex-c1WiG zxzs2DMZ-NRcvzu-6|C~hDD*D=T?b_sp`aOF$LzNW7EMzuOB7}jW_5=Q@ARHaKLKYf zfRya%r1DO;I$n<8Gro_fBMO&GZde8>l!r4dVDvo1CU#bKgG4aHyDhJKgPOYB^P=8c zx8)@*)NOeH(E7XSw!Ab0!@Dg%zG%1Qfxqi+%TM*&bz6QO@1ol@&I=E4(@++UVocU` z9er$%96z^&JH04UYG>p=(PFfuHU2XxvYZF}jPB)wix;*JmM^&oi}>5Fvx&HDyZbGF z!Tnb3aKDu=y5Fjo+;8>E?sx1f{PLDYu0T~Hw=QEoTRRDLQjXM(We#vvKNpl6sRP{> z9WcyQFX$vjL0)>asQ*23s-r}e!Y)QAOPpkcsKm%+jU0uc{c7H&Y5UNs55TGNb6!;z z4H_5-aS^K+3i>Xh^79T7tStQmytO=9P~IfAvSe8Ns&lRxsrZ$nhC%1$HoOiq86}nX zGMh++I9hkwc?<$EP;48`57x_8eJYAqW29x$7Gi(r3!~e{7#qsz3N`3f)kIU|RbYfD zU-fIl!&h;d+q=`4doXOu5hj==(EWT4q0-422o(e&SbXjg2^Ib%vPnV(Zp~x8%wq@| zvk^yTBZti1I2;RB>yr9HXr1ZXJP8xYJiuO%({*DBy7~5lW4vqEz=}sG-&g~5(GS=4#=NppO20yRWlTF%e zyC*T(pxgd6;fLHhfS7pFL8Iq9?g~8{C!^n%*PA*s*FcNNr*`dyg?-I76fgZac(yf|Oe|b{CH*K7n=0^67dLAQxGa$PD(pQU+LUat?-u(6T2=5Ae{} zI@^9UgF%zJ>e&U?<|t~kWLIKLom_QYQ?a}=ak(badV7Lsyt#QOqidS%z%^z!5S8ql zS>9{UqCs6U2)Vm$7kk#_C5u01vKaA|dGY-gUt6;HlbAhi3}C9)lZQsQ**x3OwrlyT zi@$D$I}O5&P$oMstI1UHNXTV1U00T77L6(Ex|G+juByqj@>mvFAO8rHJ;fLuk$({hp#qfb~Lc5FMG??)*;hrB>AFW3%z8^ z4qWKP3Mp@zhTa+)j`i{D4?|W~?d)^78aqF)(lB1-Y`hMBy~KZGrSl7`{$d5#9jv0% znOl<%@a}%XlAIB!v{=BWcV3g^rGiHHW=!X#`oWL-LC&&eeGW(WjHzOctP#*T$tOaz zI$f8Qg=Kf*j+FXhSX}v#;yM?WB@U@kY`P*QoMB$uV%zFlES)x%1vik4KB zR}yTC2MEPveBy%ZmPp!r(*M_!jNk++x&UAck=3~9}29(5y0qSN>Qq))W*2^MbNpJmFsh=?^ z2#a4BF|Sy-mNFDRk0EcvAATY__kHDw%z>V5WpD?mzZwp-q_jK7Drz*VaI-5lUiA{Q zD4!?5THo4a_HV(L_+}o{E60p)T_ZyU&7kSToDxS=ICz3{tM>*^kiES9G-rC(h2y&# zj45%2@tAqOdCGw^lAYh*+AkF0crkG73LN{LgRX9zywB_SN8sw0{>D1H^^fURf7m&C zv_WaT1bG+*=vUONUyUIB^5e#5=2<^=ZX7dea|6pf0qvV7AkV6JPzkSNip^j{DK2{o z!J(x|@HE43NbtB?{cIkEG3jv7$Y=OBNKlhccRs!y(K+@pctXA}05PeU$h_ZhAVlA* z@(*wq7TNqz5oMV8XbGH59%!iayx36THxO^#&?;>!@8D^?o0Y$6N2C#wt}IVWk}11wihkQ2W~-wYMw1uk?*9IWq#vGzPVPbk?W6<iJwR)1P_j9{CGvIvIgBgzk~5W~J1qrq~=j!3C5=0#08B z#HgVGqjLed60AN2J2ZPdwAoMdN<@FXW8~`9C@JX`=6QyfN83M201v+U&yJisr)*hc zX&)=d-ZA5@7WinI(_1PgzNUA~sTTBEeS@Gsp<`f#1~sSMpuV~^7vv|LWkKZzH4!&? zeIpX|1s9Zx1X;qnPNOKFFSm{A9FrLnR7i8>n!8S1F)Z5E#6?#Pk9JjX(VrhF^AB3) zpBSFnW$vOsK0MlGZqb1}Z(8%-F}sDCFl=oJ2pY2|FYI;;+nX2mGYi|77e=Y1Z2{{+ zeyt08$F%-M#6P!p%)+QYMc1RB3*nQ!V@5^&lX}P8{-a2IZSR=>lwX<&-fb+nt}xBY za2YwtV@~xv$M$$0Czxbv9cD~7@GFN*+7g%YG^|mZf|#%O%?~1>RWbAH`KioKp4F9E zxQ-?04VVJ!Grf0}e4YrN?Cj@}tkU*vrR_(Kcjt?~w0T8S+;bM@?mcn2Dq(ga%i>vy zslY9{VCkZ`SJFCJP5x7qQ`@zU19w&_-rz0ca^1Px8| zCeroeD9Qd}#HfJ@iA+D%bX88}&~oAh%BjSNZA0miWrsdN3%rg8$@#qHZ*s<(L9Qm; zuDa*)d=Cw1KT_H@1y)^SV?7a%`@gmR?|5;GWM@@;<(IC9XXSNO_F^l3l(+m_IF6P{ z8H0bMOg=^0fH{_i%uxlw94)|@qaToCj?n;Pj?sWim->|r1QkVwJx6a=@(lCYu5SY( zA5BYh-KVaRu!PF|3l+8&Z~H8SpDZAx<@fu*I_v&n($plLA;26t&(GRh-|G{Z2P9iv zk~dmV$q(I~(||x?;pC(ysIk~`rJnBee(Ra-hmK$J2kQL#SyXtU2x`)dhRmLZOuwVr z@wv$&Y(CAX8TfeSsm#ux>G>^?uozL`d%#bMG&^h_daS%dt&KkOzqJ}ceoUhi{G@w?aGC}cCbk1cDPU~zB0 z*lT(e|0zP$#olQzT>b_2tjBXc#qDAfU%O$ix4Lgk4yb7(haMij*!%hxA|JTe`vw5x z@8P(eb|abqW3_sp z(q4vrAdg0>htr6A=ko){M`&DR!!dg(-MS}7HWekUQ$#j@n0cD#W5r0%yb?y*Yu(E0 z!P9y5oTM5f1)4W-^2l^^ukc+Ujp(U5w;}W)J(txUJe=ry(i;8^_bM)gQlEJvbHw}g zYdtUVEW@k5C3|OxmKuuQ;hK^X>hIFL%WKUb)s?I|f+*3qpy@Q)fC*s9DMO7}OE?yPTrn+=`@D0{$eUre9#Sh95Ibl#gTeQuyf z2AQp%nf_p0xn%+^E3zr#*zpIHdeHBmynR7Xjg*T*34EV0Y?mbW?64;4M>7vL*l5hl zq5V*c*CAXknbv;j7`MI9ex#*!!LlQLgnAtvd>O7Qe#LLsk2R-u{k!%K9nZ<%#>^sS zl`K1?gl$)ni`St+?s97TE-dOEN%AXe_~a)XXpClhkA&|b0H->DAdexj$E(VpaRs&h zu_KMVWL=~;yI%|}!lzgv1 z(+f;F5Ir-Ilf?45^pN>X8`2XlU`M(&9?zFX2Yy^AaH)+|<4{f3liVpflG(>Zp2wDl z?O)~%RrG>Re;4wm`lW|UKX!ln_QT71OmjGAA5T}9hAjkfgE_inZR2$b|Mo;v1q$1!?^yQ|{Ldqy)`9tAq{aAvRTk&$z(&-8^kR$WQ{MKWd1 z?<_OXS-Qr^_z2JeC(y9SA1ILttjfvVylt|!IwvOxhiu4?(CWzQETlD)QiDRz9D@Jh z!s}5ui7FyaKpl#TzQ!viX{)Dvh;~d;{##-F5oi$8%I_8zHBpBfi$N>kuEu4f%T9pD zu3X06XCzS94cRP|K5N;L3BV`O;>a@H7$$l0PMId;sSb24RA3_rq z(8M~ykAPj8=4)mo?GLAcN@(DWNI53q=Zo{+@?|O@D$$cG%%*VfSGnG=jAZ(5dVk^3 zI#VZ7a-FF;IvKx$8vt+csf2eSTnDO<2EtblC_?+{F&AdDREA1#EL5fBX%5f zgr=V)?rXAtMpIn=ZP)oHO*)(uHSlEN0piErZQ@#nXJy=#9$#?v#qGn@31B?7s6xa@~XQyDk12OJb_`9%W;Ud{78pXYlx&$lMe_aAw_ zU*-9JlIQCzjGgQyAk=5rr?*XLf4i)$ zJ{R~0ys_BE{*{l_fzR-GY1^lA{=nwfkTbj?N+m(h$UEnjw2P~3*>m2wjB6nr5atpQ z*B8ogcf^;1R`cpaySrCtUL8#4o~pUILV}z7Mx?4Tu#O-V*Oo|iQ{d%h5|CV70Vj|T%b5Ah$B6CkPFywXzHp#qFR9oznB+EHGZW0SoBzBQx zHR{gn&A1>pk^9S{eZf`Zt{Ih+Zyw8zc`KSW_oS|SPR3`SnRV?`t}fx0zLw#U#8Qp7uMhroRI?!!3#KtEHhW(>u$U_35xypZ)Ku741R{_Qn~N;AxCkd*h5w@bJ`^H_iwJ zPdYxy8)uYao%&lRjBMvG+cg*I1Nw~!AYmZ zNO@HTd6B^KI!Y!JN6Mr+$Yi-jB^l*q610BEK@d3IDFTPlwZz3OO+>&q&seEx9q`$O z|H`v`NMv##{SM}CiFmW$!`y-t`yD7euR{Gd-XGh`6 z4EhRZ93?ndvhf2bX*;i3%E_Jj&g(n);Z?VtCzq~%_+ULxjfYp#tP^bfCcEy7Zzk{Q zb6!t&H8420jbW>dX_V$Hm{H~5rA%R3!mzer#zfsItsyc6)4;3*HT8A}=2Bm07~&G@Yjm<;A@vQ8rNP7Mvj2#%U*Ea1 zj#(==+CayRYL4~K|GRJh@;Q=}kP0ekJ2Z*xVGcrSf{>enkO@J^%|VEsA+=OL3qs5; zit_n+5E2hyZV5sr1|hcwA&DU5wje|&r7Y*$gOJ)FyBQHS1x6^i_$e4Puc3kW^IVYSxTd8{qMMZ@G8-8M?S z+DF-X;zo7Y_aV#_8y;c!Z=i<~d%!j?_e+>TZA=^MgRT1MgY#3SVHkE0P|E|IO{|KC z;FgKP3UlUM&PP997|GKPB@WHavFK=SM>|58mm3EUhvqgZI5U|2g%1Cq_6e zN5_!z)q2^>Sn>q)r=^PZX5J*{Jkn!=Md!)8l{#>GzK+bSU+D$))(KK7@WkS{gEAYn zxR%?U=W-h*D6X|PKjFZC*0&D=zMk=tJHXpJ6`j`7RnR>LI~jjQ{rFnMDP#T|RcU4_ zVpe(L*!d>TcpyHG`rx`*66QiUDGPgVOmT4TtVbku)ysb!k3rL zdeJexQ~k`HJeb?5{e4WT%mrM+b^W*OG@~osoeXr8qq1z~%YK}3XD(kC;cniv#k!^) z)Lr2V0@>mE0C_do`TQz2B#FsI$ad%rV`r@|0j{-li z$z?fakypjZo^qib5dAMJty569%9w>nIszb*40Wq%$ng9pwzY*%Jh4*l}nt zoX7}kXi{C2u+Bj4k0KpqQ?Ly45?hiEl~K)*QKpk;SYq2E#5cP(+M<$k&hgg(=ahGr za0c1tmdU-}AD!u2ZS0%pl#Ooth}pI? z{0o^9Io0&P(c}dywHy3{u{i!?Bk7Cv9_zfeox2~Ko zD{r4aF!VbY9-JmOLmHqmtOGJL4qvdQ{hiT^z04kv+LJx0bW{7wqsMK^TvDF>GNaOXkpMoN53r|e zdRZn}p8X6k)|4#zr9op>Gcj&D&aZWzPDOmvjq>l0^3|dPZ;4S4p#>kilNVOBZs|;x zEx&*9%+3kz?||29XiWP%;8m*m-zi>~%pY0}!|CB@uldN#*3nYb;^1sk&pRjgymnIQ zp7!md$L$e5<`ZW#rT{*i53s50^0EN0hO>cAQK~OCl=|}s2+6z=oxI#^mCStJdeUit zmCo0a#f(z$NWB)wY^GidL^e~e1rpnWmUuE02@%**p+tzlHa8Rq5!e>`@?caY_uo@k zM2*+JYhk_udai9y+K6J`%{D3-xw#o9%23%Y0H#`ahi|KK7E+vI~M zG%S?hy*gbi}4dyfQXCkBh^!s=Ouv}R~S3N)VG83b<3pX!+H z!ic18BSLf?>HTH9Zl%O}M*-8#^eUzv2^vlWvYrW=zDTu7?v?^+U-FlYoOPfB-pt4D zkPcvh$GhwKAV=+hrIerF0S-BVVpugW#jsn62K`V&aG`!+N$Mk+8(4lv6oQpdC|LE1 zvai2egk68v5LoLpeZr+~-jO4}r~K}W1LwMvHWld3A!sRpO4l7N)77INX8EN4D%7cV z|KEC%E%M%g4TNJ_XO(J(4U3w5g^oLOas3$(-1N-ziO!bzST0dk*Bepk>dAO* zj8$eOBNg7UX1BB^yN>iniT?YeM_+sN=($Iao=&vgCWzcj(fR5(^IHnHs-&*vjim=z zO*VQB2e?Y&UH^MDEYsi9e{$)%hmX|DbouokBM1xbgrOL#fB0~H`+9U^uyn8ESc}qy z9!^)>ajv`1Bi>$X2QhX3qB7whyx>$;oUQv#y7_qThHoNQppA9+9;WEtLtXA7P2uX+ zkg~MxEC_6Zf4OC%|2xV5mG&3BbJ^bAcF9wUWj{obWWjZpGF(T?#;&`Jlua-4`EOKE z_E}u@Qcss;`*DVsV8%gz(ffa;3W(hQ8-8VQ=%qrDVd-LoPFtTwZqcYkOk1NrD-y4T zZ@U1;^YWTY7BwZUvjgl;&tQywS2=jDnvvi;p025-OC|(lDmAjHu58}&siQ_csLlV# z4H|a2Lv2!!Sll+3IC_J|zY{>&m(=TeS^nuPC;YH&1NNBjTI!|#FS%Q4GrRs}!`Le1 zjJ(K(&QGan&fH9Xwe7C@sv45JR=8AFGhZCWCW4iw^9g4y1+eX9J7t7zd_4YPBV*t0 zWKlGDz01z6Uxw7`Sd^Qk=e1XdQ}2leEX4_wtJHq zQa;~5&ZQh1_qW&qge6C}qnicxnB>nf_GHIR}{#B#JyB)3vD_7;2 zGAp1k^~b*%N*g>O-_qEs(&#SZDp@K6Inic0-Syrqg)|G7(m1hpw|NJ&SeYIt3ANa+g>g9hG)~* zEX_Yf#EDsWuW2hjtG0LAzRSmB5V8lX$XeJIuNLcVtFvQ5fF=yjrl0k`zMUBF8@nh- zHtSt2U~Dl_fIO)xIVYn9eCVO75kz-S`=d~K4>tb*Ill(u2`_YTN#hYaSqvr*V9WCxo z9=ka|bx*P<8zcg?DQ?ppJ;Bi8(vjlQ@3uHgL~**jH*#@8ts2(NZcCqZW;CiB&HM5nM?Aa;I&R- z;%2J5-LKthBlqSkwby{tzbgBf%Q5w!;Sg+w2lFk<)ykI^FW78Z4sUIGgQNXfj;jRe zmCUEPW>F4A(0o)PP=cW}XDNLWZ+>?)M>g}J8+Xvgo3+84MW-(AJKE3~TI%cwrO!TU zsUc~YdIfVYM!H+Ha-zAAvtjxHN5b16;THjHiI)W=JdKLZiK}1)W$h2Q zw2EbqM#YP%!M#F8ws{yMixMQG)|=0eoFCA8H}83n*$#qs^4m{_G8GTEm)+^K3K3&r z`bhVwrVQb2m-q& zC6oHiYuy$Y+hD0R-f1>AuljSUjgHByea<`GX2eU61rpDe%Pz7x^s5MM9C{iX(B~Z2 zPQG?pPWJpOxeP-hP1m-w50OG2voWV>@3^4A%kJR7&d{{mzDe%*Vv%>@|Xc=@#g^z~;@x)4j!O1@@pm5c-0ii|f7l8y&Bz6$^JI z8=5Po_w1@k_PlD;xh@aT`WKoFpk2R5NmMPQ5M}}OXK+~!)?i%d1sbXk!s8?}Y{ zu0%1k2fHLb^1EBV`@F@32*nI$Nw5Kzrct}VNn?Ds1F`6fy(bd!Eqt5eeTGdq54>|D z?xr}*7Y<4|nKoaq-a8aVtN*GHIOR^!7B)`OTq{Q?HC8nb#233`K z0gI!&G$ju&GaW6{stGN*YBH@9tY&jGNq#j+8zP4JsUTvSqty(Px2P<-9qfWvVY)TG z(Z)pc0I#4xuJ43A5lo9?*&M)Z>^iLZWxarcuorYdUdzaDo|VvICD>|;7gW5aeXJshlgmj^iXVh&8w|cYIc(dqN8o0%q^{BNGvduBK5xEo(er)$VMn{F)r35F1FTyQBdr}F;5&wZzQ>~<2T5~5ubX{E$k>Z#j0U8 zZ6mklZD66r7z|_s(d`bnNnv)n$e3NLF}p}bM3B%ME9+(z1!t0ctD@r z$R5c{_2bjSdk}HGm+GfBsy06OaE{ z8b^Bl%T~QZNS(Zm1!z@bl6KpF@%YbjQ+aGk98b_=2qMxgG@n3) zPH>1jm*QgjG*6|>m_C)?(&x|0yxKhk@3WTx^#)ZMhEBiI6jkxtl&YmgGn|R0rQ!I* zsNS{~untRuK5+v#)O#ZjGDe5gy-K@Tf1XGl|1+o1fEagx@~mSYkryI~#<<1|F#-SG|gr+Enk*c@S90GqsI~ z!-6=dkJC@4#Uz~UKt@k1+0%-Jd8YJ~W%^ltwuclJ8OG}BAO`L+0po^EYrM(aB1$$2 zaT}Y2U=p}nG+Q-;eKm%Ev2M`||4}YJJ~vPnxZyvZfntNhA1KDt$x!cQMutBjWf*W< z6rZ9^%}G`_=0JB|)T>=@WKC#`#iip@aJx|?KGOV<&k_hV8LXKh-A}l>mvivJj1Fyq z5T7oNfKZJ|yv#-Ffb`o6O2^9xQsesg)o|soYI*~1cwX}p(3!DT7_VN@OEai=1JBeB zkBgwyP2GyvOvEFE=7513=RNR#?x?nCroA^IM z9Uwgj4f$CKfdZUPC#%#3_`pIp6K1c43lx~voER+v5{~FXQ(&%j1(~>|7@Pb}Y4QRw z@K$<$msMnUFhk@mkc^Z-oyII*nAJu9p*XR-jKysqZHF0Mh_jp_G0d08?wNLU9NcaZ|&Gj4us z!Cl~95+OFmh_~rabF<*dbHKq*;3w4&B>fHKMDy~A&5Pems@EOVBmh7Q084{wFKT}HVo$IG5-bf2l3~i?U8OlMFg&Mnwe4keumiNvnqtsS2Ai35Gig4d+O_tx!#G1S<%)y$xgOqglO@vBt(4}#$ zv7LJg1cHZUKM{3!wg3i6fR2QGWUchgtzrj!8&#h-adKx#&Nmd9X5s_~{G-qXuk<8W zDxP&Bx_BB+*coYR>=kfpBQ&NyrGVX*5#@@k=SkKAo@BVkM-xvNns_3y>%w$23sh4X zwF%9OhOleXv%t9G)F#?Wf2>f&IduY1i)+YrYG91;L z5$0yar|2m{o5BnM)Nmq9BlAgOTjMto3oC*(+$^yZqCgl&Okt=XW=PJv1z0BP<^vL{ zh-a2hzfG8iO*1s$~)H_IfkJQmM1%AN0`b|1`ML7hL7>E0;|lxactgPqO>)1FNaK93 z;!Vd9j$rOgS#%geC(TwTG*N`DhG5DfQ9wAbU{$(B1?{EoVmWWQ%n{0LveW!YY5PD{ z>N!AcntRb?+mtKiwg8VRiU!`U+};#Cy%gwNWrd- z3brC45)LICaw{Wi3#LC55_+jN~V@~~%5(}qq^n~{YB~)7(QNZler!}sM zi#w1ZNY$uXE9Y9sb+e)x9eN}Mq&8EamIXo%dGA$xA}+Az_25?w8NW4GvK=Y!WHa=b3RpO02*)-9^07AGwK z{2ro7w=2%p#ST%98mS9X28p5Pn}m#A0(+8AYNtZQT7c+R?H|OgA)_C40)QGCi$uPR zyj!WzJH(|CE(yE^ucp}4E*t~=&!bb_I@_o|LBE=gB)yvU3y-ciCl&>8c z0C#m(Nw?%N&QA4fg0+rY05J&?=oUZ$NIU=m9ppkufP~8-^HmrK30NF8u{cUuRfHLoxln22|O$U+K8tG^Qn;SxoUVrJJKS+A${F~zy11&{Kc5n zPbZDEBrCX6ex_BIK7&-)ckR9W4Enm4(wId|8T=~leYn{qS*%~vywkxI12JqIzrBue#3Ch4zOuModgB>94%*37*>jG0#EWuE40Tw*912(sxiry z4c``@y!^qSx0t|cA|Yzi#e#{nzz!0i#BN@X=K*a7?8n1AZs%&?At^{vBwzzV(vVv) zI_>cu`oUI`+6UC8MLIYfaM@=~)m_VQMG&AuO?;d3$A%7ZL#h4YMo@UBgCPWkRT%cF z$r(90#kLPs)N15;RTJUUWHVH_^No`!P-BED>RcuwYo#IF(O|a6^t^;Jt!uPEUO8!8SF?v z5uc^?2gpVDxd}k}C4hDNW~xg4@$AmULRSRrS5Bssl`zJ}FkVd#428q+Z=u}JZ4KpS ziD`aSFguy$Y#k}-vRQgxrWk7355K9NO4lZ}Plm8DdZSsLRLsJE{T_9LW?M!v|4NM~um1B%!f zg-5ETMhF<>CrJu+NP#`7mCf)k6K<`L;y`rENZMsJ(Jag?sj0vD2wAd6z+RW2LpmPT~#M>xqj86&lG36RYLNL`z z_s}T^=(IiyAxe`Y+8v@K-0d+E5pWnqp*pV(Gu%aFw}DrCwfk{skW1qyp0=Av*Lg&4 zB@+Dyk@OEVstl!3*%F3}AfY}n0s2n(U{}{-#RE9EN3`P+WF!=5kSSA(W+t@6N((xO z1c4UmCzYT=&M=Wk(ztToK>&AY0AG}slq#UB%#|Z*WWb6sA^A;obOyUvWaD0oaK}Dc zjeSV@EbV)`pDd*KW4Ma!Q_jDeXj3&xYxWu=fwT~=d|CN+;2~)Jh_yJ=Ky)Dh zzR}>#(%=%C#Hkv@f!*qZ_ae%PqK{8Cgj_+;dERL75+V(5K>4d)~D1jg0U!fE) zpdg7YopMPQlu`NDgJM+Ev@u50sERky#Mpvz6}Df^)`~o3+;%l#Y2$eM#I9i4b8<8k zf{ab?hJfJ)6Dn^morw%8m+#?`8uY23KorskW@V4Ldsow06v1hNdYcTkZs5(5u( zc#xf$8L_+}C&nKNX;n&VbvC|DJwug93n2aGD8;D*Nu8@1#V~^bS|yc?nk{0qG*BC@ zae;Xyg1P3G)G0)}#G>w$R4Po5RxH$LT+%vz!FZD$$Q#w5OE5u&1kGXm2 zrjZ`<%wui-u6^v7-f6m&R?<7I-2LcAIKE2#C{b1Kv}zY*_vm}4)i_^VKLV)joi^SD zO>jRG-OnWb=`HwR!^p z{gXix3AR}RhzEZQ{%-S6w1`xT)Qo_Oj5?eK)R;-R8tRnnv9ocq>3W|#@sO9sW@q8|vz-Ja@5j&qAk9KB=)pR~q)A?8>HpD6i zwDPcue<)Vd`B>$6*CK0WCA2pLtN4dvHJy*ubUs!|kcU)Z`+D48gwuKhxA8`9WSj5W6NvrZ85ak6Bzb zV+D^^K$<4lIV73pJe#c8M}*cZ338h*BzMWg0K#O9ib%34@+q0l2DoJKM3+n>KTO6r ziX^KGlG!X~)@o^*HA-nw45<|llcy85tWnZm#%3{_J)uTzcAJ(a2Bug^_E|bLYD2*2 z8L?vRvGcV@w%Hm@o1``gPwu!>YEzg>O|n$+FcnR5snn#fEHx=ir50JLT55>|T16?E z_-F>AEdkb|Zk&?S2$gtcGBT5g;}G-?aEr)jw~cw)(%j+m#gybxNo6Lp3m|p{t!(V++iUgwGn^JME}5qdh*wF})$0 zH`BR+1^5u(m^U)np$mEIgw1r@Bm4!0=e1|ik+)b zCcU`ym#Pp+T=Lr9sZPR~>iTi2lW?X663!f61dv^O9^1;DH$+{itCeSiHDA_3Ys?T~ zCMY9+6>Tmb;B;2x=h>@Jm#a}K*kWvV!)BV`{5cB6f3m%US+ zVCN9kJ2epO&IKt?d$a6Vr!W`brFUwLI+>uE5O1OZ4FIJ0kZ;)F=*~#ZMV=WC1izps$B90VsqKsh%`q3yR0--+#t8op{_|0VC<)TDMpd%Nc(J$S_(0t)e%tJ%4&R#E<=nVJG!CyiYUlJ$ol?RL@^FZ2 zDEfEfqCG@UV9bSW2U-8B#sC&CIvEn(_KjGiBm|~fcWc0|0m1^RBA{*?N1$w62-H!e zvkBZPdsShswSL#of$B!FXDdMrP?Cyx?sk49f2k+&f*)8jod7(Uxg|IO^be$={?QRa zb&Nx&JFC761fmCwT@dtILKM@1+;QyMay6Q6eWXPfl+QGeY{#Qpqt zgTOv8F`K@NonJnr1!%3DkX8lgGyJo!$suQNwg%FL)xFaSEX_?xsrkzn0%n0@U0*cC zXfpykCthbkA+uj5>^p^Il%=bz;r??nV(dIhLQ^5&a=z#o`Ldqh>mR>1io_-c9D$(q zxKJM9IsjIl7t$UAX{m<-q#fAnrTG8mAb_?9RJ#k*y+#Nde6I^Bn@A&NxNb7PE`08X zUbImG3b|tt&LNA9O;ZY&m1n&G+>87ph`=3yHJT2HH<)Asj83g0$!5SG;a{Bq&zKGI z#%2bDo6pjnQ~(--Tk*&kx|k80TI(o3bw4-d34{H`&K=)7Tw(yLVkpR4CNtFd*Onbw z^@yyxg`w_|$V%hccsu0uu*hjMA+dm*d^L_5!#~7i^0%7{pa9T8BT=*mA}n}#Na@27 zLaLC!yjkGR(bzEAHkjFbk|Now{J%(nyS!OhlD$Sb3ks2yv`e}1B(k~)vI5#x2~2C+ zU`4~gw<)eo!4@f~p`{tXEYj2mxisN6-6i~wScp**l+?+Z7^~qv+WHbalM=dwguyd` zph@=+RxxY9wseAfBR~90coy&CU(Wt;!!Nk`Q=PAf) zEM1Dq+e;s@#*SrxXnm;vm$mDxIl#Z$juz2`>R?~V8X0MNq4r+sE&#CJ2yOrrYOlX4 zU@qo7L^%!6>}4W2Jwm^zg3^zw%19{GkycViyof4zr3PS@6EEIORqR_ zZYI-L>@t+-5;N=!-(!I5oW2g`i7qgLVIy0!tz-(mQ?;~4PUhPz4Y`!_Y*E+}1()6L z=WUtGMS`5XELeJ$vnPMq0n9k z<|oWv2nEVwkC|$LHR%kH6aXo)ALbd&J-Tb0!d}ic|8gO#1gCu%(drNrLcRqLSVmAD zhq{=s7r@k*Eii#?CHG?%L0qPr+A#Hs`Q_Uc-h#mG)7zU$B(~V>doH8TFjgEd65K}!aapYG3(~F1Gh;aR!!II zbH6_RHNb?ofcCz|;F-UPe{h4j8m!eI1uobSbS41@{4Ugie-Y4Qgk{BU)hM0NdW}Gq zQK`q>VuXn#9R%+pGi)Kjb?qXRj*~ng*88wnudWhm7GWWRo+nE8n85*o+HrG*`T0`; zA(I09a$P0t8kH`7u|y#wh+5=jCU@TA*BT!5?8C`p`@jLFuhg?Pa)c6Nei0^QwtBQ# zInr=#_J?cp?}iD@jxwRyBQc@b5hgVIT`-|sm&;TIiJywO)S{ch>Lqhm*V= z>kO{V*CJDG-%8&yR?{M;jYbec903wh$Vj(6IW9^k;7GBjo#MKvSax8*Wg9e1s0OvM zr6BzNp_J?!cA$=SPj!=O>!_670czRr*OGPI{FnXO>uRbhgLKdgvA{C8CL)&M7?EF9 zaW`UN1G-Crs0nM5u{GV!QUvsrLi~_CYGh6_wMt|61)}&xgk=+f)kO39JgH1rQOkPr zWK-HZ#BiH;?J^sel9loW(qOR-TZ0*y{Eu{Isx5#k$sak(=U#ijY%q~(bcEcCR%w62 zI7c{F!rvlP9^qd)xE81>CkV?q5^?yp_SS-O@QJWn?j!phi~_)l7d%BMsu90Cwr3Cx z2|?QR`Nd9{|5%OrZuotTVH8gv9+m{ndmSDTgW1o3Y_{MqMKE(k3OSh0pv*E@ez$k} zx+`YVNG^#YV*95YJ$GF7(#1qjH!QwZ3^f2q4D}-hQ&J`u1m=pw#nJuJ`%+(PTCnMY zg{5nNH%l#+6`@%~LMS!dGU$`k*vLtUS*jYxMzg$GI_RBlO9}6qvz+8@k~BS54&kU{ z>>(*xV$iUFil88(sIitm*4ff>3xHfxa8Gg;1%NTWi`4UJt$F~UPAPa8^&$`eut-7R z+{PdPBJ6_zK-i{C&?V3aWg-p-OC@(u&FGbS4K>X+pNw_1)t`%oPOk{>k?B=FYm)}P z-#Tl8orZCZX)ywJ@zk9eR+Pdwdv>TX?<61kJEy=LPk^)9fs_&y$U#sc>Z@oRurU!> zJ@{(|6`dK72H^NC|Q+|lCQ`4!n?{dfYC)k>w^mN?> ztJg%n?kH=E4h=z$&Fquy;b%XD`cA^u@K7i#dvU8HM%K1qR2+2as25UhKI|5gF!J;} z7Opmm!&7Tr)DGmvZFo&;0to)hh&C0awyW$+DC8r?9HIG*B<5eC{URn3LZ~4*`8?V- zglu&CN&{c05-hFE=h03z086CxRb-E;$xw3N;&`;v18BKCj7P)8^Ley?oxu(l3*(We z7R(kadFEZ@6@a1t3+5>Az@OHo@I+fi@Xd|zLu+e6SQ@bUYA$6v? zH3?VJ9H;wkvUri+a4$oqgk$)ZbLMQ_z3??W+vHh$FX|LLecrV{HFoEoj55yS+t16X zUj8Ovh~>1{7suUxBt*Qe{SdFjY#_JAQ`-+=x%>p683K=MMJYke$$NMUtPlV& zUV;oCm0E1Z$So{;@`M#;5$u43Hp7*-lp>CaJSOjR`at-c)^#G(s|sKYrMO+$N0?RM zI{Jqx4DT>B3EXmG1aOJV$-oaP6eMXE)S*O5637+r*6f+aW!%$VXg_V74e6YFWnBF7 zjB%B0DyOcH5MaU?vXzXUy44HrKr+1F4N0x&HL?%5-Jxe0xsOP8N9c!`nzw1vx0BSG zeMIn*yr49?P)kkhDWER0wj%X!!NWcVlk3UGb0lH{;l<9^Ry8uGIH?N=)a>|Q;{Qc} zbUISlO+5oJfM&DheCepjLOU8RWuS6*Icht}g==d={9iT@Vzc5n-ZHr)wH`>AknK1x zIqGJEY91U$Xx}x7e2fB_Q7TO@>bN7{kgrn=T&^6PblcrlTQG^S`J4)drpYnKoXo-p zM$6V-@hwPYBGx@jT=agB(QsVe&X;gwRVFXV<{Ar7^daGbaf2v#m=1*w_g6pAvW$kU z_2=K51tISTf6UPImb-^+hZZvM6Gue7t_mD$q!~Fr$vZEF&nVbxThoBCCdooR>CY|$ zJIrro$`){%_FitNAV#8lT~SpwWpqmFKC zDLcl9$G2HhORfPQs7iKG9qlzMS0nUf<~5n^7ecLKL{O+`+$tW++m}#9@)NWuCsDf? zsTv0laz_dLVMLOu{3KR*CGwG#!DNn-9`uP+QQ6b>GVy22u2SnU;hx*`Zf)lDFR*vX zY=`}+NX&gdon|ZaKviWd=hz-MyKVIBWT7TSII+oYTS<^-!xqM5`WI8L$)rwg^mb!1 zHxx7oa+;_GZ~K}k6l3!>=^(*?5L#!7%(YellfjXMATWlBkiVM216!UicJFr4nN%fA z>UdJ1Lz7VCOoGEP;U-{MgV%EKM~;!av`SbIatqPR|2Ke!ed|?H!T~@lY}|IO0Hve+ zVMuO}n8kz{QiSxcRuNye4D5^B9ngu~0i9%bKqrEwq+uys=Uo1Sp!9*Ifs)T=a{9$) zaWm+}W6h?3?X#&xhgd-c+tM&95SJQY&O?H=ogaLf#k-*h8XkAT7K>RQ+budEnA%DL z*e=V33Gxwlz*;uZab#{M5CnB`Zf^x7&OPzE1uzdQ9mSv7`p$Fed36 zy1@>Ubw8Nx GU?Vrq0Qz^s6FXU!Cl&1MAQd2BV5<#ukC!+q8VgscH>Y&Al=2B>& z%%~OSAQy17n7uHe4kDu2n%S9N!poWB5J$Uu>6SP-)~`u~Bn%4ZDrDQcy{iv8ZUAEs z^9Hc$XnB*BBgJSU$71x%!qvYDvaE?_Iksq)kOP8rE>W1}r70_Nd^Ee-qS?U>$u5`3 zWoK{VsG9AcaZ`$6g<%q4g`&86VjCRZ>6^W)2ZPqUcLb$|BgoJ9zlJ699g3wOU*Ax3 zuGMtryFwLt<`RXN58up~1YK&`Ak0G-Q?cQh=v*%yu(0zk7HIv zV%Xb(=TuIEg)+?2ABFm>M8DG*0b2;TkSUAFif`pKINdgazEe&R8liCa8tEvQ#W&*Q zzwpBQipk_6ZtZXDoY8hV0WviQt5%^lLE?s*7Mo%M+LtlLNxnH!v2cI>^N()IGNkFD z%tWN6_ve3V?062Nw|wBQY>jPJR@K~D8uJq6E*vX?iRDG*cWQpyR-H!bNUNM>Rm`2) zmBIXWjAU6=0^WdHLbVE6Ru#t8jK5bibU>qy0~-D`#K{Z>GqOlL5IAgA0uG(1!3d*i zkftzSLyPngd8$(|DabC*$tq zyYnLOvdkO4%p>vDDxzXrRX9QzJdyCqx{g=d{*++5XyE2Y>W7SJLJ4$8&q068`l&fc zEzn`=0>~}P@2TXV|2g!poiIqvtRz^++*0Q%d;2Jiqi-S|rcue0Rtd=oWX``PV#tjd z8u379%R46 z`4SR>nTXZ~sEXfc{m3w=hzbFPyubTC&oduM@T0rkUjP5KxvtD}zCZ4BpZnbBKKHqg z;cgx?VrBsf>$n1i&C?h_sTZJJDnOYjK+zuwLxUHfxGGNnHFUq{&?(@ma$`p+mjUG# z3&(7L++vLS0{s@bORb0S@S}Q_5E3TD5tMe#l?T1u&UNG#hTm$2wn7IuHkOl-ZOdjC z&1*T*ddStgHkhVjN1X;L&X!SU{>a$Z%h;F7_{(g$R7j~X-v$ZqFfXlT|4C?y_Q>{n z6e^s>7$1eiOrmvCT#FQ^%XqoqQ%k*+40cPjbXd&_YwgTvG7$&SzWP31RWCtQAgZl1AKo+82@4&vKgzh;uR~qYHL6?WuhdeHXg+U7(|)NUux=<;5nj) zshqpq%rL?(LPR6gB-9Jo{Uj6s(*?1mF8dBhxGN6Z3Jq@iBHa{HDRwW)1#hG%Gt59> z1m?(wM8TK2PNf;mvionA@oqko#I1sBt_psZz9Q1T+!c4o$L8yVRmnXn*Xh~~XvPW2F`f=1G8K|(e_AfbCWEh8=KCTNr)Ty1M`z~x~V z11Xml$t@CADt!T!i|%A`Jt z8j0!Dha{gI%n83VM!&t80!Di4*F37w-g5dCz->4d?YZ_@g_oC&*D4=c+9;mpnIYL>OA`BEUACrB>Olj-M-mNs1vlzKhPi3)+SzuQIs;(ue9$#W&-|5R5auvrCWytd zKy`XNB1i>&;#bT7$TVk`yn$Dz=`A{uWrD-h8M8XHkrWKT95GWO^M5x{42oKl5aleU zliVF?0Y_y(pEa}a7$G7mc}A+?_?U$66RQ*UDB;9$BgaUAKnrkDwrg_BM9)`n(?X^u zv&3BAlQs(uh=|Wf(O6@I4#>ScIiC_vn%iHQ#bz{so*A9Zx=7@AE2Ki@!9{auWS*^9 zCWE3JbonwF6a`?p+yYcY7fhO@xk*Q#CgWzh(I%+*JAC+WcG2{BjKnfCoHFl=bRNz! zOgiNWO60ee_-Ji0BVlN>N_k+(-Hy&j}{0ehVW2Eeq$wFpm<&zsv!V+{-B|P6{5?*>4?(ug;&XFcjX^;%7PVF{c%f zY|4d|1k)J`QO#6D203B1KtQ@k0~Mhw@fw5%mt41di9nDWto~S+2pH}^)+GWKLOmw= zcibUB70pbAALUeqzFjaWFpX*WprWW}sZc^r5%v{v%Aom`hN4 zci1C{b1r7e$@QfICf4(?W05o}N+WZ#WiT6ie4v z-RqOPUNtv8`O{4wbPp^u#Ng1eXXx16F#XbbA>080a4>`*Q>xle@A%iA{th?)WA)T3 zw&#Nk&Fe7Wn!STe-c2{w*TPF|tZ4=J!c3E`iQiM>^=O`RBW!#rUX5loi^fj zSbAF3L#LH)#4eD6U@Yqg?iH}i`^qVqb=y#Ds1NcN*KVb;w0=!^z?%lV(LEtP?@5n)4{kdO2M zd*6bXGe3Od0<6cfY%UIjt%?Y-OBj@nDn02DgS}NeuU@9GZ2vT1NBo*opOVoCq6wkL zC)u6apW-oTO5KGGfn&q=s(n7JBG`$tu&=4^+4eUHm>h5$ST1K~R)blR|;iv4}SCj3tPO*Cm<=2}D&(d4v6i9x^h z%U=6VyP6r7IUA|7&a=#SU~y8hFZhT_P6#trl}_2McB0R3C(?mB{tY2c@CF(pGb28Cg!!iHRMZ+B9 z0X|-UzfFxR?HW20Q(#diO>&xs9UH*j<_yG~7k3RgJ-h?k=I<}a#S;per8YKxC}yqw zGV^3pI8M`?r*<8Q`k#!hqE9|wgLT=EwHDzK)kepsnZx0Wohf%@s)>yzdi|yMDSTt4 zO=wBhwS=3j&OXpO=Io|NX6zT)tpj#Smse1F;vF0YVcFJNjOOvq!3EaRcSV%|TEF;r z1ngO0W%ng+2?tB9+kY-A1c|p1zPqut$3_(sU8u5gcI)GIauSa&P5N(ka*d9mo!II} zKRsakkJ$dL>q2y-dUvdPkCTp7zqz1^ckZn%kR58Gh9xhHmLyMO*vX4X=!2VD?58Gq znEe@d;dmTHujhVEt5C9eMpKa`CO30;%4>W(w@dnNnm@oqea7wG<23a-y0Wv6*rfxN za`=D7f(C2JBR+l?^z*|r!UWC_Pm$n9eWZKlVF|(PuY~+sL%8{!r7hXtNF_rHtQTm+ z;@{8!$OO$#Ya%Mo_E;4s+KHZWFs$6J+hKK`$G9XPP((J^HX9(?tp^2ssVVo{rGQW% zF&XUWh^~_%R>0uBMI0fpJq}1RSF%J+civ5yS>sy~vXkcRmt=Wg=Y(=53@F_lurD;T zqkRwztAt$MzLVj%Q)|MKBo$!}-4>|8sRYSdd%l0a4prTb_5&ADxzD=&5~fsR;&p!v zqPMUCO53?wF$kYcq0JX3C*AAf&(!3^dnIhf#mVr!(Nx)|WBwN(B(cvK+_i@;RHkP5 z?be-kYLiyK-tY7KbY3bQTo;s-J+bPyoV~kVO6>KswzHc$8&Q+t!pza@i>g35SGE#5 z72%3WQS%mrI^^_JKQ$t=N;F&EQo*%k$|bH6^y`t9K`h*=kiM{$Y2ghuHve;tEJox+ zHFCRSvNOo!lhiTiE$vUO%-&ZNHgD~Eg~(Tc(G;df6L7nRkp&hL$+;w|?7)Nc&lgq2 zV@1}`0&5$^Qu#MPmc_6_iw2ZZ$Ex>}D^e{F&D+vUV`{F+8EkM~i8{~5oVQs)Gk=A+ zp@~U1FME=HbPUm#UTC*IVMEc;nXdVsOMGL=@IOiz3e}UoXD26y8=b3bqt5clQD@qe z24``k!TFn5gR|UjOir6&Q*ThnDBlj3%-_Q1cJbA1UDwi z(pWA>zLk((a!yVKB2K#J%`^Pz9mA{AwcwH6YL=kcT6eB1to-MY1}GY}F@y{?_s?WYMAE3)-MhIjog zb=5Fs>JaToHH&*neX8Xg-_+Ek&(X-pwA93KeQL^?4rcr6Q;E>NQiO zw=sfhqn{aaj>K5N0Q5esk@lQo} z9gdBEEH=K+T{(tuHnwhWN|iNAW28}0XFwv$qq~MUtcXdT_Z!CViH_G`d)JZJ_^r}` zw@B-3m86v{OAgCj6O6$wO5DnYMm!654VjeEMP|kf_>$8gf|;X$K)_QOOB&eNt%kH& zYu5xU#*$uE$};|7cVhn;4~EEI{ZQg)$vReWpVc&|D*H0dikIbrmjlEoUWNoO_uvDW z!7Kq+5+irXX=o(e=OXMq;cX;vZqsy3u$S=(4ege1U8e@4Wzulr@+x@C&-8<0@>vZ( zvH3HH11D?|<6FXv>@St?rtlEo1?kSPkGA{beVySFadho$vtXz?d@F)9W?o<9^zqie zbt?C^fLh-nll5;9ckvu`Jssj1#*=CoPV~oDcZU5GWizv(7>n0vjaJ1Kx8ty7-mY< zD@VzEvs3kc(o8W!7!7{C#Cf`BZ!j9XytF4BxG2OQ9Jsl|aNN!ys{3-Fzsy5bnePCp3R&Xh3ziP^8D zX|QxP^J5mwoHJl29tudw z_J!z5cMejFY3RDBq2$Rg)qUI7{`2eusTIT4gTskKXGEDOi5JI7H%low>TG4!MR&c_ z5S%b!y%366^}|u8H@Yj^5Nw&?Utey5b`3^@u?Zy`LU^l>_;;;(Z+M)~xBSmn9UF#) zxBfvi;1@)lTKLqMGnkpr{8^P9B1sg$g#9!u3X+t_R{~g7H9#XkMDY(df|@d>@+a>1 zJvXGa47ZGZ%-K^tlv>RmqIl@1r|!{0GS^eH^L*mfanA0Z!BYE92HlQ2N1V4z9|PLQ z>bIioDYc6M)5YqycD)%5-V!LubuDBA|Huf;kr9*rbwV2cIQ?57>=~^n7|`9(#Gc{- z?I|A6p3wu^Q#_!FBW3Hv_LFtlfdA=LM`Ucx>5BE>!NkEcoF@~njdKPJKv|`t&eP7} zB7hzyD7tHJLvWS{(8Ig3(O^rUWMhbOtKUw%=hd*=1F<=SOS~7n>GVYJxSnijs(v`S zIuN#7pK0_z8|@2(nL@G(n+)G^BNQ81gE%O%^Y%jbdX*)TfM8)vJlMsRY~w#gu4!Tx#G-aiJ~&-$Yw

Ta%480W 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 r)@g#iy+^{^5@W8 zAVLio)h$l@X1J|ow~Tg2hJtxW_tQyy9sJ%rx?kD=Ckg<`bG|+c|0O8Tb{i3$rQaCB zHH*Xg5VE&HHavZ!!<0>FfpPIULrvtVE^`|%${Tn0(fcCQ;nUv6C_POPc(xixldmZn{=5f8PUTc6eBKwLvSy&!dnY=vc>KYtd-n0 zfw|m~P@0dL7BmDnHB%jnK0bl^;c}XpmSa|1L%p!FZ}NO?1eS;u%LTLTI|Hmoiz~T? z5Y`E1r{xIPF_z!!!49|B2CznpJqT86v8^F;+e74bf!Vfj68}VynPZnJ3O=V_gWl2h4=qNphRPs=4mk?Kdq`eD8m;OhJvhH!Wv- zTtos>0cB$$*fetIgXOBhxcu{xN1r8Nkr-Ww_JLOmo}UfNZd9vvF_vEkH&ZWI*F9jS%(Ayk2N#Di&fh-@bB{Xg zntsrSU+keThUY{py{G#CYt<++3^oBN8hCzXPg9=$elU>BI7q$Er)` zP5tGp0ROMxUjX09c}j=cYeC=NrVs16pADnq*c|=+G<`9Dc7J`nQGcnw{7PbZyg`8F zN09jHU4_K5DJhvhuWlI7YeJB;$AFij5i|Di9u1by!JtFEZ;I%M{eM{b8upT%~b zF8EpCW*-N-A*UPsK_UMc@IQeY`R{I!@bvWs7!5!F@9L`{3rCX;Z=9>d=DIAU^~AkWLLu`p*OJ09Sh>Nn}3wb8#)N z-iJn~i@^_0XpZ9IbQ8~_e*D?XH0Ln}A48Duggmm@xd!q(AWzw+j#Hn}@%;hhO}W|+ z{B^<420!Rx?cc~>4_*$A?!oyS>=_0>9^t+T`CGwFe%%ZC`vw0l_~YO&K+hKN^-DE) z3j9Uzj$RGSc>knd==eSgo(uUmApg3M|2KF^pB6Obf9!Zp|9za*7udF8_B! z-psX5hWr5J@#U05{x^_c3O(n7m-lOM9QYFOZg4bDP8V^uXDc$+=wE?!eh~71g`U+) zevGqGl!s44|6NHfXzEMfFLb;vAJF^@&~pdmCtsq0dZ!tk-V1w*MSQnF{zs@-rd~e> zdGoNAx)(-zeh#q;Gr@}?e-wBf_2P@`n$T&N&lxdKQCYSnNy&cfjXqZ|ePooc=qY-vyth!*7IMr*42Os77%UKTY3jP@*5BrND|0QrP z?|c|N@1q{&W1y$@hmiXwl4tvW`YUax+N(hPXG+f)X9Maf#ataPfZrkb4)FDYzYXq! zn|}FU#5vsWPKqeKYL5V&O^k7Vjd9#lb$DvhOQ%x|M>!-Rb)0B;Ur>IQ;THyZmErS) ze6itY26>z~+xg(3+D^3|O(JWQJk?XwmtuIk9lRJE+2(u$d<%{H__$PmIX_X{)CSsr z1OB|?W1P)MH&kQiHSkT~NCxM>;9ErcZ$LYI3s1P{Q0qGgBWfBwT$`_`sT2ly@|0;I zN7SLfLyjo@B2m~8rQazEJEGn$p`dHjtIa;2q*P-N=40m|aFg!F=`e6!|FDmv!H=;a zogWWAUGS5@O))Xf)4^*Dz;^*ShPR$;5qPUd^vRjvy@Hp4^SXt7)PS$CA)VKQuM>O$ zxT*if`2z5}48V6A_%{Ua2LHa`ec)&gJ=YZYFFm49R)B98{BrP}f?o~(f#BDHtLHZ@ zx0}G#b9@%R1^gsaf#CKf@KV9=23PmfEInTbzgWmW0Dg(!-vj@Y;17YT=g%ztkAZ() z$o~xdD}p}_{(#`W0)I&G-+=SFj(xlW{-WTof&WSHx4{1*_}{_*E%-mc_tnjk7xaI? z4-!181{m4Sv4ZalK11;Rz|rh^`VRtc5b}qEw+em?_$7j$2);`2Q^9$?%03FfZx{S@ z@cRTm3w(><72v$SWgqI<6Iw@oP4IIe|Bm2`z_a|Jh*EbU_5g8vTucESGu{w=}(4E~tle*yoM z;O~OJF8DvecMJXz_;}I9XRDz@wlhWW@!(Sh-yb|*@I$~$1wRtJQSjry+XX)fyif2M z;41~61%9pIbHTqXcnSD-1g`>rQtHwCioigTERa9-YNJ^;6sA12fs@2JHbCM_`TqF3;r$e?+E@N_+x@U z1ioGHpMbw9_|L(|V7_3|Q{PX@b`BQ&*N{I+@ZW>a6Z|#sM#0|(?-Kl7@L|FK1-@4B zEVTfV?c64K4){jF_XB@K@Pom(34SE_?*u;{{C&Ys0pHh5n2@0P;71C6I`~Y%i^0zn zyb8Qp@H+5?f-eA%3%&&WQo%dGZxZ}s@UIGf3HY}K*Y_8*oks<~9P#BC!8d^)EBFt^nZ1AfEKNtKK!54#X6ubreM}l{O zKP7k{_{)M1f&W$TOTpz5%9Y>;VqMO}?bF~V2)+*dbir={H@}Tz^n4k-Rmgu8d`R&7 zz}E`?UGUok{}K2%1%C|u5y7{D|3dI*z;_7#BKSLkzYHD~3p%fYA0+r&;JJdo13p*q ze}eNmdf-qCMcGcL;QN5D5IhEcgWv~&-z~WQEr4uiv*5=;{%OHa2LGerGr|8Yco8_S zbKA#R;8O*!1V2si`QUYeH-nqs<1t}e0G<-^?ci4no&di^@BwgMpSF+X;ExD?8TiwJ zUk(1U;MaryMexsq|5xzaz{iWF&aZ&Gf^P($E%*cA=Lr6N@P&du0^Tb46X44Qe+v8t z!Jh;Fn&7_ye@yTl;4caOXYjuX{#Wp^YW>E~vG>8%{!$-1`nMvooqQo5RX1d_oeIIn zfiDt#fAAi`r+|+Lezf9Z5KeZT0Qnn){Hfqy7Q7H#uiN<%n+v{G$d`h@EO-t0yMi}> z@2}>;zWznvdR@xr7lF?f@^SE5!S!!vWIN{xo`Sqy*YWkQ1YarSuK@py;A_Ee7yL%W z$Ev;MzIMm?BINaYiSP0yaJ~NF^LxNw6#Bmj{*K_^0oUsazMda~PgL_8pKk#_Oz@w9 z=L-G{a6P~G^}GOHCgit+HwgYG@QVb06MR7Mzk};}vmfqm@GlDakHEhn_}GKlZ?^NW z;1j{05nTVKNw)Jx!4HT02ZA39uIGimohN}GuEx1O&jX(>_-Wv!g3klj^DSRb1$eiR zuLWNzcoVpu_xO6w2mgwYZv%f&@E-83f+xYZ3%(5eUBN#EzK8{=J%P=Wx~k`1}jhs3-Y58l;Fk*C34XocOTljwd=UIwg0BGoiQxKogtDEN1iu#Y zy4^Lgb(|Z($E*DJ`4_;C6Z{VFxq{yfUM2W9z!wVsZSY>fH-oPc{Kw$82>w&>`viX) z-25(-iP`huF9`YHfxjjAAHn}C_#5B{sBfd4_W6M8^6T?|fS)ep{|jC#c=i_<`U$pZ#zT1HWC!9|Qhf!E?dQZ%7$UGr(UK^0UF;5&TT>j|49V*LE50^ynbC z4#($>;Fapz=jVZ6BzP;h`AsR~qZ|ANA>R*vui(S#daQb{ywSnmTJKnAgAM6?4fJdg zdOidGyx=#1?-YE!x*qFn5&G|h{C|YJwmaK7d>jnP_c)Q>~ z2OkprS@6#a{%i2B3I2QV?+X4J_!hz62Hz(5yWqbO{9oX&37(~{vz>PY*T4Uj?fh5p z{UATyyc7e;eK7b@f*%Q9Ao%g%)qdD!49x+0F{VZ-)Ghg5M7Q zWx?+PzfbV5ga26YP2j&1{0HFg2>vMeM6*#B3HK!Uv4ZPzpY6;R{8x~#6#Tc~=L`M^ z@IJwJf?px{-@tDc`~&cfg8v8nA;HI}a+B>mBe z3;u}UKLUSF@W;U47JMuCShL|8$@C2Pv4Xz{K2PwM!Os``Rq$nkzXiTd@OQw!A^1PR ze=4~Cu~u5&5PToi?ohubcnth7H&`AH0xuN&2=F?=j|0D0@RPx>5qu{2U4j>ZKPvcH z;4cbZ3I4j^^TGcixc*JXY-itNoWOAbsXUA`uqFflLdbSJXi216d&vC z2&!?O0?)|`Iy?uSC-`r`TLs?%zE_zi+j0so5NM}vP?@Dsqd3Vtg1?*uOde@F1S;5o;cl+oX%;71Bx13p9W z2Jjle7lF44ei8UG!QSmhW5Itb_}PNjf_Dnu1U@AA`QTRx z-Ufb);QIGzvz@OAo`n39f-eJqMet97?-pGD#%;DU>BM0ATnG7F!9NE+NAO$0&lP+F zcvA4MfnOu|{ov;J)r?i&1OJhbe;E9E!5;_ztKk0wzHhG4tiOK=exl$nfmaCr3V4U$ zuY;T4P&1+Y1^i|q{~q{#g8v)*3Be<3e4On(FZjOTZwNjKJaUq;M1LOwet_Udf#(W7 z75sF;^=}VnJ7)`C0QtD!bHG;$UIP9F!S(MKXFCrFUJv=F1z!mMn&20LXPq2OhfeUL z1z!q2SMWjbX2Dk|K9(Qy3mmJ#^8~*ZT>Un@<>LnE?-ly>yer$eR`5F@zd`W3!5MSRbL{QE+_74o};d^hCxJ2jZj{g5~B zF)^;gkUv?-uL7SV_!{tf!9N2Y7yKshRf4YvUnlsT;9nK|Uhp3Z{w?rd2>u}W9|V60 z{5`>c0)D`BlQR1I=ipNXe-^w<@Lz*368!hzO9g)o{BptHR(z~e6b;(*F66%?x0pKNq9}2!ma2I^3;3tBw7JNGR7X+UL{!PKp0DoNYGH~--b0*Sf zgTF82&jsJFz)0%v#o#9j-U4oZXU_QQ0zXg4_kpJb9|FHl@Jqq(5&TNGpcD9MB{=NYG zXu;dT3k6SrpDnmv|IKz<1YZvMVZkp0|BT>QgKrT0dhqWF{(11H1iua3{QjMZwO(J& zc0LgD8zDdbG$X0M9{@i_@b81q7W@(LTEU+HZxj3}@a2L(2Y$WazX88X@Ezbk5d6>J zPYeE6@IMOvKKO3IKLnpx6ilD!aePhdpMsAAFA{uz@H)Y#fOiOfH24a^PXNC`@KeF> z5xfxmhl0-qe@5_9@K*%a>-)5SM(_s6JEsTJXA$@$!7lEnS%F%&lfxee!k!< z6(8$tjt1?y0(^(yYZcFSQbNy-;GY)!i{Q5l{w47H1-}RUXM%qd{1w5!1O9ixe+V9( z6O7ju@IwXv8Td@We*s=B_zU3Xcl=B!+rcju@_z!qO7J(qZx#IS;NKQ}H~8a%e+2%5 z;A7SOiEQU}!6$<67JM@JK66cs^!MT5hX{Tw_z8la1U_5vJn#y^^?e|^uOaw6$ae}} z0X`&nE%+M2o4`LW`1#;>3El?&9l?9R9}_$Y{!77^ft%kKG^zS2@LfXwD)6yq7)kwo z9rzJ~e-1of@LR#F1>XREq2ONwUoQCl;5P{VJ@C5(e;9nT;E#hpCHVh?m@|lL{@7Ez;CHP;!I|Y9a{0hPU4St8<5p{nn+xfoW`+`3!_$2T* z1wRCQ%)FreM}bckd@A_yf=>fKP4EKnvjv|6e!k!(;6s8}gI_0jJ@{7yUkLty;1_~F zDtIUOGlDM#|BK**;N#8;rrQee69r!lK2Pv#!50XA19-3CUjSb%xW1p7?R-J-yCMH| z!M_3isNmlQe@^ht;C~kU$Kd}K{HNfPii7F%H2Cp?KM#Jo;J*W(FZdt9+Xa6Ee3{_8 zz^@bhAK-Ti{$KD11=shFvz@JiPf+($vz?a(KM?#~!4Cu9x5Nn?$ABL#crN%X!DoQi z3O*aWL+~@fR|;MZexu;$fZr{6Blu>)&ja5kcq{lH1n&m_K=6L>aixLeafZQ<7JL=> zEWy`+pCkBZz}p1BN%4unKz^_`d{y4g7$zU^=`FezM^2f)@(@FYtMSXQ})2 z*-nk%IpB)~-w(V?@Pq#!&h9+EjK)8 z#gF&gT$hmLPGkI##GlIe9Zw5xmwAjY8xiz#=@Ib;<~cy}w9tb>er>UlYHF{-OAT^qp&h{qs0|ocPo9iQ+HP&lG=!zD)cL`ZeNj z)BDBWqdy}4Z~BYkpVR*$KEivxXSnl;_%5ECdX{<^!}w9B2m5C%{Yddc=u^axqMs$6 z^4vThBFjCVJ|I4gc{(J|sr2i_=h5#HKbQG8Nd5-K4@!Is{rBR_m}iURxrFimlK2($ z9cBgl^BU%<*goj1=o#@_>GQ?!VE%EE{~r28@dxSi#UE$>Zpr^N<2xn(Mf$bkuh4%Y z{s!Itu8m#mw>>wXOO@rm$N1MI&%f!Ph=0yJ>m|Vgz&KB`qJRk1tGTXKUf5$Ms zye#Nr8Go3>A3{G?{3!Y?@f5vD{CN6u@oDsx;-}IF#OKl1iJwbq2@moDN$9LH-cQF2DiNA;bp!kE#QzLmEr?-he%{(tk zo);N!e+R_&(kt{q$@2z%Nc?T)|A*v%k3J;ly&uu@KQzGwe@Y)c#kK^0zv?}=XP!?G z-;q95d=!0wcm=&ne1H1o;)l?$7oR}CO*}!rPaMxjj&Q1n1=nj54%Ev=vCs)^mD{J=og4zM88h_Qu>|Zz4SrxYw53uukw6^(?P2=i;)C>*_%rlr;xE!?i*KaYi@!$i5`UAvLi``}?~A`r z|B3ik`u*Zx(4P<=;XU7JJ})djlK#5*9(4P=?zUI=q3>~$75qJrK2H2FdP+P(uNF_! z&lEqNzC?T~y+?co{X62b={JalUyjDJw#Tj}e>m(l+szMTHP_~rC3 z#IK}}st)%5cj*U+-$;*%_tPhf|AbyEeh+<__yhEBia$!fR{TkNzxcECd&Pf4e_R~T zH=E~9#s9?kKZ?Iie@FaX`iSYl{``lTg8v3m(2+F|1|nu;-}IN5uZm-h@VS8QM`eEns^I+ zq4+ZTGVx33E5ujOuNS|Dew+9z`Y*(9r4NeVL4Q&F9?wTO0B$zfNB-{uX_U_`9B)`+(99 zA2Htj{YL+PpV3!}50AJ}W`7YMN!RbA9!uyd7RC^Ya!PC*97{YI6iM< zuGfiAWc>K@V4kV;Hu0JCHR5yWo5auYeAl9JFX#C#_GdBk3t!53N#k^RKEkOSl@Im) zv7C)&SZQ^&+2gDzsZx(-yUa@;H|2le& z_zU!I@s0E~;;(x?+*vI3{1$zg_`CEg#6O~cSNt>jt>VL@?)nUO?h+sA`3Pr7+BuqD zAqTeo==dFgLLZHzJ~2=ZJ5lpCkS{y+QmfdYkyW^b5s5qF*Nd8T~r(;W4*9%=eH>|Bs|U zC63RD<%FG&v$VugK3=G zJs;^DEPgkAy!Zq3BgG%{d{;-$&)0dri{lNizIk3?9`%j%gfG_p=j(L&ScdbK=eriI z*Sn0D$B>E4ndtd&=LxBwsh*E?W)xC*|C;Ifu0_B5FqiRiSGQ?A z=x2*Br!Nq{f?h9vHN8>%2G7m-BmHxW=fj;RrGIW`{CbJMoAJMq_y_3kh(E?W_@1Xi zqt?-D_A8kCuNUZj;v4Ck#b5V)q|+Qs z#7EMr#7EP+#rLCMEI!V2bKiDsaKZ%o0`a8h!=17-g7FjS<>FK6W5s9E4;7zFkBXl| zKSn&~`AFyTU~`egfkgBtA)BB0iCM z$`35G#r@Y*dX@N0`k*X#F7vOD{O2&fQS#(GAL;Z47war#o~tBJ7vryz_~ndWE%8@) zZuTQt?$vaBF1C>D272b8g1P^?h2AHAI~||TE6j5@y+%%q9-yxge~ex>u8_n1*E;$F z@fYZW;u}35>8uQmcBr)~m$gTyE41y% z=g@bN6Pg_JS4;k-^loWq7kz{Ha{5;BE9i}q|7v=l_zgCX_$~DH;&xl=;@8qwivN&aE&c#~EB9-g|7p4%$E?3XU&C?I z`rqgS;_mkvxa-?5zGDX7D83hcE5~!2{|Fl|o~3W*am2=-MBgMnhh8q8qucMJwt2eg zjXW+}{|D>}vL$Bof9owF>>1+AE%=%J#nfN7i`~KR-Url%R3id-keQQO~@1w5~e~R8O z{;G{19nAB0y1m|I+w)&~nZ)mCKF{y==inZ}Jp0k@bzqw(LhqOO6X})Wv+4G_w9S*F z+w0iYFQRYWJ=mU=^iATo(>I7eLLcCLG@Ji9dYOz%f1+=dap?oPJ>Rf-%8o_9+3(l2 zK9*i7<4l@fAznjYFXKal%`e_f-z?+9RrCR#uiEykrdL%4`_uiN0(ZOH>p3?5NqV2u z+a~%->F0Opz2e&)hy25&pU2S4r5}!__sM#>-$&rKvrOvhEP9VDx0UY5axbIX??<)k z+ef$Od)Du#4@x^X(AS8+L$~LXHqTBI(f*YZ?|$!qyIwuw)9C{;-Zs$Z%l>;Y{Zn2T z9fr;9tfa4%dj65kFa8j{P2BxH0=J#x_X*a|-{=+M&hd!fB=xf=9lvK)7@v=(ub22~ zbo={Xwm;9MZ_X+QV(exFJ42p@2_n;8|mHq2e+g9eFX0I#rM1xw#$w58i~J?Zm(O~ z{EyJ>^-t^1($`3x{E=S4lSdo>9v#nJI;Lg#Z@VhAbG>ZGG4ww12)$pn<4pRH>~{<4 zn`Jv*Kwl$%CA~ttpT0@P?fdC%;_K=2#fRuyq<;Qu%9q&IIe*@iKH?#gzy1ia!{eS4r{=qz(==i?pLi_(o-@0Ege)uG; zFTUTs5Wg3FP~s=h+r($k7l`NR_WHSP|0VP)iT^%*<-Wmo4%j^6Yw7m>i_QNWeX|_z z{zP9Z?taeS-GA{r^M!sGJsI97@kh}IcMG=j1o|5B)9L-<3+X-Lo%Aa4E9epN@6#*A z2k4IYFX@A$g6)5fzDE3YdcXL4^d52d#+uuoRpO)Q5%GiQmEsAyN#^}$x9>Fipp1Lx z(tE|1(QCx7vH8XO=|g-@$u9RH`U3G6Y<}^-(yPS(Lyw4$nu>m_6n8(ToP>4` ziXTj0BYrHsU;K3XO7TW|kN7v}ZQ}0deB6FpAbuCUM*JyymH2D)i1>$e``o7Ow_U5T z+%0mxdJug;_TP#0KJhc?_IbiGYzF6i`T~i+lAaO2oo=63w0V9-e@EK+GJR0auimHI z->tBDcAbv(?Uwj)^fvM1=<~(r)2qc>=@sJNqHj7ZSf97rJmL?~%fw%%Zy6uV^A>$j z{6F-y;=7)Vepn-ZFnvJ$82Xk&gUg*k&m0o;1{*&v=$F#*yEp%!Lm!ay+g)d3y?VtDqxXnUp|6qi-g)!^@g?*|@k{9u@m2JGd0%-Ky;rW2 zJVUq72ipF5m%df5BMmzh>$^pKU;1V_FP%uY&okTnr_tw2{6d>w&JR23_W5d?=UXIAPpl=ZGrmq*j zjy@)pE~DG$J#3zz(N{`8zd#?7#`6p5)X3iaJ|aun`QeROs_dS z7=IGIO#CdHN49$#eT~%fW%MfP{~yqMt-qqt8G;Y?k*y zF?yeP4ZT;~eO}PrF7|mL+YdeT`4azKx_u7K#@|b?l>Oy-`UV;IhUmTG!{?(t-Qwfv zqAKksSld>y@C;{QZnDgH6NTYS{lxZjB%L7y)^ znO-G+4m~1%0liZEdb<66$zkYLXMny%#+fH=9`QHmz2k%1<$Zd;T=y7xHrBUX{0MrV zj2n~bE5*;I_lmdDH_QI}9eSG_mv5!li2s6~sSK{yuj!8XKj>R!92jv9*0)Uj5PG-l z*H!eMeS^zAlipYn^cH%h__yd~;;ZTQ16Q`5*V4D{8O*V zn;sGGqK_B9nqDq`2fa-ES9JS%Mq3ZRrw@$@*2DYs&Eh*Q!1`_yKag%eM``mPOJ6VX zv*~NZo9P4MSI}3Aucr5kKThuvf1Tbf{yDu(eE&MEZ=-k>eSvr#eZF`Py+(XBy;^*b zUM2o#dPaP^g=l9){2=;x@k#Vb@j7~i_&4e0;$~>g;C4BjJ|KP$y+`~qdYkyq>D>ng^KYbYsto!TdgDGpAKt)r?jH2L==S?4 zY`;yQ_e=bV^bOK)bFIt!ucg+<2bX&}eZBat^eVX?_#nOekYJwQ(i_F!rOy}Nelhx? zYFseSSb9W!A|1akSGaC=7QN?yV4hBTrT7i>&6UCUd+Ckh>*+P(f2LQ6e@@@Be=z@k zjac6y@e}Bq#T)3G#4o3B5bvj#?H63`qjX37kMyl_-nf;%S-heN?cXFGqi+yDjc&gm zpbX7&TIgl6UtCMC+AG-pAJOgiA=o@?>AiBk`T~86jQ?-aH^_KC>^!VjulU~d0om`e z^gi+V^sVwfbP2sut~;%umx=e&7sz<~2)$hV75W+(S3jUXFXKb`60Glf@d$l^Y?qnz zrzCzUy+`{0DmuOgwD3IVUG%k*=NWqCVZrVG8vTBW|CGK)d`vUet7?2O&k^*D_+-Amw&64Mr^o)#SuhaV^{v-PJ;yW+JdaV>6M{kpHbqalf_(FP( z_&4a?GEUx1?~&y`O5Y;e>t%XI{9knYc|*JZ?$(0!>Xv>!irywZlin!aOkW^=C4Ij5 z&*(Mc&(hlt4c5=Q^hWXWRAC-a>c8ucU94?KME(BK{bCNc>g$2Jw&R z>&16$!+H&hkE5>@KbGDnemZ@n`1$l+@hj;IWPiESx}1+aOJ9GGY%h9`oTu%0KGv&G z>ih`$n#y3FQ|SZZt@M8JtLc5>KclY{{{y{O+-XNUd&Cc=56E%vmtxmK7t znfR~hj`$|}mfeE=|6lr$`2O8kud?!Be45_BYtYZ2_lYl~uM}TJ?-hTL-Xs1h-F{!F z-QPc^w@Lh%3(@{Y@f7`HIbS-BJ|xGl9KBoOFQ>1R^QhbDJ>rkk7l{9nUL(GR-YLr+ za}n07O*}$x7C(hvF30O8`k<`ux9M{v&mHvfhX=R&qx3R4PuNJ`B**uE(j%3@JiB}y z>os0HN-r0mM=ulqI(<-%o2%$+#P6o}%J~03^aT~ccK(?@UwpfZ(f%6o1L@V`lj&9B zIeJFCmmU%S8GXF?3-ogFx9C%3`|i9P?XMC)f}RntrbpzwE=M0PzJgvMK44wi`4l}N z%YBm`5g&dD+P_lH8xNyLupYF(Qv3jV zh4=|{NBkW6)-jIvpFJ*IOdk}#k-k>^A$q^~MtYz4ht}n|x#Oj*L-7OXjp7;l0`VGp zg?IzKTzolwXq4mqXZzuL`eyOF=zZc((Czn2+dRLgH%j~#`U3H?Z=xS6#K+Rh#gp_Q zIp3H;-z;8F-$VAhOKtvm6hZxVllzCnB|eZBbZS73eDh)0H@AxgO@7BG7^)`;aMf?Q%koZ~j&ElQ(P2$(mKa~CM zPWl?zj|S;m#|7KDi5@vP=>MdzKQQR-7csief41!(^nK{_#nbd^@fkMHzQH`_(*G*! z^>w=a9>p@u=GBY@7c;`UZ)gN`FeciT+m0 z;@_cni?60<#P6ez7hg{=6Mv1qRnC9jr>_+seiiy>Kzwg{ulP~)Zt=XO?(r*PsYhD^!YNrjkpHub+fed5c*2-Y4r8d{v3U+_~rBg@!RNq z;_K+W;(w!ei|=qP+TSnZ$zgQ-&TZkmaXNj0tXGacM|?TGM*JrFW*HwIrf(A8M6VM6 zn4S?Ivl8nyLzbJNSBalRKTiDX^q#{}nD#iel0N>hpx;g}7k`XiCH1+HzE#Hmf6zC{ zcG=-Ntk-(+arCv~RrEor=h^fD>9@u7^77z%EvILsfBNV(a=d%Qx}4{{PH&Xs#TWGX z;`@9T>su|Jrf0-w)93FRY=5)OBfi4s5noLoFa9vSLj1S%GVyolTXzYzXZZK9UPI#h z)9vqY*?P;+*Gv2?`daZN^a1fJ=zZe1(tE|%(!0ffLvIxSCw;#7upik1+1Of9XfKV}G|W5)wZ# z#HWP#d5@P~?kOShb3**A5N{0eOGCUj#IFtU+d}+j#&>hR;`CjOj{E0${CzYe{;3fE zopHDS2am-3_WbGt`hfV(-$(q9#k2IQ#OKp{#oOqYi+_jSDEzsj&lcaS z5AB~XK9OD{UPqrHzMNhyejEKb@j?1{@lEu7#Xq7~i0^(Q+P_7Pvl03`;`8W3;>+l- ziC<6OB>ouvcj9l-pBMk?O=#zO@qOuo;>XbM7eAA}M*JfBUE-_hKNf$A-Y@=VdY|}q zKS2Ah7eAbSmH0{YUh(tjmy55U_lVz3zgYYwdbjxB>7C-c-Hi6PiKpm|;$NfJi?`Fy z7Qco*U;HQZYVmdSDdKO@6XIXcBjS7Cg7rF5JVGBYK9hd1`1$lo@s;#_#qXw9i2s(p zhxjM-a`C-yMf-OapG+?kZ>A3uzn<=h-$h?3??--3ZDNdXnBY8pkzzKK71{m;M>ikM$}SKY;E? z{z>$RykD!O4@ti*r*}*HSJUTHp8@o5Xkf5!P!^w#&ivHR8w6H}O2lw!enn zC*DBs5xlj$2O zgZa;;uNOa`J}BNxuNJ?>#*Yo=zmL9F{MYn8@qf_U#7EqY^{v=1n14@tx%gr9@v@(u zK(7>^XY-3Mw)w>`q&wo*(1-R3w)4mI4dPGI2gP5euN8lj-Y5PseWmzLcc9<8#rLPT zi6`jQ;wRH1;!X6yy@Ts}8GWtzt@JkWwe&{um+6(_@6s#8%YK6O-LO}%JqOa)i%+E2 zh}Y1o#p~%2@h7 zeX|_bzDD09-cH{j-b-IEzM4KL{s4Wg`1ACB@z>~m;_uQIh<`yZ7cc)Q`ln});C2~D z?-oCn-X>l{ZxnB!FA)DaeZKg0^cwLy=+)wn(yPQ@q-VtcOpl2FFMYiDh@YW<*6$wd zpRx2o@icwYZo&8&^bK;|xYp(u@38sBSJ2mr-$Y*{em8wU{C|w|(mxu?|F1XhUXQx$ zK>&w)=Vkh8`mv1PO#cJj49nhs@6x~V5MJ;875x2#{@t~B-H1O<*_~MKf9Um$A5A~^ zmk3OL6@T|PUaI|vGX8syA+C;jBJ>X*hhIWJp58tP{|&vGKKTjw@8~u3J)eS)!5`;q z^!w>NoI7>&-_p7JIW6?R(Rny`E~F1zhr~QhcP^(NM6c#@uc0rYPonqH@21=Bco+TG zbi3R~>2K33ndb%ih^GNI{;%|d=r;aS`egb;?6>l}xP6~N9_t6wfAMR$?aw&<89EQc z&Sd&u=(as)(7&MD_B7M?e-`-<#~?57S?v*D%j|`XMg>Z2!MTKT-UB`q}iInP07>?jK7*b?vz~s_UjPTwH_;!b$GF^g zjF&ndZDIVDH<92I<{7pI{rUI50=8qGJ?Z~^3tq?g!{{^K23)}SiS#G`27j3Gv*{NP z0d{5lV)~VThp%G%Mf3yy5%lZn57F&-`&0Vw=#|X#EBc2L|3~_$e2}+$1=}I zGa$R?Aj7t(E= zJV#$ak23x}`a|@y=+3=Z-%;-Z`1Z*eO+TD&+aIM@(dRPHRQe5c+n%%N57U3jdN_~1 z@Lx#q0{s&D(eJ}QW&UgFM|=P{oPIlfF5R~Cm-Hp#FVZii^R&bHBYoQcB5^nKe@uUz zzAxLk<9+D2KYWP5X2y@DPx}b4BRxy6p%15@PM<6B_4HbazmQ%pehs}z^8A?IA@L8< zyTzZSFBgBE{!Q^M^l#DIxL(8WNB?|GPt*6IAN6m5jgQc8rLSWA40_^Yfb~ZDv-B+E zm(#zx6=3~)^yBDX=Z3kR{tySktGRver%xFMID+|~qqoxS{_-ZhmwpxF|4ZLvIP%0f z{*QP7{c}J?m`e!Sw&x0T7`_>F@6d$gn*V>4)tEUrIldzDm4{ z{?(lk|2gwtPXEd-fQ|I;(O==f&%=N-K!3a(fhP>Zf*+)Rwg)^(uQu=B+;KRz7rdP9 z{QN=qB>E`&YxLRTzheG+x*fOI(J!SpG0(H~f6y1uUomdmK=S^)#`u%>Mmu-l#3A}@ z`X2QEr7xx*Pyd{LJKc`kyKuc;k@&InJ@&zJZG45J+0j6azJ;c@f}=qu>6>6aTX)o)ia{`ZWpV*JhYz4i;P*H7su(`~;!Oz)-J zI)8>fDDfNVpVM#Va^I%kG#1Offc`Ok)c){u=wD@hw$N?=>_*>6KcDfH^l6pIvpxPe zar(>y0FxPiB7G(O+w@b7m+H?sjNj`(f`$G|L+c}AT9KDr!X3_7YPod}N|DxOT?RNV6|m~My5oFuCcyd_ z=DG4z_N$@Hh`Kcb&bZ)8Jkd@X$>-=MEX zI%mTprN_hbA1&>z%yZX#B=|P-e1o1m3t-3XE9rO8KVds>q_6%O;?HHCJB^nbpMTEy z&$t8GJde=-eGU>F&VF7`ujGYfyWL-8T&xA8lfesj0`xJ8J! z`^7=@Z_+E6Cq=)B-a&-A z%Nb6FzTpzIpO^ccDfI7u1AYzLGn+oH2cE?rCr3Z`QouJE-%j65xAEVk?{yjCf6MqA z=>Me8VLz{?pRfY)BSv6`JLyxeg73)q2kEC>10T)t;aPh9b?_S*|5y5F--Exx_IyZx z`Fc42INLpreqOu^ehQ1J+_?K(cMl7JyNh!m{c`bRjF+mzlS2H|5T9q<-H-0Q1MOMM z_AjKL_Y?TO^j7)``d;)a=&R}H(0@Sxl-@yKLvI~G{@v(5r(a6H0h66y(#QM^V9%c) zrYGsUaJxK7pL`eMk6`|n=q>ar`k(0c(2t~Vq5pw?7k&7z&~Gd54z|B_6}*qW591Sz zzmI+beP83Hwqqp3Co|6n%wzk1R!Dp!<9E6T?L2|Ytq+O6i18;g{s)X-782jf__r8u z-|zf@{)?YuxrZ>%_e1jhjPb8Bem}-P8WKNz5dHiib#@{XRb@b$e$a4wv{MpolJ09LgUrxV(@sWoRe=+^r#!D^tCdS{z zc%D8wcZI}1!}yU8f5ppe$JJuM{9BE~<)cstJ5hQu#n{7a0Fu%Ew4|AM}dejUB;m*}@^d7=My`j%h8*D(HW zGo6@cehvB{~-S{j2}mzBp#<< zOh1M3lS1;>gm@G4Ji|O=ndgF#_-}{!_nGG{=J^rx+-BT6&*5vVo#U(t$@2u`8SeD( zAI~xWx1K--yG?&j|GxM;^q-%%#c3!6T{yfR} z#lOaK&;BZ=y3aF}ivKg?pL`ziJ2U=+kod2xLw~;X65@Z)_)*47L!^v&XT(*H%b>-aeR3-RC5cio8myR$uirXMK& z0X<2d!1(Q+#(FKJpNw?QuJpTJ0USu*i~i!PfJcTQ(K!0IUxQaM{%HEIUkCJaxmEP0 zH{kZV^l9{)>9#&=>G#m>IJ1=gyu@Eje}ld!m-}t{NAykfo9Hk63GK1*Kc)Yb{#CBm zBlN#*2H18!NB@NW!f-6$4f@k>BmN*R_kZbsr_W{nGV=!6t+(Tc0E-yEyK!3^B=1jU zh#$>7KV+W0InzY?BlHOUWcokpcKkV;?))9?vEE4^O+TJ_E~n3?+i~f8^d%BMK>sP- zZr{i0&(Ocd`@+xC5Bw1AvCr-Nfqvr0@FTWIgWjPxe-2;5@q8=&RR>Tr0`WVoNB0c{D{L>t-CeaVr8GbI~PosZ>Zu{qK`uFKapt;T>jp?Z+z{2&nxMx==OZ_Ci=Z}TjzJvpAvt9{tDfWlfR+AMYr!$9#~p> zygW4u&9d>G=NG0zdq^L6Ig>DQ(6j0*8RLwvswKiIgt|K7pnj^lEZ zA@LI#{~Y6o7(X*4{)`Y`6yi%lyu-NL&d)}npHJd)zY!AuEyhpT4e?u9pQ}RRe;DHT zg!nI+|F}Jn{|>fi1N|@b8C>q4=|_!0d_Uv=9g=_8vsm938E@a$R2VN+SMKw{ZvTA2 z_)D2T9TH!~_?|t{o_TENZ2Bt|@C@@b(s$VlegeHaB>yFhpUL>ejQ@5>{B?{!e;?#G zrvcu7chFP&!tHhA`{^_2c0XN5Z=#>UJe%l)bURM|jef{}$luHO59#;Nucv?YIrQ_S zv4}sB{k8}Fvi;#V(Z|vEI{@Cz@phu|QrmHIh*vYu4F@C7c(!LD{W1De%ztr6o-0GV zk9jWT4L5r|2_Rwj=oyr|4zSC+i_dXyd%VWjJxag;xTA{ip#l%KI~YyZT~9z zQS?T}|Cqi?{66~Ubld-r)60)T{sWljH}ojoUZ>qmpFy9+_>bwg(kIb(dI9UTS>g|( z$0lOAHa;EBj{Bz=2x0_N7qsdRhZGMauK zeY;&S!-2+2)n_`yt3v#Y5N`HM{g+I4+j}{>#g}T)ZyDaE*upSe|(6~4Dqocey(wM zxwB?txyQ2p+vr!*Teio9<@Eoah4@1mzmk67*WmX2|0a4${Kxc@>CMdZ0R2I_9Vge( zU!~jeYLoF%&Q6@W@VlZ;`=ZwN+)<01#m#l~wTqi;n_JD_lV;S;n>uUu^wUnQjn+oC zF)g}{X|Zigi*I9EVjI(vq0?g9XlJZ8yq)oF%opG0eBtXCuMJLB_<#wnWvaGJXsm`ox?c(;Bc(KsJcaqavdF|5dQ9L%eC9yb{Z(8lbrk1+)(mR?P#u}~d z=vugqjc&%_j<%-uWhGm_xUGw=scmRWg|w&;)6~)#64cbfPOq(NZ?C(sbXAzybL}m4 z%?+*XOY1so&+p2GtX-+V;vviJuBCNtcAsvqYYEx)mv%LGHo3i7dho#Hdbg&xSzTUS zN8Qr4=F)qoH+@?JN9&?R&0QT$tu5PFb>ugP&P8UVZEY#tkqmN2mZp})CATa_9aFlk zOPdy%fu_st`;ctj0EH65G20zSORpo-qRO|Kj$^UiI@{PUxEi(1W&?JavCC`)(@*uK z8_;RSq+D~e*E!o7TJ6r^4zcZK9@Cd4`^m6)@nvM zQ~vEurAN80mL_-q_&@X;hDvvIYHwQTm3LS%F!IX}ehk#Hk%Q8r+J^SlrL|ohx%Rfs zcBj4hq+DlBQ+KX;N?m8&Z1gAEX;Iw!M5fLosRlkLvyWr0K&f- zb7l`VBN$(Hw6>e$&xK3vR5J!U?QN#t>TA1OI~tqXTkT8lAeDd7W==_#Hg%iPiP0T7 za{!pxYT7z`QG081^W?hb=7n{OmN*?vEv5mBTH7u(!FbW0YiMe2&X-4HT?fuKyrNm! z(O_0PXO7KH4LCA7?ThD`!(?lFY)TVGJ?3f4<(4?LwKcP*&Y5#&?XEVAefQG3ZtvgekR0)}X+M@@ zhPg(kE!V!(%#cV#oNjZt&6yJI>~J$=T`*^M1&A7GZD=S!EMyspM8;|EZgJB_vrhBU zChwoIh*NL>8D$&19X~8fCK@s&8IL-qsSRcU$!LsQU}0BNbG>iVU_^21-4hlQ7>Q(^ z)^>A_=l$EXkLwvR2~5o)CK@&ISpP^g;>?YF+nbM2>? zgKe(ai!w)cjml#0nB3KF_PLtYj(n-qnL)se!bioD@p!^%uIn%rVE&nOOjYGf1(<)w zoJLdmt?i}>=2hI8y{N8big)g4Y+6&ZDIN1hq0vmu#G;PbxpJqP6DspEVS>&1TMZ^A z5^=Y)mzi1fl5rMwwYQtm!=O7uGVRp0wedwNR$@`Ja%PT>re!%Zy12caO5|GH@}1+J zQJWM=(;-V+>kBWl48vZQ_f*EI>*{Qsy38zm&V_AWlWk)>oMG143o*NhIh=TA7H&4Z zJMMNYGJ`}*M`LT}WE^arqh?Hwy8ny0|BJi-OSu0_y8lbL|4Y07%eeo`y8km};r`#7 z$CQryZ*Q)sH(S)3FY3)0_2!Ivvzpz&M4COo{XdrH%^UOPjd}CNym@2ZyfJUym^W|C zn>X&wYYN|FFq_u>zc;Vh`tHBIdE?%^ac|zZH*egV*X-LSCgIJS@a8q!)D>^ugg0-( zn>XRjYqo_u)tlGUuK9P;n>XproAl;Qdh;f|d6V9}rU=|fZ{DOgZ_1lD<;`oV!c0wh z^O`Z;{kJ!7%9}Uk&1*KU>)yO+Z{D;wZ`zwT?agb3P!p5(=1qI^roDO1;ODwGZ^oO~ z3?D`^-nym`&AXXeU!^Jcwyv);T}Z{DmouNj8j7;oOJ zH*eOPHyZI~jz+w>qY-cRXvCX8YK|>trf9^=5RG^#q7g4gG~y+Rnjy*!u_cBqEHYLZ z%Zzo#LSv<|)KF_t6k8P47LB1TsJAEzE{ckaqU55exhRS*imHpE?4qc)Mp3U(6l@d~Yff9d z=Ave!DB38hHj1*1qHd!o+$btHiqegucFh6O%@RZH#!$O4)NTy58$<2JP`feIZVa^> zL+!>;yD^N9G1P7hwHrh2#!$QFu;?uhwHrh2no}?jIZ)b>(yLu_N`h(Leq@gPc!ew+ zFF9bMc4MgB7-~0$+Kr)hW2oI2YBz@3HD^#>PSmbB1M*&>cFma#UZE|hU31n1L|ah1 z<}45B?bGI*&3lE~HK!|hg)FFDbNmD%3u-rp+BL^!OhXpbZVa^>L+!>;yD`*m47D3W z?Z!~MG1P7hwHrh2#!$O4)NTy58$<2JP`feIZVa^>L+!>;yD`*m47D3W?Z!~MG1P7h zwHrh2#!$O4)NTy58$<2JP`feIZVa^>L+!>;yD`*m47D3W?Z!~Manx=cwHrt6#!N7l$jpmr0e-2~5BdD6;DA<;g2*H-Xwspmr0e z-2`ekf!a-=b`z*w_pOZEPSkD!wVOcgCQ!Qx)NTT`n?UU*P`e4#ZUVKNKd z+D)K#6R6z;YBzz}O`vuYs9pD(gWEFHZUVKNK*_sNE!LH;LL!qIQ$0-6U!^iP}w~c9W>x zBx*N_+D)Q%lc?P!YS+EM;5GuaYu-KMmA8$OsNE!LH;LL!qIQ$0-6U!^iP}w~cFo&r zFAK(9^PU;6yxvWscHK9@?qX59Nz`rxBx*N_ z+D)Q%lc?P!YB!16O`>*_sNE!LH;LL!qIQ$0-6U!^iP}w~c9W>xBx*N_+D)Q%lc?P! zYB!16HJ2T{bwKSVQM*ahZW6VdMC~R~yGhh;61AH|?IuyXNz`rDb#KXwVOiirck>n)NTs3n?miTP`fGA zZVI)VLhYtdyD8Le3bmU;?WRz>Db#KXwVOiirck>n)NTs3n?miTP`fGAZVKaW3bmU; z?WRz>Db#KXwVOiirck>n)NTs3n?miTP`fFNyD8Le3bmU;?Yft|OeLpKyD8Le3bmU; z?WRz>Db#KXwVOiirck>n)NTs3n?miTP`fGAZVI)VLhYtdyD8Le3bmU;?WRz>Db#KX zwVOiirck>n)NTs3n?miTP`fGAZVI)VLhYtdyD8Le3bmU;?WRz>Db#KXwVOiirck>n z)NTs3n?miTP`fGAZVI)VLhYtdyJ^&J8nv57?WR$?Y1D2SwVOumrct|T)NUHJn?~)X zQM+l>ZW^_lM(w6iyJ^&J8nv57?WR$?Y1D2SwVOumrct|T)NUHJn?~)XQM+l>ZW^_l zM(w6iyJ^&J8nv57?WR$?Y1D2SwVOumrct|T)NUHJn?~)XQM+l>ZW^_lM(w6iyJ^&J z8nv57?WR$?Y1D2SwVOumrct|T)NUHJn?~)XQM+l>ZW^_lM(w6iyJ^&J8nv57?WR$? zY1D2SwVOumrct|T)NUHJn?~)XQM+l>ZW^_lM(w6iyJ^&J8nv57?WR$?Y1D2SwVOum zrct|T)NUHJn?~)XQM+l>ZW^_lM(w6iyJ^&J8nv57?WR$?8PskDwVOfhW>C8s)NTf~ zn?dbnP`eq_ZU(iRLG5NxyBXAO2DO_(?PgHB8PskDwVOfhW>C8s)UJE^+YDA2)NTf~ zn?dbnP`eq_ZU(iRLG5NxyBXAO2DO_(?PgHB8PskDwVOfhW>C8s)NTf~n?dbnP`eq_ zZU(iRLG5NxyBXAO2DO_(?PgHB8PskDwVOfhW>C8s)NTf~n?dbnP`eq_ZU(iRLG5Nx zyBXAO2DO_(?PgHB8PskDwVOfhW>C8s)NTf~n?dbnP`eq_ZU(iRLG5Nxv>6m_21T1e z(PmJz85C^>MVmpB;l6m14Yn?ccLP_!8oZ3ab~LD6PVv>6m_21T1e(PmJz85C_6 zMVm#@W>K_R6s@_w>z%`yzr2`>?P^|oZ>r3NUtFJyVAGn{-g%Gt>zxpqzuvi=`Rkn$ zn!n744QyU}XNBf3^I;pCE6HBjn!n74&1_yXA2zgk&3xF@<~8$SW1CCSY#%nadCh#- z;N~^+VUwHJ%!iF`UNavyySb*#eAw{jHS=N9o7c>Tjc;BvABHaTn)y%%=HfW>p%Tn% z=0h!**UX1%Ft3>p^`elDm%!d8u=fdgqrknXZ@NE=-p``*vpA?^ z(e+szRI)gzWN}c*qT93R^(;C)i$2ey%d_b5EIK@k{?4Miv*_(CIy;NL&Z4Wc=;`F$v*_I{2A?d(o-Br*EJmIz2A(X&oh*i( zEJmFy2AwR%oGgZ%EJmCx2AnL$n=FQ#EJm9w2AeF#nktEJl|s2A3?xmMn&rEJl_r29_+wl`MvpEJl?q29+$v zlq`mnEJle)hhfz42#n`PqAZ_NJe`>t}EK+53L>#-F|AXYU-^ zJAw8dpuGub?*iJ}fKeXS?2SNsC(zysv^N3mJwban(B2N@jld}H3!0+`4nw>pXkO#A zg*OGwYaG^iThP45VU2eL&1;k=Zw;Co(#*%Q{ zc!$jx%QD8Y&C@^LS~Sk>%+o*KRy2(VX>Qd-5)$d5!hq?MCw&+ktl)&1>{O?=_m&Xb0~$nnx;_kNX2} zI2vaj?hm}@Xq@@DKk&Arar7T=JespH^gnMsn%B(7{eU+ijoW@;CHzmzkBHPLRg7+njGavU0-kLOy?ZTUr z<~7^L{et%=&EqI+ANLF1qBM@}&6||wHS=+Q;O$Ctw#s&Kzvit<<6K|v2fR&bobBcQ zz#Epv**?A<;yp|AfDGHmw?n*bX`Joje!x4I#@T;-JH(rp<}8}+|>m&Vy1?hm|$ zX`JiJ{egEe%~?3}a6jN3OykVM{e(9$jiX+8 z;eAfy%*Xx3z13+xA9vcM6KB+(Hf`GMsdH-QoH%L5)LQ4H87EE&`Q+Rr_ajl$%qODk z^U9Om4>ko}Om;t@6p$(IBccJBZ9Yx4s44%@vp37kx{f9JpswcTX?2V858-wqbo050#kqDr%{I@|7d};CW}1`h zp6>rp6=+7zJaSr7=YCYke6*s$pTW!!oZ2K)LuboRD9ll9J`H0#WqJp?EdN248BHy@ zGn(oP8+S(Q;-*EXwb>cG$Ma{qALnQ&rlvf#nq_zo@Uy>bTAMFi+}bkJeF~j4D_2(^ z+_Ip zd{?_WllK&OK&JAubhhJ8%C+c>rg&@I&F!oC=^e5{-2A6CG<2BH9Pi@J1$Maj#T@i28(6*b@UKbTYeG4;Kys)@!>WPaw&GX0F zBzQ9Q{4Vb?cAL;ccUPUAYcqpdXMV@`KDtv}Zh6-2=2cf=KeYLU^ZQ)T^E;^UvJz{U z{{Z)-+~TH|)BT?&ba&F=V1-xi2bFAtAg0^>h@B0S3VW8f2f7PrGM{YV?l85bKCno$ ztI2FeWFE6c5tHwp!Z2T$CVOXof;82**MQT!&oT!R`Mj%mLP4f?pgDG(rgsEZX=Ytp zaQfU9^La~>?tZ=x&7bIfUUqiibIXGoHiI8+vaAHIYWbk*Fx7YiQOeT$ga(#Z(kO_f>_~$4rX?lm$!Ss&c_BN+dOC+RJH~3C! zv{-#7HzAWwYtsqrk!b!TCJ*^_wUQqj^PnLy%@Qkg3}=dImRO;S7!ubk@uDno%@Qxl zlF%%PqAUr`k|@eD)B8AS@oK<}8wU3;szV2gdFCT^^~K|dziOiS^Xs7I`#Zq-6%A_X z;QT%u2<|8u94pz3SYa>l=O}FZpq9>DvKg_`&4`z5M!a-03dQ4ZhHpa!xMVZprJIpB zbz#YMNt{}!8h`S{sbP7{r;T|K55{+eEx>mWl{rEd5t686MgrSotMFFIlKeRB>68t&ZPzUq)E{v8rkNI8IhlL{bp|85~7oqYQajxcTSH4M@;$Lx@ z??mT^CO) zym>61R(R)FJZ(nZg@uAOZ%lj<`Q9-ysNwyr#SuMY5r}R4{UabqJ_BXopY`CJA-_B;4rmORz(+hQ}Q+&ngPSSmR zp80y7;H5&2U%~nOBXw|LfhoS3^4IzDZJyrY+hn%0r+4_*y`a9$WikI=E>N5P+1;yz zzHg2yG0A(&AN&HGkbVrXZ@t2LFkfrzzi3x}#S4-zCsM2^$cP5Ti-L@3P@*WvNIodA zk)rvA35SFiG6&eM4>GjNdH5ZAxMLnM)YHJ}J5)Tf92v`o^->C1x80`wJJ7-J3G`oye@5 zcfC0_#n%+uzjk80)WrP8E8fg;o1oNru2)BeZ|!qK(60Q6Hp{@f^4*@VM{^#+I3MND zHv-jZI?#7%R5p)qN|#Jx{``gw9>j~L`o>0glcBx&nSLqj4_zwJm8Nv>F zH6cea*Gn%U`xD!#Lnu|_;?3OKg1w7xufvG|D->xa1k{9eZMT^hx zF8-sI`F1AXH=_mz(&A}FIqfRBGZsxWr{TH6H*VS+DAH4AcP^SS-%_(X;W%lIyXLD> zJI&qil83s&WFCM1Z&8J6Fbm?fVDnCRaV{{y+Y#C7z=Xn5b<`iZGf`!kz3B)S){eQ!|Aw`?tHEHMxTJzqC9b>{2yLKk8V|6NPNCv$ZQ zms0bP-{mNU%ba=8kisQMhWM^NQWE)#YkANtyxvskLPqAVLxoQ9U84)kQ{0UF^{J3t z@$Rr(q2BGg;u~1Hxo%aoltTG*xb;&!R^=aL;Ev?orIY&}?y;9t)6|x0HoKWEE$_;W z_oz?)py9vs#<}u6kD*6$<#*@8BSYSuHQ!w3aV77}Oa_O-4Ed#-@ggj}*=z7bQ1FDy zdj=>-%wX2r_l3KKF~D|0@r^QBbZ|Ie*XGPqG3K)2H1At)Z9kgi{$tmS!iLP>sIp77 zvy^P4ZGe3asj&0n_9zRcup4rQyyrVzCgeL&Ym+&AhtlAbqC-N-$zd%lao{L9zyA(L=>Xs0 z9}=+bHuw$%rRMkDVJSJ;e~1YQ_>$%O4{N0}`0mS;3iy&9__DdbYz+c;e@ZUje=rRR zDD=TB^GJ}n?0^RZ_>fBeeJUS=3?9>nazG1ee$PSP;NfU){!X@cN}4~2%KdCTY6Oll zg~Nbwe#rqZjJLw2!wUmjAlz4*0WXXo!lkp@>vHziEx$K6*vs|_PIhyC_*XA=W|Y4O z<(~d{7eC|*kN+htxcJp*xeitx3$NLF|yIBP*+{G%G zxqDT7vKqI2>TVMDO5iT1??$5kF+Lxg6XL)WbLrOGw&GLF?>#J@X}&1lyxYrv6*5aL zFwH!OZoW_4w#z@sbgg+-EI*~Gqs@K0|{(V~hU~V>oe|f>j zyGqWP-;;{BU+~%_9wMAkw=kDqH8Tsern6lqaD4PiqQQJhpim8FE>1M>554Edyj{_* ze(~fI?}R0Rjrfv8@)lo`6k0gFWf`9ULXrEcL#IiR6ejz6+pbz+qM2)((@oI_p5-mf z>Fy4EGTf%kU)A*nx(+Rv{A7C#TLVgL+0vV}rnSwhu9Mu~ps`D@F<<0ftb8sGHw?Xd z74H7&yU<|P1DzYV+gRAy!>%fG%qV$X+05-;Zg)p=+dBVoLt5aU6ny99pE5ms(u`7* zxDb0a(+*hp=_CC?qu|ugA4Up{pOY?}WgccWzg3|#YjO@v`I|A5%$JV4TVPUaw`oma zcJoMT(T^zk(=YT!RQ>TJY(INb*dM>B#4jloPwx!g9q~qFvk3!*Z!urrZYD654zmaZ3KmlUv{1&&&ma{IP73d1%NTUfpMt?4ugCsos-A zI?36+-cQ~}AK>FfVGZy;d*q+!Uv$w#-$K2o=&?oeZzgap z&)3&7g-2EUCPSvWSH^uGkw7y4gCr8qdq<)yKvliiEz>!y2Y!8uA3*d?3O;#{=f6TH z`=0CaZJod&%{~OhHWxh$RkZN~?FD)1QHd@QU6!2Csq_PxkkhZ#OaLn7Qs; zy?K&h+W}#d3tl+&)ygV;TCP!2(dH>PU%A`iHK>98*B9+yppWet5Ql32l;Ar{Z;Ef% zaNmTZxNSSaBl2UJh7>k*SQ7VBxZ7Tge@6_pm zOiE1Q#Zp^O?z-E{9-QQBjXSk))x$U4pSZz1(_HHJUfqq%lUaXCvkLi7mU{iotzWpy z98`O;Yii4~{BTsi%$Ly|(770YNJHrm_exjcD?P&5ZJAbp;7h0md ziTW>_?oV1OLBp3M2&@Ma1lP1w8#JOsD(1lr;FJtjUe@kSln>l>mZ7(;rt$E#v;mb8oGi+nI-qi4!fJpiIII6& zCV#T|%K~D76y`H;_BWc%iLv?RasTW~i+*w3J>S3?VTb>W*~fvmIIeqFCOGux-ypgZ z^sCn<>F)4WbZQ` zVN++iU1w&R+-iPUHR?a_kSYH12~P4K<7GofR8>)<^dTwB-aK6PV$Z@tTXye2qGyBTxswN37K51N&&tM~5F29Gq1!TXAQ zN8mC(wt%mX-Ba@Xw<-DEyA{MU&EmPdskrA~G!fNOg53{t7qKY-jQc#W``X}6;0>;ah||J zeBU$V%Mr3%CW!inmAv_PAB+B>ByS}G0|yia1`j0`OJoclJ{TA;(Z=9FZUakX3=ZB5 zOq9qN97b(miHyOa^ZyZc7w}Qr{~yN>9}dHZI~1q5ON(n;TuP}!+bb1{>#*Sr1`LPc z!+p37hv7c_$A*jnV+nmFoPz2DyOwUUOiFTr z^?TXo?D{ljqCsx^K&I?u%jQB~t7G*~&lvlV&cp`>`O> z)=z(~1 zTN0DG0?J*W|G0M&leK$u!Q%C6`25G1@2_2LPdqEiD+T)ZmM>0l!nkNWeOt3qwT@!rUZM{IE^}`Ta1M6>>h@=_@`8a=Dsx@3PH;CD%agF>E|#XT zOmVkh)>mh|i{-_cb%MJEvpknu?&5aAJl!pr^(7XI$t${HL|Z4h9RTvWZf@@t-}^r% z{m0$@V{YO)A?|9rUwn6C!TQqC@`&9HQtN()y6exdEiboR8)U)B^UYX+EUEL#NvpZm;UN3o}`U>2Ge#Ooe4=BxtA=?J7F8T z=Alm$`_1B|wOHuBcIA5aF4m{1^(i#e^=494%bmgkB0~JNZt>Up(A~uT+J1~>s_htz z^=NXmI?Y=9RBpH&u(3((*lD|Z#^6Zm6@$3ELWJ1o_79BjEqDH`VBjS(E&*f z8P#moLlgeaXlqX@)mw}nagiKnq8&9gJup$j8@-|()`%7F=UJLbO*Ph(2xm~D$(9#I z@;egQ`SSi2Aij+wT5Np&8%bf`(~OM{kLm9(j%f!+$wOz>M{g`&Z!y?KGbUamU4T2P z{xPAw#h2W0c@39jm)R%k?{p-2|KOnAF)t(~o@0!G>>ryDK4_5m(vhUvSZ-}B6ZF+oZ&m-^p)mpOrzWwwse9`q z)^$(s&VKp_d0g*LStf-zL&e5Xj2dfdez0DAl1F^<-dKEDO>ECxTdJg9C)$l|QSFm0 z8#_7C=o5m21W>6&&sxrWeqWU`{#AThM z={m);Zlu|oHqk0PG%St_Dk_PiVU`D}MPmO(d^pS|wQr}=xG_G36>GitD5kxFNX06e zL~1<|Bngo8vNxBfNN{oVfDcc5Z1O9%EQ^ga5oSHTWvoPf7np^Km$~|(UVCagmdnYa z$tu}yTSl9h-ZUmW$Zlk2bBVh}ER5b&Ty%NxIPp>@aY)&+RF+SQ{KpjgoLnC-u`Vpj zSyv;uAg()Ewj{PGZs%m#vRLk9-NLky7m13n%)*FRyKPKdn3IpVoj5?^7bec!4h^%! z@;HNB0gUmltr2oNZeHkBi?qQI5*(B0&Rv~O%LZQCF-dyJYm?;pvX&zHH_7Q=C1#lr z6Yh)=*O47$d{0*_r}~IpLUClq8Efexq-+gWY-u;7Nn%TvxUjW5e8ja7EsG^@TdFz5 znXZ-x>?@8!Spukq}3$ zc>C5FD-&&q$Uo$UK(8Thspnkrm$rI~e~qiwh(E=rZ^Zvat7>COeA!D(gxWC3KlQyA z@x3O-pRQ0`J1i!`@>x6I2xpwg^!Iv1L3!qtxUJqEG6M@}EDk6|isMOkXXfgTuFj1W zR!y~JdRbrnsGX~v>$W}_yS?Ttt)cDJi(vYrl&`SVTXiDS%W2J{o$_KO4q_`NJTnoBn~IZ>!LIk-=ZoHE4gUm3F1h$RN9xD8q2G$3T0gsYp8Cy z9%3i)AxdIy5Fi>=yB+Ucoog>5L1Lx$H|-!x}0mHr2sS z{gncwH5J#YMxftO4rz1u-nii#7!&MzyH$qryGgV!a+S*=mR##e(O}|fEQ!Q8-AP!v zT6&wu@3hA$)_8e{h^VU};^{GWm)>wXTu~Es+{B285)`3+JWym}!A+3Fqj0U*CUor(n34YR(HOOS@^Od`v@eq-7UMv>42`;rZe1;* zH;+BkR$yBw9upJo`<>PLsXhC;O3Gt(lw!v6iX^s3DxQ)cl$eA5h_zR-+R=4{qG$Su z{bhY)>!SKA4e>IE_cy8jB*AHNCrE$!;F=~{H}QO3p;=6nk>l99Ar(%00#VP6;wGl+ z`w)rm=gPGwBix~t{4xyT_3^6hZRvk%yJ+gqZ~?T>T8n?h{LBrjxS_YQK0$v_=JF?g zz)3WQTovS_Y#$#WpHGdOa_cT`igwqw!}>FT{H&fb=0b!m^+Jnag} z@(Y3^VjUsky`T_BN70ean95y)W1Pm{ZN){QRoqa#?_~a|eel}2Ek55AC*I7Dv){I$ zR>4uB;w#Km3H_FDzZfI%a>{dPgW}C9VinQ0R6q@*LdCm2;!|ExqUDWBV&6s2RiN#8 z8&kEH;n5KTjoWR4L&dY8aZ7Hb#8yPzQQy~=?^UY69LC1Hf@7kMi9W$05u(9dH?>y) z#;w-kJDdHS2>~%du|_1Wf+4RQs48ifw-W6hE|3 zp0<8*-L@k6T2?KCr>(g>8^<_f<#(#0Up(81Mi57K!vo_Z0*vnSwDhjJWpM!XU4HT=K*r$z> zTR7Db#*~Hw!ecGV*vcFpp4Q>vDb5ry?%rCw@2V<^3u+Dw6t5`7XB$+~Au3wmq8fpp zQ(I9x8n-RO$WtFi>b}|yOW#@tkXR&bE!DR`USi)XMvT7z@lKhZh$ax<1nl}-|9Gjo zt!ArFltWJc%QeDqFZr5SP1ak=a-*~5Ru{{yu9jP!yI5~`?PAmetO?9_F%z@%zDF#~fT znwe^BGjOezW~8@)d0VX!W}pp5^Jbd}IXKPRzS`{o?P!IWHi>aYs?p@qOiBI(Sv!z}OTOe&SyJ6bzR#l^1JkK^2uj|Dtp;&!~ zI>^yHRwZ(<2a5NM9pb6-KO%7*3H?FSiBMn5&HJ_!hk3#hNiB8J#^Px>CO|wT%Vz;u zPY*hX&+8a}`)IE_^;|w<7}!jNHgDLupVKcOCNwxskuCuV>aTX;^5vv{M;~WIggHmK zYoU6}wG?V&DK>CwivFTTzq^>|h>Q*K4-F6T?=7xc8Rfbqwk2Xe!!=F3!y`U36%gu5 z0_3}d{&8WVJHnh1LHZ{FW5wkLb41?BU z=GtKvS;f4q?MJGpqu5PyYCF@GIjMWv3UzYE^bHVQYc7I#$l5Ct%bjJS?ODeH1`J3V zS{J^p_$Ze=3hR1|O`L(^Yi#7Tu|pEHzg5GDN2C9xpIIhX1hvfCHL!8p(n=j~ugt>yN{}n6A_$+B1V! zyXLlD5%1rM54pwZ&l{rQk56v5pj7^MpBNUa^e%Z360}p^l$&t zhGO$5@fuhgG0nu-QPX@A0-|~3PoJ#_^_Qux5$PvRdXe*1o9bp_`{5NYzK2%sgy~x+ zV@vN48z}L;g~oQ?TYetZ(N^rAcJOJXeMmSgMr?Uvqs60%3(-G>EIuk694UuRQ?UVy zmhYTKM~la*&s&rIO9TfeVdS~)~@BU(~i$5#K_oGypAn%+)4pK4=U8*2KXF+P6YPOPtT{HgU` zjW4r|{MJO=O_stRyu}N7angjBc8wJAJs0Y> zQ#;HN;}D;27yB0B;*+cL6HXDq>NQ-5obCt_`;C1aA#vgqSVxE^4d!}NN6_C(Fko-X!g-tt_rswnnUain4`` z#R)B;!LHB|7#1WtKwQaAETg=ec$@=b#nV_41;xJLplPOUGrD(Z`w)NJ%u)R?*GOEG+6jAapRAXex&0mNdd=j4X{ z#TjaHA5D&Tm1!%OOEij)ixZy!bv+)1^jLcsHj0I^Sbgy&K3dPSnF%;Zsl zNV!YVT>L3^K;c5#hK;)B|8+DkbN>TlA>EwOe} ze>EZBTCnV@$|jemiZm84?|aMha^xP7_6CIfL+y#``#a6Vc-Hr#%-hDR5o5o~QbsJ7 z{6Y+IVDXVgG4|D~J$*;THAY>NJIct<86Oy?4Q1^wZ76GhaVV=m47TRl zvy^#TU+u&dha<$r2*g`7+6PA*DIEHbhxn&)YKP$jd_^d%-V&m+QXKo~z*l z;J3j40>2-=H~b0s^YEA91L5z$Ux0rK9|Zpf{vv!b^#miwLoj@LmCL(bg3kpX0$&*Z zGJHAsQ26TbSKu4NhrzdozY5<4J{&#}{u;a!z7PCB`0Mav;QPW)g}(tm4?Y5ZIlO$1 zFvia&_(=HO@VDTP!AHTLhrbPf8{P^382(rI*YMHsAK~x7r%fqth#xtA`oU*Yxg0-t z#jo*r3&O|1mxjLwUll$UzA5rJkd!w-Ug4F4PaYxu$NAK`z8Pn$~I5I?fthrnl3x$O5R z;@5b*1>uLnmxg}|Ulo2Be0}(5@Gaqo!*_sx4j%wN0=_T&AMgqABjHEFzkr_%KMH;k z^3lk5pw6GDa~S?>_%rZwAJS;&>+oaXAHctYe*r%h{vG^l_*BBkAKCBY;Bz4#kK9w` zayEDQ7!^?d$`6K814ZM6#mp{_~Eq)Czx7G4T`ibyz-IqVo zzZJiRmwhUKq@M&Y?<;?#|3~~9em4AM_$Bb~;Mc)Vf!_iD9{w==RQNOS@->37JlEl; z!9Rfi7ybqObogXx1QI{89cCcUuX5QAAH}aR-_r2k!h6Dhg0Bxh6TUh8XZQ~Av*7*V z9bzBYSf0M{-@(VjCxageFZ(CCH!Id@8QqDr-Hu@ zKM(#X^7+Wqd?6ZF{K$SxjXK#>F8h4}e13TO+S6#C((nu6J>kEAuMfWnzBzna_zv)k z;r-#$!S{ui>!7im@$l*4N5U_Kp9r4;em49v_$BZe;n%_c0KWr16Z~QLv{quo-am7_%84y=ODta3SizJ$*UzZ$+cd^Y$>@N3{}!)J$Y z3cnVE8SPmKej9vk_yX`v z;kU!Lhc5`<171G28uJZ>F9aV8zY~5ad|~(r@Vnr@g)aiX2>vJd)$m2(x54j*-w$65 z{uKNk_{;Fc;qSrkg?|cP0{$)hKKNwm^>HG{gFKdKv~xz4dx(5Ld@lG>@I~Pdz?XwB z4PO)fAbewZ5BRq5hv2)wmw^w4m-}GG<8s26g&z!m1bz&BIr!=DN8#temxo^o|1Bd|mj4@Xg`nYcAt)`NB7X_lLg$9}eFbJ|6xi{BU?L_=)hh z;Ag>m!!Loq4Zjw?3H%QDU*QkJH-$d~e+T|5d^7k5@OR;#!^`)WjCOtpe-A!ICVia9 z@z4T3v&!Z8xeuQQz9oEdc=_7dm~RF6R`9jqAHsXXw}x*I{|LStd>i;s`2WH8gKrBz z6#g;%IQVw(-@^X}zW}~H{A&2$;kUs1!0(5D0)GNtzE^0p^JVy_@OR+-;Ge=jgMS0x z0X|t~eVoYg@Ekt9%H{a!2%ii75BS3Ho#4yC%VR9YR_`1A1cJ!PYvZ^OTZ ze+=IX{x$qR@E_p=;L~O?$ImNK4)DS7 z0q`H;`@)C7C%}J#9|<1{KNo-$93@XvjIlF3tk?pH1fmnec;c* zCx^cd-xvN7dE_@pJ zrts15zVKhb_kiyQ9}b@uJ{CR(emHzO_zCc_@U!64!!Lr5gI^1u0e%~NJp4iUjPMtc zXF~o0b^4>u2l&kJslGJ(Jpn$e%4NT2fzJy+0KO!AR`^Qr1L5n!e+l0deh|Dbd^Y$V z@PpyQ;j_aJMxF!tY}6ToI?Ld5!mooL3cm|J7yM!PVeseRbHiVUm!BOnwi}P&^T5A= z9|8XX{ww%Y+01?)37=KvvfuN<=Y<~yUlKkad?onN@O9zkdo;%5Y6|}~yf1tK_#W_M z;KShy!pFjog&z)I2z~)e@I~QI!G8mP6}}k!J@|?6 z&*6*1zlEO!pCY?HPULtf0iRLj^7&#id>;6c@I~RLz*m4T1z!_>D!ezmd@s)!KW*Ws z!FPlAfDeYB4&M*H4E$jD8Svxa%fe5G{}z4$d^z})@H64Jz?X;L3qK3~1bhYfi}2sU z-+`|P|2zC__&4yC;6KC9flr^q96y!ebEsU7pSkdb;pKa>M*o(9{~o?Nd=>bH@blnX z!&imx1V0}>5WX6GB>V#Sf$-JgN5e0Kp9)_CelGkX_~r05;Wxl9hTjce3;rnl68Q7* zwc&5VFNJ>$UkCmr{4)5D@O9zSCy$HT9N9|_+Wej@xD_}TDY@Jry=!moq(hTj4IBm80b zCh%wA*TG+hZwmhaem(pP_-63$;5Wdh%B7DJIUeL^FpU1qta3SiHp1tHZvkH%eiM8p z_?Gas;WxuKg>MDl9)1ga5BS#bq3~PbW8vGt4~5?bKLNfi{I~Gi;TOTTgI^851AZHP zd-(nEJK;~k`@mm@-vxgU-WUEU{7>+2;r-x~<<`fE91pwUGpbyUANg4wWBlZT-veJ1 zz9W1&_`UEo;XA=MhTjL@7QQol7x?|~!SG$+o$v?X2g7%T9|M07emZr{5kle@Zs=Rk@rFV8g=-(`!hUWcc=Zz?03HI&Y^PI?|j`|5dIe|XBqgu zSe~lz=iwW|N5Hp)zX0C}J`z3v{vv!Nd=z{F{3ZC&@J{&2@R#A|!big|gTDg50lpvn zE_m+89);(A>^b;q$|ffG-LE2;LKZ zBz#@?|G_th9|i9V{}|pMel&bI{BQ8_@L$6ZhyNXZBK#QmS@2Kbm%xvOUkm>feh2(G z_=E7z;LpI1hrbH{9R30P1o-Fhf55+k{{}vNesi2mL|#(ma-6(C9Z&d4@O9z;gl`T% z8QvHECA>fU6!>uXSMc%hQ{jihzlNU(KMj5s{9o`(;HSf{g?|IT1AYelLHNJn&%l2R ze--{M`~&!z@Xz7@fqw@-3qC~wz29a3zJt%Ka`}Am9ef`6_wdExXTw*3{{UYbeh$1h z{J-$+;pf74gZ~I03jaNPKlo4ZL*eJakAwdV|1JD{_yzFtBmm=ib2a<|_$~0s;P=BX zgg*hF9R4!=BKSM-@|AhJOQ}5g$9HSl-fGr~WGUkm>RJ`;ShLZV~EkL>p!;nNqAseYb|Jm=jQSGfvlvF6vo7go8T zjx6xyR4(hUhp!Hw6}~b22Kd(SU&42R-v}QFpAFs#zX^UIe0KOT@SEYM!smdW2fqb= zIebp|P4HXccf;p`KL)=I{ycnc_}lQ?;UB}xYZn;(`x<@+{73k&;L{d%Xg{)lcfw~= zxuA}`@CD&_!Iy^52VWKbC;0mC`Qcl_?}qOHUjRM;eh++K_=4~W@O$A$!WV*{48IS4 zHhf|DW$^pq*TENo-vxgF{xEz|_;c_F;jhCNgMS2n2>u1UyvBtwem=k-hEG*QA18u3 zO2B7Txg0-7;Pb+lgf9ty6uuICDfqhZKf^bLFAeVte+<3{ya#+Z{BihL_%iUr;ZML% zfG-O_3;rbhBKUIfYvE79Z-Xxne-QpO{3&>OtrDYuufm^!zXx9t{yF?v__y$t;8PUU z$B7&d=ioD{Tu?`4_&o5xz!!!0gs%X99=;}g6?kv>3-E2>tHO7KzX%@;Uk$z={3ZCo z@YUhR!C!`-4qpR)0sIyC4alz|KZQCqQRgcBHTZk*wcww_Ux$ASFRyiDjH?vI%znQC zpHbz4I_kjZfxih~6uvHe1^8R=HR0>Qd&A#`Zwp@^z8n0n@WJp6;QPVffgcRt5Plr| zUHIwnjo=r+--BNX-xz)i{C)Vn@LupI;2*$WgqPPWGWz!p{6qNP;hVs}fqw-58NMle z`r_vJ`5$}^l?&=<245KdF?<>L=J3_we}iub-vYih{O|Cc;9J56!asqJgl`2u5dJCr zX!zFfQ{kV%&xLOTza0KK{08{8@VnvvfIkY~4*op+3;3Jx^4eC$_<0QfC;UrzANY^( zFX7Xa(8r0O4qy0eDwoeYui*2;`@xrne+};m-vPcp{9o|R;XA^2fPVw;58nyCFZ|!| z@$jADN5a2_p9tRtem49+@Jryk!mopW2fqVeUZc$D-^1|l;m^Q#hrbU00saAe5BL}G z|H8k6?+Kr(q&`mMc=!mPS>=K{{NeM$e}XR#-wVDH{Ac*u@B#2m;T__d14g^GhwlyF z13npiD10D%EPQhKq3}WQ6W~+8e+wTBzX(1h{A&0R_-*j1;P=Ca!k>aq4SyLv4E`Rx zyrzfIo=@S!;ori40iUdtK28L6^nuT)ayfp|!smkT3ttpI9eg?X2>6=t>ERp0N5Z#- z&j8;AJ_ld>;4&_`&d_;lF~P3_k>ZE_`12W$;7cH^AqE-vvJm{wTb> zhL6#|=irCK--Is!{|J5r{7d+P@E_nu!l#h~LHx*n3c+VpxuA|w@cH2j!9^Ir@^;}uK*v2ydv`9s52dPCc;;Op9MbyehGYK__grg!ta2W*XA<% z@gV$6_%rZT;IG2Zf`0&C75+K=cku7vtHGxzt983WP{(Ze%qo}tUL8IU{2ch=@HOBo zz|V!R4PO)98~%Iv_VBgfyTQ+c4~4G{-w%F1{80Eh@Kcf3MZOkw7NE`!_Uxsf9e+Pao{8RW=@NeLsioQ3NGg*0koXGJoEVY@ZSGg$d_!0GU!M8^J z!tm?h%fYvSuMWQ+zA=1T_}1_n;Jd)LgAat?2=9b%4?hro6Z{x>ANZ;8o8jld`@%1W z-vYl0-Vc5^{8sp5@bX%YMn9g1-v)mhz9al&`0eno;XA>9gx>+5wt_i+I>TpExuA}n z@CD(!z?X*K1z#1uD|~(UpWs`!&ibo3SSpK1imT!&+xwRq3}K6kHLq-hrtg<9*%rA>eNP^W$=8T zYaM(8_+9XPpXe}rQ}}c6d>`aGJYVNNg6Hep7w~*t`2n7GKo`(5^LAGAYJm5W7m z9LI8&h3^Yr2YCc?AJjR4I^EzS;rk+wLOvRG_<7f<@cg{%TzG!IbUFOAH0Jud1Gy9P zJ%c(YvHVxyqv8LDydUyUsKfowbd}Ba=l*AQmCN?${%0Y0?tfNB9)tO|K%G-q{*Lgm z@V($q!$-i!!4E?&uQ_aN4`-sz8Pr(--yeP*@&x2ZQHT4b=i#|udJ~@erH|pcU-}OD z0L(YDr`|8J{m)|gbE{mgF9YFAAs>Xi9_sMCo~H19F%CN+AB;MYsKeJ6{o(ogVl46@ zsIw4t&f#&bfgcLL75*3a1MtJ(Pr{#vzXCrT{x19l_-F7V;6EWBiTtZ7W`A8oof0aS z{WS`{BK#%zI`E_6o4{X&_ksT!zB~LC_%Qe}@G)u@HgSFz<&dO7ycIfGx&+{f5YE~PhM5;ciF#_;4`RPP{*(Ex#1_n z7lFS6Umku6d=2=!@Lup!;oHF9gYODI4L%6|K72I%bofE=58%hb&w!r>{}6sY{I~Ec z;2*(nhMx()2mXKX$KhweUx0rM|111=@V~+T2LBiQZ1_*`zr&}iW{#gZ@Yz)^sN)HI zA^5rQ9`H}$tHFN{-vIs@d@J~Q@Ezfw!}o@t4<7;l2mAo|1@NQbU%*d+UkE=3{!jQH z;1|KKhkptG6Z~TMBk-@_e}P{De*^wC{QuyW!v6{X7yQ5Q%ivR2*T;#VjyLdMs$6b= zet^#h|2KRo_~r1G;orj7gI@vP4E`T@KlqjKJ>lQM_kmvp9|!*)egyn#_;27pz<&q7 z27WR8zwkf8uZ7 zz-LmqDD9BnJ!kl@;5Wh-gHH}$5q=YVE%+4hP2e}fw}Vd!-yMDnd!&!BQSes;s>gwF_H1bz>ES@=xwHQ@KcH-gU$-v)jkd}sJ9@ImnV;iKTQ z!ViK!0RJ`om+;fz55j*BpACKm{2};_@Y&(_z#oSH89oR61^6TIx8QTa{|0{){uR9Z zu1RD3e1iWO{)<}X_{j~QUFCB89D^?ap9kIp{y2OU_^;p_z@LC`0iPGXBm7DDUhw(g zBj8WL_lM69KMMXd{3Q4S@N?kLz%PX_2)`cwEc{ORLhwi6&%vLCm){v`^zRM$U*I3Y z7lHp1{yhA9_@eNsYwP1gj)x2ISyV2!KgHnl!C!DKw_&E5h@WbFs!+!&R4SpuP2mE6A>+oyf%fN4kzX5*$zAXG{_?z%o;N^GA z8sq0a{4Mxr@a5tEfxiu(ypBFj4#A*Mh$b?*(5O zz8(BM_^$At@FDQ`;RhgpfP4z-R6(8D@DJfvB7cN@Kk8IPom24tgTD-44gMbdWB8}= z@;il%@$eS@H~3_A&Hk+cpHbzqe}9KBi2Moi>Zrr(w={+ygyWg5;d%X*F7Sil1L1l7 z7AO1=_<``ee#jVjUO!|u@~3!Q8&Ky~}Bt{P6GKOTv4@d&0kmuM6Jdnhkt`S1@epy z^zk73ou8Y^qjI@@Xo|;GROQn1b5IrFo5MFmo)YuzfjYdddpLYvY!74MMRyv}xt zh7RpV_G1P3j4GG?_#Nu!fv*T(6rR`Ft^i*Nz9#&fWM+SP!&ioH3(xCpcZ2tY4~G9f znOVOdd=>b?@VsvJIQVMt)8Q8-GwUyauL-{rehK^*_}cJ$;n%>QfcJvG2+!*z-+}jr z{~dmPGIROgz&C^c48H+BeIs-HG>6ZRTz;pmvHhv4ayhQrV7t^1J~ezx__pw!;M2ed zz_){sg#Q9Q0lq!_X!x}7vyi7lz7BP~lADir7d+2*J`CRi{v15d|Gf_168;f9&;Nak zJUx~(b7Q@~L7@bWv3jd2o#JPYzE zs8a~-@ICxKjKd$`OTur2=k-8-f-eRCGyKn}{|kI+_*?M29?1XTJ>Xx#A4mOv;mg2( z;idPZ>@QvqL?3e0RANEmx3<`Uj?4m1E~jJ9=-)UuLt4>Uje=sJg*1R2fiYF ze|TOGWCVOA_(|}*9>{m_mEo7d|AO}U5#AGiCp@nQatOW({8{)5sDBN%BN;QPXthc5+R13m)Y3%)db8~8~0uJ9i4 zLGV%V(eP#92f;hx$HJF|p9UWdKOepv{0jJf@SEYw!|#EQfjH8uB>Q z8HhSV;j6<>MqUH?GSuODkw4OZVQz2tAg_r!7f@$4p097hw?Lhz$ZMfaispL1$oBsh zuh%lGT(0ls(wNJW2YwxVarmb2)sfduYu52aok3_%fA~7^;qZgu@%O2EPNo0sKMu;qYhR8^Yf~-U#_ymCOF(`A{iZ==~`Bs|)%)qspb{ z`A~V_yTX@2-Wc<3h&m&%{4Lx2j3dL1pEZ} z%J6OA>%e~l-weJjybt_D_@40X;KSf2!N7>gYODI8$JZSJA5?!9QYydJ>bW}&xM}>-xGd5{P*yy;Qiq@ z!_R}?2j2_+IQ)G0OYi~kzrrtoe*)hd{xA52@Q&8z_9PHKoyz6-Sp=UGJ_x=L{9^dB z@WJra;FrKRf)9aj1-}%&Gkhp~ALL=k$D+@DcF8!mosX0v`$g7yK%CM;o)>qu|r2T=x5F_?+-g_(Je&;LE~C!`DOJ4|zw_ zS&KTo;bY(<;D3Z403QoK3Vt2@6!=W_~mCNmXCDbVkKNr3Rd`jYgW+euZ-QS4KLmai{AT#A@I&GE!Eb>-2|o<}68u*9yYR!|pTKW}{~LY;yrZ4j zkK5rhs9g5rNcf!aJK&4JkAg1?zZ1R&{Al<_@VnsKz<&+j8U82uAowxxQSiIr2f>ep z{~CS|{51G+@ZZDlgAAxTGKNY?O{89Lh@YCRX!T$^&0Y4qSKm0NH zQSdY1C&3?wp9B9b{8IQ6@ay4c!taDX34a8B7W`TGQ}8$7zk`1We;WQz_}TF9;m^RQ z_R+_Q91nBgv#4A?kDP_i2R|3S1pGPp%JARA*Ma{9z8U;Hcpv!l@IB$@!-v6NfRBS; z06z@=BK$Y-3*l$NUxHr@zX*N}{AKv<@QdM(BVU62SJc^u=j+Gt{&>EAi+m~SWb@Vg zUH0!4EKfm|%ki)bzBK$*_^R+fz}JVr2Hz5XIeZ8B>+k{aE8zRW-+)hmUkN`F{wDln z_*L+WkgrC*19gg`{SU+Q`%TWk7lXeJ&+j*RihK>`o5s)VuUlCDY$})iwH7`<{B8Ks z@IS(P!v6|iAATKtbND;(9pKl)`@`Rb?+d>HJ|6xa{7CqX@Dt(h!_S7_1iu>jX5-4t_j*iVkMKKgV(P%qo}tJ^{Wk@-28=HBpDx zMf8TRh3!UL_<0z&-Qa7(2gCEai2dN}z>h}070Wpfb@)ArE8(Z(@os|W_ayFxp8iD!taEy5C1>- zmhijadm#S_`9RbehVeEAJ~!HDD*SNxdGLAQm&0F#-vl28zZ?D%{4sbZ{CRkOFY|5q zX!ytQS5W^od_VY)@QdNob~5|D7JN39%YNtgG8cr8fiDez4fU(S$HLc#zX{(GzCU~q z-@#VQe4f!3V)Fhd%@cZCf!~YK71%5w#Ap8?}C;S2U zf$&e^$G{(ip9=pBejfZG_~r1=;Wxn_hTjeU2mCSkBkT)Ul5+>LzRaA3%)A+DYSom_&4w^;ZMVNfd3ml0R9YoU--B13Gip( zN5Xr-Plo6DT(jZ5;g`Yle6DryP2hLI^L(zu@J->*!Sj5s>+sFsAHnl{t{3pl;XlCh ze6Cd8^l>7`LkswWl2H-&Ev?+c$Cz6bn2@Zs?1 z;A7$6!4HT31%3kjd-z%K=iwK@e}G>Le*u0Q{J-!A;V;6Ug8vAA75)y@crO#!ViW|1wRh{7W{Ph)bI=7Z^N&IPXoUN{#W?D@L#~6fWHHO5k4*a9r(NO zzr&}4e*=FH{xf`f`1C!@@pB(Ohsx#n$pBv%{sDX$_>Az?;UB^`gwF)u8vYS{C-}_p zf$;x>kA%+xKM?*g{Al>B@KfP`gP#lkCH!*u-{CjFXM^7j{{;Rhe0KQr@K51y!smd0 z4F3%NC45f!kMPgo)AZEGi5w5P;IpY*Zh!uO&kvs)zBK#`cu)8|@b%&Ugl`W26?_Ny zm+=1ZdExuQzk-j4&j&ve{x$p-c=?vB@&5Y+f3w~4qt4l2Jr|MVFVy)mJn1~Q%4Pe@ z`}{IYcLi+uX_c3-<(E`m-j-iec@0}`)Nf$Rjry%^xlzBPEjQ}-v*owcdU~d$`GmxXG8g$@}%ymtT&N zztfuSHWN9=+iB!);WI~=b^bx#ANf1vU%Sa?xXD+z$j`IRoUv9&{$9!u?n#=hC zd6>#&9l1UZNvFFwqn^NKY^U} ze?iXrm)+E#6Q#F@(LVCpZSv;_J3&P^WSCZDNtW4ro;+AhsixqMt7(eL}*)VUAO_2O?gK6$kEaJ6kYeOi^< z+bu8rCoE5SH@>ACAB6lf>dZy%5M#}F{#xUv{tkH7Ip)SM>8C$lW4zT-<9Qu&j<>DI zi($O&Qn`J+9e{5uW@Xerjhyu_A}@~m*WA><1JC+Tk+c3QvXZ_O1S-&FkQm9|mP5nCXtltbd>$gQ-8uk6$)b9q*`k}~KKMJ`A z>c_gNKM0=n$0BF_$;iu~{tP$uZ^fGZDC^5(N%E(4oc^z|Uffc7q%F^&)|Y|ExjZ9~ zm&NjoQMrgL+viE}a(RsUbC9$CBIM;z{|7hq*TS>@4&&!Rxhu`EPsX$(*Kpq$>q7A za$|XBD*r2Tw$CHv70^CUP@m7ge+<^=Yt+xD>c6w)x5RsU@~7qy{a?e+S9!gmdM=lr z`;8w}Zuqile5O^;pEBq2XF*;O%b!E#vObqTAG{ntM*ULAS-%4EN~mAOP5pPnMN#o% zEPpGt{HaE0v6i!b2IQ4dKdZ{^%by!wF27N~7;@GxgPip%s@z_G4!o@2T`hmMk>ZB< zu|KYY$T{B<$T_acsN6o^ipV)0&X3mTD?P{g8#j5x7}K-P-zqnjzn9J&MaSxY82Nnl zcu|p5Cs=*=^!n|p6Rmk2mAA9y|El`&w)~dLXHGWf%jG|;a=Dzx#ILa*bx!3T zBI}ac%>RM+6pd&2lvDKjvQ8D`S&&yno)397hFS234dATa=wl6cz;D6hx{e-(a2Ly)!RYV8IL>{@)^iIkk3cn82Luz9g$}e+dSj( zI+5omsTCVYALKJeAyYr(gLkAUwCUmHFeJ{88*K=?ZF)8V5~|9kkl@SEYC z@Vnvb!C!>$2Y(B`KKx(sG4LPZ8^Gt7VYYufd;yiq_HPJZ4L&v6r#^fm_)hR?;CsP0 zh93Z*faMtp?*%^>egOPZcyIWh;0M7UhHnCY6MiuKL-?lf|H8|CI%9oF^{w8{vOSx@ z=U2Jh&U}IPDFNRcz8-v9_@?kJ;Qis#!H2=OgdYJv63agUz7_lucwWzW4SZ|(L-4$A z^C|c?@DJd5J>+NbZQ)bS)Z1CMC$BS{QRTAz+rbxy=kX84Qn9pRtC^E$?V!FPhsFw1QJEU2GD<+A-d z!W0Er$YUk z@IB#Q!>5D)7v3K}`*&vhr-#q4a@qd9;H$!Cg0BZ30N)WlJ07n;d~f&!_$;VD0zMFa z4t!SlCGbJ;yWn$Rc@Dt`!{30<3I6~-1pWhjH7rlc*?K$6_6&v3r*aRG*MKh$9|m6+ zz9xJV_;C21@U`GW;rqZ3hp!Dk9=YC;UkG{_sn&{KMf#!Ow;-iu#M;N5k)gF9v@Q{%iQ_ z@I2q`KKvN?_wdD0KgB$~on?EDh0m*U50RIEF9tsjz79OkgY$+T58ng6Bjcj z`Rl+hg7<^32HyjIF?>9Hb@*ZMOW?nQuK~XZekuG8_?qws;FrN)gRcdD5B>-Ecks30 zlP}WSS+?hL_^(v%A@Vx#Md4S#*M_eP?*+dSzB_z9_+a=|@I&G2!;ghu4Zje+0sKn% zHSqi48^RxlUkiU1z7f1*vEH77I{3MftZwpBOLgxd{^53}ippib91{OCw*L*_199A` zFLJKG2`U#Q9HWz&bwWDr4}$lG zkAmmu9GKG7a{o=@~MJkK||0MGMHZo%_> zli%QZzR4?io^SFA{yd&{zWBi$KRn+gyUOMGxd2}Pp68o*!1H{QD)2ntqyhXT)NcXL z^G!O!Uxx1m&+|oN2cGAfEQL=FzaIWNmVYOF3iu=N zJm2Ijd`kEm@HbKaA$%(MKjCk|zlTo^pL)4IPULvt`6gLZF1J5v;Pb)re3KIJU%*#} z=lLde;M2l4gXj4sKJe+_d&2X4lQ8)7@Nw`w-((nk2KaB_dA`X^_>Az2;d#Ev8u(1` z+u?b>$pQGx@TcK z^T4ly=lLd^;lG042mcc5`*HZZ@R#6U!T$=M5B>=}&o}uCIbUBmR+{5v1L|Z@xf~}= z(wW=mobVgri@-O9FN>V7Q)-~jCe-nQZ-zQ;;5Wl}g>McY1iuA78omYmAo#8DW8quE zPlMkEKObIxhRfJbUV)sizc!=JcGTGi-x_s}Bj@X~OQ^F0b?(BqL7gYa`Fia=>g+_F z)T{Jy;vxQNi#l0UF1Itg;Pb(^gD(O96MSX(_V9J!cf&V>_ks6;-vi$h-WNU$elL6+ zydV59_h(HSh=Ex5IaWKLCFa{xp1N_$%;-;P1nCfqw>n82%sl zuJFlM>*GX@ha>QrRPG`2Zt%I`kHQy&?+#xc{%81F@IBzY;E%z#gYOC775+GU2)sXh zG;+S~9)UV1P-hZ+FVy)C{v`ZT_yG7H;ZMQugzpW12>vwuS@=NsYw%~_AHoO0{{ep% z{yls!e9ATEI5`KOMdco1atQoa@V~&9fDeVQ2!9^F4tyAV6Zi}8KJel2-Qh37hr#!O zkAc4gKMcMv{CN1w@H62f;1|MQfnNh33BMKoD*OTXDEO1`*Wj6!DYrx-z_kxduZv+1;d{_8*_#pT@ z@X_%7;RnIrg&zx_06z`>9{hax0q`r}@566~9|*q({sH`P_(AX&;2*;O3O^YBH~2^J zf58ud{{;U(_;f#-<7X&*c9qNV^BBGm{4jVA_}}2G!4HRT0RKCDEBF!c9pRtA_l6${ z9|8XqegOO^_)+lB;HSWkhMxof9R3IRui@9j{{jCK{22Hn@GszhfgcNh1O89=|G|%g z{}cWt{J-$y;Zv{E$B7&dui(E_xrfLnz~_U14POfW8~Dobf5F#-p9tR!{tdhz{3Q6E z@PEVifu9T?2mcm+1pE~EZ{Yud{|@ZZA!1OE{|<$8Ubc!+;y!e>&s96z7nzk;6yUkv^;d`0;0;A_Df~7k(l96ZkLS|At=#@7SP^6FDBz!e>yqhsYPh=Y&rOUj%*$d|CMP@HOCjPOD5Kfp)9XM!IDza0K+_{{Lr;8(zZ51$2o1^i0*jqq9F_rR}${~7*E z_zUo>;cvlbgZ~YF4g4$k?C_u9*TR3X(HuWH;IpgTLrne=z5skqcn|n>@KxY*!8d?k z58nblH+)C<4e-6-^T0>IZ-nm;{}ucw_)YMW;Pb-If!_?j6h0sPdiX8yJK^)gAA#Qr ze-^#~{0;bR@DJe&!v6`s9sWIhA^6mr^l{=L{@DSaMdfn)Qy4xU{7(21@I~M&!|#Hx z178%r8T?Q1KJdlhd&2LA4}&ib9|yk&ei(cS_;29%!q0>+3BMSAAN(5lQt;d1_ro86 zFAaYh{s8jB(d?uB9i2N{oZuoNW#o&*?mxnJ8 zUkm;yycc{0_;&C=!}meX^FxOr=lP*Ckn{Y|t;l(P=mq4g^9(ubq}igkr-%55=Z6+V z&hta7A?Nv_K5p_5!dOFlg}XUoZ8F_ZPS-u?1DRvVZ7BKDXs{RGoLWJd5&~ zcIfvrmjB;j`t97d+?cPIEjQ}4LtYWvJ%5$Uw&C^4LgD4K^dt27I&JxBwfy~Uxv@NB zY`L*K3v9XZxKixY=VLrxqfRedZnS5pn>^Z<8|^&ImK*&z#+DoNooLIAcGzgk4ga^w z?c=k^F7t8a7ZZ*5XXhc8_c7{p{Ym%sIu}$f+lO_s?l$XJLjUGexvX;z>xBnA>%{Ic z>u`Bm?KN}y@hX>=*R`99oanhpKqIi%{nx>a0f2`L0LK`R+#jlwuyncHl7bYMAd0P*16x`{j<`3E<7?w>^g@gwWd*Km{fa+CK_xol5v zPX@y~Q=9Fu9eF?GSCMmh-m6^JuaU~Elm3_p#E)El*3Y4GqkpGP(3qnPJm*^tz9#B> zt6cUMpHI8Gsgr;@@;)=we5b*4ITym$!hF{wuZ?`K%I(W@$xZ$Hs8a`ZUb?B1>$u)d z_VG|y<@Wxq49~|EiJa{`1v&e76Y8^n55cqkX?WQdM*rT2=X{^Tvw#0pxxGEJo-o^i zb;_&U7*|IBHihSMc7SL91|w(x#;M%CJQLm2pNl%|-&Jnv>_MH!T<_fEe<9DC#$4~R zpETQtc|GI>;5Q)OjrpEYxopq67@t>FZf}RX@b%zdxbc4@=YB}KQ|9uw!}1hI-UfLC zFQ2&#gJm=}8A8#e(tlt!QIO>NY4?#Z8O+E`b zAJ;bItaA!^0P3eaV=jLu$8-Edn5mhI&H;$;`GIFq&}NvgO9|EVSju@*GgPT#t^YGoJ^~ z!8gS?xem|$##btr>o1QVeny>UsFUdzeH_`>-|Q+k#@lGsZh39_*D5b!%g3m^v@IX6 z@`|>6g37Dg^06wfXUmQKqGq;yn(}RJxv~G&N#(MA>Z6^5kT*ac>!!{?TRuh2cO>f6 zL7j;rV*Zj8^HwtTv(^P4T7q4F#j#KMUm z*^lk;xC*M=-acjE+r!s#qSjqne|3TXQswsk%7>i$w-r%G-e-s!54COi2$eUn<%Vx> z%MIV%mSo}R=He8zAu*Xve^!DS|N4Ztdh#@zJZ&(t(&~3n|!#+ z<@V_5*yz7Y8;6Ph`s0=JWq#UCUgE0htD;V2hro5SKQ=x+~mKx$EjQ{{ zvE@en+Ni$+^}TG~*iJTAxxF9T+PqP}Bl7NCe^H0)dj!0khq2xbP`PY}L0HZaZu~gp zJuu(zR4!|CzCXjuX~ye?`zn|7t%C9V6nQ@68E*f$t4}(T)GCayj3LST8!?6@mD%FVCF2TCC+U@VDLM zPmy!|YJbnH!}bYNxqQ5VSpEc++uMH$d=UIbH+~0luBV?=E*~$KC+B^AIqm(`PUX^% zLOTSiTrPhwmL~>v{*Smb0gtL^+ICpPfPo1bBuaoFBL;{NR#`QHK?6oW4GIzwG%RXZ zgor2+!2mJ>0vZ)DucD%&q5?)hjhaB%K_ehL8ukQH_C?me`gAqtnR43g{l5R3>q;_n z&vUA)tE>BT_c=4c_Id?4`tuocWgo}+BH-xfapt8-uY5J@=*xH03wkI!&0!p_#$0Ku zKpxg+uI%&!{~H4D5BwJ31AwOj$NLs01AiFw+0148e#~69%Qmp{2-rDbv2)!Xst`S- zoo2vOp&jpFuKdA%IuLlkJQ?iV2Xs={|a~<*gp=u0q`pO zU4KyD1UTxu0Y^Va0Y^Kp14lbw0Z087;Anq8@S2yq^XkZA*MHPEVXpEd?J`&2j=72_ z=E)tP9|-ysi@rbT2Z4ULMgJLdl|SfbKJb=Mud7Oe*Q*ZjI-qaDT-A3l_|uNLtnb5M z=LWDd3OJ6F&w(Ax!vfIbe!@oJxDNdtIPND@KcMR?^ZY*MDsE^$4LI7L0vzps#$4K8 z33{|sV&Ua}aoYv;bu7G-h4%qIvz(isl(}kmRX20J<4e%vx_gz-n|+KO z7X5MHxX)AJpc{uT!T-9zM*_bWcn0v1z|$ZP=KvoFd<%0^U*rF;pvV29ioa?O0{wInbLA(FOP_!p+zT1h zEB)rSR}S#nz?TB=$XwO;G4QiHbLrWQJz=r)JaF81S`KzFuYLx7KKS!1b5*aW!Jl(r2lJuq5faiv=GB$Vm7P&wrxxhZ zPJQ5*Cmnz{y23qQbOZaUY_nhYs6{`*q8}%?+25N2b{a#uuL`{>cQ$j??zo@%8F1Wh z%oTP_x!-{v?Q8{(c1{U9#-EFV8~c|ZB?sxD+C|09>??)?e+JsCCUcpG*MlDIG-Iyf zfO!}X`q5y&i^YC#u(J&Eb2#uk;Mrim3zdDGe$-D^13O2-{z%~E;JiN(_(9OW z4*WFm_n0exo&|qCXDbUoUtr z^X`JLVg8Wd+nEm*{2=p@f}dkPgSo8NCaE8#>lt@S|CRcI%uO6jyDYQlHwk?b`?E*z z6y`?+Ph);T@C@eRr-Qdkb-}Y)Ur+Ek%x@Arm-)kj*JeIka5K-J!d&Gu&bQwOj_amn z!j6~iZvs88r>^`xu)aoruZ5=zZv4z-F8!P=^pn`1*9D)-`~$(Wm@gE3I`gH1n|4_* z_)OOC6nqx*LxRs{eqM0XzE_+HjN4q+Un6)9^BV+T#Jri{CQsT6p2zw-1utO!fZ!{b z4-`C!`BQ?YFn><)H0D`?XE1+TaC0B^*MggVeVDl#2k`T5pPtq6RJ;?+yY>OU9r$_X zD&O$>a>aAnju}r(e6AAQ#Q7S*O?%Z8+_d}kf}8xQFL*Y`r;*?$pKlU;66@OvK9+fV z!A<--3ZBmTE`pnO>?U|B>w5~G!n}{*$;|r;p2YmK^E&>jUGV(=BXAtYN|>wm!q1WY z4*DWEk5|6n+Q;*I6W}-=b_9<59wUI`KF@6zwSAL6W?qrPT-6Ide>WI7?zcY!9QE%3 z$Ni$Mz|l^FkW!9As$AShx)nIq_c7pTXAE%cFJA)3cKMFEiG#UcYro(oZ%+tr#`7|z zwExDA$^XiNoAJD+;HDqlD7YEVTMKUbV@JWwcz&thKkp=XH1jOM&3%b81UL6Fe!yIwM?M3N>xevIr>kGLd!gXwa|c@mH|MXP!G02) zkA4NcT8BpJFouMdar>_i#<8n`X92Il-1HaYr&n;}XA7`{_HPA__ImEsS@WaeM5&SswF9ko%e1+h}%r^?YnfY$P zO`Ieh|b9rE189P-3H+HTUJeKV=7TnnJ32y8p3*Lt9^b*|I86vo`Gg@%-Js1-OH+KFb zxUuuG;O2WX771?btPIDa--hS6VOIpUm$6@&xwKPN=#8Bk zg8SHhbHTeZZ!dUn=3NCJ!u)>0M>Bs!@Ttt75PT-{v4YQKK27jE=I;nz$b7EgMa;hz z{4n!Xf`{oz;T~sK5*QxSOpyK)7S*S2OQ&*2OQ&52pr>+;&Iyr?T-PDaeECo z#_dDk7`JuIW!#FHtMN_6EthgmJ$?s17V@xExEtqjz{>+4543cmnXrz&iqe0r;K3rvUE(d@Arhz^4I!82F389|Qgp@F#(10UrbW zW#E3`uK=G0{8iwu0iO>1E#R*K{{Z+5;PZgL4*Uz?*}y|9yLpcLis8)7dDeXHqmJO_ z^BOG$H=oz&BDncnMqk0r=P$-HSK~t}jEAoQ$InxI1RVV@0{j1g`W|Ag`W@b{auM`z zfWFd|IzCcggSm>&o1nkZqHhcOnV?Uy=u<%d7U&Nn&pLg_$Sc4}2Dsn+A5!&ym3KKCWlMj*3N7p8vdH;U5Ek7s{Ov z_VGTeMW9#q&HY6Mz~2KqD=l_@0KKwf?nl}rxUs(-?BM-ZyM#WD>w66N``}OMtKD|N zc$Q~w+Qq~zoVm(#yuYX_=cCaKj6Zb+H}>Oz<9&(Efuo&vf*U&>f#dy(U4WyV zo`M@Y4>DKv#rv!t2K{V^=V0Jyf282X{Rk z<4D2H{^10{&#^z*f=^=pf#BK97YIIw`4Yi%nQsz2iTNJEQn ze2o1t!F{ZcWUli6c9=iZ0gm4n*Ah5hM`#Bezjv-1aQwc$hk)M=Dj>pvTYO<%9k<(0>mczt`>r*qH-m6M?0a{y8RJ(Mdm90sW3i7f*$Qx zx9H&tp9}s^s^-QMzsK7b6`U6We+>LAU)|Ls4`;601;3a34GT}I;l`&G_<0X- zjKf6cDsJfik(#bQ`2FW|qJ!K2#=>u_<=R2}4>4EuLVrF7J+@;$@Mj=yKLJPmA>gRL z_qyQzuVgOc(6qLz$9#yl@D9vn9(Dyi*0-BQ-yif??qJ}UhvR{x{v`{a&RqKW4(QR( z*%tj*pvQ8T07pO10Z044ULQQpfyow>j<4qsdNQ?bGAj0cW(Ub67ZZVc|f z$HLn+aLa892!TB@5@jQ}svs*7bkH5!U=3C`kTs`_<6FA1FDR9)c1CIK8 zfup`JaMW*PuKdJ2=@{?&iT!9jbEU^|W3PoD06XZ<3D9Hw&sg-H1h-wV+^WEFoQwmG z`kO7hJ##spcLqKBdACLXFzB(|$AF`s6M&<=j z`$Y@jI36Z3m*c=l;8@=s7CWAMg8Ne!INEuJxvcMN7X4P>*uDw(y7m1W=8ehBRlTs> z6wogK{XpPoXSBu61kj_M*MOs)ITkxPphr8WE&89jyYgl#4 z#w{QCd^pc8W3JlqD~M-&ifiXH(B}Y0`*HWX`X-?74IK43z;Ryjc`w%v_V;|?m_OfJ z_`44Tw=)ko+WFSPhxK;tp#K&7XfFF{RSPej8eBhtxoStOZx(R$^KA>iXtCe3uj@bB ze+f9+e+xL)_tuAl+qnxk+UafK-!hkR8}*25AI}%#fTR5%fTN#bkGghpAP@Hg$2c4V zj`mBXxpt7>!Cd-(AMmx%kA_<8yapWW`xbCKKh6h^^W?aJ+E3|ETjuh-&>8eNUJbGE zX@i2t;Q(-q=Skogx3YtS+j)q&^uPR&;QB_uF%B((e-7>5{V~@L>U#r6{X4+X|7Faj zpT424ebkQ`=5mbB%fL~;mASOP5AdbT{bH{%+vt z&mrKbKWE`B9(Ut|{&Zw6{eKzs*k7`NW4RxL9qf;*E&7wdvERKg-1QUdI|DeDJKMsK zGne%`YvG_;>k1($Gw&))QJ(lYSJ>G}*iiMXO>H3NJc9n%kGFN`$IqJWK+P z{yb>mgDpIrx%BfH(4(JYE&5kMkN&&~9R2?sIO-Q$_;Tjb&vl?jKQ~$Q2SAVI9tDnm zmdyy>?v*Y4YUa|sa(HL63eW07pL`1djSl3!iG?FEf|^&jdaC|E@*92=wSr z9&q%38*tPYTllZcrJtukkA9xF=)<25-oBB*(a(m!(a$y(p1@rCnFMG z1u)MqHP$T`>-!>exxRh_IM!>9g%<+HdDmvAf*-}N8oQBN{g@x=H~29E3TzRw4@GmyEo^E~J=Zdn%ohJ{}- zF?ign0>`*{ExgSn*MIb`2l(BB1o5%4tNxL;c7CD$J;w+(RIFTEc)+IbQ<#w{+(wU4|7aEwC|b5-B{ zF#h)dJ=*C59PJDOJNv-SaEtyq&=-S#2Jl_LKL)-B_*cMp178VzFYtR_cJm6qmwT9n zKWpJHS@=V*xc2e-Y`s@CSND(o2L3ceUntAT$7{KnU{edA9q`|~Jsm4}DH|4E>~3GBQL zTz#g;%s*FT2e*IEe>7M2vE9!xm+i88rmHVi!L{G`EtekwKhxd`&P%`R@}r=i{GQA4 z`({4@j`?#CIQoD2`>q}I^J(B{{}tc|!Jm(T{|bBuaI{lvwp;Eo(BA?4IPgc2!{^#= znd92Q`aaHF<%w#u?W5=yJw^+@hWQl13z^Rld;{|j1mDcO%Ezuh_&I_pz%dT9n5+Cb z0rgtK-1t9>?XLhkWvEY^yxn5a{{;H7px?_}mV4e}r}QUoy~=@|YRsjd(V#~^8(H+t zK_3eC+cKAa4hK75L;oEIcJRL3k3g^T!NhYe=qo_EKU(x#E&83nF%LbTx^csN@G@6% zL;r6Aj()ZQJLqRu;8@>j7CWzi9__pV9P{&A<}&^(E%v_yI~5_G`z-ojK<@#4^jtS? zm4UZpF8%2O`YS=-levoXH;^ZffF9#E4ER-G=T)$S?UD`p2+)5H9R0}$JKusog`h`& zHZhm=tv1h%PZcP)HFMb?<3W#ce%hjc)}o&X`aJM|2I$fMMZmFNtYj|hwb#ObxA4mI zbsS`UuV${=sw%`MmbonVRtq0!u|L#e|9Ojk3h1u|f8GH-t~)-q@EqWnhhKnwHP4pn5$J1x{;)+K^_iP**dLn%$M$^)IO@}xtM7GC}f zw_NnU8gpd_;}8w{hTu;Zm!c+7u@)HgWyBB+(v?%c4;km4C^}x9?QIo;3^*K(M#}T zjYIld_&~u;eMbu3mF9_Qw^{7(7JB2)FTe{RuPy>t{oTYTEZ5DqrJ%0{TR#SAk=EW&_7^ z=K)9iUjbhQ_Ll)i`x}9yz6khgu=5LWv~w0X>M#4+%?GS+IB>L6)56;d-jv(Dz2K(5 zcNW~}?-AVe-(G^7{?bqI7F_Ni!Q+?@7u<}KV+8NX`iX*@{G2AZ(Z9-Ejwf#lz3IR2 z1IPaRiN($W(5rSac5($b{r4xqv$$Txf=^|BRB-;XbAIeEcr=$gSa1{1#|1ZW z7{y%03+F}Sg+7(-za)4Y=C2EG`q6B`r?WmsaHG!?+}K}X;e~=5JDUYJ@hlQNp8Y8n z-1OhWf}40=5ZvTLg>T(FTm$1_1aOs~re0BkoBW9Zj&_;@S9Xm4X2Fd=cM5LG?IE~{ z+f#y@`R%iUo47qMxQW|~f}3(@2yV)Klex-6JkP!ldOXiA0*>dq0^lk>S@feG-wST? ze=~DcF6Muc(5E_9LP8Dz$8yW$>2_Ck+J?F78V_@|-dqd$Py_V1-oFhvUSCKCJKuqw zfuO$`%6%O8Ex?}zj@Jbyg8lEo{tVEgpC15E0Q+m1%k}ITu&-iduGd@yJMF>FwfSy8 zLVZoJ6X-jE{q4YS2OhFmw~LDN9l$FvSMAanxCeM8xc(afyd&tVfqlGwT8Fuc zTOs6UGq8jCnGANifc+kz$LrLCfa7)Q$H5NPHxu=6o%aRMqyKMM_$IJ}`(ss>xZ}y4 z;D0o8nLpQq{%+7`SoC8+kNbWTn9F|Dy1?}Z_wCyQzY5BIg}L$*_p9FpJ+{|M;J9B` z!d&`OdTH?S;d16G53ybm!0!S-qk&`mTQZmB_GT{Q-xuuQb;HL&{{!UhSkPk}CNh`h zE(AL`9_E4_EO({F&Jl~9lNLLrmbv{M^Z5qm%9m~s&j!G;9g{3}dV(JFyq`rs%)-Zk zomlW^nnl0P!uMGC?-pKZdGPquvGC>=-rK?lF;{WMynPBd=Iuo0DnIc$&J56Fz7+sZ zhPZ76j{W)|@SdPAyCQfTsxz1UUNav62V-y<29hi z_|&oJ>w_NS-`JwR3G^7xPN2v0OApXvo<9T}$EC-Z%lJ&T@DD8fTMOT6;U_FSd{yv% zRL{bF7T(*!Gc5d73xCVPb1i(cg&((Y&+6dyZN^-lU)osooj{)g<4H1b9N!*cF7tUX z=&>ISXD;((s>ROB7CYG%J98{{=7F6Dpk9kCc2qZf*$kpS>`fNUbNVG73}nZ zao`P$olil3Iq1Kz@b8&R|2Kdh{olr1`hUV==ZwWpsqcfgV-4ogpW4jjxKz(#r!CmQ zaVZJxV1MrpdK{PfTl7zZ9>=9;L633sGnaA820J(|eFS#U&xN4JacP-Fe-wBt$cNvV zOMf~P25*;#E&OW>-^5(S<{>Dz$f7U*gDzLKyZRhWG=1l?dembs{aj_?B^G}BI@kV2 z7|-vq@IK6CxjUGvdZj|W_E_}Q*9VVhEOTY2FW6}UydUsZz)|l5j_bR-Ec|}vvVT1Y z`ux1vHy*Q@3-(hK<(A#-+F1$ymj}KIcqQQI zXBFns&ln5u0d}z5Uck|Q-7VTr)lc#Bxy^v%eUO?ZjF5joVy1_<7PS z<|+>{A6^4~0OGkC?97L8cs=k({5)?F=<)Ns7l7mEZLi$!`o9_MS7omJUk851 zfgb(56*$_z4>;O?5IFkTpSdb`J(T+xaQuAwNDCha9P|Gj;F$j(1IIj^4}3NFlM5X6 z`M@!6S1_+f^}_!9;SL>tnJ1qD{{_lj3LNXT9XQr&FYrBJ=QQvQz%K&7492B$Ke>LE z10D_><4^@S#-TcM)qk5ozTFIZZ1+UqX#Wo2Xg`^`jPqd7V|>zq?}a#wwAgtU^!Gp< za)4g}JQsKc;LCucogabU0s4a$Ug>AIU9etP0Y3uux|X?&Pn?Cf13SmS&RxLqI>jW5 zodVFKosGcJ|82mJLb<;JKMVZ9A~z2ALfp0i?+*Mh@N-}%a;IyjEa;msS9v=R^7c;P z`2C7KfTKPgIO@j%-vahu0lpRZ8^G~<-b#Qs0sUFvSZ>%ZU0+$R8!WsHb2VP!{VhqL z$MeFSpvUu6576WI{~U1q-iaB&@%++nx9k5lsP9nVcpiTaIG(RR2afHPZ{cfzZ-;V! z1di>s3pmFA0B|h#Fz_8<{}k|_fVbS|#^Gn+iOf}d;d=Q8&=-Ne$f7?Eyb1J+YxleT z1@H4|%UtCZ{@*ko=$nI`&Y*t+{OM-VKLGlXpzmkV4*~rM&_7|(j{*Htpr2sTzX*E# zzih8r^zVQk|IgZopl=58$pQUN@aHRwektg8fqsoezY+AiLBGSI-w*mdp#ROHKMi{P ze{dHq`trqYKI8v=3umtK8RK&;==Xv@wJiGjpx+1j#uj~d;F+*49$?|afsXYZcZvVyp*cA9KI6wM;-vs482;2|#8UY;bya~J| z*jWG^_4&YCfj;(t>p$*qbY!l^9~}Stf*$uhp0Vg#{Nm;zt~Y(a(f(Z)-r!(xJFS4D zokR;S|Ep^!;QV#SP?^}x~2P78neq-zK3)!>xovR*ALyf<@| zCurvt;Fv$Nzz%*t;TNDs|35qH`iXqf1=mkpk4yuO>&^MVr@**3{i16J_kZ4GF7s+( zh^ndnya(#n1IP7#)lyooexv`DO1m8M;acFRkFoGlWrEwO2psKHv+&ZFxpr`V+X^_g z?+D=7zGH#UhjGKtT;&yx57R)8PZF%H$kg4=J)T)o>2@+6VD>~|@k-w*o!z>9$oXRhLm>#6Y;`!hlR3dHSWi$0gR z@?VuPoxfjenc!K>3k9Fbe4F4=%+CVHe6Cc{jVE3Qxt6)~rw;HEh)*1FY{wSBRlTy= zpSH}Mx=@-DUUWb`0hW>|D(s5S5 z4?x_S0RIK}9n6)T84#a)fusFVz_H&=27Vsq&mRE40Q@W97lE$@u0AYjK3BDax$IxZ zK>rr#ukg6}_73psz-Iw($y^9QXN`F_-;)zlE2(%5C?mFrHLlF6}h8@JV229@OgU1o-E` zw*g-Od_Qp9Z#e{fCg?9RSNkUv~mKPCt5@4AP@N z=rNwdE&7q5$M`&J(Z6ru-&yz;3qL9OK<$6^DmrfJx2jh)=3c?0m^THE{ip+T*^eFq zy%RUK^NfXm33g7xxN**+FMV~O|HjYC7GBfB+em)Dj?WYe&tk6XgzY%bqF(^|FCm}5 zw&=G=euwtwB-qIXI~A&mIJDLJI>1jt{?})&{Qm~*v<1D>UTi1D!UqUmjrD^Ck7E9W zg@4Xmm5Jxa0?_06aW!x}KW+y*cz(PgQpZQx$L~q*WZ}Jl<9TNmb7k!m#Pc)Iz-^O-E*OThnmz;Qma9PFQg_-q6{#^)#Cm?u|P zbK`*XpN1Bm%v>FX^O=W0kL3;oj`7a{j@J`6TX^Fr*H5(5mbsi)+->20u!DIx!@}RP z*f{}u%(v^R2lulBaI9|^;OAhzlmZ;}j{`pg`b^+huPMxxS7#wl-T*ze*LT3N+&#cg zL%BzQMKNIvJR9Ca!pA7o46?4Jic+P~WC)(h9^)tRez zOM{(Q&||%B0(}|K-)hl60s69_A8*l51CHa;+rY6u9srK*zTyU5U-kPkDEBAkDu3{N zQ7XpOe@O3{_KF2w4(!~g%{Uxe0cz0R9>9%FK=Zuh@PR=wAkXJad^>=@$Nmh5rEd@%rOt(Bt>F>;e80_!AMU z>#O`hp2%Fq0qu8YZt83L<9(oS2KFBSj{DF3n9DfK1O0XI`5pAQA65QF zx4wA2KGwo-XRhLa`%&F2`mw;ffS-P_ga2P<8gLvZ{{wc=&$-N1Ey_dQehGGdhH^K7 zz5?jCgT4s##h`ck0O#`==CZviHqh}@zpnuM*8oR5(afctFPJMWo`3T!c2-+>#fHJ# zcLsCyZW#Fa0draIT+pNcYc2MRKwlB;9|Vqej#=zXiqrl}e_mp)-bFiaSol`vGS2-Q zY5VGTCGc}Nb6M`wpvQ7&Fqif}x9|-XKCrRtj|cq8U@ra11U>rmI&F3+b)lq1FzQxWh z&D=O#34V5FF70;%J=!12T>AM8=&u6%S-{cGIt$-ou|K%E_FwuroVkp{c;?d2@SEH? zM1Y?)nM?b1K#%@+vhZ}^_<7r>fuo(V%%z{FKwky?tkuHx|7zfI%%%S~fga244jkuo z{h3RDwu8PZl=};FS?*ELW4UEpy6yNHoWIHg$N5G$bLr3Rpx+L5?gKr}qlN;<^ZOHE z2ft@;0_gEP{xWluZ)RSa4LlO!^B&m8>rkHo-wFP&0FK}9w;t?Y1NL`;9?!qOF;{WJ zIGhHK^Tsl*+;+ivmxsBGe+vu07dXZ_1?=Ph?|YEBjOU{kJ{0)15Qhw~k8vIk`f8wm z8T1&pnV?sBYufjH;JEIX2X?UBFM#8^<6E$!?3;DRD$wJ8LNRk0{~E1zdr98R!be*8 ze=K~rgT!ecDFxrKKIj&Z)jWd>eorO2I@OI3VwdzpcJ3){2?F}5uO}Fq& z3!e=9B8(3&0uQO^?gPIA9KU~c4s+Sxms!T-^^Uqq9(*)KXc_L#^Hj+PUYKz$DtZ?^{)C(FLT|b9&>5Go5fD1 zg=c}C>CjK-S@f$cyn3ScU;W1W`TGH{1^z$IT>AeMaBSbP%w?WT1N+y3{cMZ=W3XQu z@?;^{Q9haP$y^HhGNAt+cv;|km`gv8g1#HXxlG64?Ow;i+cH;2)rR^eF_-b|0eUa! z2UzrvgZ_HZkG1HhfxZstXIk_hgZ>84=UVh@nag-?2R(jI_-^1{i1TraosdpC{wi*0 z=W^h+!A?!!m4Me_uKc_V@}WNH%fNjvEt#v*G2d7UL#4zQ`Wa3bJgcCKKEF7AB&x5EPRTEXERq`;d$zPi~eio z%1=B`EeAU|ZmhT1DFHjTL!KN4J9VLbFM=N1_o_Q|JXM)^{<@aAdbb|fsSA3va|`Iv ze;?>8L%-<8T(;v-3m<3U`~aeh+2vsr1JL)e=m!ADeYV%YPD8LW6L=i(55W%lGY|BQK%ZyPF9&^N z&~LQpcYwYL=nq=-$3Wi{^rgGH`HcRTXRh9D2Kq>gz9#6KgT8@9-wgCOf!=4)-wyf~ zpuf+e?*salpdVtH|Es_b z*7pQ(^#6*x-Fl(E7Vx49?l{>1IO=`CQQsLjjvGCg%eXzpTzQ4pU)}{fryxEXf#db% zVhcZG;bF;c9MDb;3y-t#B;fnO&xe_-QtM2l^uLa}4NleE1sl_&qc0EczSnb^VEi ze%FAxY?tPs-wXc41IPO$@3Qa*!G2S?p7;pp(Y_z_Sl=a}$M1vM0{YgFKRZE>?S2OI z_|saq|p=e4IJ(N0(NeJIA65rFTc-ichpy7uG$^#Uk7^p9@Hil zeJhJT2{^V_GT6cP>TA&t1U=@%NYG=xWr7~13lV*7dV~=KeO;97W=C~kNs;i z=rKM;7X1Ox>DoOz_+5zM0m z-_c8hXu)?f_X>Uk+ldjpG4oi#+cJ+6JdwHi|L3N@cQZHtN8RvY%+3E%H~b0a@xp#T z=03q6VV)>>Ci5i0O`N+5KAiQ*f=^-IUGSHfrwINm^WK6_W}Yf|?05|Z2>u51G{Gl5 zr@;`xXHL){UGO-zGeYoY-)WE`_?^s03qFwfSi$|wx%f-@Kb!d^pL~9F9xv-kEuk(D!4$M{v`=#e%=U z`h$YM&HS+73z#1ld=>N4f`52agL8s^%REGXZRe$W{lL7e;JcZJ3VwolnBbQm(*=eL zehu>o!Rs@R6ud3-D8bK`)*xE&hGjJH3Vsjs7{Q-r9xM1P=5d05$GoZFr&UDq2O0DSN}^6?Oexvv)~PwtMB$leJkeb zJM)p>%3OUHI`X@itM8CR-ix{VE<5CpFjwCVf_yl0^_@}3pJlGTn+5p`%++@+AfLfp zeU=~jd(72m+mX*_uI_0^{ta{WnLFgGn5)lHA>YVceWnKaF6Qbp5y*dIuI}YSeulZa zX9jt>$~qs^y%5OX|3PzgtrPiY%+<9U%+*>L`J2qu zoEG`Z%zc8-WS%JaQ_PbDZ^gW;;BPQb7W{SQ-36b{JVkKhXK%sF)m1&2{`a5Yr(-l9 zAox|RPZRt~=0gO(nt8h5J(-UXd>Hc#!6z~wE%;Z=#|qxMp7wu&;P)_}B=}>@rwaZG z^DM!?Vm@8)L+nqs;1yUuQ}FAV&l3DB^Vxz|sITiaNAMcV=L#OnJV)?W%ohos$UIl@ zCzw0QLcdh+R72DQ-8Bi-e=hMyn1>7g1oKG2$1{%>d^+Cz&aXb9Jqz_n)~BUQ^Pj@XnvWKI#Fd)Q5q!fnn)AO&ykw_c zHOO-XTP;aZB3XRmO zkPxrnEt$6wd;s$Sg6A+FE%=TFBJA`cF_8Bg7@SBJA(VG ziQDtcV+H?$xliz7=0gN;+EJIAE%TLUmntSy9!=4Rr6HAA7Va7@O6E)UVX+~J&d1MKdfJehUveC zr!tQcd?E8V!S^xu30~z9ZMVDNKIUnHKhAu#;IA>y68sb9>bu|7!}!01`9Z;_KdNDQ@(PoJ!Lj^LRKG+!h5o6L&@-^%=);Lj}7cET&`zouR<@Ed(#OOdsD>@Y>7=2;QD~w%})$ zYdeL4&s(W^vEa*@hg1ple;4ye!7nn86TIdseSEUu9hnai{0#F6f>&9s?aUNBj`7D*_3Jpn6PPCop29pu@Bz$+2%gS-tl*=WXA8cad5++x zm=_8j`n~plkKpmlPYeDY^Qg$cI7F}KI0#;kxlizB%)1L7&pb`=+nJ9R{2u06g7;xQ zTktgIxq^>i9>(i(Gu{r|tn1ZX@PaLxj}<(7tL7^N_ifjFkKoxqX+Gdu{nwQH)lRk} z_>5he7YY6i^C;dwFm?{_*81*(m+a9zTkv1@YMv)}(mu`43BF{%<}p$FuPHa9SiepZ zd}4{_qXn;ZK=T~I7cyTX_y*>C1V7IFoZyvz(e@*%>%Yd&M$F>{Ph*}Y`1{N!2wuQ^ zrr;&a7YTlmd7331#ikcq(-3s4>FGwd_40w!51=561?)S+HR`g^_XV}9?v{W z@Rym-5&R40n+1RHkS;fZ_pwa7G(4iYPw@IjHSaBWH|8S*f0X%D!N)M4BlxYywEY6X zzhPc1_}1g>f3*H<{J-^tejOutSLSU5@5a2V;14iQ6+D&s2*Dp_K1uLl%x4Ndf_aYM zPcvU3__NHn3;rDQ&{`qR!^Ghf^C-a^oYcBR!QWt>A$ZeMT0d9tRm=+nFLPS!Hw)f| zdG2-kedFgszW%;la35dqJ}vlQ=Hayi?Mz_aLhy*oN;$%0!EfUm5Yhzi%Y3ZhFEO7j zcz$_pzd-OK6*NC6c-<>B5Ag>2{|fU6!OQRs5vhWgs-*4Y2)>c8@2?QtTzB?eA6V{r zzJX$r;Ek`*_Gb#-j(LvYcQaohcq;Slf{$T-SnvbPL+b?k+38yCPn6(yGmjIzKXaep z?=tT$_(tYwf=5)-<&GA-1M_UbUt~U4@Eqm^g70QtBzPyjQRTSc+D>Rp zU>xqKrFoR#Q<*0Te$91SKS1#EwKX3t_>au91V7Gvw%}KJwVhnS?_ypk_&DZ!1TSEI zTJYbQht&;?L+tgs+-SicW!_Zq^~@6mA6-Y=Nfmqx^AUnyeuLIe61)xb*@Az>JXi2T z%r^^ugf9#p6uf?2U2aIdz&Jd@JXY|w^|U@-@GqGs3w~#PtsgCTnm=8^RS>zmqG+ld!^3-e^bZ{{1&h6vvJW^HGZ;M1AU6nrD| zHG+@1McX+o__TPtvjv}gtJcpIe8BCR7YP0{ z^UZ=cyF=>_3O=#3<{>u*)@$5dnnwu!JM$KT*XpMA-34F9e1zZw?$P?`f>*p(^IXB_ zbl3c_;LYySyljI&|KDRCDfpW`wZ4tu=TkKAD)`C!HBT2jx{u})1mDCwTktLqYW-Zn zKW1Ja`1KEI{bs?RWqwfb8O%c)2F4*YRon4O-dFP$f-hvAB>0AYTHjmn#{D%<7yLu! z69n%uKS@j61ot!d3H~PY?t;%{o+kL$%ts5pig}jco0!iQ zd=K*i!3#%e{|^iP>NA>$Hx7)$^?bui8^L>x(fSm@i(lev;s0n9maY>JPO(SMX-cLz@TMZ_hV0MF~ELd7R*% zFi#eIEAwo@$A8T65qvuH6@q`pe2?HqnV%E zo0!iL{5bQ2g6GcDcFML0^rz;0&7%Y#$-JrH)0uY_ypZ_-!AqED2!4Y3Ou<`yru``p zd>`{-!N=ujeOSxDdR_my=5d05%sg4}W(%}_gy5es&lWsxq1NXKK8N{n!7F~jezpqq zvo3S5;O&^V5quc)WWi@KPZRuW=3@o_o_V(57nv^-yw8`~|LuYw{#NtQ)`9h!nWuTQ z;PaWc5Ii(r>yrg<$9#z38O$dMzMT0i!S^yR6#Tixy4*d2zsmfy;O{f{wF#{6+5&B7 ztl*88X+Br*)yxY7-@$yd;76Gs6#Vk#+I~peK!0j7j}W{e^BBPsn5PKdf2FpcA^4It znr93C{r8#|3qE_j=H~=o$UOY!K>wF9A1(L~8?>D)!HbyB7W@$NT){6gFBIJKqqe_C z@aveL7Q7kr@LK}?e~@__!RKt$_InHd-6qYa3hv*od5+*KcWAy{@P~iW{IuZN%){dY z{rrS^tl(>y`vm`qd5YjCm`@jc?a$huxq|Ou9+wc}Jj_1%{vxeU6#RGQS%NRyr}c9L zFJZn}@SBUZKD=FExo3IT3k83adD-@Xety6_ zTJYt}+xPvSbV!;Kw!KPUKV=5e=C?ql;)=ePhuX{DX`p!nYR%r~hFvjqQy`3Aw;)zJEo+XKtZtf_gt;MHqs zK1uMGy_(M!{A=c+NrCpq@aOfS1fR@2PVhIG`vm`pd3V7VG9Mv$9sXR{B*E`vK2z|q z%yR_)gn8s0f%W>Xm5xKK;ALBLJOyvSJX!Epm=6&A0`m;P!`o>4Qw49te3sxz%ohp% z2JnTK``jL&%HQG#bPj}!b9bD!Xy`2PTP7kmWsG{KiMA1(NC z=2?PA@&5suEx3<)uHdgS_jU=a@6Yi%J}m^lj{k2>lHi@0_ZIvS=2?QLb3w{@W z58z?JCo^x;HPFwq{QWy!1;4JRwx23^bLJxi@5DSy@CD3g3%-eYNP}Td4ovU!ApK1r zs{al!&xZC*>(d~;?}+q}2C040`-C)jaM-Yr215s{7fRl!L8HKzE$F2>MoajGqb5wW zLE7Ml`lLy2ptk$au=J*vtkR1{&G8kL@X+9a1N#mlp9T$1@7v(E&fRVtmfq)~NBMRC zL60{WGIa2ezC+WW`z|5piK)N&8&5RY@!<=#|8wgH9&hSzj!)*}wc6F@ z?b4(m%w_6Xbl}Sn)h&a?KP2OFM>(LPK0w7^5mUa2e;;DX7a6~qhjjUQ^d3H<@dZ6k zp`T#o5Af^qdDwDpA1_Z@S^ks6f|cLvW>Q%AY+^mv8E+>VF0OnBxss z>7mNMl78?pfXknQke;iu)WiIJg`NjHKKh9Ee~6=Ye}(f?^LLiz_^Et+clS`|nepHJ zoyW(=30*NCulff*l&|Vx{(cG1oj3Sb#8K@(GWFaXXZR|5q9QHTk$il#5%OQ-x52yU ziLxn=Z^6ee>S~nwuRMMS;b85b$L-&h_nlSyUqwIWc+>vD%2p*EZl`-hWNTgHtBJLv zK~f&Ca$5Esb$sY3ogw=R)hqWQ<5!v93U++>5}m&X-9w#c^7x^{2J{)ycUXhL4Wpe$ zoc;sPHEG_osl%GJXx>~u>s{fQ4oSC`F6CM*6>{?*+E*1iV5jRuyz?|Z#1m2}01YtGTfJeA`^)vvH6iT>q@`G=zWc?K;vrIb#ekvP#A?v8l| zCwoIZl`Bt7_eT033um0@ubk*l2wkH5?sj)#=D|qic%J_(`RwzSP0TNj_WQh{i4$*B zg-(1rq*(p^R(a(-BR5nUh4k|rTIq?&cbI=meo3T%YyN?7&w_QH1*bd<&N@7CVs)0T zJLaj^jl2%Oy(}HLjb7bfmR^-P=IKSA^jc+1CwY~K{4n5ll6Aj5j1JN!{`BbURcWM8 zRaPpedc!<1YyRAv_Mv>cb6mXS7`>@{RaN>kbAc6f zOnj?KaGoV*7DV>E-)S0Z80AwQMQSIKPZ!P~}&w>pJ{!RWP z`6c20ByZe=B=2?k#gWv-nojU}YpdXT8s>X4%hUKr&ZK*zJPnTxFHh!E=xNMP$2=+Y z#CaLviCIm3#p&Fhm@TAsIwEyKPx4}VbO2TceQ@k;rDcN-HnMlw0FbXvJ5<$fscJe)fN2G}@oXEJtfq!#;am`Yj ze>hDw@@Aeb<$0kTSxWdu<+Nu(lDD>JL9+L{1ZPml@Yd2%*24l1F;wE;A05KUFP~R8 zR^Wm3MwvhFdM1vMB+c+rH20H!zbED({rQDzndXg3nw;uwlQcQa+k!OCMUi8k9_KwV z%ai=SCHeO|-qSm2-cV1>33@Bt+r|^~ohRlzJ_xfNX1croN`5p37N}E`C6xY zy`D)S7cO3$m_+?zh02e7|M!{uOVwSTd9jpd?2l%+3mEtk&0v!7fJ#1ghKAbEl0Ec) z_6YIWuNR%2=oNQ^Bh*0-le^>;{dA{vPtoTjBcT*tL0yDiI_Dx!%nzRA_4JB+%dShk zMI~V&^_IoZTMEczp{LsxPs|d}J=Di2&ZETMK)~S># zQ`8k5-$Z(kJ^Oa>EVxKNCw-m;zj_udp)*3X&;Ps6f7Ivy z&A;4?hDmBvqo#?_QJFK(aU76LW^%Af+efdwP;gXRH|N zj+7*7oFt2mw!^qRo)?x<+kQnqA(x7tnBk4)veLY`+7VMz$J3^hN!f8TQO)X@Syiwn(C6^NtJ(cnKPwQD*tn-Z4IeC=carDBopg>LL zXpu!je}*@PPI|Eu=@j4`Or1u}+>^Xsr~7#7QI{YOlGIwFGM&d95p@^U)fQ0co&{+% zFd4UtYzeWIGtfDsQC#^QfR(m`Xr5)W}0vz$<5>luP274cs)|o zaK73Tvx}ams_~WjFtt9NMXBrPl@=98PKRA8?2^0G#5U8b=q){HCo7}6KcdluF&75V zqSiC+XPOK+b)W@K;CWsz8)(Fhc1OxEUWr!k6N z!nma8&$@S9Di!9!*qT&JI+!{g8FK1Pt*M7=v|^f}8Z<-TNJp6%aOMsOCuKE-Gfah3 z?b0}b`FG*`Cy}D6t4S%XFrATKof}O($st`&np3D#;9}D5A#JMD{;5tTuQBaMgE0*} z*7yard+F?;S1~4j_5N=BoK-UAxXMEMO}&GDI}J^9hNuMpMKu_E8f^DW?4?(}v?8Ng zs?2me%CqC)2dBbag;QA(sLq|I&>7RnlB8eiqMIe07;@K(4mR` z%{+$CTco8prZ`8CfaXn`=oG?}4V8v`>RjweCcn-4K(D4%cvTeXXYmSHAFQF!=X<(s zRm1B&D`+)c;%j-{Gvyo4SUka}WHL7oN6@ciQqIREel9F@r{2f5}Zw=4@nKFiR2oQ`%UOW{fW zlW>aBZ)d2fyN)SM&uF?zP1A#7L#@H94LsunTfN);AbUwFUKBOe(UpB?1nQxe+SCzf z$PQ+bgk|W>KiS%&nH~vfE=Ha@&o9+;X<#k&et>hXqkLA*IE$$sv}{qk26~pL7cJ-y z>Hgt@jgHXvFNKgR`^WetWEPa_(DIyTQfYH?wJxXA50$*`ETO4AR3~%ibde>C3vHyU>HKkh;$`Bb?C|Dlp0^p_@R zbWT(I2sFc{-?XZr-!z}5iN_#4T`no0P&!+gcqVX0GMcN~MzZt%W6n6XT#r=FcudJk z;meU`a!ER5; zKS=AvpVfMiD)NWHjXKKz>{cN)$*~SCfAdVa5IDNM2%{T?iNdRzaWe%h#oN?9UGn1a zxMu-11P%VNdWA?+XthG*QMl@#>CiNOp(*&+^8l}G)s0bAh zqR#y9Bjf~Am2qhpq{i}6Bm8j;q$O=a%N?F^pHtV;O)WzCcN*M`ysFj6{GN}Nf8Q(|OEmp>UW{|^_z)H{nQaXWZA z|5owe#C*f|#gosFt|wFX+Lz&wE#K}*!AYxdy&uz^JT zBxE4PSzkHx0(zCE*1CH=_wH1K4$a0AJom2f#2lsmbzBcap|n%j{fORp`rX;jO`+); zB^0%NkKIZ`i*Th;TN11Eh6HWVlRyWXd`?;Fi8(;;7Asi^4P86vu#}(a7oArqU3x50 zZ>RToJEs$?eY53Bsw z7xUG#eANRI^LIx3*Cm#B`o_vjgs#A^v>>A2WyR#$p`{^iR0O7$zxj9Kn}wK`Cl4}1r%T867j zvw3v%s1^RRYPVTk7hXffm-Tj}Yp_0=RFtJx)YZ9L|KHsKP?lPjRuUch7ai9b z-kgl1#H5ld(}Fjqfa|r>DQ%Z2tw@)4&Uu&fgzuO5>w=u^L{kyRLO>S}H#@pCE7Ds| zQ~;g-of`{OLT;oh@T1lx`8PUu7SQv>9m^kOjY?XTl3OS_wy1tUe^uW5{P{lrDxd#5 zm6#p>GWS(x|NEj=Iz=t}lcEClZX#8NpGff2g?Dmqsq^7U4m<7BcbGitLWjwZmufdT zqc*J$ifLBje2miPKk0}j(kwe+a{6WJJ?BuLe;04T2C5nAn>O@~5YDwrv6JN7U!w;U z|9Lts(w4*lisGPE^rP>8pdRgMxZ#P*JPiwnM|c_*dB#W5`O*_pNaL6@^`Mx4m*_vt z1IAB@<(CnGA!H{FA)XjIr>4+|*}Ygb=bQ z*5^w-Wu6ytC%RJAi51M-#I*l}xy12Ol6t25H zZAN(-?(>Xa;u!3)(YQXzY+LrERpl9)Pf~PlAyvZcqO(@mtqu0)yyE|P!rwXKy_($hiBK^+sj;2`B zlUd%e`bn;Lf+3R(nW~>;d9(DB9Pe~PvgyfkpLYoT`_}gKm+onOPW>H0SeZ@oX4tmM z=(IpL8Td*acJ4xnO{AmZ)KT%C1xwXpS+6u>N-9#YXc3pB(h<+q6URDvkeb+}tdkg? zadj(DdWOal?zG<1t9Uxr-=bt2&2ADi zDJZ29DY4=bGf$WGjNM7gcIPD-OdmUhYD1fK^gO3vG#%=^R8!ZS0&Y#pWtDSugO9pR zRbLe|w>i{S7Yt~JGREoSyy+;n8p+sS-u$N~aWwooX84Tpx6gvkN{8l#G_Rwac5m;Y z%VHu(g-e~MgWp!Ew@7q?#ViR@V|~3ljf$h-m`l@GqPevv)-$ObW&BCXE4r2E zJ<6>A)g*9|hN=&DfD-z%iI-|#YU5NDH5%(8=wQ0w;4CpNT?`D^zz#L{xlp{alGcGeH{bPqQ+~Ii>u`(SOm@^tLe(|F4FOBz1Np z_w~_#2uolC{H>~V|E~g}{Rk4qzY~Z=s7j#cfB$Ih{(lz;?Z>~(2%1#$veTfb%@JGV-6I6Y`Eg3Ur#AD|?w~Wpq{gL{!(27vbT$R!>9_-G4^QvW(R!rv z9B+;@A*HoQS#==o?9nVQ#S=rTl9c`QBGsEjzh`;XY~9hT3+6O0R${$U=}kDxo9Ey| z3hRw%S_f6m^%m&Evb-ytC)8z~-AlbSnCh&;d6`2e3o^4t>t}fj9ed9HBrR8IA8`Qv z9_!tp-_P-G)=$QIx6>1LW$;B-^V#R76j*yy{~`^kkM-{SRh(GRGUCpX7MeE`vkV z*Eg#|CV8VZ%JO7?u2(JMoYH3MCt2QE`bmzn#G<#d zymN>wAL|`Wf1I`6SZBfLEceDbOGd>>ImxS*jXqC9J#QUfKlIWEqyF$QgiC8av!uxx zJ6cHCKvJ_w==Ldi}p!)~M-d zMiO1o96?^d70tjK4D{Qy#HDJ}Qi`Oh&O&nyy{22bJTVuj7oRh0kg_y0HJc;iuQC)IoX_na^xR zs#ke`rv!?Ded(ja89_1ap>Fcgmmt(-1KRM0I3_r^Q|$MQI~QcJJWj21oVjzlGnXDh zzv)&_`c1ncv`1}b)A|D<|1MF;w+Qh%j2<`s=Tt@ucNuHV z-}*e(f3xM;ZL`|-ge_0H`QZ$m#+^-1pQrQblKaR*_tv9?ujyn@6A3z>w@#w_sluH> zyp@_Ngp=nmRiK*UR3X%Pd1l&}4x%%DDxX7D@XQtv ze99!2ro(#EEyHZ{(F}o3N>t{h8ycy2XFlJZuFunX*Le>6mUy=j*rNi|yd%se9@=wm z#`)PZt{t_k+7J$RHiW~S4dHRW(zagWj!JY)dy?!ho(!))A^JSqN`=jr0S%4BXO#=rXP7?_SIv&kDPq>7<~|oXwq{4u{gl>Xj`w zIOjZ7`dDuy5b?qjIDHLQgtWD|g>Az|6e}GEVes+!O|kBgXU9la1Nm9m3As{}) z{L%Q@oLK35UK4M}2DHqLTe>sw%6`;#MDn$ibfT|-3;nP%z9#E07z{%_=b>`tFNW|N zdoi&)MEQ%o0({_PTK*!&H&DDQKokxyR{CoFSN6AOH2kf92AWIDgb&*y?Xa$D z>2BU4rp>hSXJf?w5Q{pa>|Nyt3OjIhtiXG}+SF zion@EtX18CG`}ED%=@yt2Y|Pg@ioGBjN;?D*OYbX6FXGQ@!o)3_Cft8@9<&2DIFEADRLewb@;_$&(18`0%0KT-k}ckjJs zwaiizZD#0`Dv=aP;A)M`xXpd=mr$fUUxsGDjB92}XUOCDc=(Lha4!kEP~9%`RKDea zH$aLYhfDY4G9EWWRX2FUJG|vTHg|^QvE!+5Z;|*1xMlWjgKBX@To89cTvpnBg@#*1 zN@y(=8S&nHZ{^=)+=gml7W!9emr;ELl~lt-P}wjT0VUPex_+T@{(mCX*gPhIG7$0k zhtw)%tS~CiNWfd$XIJ*}DNyJ)*W&O9y;D$VIb3wjcAz4|ntvdLm5lx*1~a=9actgs zd^M5+Tl{5oMRuV#LZYQb9?qZ*-iY(r&x=oCv=&XY#%rPt!P`%~$~?Q@!zdRjGPM`0 zB+ycCihXF;-m;g#3MysZ?XAI504iR9GSFkV&x=~aMgSFp4IZL_+7%&%Zbg?4ld53N z15X{>oF#zd%@4$IHYd!X3U3radNc=UDohg3vg3JIf5%_5UB7gXg0d!LpYqs}+E@fH z?j3L=u7^6@%U`spE+I*1?3?F7YR9=YXb93DMp#+ZvjIwQoIl-oJ zD;C0pO5imjZm8j&hXV_FnjTjQxD*7*aXk_~?cZ2Tfu8}Rv~d^&mVVX9JPR?Gw~wpw z&`cG4BDhIotDliKY0(tAr+Ti1@jW0cV!77XuK1KsE=Y5scF?CGXms^jEEPi+Q5e*d zg;BFbef7K`7?UCc{HYuI&2s>$1HXH9e5mw@+|MuN0%z07eFtwCR-gBD^*b?YUjumO z_e53U8$?xyXjO$71QeBzJ@HAvPF!&_$fTkcB%?|5-W%U@#w(?$Xu02I-&~ax-hbOJ zi>PoSx|_vtVZKyLFK)Y3i9$tP8Ov%L=p%(!OWoab{llC8SO&7G*RaNJ21MvtT4 z(J$!k98{?g6q8Jp^4w1cRQe##6d{f(T#6pQ!Amui-Ktc!Eq0d&7IZ<@+Fd zWXH=V0^x0Hd2ALLS^;CQX0(JnkWu$$(56OM4WE(d%I)xGT|&yU%}aOpij>hXK2_`b zYgu6zV0Ibq7k?Mc#pD|^Z#eRaGW)^Ar@Up+hsI+hdJsm9euNLe@6c{;R4sKcLfAJf z>aUKry@H7pA3g8%U&56bZ~B@!4q{jPN@ksCONG!Ip-o}-g21^ zvL4|v6H^;xhRc?Q!CX)tI+Y!TH&fC2R!(c=F0*+T9TeC_3bjLsios`eB6S{9UJ>q_ z!}&oOp$gOvJiUYqP%k)+@iu3l%h)5n zB1+y0xuboMyEsw=f+BmF7*5_gIeIUOhj!!Guh2_?w1NcKZb}hA*@bJ zcj$2{u^LfP`mVQ3v=SzILx@&6OO{lloq=$HiEGmKQtFpIEF?(TP@`p^-TVRTA{;8pgibxl>&O<1#eX%`Kb zIcuUYs8}M9>Okc-;k%I)oB%M{$GoUm8H zjNI%S`ZSE&EiIdZrwkimGw4)QgjR-3Cg(2Min2)mNa+ao?P*|13bt*nG|eN*_6zjO_L!`**|b2VNv z!@1codW~KZVXdrdST9M}0&~NKg!?nT4vJ$3$S8X35ZL3ndXSxm+ZstHiQWW9jHg>c zWHQzuWt=25qQ68!BNRHX(ZHUK!daI+JIj=dH*Gk{6b-=KfzA=J6KFOeC0frw0@3(rU@#|+ z{k@=FA~y_mSS(8G)44&CS)+OnH)2r98pg@+>G{g1zlKWzpN=9# zOZXxi>Sh)`w$kNbmV|4lB|>iWH&+j3U1Dpwxb!uw?HUl)VED?bUsLW}IybKXg4H6? z__QwlIY^358!nxiJXF#~T_k9`f$gT?>E0<14w0lsm4Qpd)_^Jkmr(77e8EQvJscPC z(P(?)BxwsWp&ek!@G8t(YmA+ZBV%h3Qc=1>Wm;<;SvgwBCC#~oQDoqH9YQ0J$y#Eb zjQlVWz_%9W7@u{b>45A)xUB4?O{+NPyrgA!|KyNbJmQU;|9|1mEx$pk|C~e2Dmh<1@J%Md}MV{{xBi)7z^Aa}; zlFmPQqreQ)6?}@2!G?Jv>>$(^FV*7*?tos{Ik>6DBM-$=5*~G|K3LA3gpu!g(jLN3 z6*5?&0%VglRxsZ|qL=nnaI7!q*4$a^J zdr&B@){v}bFD^Xk7LF77B+oF=A*LnyK9E1jtBg?KNHETo0A}m>xTdWv4OSisW55fe z($9#ltG?lI&f<_5nqa|79^1NSyL zkTGNh8TXYH1$2); zlT}r`9^6&Hv$F2rB-HhgQ&;vl)fL@j?x=O50K7N~*ep^dX0tN!noqOV~fSok)4kjCqFDGF<54cuaUiVB{p5jAz7 z7Wne!9F3>OKyD6X?p5{)#OM;LB>e4ji80zv@UzBWjdayk6V&Yt#AtYxc^*PjPVaP3 zM))njyOHx5o*-gQ7odraLeM23sSyXjxNN4xWt)(axp-=X22mwu-RQi;tQ+nE{vZ&c zB`s@cB0@W40tA^2!m@@M%X-_OW=3Tc0&dF9sMw(ieNZ!O=~hm!*sWBC+JtF+&YIRl z+_Q-#=hgq_Bq?EEPsjs35&xqU%aUo6v8*C%Sv#Tma;MzPew1ZdO@enUbe1)f&I*<4@>(jYCX`&<~>fQ2D=TxT2ZW=Rb^Fe)ljomSI=YLFr~wQ{@EXBbki zppGxd*=U@->=pF@*o^{kTb*kDB2WyTxIJ2g3#$oj#i<#MIkcM*sm4tkAuT8`)ERhk z$%qx~Gb|*h7k9W}0izL=H{YxlHM(IT*#iLyLU~~<@KPTyM>j6~AvrGWP1W7hae)*3 z=T znlwC%WmDO41H$cRwKQQ7YQ#a2(5a6bcbs)>ch-?Q?$92lgNsbnKb1Yi%%g6>ab|#9 z4}kRhvyF*>%{T*II~mQQ3Y*cgmbHmGkt9X>SsnSX8hP^LEQ5n0ozDC3nIZw zwalTRD|Vp@>WzM>fs=C!Tabsl2aIGsE=a7$H!41oH!2(B8w5I1>|+GS zTFozJ>NE??2kpX;QBf?Kno%L_hF_Q!jF1BtN&`IxRzR>sfsB*E(1jte3hN2zII&6c z;n&XoX_L&zQJEWc%wrYsbPGIpl@T_ZYC2ukvJ+3MF!;NbZpu6@D&3JUuQW53uwQz_O+J@T>aJ<##FL^Mf!#QR`)!gz7eOiqT zQRZ#Ok#Q}eYcgygIDIE9Ys(zK1w=nfIXP2xECQdb2hUSYR^bI^$Cx%1_sO^zUA;cSw*W!JR#m-*E2t?= zqxub^yI7yKoXvKyQZl=w?O^8}-4i>pe)>s0vBsNX9Sm=G(ug*J5x(XDFv!P1ZnP#` zy-C6X_vm~zhF9*_fuXhPi=2*{2gvNQZrThirX16LLru15Le0xj|A77LFWe2Q#vfBW zC8y|6IuQ2Jb5Z}SSya~(&wW-)(T{SgvNw+ zCK|!u9Yt4dm4D$d2FL35pi0zI7}z{SJ#s&q)g)^=Sg=K8&v{lF;|o53j#=O)THrJM z!Tn`dUyRbZ>}epj*D#>CXHhxK;DS80_Z~`q&%Bi3x)=So2bX2Bw)y}ZqRjfMyJZlq zX47EA9K0|j$=Cu@wSzR80zbl$22?M(C%npYqFqij3u<+b5ZNjz0;_ zKb%-i1Da49*h3Ag0rA)DGj9#QV#|g$)pX(#w5SFT{lJp=>|*r`v^N+9o|u4JAp-e| zEMR_9ANNK`r!G1di3^C|z zlm^=RZHEN+ME%~DD?W<0#GcI&s-CmK>j}BH#v2c`o*JnARCt><)MBl_Extd4n^TS7 z7LB*!@60;ti&2>(d?!Lz!cnMEczUik;^{ieTB;(9aLyRxu}Ag^jO_ccQgJEN{z^RYdQAlz)3 z278DhE<#_TpAaJDqI8j?lm%VJ$S6Ch!EzYzaT+9RgRnJ>0rq(a>}qHpFU5c#78}Kl za)qW-1vcwLJ;>tzkYNW(g7&_>K`aq8W}`*v8veXQzZ&%!Ldvj9O!N({h1m?- zg1ng4o`El)M(*?`iz+x7i4s=5EDFwz-{u$c5C>{tmP=uSXs&c_a>LhP#DS<`KDMMY;l|&w zS3wRD+4T%N13;4V>7?*9nF~C&;5lG+3zwU5_lOO|3{6Gtd5d-{k+k<1rtQKF3I=748Qb51H5({t>JqK*7MXfj=+k zSvr@~p(ThsaHUKBrp?@RlDl%RU>HTE*02Jw7A$6C)fqX!dMb=NFSjtYDvK_LAAlMT zL#7Q(A~a`yQ4HIGcxHL|O0%c{Lea9KlCycWACnIbPgu@CLog8$`T{f((#N$NiAFGtzzN{l1{PU}i?k??mTy7= zFd__NL#(>m?IjkS$0w*#n@pnRKY-#18!)70C2Njz%u2iw+ZW#~m+}J*zCf~}n#g9} zM6sd--^JtlzX)_DdG1_%dbH{J`Y+&|_0K!aTtKQeTWq0cfG~sAa&KD$?WJvVdM^vE zDj2bUH3Nk<`y5-3LI<$dnyaixfxRr0Koua@ns=c0sJ^{_4ax5ICZ9zY4mvz-h`Tf1 zT` zA2^3r_!!t!wHYNjx{g9NmNNp6o!3qBMo6H!NVdiZRe+$5LdU(Dh&N&n`~m*PD83W# zUaTqMOH&A5hS-k4Q?zxS@WMX!A0{Y!5W|8Bn~O+m7kyqxa&0Eu5RgoGL<8H{Co}yd zKs8LL`1I6>w-Z#|i{vei;0T`>dt{Xyddi_3b0~5A_}>kTeA9LU!Vu0NZ(cW!P~)$0 zSntBM9&u+FEI3rjX1=(<5FB%euVJ*_y2$fJtX)(F!J=(7YkNLJxzcAB!FhmlBc@z0 z!>KePsD+&*-kQZ8ml6Y+H)b)}Q@MIN*!RKDk_$tjB^T0N>#zBTW700U@QF>EpfwMS z!O2(gz3_Q&LmAG;e)0X4=i&MV*wQcp99S!kWjx|r){1L5{d2cHcT6zX&r>$H+}YRMimxadyS>GmTcgGa{)mJeQ%ku@c2 z(BRR)P+!m_DjDJbwX^M2mfz_}v+Xr#0PzJDhjIws06dE13XA*fm`^HyLDru$(-co$ zTP?3&^Y}@;(3U$g`fExkGz{4bpfLP=$RF_1GAtilmbrUy0XhKP4ym(!6D@tPeb-w2 zl222o1zBgOsglU*0n4lG)A2ej9WVB~GlY#aiccY{B_Gr8Hf1j82QLT73X88K{U`Oq#LOG}(^%?$r{#0Y zr_qgxS>=#nzh=z794b+6DD;ioPps4U!Fw{YBI%40*~xFN<@aR<1RvkV@q?FSWt9&~ zQ#oX(AAQvFyUn(>g+A*}`oi1kN8`y14#>ie`1Auv- zM!yzhU7F7Kkk_r2*V~`6UR%=Ci}urDdHvqjtN;Fz=CwfQIc{mI6?sxe!#ViD=K$^K zlXUd{?5r)>>2;KCoNoEu{b~69G<#7xZUx}=2g@s6UsIntEzK(WHq^f#efm~**7xCc z`|6XlA3N;vGu`I@m^fhkV6^|-kMZB+H{J4k^ppE|{NSHvXMOKue8@2HyWjG=f|W%3 zQpe+x%nCIgv;3X^58K1?OR%9JKU4YBPx%v6`HUf_Tl(urj}NhWi`_w8#fR7mi(RI$ zA6e{YLS=m3{T8dVdfumh>GMYQ^?58~x6Lc#pe;AVfDIqAVS?pFp z;2&{3&tl&o79CuWdBdQ=Ij|&&|LnETnQP(67+c9_fyLJo$EOJ2WftqDj--z9uR$Gb zP#rm{0GIE#v=ZA{e^-{350hr#ZQ_8fmSzL!Kj}j;W{2K6+#g+*%zXM@$qL!PA#f=R zocjA@$?T)=m8_6;%z;Z;A#22aaI4IHaNDs8HzKfuoWj`$oDBtQDl2}#a}_O<5*zhX z&y$62fb^-(QfTo44I*7^@nFk_Tbw$hKj+BF0MRpzb8Ke)hiVXMP9#I9r)i&@$j?~$ z9S}10O5&9kFG)g@y2RqtOZ~ZAP6o)FK;u_ge3S-}o?&rQ-{i$>EKXmoKR3w9fKZtR zkzQ!=@&JCb#iIe-Or8fwycM_vt+j)sy3mC5(Mr!Bve&+gV^Eg7^ap(Nz{y>6{kF>D zq~XV1Z%3N^9bcI@1A9`@Aes0)kCe-s0Fih#4gOXd{9qdV2pD{S{PWV_#{p;kC($?I zBXfBiPqFw)i_2Ud_!$--U|qx&+oF)8faSmWqGf;@`Bm%zHJ|2K*Nmzr%K*%)Nj=1iU|e*kI`g zo^8sNxfPPHTKs|w4K8yeB==bSu`+|ZaX%CK$NJn8F}TcokUZMrr;IgthdG1_E#7T$ znZMxLIl%j?XQ`!sY@A^rF)Whh7B97qOy(%SCs_QoiwwQYH;}x_;+HYF!$;;0IMzTP z`YZQ(OCK?gJtXr3(BEqD-4n^h#``$lY4KN$!w*T^4*X{pUvwp@kssyp^RUJDnt>oB zaX0Wzi~nYtkePTI$=w#usWrI7#Ylc8+sJ>-EQ3pYi{uw9e!^^nPe*=!%7ORS-bzb< zi*-B_r-FW(#kX7hI^lv?)Z$|-;9^p)M^GO&Sp|1->CY^Fk{PfDJXmN={ zfnRO$H!SYr&|572N9&j+76tuE;Qh(@o;3ImET3OBnEE*X`QH|wU%{%oN?TNs{wPH57s`bkoY$+K>%Z>XCUnl?Um$(TrN+9l)0O{$nYZE|ExtYTWI ze%4KfESb7&R&A)fZpPw?b8eb7_li*6T(ELX>gJA_bqa$PjU?#C&Yxd5^K9Z*%&G%>Nmk68ndB*{*qnK@5{WAksY&&9a~8W{ zQ%9RlUc7A1ylaFF6ADIcXUw~1?yQM*^UY-km@*(*b3OHaC2}p zmAapL2^8dd+5CoiGiS{VO`Eo`en#!}(`v81e%kCAbLOUUvs6i@lk4V4TZPP>^u0W8 z#=I1YWDk>e%&c4H%tHU(SXVz=$OzgBPMkmYX2F<9GESUXvPlc(A`h?6s1tGnjG3`; zj_G}KK6Xa^4GnYWUN-**MKo#FH8(&b`ee3vkcWjoj+JT9r42J?*3GD&V=T#5NSfN; z6<3-NjBU6Y*%r)SY~-QynoHwh+0x{R^XDY0o(h_Jr(&wosTYzp4)u4z6gu|WS+&>0 z(C5xsIA{JmDVbW^59~CdziZN?sd>Ot)-{3Fks*67?qiQ!<>1uL$hy~ zantNTISKi(-HEo5kNFhZBf_f?Lu$O+FP{+>KLf|p6kerp=5_RT_~d;`S(pKMkk4~z_`GcKARoT!#!rw>5eY4>>tCvH zUH=OdJ`DL>d!q{1{nDiH(-r+66|Vbhox-*JUsSlR&%QLci;LJ^UC)!V0N_Jhm-}Uf z>vCfX*X6qSHYm?oie8uN=B>eU8L#t0T$lTZ!gaYD(%{c3T$fu%#`sW7x%j&N`i8;kztO-8oI+?^v7%tq+G3uH|nYQR^#*FCiY~Cun!)D_oa5%i=6X z>+>RoYkB@c;hO$=i&JhMzD_=GDtb<39X|93oZ!Q9HUEnhuK8bW@gV;j6usvEU4?7@ z?F!fYA5X*oB}K3K=M0qU_o@Gv6|VIvqVUfntCK^O#n~>-M;v~=!nvg4@S7E`_39qQ zpKGj+{zr=bXode?;aZ;`R=C#ZXBDo?eNW+B;&J7koP!g5*uUCNKW}l$z7StWf0n|v zeqOHl=>D3maNWQ6DqPb)Z1JG}tWos3fA=X|^Dj6OmBuG%FGUs)@-J2Nn*Y@b*Zl8N zxUTp&=D$zj zXR3OBhC;+A$me8>Qx2L>RN

H44}Dyh-7j{#zCgmV2+F*X6EJxaPA#;lof@*Izp= zPX5|o?Nhk+R~b|qd`N#3zK+jOi&GBTUll6)qZR!*3TM*si6~s_;WUNoa=)Q)Z7(la zJgA??lPNyLwfrwoxR%>2g=>1>;=z8oN73tkS*>u*e~ZF3|JTy+e_PRO{>O2U#)s|F z{EHQ?`+bhWwf!ztxUSDnEgo#|?-jkS&sK%&`n-{b&t65Z`J8AM^@8mhrf}V^c?#z} zJ*QW{Qn+sK3kuim&7jib6D;>siwEU!mZI17uTi*`!@M+nZdUY~&(9UE`TSYoS`P0i zT(|ekqm%8@?TuMH*sdvxUf1VG3fJ}dV;VjWD|*f66@_a)`xLI*)k-7BhxN?G*Y)q? z3a9Bi{5gfwbR2#_;YTTati4fs1~47BTx4a)mq*mh@?5WQnvTPtQMlHVJ&ON1ioRFTQ-vL$f%d*A z%hme%S%qu;JV)WW+)EWs6?Xh@w>V{{^{2(+LB0K+!nNM6SNKT9|Ht__!H4zNcJ~{F z>vpYDxNg^0h3j?|9xv=gKXrX76|U`QhQ)*WHe1naefx#Nwf;Pr27g=Oy4(zV<2hLF z(H5tib-9-)T$g)Y8a|DRUh`S2aLs2=8vMi)lk(K`Us1Sj*JTzDwrh%_*Y)|f!ZrU# z)8K6i*LM24#aXVl$6keNdpyEEM?m_c@OAosip42^ZI8u@{%A!%TH#u6$0=Ov?M#L1 za=)o?ZI2IFob~yVDtCar!O8j$Quthp2kp1s;z9duRJgX6+ZBIZ&+jPuB31716t4B* zPZno=3Kjixik{b;{C6o_>%(y;fe0VgU(**UT+?5va7}-`!ZrQ93fJ_%Rk)`Aqr$Zw zKBRCxUTn5_&@P@+^x7`oRP-E*oqUcizzIH-!v**{yrBRm_z>qKAP&E)04Mka>0c-i zSY)aF{A(5`y{`XT3fFqF-{L_#$~*-O@F5?qCnqRe>&Yn=r|b*yb@i`Q^txZF6|Vbb zvBEX~Un*SlX;--B^RmJmG&cIA

2Osu1MdjMtU~%>rvpW1X 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

9Lk{DGjmcyBbL%UK>H6hT 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 z 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∈;=8o?d@VjDu8#XA&36xxPUZ~*_3(Tx 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

wR{sFlq>37NZL=0z6a-fFL+dXc^`p6l&|%!_2B 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 @_rg>l&5pftLG1;o9CxUEp^)jWT605Gj& zgcll&^r8KTUxoNhYyfgtEgs2OBBS;?w7%{=iT$f;`Ws9qttJw{2-mFBCIeQazE(bH zHy%pAZEJ&e^Ogo}^(tq>Si_Z1*C4uv(dB5UFam?HMP9wiMdzX7%xC-&3>-q&adhP| z`bdc$Oy}`nrKmRBC9FY}v!}|rx5~Mz3NxH_$(ka=o4K$21m|T@HIF+Z7h^O(1|Vg^ z?$9yD7sH3mi4h$6xZ(cO`RqNs-!Xp`7chIL4&zw|DQy%K-LdjK zVy$!e)*?hBUFc;RH;c`dbx18jc*2ijceMhgev`I&Fg1(K4R~w7vk^>CpnxTk8JBce(0NKkop5T+NT3S}6w*ACF={*oUi{qR^=c)!t8OzXmQq{oa111{8~D@;zimnNNJAsBsnQCs0PStW zB@?aWW36_J1RcSVSo^*;z`ELwgX+X+ROUfFxce%#L3W9SZD4J9VN0sx_kj9*sy+kf{a&tgJth)O)a1>RGgndyo>W}1xi8R z;cdqXZo}xnO=-E2iCE^)U82YBuP6+41eXDaY>V~D}@8ECQ{*UEQA z{+4`NSUXT%hOeW^kEx3I4`A)0+p(U0%PW}1>qa-OWCpya8ynld&I`oKo6#biMBM2u z2^jkmOaF??s8e=a9J^%)xUyzmutYE!xBDMmH905 zRPie9e_$+BnJ+Mhn9%z*{k(r0gM)ShcA$`01+6SN#3)6v>o-i7V97sk@?N)4zB_9w{NfpdE;LC_$G$DLm(NxO;{)WM|`{GL*G8?Oim z{N5F-a2{CjH7*paY9V(8Rts0Ea~Est%(3`CC`%-kK#S%70X^55r;p(r+< zxGtCvs{`7-1~CXGuV`${^#Ty$FkD{07}emlI&~eJE^yl5i3Ca@rOSp)+D0r14*nIG zg~PJj4ytxRA&=0x17k*cBma*4CG5^+i`mIt=*(qyui>h;1GmmkkLl>>0l z06s#8Y(Ym{=XG0H?8M;)GO`1%33%N$u=dwNA`Q0ig2PqlQH8Ed1n}niy%?D6#9L@C zZ{*Jvu~8Qiwh@30w~zoEd4FC*oEgA;S_%Dbh?Z%|VOAyV8oa>j{m-Am-_ljc_wvmY zTW{T%z>O)~(!W`ZEUw0l_SKQCqClO};>|og!FruGwy9?=BLiYnTLuQarixjUwV8r) zF&>~bpGaVV*3D~u(Qjc@-CVi_ke7Wm$E#0Sji(m1B@Ybx2q8FL(VZ_f?(2&T!{HQ0 zyR)oo-sZB;mw{yZv_Qfy%I?9k$x*?EzRBpKuv^L451egzN~7>8dJ9+MZ4TRR}M zBooTX-%5LU|IlO}{JSd#!D_%7B*Gy!SfVBCM1w4R#Bss0e`*U@xm0BAt8s5%q#$+&8q(qPm#v?-)nB$(3w$d%{|z~@we%Zt<6GcFYrYo&Rp#~8 zm^qJyRWI$XO0-#2X>og&ryhvMwi55JYjTOXaW>C&LL5w-N+!bLkG{|gE(((BOW;$W zvlI&fY-(y`mZ#F#mnzP}PU?tk&tSi3RRxT0OsLTBw=Y0+rWbz9GI&e2FMK)ljA@ki zDw-0zLI#GIqb)x{tkJ$d6E+HQ$@kO5DGz~i%if;>%Og92rSFH2le8<@GDe^LYeeG$ zYp5*6SI82XdOIayYFQRx&EMXOY_zXY%!v;?NP%4A*ReMzuFhTyvsqfxkHK;VVd2Q2 zk%*>K;S*K~Qwhd7MrIraDDelA1;efH2!545QSvaL6IQO25nZhkB2&~g93lDP$@s-x zjyEt^0_JpgfW~t&n$LZSpRzH=YDfWKKs0gu!|*v*2c0|2iP-8+hkb&+#Bd}DI#(y} zKp6x8^yc_W8-Bxlk#q#T(cWUM<(G)Z1@(b?BD_n|G!6Z0=S{6QD@MQok6BS1h=seo zSum-=!b<<}U^ZOM>=6YQ3@!I1BJcwwbGnPZ8*CqpyYwY$>5JVm$YD+|pg*YcT8$ZF z`-U^_4BJ;k--)(w1bv0@!JG}tDW=~EKkAIm9s$bb{A24)_du%RgBhXK2*cztvBVtJ z!3^CBwK$V38Eb}%1=Qym=3H%u3BZf{hY8RR^beDMXzU**4Y);xp~I-L9VnYVLTjN! z54feKKpdR|&3JSANCGqg>Jse8rx2=WAcOC-5C=L~iJcgTyf1M?y5Nk`VqfAARRY&R zw;r4BlsG2u!QnKDMwlW(hP{^#Q;LraTaylRrSm?M4jYsXTa*qPoDRE3g(dd_L^B^a z55z{T=0uW{fUZI63}FXIPFVyr3VwFx81&^IQN+Re(rxvnOOYe`&7JPc9-_<%DcdJ{ z{&X;VU2bb0>`QF@H;J;7OP98*EHW@Ntgacg{8an$65=I@OFb~bA~)VDkTx zHdr%T1<64OK&(sasvVnf>`$`A%(%SRYU`?Wm?s_fB*WOi5I8S)FgBxTIrjN7P}@J6WKJ0w5WCcgRjMJRmG;kNI{B}3OGh)y8H83Ksb220ivFD{2FR#k zlA$UIyjRitbvm|=-tB4cHT1rp_SVz;D!ek8agQ_dxuZ}6H{V#8_P|P*dL3x_GgiH) zATh84{BjP#vJcaoK#`9H4N-B)TM>%;Bf~L%rdae=yn=&K_zVgNQ^!T2^HyrS9o_1L zEBbC9_zOMSHm&Tf87G_WJ?*5+@Vj{VC{{P@kknhzSp|8K^``ED*PU83kRl z-_dh6EC2--5M)O9wJJZ=1Zv~TyG*DJ5&@w$Imi@hJNc0_FYh*(|G@u)QL zfw2kJw*eQ)56|gEJEoPrHUqo0H_g2B(F=}n!MrX+hmVT(`XU?5aRssI1;~7;WKOk5 z?oP`xZ)XS9>gF@}WXa_|clT1C)V< zKcaG(l?AY2c4TwgGO~UFEzo04Y1336nGqbo^d)|7`@W&?a^=g$ca5Si}y+c{teadTIQ2^E%k08ROFk#3wItQ2kF3@9J+!5hL(V*V=b7P2-mb`xGd zNP)6@#=8;G)h?{5vhPgP5KQN4E~zSDJs?y8hpT`#6|ju+b@Fe$h*d}>hP9@8U|ko^ z=n;F!vYm%A6UMSR;hRA0m$0EEI7tyj3Mb}tA;h;;51SLeu@>3a4M9+vHc%KzAh``o zh}te@za0Utg|GewjW?q&E(Uy#@EN#yaG8$F0I#jub+cRWDmJ zV_1?lThx{)WIVnI!D?a;PlByMC}|;9vPFB*?=kv_0DIQN-u1OsHgWYz^d!EU6N?p| z1}0m~WX{#8^9M%Ur}Fz_krB*(WA5xXs_gz~xi=ps)CjX$f0~xSP2igN7^uL!5e{@@ zfW`eu<%4$|y$>j_IbEmkTObuMnbSk`?NmM_#aSZ&N$0$b-m8>1x78IKGL@}(OtoTQs$on8>Uz|s-K_rIc^4?p zh_B?{nMJHY5kY4>^*`av*!Dpne)rH*UMTGJVD;KuVX zVK8B9KjQ2(FLsG<{@(q47|}cVKtj_n(#+mMt%(w>U>xf@KMUl34xO<(u&JVU!TQ|q zXjU0lxvPw^cu4c2A|2d;8*^8b2qfKwOnhfShM_|q>?=aL;-GN{9@V@Ek7|zPqncXN zLMDb_Xqq|Bg{yO81Lin4zvI9L;Dae=oCp7I945gVLM%hzW1?zvoQL1b8vOCGmxJhy zf8%fx(PC$aAmHpwBalgFNzP}AMp+O41uYp-9~gYRSQ?5A+6S^g?UNzY;p67jsEV>G^vEIh5`)JB z9^Zs|@IcNMd~n%2fe-)S>`^W{do8D!w-hQHkAuL}G6l2^r816y7q)`Ns{vTlx-^If z6=H*qcvRq+^m_%z8d5aiAlr2$%v3?<%hHWaX`oasl(lWe#>?nr$}M)f6m$>OThoJ8 z?X(PGuam7Xd5cw9Cwb66$Dbi=-eVu%##d_&L#20;8ZW3LPhkpi#=N5 zCH74Eb|>v2SSZPTT(LI0L1 z=+aCC$tveZI?C(^SdJ3yM{OGYl61KznFR}A%;1McL5p4N4h66zHr8}nK9-c~VfkC)E}q*tQrl#snu1Xe z)#0<#aL*vf7wgfzxax~Xd0|fTB4~qFHm!|}m74j)#|7GwQF*wS6+X|`I!f9EV>*$~ z8q4!|^PsFfd@|D?e_$I!v2h@67~4#3%+=C~oHOpkQ*MOekmz~np??6{=zeUC=EI@K zR&Xn#$J>REh_M^+h8u!}&hf+~raJgwj)SUR{EJ5m(k{NMrox7&T`stoL)wOCg_MkS zc_75vgdgrl?cWVR@(#eYY!rS{&k(bgpd7lOIQ+;uByaM%5x`e@Ah@U8KYdW1X8wc5 z$IrFfaKU&jWC?ogdGB{Nze)5A*_sf|bAGmxPOL)2C}f^u&M8V<5x}VlwAn~TNDZ?N#l}KX z5&IcC7v%cQ_@Kv|_5Pw>#R3@qOZ;hJOmCW0AIW~PmbA|c{g8`e8tg!taj(&iU7+mmfS0*~>9{WaDT@_!wE&po|~+LM?}x#S%;Mx!RJU zSXPha=_(Vp;#{6-6X|t_Jjt#uYjU?%)c))0JiB6>XWbCK9T2c`D4Jlc&Z?ZHUCkAY zi(^m=Ks9^GP?{48VYR~(O-^VFv=NvfGFAebU|CQ2TqX({9aW_rLFc;gATEsW`g6jh zAVV3c&FL0!(hGu3r%dQA5;_ktDNOYnYhwQW(cY719?{(Qt0Mmju87gSLnDXo*_=9} zYp}&sH22LKri`%$ja?~^a;Dx38taTW$~Agr+wR}f6T4_qZ0yMBzM)!GyT3Irh0`AeM`=skt%tQz-3^FKkkPq4 zskoUmKwZu=P<9?l%Zs$9LsipNQkmQ5Z|AK9Sr)Fr7`rlq zG741!EbDk_P&Zdh#cGAg8A~GGr0iSRCX@IhUY3HTaD<#0N6ImSutu(c;F~|St`=m9 zq;%i?9FHcJ_u|Kd0NUa@QvWMGnDOK+WO$(GGYQ>U+L9qnZQ&zE501b#G>y=8IVC8v z12=hruF`IMYr@X!R2v-O8(nG)Q4W1>yw~>+M%|QtBgSo+z}0 zX9(YvSI_u5?kRd4=jt3&ec^N2Vb;Tb*3)#@$c9~bH?33ZFh?hv&gF3pq{ZwlEzq6X zrXEleCYrBZQU}2$^d!=E(&*Z7J$sL*#jI#|xCUeAa!dCUrs%>)!VH|{wM}ekfeuoj z(P8(>5S>zczQ%~HIB2$9(JZb?;X0=EYT}1#8}pvzVS}wgqkZ||b7mfw_Bq2|Jav*) zRVSW-IuHQ0p}|ya?6REe!K*%ip}!Vg=I)4GjJDuW$uzS|!+0%7e4QLnrZUZ50HaloFsp=h<8E_;@#=(c|Mi*0;#|7V|4&KAX02zRt04 zb=vd3oKqOCI}AAon<}WTa=VI$OEH}BM(CH8fJTqs)yk6br&~8?@L-~nZ6T~ZnQyEW zoXIX~F2uTTCgh2|*zBnSi2VYoO&y@A?Ml&6z)KV6;X-uLxXP6kXQ5!Il-93FZ~1aI zNw&I&VNyzbd~IJJuzFHv^Vv5f=exUlZ1yxMKLvGO;NjqPew@2b=CTD!>@ZNE($9tx z*Y5CTq1X*mDH#IB943U!E1|xCgGX0*1P-ZrtI~-l)K3c;H@U&zPzr6GJE$B1qesz% z|C&z!N(jXIppK`$A7vWbd(FVc9*%`L=c?7eu>d!mhTZrY8oW>|CnGW`6q^aK_Xyb0 z**-k5s*Y|B!O;y~ne@##k#A8Ge$#aXCw06!dFK&0VA=+$ZeMq5lbu;8B;5uzpZ2H; z!J-RXBnNKP=98G~hp~x1Kr>AZ&Dd;D>hb_y0`r%(&G7Mo-7oa^t-#>h(a-WqJ9x8H z5V}v_^MQ_w$pM&!fH`|tC{}P7%x~Z3D%1+WFSNsK^!mtW0U+C)=z|%jLZe;EDLZ{w zcoBLbm9RT34SbdeO8^DpO3=>$)!nbZfQYj&uAVp(i`r@RW(KdZ z8dU36OK57P4F_hZIw>;sxILJPWbKXF@8;r4f%MhY>b*W2NFRwYcAMK4M&g((0v*pO z(E1hQuB1wYg?p?;+mdZ&+HKDvKlSGvaD)b2l{IM28BklCj~syxtp_4)AXIP4beEo^ zD*tu)yThkrax!q_`3r?~yF4KMY#{x-GbnpK;O+R!bC)~-?VTuOm0ci?8Frk`!ctGM zfilpJmbM*;ZW}>A&s`1k+nwPbfF3g+eSPGB-e4dO9AK7OEYY%q4(yF-xhu1J!uT5d z``C*mhgrNd3WPXOj7j4-455(tk$)G00SI79SFFkMYi9Hwq)NRcJXva$`n-@v#Yt#~ zY{?TiI_--`mmx9#w14y{P}9BoLT+JJ|B{@@n((JfqW8d(o<4XlHMHd0;E zAE`mshy$bR2;+gZmKlCQn_DCtoc_K5mMnV z3jL(}5@)_&uO#cAi15H9wxXUSH4>Z^+-X|OCN;RzWGF>u7VDqoMk*`IOgCo@7*ElB zr~ZBBnz^}04-2=4YJn8}1i?#H*+cxf2|4FLG((=fpM<8yW#o{w1~fE-0Bedhqpj#! z^5HM?Wx*1hqlbTq!MNG3?bF<~;Voa*#xCxe*Vl&&5z&X?$2AH0GW=Co)%e$d$jRQn zPNq7B8+hV}42~|-Jvc?{949`$UNv~0oPX+a{uynb+K)kuk5!4R{jxA~{kVYexm?hM zr0gAJyuvEjzApE5Y(oE1t<{cDHCRk!y*b3_fVgOur$>A0=t!x+-;Z}(oxA(b$Kak9 z!BeZ~bI2oJ$(>5U%nDDI1=vKR;Tfa=H)j`Rd|ALv7vN%(>diddbHOkk4&a7H$^y|`Wox2P#?DcgLCnqU%U6{d-ZqCNRfsMN?Y#oiA^Mj{h-Y|w(n;vO( z77xa3E_1wlzz%nWLh~S==p!?>uvyy;g%4TF!MlD*=KLqRF?VWW`9zsnb-THlS?INc zZ5b4abRQ(zLYwtWJwQF$qD=)&h9a{-f&~CP@;+~B;&g!~d*kx{zo-T;%og=FL^A#YJ;c{vnRQJj{m2wllc zjuj|NyrW9in$$fW*~!PTjG{Z^gEwJ#tOTva;=YUk68s-&8Q#@J3NKE!0SXN)DQMifV~7yao8iSGWV&y z8X=bG=y|D;XiN(zax@ikXCAZRE*EsjbYr8g)JpXDShs5JSZlLCw#f1q%a`H}2x1er z+{}#z+V!K5F$HoBNVFi*7!!hl6spPU1|+ml_vbA`W4haKRyvG|;Z!(b&$yJt>omC% zg!ajE?)|nisU{iBF8B=JrI#dz}9E4+jODZ$lqx!roYPTU%!;=kGToYrIrCJPciX3w4&quXaeh~qcD zSXqLez}SLGsDO9s*=<2%%X6HzLPi|&nudT;;BCMSr#wuv__$FFZ0_CW^5RV@d~xp@ zW?^tG^fumQF1)N5F4{yWyb7-)+;$zVVi*402iGm$YOV05YEl$LvSaJ%mJQI?XzU2eZ%ouBt%wLd!%iG&h}4=Aum0o=f5=*{Rvk_ zFebkLOw@0f;_ce38L5PG9fs+(SW}d~Q1&ogAe{lU>X!DG;(q40w;@azAQ6sX{E;ym z2Dtnjt}w~SJjUZs@`E>%u@J&a=0E5|WzDa^AzF#~qIzglxOi_5Bf1z?1Qto;o!-ne zhb<&}{d10U?By`qK@1~km&zjLyYr#y!O2pOO^1j^iI%jbcos$8m3J+~5X;x|rDQ$s z6Jp@KAKkzM4Cqnr60FH$N%;VuTydc>;jh=W|))se6m1Tx;4a-cR({yjhZ8q4`e?g?gv9w0q1% zmlk~qbqUoC_u&>?cDr$fTd1GrSQPo|9y*2ot9f}}4S*V6_EsaH-bbelfvMF&^dg2p zHHHAJA1v*_YQicwd%*&Pxd;{O#&DQTU0UGP&HL$ZFbeXtr4Te9ycfXjFGfnc&-54h z`ZZ7md{6hJ@UphzMBJ4*vCds^d!jhzb8-%?M8kuJv>~u3q&)=-6^Cg{X_xIX)V~0d zvwR+jVspy+%zy{`#G_ciNxk|>`)G#kRlLB`+ZXvO&>2z(E|LySy`#uu zW12i<5i-%k=@k|fD+?(JVk#nb4{?Tn5Q_a>;ZW)A=_@lhtb%2!N>B3N(PR*gRnKeo zBiGBe5Yd>HtfdhMTstA=3I=1Y`D(;86Isx`gI$b58fv&rhq;PEOrCI77sCnafwN{L zoR~i0toOl*`4i5m)o_A(pzm29#3T*s*_72?K`wcl*j0z%^}q1Xbn}>?3F6(T$I97d z%h_dm{(}S|WL|{sDg+0spR`9mX_sF1R^+t?SORO-(FF9{UJRI1*_wVm#s&osS>IEo zJ>^dQ!EUx5n}gZp13@#gmU|uHp)$=S`8E;x30q3|3QA1Ai$IySlk07l+8t0RXi1P| zZkPESYvY)Jc^_4J0M&&v&kT@8w?K&7YdlH4Af*swv{Dr)V2C1+AM0?Q?3s#yNBwjsOR14~a{) zd_(y9exfSe;D_ZdNZj8Nh?IPNr~>3`EqrWd_mv8k?FgUbH%9z}(s$HK7=p%G83_H? zKw`7(bM!~*(+o^JTucLi1IqC6(Y`_96L2;eK9NV5#ROJT!~%`>aiKae=d~qAr?mqB zgRq@d;@eY27lH`F;OHV`%)41GO{!njjL+0@a}K(PVVmoSv2 zsW5xT0o$5PLxuUA)ohzIMesj_L&L8eNz*R@PO6EboT4J7}_Hk+-n z7Qq7P0APO>7}3mhWZ#|Nm&JRjt22uIIv#~8_Uk!1ZAGc{?V7=nVPu-rrJ78+%X%SI zOCx#^xZ-J0rciq`#dWix6fQ^SO?5{m^*yu<87Ml$3}|m^X&BVfNPuLj4G9EpyCIn3 z(z}~K{~|YrECl{X?&y9jl*mNT*_NRq(ngsco#%0c%R;dye1OXydugqLzKI^A(+;(T z__8D61w9;ltsqmF`dI48zJODNYJxcZrbY*J&GCTvZiu@Tk@0;pw?B^6k@%)Zw>%ut zh;eyU%)9E%W$U>$ZWlta6$(zJCmD}E0I2yFk3MX_hKotZrQ4P%)T=JUF+%v5o4ad>9TX3FS~zD)bvzb`1p# zhF<}wugE@D!`R2rED$_>NSB}rwrR2X%%JMK6=r`Xz`%&lZt%BI4x&y%Q%C}pa-T)6 zFsvi0Qdq$9wNhF1CU|J)jceY-Vy#pyc~_4VBWehn;?qjif_HPZR*LlwVbkli(y+H4 zuG!OQF>V@M(MBLwD{b=f3%|Kg{P&1uLimMc(n=rjE>iKoBk!!0KH}vU@qcO)|6^W$ z;eWha{D1TE3;)ww#Q%(!U-(z_i2r%9u!`GsMUL~c?^qQ z-xWn9QPl^c@CYUbHx*zx@&FCW$jPALZ2e!Ep%p1_P^A1)dgf505QDgoQyry101aCH z*bt@1y$jpI^sr|#mBxr?(z3s?WsX(vmjdx3#|&quHA7Ik^diOCP}=HS=)m|lR!gep z9kcAiq3pTB(gFuE)I?$I+_O2csSqO&uWwS^1ipU(B7@kS*)j_;fh~{^*bI@P`$>bT z?q0=41kKTy&*~{b#Kp~cAGeI|PN=4bhX>8Z#1IaU^|sPZY8%3;u`p$ay{cA$%vvCu z257o*6!B)q%ORsPYh`G%w8RO*kf1sS;>>Ud$6BNdQw0=G1*g>@mY((OU036Gz#SI4ykrQ-NPG&#{(g0Cs?_1c7CN{VI>J2F+ zBLST>3oSozJ0~-XsMCS3+(cTnME5*idrkc58nvd?2*4I~w9WEoz;Q;-k5_m=j6Ctv z%^#7obc1C@-%P@5!6W6kE~d)s>*kg&{3B!_RU$(QY_Qt@O!#w7Fp-pO49f-vR{avx zd!injU9W}=mO(^{+kCv0?cWjkqYa~VcCWS^yIzn9HKkazkHnV@V>#-F2ZEK22Z(Lq zxAA}-xB~&X@sJm}0kFC(SQQ=|(CtHeZv`GkON|^PLr@?QkwHQ{x(cI&f4KIvDdXH? zIR`Yz##l>kjAh`>!=VHe`b}RA>m4NZf^#TF8w6zv7qA7Odf<`Vade$U~>!9R>4l^a8 zVO_UUoWTEP?``0ttggiW3>hG5^a&bmtW;wiYob)~ttFOPhRncBod{NxU@3KrYhkt3 z)fuqGmf$47({WmCwJ+N@yM6z)UG27ORaBDj5DU#js14pH?*at%K>-l}YE%BNIz z@8gV+OP}p!bSEvxFS5I8VQ`Q*+o8ARk%m2q zl?A>1N%8Kuz5Vy%$%-#dN2Aiw=?b{0SZd7WU!Trxi*&bdu8iR%lwgm>8rr`)CGv4r z3{xqt7UHt{iMl>aZ?*#JapA z`-F}*zpI>@?22EAPCmx9{p6m(v!`$hVOXHZbpO}P+q`Z+Ru=Dvo4l%cGP<(dT6KS9 zU-LpRk|sm;IWOc`X7+WBrbd(uz-x(ny;ep@E2l{-AJqOi6;*!S9aSEZ zZt+TSh`TF(vGeTumrqTcB3A@1lv>P*x=ubGQ$2i0ylhU2B@3^G2+S(ylfk{?*_qg$ zM<(TE>3zA$@(|^39^Z|!)Vj-T3WYdo|9z4K^<%Qr*sEe@QAVfx?U-*RPg95NjvP$f zAKBNu&`VzEIWM%{Oqo;&7hfE#f3FmFoc%NfQd}oe16K;{=OS-D7wLF$5dQIgC{%@e zIGB&N32SB!G|jG=JwtFzeA`d)L(GQhuIG<6tW3Pbvl_mrZ)4Qg+vM96YgiXQ>XT`| z*2OLQRoNb8`Ii>R<)h#w;2aC2lse*6g~bz3G>#@!ozSicals^%y2c-Fc-2b&h<=6a zJ)!zcq#+Zr#;;MSeIc>z^;YX)8i4ew7jV0m)n#6%3fa2}uakGMyLpz0f9~sR(|S_J zB=^=@^Y5fl9D>!vQlG9O`O}riEF9Q!LmrXOaX**-6rN8pD#J&Gauk50sxm2m{jKI9 zmnpp0iJxNu(>xa4QbNQ0EwVpiXA5u=kC6U&lsi1?!h3hL;nBn&LvkY{6N58zY3eA> zkBW#PGI8{eK3;127~&!5Tu*M%o+O=~@D2%%o2T?LTfc3U(eZ;f0 zRYa3p_C*^Wwvt=}=YHDSCi{^l>#i-rb-c-Ofy~GXZhkC{r9=MOSo(IqbSfs!ia|RO zoj@Jjm|!*Cl#cnahu$2fDVe7R&|mtZw<5t zeoJ*cwiL9g*;e1Ms^7HgUa^h?tN=sRFyy*5@JG$HmR$0#3U8?#_dGuB->{C`EVbMW zZ1}_h4j(+8$>*xT2%cVfB5YMZPF9{sseUpjpd?AoP54a0b2(n|UywihsFt|uH_3}f z{A!+YIqrE$SdMG`=4BFkSVF5wTgAV2>$r}ny(+pk6OZDu6a=1-u8aZ-f7JJyRaL`!T8=@RqH2HQki35DR-|qoWZWL;REQWBhF7c=AbF!9dLQL~;);tg4 zhV9;9y4nJ}Le^Mp;IFBO)UUz%eNe>rSj6{eD0KuJI?I1PHRzf2`wd=PR2jBcH=!AP zb7Qn)%OEc1)?Azp+#wAG)en8Op^>_a2Xzf*q#Gi03}(Ad{5(0Q0+RG6i9;bGF7Kf_WL;)uYj#rmab_B4! zbFHSOK`z8T;+XL{g2ZQ~$6xB-<9MUai_=??%kGy)?7}t|b?@@eXRGhnQxTlETcn?x zufSoB5ztn1xIG?3ML_FJtSb;N))gOsJHGYBlSB5?1p=DY+QR&b`cV#hzeU*Vxix~w zb#eSkV$JFQRMgiVv6e``Rd(x8*^P53>n_f>+0=IPWYJz`U~bf!(CLYB9S0EOVhtUM z2Mflusd%T|F>NlM>~WSXlFteBZ}!FjzO>6A#wo5eSxefZD$EJ0DAu&dc>3nbRX^t8 zQ5gngDNnxZ%wwIOF6itV#e3s+_RqzWL-vLP%XeZ0#tJ%>k9<|m_QA(2=Xkj>V0rAy0BH%y1NwXSi^(8ZK}y1K$f1VDi)P^6ZmF z6ZV*PBiAqUBBqggu2|{5@9XsS3b+x}Ns`-nGjjGZqSMu6S5sGT$qsaG+l7Z2c`M}h z&R|7%VvZ2tS&pbQr@;squH9KzSyoz50qnzaAD3KE8v>+!&o$Ss4 zMJg$mo1DapTHjJvLnruPF$IpU*gInzuu0Xn!J^?-K+JZnhB_>BE!W}M>20mGUuN#m-?PzPSx_f zR^UQGPp8+56Mz%ByB}xgSQifm?bXn=B?7k)+g;{s1Y#*}zpsneyU=>0$^LW98V4V^ zS)IQbl^>pon|v?E>bK-UONza&GlD^nbx-x6g_AgfOkG~#gk}6t>7|LDEEnRdk@2f9 z2rjI4x6>$h<$C3!eG^BL4R6JNsZ}A$tj}f?kEuR{=!7Q(^mf|iDSg>f!vF#<;k>SK z3;jn$xT{Aa(S|ofJnBF^dM4JeI&M6!QPsL^#xeh9uRl*Ze5SG82&HuQH2z0T^^4&S z${v(0$ZVb&F%>p;XrClWd&g7tv2nhulbIIJIh08F;hEjvc!1{srf+Vtdtkj!Z1VBh z{qeBK!uGOY$5uki!u6X`TLwF}*95^7HqoB2@A2Tgze>Z_*O${~(0&$) z3bK1OFYt|J_mz<`Ec3keSPZ)^mU;bJ*nUQ)7W>xjYvx202Jv{)%&j=) zg4y3uOO?U3+rz%iG8S!S$MNISlRnszkz3IWA~T(DxOHoMXvkJ*n|0=_GT(c=WKYkn zMHZsXCQFjXA zepJ*oYfu?EPu02ED-;ufA3+^)Rt<1M_~Xc8eLH#ulQ-JJS>EU|Vm6_eyEm~-xb3KK zL#*MMxP|<1g1ZpbWMA|yFRY7CWE-*9+iN1emywnAXd#qlMSKWjD}PW{#MR?$Kb(iR zB(|w{6CWb{`nVNKS09~U@n_6DnB~Cg_=v2I%R(s~Xq1NxjbhGdB_0GVTZ}gn;VI{8 z>zVHpE2U0S$chvI89Xt4X^Z+40p7CwyAoMv-orE3daGm;G7>1tXHRaGYzo_t7!-X( z@pY}D><*YfjD%XsV$-{urX!PVk2Y+#ZheHtSpoKjj@>n^lZ8X!z(o%TG2rFsdt@D1 z_mn}pAsAO;2fno`bXbps2NA9z%o@U$Pf_)8XC3uq|1&&umFeWB{_BXY4OmC?cy)N@ zCT|^O%&_>#u$*<23EOMTI$ERaXcG(OuwciI!^Wq7_CetpGarc^|q~TkbH+ z&ZWl*TOn(QHeppVVJ&Pe1rwH~56*<)`_!GTK{{RHE2os{`j>vw^~b-*bb*Bv(t)d* z>=&aQFItGj{i$D-;_Z%MI-dwKnQ~`7r^vT;oe)5stO5ck>kEEw0N=9Q-H8u@Z#ny& zHR^JENfqY2fc#qGX^&{(9mG|}=U9&7N_p9u%+u?_i3k-esB@)Tr*S0dawOPO+iUEV zvGjRkc)8$H>ETgB9UZ;r<B@yIwV#Ewgt6*S*bm$9kI+Fss?GEdn(MLs6hmT!2`uKDNhe7VI z!_tvKxnDjdPMsAYB>snk`1}s}UJm>ACYP3n;23cAI5bR8f0*6s_7ux2XVH(AMgI{O ziZ0`#6xc8>+P@ZueStU+U|-I2*%!E%`Q?So%Z?oLvb{ea@I(0-t2mhd+BYmw;S$-k8m$= zAi|5#ENu!e@`N%ba4)@v>i&htQw{gRN4S?)f*t$Fw=-<72zG2Ev?5&p7tu~B)qNSN z``go%>NYAd@u+S;HU+;J?{)^h&Ul@R4BiYZiOnCBufcfbkl_!Nec7Y39{lAVf&>35 zdFFD0$2uIU2c&hrvi2{5KeK)K;)-FW)V?Lj+c~KJO*Y_HL&@0 zI}9Ui$kn1Y*QsEqI3KhUF3@Uy1|%;+o&d$muTwy!S@i2`u0|m*@A{r9CB40-j^hgq zOHH;+h`Px4YCDSfo!L7b0V_Jalamx#?Wo>lwPPC4vHPT8eLH(aN6$&2`u1RbClpGG zZhbv$oxYhr)3)&EimkNTOUI|af&zcai-elDnfrv9H|U4A2D)RSy6ZVHhE%Hbq%+vD zmzukI%PrWknZ`Q9_1&}=p1HwLp!M>^y$XGNgaSPyCCC&uCBjl-y{JmHS0QVnFe_k{l&wd#~=E*5%8xzjk;RZ9-8t zf9J&XEgtBN*pmW1Vtjwt?q69}>)S&(A6OOt7ix2RR`p?-XL;uunK(n+0qS$`1!!YcZ>6uO#@y(Cqs%1;8ixX7}Hf9o@o{W&b@&HlifLwp3u2^Mq6 zM`mPcu;VS}a6?c+TbRS8;rb1_MtO;{oku&TEt5q``#tDYFa@8o4DHkMgRgL-JOH{u zDtwj-aWyyPSt@$&;44}u6?IERk5dsxfAT17^AkZM=EtUQXwrMG$WUB&-TiSL*jpgo z1|94cLQ8eL?Tm62lxU??#haT~VA?T7&PLZ5aV~QXr=d>wqSM=>yi?h+h2_QPEtXfi zF0ZAiXmxpM?e$B66EK?kVsPe0Spu=?7%#UQfb)^wYzR_NmZRMsq@=9S`lT+wd2Dl9 zm%!VFv(v|iiGNJH$ob1kK~EmTZSI)4)HG7^kj=u3P2X6E2JmkK&>&R5k;a`_v!=a3 z>)xatuvbt2?R({*fHmzYdgWoj0eiL9?Nxh|naCzHkva{#1t}myG9e&}&dyQ;tH^Yo zC(S3UB32jBRVEz*Cb$G%<|fL)B@(uRWLucPm+0(PIY8@?2?R}=A8{~kB`ew`SQ(K9 z`C%5evlm!rZJvFMb(U@vvyOK6f^3Bw;;VaxsOHJ1v_SJ|Nb_mP&1cYS1SWkvx-AQF z#L}znu@Yu2jp!uoC(L3P(Ls2K$Pfs>RZ&bUZd8)_o43SCDwcrF{T7;YmHHDZ4A*Rq$64zS`jv&!GOUG=@A0i~! zfk1}mAo|c93<|ey^!U&ij|=uRaY8@;^mth&8! zBQXS)-b_Gt>6x9fq*(82P`LTTh)?Vao%LSd$*$USl5BFF^_>pBtrq&hykD`3R(c@C zP)R1)P!fA*Mve|meR*h|@Pp&m+TWve~C(YLXGt!gpY=)hPbm`5NL8chZo z9)axO{Miu5l}aExLT1O+y|FZSD^@r4-xHPa_FDzAN#{c_YW8$=!G^gN2nM0l3PY9v zKn&SRK3q@?1e93;%K8F|mjo1B1r*BhZjscDzz80N)E6Xmqoh73fZ8ajs|1V>6RKOQ zuyo_DSS|V1NWO=$rg<8GK7w`3!`TYR9p)@`?GQmMPaut-UIlfurmP?Ya$nPNwe^x{ z6>A}|SRcJ^wMIZ=7Rm};U8ivcqCa9Ui*{@UQThDUL)2wxN)%Ch;3hb403%*j?8$L2 zJXwW_9T>>xZI_xYM;8G#>lGfvc3CxQxRvGmkwwkIQmI z;vXoOcWij5C}@rg-T6jpapoIDbTB9yfMrqsgC&jx|5Zs*3VCMum9+ z$2bb8DDwruf>jZr!v9%usQ|>|qZnG1|9iTfbt|*@m@tz6yuue)L7czCi$tSaz32yQW4}(Zy3N@XRVptm3`1O{GO|4r-~hZ zkn?37juE5MGyAd)7pI47r%*+GLq{1&4PT*ZvlE!rVg6fq&DES_KbP2QtUNKk@8o1@ zRbr_*S#m5I09GljeBHoOFa|GS!@Fo}nE!;5Td{ZBAGIg@amzWrfRTJv^MOG6zek76OsoUVGJ_b&ai)6^I+ak2H&!vgD{1wlCj?3Rh>sB9h4eh+a=K)zK*XmAze*N_n%_!=PERF9xIYNaPGlP2Ek%p&1+kSWn)E$)wUN@ zRD^y_a8xn)gNnhOlHfe8xrH#kFwi~YUhE6}ke#=piAq{K_+=;z=nR?ryy&j3tK`pY zxkoa$nvD>2;n@ER=`q~@@vCjSAqda|?Aj(^fXXH*H}9G&aa1^=j@t|T?zZY);KK>Y zR7_Hvt9@b^iL0#%wFIg)BgrddkEN(F4HN@Bzxd1gDZPRB#}t1BnjYizXl0DGc*|vA zoHn0X%V;nl8a+-xInJ)cKil}av3#R=`D$ud5ubsE5F)9>ax6AeyaPI+7V#Bp@Wyig zypG*R1?{IX-R4&AOMG^R>-WS`bL+;JS1z#bT7$eHk)irM!6kCKXRh6T-CVm}BF1ka z>*C#N0VAEovReC^1kOH8Vf|>7K88i?jdi4kQlG6zeYP@nT~#Rc`RY*WIsxb^-UjDt zuTF|LD$p?Bmx+sq-^I;#5kq)`cn@nGI475?vg({%F0P5W>j!YZ5KLj!-8Dn-0XJr; zk&32jPV3hGQ^;MB+8tE3?hwaGzIL12-m*oNwqhZ{*i5MF#LEsuZC062D5qk{$$>CXXBB^n8t9MRfFufX;^Y+6aq%CNP zd5|W8?L*z!eO@!?1vtvdYX(}b+SD(fpE$Q)llY+v1X%UpfcEZ@Q6 zn&L~T%j6|zKgJh{)Mc{s4900+;(8q6$lZ%DyQ$$p*bf@3@K30s2Y1+3LdDJH#N@{Y z$4?+xc`IRU>~Mu*h)g|Z+0K68L}oJvmyEx!>_$V=A2**hc_c|(T@-bK3o!vn51zmS z#}|%MIMzeRaiVMpIS(eSOH6WzH?FI0tSXgwKkTA)NyPhyX559u`y?UWM;3ToF8I+8 z9-N5xBgj|Fz(QRp}l3`K_io+>#EWu9Dt zMioN&45Z@|{b?~|wMqpcF6>x!a+j}?QvBZAH@YVt`+^mG{wPEY7O0f_2k0rD;>_aWN`>3l! zwtpOimkj=S5M<#@<(w zciI%c$$My{fV0_t5<%cR#uaou*CyZk1Kr&p&OT^R_a5`POQ%3NJ3~e%7EFO6 zD`fN>oq~gOgS|gKS!PR`buska;eFG=;C3sH(+c|z8BPW#Aq5M1Ma z*pprHbA@YjXcNfvI;zNnV%`*!AiH^&;#{Knk_;zTdw&Q0UE_3|$`FX@R=%b|kkC+4 zt;D%Y*VU*XQsu(0rG$|%0XoX1hl%1?%_Cj%t|p|Gq!7C@t6up(_2QoT zsOzp)iK6=hAn@{|$d>6#hDOT4iOrBejS}ML2*`kSStM_hS&A@QgzPz-MdlL3G}FCB znW-YOp=9jK{>FTMW{+kdgF)xkCJcnTC7na1uI~< zrU}0xJK$vm3~f3CKGCo!6{<}V7jNoNz*LtPj`e`)73#Y5sc@><)`jL<_>6 zC#xM{KpwT>yyQJt_o5iW3M^l3SD>16(&czo4g!SNucZ%V8qb#Jstrwgo!g^>(BJJx zhfxP3VRRU-=K5y%iy~}9X0iOKRYmd>d`uYQo7EeOB8_i5%}2qr9~* zyE3vP#qv_utXK?}F9)w{JKfu)qCS5Bu`Jl|^6WoGQ+^(KG^)0!?GG4UsuWe5IL0gj zmUq~rE_2YVh-MgNn<(gYm%;%{$#2dbXqS2uSi(!bCm0*GzKAVZ0mc^WMpv5*15sAu z-xHKIE@%|-`f1*d2W!zf>$?Sg8N_Jh=_ZDle4}>_E2Tq|MG=ikE1P8 zDt-Tfj{ex~%sEc>K6xpwW809Zz6!|+%S4?JIfRHwjY_dzvF3|=7(IZ2=DVj2F8NQL zt7UjaLyoiSC+VXeQ*n7%KQ(YApp1WC1~p2GyR|2Ngd;w#kI*hICXl|LzOnRU=llcRRG!y!@gv9hF^J6b`hnJf2Li4=T*@T?l8Y7key^PY6yAO#` zS{GOE^4>ch2Y!20wW__NxoRb-c{qj+X$~>C~v2{4G%|kz1ivuVh*04s+F^P-wa)wlM=x3)e68T%2d*oTb zjOCgVUW~EAjOmC6oR=Q@Iq5&)lA;JZ;jNJUZ(q>jQy^diAHh5@zMvDV1DK*4EHq}5 z4N$0OZq$bkV9Ydmfv7l$gOC`%><_t9IrlXDkih)Reomy{&8ggz9=hocCpL5M1z7Ny zx*wqY&GGJ#L{&MN0{|sjaJ~Pe{aSDt_WHmFbtOxHhUoAYr@o%Km6D$GnJ35u&#ppx zhGT9e->byj>Pj`Ys^vk@THylfJT9RBdB_21(DA}946xs*JyaUR3zgthBXp&?oxrtf z#L>&JG^Cg^%@Oy^`I*uLlM{LGIY`z9epOS;6g6na2Bfz?9w}Wmn$+eV>PBzm0GYy3G?d>N@-2V&VM&l@q^w1P^x&$|5@M`wSf9NP}rN^9fdtOgIU(T;d+$J4kV|s0OT|RIo*%t ztWwe$1u|r_V+r@Xhe!}GSEV)K&=)7-7Zu6gT7+Uk+n{uY+N!0TOD)+y#IR1=Cll9i zrU^BkDuG9#%KQ^AM9nS@g??VLm6}xd{wnvX&s=FO5IZRvTx|F_z{)Ek z7d@6*3l1|y5GW1lpMot41sob)HChVd(1UAuR^6NQ=XJhMl7Wqk&<=X_3SVsXrpg|G zsbBLNm+aRfiAr&{k>)IkuhLyy`V&K_nSWFNEX6ezGCvi9KLzg{5dBf);g@3qIEK*U zq&a;8QW0{mBxj5Vk`W1+`rINwspVQ|T!;`dBhNzPfdgy@nPrHAG;55lGnstB&|!P8 z9Ed)!y`SWEzoWI`l~MP(!*{{! zvWsHM=(w0D$KzBo5EIW6i~xZySw|62)VXrB!df79Kos#X(J&!X=%fn^gN?YI;fk`s z#@G0=GI$3*z>=Mj)^(5 z&@qE1TM7tOg{ue4uGVB%o3dX;*1?HUPyJ()2di|`WtIDlniRzUKf1{`JDdE}(l+@i z9~K!Hf?4uLFLb-vYz;zIR|4vT+~jBC6={Dm-#<3_|5cm3a)oU2Q%l?AjrA7zRq{qZ zm5p8$v;WxS9ZoLCf>*d~8O+h42`m4doBaPkI`-eV$)As{Y7vqtti*wJrH&&5dqRcW zwzSUdu)g1E-LpD$%{1Y6`fX_ znz+cDO=9|QtY=AUTfr}LF2pmek<{cmJU-lFcVY-z<-ZMU+40p9Jc7^!UINoM1&85G z<+F9_0WK*y^uFJ>u~!YHh6WqjXHDQL^Z4OGU%T4Y|B8C?zbRF#--ugG5pnDABZ>TE zy80Ha>wBg(tLpGvW7e=i*HX&HT6^+vYQ&@LpqOt3{>gYJ#20E<8$X`b zbs%9mQvDLVTXu!=`h~|{9F?tfZYaxL<$jlxT^4V!fYQ9?E_!jC8CLOA1S;2-Hm+H! zy`P$;x=0o?Azm#td09HP)#7#Pu$_3&F#7kZ)a*!Vu3x!L7}E;R)c4M%MR#85ZmCyL z);_yWthoZk?+;hgT&?q_QFe=wk)G9l?5}>Sbv>w4;zblWSV?}O%)Ci&ZlH8ZX=5{V zFO$_5vBz-9W2}UL2JBytlCg8^UF?w~FOJ4T>PYxz0WkzjMH?&N0r>18DbxWo9})$ z$wz;yD#Q&OCm8N&zgRiTd-jUOq3h9v7A#hENBb_p*dx1qb z1ZuEm|Keb}7l%9#8((S2xS@G2fU7~4xJ4(&vtJAwG9Zgff)vUQG26vkPy>wl;vY&4 zb=}Yae-^7->9~T13!5*uXPbxAg#P&{mrsm|`XH6)CT5+ra`tigKg!{KbX0W8%QEX_ zekg`!x40uz!dsc6s`zc#!O7rGd!1nF4sT4K=|3j-im`iPu4`N^bIa=Li+_|`ZwYK< zhDKz_&S14&x-?E8Ij)K;$~BTdAEajRg&_EV%z$5jCq_eq1;++)i$y{ew$JHaUwje> zP>apcO%vl5+hPqap>Cid*>>b_rTm>-X`@2bIAO*GdB^Q00bIObb`T&G3sk$+M%=>a6e%pl^xlZP4?NkFsJ15K zt$^C9tjR{>Lw81LIW4nO8|=|6bP7F}geL|5On6dYD{ECiOBKx>vSp8=_ao>9>RD)z zbXbRj7T$DQF5gpL@y0r9+3X|TA5N=AXu=^FhYco|$XhxdW}*+D8M~?Q<^U`0s|F5Q zA+Vw$08pn{dED5oS94cdXHjJK_lc~eb4Hm;BjP|nyFw#I`zg~+BP+>ybAV!dW}OR2 zd1wH42UQ$S^Mj}6rY$$9<)FV@mI5$-0Yc_naDcr0%+zTROD~)UaTt$79&;_4u{sOYV^^Z4is=bXU+$+r-q^=Fr z;`Gm`liUXwKk#2W&C@Je{0;q8sygIc2oCIDBEtfs;=?s14l7fAyLC|3F&^Cqi0;Qy{^)| zd8<~8b~z<0ctzKXWqKH&48Wrbbz=OGS2C13Bb1u%Pkq`eC68EFhwQ5azd^@pfu&5C zv;3ttGcnZkU>!sfW=PyB;AH|vsLLM^!dY;?waSfAn(CRuOF+t(*>bqS%jxc3kUtG( zup>xwNi<#3sjQ*+a4F8W_Ud2!rqMAMIl(m-nJ%_#%#k%rSSPv%V-qe*94^k9&CKfz z$bk082lv0~{mNS9vk%r!k382b`y)PxbT(ugV&5Ky{ACRj(QDY`;ar+(gD?!(E2LZcS?SNEK7VpO&gO~`d)0nCNaOJ zLmRM)g|*&HDR)xqZp5Zz$MRC4nFX3_6zsidM87FG8C<~2697+*AHkkd~6es8U^kg7NalLb}n zEG%8I?n0wWxkV`ZVJHwFjoo4HT>T}>)Ky#XPP^jPdE^)+wP_CMFQvv17h3a3>_WZ~ z@h8SY?Pp}FiBpdBSezJ+V+WIO3CjWx*BQ!sYNh5}WZP0R~(7#0p`@mdv{d2)p<#KUG{Z*_czRI)9eeuH0 zwfR7;n#2RP3N#Lt&dxYc(-wyU>lO{WcN|S5+e79c^8_+SrP8 zja4s{U5>>_+eQ+~m1;Gb1W_}!ENSB6#MlUbj&v0lTtiEY6%U`sx-m#e!c`#`30p-? z!@Lyh$#N*xMfg2jCVeqHP;eSIO!BgXgaf4Ph=Mpn{_s0!o{?6l2>FWzLT;SGQWLJ# zggD#MWz<#mnGu?lOP{3aQ#Hcjd#%)2SiDeTQh?H!a!Bb=fSl~&CZ|??r52r${7Mxs zVVy>i5M1=65ZC0I$r=w#)hg&2RfOCsMC`#tMBAf0S|JKu8Ny8LDl*<2m@%M`G=pq{ z)l;s}aPm4k27S5~4%(XBL%yqo8z<&^1PN>M24XNo(U>?dtXPvbX`X8B%(YH+4AbeO zMlgX^tGueH#RO(o1?u=aH86td{G#{`T`PfC3G6_gA)@M9k!*w)mtRvcqLC@D782!U zf2AOMMM3uAk{v&hM8;$QQ?8OuivnuORAHW)5jm#H+f5D{S*JpNvV zSq$A$Sw#XbQ2IGj7GYHCew<%O{lku+UtYH73$jVS+-w&~85M6RPk(s$Lq%D@OP|#1 zxae9MD>9?#jn(!rf1O20cXW0Xpo%M#$O-afexV&NhD~mcKWPq?j6m@MH=dq@CU$q_ zBl6rbi4Ueq;;Uqh=3O%pvC@yNw{QYnI0YI5D#LlGUZc!)-s269 zH9Sj~;lS}}OU??%bGL9aw()7Fu`+6}V6Df@@>o);v6Aa$ow&$TjZfsw*K&OAz&fHh zQ-N4tOcg4rx+c%PY#V1-Z>n zLZYdnT%8b@fkcHEETM50Tq`R_Gy+D1h~$=yl9+ir#19cvrhvq>25N|v^||G~Q)IyQ z3vWbzgZe_&Pt0VFGLa_Xfq9Bw!Kkdv zlF53`h_|qGvX9@ZAESUXiv@$^pD;WH`v6ZfwT=_Iqi!toHgn^E%pz>&TSb zt26_sAdKecBKCjYO#(_Wdu&ZA?6=1bPlYS&v9+mir9Bp0`6R>p6eRO`;RAbrr^7=j zfZ~o(;p$+F2AHThsC1s@QE*1t*R2rGJA}x-VutaO`M_5h4aCQIP)S~)JFGkY5z#tH zrRP#9_nq70BZVBqaN!Y!Ffj`I^@uo7eG2%=%Fe5PsaEU!b?a_40D8;*OVEBCF{}Za zcYb~&wbIDhoO4&%Yo+dU`?|%;2#1#;dwQVMA$%AHMGh-&JRJ_kFpv>z#7-JKN&0_( zFO0s~{swe9M;pPV)7-8>lk^hPw8zVdTNruuiaa zZQiah((TfR>Cz~v@N_dJoPau$(N)r99JuB&@1o{@aElyZ)C%nZi1H33y+WW}L*r&!2ni`mB4ZC6@p{oK{TEjkfrI7vW zBlg(qC2$jC8Ir)#qTBJbkhfdr`<(c$bisZrXzvR0X1)CgkIu<{Tp3)VgNUZy7qM>- zEF>43yJyD{;zYM9ck00L!*JTHl%0u}$W{{49&402|9;cB6PxB3Ih1SbF(sXe7*FpLn9HDQgyUiRHvClCS zuSj!db>~sk_oR}(cnLlC8ns^&y<3&`vElU_Pqf!r_xRtplx2JrKM%K`v>)qjpS6#- zV-z@f+9Q4F1TF#u^ovvdPS09S%xlmp1?@jK*(;i`C~N&bG0w?VwmP`*tfW8SOW`mi zxx&}L0qCrMX|mr8t{BpX0S+nvgNJH`048AW5=uxdwa;<<|>0m zEsg)K<*g&)$Isr_^46gE(JgP4C!QQ#9`}!~Ogu_k*;S(l@#Ba@hx~Xz#{m&R{1A^g zs%z41**Pi&8bjGAFat6ul4CL{WRBkpfq>4xIwCwO1Po??_g-?4xB;pm4q&i3`aD7I z?5a!7So-4v&6r{7V(AadugndHAv?T1)LIZ_8Q9w$QWlx+zYQtv!oD7PbKqYk&s!*( zF5ul>9ZKdnH)^T|cv85IG&0}LQy`h$6;go6FsZYTB>Il_Wc#2@kH(iL4!>8d!7|Hf z(p1-_34UwA$$EsVP9BgM9m$$&BQYnf!Mq z#(+NNMm?ngCT$UE?o6KPMlL0gHdj*-d{G= zJ*Elog!jKDmx0lbB}Cn2nLD)PJK_CxUdex!5dX?DpO%o;aS5U1TknMTXGng<%#$U= zzp~8xB%}~NQbIZ><%AB5_nWB2)bx~uw5Bx@(%vkU5D+iR+$SNe^DYVLoc^4U;{AVW zGvK{IMeshQDF>!tw`n1!Z7)q3&`*+LvJ~cO8k5#bnmdyp(NrR@AvJF%PtQqFpGN*f5sOm;|$wmxL5f4-(3)$s(;YM)p6ijK|)&7SrXD7%EK?Fhw`M0naN>42*^x|m&4@SK;qvB@Uk=L z6I1kIR$A}X+|1Wn+BGomlKe8OztA*hYYA!Y6#iOMiToz1c~dC*$vm<;YmYO9**UW3 zT+ZX;(?e}#F<-CXt&B1IIUP*)(>jvuB$nOmvm~2;K}<2sqoo{lTsneD{O~;(A zRn(OeH{DK7B*1o(Jn0B)lMw82YJf*5SXff%IHY{ULz~@-QbJqOzd=Z7J zle>q^UWH1>QL*J#7*H+C-YZZl%l_W<=>M4>{nSMMz`vCp7{9A=m{^xm!XH?vQ+ zHVysR3vKtdyB-N?%};u%k4Q*+)hQuGHeroTEvN~d(9gWkzj>iW64E};myp(cvzK~< zgtX5yB&0P@^HL{yp-+0DF<$5+64IJSNJwk`pqE-BA+7l+32DuKFLkeM3JQar-uAFf zLRzAG7a<+*3NQ44gp@e`r-XFr{z^hx;zwS-+a;uA;%i=Ni4iSz2B`{Eb?Y0|5-m<%?gPJ(WiG=Mzd}1NHEH!?j?MqFF6|1~hX`Ug7gj4vo zlxGSEjqy{7P;}ZSA{FtMTGPAhM`3BxfddT#0r8FwM8`YYTRX62Z0mD`PkUXj_T7~{ zWrog<;MCK85-WI4(PYxr#VhmA=Q#C>*!yzh%w|-j;aRB8DA3t8i_Q-1{C@x>^mgi1 zD$l#_3~jzZEuZYTUUl-KjyGOFU+w+KujC@la=ARllV)JVbdEsKeyJ5fr$C=J+BOlu z{pM%NtYIhc{pTvwNSvr&_XV^~*Pvr6uw03_MwXnS4=|=7ag0J{U?F3R*wuKY%sNlc z_~LVU|20y6Gu}GwIq0S@Qz5iWU!2VxDFy5ow69Kwv31Av15vctUW+o%-Wf$Z#z@mue+I#iKPNSae zYP?Bqg(c_Iz%sSS;FDkB8s72wIL942u+G6W=f&fR5j!cTSaL*lL6;zj;6eIZQib!D zX0xbp{n|BwDC_pzYNPO;26eq&4||*|V=rm0%xz$Vi%S{l99dZI7V zusiXpQwKA{$(&43o`tO2Q{4}u_L?9jAnZ3ox_sbDA7`*`w{su}joKMM*1(|G8@%>N zD;G1tmxK0a%Caxnz0UnJaKpWnt!SYvgWEJfQlmus;jq1;;nDcT$RzO@$+vy+IdJZ6 z!h{5q`w&Ft6H@ku7Cxb70n#aB6KLH7SFz0@zYwY0<$Yw{C(0hD1l65BQ2Qs^OIIbl zRLmDY8f+OI@Nu1uHisIC;{_SUhl4F&Df7iY%xn*lE+oEY5Re4nlc`k;2<2^7fm41dytM7i!sDZU0Rd6 zktIF{`-aBaUc{(Ar+iIvw?96fifWU)2Pa}udAb^2<1%^aSc>vCQzY%bMQYA|*xe={ z;T?k_yq|VL3rmH?AN7Rm@hl8pH?%2hK3mP_IrDi^wm!L`QHo{yml%*7nde>Q#&Y5S zmgyej1b>isD_P9QWVXH`U@tJT=o)9{z`Y|W)4PpaW=>zyP$jb~Gw2#-IAvn#tHjUv zKEcfIZwB)0vK20x>P_W%P*@etU7f>EtL?W`W9|{VPX1lc`?+LZ1oTotMWh^(!2gXj z_iAr4tws_Ytd{5Sp*(xLJ_d_*ge<64&wBkas|zR|ZtC)tXP47EWmU{o<;>*}3MVKV zj1wF~P!ZRivDyNd)|dn2e(yid88~A#g)^4BeD76Wa7I&P=3wUh2v5fN`8{}0qHF9J z=0Vw_+TLUFAujv5@I~gS?Q6IY%V|3HD_E^cKH-O7BoI{gh`+)g@u}c`8J}9au`-HD zF=(<@vfHl;2Ma;xJ%Ch`KbpF%%Hb!-RYNYJxlXQ;yM?TemFJ)xtb_HB-%kTJvURHSacLF#vOlZaO@-?q zsKUnMSAhQEra-bw44wwEPXqy0sDY<2=6`{9LYUpr1Dyi}$b;GE&49!*jeV>7aM^rd z?l)Rz)_i$LLU`UBL_U)Tk&t!I&JflquU#%wFTRm7?a4WnWr-s~_O6iK*Bd24aO}qe z8mPV{c|lp?*Phvw3~EsJdqK2}%v-2o+pMSopfL%grQK5D0@Kn4X1q2vr^1D=NX&_) z2E-2t4e#iIBtxAuq72k{t928AbYPk$2-Y+0X3XW4o%DUHb>_*=czucielTE)bi=^_ zcf7tLCar76QmI2G%5dYLX0L!Mg7WgzRN7 z&e#R)iUDsT$^d<@B?H^-3nriKGf#vho(;>zhT+lG%Yw0I+G zoxThVb#C2FTd9In1>I=dm6(%xoSZK0>wE-+AE@MVlb04x79~UKqLFM4^u;gy(<0jK zv(6m#<;uk2w0x~735M0l`{#;bymB&4TGeH0R=AAxRFtR!bwS(T45+kvk)Z8jssp(S zCUj8t=h!%j#-=TH`nu>$79tx?U0M98ppqsRG)hI=n%Vazs?L>-z5srcGfQEPQc@FyBvAq-Ki!w~J=Ad`P-ts}0( zrN18vPNhnaaEJcyxnFhlI?ePW#s zafUNQOa{%=LbfVbB*k3ImpNUQuf05T72kqElx03bRH)%xfr1PNYJMZEMy+PlVP>ic zw=9<7m04{k@B@@%gS;`?qG0kRj%`_NtisM<`0RaUnZMFUcTm4C&f$_3q$ z`r%}^qDoSQw&(*rZq8q7PScWPP|f)_i6ktY%gCvQqj3{{)I;zwEq&)&3w}qQG1fg# zIsMAn>_pPiR2g=O|M>n-hQk0_#rnqvEowg*wI7o`M%Y3O+7=5k1PvQ>!bR!PXDT9O zCw($K;`C6%mK*2B(qEAC#`L8yEZcH+Y(kRxX zMkdDwM{2uv=Yq-A3mivxBER0=A*2y6cO8kTl5H}co>CL4gZ9ecydHWucitwt-4e7r zf+lpTM270yLk%c|Fn=c)Ngc)G&G@+Kz~xUQWu?YfYc9;zBK9C{x4D_yDf7+P!|899+8lbz43VE9Z_T@F2K+h!;k;bkRf(B2zN`$xta*51%lzi({XKV)8~_II7C zXcQn?L~!i%)Z}XW$$8tPYG&JBsg;|?=V@1PNjRi@d`11vrTp)9eOx3xS%KJ*hl#!w zfEWm$6@R}>^^z}+o2yzT{+r*roPkQF-kJ8o};*XVRxfh_6c^I z8nb^E5PDTw+&X;2)Mnka)V*W~6pkWcy-DzGz?Wa1HxHQNL@$CE0J>B%p8ev!lx%coEl}{aI4c7=$uuTp5cq6M~js_`?Yh= z7$>h%levuM*2JX=tw}0z>44*c$X+gv6fhMKC9H1xqATadUcv5^-I^QxIvM=fDrfLV z?|<-@I~s4BYiPKINGn>ybs9jMQ6cFS`pe#?+l(p- z4MdZ>Y4)ci#?sgO7OhxdFrj+{4|`;+}@irKHbqHXFJT?cG0*1}1C z4wTw`sp=#w>1!)O{wijGn?`P4IR?^pj8x3II5M7|z`coXh{tr$;SV?G*u(MpZr%@osP8+Ykel&{AY&tP-i z%-bP1rMZFS&+Bn(poU24G;<eHsnQ{E_Ajv(w4Rl%VD{>-$wqGtSMq1nB9~HL^6Rr9fSJ3Jwar>

F0v7TZ&m`K^eaQnm7AQK?~{@nai+68*y$!Qw1a1Zxhm!Vol_gO>R_6O7B`=V)oYsB^k%u!3GS4w*q zDlu6D6Ri5yKpFA;ipeX|x2khDeof;3XZ`H~83e!N-Xyp=()^OUlVIo=^Gohef~OPB zFS$cm|Hr_U=GOy(7J6>gKcE*-si@V#>()Sv$#HAoPR(&^V3CQq-NE$R19zH;9|YPp z#}5K`n~0z3bx-L*yNUR%;<$98n+PEoJ1G&d!F~Ci{;du%BUZby^o=*gM7{2w{wio= zR(NO3zVZ4@T(kTvu#z#cQyy}v zGt0~|)qwvo2OLFFnf*xI64)>F9V3V!yX42kJlbmgHJIpD$iC*%Fsh5$nd0jr_OU>~ zYL&Om6a$$4Ci}u@*SISgKv^{XRYleqOSgVcvSWrKYs}t_?IQy_GG1>j5TzyIq4<6> zAs%B_OS|;oOR1G1W@<=a0{^RpDy?DoiM{SYB~ioXR7v!m8hs;nZ`VC|w}$6%1a@6p zyM`MvUAr#bt>KF%MpA7(1VQ{OBgv0(Vj>2HnLh#ONP6)YAfbdo7Rx5dmR>x=jdRw} zPA%=yny%tN$pf6L(JVR>|6Tb)_BAsyw-g@Lvq)Dm zN2{Jk45XZv7E&j$ns5kx?-lfME7L{Ru@0U-95tGOVT%GUih ztl$GOa$|FX)FEselE(m?qSd^a$UZhO3+$oO>!c8?OQ~-|iTQ-QmQr7DiTQ-=mQvsD67vZ~ETz7R67yA+n6IY9e6=O!t1B_z$P)9( zS}z4IV@k{?WTKS%CYG45xx{=|mY8owiTSQCG2cxk=4&Z2-@+2}Eh;hJcT3E7XNmcK zRbsxoOU!p~iTT<~%(t?{eBCAH+fZV@o)Yu*mY8p6iTQSyn6C_uwUl*PQDVNT67$uR zn6I|Pe03$}8(Ct$Q6=UZQ)0eIiTNg$n6J6Sd{>s3Z$^pvt}ij)O(o`QDKX!|67wx8 zG2eGf%y(yr`F>SmzPn4zcQ5&{j~!ztdkG=nwDVCWQq7~Swi~(7haRxtCPZ=9ML3;32=V-8o;Ep;C))JidehtMR+}jOGSm5^8S<2-yrqB^$%r*U z`_Zu7m8WnrYP;#!8lafVh?g2y+bC)SN4}E|6tune6jTproyBt8Xq~OL%gMzE>+-}j z)nF@FQ(rL^0KB>)4fF%vIt0k-$%A;%TGD0x34QR%oekab&)-iaj2^YCdw7h7VBvE5yemA!hd3(9 z;ubO}*M-svEXSP|Wm(!wCAVBT+=be!BL44Qs`N*!$J?$TG5a;0@yxfWRza_FYEE;g zCnzAipuQ1WqxPeE;BmIZnEOSHqD;+NxE|%AtXdvkN}g1*1-wp2xXu49!S+b%4_ERD z>h&MVeIFvS=sx5QY9zH-5+kW{&eUQ!cw8hT-{?Lq+b>NfclRXz&21$Qc?#z?SCP@c zi&aeDqKN_+x$wI1n+1*aEh-~Lj0UIoinYHjHgHASpnZd1mCCs?=)+N z)8hVS&3&V$fL3xeh8;+>e73c!?94z>JB?lF*MJ)3<%Pq!3V z4zw;j=vC+>y~7SuWEBipXFa9!Dn@uo%}@clu?fkV z%7{mdcdR-4vv8ZJj4E&Y`S(e4X6u3tD%q2wV5;g6>w+AzsB{18q8zZq0-_4Pgu|6dfr*5saIi8pa3!IC;!x$P z!1aV?>VZlNbIgx_)$^1^=Er>!DaR>yn&0yzUe0jtHot9&ms6Z}^ZPc5mvfwM^ZR=e zFDE%Y=J!t|UQSYWn%}>ccsWQZV=y%Sdx@9xoGN~gzQAg|O9sg)Ypon4am6MRvR@DO zab`n2TkJ+_;myENmLz9aVP_qtexT6JV_JSMndU8%Nhq>e+%;1g8OWkJWasYvC7V-m zfxXxejG^mlY!Gn+6D7dq=lJKDJ7WzCyQ`@(S9xLKm)&?_nBDN0yl^BhJTa2y{X;Q2 z=f1m+9h#J#nwMk0wP%-=l1m>_jU<;=#2VhRTF1*Qq|Oyvplr*9W$|rhBGgjXoefmw zk7aIT<+R)!IJqn_cm-hLdQ)N!W9Qyk`T;%Lb6HK9Z(SsE0MF!_)Q7xiYKunFe{{+e zn|cnh-exgoPjd?os5<-8#V@lrX9w#iR-^~+dAfE&8+T)5YyFX|^#k=Gb2B;e7)!SY zj4h9?RJL?M4Q%Q3QnKHB9Wc~qF$@vmCOvjERe7|7sfKW*h9>uM3qtJlVGQB?SNAP4+(D-tnSb742P3JE_5PT2y>OIB;z9wj zDMfAlce`c8spV9aEF>P;ULyNM_S>$w^Y(1Y6j@6L*rOk0lKQCO09i5#vTzA0V!VF3 z7;J@l^GoH9D+^~p8_1kP6~_AqZ-eES?Mo3Txx7`evn8oivwA)Iu;iD!I#2eF$Bk5WsWIZ?aO}@&i|}gSw?vnS zFcF`K?m*a~+T4Z->i2z1&Uo6|zqB6fpHqfY#fOXZv2Z%>1^lc^1+OAe-bShZaUHj? z>IC-*!9l_AN1Nw>~=2`CE* zUt+kvRD9duB!YYdouT$_-tN}EHHb8E_6SJ|n#wPtZ9T{p-FJ(zLtFqjYRcQ9uJ zyIKRX%-+>_qMi{gZZ~!f^~Hxr(sORYm_!GbT&(Ljfvvkbo`|I98ZR5!rz5GwcMBk$ zoZ07$v8UP4ig;V<<7o)>?Gd%NI`d<6Hk@R;xRYGGk}As*r_u-5UegDeDy~Vop6!pJ zE5^}}l=?1aIN7z@*8(~-LtRf7ppjm#MA>p9@KS@UU6>X&i5(0EhH%`UCO&3Ax@06h zFte%#$X08UCZO@UsUniT34^LvdQW*2$_jsGreDaxxn#oi3GCE7$`gVmyn|5A+!RCM z2wN{sOxk{~S>ERUqipcb1xhh$djuk`xMx6v{?@fEk~_L>QlWq&|E{A53dZhWMgj9n z=N=MHQ-{Lh_+aos`I-5x)FE9jkPKT@Wn;S6dJU^6sN1S$R4S^~WX6*c;uhHOjF@AJ z1O4F{@!kTIWgA;QaW`9l6V#JAoIGJ% z!8kDcSAM#NOz4tw!Q~=BfVKIv@oS+lIva9p+{}iALR^Qg-y50UiGB9B0?}_qI(ln; z-5t9Jb?iN~LfeekC?wN(zOi3Yb7W&T zVs6@2iDhy8^sb~=IarfZYa~8vZpY>bUX#5k3Jpvjnb@_j&uo5-O^N!?m@HFkrKt~u zE6e_e+A$k@>FiI;HBc`7D+`vrZ6HuYukZNxF-mMKykqG)at z64iWQY-DWB=5<_2%L)-CO4u8vhKQ=Q^;Y7II>(y-9ZGW;Qf72Ii3!|g=6;c2K8DS9 zxH8pL)wb$hwtRlCw42298tExj_ zCoQFTlw<#YaZT}g%PH(J^`&9EGLW~xF?J(Pls#NjXp?@a`B~I{DmglU40oGE3Htw% zKqz%XW%40e2xX{y+EMqk2RnMIk`HZ=sQA#}yp?5TgV;YFd^|704@%Fjh#~3KM!8E` z9T0(T4&pDU;g{VJ(stIys{qtKla`QKC0?k{LhdPqo$sr zO>JtiroGeNq+*Sg_GSvz44J@*PL$SHsAy@Sl&iL)%n({df|CHJhf!N;YkRGFTYKxh zc*R>SK2S+`1>b;*_(l=UIH(9Jffn-ruC>pZnS_K!?QQSx|0$mjnSJ(i?X}lld+oK? zUVAe+y*C`9?ulI+@IcG5*MHu{0iy9(pk`Iy98(p8kCC0!jgy1hJ1u9r# zO-E&mTqBhC3^Bd{{&4?e>L)*P;N(XKNPb^1sZfd!ln>rBJ)QV$3Am(-YF(}bgQ=D`C0C7m9O_o znMdlF{g8FeijLQZ9Ksdaj;^5jDltEy zL)PIWasBJg27xG7x2&UH-M2`)EI-m4;q6!7Mj9Mp!OJAT2oZ`&H zuelQAwup{GH~5pq=0JJDI_HYF)96N>I*J#nO{-$+BvQc&k_G`nae& z`qr+S4n;s+5IdGr&eeg2$hKt0-{WaJ$`fyff=!RE{HV6(PueK*C6|DD?2gxp&58qG z6OQ*;vZ?HvUvgDivKE{~3R>%_o%I~8@>lBPAeqMS59IN*8)=VPuAD+5SYoa$mQs4E zYdec&rHVO=Wf{xE*quk)a;cO4S76dCGSr&X)%+EV@H*qTQpJojF2tahMxE2jz9yo9 z$_LiibuwDj4gQ9XtlWN|FQNoNoE_+F$Xq2}fj$K1V%6Ya^?SvJiDYW2PUgQXG^xE6 zR_iVz(0!RpaL{6j)%wbZY%;eDJdQjfje)MB%#|OqR%O9A4DtFgi>f~iTC}#W`?Y=H zuTfjEU)ytB`25hY{W0M6^vb_RZQt{2tMzId{DQ7K#Y1`l(Th9ito=)p0ozlk@TDTJ zPxo{eV(5cb_fx;R3#d-!jJ1S0{P*$Yb7y*k+QZHwNevbfa~hm|qI9b+@;v#b=eM(7i==2HbSk<;Qs-=1RUFHO7NR{r zuOO3X*=Jp5Bh@z9SPSa5_kOPNGgC_#ks5;!#CQo1VQfB`uai^|%`~fwq=>ucnDhHZ zfRCRM10*v!jL#K4nSF!jPBLE<;WEvwQK{W{nTk8F=Z~W^v!#D>*|rjFw)I^8nRGL{ zl*_&xw3Z&9db7H=W#1vz{4!+}9k>dAEcu$X^yEP611QT=D~6;p)h)ZppbiXh=1E#l z>jTLyzsX*0iOBf8)N}xNKz>b8;u~Ul%F^%<%ScVS7Rhrn>XX($k(R#0^hR!{$DAqQ z(Xz{D6M{DIMI9mJ;2L}GO356LY)Nj3xn$CsngR{!pX*lV1-yqMj^aeu3@Whc^8~)m zS&k+&#oyUvRv^ODolFlHmET?7?_1vQYl3M(Ul#SDKlznAd)RXO^fLEvt7szvwg<&TFptL@ve$MuKDGoBSZ<}%1b zJh=?wUZgM)3sn+LtFo?GOUDNmjPGg1Aw)*faBEp(cf5?haU7LiWb#?Vh7evDZUG?P z$(2`T7lp6Zk8j9Bv)6@h)Q@kXW@9V-9`u!_8;vxS{;cETJa2FyHqMg$&p5&m z_H@1Wz{i6gVfDs@U-y2z%b=*0;|+u{RU*~Ms-#QQOFCzDH3J`&;6ra9Unr`k+1(zc zc`3FNME%+~78``xT1V==js#kH+CctK=QMFeZs z2=3og6OOFmned@6ks--h(d*ed!O}v`Y9OoA@?@o6H+rKpbBmyc6TiyLy?c9lT3Nlu zP$!j${oXLyqG;W4`s5oKX>Py)$h1+F(ncS-B(;t6W(4>Gd4v;R&wBDpGT@%uB^J9{ zkzDLJ)QVFb$QK!65{O|rMW6xg&o0~7(-lOjV^)+3!8`=nGW3&}x?6;Tjm(lCisWI@ z&iO?i*ANYRO;l$<+<8ev1gV-yX>H8c_(L+s)3?i9iUUza&o%7|BL~UvY4?0poOn0K zxus048e_A9X30~Ii(Ma57#l=6*ma^(1Iu?sUK-az2iVvul-iz=ev5agm|vQCTI%xb zOTq)`uXDA7z*60A{6>m#A)$vOq^Pn=gNT^8|9M@2vjr3Pe^zafLfP3uys^lX@W@NP z@9kf`UUJBqj}Yy!sJqM#mmCW~A7t0jD^kxdXdGh@ZMxps+^5~Ke!C0efKpj-ZV-=b zw^|_k!|2e{j&KI zUaRV}=2kfHNRe@7!PM>+jhe>G+w<1g%?zhE9qJ&bE`}_Lj4j0a1i zzFEqk9V1w6ivcvZMqy!PCXNzZFBb|PXY&0Y_<*d$C$`O`D?z?8=l$82h#F7SFrqlS zyBRj?PZ=-Aa-wf5i0+fib{F3)RO+pgq5=1I4ZLFQ{2WWEK1%y+fq zGg~5F(z1Q2PW)_+tZF^ev`3HSYevC7Ni&avs7d1i|cNB;X5&S52`UFuq9dsJjeFQ5A&VERPl>~pi zM1yiUYr`X2Sq*LrYN-rWP`$0c_~&~6hjgju8r|4=ULB3h>x;6U%$xrlNai()nv`dkZFJ_z zSv0u+p@F|0oY{Y}^hFLn&OV)P@F=u;gC2r6(?y ztod{Ks&`(Cre5O!dGq=%(fG=Jqqg}pS|6ERYPEe=YKYW_thVnEl6#}$Nz*`+ADAQo zoUHO{IoCX=@8Bus5HAzDX9nG*GCN6!4WfxKM>%>EwoPO%)rro#nvhU52SP(th2%Yj zRu9@mX)#`uNb8P3VWHB#F{7fI7Dw#O0SdG(oUe=X)kQ+Sm`Bgbq_fr%856KyE<-xW4y>_@nJa~z&+J3bBx8Fx>vFkb zS%IZcDKp@7&x$V4(DBMpHNJqX8j5FE&V8CGZXrXCYIUe2u# z^1}n?5?R6$EM#V8Xr33>bLn92s+&pk6-OAYqQgafwZZ&6v<$s-Pj;30xz9u{HD622 z&&>+AS;aOaPF8N+3DwhJ=a>@jH{|`6d%qRlZ>9HJEx&r2-nB?<#f0J9C4d;7F0NXf z9jcr(2)M}4RKQ-x_flcoo(lUEnU|hP!ISmQ!(yi*3g3EWXR9nwF}JzYS<7pV*&)tG zwanc09xrWkV(6^(KRbArE#|cQpLL}?MI4Hzy5UPb03PXZ)>w6K&zR*r;1es}fL??8 zIgu55olsZqo*s1Gc2Dq-bx~dh}5d_{-~`im?YVGcKY;M1Q@0p;uoZ^O*$Rf+i|wx&M3`wqQW^n?ADFY?wj8H_654Vyn(t(=kyVo8H~r>GAQab-GsiCi#wB$*E{dQihkce_RjhHxr);w zxZ+>mt2hgY%U#7`cEMj4!(UNj&jfw-9HbWW+ZeKjox-uiDs&8JO`3^`M2&T;UNYqJ?P4`7Cs|;2$xaWU(KcaVD z>*_pDMC6Nt&=}UKgjfQE+_2eNsmnkG?{fGuF8vEOI2_orP}sR6$K)YCff->^=Qq>P z;bo?O~$t{&>m_RUn;Ahj+tf(HNVQ+llZMLlf=E0+ngpj z`-bxOzd4rvAtV3&W#k#<|B#XYAtV1oM*iQIk!4Z-o3q$|teO8mTQmP38qg27yxT?y zLaux#HK(K~akTE9ofnO4Gn+kzC)=zHM9wWiwwaB_%$IFum;1?oFWKh*p>g^LsHi5; z+n}oOXi5}#AJ)ar2gj-$LzstE-8r6>s%+2xJ~F!QxIget22Vki1$u0w1o`{zAg6q& zZ5f@JQqY-cA9g!DR_t?Sum|wr^cUP7wX?Y!{bF-9^cRWu)Z! zP*+_b`KpR+*9RoU582@sVERxUKB0Gq=hS+=m5K{{oA>>c&1zRwn<|gjZTvfrxf~{b zC={I13kBXW=cjGARv&=U*DxQ*sNG!@kS1+xDOuFGmaRR5X7 zwFPsy=EIKXhv^LF?Z?s?+?KQWP^a*bbPJINm`O`~Ji2bgn9w%$DK8CUS;J;Mf+d~x?1LnJ1*R@Cy#J0;OJm-srWP> zF8FrpkRVSmE}+VN4L;{CsntiPw!Y|G5UO`xao%XKmTcqg()%l@R5adFIZyWq0*=Lv zdvfTSy5WKB-57_f2G+m(lI`-GK;7W|{vvvx7?@|T@)fwe-pU)Uy!~m^w=zh*Nl{sj zJEyx(EUU%PmN~<7B%E%pu-%h-XG--P)I931_yD@V%n8U>W85TGve;>bjuK4lv?gw{ zDj!0(TsqIHT*q(O6+5k_2X|V-N^#5BAy>cRk&fiEJ`=6HtCC{q%2D&jd1mziUc8Ws zI3vbAgmH@^XI5gq&DpX1hPZ7fzh(04^tfgBs)ah!r8;@AzH?t`RO3-4JLne_iC#YH zycfm&(DD{43?$FR8C`R8++A`TpItY+vA0K@oYe>Rxr<++Vt3hQ{wf-+C0#f#d9xvn zlMLwM+~|4YLdLsGa8fA1!H6EU_Im2VORha|aC{U%M5T<|CnZ`W{T9L{7oDdj?{ zx`ljL4)2E~CUb&swfzqX?zqy(I1X)pAQt7^^1!!V>xBoKaES062@A#BE~G1p9zM9! zqaPKjFgCB5%87W}TZagNug(Oh&9B+mC~ZiLk?KQ5i3x?(RToxgYjtwuuhUSb$tg0@ zwfGv$gvA=bL)359N_ap#{&s+501Hx!5@8fz#D%ZLfI2H0I5w%V?i~4b2~$kk}YYk2e#-cFzvQoDOSA=@r)UGdTLSmOLJKuw&2RQyso+_q32xHdh!YkTgU# zBp=KEO2C(k053v!=D;f>cV)OKF^7odJ^YPXr|y}Gr@=;Q7+*2Q89jvG$}!GJo~!;k z^*orEXgllU>0p|IMb`3!WSmvOu~@maWMgsJRRDm=Km})r_0EgX`<_@;Pu!hV87&@t zl^l*&);qgQ^gc+SrKe}^9{GFOkJTA*lq-VuqvGN5Gfs?g(21c%gB+u~h7_^FJ!O=U56dO3%0t7GYJ^yo2hh9fYJq*eyRpIaq9cEpier5%~bvHrYY z1GOCgUd^xG0OK7PY~UCukULTtBV5uO*r-3S(WrH2q8{TA2Apw@a`j5fL{?m~-f3@4 zUkLiCqcj?U<`by~?qSymvTHGR!97UNa$zt!(7COoaij$p5l_`DRU1Oq%YoV6ntf~om008vJqKgwjQk=E3% z0WL~Ooz2`_w4EBA7@37Khv^$i6M)hwdv@WJttgzb)wwBKNjF*X+Y=3_TyP7TX(*U0 zZw@dcy{Yup0Le_)4)EV@g@s>&5Wp zNPv?U?mz80yS?!p8P%~6&)AaW6e*wtB|}@u(4NJ}p2fiO-yO@aj%8H&@181S`Vkq^ zu_JUy&thDd6Ltg_0$gGRkx|zNYQ8iqhsye{N;GwO?U3Zrg;aUD5am@2hVw%79-+uA zr^RY4bI*ZT*39^fbA66Awl~9i+%T+7v9!G(!{SY#UK|U0?8~y^kq48H2+O)$IM%B= zJ(yK-OoVDP*8u3$`hmIB1BnX?xD>7R$EIS=Q*f!M^Hv`&1tZ;wxmkZq%I(W4Gc&=d zu$oclji2#lY-*HajV)kUF?T#BBTXT98k}m9aH@5&^vNEl`le1V=@woBYBM;t(b-lh zvrQMdg4w3tBdX18`!tuz{oxsl?0SG@ZCwA!`Psq!Oi0Dd5QMDYPlWc7rZiB~85F}> zvzjqUHf6*mq2KiK{ueXb{b9(e>_9XN9&A$|nG4T?})zoiQxbc1AH5Bem=kB0p*o0%e+)jH~(o z7!A{xVZl#u;}(cFCjXs9Dmv=a@iR{Hmna=@8f_A2CzbMN8l4PHFXPWF8S_V2oPhdg z0=2S&%mf*F&d8b6W{n!F{G;5OCuS?MM78p(OVoJCLf8Vm&#zFY)=+nFu0L3F=}9Qo z#u6n7!-8`KtCY#DP;GDn!($Q)8r<_(o-VINnmeAlmy4;Aw>l{wSWKjW@?QzDlliU~ z)qD)~wm5FPe!KE3xKy~cflJQsi$%rZP8EqGrPsnP%V++(tacv<8QEXR#bRA2dQp9a z?RZpQDZ-ptV@7*x%;~zu#NC?0<;4h?A`zC;FB2S;zc3UQ?}LO2 zCW}lTPas1#(o~>f@M(J605nand$Me*xsRX*m!fvWqe0y1Xmr*pYfuHc+3$MKy;q9O z+ocUokM0pS+Jm(G6mPw=Wfr==YmRU z3h!4@%U@5QgpL$i>6w?%PMIHD7M(&ZU(3dWJ8QIfrqfx*UKv@CiS{KeWVD5F?LE zy;oZnNQ7H<^O&Kyb8g|0qWQ9Fid}YtTVLT8Mc5WBmY7b~ajjzbkmkegVhq6L*plog z8al_8ND9M?YAx7~SW(>I43%*g1NwO%)9Q|BaLx*$@kj?Bk<510T7oOcr{Xn$4KGTZ zE>-A~8Pp|H$R=d$)-@Lb?hWg}C4iNWaf1~km*%IiwPcgEWFj}+1J7fs9gO33Ae4Mq zz+f#px&LYlYOMInHIC968{DCEyd3U`Sg^I*4y+irgDHa~wbKa0(em*v;y>*wZ2RcXB@ z0UINpb=eh_>9SVT4k%S!n9k=&3tm9MCxKc1%l87@Q>xr>X$ zneehdqXf|jXDwOnUUL&Z!DG(5v8p#BPg>(%cV4%atV2Fs9S?M)_e-Fv*^oT0YO!RC z2Hwcdlqrb)I;-*SUMK-hp*W5-EPD&c8kGwhaoYXQ2 z7FlgEh?ba3{+Jl&E|%PO@nXppsIYaD}X;^JFOMIyn6E0Zs40I520XWzvC zu#VFjW+tgo2OYU~tz`X*DFo$Q;Ysa}iUf(!9Ev^48agbtHfW3MCU#^mXx_|O3_7G{ zwRQlZM)fM`=YHMfmWQEOinV!Z@T-1>wd8;$SRs5%RhM&+$s zuhD+~7 zv2!Q!S|OQ&k6M-M>7DF0&X68X(EShvhMke`>P7=PdY&H4sGpTebC_d*X85&%BdhXp zDxu1zGQnP%ph9XZK%7_G&D7S1%rc9JQ!{>N?Ml<;6%r#o$;`@yevk`IA*2)POmFos zLA`1_JDo>TdjiQS=P_=+yeQL%UBc#u^yuMhidsbTXh*t}?+8hoNwd;<%42R_6wrD1 zvIwj-_dy8ohpf%SGf$vo4~<8dgKtQTf7anMiH5*7o0<4R_IEx58-UkEbKr`KeiY1F z9ZYgF?O|IU6iSS1S)PWRu;O9jCYxf;OH6ytr(jtz($vwWK|@=b+|uaBOS%wmmuc z6Fac>#GcK5`yaXafZ!e8e{%9#6vbUK_{x2fKSi;O2PKWkau{XOvb&t7V!$2xKdlxUb4b!+d{Os8GDvrH6=5W7cQ9Oohx&+ zH#(4d79V7C5pHYqR`ye^a?8g~-K)(2;`J1ca;c}|)gh)h`xAjK`)yHjN1mS*$BbHCd?WCO;9aE6xi6mR+ZIUIna_1Op*zg-01H0rlUOaM> zwu=ihA7)B!@M`(Fx&2}AaEE3rK*GBSFxq#{91JQH2`>;Wh^H%$OOR(z!CxTp9WTTn zeu}XJndNhPRL-7vqAr*@3|vRCxU<*kMh+e#eJ>Gx8S2hf1)(uLa(>k5iKQ>%LJgPg z#G6w^<}9X~;#>tSal={8BSg$SIiAo_Q_RbTJhH9%73WzWL-1vPfjmzcDqF1lXoP^p zNTjQ{pf|)wanO#oiX$mhz+9Nm*6RU8mp?$|ikEulo$UE^F%(>4D2>iuYtvvu{YQS}je9^^5sbu~_wqxJfxXkySVT8y0zx5gxfSgy~K(a;dB z(h8kyDjcSDTEl9&l4n<-wqWYCSKE>G$;W$DySq2_EE6t_#451h3Ov_^j+YO@TR6=G zq#29asTt`Kd9=MkfPE#?B1g@NjEB=3R z<>L&_u;Izv3l^Q@Ru&G^C0P&(mW78&5Jta>-*|eV))M!anZx54dz=@#PFait<=>LQ zyhF&0uNDCLt&!h6g|?karpyodgIcd70B7f2`r|Yhn!KTmpIjo2q1UlVv9>gY%~H z+Ir_D4wCp6)rRCO6Ygl3Tjoi4GY`}xzUaKUT=VF-N`DuHV-$-awXEV-;n(h}2rWydc=UizI8W)+Tb}+=Kmw)9 zoldKA6Tt~DAi6)pNyKgdo3M|VrWc{w;rHVw-^=lQVUE3pIfi&So-54p=fWJtUJmvU zP0vh?SwHxbG_$)f3tI>UgcBOF)LTF3-Y?5RUY4i*EDCI|T84UAWTT?B?AfoDgV~yN zlDuMS)cOGcO+eGwq-QGkv#%6S-t8r@)=`FztSi>S9WuWMtGd#p>V@qA&}>z9GkzQ~HN9wpcPWOgrq{erMX%NLmY*uPwVHPM zse(qU=_%@HQIrNt4D|rd5FI~uteo<3EV&g}z)0c4$AIeHZn-N8Uu(cyxeqZ{Ck_zt;7soA&mMNe54$ zR}+GW3{9*Cl;W>$6_O8|18XrF0hAh=Di7d*AR2g+_ftk0v1Ep9gOFy7D1#bGo+Zsb zBm$7W=V-fqC4X7kWviA~(tQ-?5>3STsxr*kbbak(b~blgIb&s1sA_*EI#aIE&^~I^ zptlcfWmyyNGI8E9jJq>S^!+lc?G_-ky>(j-5>kA}+{5s;5RI%)d{Y!|=NFw{gkRmt zMkG_<$9h1;zsjz2c&>r1ZbfI^EHv~dNe85jTnBhD4Y|*(N^@5UkOe)dch-7aK}O1) zj4_@i+QIC9yQc&_G_e(tf%Xy>#oX@&-Gk|yF#y(KLE14EuKG2i*H?9~udwerd8)NB z7M?}^h2a)@EcDx4!Dk{o+AqNF*lPO{Q_YXiGLy&@4^QhAccI25c3PKXWd%W!?v2y1 zVA#*8`|LWZ(|z_;1l(h3nNRlDTfq$l!(r>V&q<^;Pdq;h)1D+dwKE7z<9A{%Sxy@$ zpjtBaprv62!6r&UfL3K0o)Vry{1jGqnI+Q*Ul@+t>4o9#v?22LEBbp!c$56*kQiE| z8OV--6U#xURWlNz-VqY9P)kSzHhbErG&eB}0IHD#WR0a^@4Lwu5yZoBg><4K>kLH` z9{AU>41r#z4uFthp}In%3doMX7t*TqhNeI<=my1!uKDOar&>RFk~UyNm-8D!oh9PQ53Ig2TgW<~h~=fhFluB0R!6?gc9~l*Nb7G6wM6 zjaKCjRY-n|&)=3y&f7#MpU*r=ErxO^W*Fc^sq0Tx>K@ZTQ0iJ~Rlc^< z`qpNv@?k1slQBU@Y9i9nc?b>$Q>1iI>FP{NVWlVq$Nd|_)Bx5uSd|a@E`@X|K_ZaPM3TV3 zFfP>O2oN&M&1obO26;8UFsylBlMzy)u#Veq&67v${X)_WSvQUm2TE9pl;&+)q`2)~ zbDJ6G;1H25Y>b=HiyDV3!uLKdbrmo>*{U}A91m4fj_FO^W|$uK=vM2Ww9e27=B-X< zYhF`+-nNEYN!F>`8eV8}DuFTttF6lIj7dWH1x$yNZIK8r)A@RtP&?y3jU@OSy|P*Z zRBL+X1jC-X1PisyEQ66jPSFEX4-HZG<(GggMds(ef-6O#AF01THiv%D|=*LWOa=G5^JP)cZq zaIG|Q-RVyx0k%Dn{qnF0e`6gDX! zSW-NsQo|E`X~|azFo^O^7q;;uLo6-Xd~Y|Y(jH&kn#xivNy3TA*}@NB%8q5JksADF zaLHrN@P1U5{3xCDIMT3FW@TpcZi2!m)sS?ZR|5nf5E0X>s`G?RG9V>dMxfF%0+6!# z0n5O;M_ZMg7D1R)aUT2?TvN@t93!2}=89Vs6CSoI_d#mxvxN1+949i}&wDiUb)-PA zFP@Vpy;tKrs+TWhq=5ro;bN> z+0`(OqU3Q#yC^dLZA4^o=%?7c=imk*`u%2e%*lvnC}D&!j;^gxQmU8XK-Icfq&sSj z>qK?yrn(XR+-2|Z*Lf4srPS%*93UimFYj3<5p2p`SMyyX`P|zl0)Xu<8_$nogOgcU zujutkeIhT{gjnFWk~i~N08d?7Qk)#A?D!Hs-P9_yOPJeDkOZquT;jQ|oF_(HDPy%Q zrT3XeqFEHADYYP%K9$j@&Xi=5f0?KFW6laP4-=$wJdw~{@BBIDE}Imj)@$S-%Dugv z_NvwZ_gw^d_<;kNQV)DYaM#V}70s4Wk(r*=JKglFRHR?y9?$?EtJ>^nFL1C1y=Xr) z6bo#PM&7XIp*!xWcixIty=C+4Dn|n1I}C7u+)YVW4cL(t))n6)Yp?FNJ}j(<SP2%JGPL5`3Qrm0A?m>R%y~hrdL8TukMq%0JSGj ztbk$*kGE3WY(um>K@Q#a+QHO>)ITO(1V`yR8y_idvRk#mE*VKV{uI zF)a7RhC^m0AE|8tWIn80&j=5fm3P)||5%^-ReF>V5Xjyip z*7%XsG8ylKtk&=F?YHw0nkdQDER0ToEZ72_MrQVLHn9b}A9rznerQ+Z@{+U7xsWNb zSP4cO^OK0jr6XrxvOT*?&H{~AaMwF#q{UBNb=(=r>|~NfolY(t#hf={RnW^@QETj5 zuB$Wgb=eYQ`tpwYQ>6R!J7(spPnqN>H91Cx1s^Oa_;JHsU^K9;p2M}9!4nEn?Y8cjB?OoTF_UK{%AgRa;Y$P6A^`zgHsb9hRg!36+4}41Q(1*E~S+e z#Y&$|urfW_Ny^?=?L~e!oZ3fMYf;@%NBE4Q}opDPz?1zG;&^P^W#`WqC-EyQ`$19 z#`{G>@#Pi!mz0O=P03KRc~eZ)c3Su@0Z$GBh0cFMMtPl(Q?e=H^30o(_K6- z>Q?it3U^G9!T1i#ROtLt{#+8`&yUJvGdD);&@S$45iYx**g>>+GG>^pabgzHREpB& zWQ0}Sb6J%y5{*)GA~qCFWvXn7n-Z+7Wtx=?Yp6*I8~bn7?1{zt4Px{>>hh3v#o59P zu&R|~uZF;C?AE}BsDn0JDG@PvK@}V8kCLn2y*!w=tBW~%Fyz9_z&`{A>-b!2R%JNn zAGzTwTW5Oz4e9++f>EG(hECV@?KHi^=$@_DgdpnUhXitZMDIkyHO!y`#0^9Fq??HC z$wy2#N-w!m$J}cD5^yR6nK_WEj$dYz@BnY52Dk_!x1s7somD#HTPW4?ppRS!V%*D1 zqIVV5f{Chbpnjs@G6<%NyXEp)?k>nWb9>FZ3vz0&>uc+ik7j@2f%zg>P~e1XM4dI6 zpAq5T1{uelwUG?{IPR>K0eO_8i2V{WW{O)spazt-#4TzBS&LJVBwv)y1gHfnlk z##cB>QO_|%*u`9ule>JUVFh+JH$uJ@a=%sPUL*wkpm=;WrZ+-RJh84c6=+wIVj<>W zr&RQHrJ|%m^q5f#VZjI{Gfdp^3Fa^IIL`=O!3eQkFelDRS)4;kR^_~zv;4vBBLw-w z9QvaS`F=u_v4G6m2xCuk6gH1h?$yrioF-)AV!T}7s@t!x=csnXoMkr{&JAERdz^xOn9LurJ#h zZ!W~ZJYr`SSxY)?_hN3}uC$g6|9RCW_{UVPR-VZexH#kle{Rbi@fBD(toYz;t0D66 z-+^sKriW(!@3F0s!mNC%8IV$lJcnV2XR%5P^K!or$D8JU`f581_M zhW?L9ScVTpX5(VJiOK8M`|?#oV3j9dZJ%*$%$*(Nsp|p`q?ew|s+XG0MdUR`m?@(U zgO(AjQU?|kzWY}a6u9JWq=c*cN(q+%P0mn5UdxTtmCXDXIVLI)6+#1v3fyw{MFrV7 zD`nMU|1+?t@Rc}Pi>Ui8=G{q(tN!L4*5--Z{e5WWA|GJ`%(^ckNBr;2x_bwnb-Fov zfk7fM-oY0w>I@GUB!x*!|v5--MfPZt<}SRM~tP@$9wq6_`Oh-L-B^D(X_JZc9Xv6fI4 zl^y*R%gmxaJquUs&~{LB zda1KPj+(?;6oue<7;1nn)?CpJ^3k+{?jW{SsW^#9itBjna|3F=&thHL$~Gh3R>TTO z#>l$n=de*@F?^RtoRwzlD!_m&wPF}HX2f#yqV;%o#o#t^GKa)^T=}mEVAgywsnz4kO&UOU{uP=aSS$yn z&|6XJq=T&aAET^$ux(zk#I*VfJFpJZYR+v-ytxx|wxaD|Sl+@BkJb7pwxH2_0kbC_ z*~*oXt$EA!HyWL762tQlIVBxU7sUfx;#FIdFBpcjNTK1ulTx5@PYb%uC6TwSwqjH} z?!j^Qv`XnxHDIYTBeBR87cBED34r(g0lg>(C}1`MrrsYuUckIxz-)}X8+YDqu*SZD zMZHq3QJdR=EGG30Rc|Dp?~fjRN&d$5{Z4%CU}GA;6s9omEVRk7aP}_te*A0XOtBzo zrX>B^me&{-W8<1DU7R^orgpB#5WlwM4>Dqcpxj*Q3Ya|6d!$Q#CadiZx|tb6l(U@? zYR5n^mOiV8F~oY(l(3c$3m}w16Sq=h6b5a`*yvEIa2tA%It!)f+Xw%kG3#-jaPEgL~#g3P&Pw*&bWR)Jn4LvRZEwrSh2` z7+h;=rd!#SxsJ8wIyTqzfATQ;sm6{p@-}*I8ret3Qn`*zlNt*<_6(rFUmDWEh3OyB ztKA@MflfrL3Gu`nH16Dw6$}gBZl*I(e%e4Og}8^dB)cIsCm2W$*U3~WY5PwmpOi-R zPfEHA)-I{$?Yj^}<{~-$6KWA_S;NqdAih`DWOc?S8_#i%mQ6AywA{%GY^q%_x?0#! zeF<#nW$*(VdW@U(R79K-0P6M!vRmNg(S!}9PmcqkM zO3q@btuvX?w9Er2UCB@ycG`vdr1|Yrozl8|^D-0-sZ~Ri&W`R4!s_fx1&ow)yIQ(Z z8eUK;FN{O+3*yBA4GkeQBv%gPvirm12^s_;}Ue<8G9xng@h1 z9-X>ENcKDko0%1Ykzhjv<}Noe3ZP$^eaWYl*x=P9>Ln8- zkreG81(ILOJi$BcYl6ixT>_CcGe5}?l?AM&dm_7Mc3Dd|$Y|6~G;}B|1@MGN4l)r+~RC{q` z-^`Pwt_Zy7^;je`^O?Hz8Q(9mCvT{?mX0iorKk0bT`=+(J`!bk16u8UTv#?FJw6ay zFydp`+s0^hfox;oxg6YC7A8fZA&Fmi22;Y|J?K%-=eoaDpm)m_F>?Fqz(%p2XzZH;S? zWpobzdvvLvlh61S$+(J)T0!(~vT?t=o#PhMEupYBF?r0~P>^Ykk`}wZd_{6OICE*P z#pr$H!HAkXDDb4^d{z-3GUFvH949@p#16cGg{ZZpK9~;HFc`sLs=eh}+dZ?Im)K5r z%MKl5EeZaiqr22vdPHhPi?w`1U|p(vPSiSWb*j51YQO!Z3w* zu5G>^vKlozIOF4dMxEUa9WNCt|Al*|#2T`lm)Y9khSt1S!GlsqYId+Fxh}hf4cC!A z*O_@TOKCb7il@u!>aFERI@=AfCFoUxvACNA&?g(+ktfyx=&b-63v8-)R+_EUQnQtE zR@PgmJ)ON7*hV!5XOsbvUdt%<+4*(ZS6E6}D+Qcy1CBzf;5?q)TEF1PxHx#|E{QG} z!;1ZWE) z7qryA(o@qTsvDh^4RiMj30Vu}p7q%D@ao3N&k`rp)o3+7ojI0h4-@5mF~JEksoBkW zY@7@I<+1TtcB>LjFoZ0gicdZyM?BRHlY^~s_gsc!L!&!<)M=B;u3=R}V(Bi8BmYFU zU;ZWgYl!AbI}Rq?-Wt1vwnim`Gd?A-i1Ir(DnHAdw_%mVQmqq^$;B*^< zc>3JJ%~ut*JGl@QOn<#6&ZVZn3T1ZI(!*07u&W0|kVZ`_TS7VQV$t?9{{|4T5u-Mp4xjS?x)bD9^B)B?n&K6wh-ffG3MU6 zPy)*r@VATq*k>+zlhp`oVn@tlU$xVh^62jCnx-yakBPe@!ZG)DEw?OJF6O*#Em<3P zx)f@A7cXg1o)aCsMVt^+GiSWTcA*9c`6ulw?~@_SKBIMeJK)5Zyhobw2;u&|4{Xkx zK=%$>0s%@(NmT_;>Gj$#-Uai0ionBzO_quWC8+#zpSi zF^4$-A#-PC%>A8ChWmuDwA0+#^m1oR zxhU{r&UY$0#|$S6YTbXyTVm8(OJ0pRuUSjjhZu_(cn{A);@qk|5pic!xQ#`6okPh= zsmJFc9&6QwCi}Yi*#>N}{u%t-}Ng4t=e zM1Ob%6t_;i2CtuP+u;a4eC^Z3Wpb0M4Ehtp?C z?g4rjCAaD0bTUWXMPbv+1Yh)Ws$za#t6-knCN2El53r!mXiQ}ozCc8SSrKCdX|Rdi zhTYkrOQqRZ-Y@sz6eVUTSMX_Wq-VY=K^C>LD3?qNFemVcJH35FnkN}7XNN|`lNjbi zdxN#s&(_phOWzYY$O9}7Q{rr!-EC3g5@6Xb*m zN|w4h3!Ic#38t2bZK6iXjBwPHw`JL%H8N@}cIWOELbv9NSTo9%Y$)=j>&rqAI5(P} z<-<@) zh+iEMDT{)xcqLgO@WziLa^+%rPG<5j`R%mfUBs5VI>dy6#_W?22WzGLl#xw_%O+gm zrequmjc`+CCL|XcYk>lyu4V^JT9ccyO=voIC29yt*-3ZMiWPT)#p-3{v-vHA)v8nH z8exmPVeKxHH9%|RL^tOCRuJOmO^$K4!X5}^#k+Sg8n~2N)66s4jN8>ZZtk+Rw5P>o zg`dK5C=qdI@j8Aowt!bS7}6chovD!8@=1jib!r`6f21Dyr;l%BcClT4Kc%v3-%sw$ zwN$Ude&)(ts5KY*5g`S>*EU#uU_FV?C7f!Or*XMUW z&pRFmh>gxWC{yKN)40jf2IN>Xu(gqs&AfNK)V^RM+I%GISmFz*eZ@)StOvMxoqPOc zV`|?)$@P6AJNkV8PoM99ms(GeS_6sWrPizaWN4vQb6(avAv1;X>k}ncTKYttNR%}3 zjpolt6Ez}#waL8hlaE)($wy0EqU@Wt2O{c|UC6#q)DuL}f!-}G-#_0inva%#yMNl% z`$x^*Kk9s~p-)R^?w@ar=HoOvvVYp=_mBG6{!!w&HxWbPwam=76pjsh zNyBm*!1oN659>7wWIM5_s*tsRsR@dja3f9l+>Ru3b zFRd`W(mqz9-|5QVZrJs%v)Yb4Vq4=fEz7E;!Nj5U&KvOvkNb>!Lk&Z3Cz9=joxV3* zt!UT=OD`WEb5FsuUYD4i7`7=oA+HYHtx!nhC@q2fi@HVLUCJmVB9i_>V5e6VMTsLt zp->@sVJj5!bRgWi#pSJ};J~Ob1?`L=mbGf6s-vv7N2Drle-K-^QhBZ4T?GD2rFb~8 z7iXH72YJvGs=Vq(FWdN1#uwNS_J`9`Kn5BlcLqm^Ib>9V44-;J4S_e~_@EA1^U7(> zy`a(`1Si98zX1K{*SI&!<%I@k8Q_|v5OdAeNd(22+G;*ADmli_ts&^UL1{qnbDhkHLA3$04#Ep7x z5XB%>{Q{^tlgMA0B8fssfe^4z^Jp}AoQ|&0my8u|5zI?)Qem75%{W_aWrQ=sCBm=4 zPuTeYO#Cw^}U{zoGjikSm4E9w#HNM12zZ#sJeU)k=PV8R0H#A!G;x1eM3Dc8hwD zmA`-r-s9vs(!t!vmmvb6KNGE(vsujOYiAs!@j@W8-P@%?nT_N7%*Hr<8t)#4!Hj8+ z`54FN>oGtt#cjXZGkCmJA*+@l{a^jvGF?=W?yFP$bnL5$K$Fmf$D&g|80 zFVZZ1Csp?6{nrrpW_I`~NIIUd4qjapvza}7TMqGRGhzt)WaZnof zpL;>)9)bF-E96#dLu8G0#gPKC7zd2@V&=)7NGFTCSZXd9ojz=l`<3b<55JxwRg}3G z_|wu%ySH$&D?}7Rwi7z~RIFfTGIP6FO*q1h7c=v66LTwMo|~Aj%S50CNTOSZ*B>l1 zJlJGy-fw`sf$=31)Yj+cW~;2+YDJ~*;mEaeALmQ^$GM+;=K#sjOo>j)>_IuETwR1K zX9&1D?wlx-x27oZ5&5o>ae&MY7oRIK=W_fxITqeLjhF)7EY1&08l7FH_TNiIRD6WY z&Vq?%Qh(xQQkotFQz*RWICt9u2H876fL??>*uB>1S=BkM)~lM8b@~x^c?;oDmsW65 zjesGQQ5S@*Hqnucx}efZiCs@GW>VXWnV2083nD@1LgQj=}PnC&7~nDU4fObB|Fzq}|+)Ss+vqOOT^f3BEbGytAt zJ~>_X8R-@rtdzVBk&V_Ba`{?0SdAAm?@JOu?Mf#qY$q6&$rD0|+K)lm!g_26LwYej z5uk?`uqeaDw&_EDf>qYRJS)m!l<6#oUlBCebubh-RJ>}lj8`Ss3lSRENYP1tuUe}- zmd0aUL|gMdDc_PKV|ghGa%K@s1PfT+CW zr}|Hp9Uyh<6fKVX?@rJPld}go+~F0Sd&9yC;98^2A?J~Btp&vN;#xc4S=l=jv=7XQ zz<{i^Oaqlx24qKDpb#V$cTPn_MF@`_WP56w=AvnV10*;ke{CseZ^(7JMj@8}Ozs)T1BkLT}R5&c|O_?-PSF z+F%%Oc5G8u_hv$(0Fc^zCUk^+D-$Z!kgPwF$5oNDHxDZHc~B1BnSD~o<1atjC0HX?8vQF?-k1}Ef8xkIAQ6A5zJewFR)H*%p z&M9^0m@Ozn)6EujpKMJlRgH-)n=xYCrEU$xJ-y;G9@weIj=PeZq`^Z3A?Oc+xmK-K zSxCL;db4BCh?wPGlxvPf3kzLYXaVFdV__NRrT`|B#_U5}@$YTKOD-{aTgyBIRqrNW z(3=~c5=FX>6<-br({=U^ackUm>2jsCG}>)8JNB#DG_XN?$@EpVee1zs=djlv)9UI{o8Lq zlBr%7ai*r0tGXz8I2KFO{2hJvX$k#dJ14x4N$5U|rn0Lg^fgRZv&)R>ks3;6ZxxE- zf#A8@^oq1d=(bZDMp`y{7TZCvXE=_3Pv^LvJsAb9><}N;DWPhxP91N@7(~fSCx4VQ zaLJ{O$m>; zs%{FeGhY`XgjL-V-fX@S;ptY@9mX#qCq6C2+JGi|nojc*Br2XZ%?eAZB?)R_oC--@ z(9%uLDGeu_TLi()T_rs?f|5Z?0Y56-j-|HMKvt!_Hei*A+eSZwl5{VEE#fRU;xAN# zj4NoRWqC}vtJS)QzeuB{hBiKn-LjlpNqNR6sN-X`eGW(fNc_VTNNzs=KJ;W#2j<_0 z9XPqP|77X+ z@YW=Uh<4#Q9E&P6fKq&!9NV#;6sX4ACaT(1^pgQSezdE!O_6?TaEm1ertUI1K-Do6 zN~w``7!hetJg`^jq}pn$6>Y8fbD?<|1J{+~KC_QzQQ7iGQVLEt-IOGA#wfkZ45J(t zjV3p{J^1O1UAIw0#NbMizyKY;rNYRo0bO>4XnoBQo)FwGAvk#{Lev`lz+3H!bT4xh zC-7GC!jzQYVet|xHIZO!KMzfywM<0FlE$ic;s$R5Lyg|0HZ4=@h2gTiUNy?;25zW9 zTcabl9_9Jk2#UF}a!_csie^0XasKp~3-R=I;i7i%Q^338k>`>)0^2sN*TiV5^(RJ5 zwrb-_Qe8uE`O$o)&4semtXjC%)eyJ4L}&N%-0a@(6hP)d_MiPpu(N+g<8ScXx)R?k z=}ngHQP0S!W-^$eSN^DUB+^LA^j z{(#34nVLJvLta_Wa!w2I_lFrSIYKeEBg54@9jN#d)aI;~ifOwjvyIQ($BRmd%cKEb zniuzASb{%Dq~Fs!R2v>c$)a_}oV~aMi$&hRL*E<7pJv_sId`vwL)-LSF0+bnzaDys znL+Zi@NyAbJ{}FMs*k+Zd|$4IlcgDFbrw%N)Xuys&FJ&GYPR9$(ho@-o;iX1R8~R< zOLc!^%E)mGz5KZRu=ZwT4|JbgSeC_8=(m6iif&MiKBf_0uzYI%?4v$f>S6!4#CSO} z$dVGo6?lm??{=^CW5lL|g@$J=#&+a~To#{@8FXO}3&|}MGQz9{Fo`~%+8hi>`nqUy z)-b=ri0UwDmHr-5yUb5nB`gXa)Voq|7f#@)^-jZjkVR z``tVGPj*rZs1#hbQ&C9N7fbL(AM34hyQ#BY zWK#vy@$SnxMq|;bO^~LzmtW@49KXC=r*9L#K*Ac`T0Q6ch@ftrVD4NJs2N@q zK~lrojm)xdi=Duw-d%>Pq_@66)q10RK}8jPkK&Xi#M$eVXT-q-U}U0&dP_?vzcHuoD|~oz z#}xd{1YX6>=geblPsU4tc%S;jA|WT{wVlb(lC}AZ-kxxwzvnQT8mmoaQ$KqSBT`8p zW#Q8^OB|ed1fHBI91&@Jj3=MTJXSHQ;T8xkFPX72hD1Cx@Z>A7TH``@<~B*b+SQqJ zhz5Kk&aocs&s+rwd7f#`meALi%=jlGB#LTUNy`Tf#N57^#=c9{gQ>0~d#`p=Sy0}n z+%uOcDG;IHm%6dAT17=A{K?_P!$<5xHd?J86=?>Ms=GK5N3P9#{WbvuuC z{fxH}bWpI!Lom5Z#sRd-jT(P!vJ#i-eW8Xq_4RoA&TC0x01op`^3qNR|RKNB(vX;<2im&(B4n}7069GXajV1u$E$eY2#B~WQFo?n0} z&6<-tKuZ1^Qb6`LzHNn({hqcN4wWtQuki{YRd{qR@^v)ulqX_Okl_=Ntef@_EBY?F z`_qNM29K#00v=x2^bS@TB*x)Iyxu^qev%xTdjLiwtE@J$JyXXh{@m&hbD0iV?0{M@ zmpH*g*SGz#&B&pWDylL^=RzXRn7G4op#UKzy8^z8$I@QZR_;;TXM`-gTTmNS^8BKV zl)FTQ=jFN06)5Ra@m7-kPT=~L#Q^1b&(#a$cmo3f5L#lVx{(ggB%`4P*55+j-GU<7gJ>4h}h&^J#&kV^D%Sb z+o-h^jlwe&yy-OLbSgMVt_%J^b({|;c%l1?LS0;@%T1J91kzM5U(^2DusA857*Gnh z<-o~H`cHN`yWSbK*BBvZz6YH+9f|_kN{XbYBbg~Dq3dDtWjE@&rYgNmjl=>k%CJxG zIbB4X3I@~Peg$S8@19z*n@3+0UpZ%`-bEc2^!;#^qAqv1yor{$H~S#$ zZ#w+IfCWUnSYv$a<>Z%dkvIDrWpf9-y160oRegk((S6+Z9+uUuVqhi$9JEs)gtr3( z1ChU8>4V#e9ocDzS@$oPw`LFW%glIYr{U1Ce+7hbcEWy{003IcJy!!;`7FAu+l^w0^tx zM+^%inFQAwxS&B^`{I$|`kXZsb; z?!RImc?IlDwwg+C+IOAlZ}nW=;?4AGaE4DTzg%PF&sGZB;dNMyc0Z;F6)lU%oiGdJ z@t&*2AEz*hcVTNXSpjWr9%csf5o`X_nkIsStT|Ju$LZ*GZjhNl+yJ8?I|f)Tdzv4B z*{F=cBXMVCBaOCBBqr4}BykMSP+M(6GulGEW_+9b>O*YjQP0&#dQMMfz7j2mhG-#V zM-g>);Fd)4C|jyekL$^P0iQEtZMSSC&St(UPK8qKxV&AF>}udPd_1r*t~<%rm#FHL z^yotrnQXX|YqPvR7YfdkqT-h2P_L{V*^_)#9Dc+DkH$rQv08seS$wIr@nZ%<%CGRQ zCX1njz}G?|3l+OV4r5lCwU-?!bMHEO;V5}@L3R^i|V7taOr_l_GT|CNY!_63{ zR+g~7@{s=5O6!J_<)X||>E&!%y_GDTm(d#9yY$d%h@PMD3Jw`ByXP`rI z0a{j@!{Ux4hZ3EEMlqiQLsqMigi24!jX-CX8_$CLQ1DRkW*TfMD7>|IVHpCPG#G9z zfJu)#{#rxurd@o34uRPY;)SaJA&AQmu)qy|2zqfU_St{hfv+Grp@e6j(d&^fm04Z? zN-rXk9GQ-B>sbE}N=%R$tu$=xa=3-Xsv<(3wWJOUR9K8>2GMDZB2=TASR6 z`gP`M7Dh1@f0E2Pt$0J@C_!;{4DSH7@35LqnFiFSOm}IC1>k7IF65Qgz&iCp+Xi{8 zz}HG!;L)ebw|7_*caStCTr$-< z?$zd>PPNWnnO&%oh!_d9#wf3B2Y@~&06{4Rum%APXME7kh_(9x_-P-&H2?@v#_J2= zgDS;?0^Yk`p~?fmw;TBOke*QZb~U@ew<_C4(+|Ke;^C1rTql^Ro1VHfUX&Os59|)t z<>l0LxJF4ej=pB3JHz%RDtc6;Pp9dcXp|1}jxS7H(bv_y!A=Fk>OwnSEXR_}^ibk! zfe0>P(x3$RERiHk~~!BFLji!%$F4USx8B{6P>2~j4kngmCf;8?tNEy zztWE6L(iqZHQsNn{vvz9(+{?tp@mh^7xu9Es`T5LS=qN5g|P5;vfg~}H5GAL^Nv#% zW=|T7^9SR-%fu>gVt5*zAE}74#)-Y5m_W`f*m-5KE5XMmH*b? zTV;P~+$Q|g{J5G$)(|~h{(5wLgY$s5DG)j~RSO;HI%AHj(Fr(Rri} z&(fL|)-g)n+{CL-m+~2Tgz{AnG1|?KXtzqdBj5DMPYEwD7OvS>3{boX+vi5Pjfhkr z0k(!~i17AfdR;{JV~Ar$wP zYlpMhS%KV-$Zxfcwvb@%m!U^9@H9!DynVW+zDz`ekS(JXb;p&8)W>g#-%@_d_^rsV z{onFg^OTuFMPF8U3haNPsr!U}XlS-HMDwk;5s(TLzy{ac>A_jP*V0(8rLm?Zca-h^ z;x_2jcJI8IpLp7p&MNY|Uf>iDcyMHzY=~l*<8|bmsQdk*)YiRvCbN~3l5;KcQ)h!Yx!n#C73UG~&9jj1v(zh2PPL zo5DAmh+D!z&>=Pqx0#4L!ett9N4VWY+#3#S#Jy_s05Bu@M5DTyWbhq=n1c&|4gYaG zJIS1ygp{r8PS4fS2lAAWCkFgA5b?;aUma_1_+Lvs3}84=!2;WGAbcS_1~ZoPlfM3kYz#dF2d5z55>`Mq5iS z43CBtZPS{IsF`gu9mDSz=dkD|^7i3Kw7^kI9Wh$Bh2!!oIzp*;eALx?rHR6>h*dOa z6yu|3od5r^_b%{tl~vw<(x#AN@uX76st8d7CV(0cG!f7olF%JEl_(UeT#Ry=A_$e{ z&}uP9S&K;Kdb!iz%zkcY-J+98r6#woUi(-*vS=LK72Kq* zs5bwp(2Sp3qD8AwPvujoGyX%YmuIo%j9yxAw^rIK(UXza>q%pUCl3#zZC~2V6DU!G zzp?LUQ(_6IV@R=-w1W~v)s0^I0F&uZROm>iB-hXlMn^#5cch$3`;*=DwDjFpy{#^P z-##;bdT>Y3!?D0q8xBKoZy^-gA8Z0H+&`WGN1{VB1&b){7l53&0fhUFnxZ@CdIES> z!H2AZw14Cbq8(Cur+<2#T1fk6&r%A)%hzBux_ou*n$*DI^hUDPA^fIuFHcEb{1_#Z zRf6-cJ$0m!s?y6l-ZNWLNxF5*Vm9GRgQ^llL2H5`pJS`BEoc+T>869-vXjd4`9`L` z&6dLRe;QbQo9?DM)_{RRJ*7r(O9yAyrGqcIOk1EEyRq*5zt~Uu`J0`xw=P6m#?not z8Ct5NB{?}afZ-i5=tdOVHbfP6V4ZD8lt;c$$Iau5Mm(Z24IRotCK!@GwGs?rrS*kr z*ipf3MMX5^kaAX^S~EyQ#^+qz%Gput5;-^!}0W%R1As_g4qb-!|>g`@a%0~BP6 zzN-Q>i4ok&oJ{oH+xRZ=YE-+xY-^bA)M&*O+OzC$oSjv`7vXj>-)k7xe2aU_omVtj+{M(KX0B|*oU#`vbykAO5#jg1#{2} zjr!1$dGj1(lDx?|;yK==%^4u)c$56(OT4MUt|H!auw5m1le8Ln*2TQ(IJ=SHO{dz8 z1aIoK8wuXjZ#QDzbUBxP#GB^q1aF!n-Xx;#c+-x39dG&^%v|VGT@P>Stbh-+SgY=m~EX&yIT2r<3drC#G;E?*NOJ2V_iyW z3cibex1?@fO}Wm^e?vS$VqUh_s6GJRPNoUU%Yw#aQW>IF#f4Ty+Mh#MR+>=NT;NVa zQ=R_bgR5{b<739cwlFraFbR38UZ#-#*B=p_|GiU3K1t2(%RAmRyDPV@ zx`PaOBe0S(0+ZxuwUQ_k9Iayl|8dbyHeek_w;t~J@|Bs|z`GacNM-n%nY z^qkk%L2S^22yMv&=euwFRxxjo7hgrLPOZY%^0ZZ}M*Gv+r(%x@0N??tMm1oPWU$@=qkUes3~kmykRth>-j{lZI# z*?M9ZPje9~pxmt&;Q7V9$$o3~8>_g5FYtP#5En9Bg!@7l*T1%U4&-%%gVcYsH)wlq z*0G-dk^@gZ3i-L#Jq3~Nfr%mDX|3Jn9D*=h)T2-R#4#XvFXtxkr{pr;=}TR_LYI+0 zWESDksP^a;k~iWD2^TKGtG?#8lW8dBdGW>)4=B_!Kt;I*q?MVJ$&K4oxNQ1iOQ#*0dti4Y$`Z zFmq=@B)YEKNeOx)&K9&aN*9<0%HzhAUny!4PR7dBd=^biPgH1e1*$sDs_Na%L2olJ z3)tr5ib4`zx)6E&Pjd-uF9@KxY-l`~WE9@^I_k+? zP+#SW9l^fod`H6$3G)}@`%XaLb_o>0(@~Icx-p9qr<8O1g zcR%+sK08jGEuP=r%x^uvNbH^1ACy+7vzcFfTsjw;@_ivqz|iKi3Qc95nG1_vU20~q zz}@byPtCk+i7U@@;bZxr&@Z*w<}iL<##2=aC!A6ySzpw3@)$R zY?n8*xXW9%+T}`*OV7W|(U<{4LoMBZqy+}OmD%K5^(ZXbpsQ-_whg+@m2J@Vu55#D zc4ZrMn=9L(yIt7^-Q&v9pclH!XwZG`G8*)y?lKzm3U?U|`Z{+R4SKb^j0U~QT}Ff6 z%q4>!VRWgRJ7+J?<+T8A?tJs|oSeley=8e$iKHpLb$RYmO2av6NGKy8#xoO5({Ha0 zI%^2Q7j$;}77;J#T;N+kJTPZIUU4k~VbIw_v5jIdAhPY}wsICH7+7ItOM9OGp30U8 zox=kbf-kt@YVO@39FC4I1Ou9E-{SHG12zrF>s3kGEM_brqin+j(7(>qQDu;7X^u4;WJ=++150(uly zT+xGs6}O8xJ|h8kp;}g+u@Zt9jAHTlhL3LMk5I88S4bTIkCZLUKr9VGF4Jy{!QIBMsQEmW@X zv;7SU07Lv)%v>x*nYp;vW=-SD&F}cu-7@7hJr3~-k9oUTK^;7imqg$&>ym~ZUC^ce z2AKuul>qJKS2Zl)a%{&I2v@CRXIZJdV+*B;R#@lmRM!z?Yw_E6+gZ^j0s(suq;sX5@g4pR^N~~vauka;n+im{g$c52 zX@HGy9~a(^oYBU;@V-}j;SG8r>~vuo7Ydqqfm6`PmYnEiK!3*dlHn+(s!pKzIdwZ& zslSSp6^Grd3oQ7m^}H*8laNp&N&P!}YaE%f``|0oqnl49C7tMEuLhSH*)VX}TY)vf z%2z{?4Jq5i!)aK}<|x>4La8f|(N>u$6#lfO~DdVz5K z`Uy&*GfUAT!``E~vdvAp=JMV<@d=ia2U0=8joQ^{BPexK{{F#{q5!>%oF4jNhT#QM zgFsQ4gJWj|H#l`Q96Z3 z6sSaK&vGS@ZPbKzU0y}xy=RAABG`eEo&HEkWgPd30*eyMW#`@xuCen=!8HmPo%Ww5 zkT?RRgNwEFr%4)1ycn4W%6rqd@@h~PpugLI7eXx6!I0x7CLDd=${+kSAOG85^YJx* z&Bu1)^*=UdFAoX=!{CM<7Tv8?T6sP(Z$cmbodH{LgFHS_M-(PEs-XbSD%mgf1%%sP~p+S7fN@}E)`EH73WhF5jpY*C++VCAwvgcH8~x0YOrKM*dKhO zUmXunD)ZetaxcP=X3#md^UH#VS6Z{BYUAo(eYwU*v~9V@$1z{iay7zujhyaFU6_2i z60z|bi*{dv#3U;&urrm=1x2y{Pgt&PyZ;r-HT~Coe8gY#arxYal#4noh9I~e0a?}=Xi+j?JQes z%Y{SaoFq*cr}R7eo8{_@dt@s6tYV+E;Sx%YOkQvs0eDwnn5^TP5lq_y!O|%T`Dwp6 z)|F{^+R7tXLk9cUH&%G^UT$8nx9%m-FtL@SmWYn zSv?|*74u&((@uuK*fQ-ja=*+1W^GUIRn|7fW$kn0T-G8K``QZv`ZyHJ_)B{-{-OmL z|ICG|3;nQtiE>_a!=bj)<&ifHfiOCfaCwCB#V0%U{(~rD54hT%kQ$bthbcY z#XH8L*0L?Kha`sE-yoC-O@%*VE{L(>`On#jC#@3ckcz9KZFQlZmv_0ZJp7x}x0-1r z-`^m?+%@HPDn%TYEv<3ZzawcNxWvAW@q_3vOm)WN>cA;q00WYA>-flfcnRaBFVsCW_(ITWl))o)gFosS##xgEz51gq1w>X@-(~)KL=l;8!c|^Aol# z_ws^8wO%lTjoY7lP0!={ZX3TuIs1)g%MpgitjuuBaZe_URQJw1x%ik-p5nu9;r%l1 zl$!rwqG8NYBy{2=AYpO$p93k}#Xel?`ctp|yh$`IqG#e1kpr}%GL&||IQo>}%XV;a zTkjX$`V9vP<#E;*s}-suYBI}ppZq$aChT+&GAZeEU}H9GVZy`tL*7-9h?J~6Kk=Ju$kj0fQ3+Hptsr5 zS5t#IZENFXV7V>zNwzX>YLH)QRfj>x7{*_?V)a1$T{IGy$F{cS>MXOrv~D!}X@2TQ zd#B4LH}HRWSM!8$@|as1qi~t06eRCBvD0}R1XEx)ELT;xJp-0tzcdFZru$%5^FFY#1P8BB@8e4U4A;XDLBA-j4`Vp2xq{`W&#EjaSKDMUOK ziPyMzgL+t>Tqfpw9laKbr_n({A{MC`xEJ)?|FvFw{rjE2faslqW|}VzEL^5r%vX&g z*P&X|TunhW=U#dy)o-sc&4dm=6+cNFJ#3`%O(B-ksl?bOQAz95sf#@b>0F;A0MBKb zejiG)qa#-x61A8;#F`M=?yp&9YwaNgyE~!Jl0PLg+%&TE`Q{1o_O?9qO@AXYff^|KmS9L#Ec2tGhW>xj3sXTj- z9gX81{C}z!2d<~V;?OxoYDB*_Ow}hrM@NApa2M|j-=5Q~ZjxbPPGeVaVWUwmgO#Zv z{mQi!eg7`QtT`?EVDHgQ`b53h$n(PMcovSmpg1nNXPdR55wU%9MK()!YDA~)n;02Q zG9_1hn95kd6*njOSOa&!#T=7ocYJgcG6UaRoa~2=iUUHlqH}W2~O+CrxdK zD4YTfIJ3?hZlBF}?C`eN)0@$*)^&?N>b0(4^d9Cq)AU5N){A>h^hJ24k-4air!c#Z zV$&F_OP`oNX>G_EoKdBCf7;3EKP?R#B$I0!iwidlo%=yKR2f<`#Ym{v`s}$M5-y@o zi5I>&nz~|$^}ML2|E}!*p1&B^vyayscMNYvJkp<2@3^H=j*u-z%0b*HpT~_tmBU79 zkAtC$8`9J*n{KD9kZFGh(OsDJ zF8^m7w(T0$jOs+o0{hJ`3H7-l^ts&7LR02AmgKN2GDm|K1dItCjN`sY~9%pf%{UXX-K z8Ffa7<3zGtXpvYrW~B4o!w_C|?xL^imw#Tq+%w@D+$&RG&Esb`Rg$|v>2FjFvNddb zniLaU5UC|nF5ln~IXsn=KACJ~+68Q9&tlO+FQ2W~*3~6Heq~f1iv3@vtxRwM&Woqj zMD@7zn#i-Gkvy9k{Epu9w;6c4km5zJzNx+kF97xi7D(S2t{U%mdH&NUoEM2r9 z-61c!URC%6>o%AR70uQKD1hPn#d}qW)fk!xOXtE0`|^ofg@w14igl&pG%MPMlJYsF zT{^F4C>mCl>Bex%J+)w2LppU2^9)%UG-%*!^w3>q*laFWMuSc{_0I_AdUSJvPTbXr z>yqk|k2sFPGkDgBrMu9PRzUJO!0Xv#INAtNg12z2`@QmwoPlp7J-{dv39y8?^roIP z-}CujyZNnadk^vs?VNvJdT#5VQ@OJkVkY<;&ra&eG!?@z^sQ?V5r`&C*ClQgZ-eU) zk);1aTzJEshNz{)BbPoVgd3+r2}Yr}nPM~CV|?GuBCNT_^E-)zyms+S@sk;b?phMk z3ncawpN(it9rlWzb0LC@=O-71qh$6{*^(MJHJmiIMPiiI$@liH0_V;}^oo3+AYOB2 zQSdUsg}~z+;PDDf07#5vg2f9uf^&FK2KHCxRzE-2KMb0&f1>{)_O?dc`u}4z4qSFv z+QA&=0(T+k_Mgt(%d6h%`P^w;V}rJ}hddDJE#i$aiNNh^4)Zr>KId3)KTgm`t(G?@ zRHZ#!D5m-|GVRdJqMVy=3n|bEB*kn#)XC9~By-LUUATQNgciKr#exaP-oWL3Wm4 zH|s~QaMt&nng( zjL;~SIecwtMly#JNSyI=mWK^2NmwzrnkP}?o#mKR1 z=)QIgh8KFxosZY2n&>s9Pc^5S=(U$$T<=Eto*%x#Iz6*4II|}7ZDZv_Pf0g*yNG*< ztX|8N$=q(Kv4a{uS>XmDS=FG*wN+ zvB%smUtj1)YzYJM@fFyM;uN(Z+b;Eb!Ycoo&WsyDc~9Sx=&3osJCF+X-HXZB?~@jE z1RX!3)EE8E?sK1) z<;T0Ga&rdDJj%hqsF&&(j#-1m@cM*oy{)%7F|GT-c+e*{3F%nB-L+mdkcXk_PL?2_ z{41MmcSntxbS?TaMg$E5d?9P!OAwV%))un&lEa`T_^<&4;Y2A6Uhc|YI6I&P(%D9g)WeFmVsFE|MSXCJU{<}p0VnzZsVrT+Ii+^wl*Z+_E`E`VM zdx0!i64bdpV&OZkE36@Ud2g}Ow-9%QS$!767MXai|3G$|H|UZlCf=4CIUszgjP7GK z)%Mb6>$5}f6HOxwHzJ&VfZgC=WQI@?Oy~!p8l{Dz+Q(K+-@^2dZast~X86b+&7hb6 zl4&@&Et-b2AkuJT?^@_`f`8sR7Vlb>X*=fJ)@#8#5<2W0SfK_p*R$}Jl-1qULXGcz#0~m4QI=+snKL!Gc_?uss0Zb(?p0S1Kk|L9XECa3v0mC zRR114abk4w*l6AE_qc{WPWX%-zkh zn+==C3B?B74U99gy~??r9V?_#*F@{Hy}K_a$T$DGT2JaZH*SN84+Y;Y;MO(V*<b3sthabQ~-86Awhe092Zb#^bI6XMIRqIa*pM~SwECLMx8r~hLAE>_hLof zjPC{8G3Z&CvDl&Y_rRp`1`E2IeH~=US=>9ZxR+7MHv;G6{*d}td^n~cV|oCn!!D%h z1B2yI6n(G_p~(j8CM5)oESZynM!a*M$j(9&A)^SK{d8w0b%O6(c77sHhj8zQw&VG` zQd;(d9h5+X{IsoYy2&_4UduSs?Q}8By<*}=GyxJ?R^z~J0>HYB7SDLzrLC&nT zdBNap%wAq_XPth`UhMfBN?nauz|UTqltbK8`Ef)}geK$0|1E%6>bZIp%)vtg{bYPM zCavh-6o9h~koD9sW@PMiR2bGTC-1kaiTYGt!K58}^n+tN^j4FEev*Loco084d0#5R z@DHtOsaz5utrm302}=qZIQzhd&1dTUP9#8L#kh;xNxb`1MvIgN=}`-|5$T$!tq+rk z0llByf;f|noD58DjTs!0Wa-llrLT*t<%j|Uki1s%ZeouSW?vi2w5OD0+F>o{GZf|? zt0Vi4+VCs;I(da>)G?BIEoE07yp_GE!y0VEFZo*GPzYf1#>&5Nqp;7IyMqfKab5MhnKxF^h7;z zyQXhVW_Yh0C%AV%L}x_+WF?dB_QEAqy*;@*`@}taKYhD?lOK6DcL~H%prfZ%fqufd9_OLmmt@tQtQZhx3ZJFBoj1@$Uyjq zOt5k}54v)PHB|Mk3KsQ-CK;K2Ai_w6-Cg+sIjnS>`_c$Q7Q`#sI#3nWK%x+5LrA^IT)I;ffa%at4x{y+TLm$<0R!={2=DCtzXRjm2fII{> zw8&&iw=jYE3*+|HF*1arF;25(6R-}YIhmozNrmyYd(ZIQRaVS4_eZj>a9p6xxJf9wLDoTVY2sUhBI zRdaUIT8M_&^**wrk@ikQTtSm&0I}YRR+}=2RQ6J2KGjTuV+XD_i~5+^5wVm0Rx)x* zl!_~h@#DpWfENQx3g$y}01M>nQ%y5;xb}FglgF8L@?@-&Cz^HgbgYwXqVx1@9K(nJ zLFv5iR1=Pgl)luHY9bgIrH?F>Wpg2=uWP*WA=7UN(JB0zwf3mkTKlnj?wPgrlg*S2 zqMvD_WQgwqv?0CE!>GIXI|W`d9pxQ-Gpw zvh%q^Jj(k`Xsw-YEUuQxk62gnsn}eN`fyk8$rgf@T$by^CCDkE_p5%qx(uIz+5)`B?cwt1h*S-J%Cf3l`RepTC=yvf(sy+K$*a>aT zk+7o94m9!{iWjCg0T)@#O^N(};CCYbA2^=K{|BBY z^8bPBiTr=ydm{fIIPdcR(SQ)MX_W=E;wnT=nyjNIb8(~2yVf%ZE1F5>UdEt<@3-ja zca8eg}-WxGu)xgjls~%Y42iNV?57E;1lFuSUEV{juu4$To%LvbtEC%_{Y88*P+w3oOGephhQatk_J(qRpw^Jb$h z_p4exgPnMI93T}$&9u+=@{v32??(R2@jvr!VVkkv5?&@GURixuo6FV-6%v*sq#C1W zKf{5~C>qGM$ir+6OGH8#-BkRs^HRCSEywQxMa@`M_L;GBglw~NrpY$DKl(Bv&f#6} zdS!IvQ=6ihQV8{o|6P%?jDL+0w&7glZ7)CwM4VA{OCo>B@Mf!Js%q)9u@&AK(do#5 z1vAr}l;Lx@+##x;hAOb%z)pM@c~2nV=LB=km!y>wID-qjNB&+>mvC@M^~-M}w;lAk z*q*tmO#m=Uw+(=5F9IOI+MU;{Zp%%dbnl>l^2Y-cJPww2j|{z2n;h(GbkeSpFZIjS z+~!2*R0ci@NaV3XeC3hiHW|Ur`7b4JhEVySPf*N7LY7@5WOxH*2@5P1xYRzn@oub-Z=pbS6ixeCgSz@=!#X=pnVp_z~!J+;6iE>Hbu$7CFSh&kXVj(7?NGx2R z$`wRlxY5YR9|>(m4`(>tBdRPeS6kKl(@AAQv%Xv&%7jktvy`q-JZwcsWT2$4CPZW; z5#onBp+xu?bj|>hh5wEb3A5+9Q&IEjStQQL2pYCS@()Ey!cy9E=@Inm08RUosR>qOclaOFD{+ zzLo1(XjR!$Ojnh?Sq_hF{KB@5Q}ld-)hA7^CN3G-=A;v#{tU@9H>rwL|4j%s($3nv zd~SqWo{zrX)%vT{;LSWQ?xABUZI)Z*iKqhE1lvgB*~bew^(sr9_M)?7UEXF+2Amw- zDjK1I#Ue>+KvC2>NRhd0-4Y%o=tSSjwbq#d(SoQ!=PgJRI-OPII0`}0z1MX#%y&oD z8G*XX2v+mgMv!U!V=DJ46Or9eq>6oqryMr-nm7QGX}~phBe~znx2D>H8#Zgi&UzMP z2qMpkBpW4LWP)Tj2csnbY6E6I1{Ql}YVn1xKh-&_p~(vdKA)9x)=3GIXcA4S>;!PBKk?t+b zP+6+wZRBWeE#O~rkB#+6Hel|KYq7&<)`{ZD8i6N>b`xV-dQB^)*HmsV)rvlJSU{XE zH{gy2BE>)D?ay-o8m-EXN;yXqkKWDKwwgOD1|oVk41CLR=%;qzrmyO(ZQJRxS`8CZ z1OLv^rx2DA;N*@GTqD4h0c`}3QD;~6mV%;jW)4+%FFr@#6ZA-s6P!Iwl}e2&VdDUu zRq9b`wgEeR2SXe!e3CEIckpMla14K~Q_*IoU3fXXF%qV)+!ho@@l^bV@zru?*=k}h z-A1k9(cbsq2h$PUY2CkbIo-0l_)HpDLYJz7vKn!tIxvS$PKAM9YUU)|Gw)66*+a71)u5{4<>RwA?ZTX#XnRY zh0VHv^R{#tWN%jrwlwC{P`Z@9%l80`G-nTTxHapdj#hf7dj9OF`?v5SYXS`)x^kGa z$JaAYEeUEu0Inp+iZ{nI8{4b-I^kYzM|L5t*QstZ^2kNUsI5-63z!oe%(a@09_$<3 zph3_xLJU0Kx+8m#h%h)Gy0>X@)n##=Ozs`y?yM7C;ojR?rpYQKGDmSpU!t3qTG$nH zSD$sqNRmA${=2iMUG07n?#|;qkAVJ1Wwxpf2A5NfJDSCX%>rIxcj<{uM72R#M*Mxv zA7k0D(Ln$1Oz1e^W_@sfahZ+7y@hH5-9*ONl!wq!V#bIUu#j!Ut)@emv`nwb8v8^5!}F#a+M7R zAceanjfg86eneov5vQss5Rl?VJTdYhCmM?D%O=$MJ;>F?-%(OyjG>si5}iO?w#9*# z-4w-w>HN#SKSdZ1W{#kzbFT_=Q*E_!L^mA!!cX zTJ4Sj3OfHTapF#Oug&wn(Cqo2N3Qwk{9J3b`Lx)1E1eoM;vX{hWmOgTBwY1|((ys+ z$eIkrNm`SU%^(pZgBKiRYVCcS$foF#lcBPoHcE_tfgS#l2Nenff=-!%HVYRzZ2{~X zD^uq}7GY!={n&#N1P{OYfsnRZ6W@}bQ*6%qYCJu$BryBGsJGvvoAkDJr+RA>5xN3a zA}6o*JRU8gtJtMcnxEs98!>by<8>lVG3Xz38ehEC|Cqy_(cVLJ5(>`+#G}={Q_M@D z0~Z0j6qSlZVFi=a{m?-_b-)_ZJ^$a$M3umn!%37kB&H zqWU&a-<+`n9A9CXk^~`EkROZpvC;EqC~lpTIHWVRK#)Nl5J7YRyXwQK{)2Z3`Pcpw z%+mVMG-T=a<7}_;G^oJhz4>O5i_*dHc*=`xY&|oGI<%fkHZ!wbk+2N~pXJj0ruu&l z@3v|>YN(P2W77MEp%&0q8#Azg*@fGA&mxu;zNAis@_VVu-UF?=f20RHQynL-qC+P8 zqF1d`hF=mE4`32n6D9b4vWw7ob6cNCUHl@AGrltyMuTL6&uXZBHuVW7UrzxmnPHd9ygb_Pd=CbTt1iQo#(|}_0-k8HKG|iUDu`RZNk>b zmc$7P3^MU#RZ8D%v@$tUQ37YplN2U5PY<%3%$fjR+Z9bcab*x z;_va1U>j%5HsZY+#Cwob&ktw;@Cz}Y&$@~i*q9{U*E_g>&FqrYW~+$&*{&D6D+hL0 z>$cRzI&W6FF{S6;Ds1PM1`~}jM{6o3-u{6#$_O_o@%Ff7_T}=aNnQL;K%{cx%Dugv z#)tW}#XY72ZpB4owyFEh-*m0Xx5VbKINP{OS86{1@d@Soo=*~PCH;1Gg@6bMFd|N- zeL$8T1u+UOJ%1+|J5t1=<6mo%?W1qi8(YkbB=2%$@#{AY1Y0njbe(z z1T=OYxEeiThHx*THBc)i0RCbX)na1ce7YGCHgw!>Nbkze(3rcIrc_ZlX&{Uu@Hy%_<6 zb!xzvKS!{iv#@xd)2SYa1cX;V-D)vE`Pi&RM!{W!G?WA_V~XFrk`7J!=9?uC`akJ= zwfA1Hc9-*(HJNBGv>0_K>=PYv0EO@JLAeQK_+oWQ|H==%E*o0Gz4*+l|0J;OoE^-q z4d&HQoLis1g>_Dh8#f$;!&$ibFzu91lwS-EFy{FlMgL*LN>!k%Jz@Y5Mf6I#&n$N^ zwp-Y}Hr(k<9OZS$$e7$pP`ryq7w=*=y{PgJwpbQYUx5pV*h&73N6}o_i6JGpQ)ux+ znn^-?b3vNfZP?gI2b^d&787-1xI$X1ZN2aFIO7?L*4RG2{KCs}Y={oz3B?nYLKT(7 z$zj&-ZQMeyaE{u_=BPymBu?dC4_rg5UNRKXr5Y#y#)cx&^u^O;CRZ%of8K7rIu(V+;E{}}kE8nZ`oAiU~$7`+^;dv2f7qPRb z^241BguOD_!?9cz?MQ-tq%WBnV=n&_~+ixlQsT*UiFJz`B}fT zn!5a18wt~~#2c=;TMe_xq#A~6zAP-3KkB@i)@K*rZcbv7k(zM@SeUz@rYhC{R_Zr4 z#Hsh-=!I1AC%&mdd~Kaqv-ppNmoP5a3>W@HsWi!vjmr+UqjsVZ{IYDu%^u*)f>PGA zM}po)`ri~8zLgc12fMpy9{YxFw%X0u7OAH8<^E|x!3sk(nlV;|JzSuZ&D-G>HZ$~^mw;?6BFM*&q@+x|o*bj;ZcMpv$ zpRcKCWU(bva&X9PSzx;qgdsqJmrlis3mp1se`@}L+sb(a8rBW7gp^=7^ZBooEzsg8 z5Ez3+-O_q;J4n;Sw!J z?@C?#d3}1uu?xPsih-Z9Cc_5l(B{1|)%dq#J zrjFX6<)@vNk5U~9hMln6Z+rQgH=)J>)73RZ%*#Gk{7T0eCxk6v9^dF%;72Vym>zn8 z7B;5+q4dzBv@q1!^wSRigt!HyL8?U0J^&i+7hrC0qz7tshWz8aikNs}Mw zsqCf2$18z-EWq6~7*HY*be(daPOtz1WJ-0g!@qCn#l4$0`D=zA+q-E^y6L{LqenE3 z`}PUK%pR~wP^jz5*VLZw1MAgOyw;)YpX0v%Y4JbYq6K1tjzkmK-d0_Jt}dFNE(mfI zQ_Vd&MZ+Rn5G_-ryT2Bo<2t?ibYF0#uXks^6ZaLkc0=JJxcbG%ZEeFe>(Z%zUmq;$ zVS&`+S^QS;hP%y<3dyQ$yti-~=;a=@lpZx}_{C$;bcj`#sb&{;G;+w`^{QLNc*K_K z9i3TU-2u_9OSe9i{h3D`&gN=SvE~esUR%7@4iX_tcX9%o ze&HYOP%E_`SaotJ?#DBTfN-4V@9P1odD`Ei?eXI@w0b)$`nPLDE)>U23W9N?zeuB> zZKI#9(Km;q=Y;qu-L0p)bUiijai*+zKZ?9&BqU9z7-{-3Hl&W=gq}_;O9MHn^~70a zL9*O6#0+sAjmqTD7){&OOhjk+-AA(qtuoy%y{ew84gpD)p}K-+H6KgO_hmnb`$8AA zi0blfqnZ4k0}#(pk*5-~g7KNl}2SG?2DdI<@ z==t=}D5Pk6n$uWAPeO`@JDYY8l`!Rn4r~j0@iqG)C#hD3%aBcZfAtRo!vM zDPbd9GHhcTMde40Jf0qUg+@r~ygohjIE}3DY}(S{pAt8MD10(I+^SmDo(%m9v6JnI znUIy4WyF<;0@a!7`@Gg2=<*!i2s;r}b^5=(nqvzVP0`;Xj|4?i?DW^2j?^%HXrwN^ zN~co$5m1LlYSS?Bt5Yi0P^`I{w9eY=7#f+v<&?sYC0JbGncBWE_ZVQ6 zMm=j&N4PHLp7O$2p#Ho9P+#bX79ku&s}P_Hf;F44Z4)iF9ID{wRP(0-upy`NPI*yp z8kx4q^MAwCHEs8YnYX6lrWZMldn_9v$1X8GmD+E$8Udg+N0mVoNYT`i!yEri@IKrXjNfTL6cTN2!U>EH%2E!;&>W=8p$ zw4N$TRn6f(W6cO0%~jb;ikm}}pId!ji1EivnFQm@Rw0-_xB9LG;#WgI|JNWs3n3=U zpIG}`N9ush(F!=d!>@Oo74agu0=~lzXf%z{3XtRtY1A|-K>ur40oS{kv=#7u%C-VB z`I>uJH=H0F%1k}lt%B-s6-06rX4S23)$^lO|LgS74p#kEC}Vo)30D1v&ZcL_N)oIB zDq*S>EA4q*WoEro(?s@Z4&}om&=nI$&y9+(=Qptj>5@onp4vhrH}j z&TVA;7i@K;29}7E{mK|2^b)bC+23k{$I(5A_H6@qW#8+h3om~pTZT2pXvE6uO43G) z2Ep6)g-#frd%ev`V8a~^_EctAl)Cd9>N|Z-+pRAg?A8(F4y6t{=V@Z3Ul6-Y!7r+znpG;+R0!oHgheCl-m~0+`DkUi*UvH z1qoT?+jCnzjS5}FMUd-e?-Ut5zl1NJrxv~U!0AAB5d07B|FbVLVy%vD~V+r72rKklOPjfHcqE6IqdrmH}r#7@1CWY%Xt95#B zLKE&bakGO3=QQD8vY?zwCK=OKUphZ`l-V>5gsQwTb@7qUGV)ke#?_)+k^MylMfPry_zW~8sV=WY zZ=Mf5Ie86*nJR!EAu34q2*xSU1;MwZ^4*_tR6pZX)K34QG<3hCX;a!?lSWNVH?8Sx zx?ehUCOCHC-2ANjqUNPbTk{wYT=OcFnwLEEb@3DoSa?WhgRUGo&#HIKZ5?9#9C9&R zmnj*a)0A(XK+T?XQvc&>H%qDvk}$FP8UVwZ=|&X6kxiosRPl{TRXjDQ-Lt}3TmN?8 zU8mV~onm$?_DZbw_ym;ulThBw0ge)sb(Fifxq{N&jMCj2Y1SB*z?t>6kl7O76Vb(_ z+AH-HD^>>^ux;XPKV(I?4-?vY_;RT0&fW>-+@-#NEtD(g^~MHdk-RhI-yO&fej*FYjDf7qOYG! z4@GSgu!{^E_i;Q^)V4XIwr!Xd-y@{B*O`?!>9DJ2dV)PZHbu`;2PN<(QKNXP)U^w``C3bU$ zFK&|!gMVYU!aVLrdo1Q~dMqEO;fn{ir3ODr`MI?7m)u1K9SfJ2B1QPM{1jExf$*6p zH>(I^P0c*LO+^dDb9Q%^8`P0K>=J~*SuW`&`U9z#s#5*es!O@09z{6~1??SIPwB18 zZLId&J90}823vjupo8`{hBpgv+dOV-@2Kv5gL}M&$GWfS$mDOhk{(-x67wf=J3i*b z|8||K?5^sao~A$Z(St1*^t*AzK(ZTHuWs-l8T;*As!aOuTcCb|^(b?%PRWFueFLja z9Po%~L(q--g0P#8%(u6G7i~vaAHGF~Mz1iN7yQ+k{9$U8ns~=80Z%#5U6hS?DyTts z#(&YK-MZ|z&ksS_-cxAPlGB%Nv%_VZI8-#e4S&QDlnkLZ4vE#| z+rhCd+MLXs^SHBevd5Y5QP`oi4bd#AAhbhMsw@Zx(5zm{lKYPqmM*KFm7 z2Zj<)uH}iHT_}7fE?pUyz7m)EJnL2N%xbGPck4T|L95}bTO-b|3(N<=S zS3R#;Ye8Tt^zkR^==Ue+iL$w%iPdog&p3VpEm&U}9k?)0F8r7mvPqC=Quv9}-=}2m zfGjMwD+vFIm2jO_HamIV`4i2k5;QHS`RK9G9qrJ z+c(&BB@k-a79C=jH)97YXGVgg_S<=EZC-<4J-lQGB@`!SE<3S8vCneTa>MqiiU7~$ z>6<`2y&6XN<&c0fOe`p3RqLw#_A&gCQy_qosH=o#dMT4`WRU}!uf z^o@vVReBK0TX@8pHr?m8{VJnegpvDC{`i2&AHTcuYvER>`dM6EhD(uMe4?*(qM zyO_epAh(=vG@C8%B&>>umFBojbKJ};RkvtJHpgB5-X;jDB4HXU+DR|jQ{lABaG)(6 z#<4)FkBkNM?K&h`yfXquVhW507QbKNN%2zm%(u$oqfexhOf2Uc(r!vH?PDjx!xD^Boc|+%gKK=t4Yb{We;tiQZbs2?l=F5}Z6Z=I6 zXe&;9;oqzkw;X0v#@J{%>^}M9*H?Z#ahE2*_af26p;Da9024%`{mw@7lp5@0<0>gU zWr=;S(~oxYPAQI@_-aA5dJ%KybO&w3o&H82V}$K;7-sv_-ourmqs4qCq8Rd$h$=GM zkl#o&u3Z~ln8U`gk{jOUKc{@7OGdsdAqSrA1VLlg9ApUjvp=IEe-1T~`H|jnkn~Rv z$BUiOJERcsPr6BcRA`iBpgXo2RA_N`CRI`*rD0C2G#t}xJ1?GpOq;l!m(*b9mlTAg zr;EidyXH3%ZvNPNaL`UrGo|8vWJD%OlQ*5W3w$@l$%X~$S9r2RpjAZ35Lj=2eMMj? zvmGC>ZmVuVl^ZQ?tgOf-*ey7qsmtWb(ow@#_wtkdr9)p^rv};UTqTg}GgQ)*4mHV$vLVzSU$5iwfQyeS;X0rGIgIgH*{af|tF6MEjKonWa$4n4=F~K@9^+vl{+HpP!r7Q zO?Z`x;@DgoF{%8S%>)8yLfLl5c2oWLY8LENOyoK#VR4P_3a9t`rMWA<*M|6ZE{Gj? zn*tMX3QtmPZ7kKM2EL(>a(0f$UVr+2bdNP6ko6*v2iO2}FII!BZVg26Dc&^p#`ico z9Nu$d13?L7=eh7Z8@;AYUaO1UjS8_w3HFRQ7S5n&&NB0OYkS3gg;)PDF$P5@&)BYdD6R zzy~qd-lKEdpG*x%n6bKs?o(atUyI#_B4VVdxhM=ny*e~dqCk-xC}TY971js~Y1d$IHL_i}mSVxm!nLD= z+t*C5lP;ZQS5TTU7snC$c`-C-j1#7VyLan+q_1}A6? zaUJAV&<}6gk5#V8fgJVGtsl8t!DVtxY+bYX2rwUR_sIaa5D6dEZ+SCDGyRc> zYs8dsDSA>RWC?NUpDI7@YTb}Y&Dk2XlA~MXpP|x->lq6>rv>gevj+dhKc+2>8M|ckjTpKd^Q|8B3Ayj$HHs;jn7N6`y zC_LOrzEiJv@MSN(Q?GY$stc`4{-cg;MmKWXpXuEt(|SO|qSraq!ImKbi1JrxrOJXb zSaX@TY`vDUd!yzW5j!m1k*?@Y9)u#ElY33--xB~B8ji?M#>{i-nRb**LjUI~FIt-b z@bR-HCf<8$FsLQm5qwp&LmnkxQ?ELLnr|31g#pt&|L<&4)_Ti^jMmKhYDd%EY&){y z@8y>pMVj$dIN-0nX^s{RvU^p%rnn)2kg==zo3;%;KwH)1CDPpg0Bd>jnuZ|j=gk7EwCnm8Tg4giH}Nz7hO zcw?_-Qg2-KV+V56Fg3iuJ`rH-WI>1k@371<)By;X4_#S zdi?Ihe6(eP(@0cT7f-}Th|?00AF=ot{%@F|3t6FH$0$w`WKyOK~k;PJJa0k1WOwuijIAm$*|i_64#l^2o?64pexZd7yAqvrE?_C zq@Cae&faF0?B0_T(E2?434&H8e^VLuE-|3FO%E__oWTxxk)a8%$6M_}_^l+=?j+LF z9TPl`5WvtGeviEZpvCq|Ko*rv(c9XQy8ipC1^Qqq3DOdvZ7W@Y?z>bMK41_Ht?nb= z{O@6Px8wNC2vn zq1ox*Mrp)A-x1vY2W|zoZ|1Mz6m+TvFH75I4IKe=BlX?_?t&NUPbD#bfTCIYx+Vm<5YPS#ftY71B_iB1vhPzjC z!{P2H!QD*o_p>GJer~R;U?A_@JQ*akN!kP5Jzy!&rkVzEIi9Tew+hGnQl$>mLJ)ywq)U zg}bAY;Zf;i;=%+9nGc8N;3UJJbHE>Ex(&{O8l!(+q>+gTX6wlH)VjuHc^FFqoli#1 zK8?Ih3RWh|@%4of62&O=Bg1*D+vh*@+Vm0 z`m^hTBbm?Mvm#+^jBd7J0#Ju*{jSL$|E%)kk+X7!w&jaH0r#yEz8sf7iy@7pf3=`i z0(tuzwlj5({w*ruuS44yhn4I;cfl-NXn#Pd9GhjI8jH=Y)&yPLpRHKO(A9o~(+R@Z zRC%}&-8^9O$M2o|aq|R^L5kuXLi%B$;)SI9Zb@%j%|X^8oy5IeG^jC?cL~@+isw;_S~8Q>1sLm%EE~~J2H?&wA+{%iM`q^*%yUN)gW)5Xx&*? z(2jq474tV*{La{Fn|Hoig_bv8fIH-&6{7b!p*Mgw%vm|1H^2&ab)52VBvMbYz!Isa zSY(ORQ$6wq*vxmL_X|bEx9WmnoXjw|T)}0=zqa9OyM1lLb^3*AF1PD`!Vl|OT%o^V zwJRGl*r;;;Mq?k*V1YU0e_E&ia`E&er7uCa1YAa)0Io;qd$l;i|Js`_yYBR#EMfz2 zQyot6`yaC@PLe*+wulTSs0Ozak|0;zB?1Vwe5!X}?s=tqT+J_CIf8euR4B=ij*1ol zog+k{TDWYBIxaF)W`OB$c!1jnuC`H`A+%4g$-sGq+g#J{ABpT zH@@M_G=Xz%t2UQ|e_QwR=+tXumEctAd2@X$YSz?VVoA%b!!2ob!7b^SNv*1E3F&Bh z3c=xy>3m@Q2K}7$u+R{(PHriEJmg9)fFNRsr1Am;5m&fpas&hsg-*OFU%;koLj*F? z-*5S21cE~m2SKhr-t_#doRneqTyCmr%q3>nHC{G2E9XY*?7Pm+;yd#%f(R@<4C*ER z@kjVnm{H&nD@sEyNOB18>U>)`$T2$`;CmR>KwhWX`I%*WU+3~$4!o~?OXClz{*Tyn zIYifv#)&3Zd^mAewrZE0_L-5++nnwC-Fl9x4d;*E((x6>945gDX_K8D_3~^Wdp>b! zFN`SeD-+Bh@?nF{1l4QN^9^Lpf_G>r?96j~k=Ug;560`V)89^VdgltpckalH40+97 z^>ZQ?vw$2+ySc0Nx99Dz#OzHEs9ID7JZasY(laA3k#L=tUZ=b~1B*o$SDD|IfJKy= zH|rV5?^1bVCdH!I05W);N7OK=^t&qR6Z?{@~et4{*4&h8=$#hHEd=5k&S}N#->@OPO2(i3p}}AykNh=*m;H?2K{Kjq74OC?|94h# z_Lgz0*n_QT0Sie=3)2fOiO5vw&G!Lp2SbFa@QS;w)vIj zn%ugyzPDA70G@L7?fr)NT%q!YZoVVC;Sa^hht@L>UR)^Xyn&Zry3o2;{E_=v9b1`S z%`j@iTau7gV^ymb66*QCFTN`xSMNfutfUn&9)qXGzyb}D!#MnxhdGYM8)X)7(VYYkO&~cL*5+y|?TS8V;H~Ga! zL!x92m+}5Y#Szyx40r>}(cti0mt`bZ4?jM#_Mlfrjn!{W4Yk*>37Hyr!B~Yspzcyr z^29LyWOtt#x$u2>%mb&*H`vy2s{e;TiHR4$b})m5jrOARPx}{@@#yXFhKHEkFjScT zn`eLIJ^u?Y|M}6|_Ty_#GK`Eaw3bv$GhOn6lR(IavxlTtvF|-vSY(y{+(w%}ctA4~ ze){CdI`?Uju&^iSquxD&sp-~rss0AOT!i242|dM;u%7*?=axTmf3O{-c=8VUe1>!P zpDbH^0eHo-#kD3|NX95pr4Zqq2E3S6$SzOyYTn*`t+&;UkT6sj1%OtGsg*W z20q*MV*S5FT6C|f7qd4GC%0a&4x=FT0cANvm}9(r>%dX+O(P(g8<~kyBOidVYnZ(2 zcu8retak!eiBLCwWP0V*>^xJf!s1sTUFwFr>Pub~&H*3F^>`$eSdV9u_ZaP}c=>aP zfh)V7=p6B{tg4W@MTF&>l}&Qd1au1acp@he7Uv_<4UYtVE1 zj4#MdDdssmj(g|mr+x4zgS7i#WFF{1uwdl!uNW4#MRNm1JdEBgum*&G?-Bkz zS|Y9^1f!jVxSo(qc0%HJTiKB3Ub%6yvzzvR)`39Rf_H(?Z?iqehfx8XQ{41=4|n|<~F~?v5n3R>Ji^$-|qz{s-usXAa%ZIYJ#+t(=|ctU1!B~ZT`Do zAvERZ7MM`F)Tr^(cP@-@Qp;8rf~-0*++NFl{VuTI{L(rv_vCi}fu`+wZ(&(9_YVJ^ z!|e)NrIDoi+o)GZo^~Oo+-wy-!ZE3%8&x`G`>uJ7 zoC`!1meY;S91;?Csg&PWO(5g!XkjM#qV8RLhM``e55h{Q9atmiwOkhj%pr=8@yKCn zS@bB6dw86Eys&`h!|k)xBal$eS>Ojfs46@x`W#Z+D|eY-iJ!Ef@Vmr&D=NPSJ}p30 z1(y~SEHhJB?RP7`E=d&3atA)?yj#q|s=_sD%n2W-4#qO8das3i|9)a*s7|AW9YQal zC_986J$1+{qlHWOIn7kRT6uz=&|qis>3ET!9SS*%`n<*OQZ;TP<9^K0KhX@lID|d3SCPoQp zY)DraqCPXyMho)BoDKCn7_RT8qnZ9|Hms0Ke;=5T>btxAENY z5~vmK# zTtJhgxW;ZQ0!L#cUQ~P)8O2E()1$XhkV#>5S6Hd_-zpt>^7%x4iVNGlvXLo(!DF!D zh!*jXYZ^rMB_x1mbWmylc0IfVy?oROlUE2KKva*>?vdSvj&`3=Qqm@>9zZ0j zk1O;3HkHM|*lsiXT06HBV~<<-`h+bcoTek$E9t1`P(&L%ccuF8qDhV!ra8k(KWLtg|3a;#60hlnWkYh=D3eQ2FH`;6NbuPAGS+hiufT-ixXzkN*)tpN3M%Ue zvK=x5?%OZfi~Nlycv*@^mi?u?G1B)Q>4o!X6XBPYxtyEbqc_^V06!uu4of@ztsTk+ zm_@UEX5=fJ(_$5Z0`<~kJLrX@KY1h;&3CxNKr^Zl;$@GGrlkf>;C193yw%;AMbBT_ zO(47Z!|lCdj_GY1kbNY(jQsq2W=ZW=B-3>6iCUcK^=*Es+q6s%?kWOiBe@w#&_j-? zyF*>D<^Tq=Z`o!F7VX4lN^{v}3KnfAVelQB-a1;jm8!TpUy06F#UjK)jV}^k8o!?q zU#@cE3sgaU(rcUan~-`Q2(PaUpKlJYuMV%(aSj02>sz(1!@w$Ucjac4ohZ}UqOv5J zptFsVIz$@JRR8+{k-%~tpBNli#kG=C!~p}ONxKPePMC-%x3|l~-8Fl{IetvqX;ZWX`t93}^OY znj1%GQv)Jg6^U($pnAcL4SiIufgWJ#*TX7rp~~VvCth@RxgTC2v|c~h-W&JiE4)cW znJkCnvTQ*EUU}6;;-Pueqw^Pz(ao5%NiTBXeTdI1qU)~v|JR`F7rs*gUFmNKf4Af# z#IQu4*%J(_US_HbUjdi`jU>L2CL-==32T~5YIOt}zQq&{u>pVLPfixxuM1^`Mrw>y zlCm@S$|GIzT;Lcy{2WqVVh$6N{bBN~clv)W$dqi@UQ+Pgv6vAr^1aoQassa5=#ay< zv>klm1Y7#fMsA+k73``dCsc--Pv(AOlm}XKT!XgN!mYDDRSZ{cQzZhLVv|Dnu5Hlf ze#So)p9yT~-Q)m>fT*N)YVOpo_wAj11BP@hmr8QQf8hw`|BXg)oNc?T&}hB*AXW@* zt-PCf76v{c;a=`b-N<_vaqn+175G3gDVhg!jdIga2M2LGE-N{$;9S+kpO7XWv7_2DG8buT8swlIsq3c6hec5biWG*Y(YAPv${) zbzeLXo3aHEgR&``&kgfuffrF^G1&)VK~K})&{hnMy|H04*BHLMk?Rq!-3cIfCg{mK zurS4J{6BY#`m}EuP3%)&!Yyji^38S~vhpMg13O9^Ugi_m?&Yrv-+yFeCd5Yz`11^@ zNLZssMh?O{?wl0`nv$~c4s%o#{A_b^DxK|%5xgT%8}cSa{W^-#o_yCXXL%_kg$fRL_?3^t1Ntz**L;Czjj(K;5Glc^)3%%?Dc==I%Bx2X0#?OaB@y@0g8r$j*7Z+i;er0C zEcT;+h2P8U5yAWEw^_CR6f?E6vn!kNPS0uyhxeA@C|*rgbV6xCC&k4%qEFr) zesVdV2T13D{}h$~+mjzV zhHNzWzd|sYU;Bj89ZIiiCp%~UQ5Q|{hI`zgeoRUoz6q|jEb;=8{ND$@Vz`IT-ZUdsV ze^`S`H5_9NW;ICsuZ52_M-eG!Co0JgO3Z?{c&U!z$Ta;Qi`$89nQkhgUjWjV0V*F3t+}4&({e*z$sefOC7jAyf9A0C^ zd!jv`@6WEd=c5?VEquo@@Gb_>?d3l@U1^=D`xUk5HEkz))=)Zi^AvJlx_SxNOvu=~ zvqcBd=%lO}W!z{w!qJSe#^ko3l*YyYHghD0V?}=#HgHBt%ux?ZK+=%jqbXN6l7@8Q zuZiLWca=k~sr82k#J>a)CC=R_socM2zVMtK4lJ4YIJ`$!Nc{tIDP(+tc6RbodoBCC zwZfL+b}cPrvvzGYX|Ji-Z*Sx0V4|C<8e(8&-bhc{=ii|hyjBuVcMeenmTwqV_%tU} zEj`19=QuW9NE+4uq#jf=zB9>Z^b_P&B#zVl_SrVGk@(&^lDZgQohpn*`5E__FMqyf zV^=VDb};K}wnrdmvSlx7ouvj>t4f_8(ob7$_*)nL&JKU;!{2axZO!3zOZeNSU+F_X zphwHQ+rXQGj=GqRbf3wbyX%$PCd->AAxke6zO4_2+pQCYdQ}r{T~B{gMGTA{?^gM- zi$vn~=^`L?U|g&1Xx*H;cz-~}MAjb}9JV3@`b_26QvW~Fjjm-c@8BnlS&Q7JzFAQD zoQQ9F*{FlyPq~Q0G7WczAnXi5*cpPbv!2)VUI@ZY17TNg0}d~EjxMDao_|tR$MVx^ zJC+esJ|I0jAbO>#*GR;H!;$P|tY>yYgH(jqFp_YwWPppQKa3eNjp@^9(zMjTL-v*JE92{H-*iQpS2g51i@k>TSUmJFT5~Rn02|v@ z*Y7zg`fr&0@$lr2H%|We7n48!RprMqav7%FCo2+i1VHRqS&2@%me>TQ!k@#xBr z)4`kk2fBj8HgpmwUF$KP#N1l*jt~O0KCt*VuFG*?A+4-<@P|%3_&3|&|Bq_X*%PA) zo!v+%a=njX5Pr|t)8KMEj^ClNzrO6Ub$#~Ku)+u)Rh8*p^tgKR$5SSM zJgxHMGN`=8w%(TwYdKkGZCvW5n|Mw2d1E2h`oMV$@D|GN`47diNln4bF!dzFdPTmY=^qXB)R;5mS?7e*L2N zmn2tM1thnvULI?V={Ja(*;-;1I4UN_?w(|yD6Y({G+~faNj4lICGPAiCFDiyr1%H7 zxSR~VY|EAOD?vz|F-|fkvd-K2&hdqWR6qRc=3iva)K5BV$SQQ(W~v~9)akyR35v7| zlt5>NZ>A*urzs=-Ps@x3kt#i+^CD;Kyq4lM6Qa^#x7i|l8_f=B9S^xjYM_tH&<;r{ zR0|XBIi<6Q_D)oLC$gVWYOhD_VQ9X#LDhKqK&Ywad&afhZ!FFArl8Psp)E{t25mkg ztclKJ^7A2YoxD$BSLdHVVUj~yJ|OEZPzB|#2)jm3-ILcYpv zgqfwBDwTW!_T>hBa%n9N(f$KBuS7z9;qGp~VLb zF4!|3R6L+4S^w|9|$r1wN|kT0cVq1V}wWqejIVb!rpE7Asn!STiz#Gj*b|pyIRKswq`kQ<(v( zRD)-RaC#W)y;2|5-fOG9e{Zo>tK}gG39kTJ8+>Bx1M$I(gMy+EQOW=N);{~pnPh_6 z+Q;oJKh5m3-+S$~)?Rz=)<)5&*Lfq_u=& zAY$*q)|m+F?g%L<4#R1U^z&pWLyXy#_zc<4i+CCdz;`;h4-AL20~RITqO#M;h1iBq zkUIut!_bn>S~UX+8n=Be2QE0IpfDo9(QSaA3pDh1v~~(!sca3d0O*+d6XCGrIt;`pA}_F$+Noy3$i9%y zT_Bs9(B?IlQs^05y0eZx7-SO&D_+J@C~oFU2{EtV$tymjIv|Gnrzi+fjfHEu`TL$o z@z_RZ;xMl_YmED1!70F5EK}Mv8`VtN9tn&cg+LT)n<>;9RoQ_IbV>5|PIWkUwqUo1 z?LBJ0lsAKHG04#TUygCuK z(gEaa%RDO0FH?h&$loQ8=r`C2BgxF?Sd9? z{SDmWz|&duQ_v!II|y?oau;R)9SG|!oEXh;HgB&uWh13hQ&&P@eDh_bRP$Wa<$q9fE}V9- zs>2n^Ff2$D_PkZ(4V<)t(M(-UJE$fmG}KtJb49<{Q5+xQns=@!fyupf?J#V|7l5Xk zLbYcMn_Au!vdjJn4jY%FZUgw+`dc-t--f)csVbkYT44a1=vrS)5g?|aOaZyCo4xh;Jj?5I4)*a34j~R2dEM$6g{q!~Re=tTk z26QKCB>?%ogWZ^QY4&zvj()9!r_wNPTX!qOUnY86JazM;!CmJ zna|A;C+1B`{+jT8j59MGWdR(c^&2R|)haVd3UjX2iA&xIpMQa$DDUK% zc14g2JlJ*51>VFO%dJXx3?A+O!21yJhyxJ-ncd}`iwg8?)9c_YD1F_vgge%Lyoe&S zeH#c(gc+IcFyskbKUkAlD7dD$=OL8^*K5r@hV4E1_`N5OES!w~gIK{AvDFjB6BJ9) zRM{v(cQjtKg8nW2`cB$c0k7u4o%%LoUR&vk*gycFqA2!5lpk%cEWQwz#_&IVSJ=QW z;@~XeS?vdg^#B9*M>Q|N-Ac$9`=49D{4c$M zQJr+?Z0S(e0@01;&Z$moc3H9BzGdh>j}LEG#lM1nOg+|qk(>uEJe1CpsztYL=t1|? zyr>f-Qiit(lLJ}_Z|6QtWQKcYVk06m8jFKOMzQbg67a%ETm|&Q^Bi1Sj07L%GI zcC=GhVQnf0GE^+$dv_1B&@P$()ew(j^Mq_O^t7vn?JeDSUhI9zoxTJ&0>s$>Y;dm?)7=ph@*{f9mA| zh8Ol4AaZzm8jrUCY;wQzeLzhh6V(XO0gr;E(rn?D%^$R zMNXZ2x!7J2t;NONOvD)Xhp1B)Bw__U!SW+KZ|mx`xQ{#obpo)hHj(QEuArBQ-COcUEv-ses_d)z>-Tp^Dch)7jgV zo#M}NH7fffZ+c|A2Dy1{)L!{WHR=H$ilZ_RFkV`*Uk*9trsLkib4r4CF?&b#cYRTu zdpan-6+4ub;ErFRi8>#)?>bzJlJfVK1wFux4rATTyC%Hn&W~k(!*2UF+M1W z8h@ozpkAc9_xUkmXnryj&Jr<-QR+y(OdWOB$#%|zi>LE40gw_G-&7ks*4%@E3S#1o zyZmEKVjchG9cwlt(mU3qf%Iz0k<-!tu-dPnmtKG@{|&68w0}Gf?N5CX9Y>ZU)F5gn zjDS~9sB_Y%=5iVey@d%x#GoVza|}tTI~58pPm^NbD;IPwUsEaHw+*G zfU6G2QmKs=e1-&{0ukU~XcRcD4+|2(YD91W2O@9}6|vus;1Or{IEeE&B9yuso2i*gN7^u1Z7VTryW;Nw2?n?> zA926Eh6|O}36{Wv6-Le3$C)}lb}K}^35#GQqh#XUVS<;N&*U0aPqI=%~MrWEC-u7zl+3`ntX976k>iI~li zYBr~Uk|%3Qc4;4Y^D*jcYc)^@TPps6zSYxXYpFYXn?i^GP(P0PN#r31P3BVYjFC}Zdl!2&K8#1?s3_X1)I{Vfc=1RGau z&0!!?$G}A3#{jquzlWgn;(==@ay zO9HatZwcNY?zt{N!Z3#JC#wP0g$uYYTuOQ360Qrd1U80V(R*FMJ_&BcxG?DDSk|Dw zXj%BD6C3_2%Yrr)m_xBab_-fO5M(IFUmU{qK#3VjQ1FSNKn7$J#6Xe462pa*FAwqX zftaE2ftW!L1w*G&zNB}8q40tXkzocz2B5}JB~r4BuCSKF4xe;WP^^3rh5iz;^1o4D ziIsN~LcPUGb*cQjdQ<(Ei;t*KiA$dK+zC)Z<;hGwGllGvAw1Xyd%#EC-<9s~5)Vd{ zH9vcK;(t5hcpR`G+N}Kx(dPfUwD~XW@H@Wwm-LY@efXHRUURS+h0+5$xsThD;^+an zaCQ*3H@n+iEE=EvZq%<{$5tOY#ymzrJ*qfB5=H^r>U;$!1y26UQ*d&JqW7fHl)YS>oV7VH2fFn3%s#L) znG+2j?%ez?l!r)%j*inev`FKwi4z25HSIf*T zO?$Tw@e}g&#&K;C7*1Cp6}LKh2?-L$0B5$0jfz!3g$~i=8Tp9}xTEc-NBeaOe{#z3 z4GMpvI69xgpD2#LRfiBCVHkROBSLi0IrOSY2+=v`(5ssfN(5Wbx-s;6{@{DA+$}eT z{zw$8P)Oc`c)+kkDf)((b|;jQ98V8$;#8-HA9dV`kOL|KJLwRFPbn0xFStR;JIjII z`_F_C`po(NCx(bpEt*s<7RDN2$ta?)ckTEzm$*)IY3nqXv`(u+E@V5cn!kV?RQATu z(}*vyMKOkco%jOVS7Ycmh%XlsU(P4KTuOZT7V$+H{~AMo)uL)pPr(>Nf7=6J2H@bQ z0IIl0YT%)~NaLdiUWt%+ z$^@UO;%OmXT;u2eQ=cQT?IV{Ry-MB~QwuWf(B1X8*-W{|OEVZkcEz~x3ahL3r+-$w zEF$*kdT#Nq;anjN;6Rx$Fe5pTebcX3dItp~jx21!;+!gVWxh@(tlP?*E?@hZ_IS)W zh!1CFIGx_qWd=HloA#E_BGThx{=s52B6m835h)vcSbk_5`$o`jBXUB4dE_AFC$xZpAO?`EK!+LjNjv zstDzfnJ!lDR}l}1y9s((X;Tr(%^Mx9bRxpq4X5)oopF2bdeTD#jcJndhNJ^ta5^jv zI6u}3fNC>9wH{ZU;Sh#cb~ZNNuqJT3jm~ZI*T)YJAVAsJP+B-FTQfnQ8SDzFg1=+my9uz=Sm{F%0iQ52$>`D4y>v-HcDd6`VlE1||P~KAI zEh*nG#uHKrI~L6Yc2VXV0WbDSrS(6=?x^s!3=zAfpgaESddzHsBY(=^7d&@Z_wmaHEbIHHe{ zd2j#OAE`ETZ!h4H?(eKjW8C&Su{tt$y-mgn35~PcOWFfL823GGw!cwqF8jl-@vr>y z_El9}taiPQxDwNTMq6U}DxpArnCUDhgO^JYj8M;YV`5}i=3191FywYUv$oE`O66PX z62TdW;I;>-e>H63AsPDctYbD8GO09mt?N1JZSfpcig>;4ksB}<$W&i>Fr6iJVlKc_ zzJ=|}-Qvg}AD35=j<>6nt45H9i_m|hTwO={Emt4sH?o2%_3^Dqtbjr=D`;i~b?W1{ zE$9^MXjI=1-zeWpgOl(L&cbNhqU?$fdf~LK?f4+mVGh%VS19#4S$%Sx(bQdw7z+!k zYQz#vE`=9y7UGCdh;C3|xa&Snuw)ZIxyT%h!8@&!P#6rO46#^X5aO7ur4oVl=O|nU zKvj(7YI6iW(JNMg*dqQi`hNDnw$k`UL#)fiutabzIx%Z$umW+kh+f1$#@K{JG@-f2 zkRGvLFu{qL6^4HLnB28lzZS7*s}vQGAI`^^vBdHd2}NR$70JDVnY%*)=yMfJ1e=i+ zAF>e64YsH+iu^TrgAHGHk89H7ZTVf7VgoZd(f<9y^DkZuG7`tD}6CquLfPB zpL~_TwzdKwl(w9E1uc?qE-K|*hhf0{l7PmzZ?*ZIwkI3DRc^MYk5UCpYYFEHQ2#!r zro(z3mGB=u61qW5jL9tV8OY3;EQ)u?IrlXg{!9hntQv*^&|uAnFN3>J`%M+ zG}~eRlCVpoAug<)oMN~}!w)c;7*4W5!t;p1SGoGS6kja1oyC%EupXQDF51FnM^@6p zR2!~L-CSL6<#SXWBs%1ptiCGM*A#rM!5rczfZreRm+WDqw9p;Hdnq>wj{rwu|7G%k zTXLW09&~k$MRY)!94mPYP6aae)3bm}GJ3{uCvW0}lhA+xcdeCg2ut|pxQh6TK9bHb zz8Dk;bER1jp&~vN5?zej;o7wy0Yv7w}TqDeSSSNe7;BOahX$try1=}LS)2!D z0Pa;KFrx$4SmX?W%r7ulg}j;P8H7K(4$hq;>_@{Z)28Bx3koD^!oBo&q#9s;cV3-yL%&iyy;$k*U-K|L=mr;YS7!xq7M*D$t?@}*n!*v%*>Zt5OG`^w}{ga z;uaD2pT+MyxAX7i-G3&5%G9UwJ)aRtJRt@fo@U;~y&Nv1T_^C@pk`b~xa^2f%ZJ@Y z@>YCC?fI;Y@_w^eRR0{2Y&+S;0JdeOE%K{VUqOUlidb93T&KR$wy4^3>WA6Z3}Uf%ftOlDZ=@hZ_JxpBU&g*2&Awp+>u!JfOe8)>g`K;a5d;oT#*fSto{WhN z?y%T6|G69FLw+Y4?n59nXj3%*gTp2fH{MoEk1 zc>7pyXcg!azhX3)8sX$yA1M|ohw4NK|N5xQ*Bc97xQODG`2&z!`fx`oWzyf41sng=WRld`usj)I|bf#&3U{3qMHFxaSh-lf4w z*mh6Ch#`VLcn<~!1-@CVt`2e!-WYW+4+wB#`wGQr%E~<5qXXDd0B{7lGh#VW%B5~x ztb>v|YNj6KqRx85YI6Bza?FrQwe^4Y4lX}c%!j(#SQqy5x>i*oKAAyn>4mW)rkX`C z%^OifRCFT{LBV~Kig?JCO4Pdr$g$LwO4QQ@Qe=`_q?~m*7O~K2p%{pIEAb)Qe0CS- zEhB&sF0|$#hP`H2aQu=Rn~@ZcO?n`CKv82bZP)~}wbX-Ms8EkRS4F(eRS)o;Bxh!D zqyhoR1$Sp|Dg|A*ow!jtfj6IWWsL-$PV9EU>mt;TIcLxfkauZtWsU{8x_;*adQ~OY z)lLUwt1jFvVn5|$hGEfHx)!nGwP%cbt0i_Ix+Oi~Ge=msT$evbDhE`!DGirB+5v%- ztPVktX~uXUl%QUZ^y0%rQ7$UW&_yuuM8zJmJS9!&WvH}vp~$^T#fbV-C9VsQ?YQ=i zEy2=(1hRslw***QtGN{E!o#uDJYiI?H>y`i#wOz#++h(7!LS|1wGxIxV3=v)DVn{v z;V+t1%aE_3zo?hTfoboL85bP}^b-HTUHu0IC{!KxdRXUEU>(pwP;xaz5E#PXIs`!@ z4CatS&so&PtVj(mm#s0|Ung>XRVdhA(*wT>6#ugj^Ee_Vrd`&Nzc+T;&-5PU3FQ1m zpOyxtkWv@9*Gxn_ED?&M!j3m~sOn&Y(862GN#g-y_9lD-9LM5^BFpfg@@glS%(Byw zf`a%9+d}+>GtV4}fR3T>3)+9gJUq?f%GDa@u)oJ3K(dHDfaZIL^FA>})7I;;#ffoas`Df-?&s-U7z4JG?~ z_jh$47hmz95_`|12`bI8$WG#Yy*eH-PxkR?D7wojv^xEeFg)Z?+8So2{)=lEuk=;v zB^~iN!hA_Ug)mg2Kcft1S|30P<%`Z_*}okPH`6$X04zjqG`^Ia3raD5^bs-`NxIrc z)Qyb#=?Y`P6N^Yj*zBTAl;!_Nl^;o&9vMr}fbr9|hb3423f#Xc3m89Had_vPaPV{| zNx>B*s}avz;6F$1ynC3HNSp{MrWB3f%^m(VQ%Nq2yphwGp}%$~Nf{NN#FTfWaGE=OD6r0&8g3lwA4+K( zXe#65WQt-{_6j%_c{XIX$%T5iw8E zEQqO~dxuGQ^Oe7odFHH`NlrfdJ`NJ^0ekW7iRc(%7}#Bw)J$I|=R>L#Hjr#* zySoAJF_5<4k_VoyUP>>9(n5F9lf`f7Jxe!00daM^p2uFV_1&)0t15 zG5qbuM(QI1C%FjiU`H(};HGTSRUt8$D-(ZG*P|84qeOx1)`XpKuhp+FJ+hgaPtdrK zWHYXU8kg5C9x=J@iOPJQN&%&xQh8LEC*G_w`;dkkUgK3$l4nG~ zNWwTTvXaChDqE>Tgb8-3$0g@lW`i58HoKK%3Lb7PSH@1bHrK&rQ1yr<5y90%_32IN zlh!^BcBDAZDZRdG^D<9xkmmD>?IjE6elN*tJbTZ>DsV$$+dAXRYo`w8AY0`$HLnZk zIaND(J>LgMZ}aFntF@IX9m(%CxDO$g-ZK(PNdmcL=E9!xm@Sa^BcF zpQM_7+baYW8)H^3B8_{odffToSIO?Ctj0e({_Rw+ofw7VK6Y(cNXG>(_RgBIwtCVc!3P2(ymZ?_B(JHYJRcPtRgsGZ{m`x$$dyfIGN^_lEEd3WCnLY^& zIw+oXVzIjkjp>%*+6CJW2sIL?#4h?YsDNstCviR`qN!_|Czd%;TkTN&u#f@CAL)0M zjG8hAJd{o zNPB~WkFX1L`ZK6PGp;|s6aT6~^FA1*DjTl8)dYV}FoQh%gN=x~VlVx``p}O5*Ajh? zvVY8d5mrOHRqO8Uh1}>M%Cv9c{s^HS47+0mw?RVd`Afs`BB;C#>`8*eGVe#aPx!>BjRns+E1=%L9_vTM9b zJ*V5b+y8Dq&D6+h-)ozS8>t5JZ;pR-H>h>zfTR19gI1dgMW ztt(VY+SV02_%QWSP~kXZg7_KjjH$*?oik=6eoSZlaGojQWMN3iNz%lMv3M<0Yzj}q z^C7`7ZDB|Io&3l)SwP~Rv$g}0XlFEqu_K+l84urq9*=VFF%vIzgqC72-z`ohWlqR}^Aw%vOb)Sp zsHYC&j%y1$O(R0qWAHDxkW+=$mh+faDl_dQx9uWcABIR^)|eTt2Oo#Cr=0jW)~yIj zu4fql0#rf^LA;=zMEQ!30tc$}`x2&ub%m(ui~;|LdWg@bTxvqMi;oeA9mN2YQ)B8F z03O3BI|9JXF^vo~B7jN7oH=7A;b#(*XY6Xkd1NCx8io5ov<|nPtDr)jD7_$ADh&bE zFFc9#O*b`;>SUVm(lbuWEmU5aIRP-%l^BWR2=OoC&zdAP907o3yquf2phf@3T+9Vn&SHKQNnM31aYNIxV#>X|2v>7x$#y9g6ev_);_7?oI!tLt&F6!G@XAyeJ zdp*tgmcR@NIBL#3b*UIefb_Pdr_&6D5HS*O0I{GUBFNNCtFR`}-19S1nbe!Y>yOr! zF0KUhvF`4-tDEK_8H94zi&Outme`N__iN80ed5Ap$ct zsRSA`d`44`C~V*3$98C9EoKr_zL%vOJXg*Lg;p+3(GO%2X46pBLJO!>FPJyzNNHzz zKRSx9DBl;ID+k*6nm`*UZ&G1D;G0sI5afiw6 z_2zBqG4w*pdx`Pz8cVR9)WbRRQO_@sUp)rE8TM0;()($0%=S(1U;OT^@i8M^B!2twVH2c)T?2$ z<9dx}baEa6j>WzvlB_d!vT0v`t02tSW(4nK(E6IV9K^eE1>RqLWfvR;xbH9KB)2>c zu7K@1^GgIx0NFMA9)KVy21ef@c}l3kUey5Ctm+C3Mo9cn#=m!}57+qDMN!xIw@sy8 zNQ8y`xB9x22n%~u^~Jk?K+5gvi}(M4k>o&VfOi0C1FpW*DF@NfMcBFOA|ObC2umx? zJ5fs**vOXnfGVdnYTqpvY_wGoY(R2r^Bpo~V4QpZ>L94g2^Jr!3GlKxTZVsf5Z?2* z1|c~IRBkZN3)xSZeB~(&zcfB)Wy-whxHc~IV2bdJtSBxDpKMiJ-|Og|4XQI-#Rbi4 zA)SYHoPYQg*(bg)=9LZk=G8~F>fQupVBrB=(0ksSK-nU#Yry_e<+DUAFN&2ptv8}@ zK_kUz>W*O1{a86>Z7nJ%(c;mAXzlayZ6ItAH8yrQ%;cCWv3M!ZgETvu*a%X5qTanH z1upqRdo>Oq$RDE4UHp+_Q8*1BhRcR8rB8nhO+ca^&O1(k#S)IjFI|fqC}Rd|xsvjG zrHy=GxoFA9a`)%rhUdu<>jPE}s3@lv&n)c8q!n$hD(4*TR#zDrMq2BOGUtOsQb9W$ z5?i%&fF80J5g4+44DEVXY@e|q`FE0Wit-uYQJ(oVV7>@ZMXeUWiv>tHAQ$u}5R2x8 z4caeucV^ldk(w85tOI~jbk>LM>E-Yz84Zq>yKPz|Cf2}{A3S3dTy+FjBel9=b@Dc1 z6W|D~1K=~lgwOg>Mv`k;@s!}mdb~ECTuJ#Rw+&1_Nb#ihEn_y_g4Y9wYu?0hC+)1# zUz~tPt7|*pmbt@*#u%pX=$i{Oy5?5Le2|;y_&Kp3z@#hAZ4K?W+*4D~gz1bD@DVt8 zf&hIBBQzq60gXg;)zB6*dY--1>$ut zezED?&IK56<-}hz)oyb6T12=YUP)0c>0o4`WnBI>(^2ku{IA(wo;WBnlDDB9U_=@04)Or3{1;trI!SdtsoLw14zcT|t-zJ*$UxJ+ zRrNsg+$}O*Rg<~hO3E-ZuMzFsVz$(t5rlTP=`P$e3j{mW)?LT_0&zYn&-@hM%CAv| z=8$q?0b0)SFOa8u-5H383)3zW-p_1ZNWLgowP+6Kh|Kc zZm=Kst5{@&n)v|{M7K=!Z5}Xboc3m{7&ip@=+aWy%2=zuxO(#zR1U-UH;proHf10@A+a&b~21 z`E&4%Ub`+3F`hm7bYi@6j$tHzhmsIp$Chgc)n`*);-*3F#r7JZWi6*6g%x-0SXXf$5PQU; zIzj+Gj$Qqwvs8P^7%jS}_yJhwiIVPB4(;IBn}a+_ml;j_1H8}-OAd%>`4ZYaNTsI` z+>rO=GcHUcqL9xjMMIY-m@&U6n6YY2ZqST)?Gy3kBS-Q7ioq;+{I3u+l!!&TRDAF6 zo#$UOxcB+`=Y$W~@qmtjpld41xSG%|ni3i;xEWNqshqT{u+w@!vvkN0LPZ^|vRvxS z`W%HPVWG1c>~?yXw>QW_lRkE)vV_4tNt?Myf@>2s9&bKpw}{q|R?J-a$;G4^B~6Ka zYx?zTylT{Ab~yvJa#oRL71Aq?O3rcdv>47iJ9BJGMzhz>w&YsTopp~>EP?=neYI_| z75@-!oR0Q4uzmD@d&KT^rnBMg&bV^^aAn04?MJV9$2d<8nwyL-%kR`-h#tPtIS{b_ z0&d8}z9Id$b{EIazF_4$#)Xng@|ecMADo(fns)bVl+3dAJAeoFF7`%iQve&YVrWY` zABH5M-6O!ONNIMFqz`2JH7HIU8#my+4jHdVk327RM#^@%9}p(H)>~;jD?lt&Ik9jr9VpA| z0DR5&>VUgNSlM7_l&clKteNY;EFgie11?fM;Ud*(oLkjB;U0oi`XFAmK3IYu-An(@ z`y#Bsy`5R#0LtG^5Zwhp+tM#zo!37~mezIIWBI3A@8nMcrq^!%^&W4S^5w*xgk)@_i+HXSDW}X|;Gwteo=i z3k@}|MP_}(j|OAhHi(lfj(sKi!Z$T*(^u`!qEDl!II-a`H9q{Mnp`e?P|ZZ3cxtBj zFmw#kXC)$ilApRAvcV%uNcBddl|#}VTuVWpa*db!{@6rg;ka0n)zvR{G5!vXO-#SE zo&Xf7mT$kuPOi6K#fjbw^B6fwM1S!*(Q25W@Zqr7p(M!MvAzq_ceDK!GFYDRtbAwR zk{^#2<+&Se`~p)!OyXAbm7Dd6=mynPJhjA=YS-UZw&7R6!C#hUho7#(T1lHEi ztX&b`kqv6K(0y=7QoxUoSSy=$n$y>F&3oDzSBDGfu|q997)$A2D_*Q?>PliqkfmYM zh#c`jElcK-@Z*2<<;resvaY$RH2!SMl9VJq&Yku;W8wH_z_62I#8R27mhk>Sacf1u zSa>><)|#~&roWN>FD@q>*)Z)94C2TE*jy9b-nQD^LCeNi7dXgQU_U&+HKXs`uwH@{ z4<>mY^Z-xb`L@yx@gqgHKw~I-9mc()8{W49RtuWFKq-f_?sL4d;Q5eR)L8TI67iez z1YG=Dnrxt=X~1yc&be1%bhJ!Dqj)eKwpG@ifz!@%FVqme@LuFP#QcWPB(5sVKC1Bjb?K$wO^~1GO*HM%SWBPIV|^wF zS~Lg%h#riQ+=5vo)sme5gmBncIK4T2JX|86BahdvHLl-=Sku7;=!F+th4&P9f35 zL4r?}0HrHNm;oFGO@O*Q(8bbK?)BHyDFj&NxA-G^aw==#6%3~jMX~F8(_;1tFV_e+ z*Lgk3(R8y=H?Jx>u{T9-2Spy{CPUK#Wen9VRe5wNN^7}=qF>m8ONbeCYln{)CXLz`T zu!l;Tb2>OzQ~ch4u9na26^`Z3)e7wPLFk_s$<0_$vQPV_(qoHSU?p#toM~F^0kd{} ze2ZGtk?#c4ejC&J4KuLDSP(#7W5HR0_RZykIuYpCzPWNxXM0z9lMRWx9n{kSF86l) zX|MQ!(i>xWbauZcyKEfTAnIQcf2;3Tt4(hu$|HbLiU6R886m(zV3Y)ik&E{Lk*Ov^ zYm}k^%p=D%n?UPwo_Inu=rj_yFhDbd8yJ9=bjT_QyX{;~8gVvbES%bmTQ{xWKv>bk zPOzWkS@?v`(MX(wfW6jDu{&fjM4w#JQDjoNs1$YAbhU3P2HFQ}A6KIv*QGASRa1?` z95_i4`>G3Z7{eU_cr;PZ)!dR~a43-oa?IY+ZX`uL4?M$rcdLj6z6D+*+R}qiS?UBf zVJd15 z@i3r~m;i7KNl^r_*FczgPkb@&RL4Hj6L@PQlxvU`RT$Tw;g%@}ziMsvyo>~egU#HQmf7Wx)6fbJTJ%aD9VDjEkr#3RFi zZWtsE4-Cp1sAx=$1r-C$CpVjep0V1wAP3;LVmdry;P@=U<+**&2t0$^yr-eIJ-#MW zfeP~hlL_>WdJD_k>8Xkn^Hj2#jfnN;I&)m!*O7T&`{RozXQkr4&?lfh5t}R&3Jca_ z2}JygFk@7|V^nX(*P)Ef9;Gc@cNi0KHTOIa-te}bG@i};lmo6scw-;8g!O@!3$7Hwi*jNNX5HjhBAlE<-K zPEY>>im!i%tu~?ACbZkchTHmP0(gsaPrj4bM6epDfh7n)EIKj$MzSDEQwGv4^?po=>5c2TD55sfmR^P|j{@=@lC8f9>e-M1!$gTr#7lSY~H9w-CG z4sj}4>z^rXzIx1*dts_}^;KU79K4wtmYb>RjqaSl#zFCIA3nr?nmwl{R%T%sObubt z!&L|Gb&>c&;pBhL2_Lxh|G#7D``q7b+g@qAFO_KM^}dSEZ_0UUG)7iu~f6z2fJw_yiU| zGbi0*xso~{!GFlpws+7&tb6V680WX4hvPmJ*%xwe&XDOuHgO!A7%q%W*X|ZC zne8iI(yGPcm-oWrM1hK{Efp}k_UXhv*{TT1^3cUfb#f@>*mf=Lo{}%^o`_G8kx%#p z(r#&Kf3E9?0|U&%3AqQ4{NHDqDgGihFwA0>~f=SS7_&UL`o zQx(5s6-r>EIT61A(IEC=_nUS}upzK5S_6T9x5QK27Rffsi$yT^K@-puz9hw9og$Jg zueFP0OQ8`$?Nkc2+j|JL2Oh*e)_$ccOj1cWpp30 zx8<$uxNk>NIGm(_v@{s@8GP7vCJPq6A|{tI07e< zLof4d4oL9DCo}w7%aGT8BFQ9nuE>yKqNYzWsmw_xM(bE4LWZmaGE-&EV5yP32Em>( zONNnu8N&4xC3`P4u2AV;XF|sEk~$*d4z<|iuM{u*b#Re$f6If43x9-}u-iR!!^`Iy z-H2-YYgDV~foh+jfH@02z*Jr}%0G>M0rP7;Ckq0mMivN|o;bOq58QO6&91`9|Cc8H z7Z3c?P5SU*Y50R+{Zv9B`kS8_7q-ef~NCkAfpn}1NdDMk{{2x@6+qqNQiJ+%)1~b=3zMtlE;kKqTbn`K-9}uY*zIY^>T_$szz`U zfGw_Aj#Fs!Yc(_XfT8I%?|i6}_JTv-ES$`1CQ22tOJuO@*L%f`>J@WT1E%zFtdw{m z=pApRbi#=dw!2D3YCEQ9&rFS677aifCj#Jy1Sxjwl_CIkKmhzm^eVo)5Ly7-fUKy& zxV{SO83e#R*vLaCj#Io6@ma*r$P__+JIG|ve`M|H7?4^Q^!@#|;`dRC> zvyXae&uklSkCbK?%Pgsb!0y;clGT?=HRb;>~5mRc2Davd-PqDbX%*AxPH{P+L-)2;na^nq@!!1rw7k}sdwCZ@%s~CNVOW)1!?2%H ztbvSWT~}IUBre4lY-VuuQEqh=$A&n!v|!D%HV@1Wa&A(=0QvMoh=n;5ylAw=!q$>| z@L3d(IOFS>crbW3Tx?YGwS%JWP8?+>{}Um{nuEWo<`0=BJimK9-?dAwL-Zr~A5Yjw zMKPG@S$E>wtQC_LNn5lNT+yh1NGz9@F*xsh1sCPG zlB8i~nXjN~ctmVLleh@QhMfoR#}AL1i_%w~O5;=bTuCeA z)BZ3%-M$P((24CZo!icOmOYDl4n~}t@L&syB2oP!!_S!E0A!%;>v%QX-NnjFh6j*k zeBM++OypAysAbq56e(yWo}kF#c=f)>0q`~UTqQV4l1kzyXpqC!E)V31loSx?nyF@3 z2)&g42`h^G;_VffcW4C5Co_2(lC$^q4W-D}ToYXlCED07>j9?S z5VKVgepU()}}Z9KkPj|48YdZWzRB`rPjQxUb}y!2@KVO?Gkir{0kBEmC~OpYVTJXgDLq zB;;N3v$HeyeX$>_6{EAMqr@B&_7taJWcZOTW(I&#wQ%(Gfd#v+%HxY}Cfh0z3ZEGqBCxpC zwo2WI&*_M2H^R^nK}6VACH^`V6K#viq7JJHe>t6*1JP%-`&|f!$x|9|fq8Ynw8Snm zV9jSfXn40m@66};tR;*9Yc%mA7M!(`)3CM^TcJ>FL(iMR2j>eS|!9N>!c zutj0}rS|U9&@8y;MhUV9_vV^Srh?XUs8@7X}-DXi^bRpp9PSlPp>#uerz zcqd_hlq@pt8~s~*cl++rS!fFTAywTo_D$@XEuFR%;2lmvFYw!l6cPV^+~u{FaJB*6 zsrVsY3=+IxoZv;kNZQOcpV#geasJ>4yEEX`F`3GBS3fq=KL(Z+UgkB-g35&ig9A`NGvJ+RYxg-Pj;gp}SG?K-gZ>z6X=rxDBlCR>!g)0_A;Fcy}ypyITY9AxH3C?#E z5%1HRh)K{xK+xjO1BWwZnp_EZp4RN6BiM09s9WhEdBTtp`|2DV4kIdb1Yykx#XC`i z!**_xDY&T|VcVi&Sn~tL8x&A-;2>`hysX4HM0Cj%VXV?d9?QjIfwQzczN@^pV*iBo zp{gi$hM(ge@9pr#PW$OhrH|SEtdc$Ny-sNTKt>*5aW@M8*+*u~#)t^rP(6&Ai$dKM zL2%R(BY6_WjQuA33RrKIgy4;2BqHEn{VNlvpH6U%kg*xdJ45jEFiNK_o`^~~U0*TA zwZrXi2p0+JSQ9cO_{(R@@QeS7GNaL=YMP&+ZdlPUoel9{W+DFUE&Udx+wa2|-DSk> z;JoU+-9X5?SG5zd(xB&eaS9cJIVYQ@h5OGiUlARjOGsN{C%NnQ~{Q8B94!R~TICMtN(zk^CV#pwu}QUEz9* zorXs#hSC%Q0yKl29gg0K&>?W90dP4UP{3sacqV|0knAzK6bcn(=Y{OKcPJPq?%+h2 zcq<}Q`$uE;{rJdDt?2Re{Kl6OLWFcl$Z?B1syGan@%&fVegb2kClG@KXVyF$OVB83~;SZv*|DfIqVV6cxVZ`5;7LlhU`6|Hh99kWP^*DPQ}e3``J)?cQI~is8GL9 zU{~GFjzGw$-^G{>-72CVBLeRrsl=#%$9`wm9}z4?FtEM%+JgNL*jmVl!Z3Qbwb^i+ zD=xd)dVivE=I@j1LWcQh*j^DyP1wINWQXUK`Z_i8X8WD?-Nhk$7kY;NJd2jf(fqUa zt_|IRXG1&J^utHs83fRmXY6Npy@Vk8QgEHi^(BPm#O=vx#bpcpU8xUr=Jh6m^FqW$ zYw^TbvKpnk-gE%=PtnkPMm18UM6*DE^sT!oT#^i z$RJF@wJV5Zq&oxG)gsKk=<3wYe&KyR3h!(m0Ma?bp+na&Vdx(Nh3f)l?^`*3H;x)BLD`-S})9|JLK-!QDNuz!Ko(VEx9z`aEbO7=x$wD!Hw zQt%^QmwL?;jPSyRyA?b|y17XhU1-;PxZ!atYHzsY)o9IKYzH;QmxLZct|HlbnkUa^ zhN})oKN#T2^z1hos9BBoH4p$`fK1up-0|J^q}%&=r!vsxYh1EvzIq4drFK*N0yGf& zHvmd{(6no6Go+kNk=m_L{l5lLKwXLIAVlKOit6IO>4HbF<$9CQeE{0;y#%T$%J5M< zcLWo1!3cuv;?5^Tm6Tk?Bzv`34!Z@9lH3?lQRa|b!SY}Jjwb#cY;&6 z=aSPbW8s+?$NPcUm+`kaHUfVK#E!$?fw8aPZ@<{_i`WW+L!qd*;1Wb?%f6eAbYh%u zrpG;npV!k@K7*f^(&uf&&&Kpu-@(s@^j&n0wq7bwJK0{h#Qhi!uKh&pXOxC& z5phCIacEZ@w}8^o+SkNtR-Vn!wh>(1fa+i3A^BNgKxeauo#OaGot7Z3o^dN1QX^+8 zL)`dXy{IoIOpcsye7%084gjhAy8FDpEa{bU-4#*W6U6~~Uj z-vO@O8G-|2)p^r++jE$sH`5OQUoefcpT`gGLcD~Zjp_F{;YXRwf13F_(m#I($o!3T zoWaIAdoX4YH|O4o>sQ(HL{DHO4zy-req@J_yW`KmaZEIIU6rx$I)e6^8D{&Iesnlk z^6yZRiMds5s_9IfA=js05(t^KV`jufsYAr&<%I#xm?*){%uP?a3lMpB1PMio$ni3J}3WQi=00^v>-40 zD>EOKYbymtOTID7T|N= zbQgfAvL~HN{cT3}*e4{rlcYa+Bl9UyjRoi8N}AkFJCGOD&MlS;YJ1U?MqEwlB=?a6 zttzdMy=VG~4SA~4l3uFPv$e7i8!^Su@9Ikzs*>;SD_QUVp((vR$N2U7$tP@ti_1Z} zj`d=wM8=C`xSV$`?lEmHH#zzP8}4g&KMgj$=uwD#rnS2y z4yTInn&igv{6k`!tPcXQ8ta3SSdb#Rx??yYs3)=_$gxZas;SH#!94wBs1uM^O*T@Q zsUj%T4L8L0Mddi$0NbyOSOZE$9^qwEo}-kBJArr%u*!RE7 z@;G+6uRmNWsrkJxjo$(%|#;Xm_C7t}-&p&X%Jd(T?_>S8oQTj~K#$Q56Fr zT=Jfz)m0vUa}lLop94%|fnh9DZZc~(;BdfLaAv?*c21ynLwpCq{SfYl@D?J!v21K{ z?F!{mAO1(W4)2Vsr#vIPWc|2yV1@16Pxv5`^hNrST!)Mr1w_q*rTJ<5Q7zZHH%@Yn zFb3(B6l9>ZKRvU=U+9s-ld?4!8&wRIMe%(@7VdKe8eo0HTbx*F@8y0HeicWq=4Yg4 zO#}~)HWWiw73!ec4I8nG%Zvr}MWH!kf%x?S{0_ozKl~2HZ!vy{)Z5=H7pDvgA=7IX zk)N%J*kj?uzAaW0a?U9iK%?C$WdbiPcQhO z8*m83sTK^zPT`#IhRf~K5s6|o0iu(E%3`=B*kbeH8O$+d5eWh5lS!o?t|_KhJvR8W(I@M6Rbm9 z>cTnZfdGRP49tLE{<7f1l}Kc%AD|SVT4^MIiWvChjHZUyMcQ90Zm_pC6hpbfp*Ol6 z9O#dn;6{!s@yAZov8Ddl3w3OnKX#IiEpLEVSZV1}H>$oOWUUF*pB%$0wAa(R91721 zHR+=pyIp&YP&oU)(k!98@askaCvGpSn#|Mx$vTID|>^fYp ze;U<$@9`GbS4HeqM&dV&Bk>A@dYFfc9K_QwAs75V3^O$_Hp++kw6s#Ff4Prkr3(*| zsLx?>acvIGfs<#3zRwWY=!D=^41tkO2u@{a2tzT3z;q`B;|zU{p=k{5lZm561-C1F zZF5O=;Wkq{rZ*C`F6e+~R5J=d1`!~c-{Ny`FnKp0CK_+se@kp%?SZ8-1{+YQEu*zp zfFoSQN`)hgXUOH`#f2p?f<<}_OxLV2k0aoYxXTiz33|%+J~F7DrGUh#IN#|59gUvWVi_818o^pYLYGKl^HJVsc5 z@)Tgdb(X||;PQClWvD~(L_Q-@Z@<-W#m>qGdl&hk%(BK3@WWiBUOmQ@P>d-jq0BgK z&V&)A-scbaImr9GnxBKc&ujQO#9yOcamImb>UQ!Lo^fEDxHF!ILm_)Cc<1Us<{%&D zEH4afMZIVFNTe!_`Y@LzQv5YCwW5jY}o%}5RcPOM1;oAD#K z;R+u-TqEl`7{=*T+z7kGDKMgqq{NU1caCd1Q~A z1KpgJUe4vn89^7S)QSdCS}K^rjEGhy;qFFjSNd#36LwW>q;@;u00Dp>!|?$e3S!G! zg|)p3vp`vA6f3D?hL`_{sUQ+AtHU2c{P*|DfSGNgYMm*}`&PSZeG)(JK|$8?Eq>hY zeq73r8{Cg3e#~+|Ci5eP5B?sB(V3}v!S$Tv{$f%HS2ssC*l$H?0aMxm6dI1d6qp3w~F9O)Oo2er; z4!v5q32rzQo^y3;%rtWe&|5jBZb3uvcc{he*`-kR6P>Cv1H{J6-S+9c@uxyNSK(;y zW$g30`iN&hNCNEQt#2a^%~WSrG8L6Xb@y5T650PC3wTX(jMVMRK=fpWFR2WPF!baQ*;^sZC@#dCnrhXnHzTQV|E;p=I8>^_^YZSv(gZ(L7YDUjo9e8#I&^3lR=q0r z42t6VItI$UJ&Cu}<@Qpi|H@tJLRcS4V&@Y&BO*A2Qg?>~7$Lmk7_-ks&-4JN3}Lv} zK13&X^)WqHpexO0F?+`DVPc2DE1f5zh;qXYmExUrEQ)cNr_zo(@tbdU)KQ)(%3Opc zAe1`y1N$sEsgl9D7zJCcB&M)Re3nZu%yI#;WO$8P_qL?)W>`3v z$>C>OxMloAK&7cD8`*h}3)DjZ)Cyb}(Lhbk*J51uF5Q6x`shFpaCL}zM{jU3MlIAX z03q7K1Y=GJ>vcHzgE^t0{JnZkXkY$bGbgkkOQ?ldN;KIaZ2x8kuN7p{Q3r4dZozo+ zV)Nxao%djwvI=j?Xc-INHg#3}&2(ePn6j*W*02Io_C74neN%>uaC*n%P1!xjl3DCy zF~{@)F+UN~u8=gg{!J2LZ2yNDAr7jxrN4*i$s8`+!B3UIaF)2$D}e~N#Aue-CbFKt zM5!v#X9SDEfHf0xPQ%OSVb+W#D97v5aE_MjV0cL`Bff^BQCO6Q@j$0a7&c4#LC_!`bmkC zq(uB2a@P1|BCdhIOg$`8v)WS!;gOVXDuduK3mlS{*{VY@Y>A!i<&d{i-8^H+iAC|2 z9SPB;pYF$;|3*Jf*8PBnKs?=TOTUqhpYk076T%scA4GfF3{1a{kFFms1f6R z8gD%($vwC)bXE&UK6xw|k=GGmjsA)@-3?S1wbhMoMOq61Pi(96;ENd(XqBO_gu@+> zps+$vba*WT_-De@tWyOgywMllq{9#}=nd6$rdRUK znYzWGG<=;ZHH(wTiO%L^D;uVIPpx-xm z%{3B_f;a?Qr?WtxkemN=4LRz22_%6G&vE7{cxfOJGzv)D5t3sL+U3kX(5*jzR0<_d zPM_}8zfCyy(xBw?P4b#>u(pVT))xpCU_s9e#Dd?VFf#@+-2%iyaE@^<$PzM7x=j_r zr=wvUgM93tJZ%%dB!?MTb2Vm^=J27{ppTpez2!XBPj4FafX}~E0W>z+RhaAozs@xw zaQ!&s%idlX4zYU$Sf2SSeC}e(zefaxh$7PBht(y>__p=@c24K9EsqaNF`~!{fZLBEzEAzQIDb4C%fY( z(?0b?(>Wd9RC#a!`=V4r-m7d3JEudpuin)(o#U}N!bzaDO0+P^uLEM5axOwxpfW)M zpqy(ll{)o!2*Z+kGy`yPj5BM9FBnZlQS4L`FMmlNv4Au_3kgXUMuGF$hb0Im;R3{)m6Pk?1Fm!E&_MHZXT?`=?}lBa@>p@Ts-U43rxKzxYPws z=4XO%FjGwJCZ#VG9+^femWZx1joH&Ax+lJ(X9C+_sp8o2pWzlSM1NmFn&4jMI-xDh zlYf#PRx9zz>2aGyY8m3<{s*EuSn2{vwj9zih;%PR9lWlJPPkA2N>petEaTYHJHAUm z#2%t_P=}fAIRXuU^c@NS@gGG~_X<_!?5AWOr8zANP>KLXJ>-@#lJsOAhJ9(pnW-sX zPHVc8UJ^~Aa8c98srfhQk&*a3%BZPHP#DXb;0IKmYVuF% z{!@QAQtiSf-B_3iu25-Br*tEdFPJj&aW~THI@M@>9Fa{h&wUJ$sB^jGxi{E`uO{oG zJw{>-x(Kp264$71g9L{_mpTKzzYQ^qNPuQ7hG``3$2AHyFAov`q`&lm7>6v{M&dap zr>=nmnTMqQ#h~e;9lvykV2_ystINBk%S~bX64>Xdt~S|Yt`a!n&EFf@E&GZXf-TYl zafNL5KUlXtW(NA)53aKDGgKUZ$A-Yz7#_D;XYfb{c3b=8`qP3a*CunV=pzcvJ$%l~ zoIm6WLAZYiu&c`=Am8VJ-a;znF7uKn2`B<2UPCtD62yys38`dIXA?|`+uURke$+ic zB?hQu&KwK8hhJBE+R30640s@-*2rBF4e1G$5*JwNea0zqVz(rVZOpu27d}*}4M~;SH`Oc z$)Tz4a=6OKBR5DHnJOjY)ulKzRf@yarSu>_Ye)Z~fj3_XDu z2sMe|QxX6gAiU8R-lW5P&>G=#V>b8G#Qrz%DR$8KR;UEtas&AXxo$s&O0myVoIi+= z&mx=GDHa~onLUsR40{R8rFz?mP!q{wd;n9oa9*&D5mwg$vB6E&ZV>emXp5oP@y5dK zo<+86j@=)LBtF(+EbKG`d=YzLTR1go-%P1g*vUaC(es*0TyVp@y7|R~Vih#*?ikMI z7#i8t07`mYWm(l#f|1F^Dw(oi34?kv`$p>=rPX*;^cm}jME_$XrrSJYVKYo;~cgctL!s2etRds^wV_xC#3JOY3UZw=4 z??T8>tMO8t5cQT500DsD%PjN zduA}Y!OSjk5z<0hxt2c-UAZljj&#fH1zKjsWF_sJu{BEs2O&5})<^M;2tQuNg1NyV zh^508bI@9T(lfIgl)IJfFPGwzM?oh1nxd9{BtOeO6f`9KI?8V6=TIptLEfW;#SF@B zM{#?@te1I3HNFq=v6A>mZR%O-Rty zC)1?t%Jw&mSgE;dqkJq@a#1u`sjMUA97JJBlFFJUdv34|zXq=PRqM6TbRgu}OJx~{ z40N}MYGA#%aqtx0D-j9(wq1LeT^8kqZN_~a_~6=>3hf4m4@?(<2Tnx0Fix_5u3UB} ztP=wwcJR|h)?LUEJ!T3vg+6I}$G<7L^Jyfy`-%Bbqk7QE98Y-*F$f z>*F$n`pSTHQ~DtO9}0m;XQ1^`!BNoGhogA0j|_mv;Kj_8S=vXA%sBLp@(Cvz1`is& zh%cF~C?rf9+mg{l(`vP{yuS_lEAF$Cw~CgvFrS+#X+5~v;!;#hR`%=-dPlq(t+>4G zWb(2Th3AlugxX&fdROeaTo{33Hf~VywMz1)ky45|bt&QOn{+8=^;H0#fiHQTN^c!s zPapM7wOAd`aTj08Gh+F3*Bo>jRDiwAA^17DDDLfox#Qe+u`I@hJkX#P+iP*pNg(Ho zTlp4e5qlt5qNMRt;CN3J4xz9Mki!U&gUPL)LoskgW5K;5H4a*xxf$7*Lixi@VJ4)^ zL`u(%)iQL_-B=BNgUPb#6cHnHwwGUNKt`l*%;kPQgWOo7ZbjWi@qx0Ji+vlbAo#%2 zU<)F<$B*JCn9&ULif$Y~s?6QvVN9n~QT!zgW$!hKYgdeUcQ#Y2-zcI`dVC590UT?l zV0;$ej0s|3yt`%%@jwXjkq#z;`Rt-F_=c^=OAaO=O8n6I0XUP!+w1%L&|H9k*ww6 z2s%p4mX2~Y6cLXn0DL!YKT2h#<|%YlF#WYmDGNxeOYTRJG|Oe;ZoAc7Pw@Ekm>HRG zG9UJ!Khm9zUCToZ>IlSsB!at-?jAPw1KGkRBPe1loGa`;m(kqC$IsSsl<-phzG-!0 zZ`%$>*1u%aU-+=Qn0GVV>9+%~G6cG?e!MF!&{!(4Ryy;9P%}a0>vY?ePu$!JRJzK% zqHO?LTH$Z$F}J0+rI{-VG~=!-OsSX4N7kPwJsEXP2z4$M#ig}pjV4AxjZ{Gex$CRnNyRgd?G3o=hDonZ&xiO2R9A1K z;s73E;b!-V)$3owr6+k}l^WJibw<3bqBiG^KSOk$B%G`k+^$gN&M65J|Loj}rphkOxX~Vb#PXu*HdpX1Z zp}79wKEP?en7-vv00K@8SUZlLhN-I-WjJqQk9gj+G9MCuzplnQ{?~N1Y27F9s=i+P zL6~#DHhmVZO#-t9@@@zGh1nTvT|c4AWom9;N*@mOes+`ZfD>ruUHQP3pL)9k6^Rer z{m;h{BUZPuIMq$>!UagknXyCY146w(g4Y$L8SheM*nVH0P~u&n^de}dZ9GmGh&`(d zWPhJ`|6T4HxzEJbv;U9#a2CuF2%CGVcJowR%~~PE1}~3?_IN4wi|9%2dQXG>cD ze<*e^#MA6L4;@Ke5qm>ODiq2RFlq8CmFuv1GgTD2~_jv1hBdpMyz)>4+UiRk{r%$8T~d{+JY&-Q=p z{@uRvQ}$1>L}4^OF4L12K7&)s9QyTqmHHUX3-M<5%ON`*vex#?aX3CZNnvz16nWXz z9zXOwijAvldw&!=413g1(!5~)rb5kcOJ9@UJe(aEi3E@|e__(5Hl)i2driIl2PJJ` z1vreNRGn$R51PC#DeKe=@K=&P^G9kE*JEii?fGq}K5E~!7C&YOL}&HSTeAq1lIIB& zX+!%%D90<;%;{Sx^deC}27A(EM^}MW_@*znNIU^r#IEV%#IH{xdmXakQ=*n8&A(k2 zirgXt03f%96~~X>Ju4z z3vA8L0Vma3qi_;FUJe)!%19qgYXX{Bzm#5tP4@-rIVx*;qCYS!HqdEpL13kv)T)wp zSJ*kDB>u4>f%1T0|UPwBJxHYY>Q7zWdTIMBP z>V+n|A*oS-+j8B7Me!;Q8_wzKxVP?q%sBIcm3Sa}gwW$LV@74SuM{?Bf6%gADvu3j zF(dImXoyg{_dh@APC(73zwf~J9P1VIgQ+j#3)^ypor^6No2 z_5%DG3p(waHZdXf;Hz%>aX;mp$IkAsiZBvr=DI_NZ-x4^J9e>SF)t48XN)&*ZCP5( zBHi(?;&M|U+4h6CvZu&sVAXApxim8lB|9ua`7r!1fXFthh{1@+UYcyfbV(!j{1P

!-5!4@6+Y>Z;xU)nVqu||Tz`N0B#)hhnz>|a9GjY3QGV$B-R|uxjDh&DmrSu4f z$HyOK_#8mwf|abxTEeEf<3}<2zc5-rExc2vBoN!I8mRIbIJ(2y>h`R|>heM#x}i1J zs|=}5D<=@8&V4L_2Yr((ki-_3ON+4!otqd)T@|n&WWc-x2N82+I*bMFr|>-Zx^mSX zfneXX9hpvkkWigDSV0Kg?QU5jZN|+x4g-qFS30fkB-^blmZtg|BRkL?S=`Ev%uZ+5 z=bFhb)0)NoSX=Ll0}2OjCG3m^t!y&U7C+QlE^vuArUxh(;;2-Bk!Zu?@#(-E`LHZP zDnL;G;&vi#8|cSXWFFo}a~xxKqwtXI2Im$6UAh2A*>mm$TwH>)->ZG+hbLQmDzCdJ z`9yqhN9()D$bW3?Ow<7r&)BydhvlE#6tI|#S9xuTsLjmW=-k98nL0c3(FMXeun$hZgtGQZZeX8g2>ySzq@m{MZhx(`eN%a0bs)Qi%sj15v72x@skyaCyc~=1jEiLgiqOl`@WX@}bDvzv5f@t-fpsJgQz9sbQ*k^N=OdU&O3Z~5UNMe)zkd90Hh zg@VrLMdl?PxU>r$c3D41=&*L}%!5KtZVlVghnlsv#M)f~og9=^{b{N3P&9JGFVMZH z(@+{tHL3{)=#(Vn_w3pl6joG5(Mk^wz1Q@lDEt-=;162F<<1@qEK7I#aIb zE+k~J|7{f5MdlIz26J!Vb6vZ3z4<05+=XQG`lO08U0UM?ikfZigP5Q#7$XA&Qhrpt z4)`RnY*KYTe(-p0{<}=9e`LPd;OBDzMQO43VVGBxON*io%xzX{~V^ zBj{|D#k&`mUA&3*o>9%eKzdb&O^x>fQeD<{EYQ&ti0kulfm~IWIf>Poh!1#qTJVAwCeLvPNUck>wy_u!>v=ZSY zAso-BdnueOdQB9;zHl8ET#kCmsC!XDv{HAmcLBAqz{&OF69-V+0H?O)y|w*Qjw6aq ztZX^@4w~hPWwY!NK0c=h%xNWM0%(bORG7ybLDzgzY>w}s3v7k5*g9264s038SQc4o z8L($8$Wk*?Yx*OV2rJPNZ}U{ysIW3m&OfsRE6DAKVDlyzfbB{Djv{J;yh~9~);?OHsfc@q7vMj_9~C^V|f(+?r)aqKj#g(&ntChWX57GMNud<*#nO z7BOp|%-f%a){Jbat!s&3BGbD0I9u;;cvfr_JeafY8?7yQc+7ZS%-`Qmd16nUWZcnW zFb53Jy+ZOym)R&wvQ=_?{18!V*9C6!nrpQ&W4(dXwK1pr*DB%hz>GpO)R0_pKPAlN zsH~|)I_|<&QRk= z^}~p~t6M=IGbh+dblrChA`rUYqBQ4YZLv?1jWS|cX%-{;Zy-}=NOUHsGa6@-D36_uKXjhr zvl?9WSI1{1m>>(7)bZtlBUio8=nOq5S#980)dJW@lgp)CU{-^+;5xxxD=vfyX~eTgky(SxXV`uHEzrQyCq~?6; zaD^EFOiwP5D!Vr8ZpAz-osh*@8BkjwRIWS1d9+P$SZS}lOVgEnV5dw``Iqg2glJOi zz<4m6B&IotNP6#4Yy5CN84q$2j%!0nTR1rY5Ikv^B^7C*7FmMnU}_pRd3I&d7c$S8 zFM3X861`%1Pms${+~$OqbqCGRDq-d_Yuo`fZM8?*f`K13Xpgjn3Br(Qi~b;a4Ph(n z7LwkI(FjCka0aj8sVRjScxPf`I`cn)@E+ri{Wg-|F`gxYq;DoekB*C2wW}glsO4Eu z&1vcbGQ(1@iyAk%-jIT9gh`BZMvI@Q(eG(7!hS5itQt#+r=eE%#*>{eMDPjZO3^{Sbft z4P~8=`G!LF|9#5ZN$ba;EV0DxpR&$?=VvMF3}PndQC6$xL?~;ud(A@!6hDHr{ykx7 z3E?}*8i;GKBHv`mWZoK(9)z@Wz40r;^36NCeJhSQQ=?K_cnezE3ihV|Clj1Y~k`zTQ z?2i;nsI`|AdzYp^>vOA2q>{iL)@!t*@jW0!9My#l{W_lu{Z&LrxX`TojO0xY zCkg@E<+A(;Hxdp)_?5y)<@X-d5+zmIN+XnpaWA;sjuPc@j@hnz6U2PPV2tSM} z`pASL!jG|q!kHB|KcD_D1;R_I!5P3!Jf^SUk8^wbw^+TMPh!ZJ7Gp(o&qD_)MK*XD zIwvx}H50(!eYrbQml81{Y`*S))$$HDLyIEjGZQILYi>x3cc~F?^+w#=2|uJIE|GVP zrnGYIl%D84Su0=5?!VT<^sdNM&x|4 zw(wk|M0uiE;$5RIYy^?F}Ro^vxYUVkiliI)+(c0`dUVy*I zID+gVlP4x8ERq4dCJG|T!193Nzft58dvkhW)RsZlo}p)DCY zZc5`jGoM89AuE^^3!81p8HGtpgeC2XS3Mfiv~GR|b-rWV@lIA?F+2|naofTh)9HVK z9DA+em}~wmlx12k5^}m!^*XjFZII{)dpPH^R4SP{{RB_4z~`Tf;f0Pc8#bA6QQu^P zo%8J|8zu$$GgF+vC-PMp;N^+<311Fudqx+qQ3jteJ3ier02^@N=o`RCR&Ou`B~+UmXc6U=%x~! zlzw7>Wa&>z+DV6~IV&bD2S!X?aziyDiY0c4hAv%93as(Vo!EdWmg>Y32Jmk>A&W$R zoygSZ^*}A54ZmOyS0rq3p~D-A?-ru4Vtoa{%I{+Qo%kE|u|+O9CuKZ%wG|w}0ZNrm zTQX^Efm{Ps*mYP)>+U?l340z9qS3P|M7GK2GhV%qoC`~=aaiIAVTrIFhb8K!5^>2c z;PSu7RFcxRl&i?g0orw7Mya)?=*s>pT|+)`${Z0S4r7HK9>PFVLXW*Zt=WYJV!rrR z$pB>6Uk)EQhkIadV6@v&-!~mEOOLj4Jr2k+;z3<01Z~Oe0L;HeYg#K+*y6WB5?afh zSu73z8`m?35+7-aGiAI)3mg%$zUQu$98sTftu_3|D8%V>1&U;TN^9%(6M@!~zD!Ng zQ9g)6Aj?V{gDi?&wMEF4uMY zF~|4TX9ln97Q=j=iaHWiQU$I7-g@r+aI)>Z|Qd5&i(p57+DV%S)U) zaiRH*tdfu4cs*@u&Fw*L<BFO2R; z6sb|8HQ?E+o}FP3nOIwJl8_#y77XX%K$m-??rxtFG>6uwML2R`<*L6*2p%~M+j0OP zA#x0*^#TO<3N-7_Zm23|b3CQftD~6a4iT79Cw2l1jsHOXSkwlj5%7?>VM3_uq(XUt zuT2+2*=pE%VQ1oLRe+CLGhV>WlLiv%ryY-kWn)*72#-Do>8v)n#GqakF-7=G5oV|C zr%N~|Bxa;;y!23yHL=I$ zSIh8Mp8~6}-~M6073d9D(*EzEU17H6QlGwD2q+V6`3?90+*8ROAGJW~%Nozj26J?%2UTUdZ-h&otjBV{}WWC8T5VwhePDemwb;C@qy;1kM<-kzFoVUR+ zSHPe(%JwFboaC#9uus*Nw1FF~X%-z7_*5}?=vs}{zm^~>)!oUVK5JT!ZPMm88hFAgCq#Uyv&)FHBWAXkoAso0mNIp1mexF`IIvNh zugOG#zLn(E*izqW8AuH&^_od!F?Hk^m{R)SHl#Q2J^U$}6H)!%6RnDv$fw2Ld$fz& zr=QAG$sFzC*QdXx1kXt?ih-s|dSm+Wh=FUh@)tAD+27hSPZ{yuo-jB*AM5h4hYM?) zi&0a&DIj82xx>kM3S5ov)V~oi*JOU9$7g%lf^UVE#ptN6LrJ~x)^Rq@Bi4C zA?nRDvAnZo8Z&#x(2h*m-~guVT1hO#as5U$ZKHRn_iK|+9}$|rI=SqK zjWGPFwB|L&9WThFH9YfWTI<@%!CLbinY$?Xbh9h|tS}k3Hs4K)DlCDT`Gz$X8wVBw z>5)P3&Gc!M?z}fE`J@-{%I%3k|E7?+Hsnv42OrW89Hc}U$5_@xH_H8Rmu_xImiU4J zE-|}qeUN*S=8IK(nB@k(P;OX5|1M*f%eFA9m_+bK_j_=bcYuG$MI_jpy$^#pqzda6 zH#e!x7jq@^Q0t*#BRBasneFnh(Z7*BcnbCpRdTA~!EsPN zS8zey11=V%60((L&eq-UK!X`tbM334vBznQeT|$qq@tR;TMw+A{Z7!|7IN>)Y>-Pl z%{MXw>|c@X15YXTJch+-IlV-te`Jup`cN3?`^JO)`8X9h1s z#1FX_NKKjR$R-uAHhmQ!%{2F3INmoYuvVKVM=gG6TYZ-CPBlj$m`$R9R7ky2y)BX< z&`9&H*dLC~SP%1Es+o-cjr80cVW0Q#DjNzkDx;Lqzt*@{auR5Y)Vz}*{ADIle3Ej^ zF$Xf@tR+zT4kZaVT{s^|T}VDXxl+tn{6zU$DMQTzQTkKpTHilc%yqoc*AR3iCsMrv zt_@hJ!o4Q2cKVa%TK}5BI<<+?#7uYSC131x>fy^Fg+7Eq4r@NO(b!w3Iony|D zco!>UKTD#bo!oI(*0$tSIXyb-J=vUOFCJ=7UHo%S<<$jdVvX`Ez=aJ>k$uc_Hg6fM zE;pr)Cs)+?2f)0(*JRwhx8P{oD+p%;1?zwdQM`bF;QuopZDHTgfLLWIQs; zzd^pzo3}xo%)&qNZu3|Y{{euY;86{~z_e?aWUG5$?bl-a#7!Xnywt*in*I@`?4F)W zLi$#zH2!>p`g%$-E|NeXZVLi)c}~XnkOOT_>a7bg+9KNJrqpQKQaizO_!LkXwE4o; zb#tJ|2<(BaM9rsCGaRG1p~4lrHJDVMVd%lu9pnlMX-@WeBBmBM1YFTVMws}6O7*IZ z5#cy1mQ#f*EsP_(M33!%iKh0)$(4h~B1}(ddT1_Tfh4R}t!JCm5>b%C3HVTC9zkf( z?7nc}qg2z{U7(wTdG++ZPH?5ik%tSCXPa$#*-Ct#xGHn7Kq@XY-Kx`>;}!Zd1rE{X zAL!<+9&H-HT}@~pPrtx^32zO2qSOVQMG~p5gagae^RQjE=0n6?Lv9>*T!gObJuq%J z>Qs1j!NC0r0~25vL&t@Xj^ujJvScmHc9$UWpg3M~f{=MiO*`dFl24!&5NMx1m5*!@ z1HkB=%21QrY;bLPIlfYvCI0Mo!<<%)5No)R!EPGYYsQ%RXnEGfvhfL6y#!hY#EK7= z=jo7NK){yhdht~ic^uEKN5pqq$jPkHZI7$u5@{DrmSI?P%XqY|MfS$n(wetm6tA7q zhOEIQ2$-=?;zvC7XD5?VMmOJ3j4WbJa7S!@l)j1<>;~f99&Ntpr-IfGxVUGBt!tAF zZc(N}#%GOE_5}#SgU!VAJ}M0ID?NyR?$r{%mRZ1>E-JZDV3(GtBcYbSW+-m2i*2=I zJKCE8v3!zFg3(t()|fL{dy0aA4$T&?tok7=k>h>1xwctF6@gc^`Il0aHFXGU=`gVw za;LOr5yQh)q+}@4qk99x6?rP4;!(4F7!*h{|m({ zXN)hzHmM+pDwlawmU!A7`#8B!z-C?THWmCLbuV6Pl~~gA>#U(C#CM%J+I;$VrDPdx zCVn@R-&*r6x<2D{;sYQS-8NWvBZV}NEydzXw?=v7`3y1l+Czb42?ZqOOm`<%QMO9x z?kms-Cg#fuMLh$lhu_%)+y^9MA=Ox;2Fl~{s+RQk$SCqgk&R$N3oJO3r1V2fmyr2c zhHd+2nGaQtw3`nhYxpIdaTyeN7PB=-PyY4VAtLWA7Ss|TiSfrNq-p~lu`Q9hE!R38s@GYg z%KQgLn|2GpauEk}-iijH+l{^9zT3;w1&TBv7g4D zSMZG8ZZ9$d5GnP>n`+I#$JAMgwr4p3(eSHv|IYMw>g`+RkN>s|x7nb$-K6GG(6syF zFc>E&6-MJd@MVc~?qi0j5xjB!Aqb|%8)7Pb-KdK)ILw3$YoW-ZI$J}-TJ}-{&*He} zIl(Z0*&w5ciycIFY`a{N=n0tvbd#0J!e^G9h&eDj3<>b6`lAFHSp4BWTvTy();xhJ z(T|z)sT~~bnC-9u6?s}1yVv&p9Hx8%SvuNfm1G1Z!Xw05?NmmEmE^c1Hk>E9 zCVX1#D?DAn)9tZRp04ESd$E&wx{9ao*xoBPF?@wuZFRq><7F^80BMchb7gLAMpTxO z=Pw+};HS52rtRq3GEaUfC@#vM+| z>7|C47rfYCem>)5Zby#@d6G&h54 zA0@KA6qaT`Uu!dy|Kc68Oqar+ZIH38aHU00{Ur!~3cKx1OmFS;DwRkORXYQu>PoN5 zy$U^~MKx}JEs@v1_I>?L-`A$xt1A05UKMs#w__Z8ruED=B?-bN zxHgXwzf98Tro?c;uiULcbmalDkB^CQq*!*(F++;}Rcgahd#bWJKYo&6uBOzk9}}tA z7<*XoBN+2{xikAk)SY=leZKGOms71og&5uBy+C>t3hbD@jbK~is6V>HTc!|o z0h!F2GNZGmoazx;X3v(gN7ljCH@oR&xt16QN6?xVi&>6*TR=E2XKN&{&%P$TUu|z8 zruBXcHSUaUk_-WrL9wPmbWL_LTBF1xQij(nmYl^wu_YLFr7J`fvhTK2z4(>_MftPx z5lBQ&Mqn!rHi^o^d?izLG+emw$bm~QtZ+U73N_^noU_Rad*DDLaA#RPBJZYDIYR~d z5vyvaG*gRhvggin2N`$M11>N`tgYd~;Hs1>`iPj+{UZd2&jyyJj@O_Oxx%HUT(!|u zQjQi?D50q-*NH<2m+yi%vZulb&b z@E3Vym0BtXA;z2@QI15AQ^Y8my9cTbd>O@_ABH~tO3W#CUb-!`??^JX>de;kDX419%z)Z+Wa$5 zM!|H)-DvHoqt>%rT2TFwSgSK$?dho+tu>yM?W83Bha}b)q&`&{xwfHf+07uaSop zSpf4#lJt(TLy)?zVuEazSEU8s9Um+mZyGy9Ivc$Z51LE#VfS zeOFqvn`%taSJM}=US^97wu^+#v4xq={2r=qzl&|e3gHh@`yXDGJ=|nB)2UE2|AAEf z?I@Q!Q>P3OHHKvQ1zB(-8#epApork1${F6-7mE#f-C@JMDM-8=>5QC2)3eNT`Rysl z{*d;*lz0<~s?CPk9BhAEnr3U&U4X83!LBo?t};|y??v^&>5~ly{YFLmGAKp(qRa}{ z-Q?wj+3rA6Jxh-(C%|Qrw-wsxCtWlSYNwaJhf=x0{}CS>W*H3qT&8MOS@di6e)RiZ zZGN4=Q*~}_4oN>HKkLUznBKWPnXWwY37Ma!6PQipk5d8rCnRdkqdf6lCssEc`82*x zHrrUn&)$wPf*52w8)fPCZPIOXtP0|zLc|pdVAC4l_)@*6Q?FcqyF2B#O9@b-6H&R^ zl{QLI`P@Ffx6*6B{Q1v(R@x_lY2&=oewun5`_3=5|C|02?;%kStcraNEw62Co;V1J zW|dN7SjziRXBu_gs0%7N=xg|V*bICzpomyiI61bw)2ooC{^(1~7|}|Z=$Y%XHID7S z#&B|Wc_-UC2qZbXut`&@EYqE74w|k0Rvq*0t}Q`xU4*T|2;D5YM^HlZf!0~?vtf|Rl3UmnvO@Z;g(r6U9P>vx+5a_sc)|7bFy{=f`*)l5fw<^(+ z&bzmpCHIQ^X69|94j+wh^15=<`zwG}Slu+dSoF)qL37l7nZIN~_1*qEE`5`Z$C*5^;I*r(8xHqGH^vVR(-s_H4V5G^$<4M};y4k~@CRKlgg;l@&SYxH z@r5%rvN?8BiX383BRNKM&gu=DzmfM&rSnj$yVG^i+bV{oSa0T{FU^R?z5Ps+sU&83 zO1&60k2+TlY$h6N>$f#%#oU;Sgp+nRt>KRf*^f?EElOQ}8vHlJuI;nT3cXUnB6efA zZi$Q`oLs4fWu0`%;6pu1S(akdu*2WjpH+38-upn0!^FPt3|~-ZE9<~^pfG#&>06~WVdS)t`K=-#VNpG)JH{$+bhv8= zYXo)@!2oibHeal(vsjP5rigZQ()%Qo=gF*gAn{~s1dW-k9KFccghs`;@Emi)x+7NA zfJohIwKnu>DvO$?dCk3<&HlaSLFNT^q`wg`RTkY7I}f^wUPXdJwx|h4CySn9>N5jn z#uTJQnVAK|>SF;y6{mC=CDRwF;o3yym_rCX3e$b=THxc*oBb)AoPi9xJGDrC$*oks z;x*hkwp_56-hwo*Cx7Bi4+JhU{G|86%xPvDmR^%?8i6M7WM}%j*Ipr(O4C1*W5B?B z_2-7o_iH^f3Nh+9VMa!V+Ug)JS@mFQ&nYNDUR{x;`p1c-gQRgrRlyAGcVlH@%TnP^ z?>UO0tEKy?-G~Zh^i8@xje-aUjgt@cpr{-)HhVeW?$pipmpijxN^*@|#TQr~?Um+M zQ3>Wl!kJ90Gu+Yd2*q%u%!TG-hw?mB_{s<-8`?o>)dPeKJme+$B9d+M4f2V-!bB2) z3%Asev#Xu9#3*?vsZ-40EiAR|ZkFlf#i8W)y_j6I(C-UY?bE*1qNdAU9!Py*pLPKz z2)ANO>wIv&4&NwW_wseGHVBeYHE0(QA0TV1dQ|=v7QeeaG)m6()Y`>yF&teh$0(w= z$X>0O%2XSwe){zC6z$?QT3n*N+l_pSDU_El+acA!@w$22(DXXEtl~itGm|zcn9q#WTEU zAEnmI@@gFrO5WzpJeI8~^R#-xDa;w!2x`k8*(PQ3g1wvhxyS*5L$+TagFBHaBitdF zELtjOK!u86^`sUIwAQ~IG}ovl=fHmTqaT8&y~5#;jz}491rt;^={~L$&!eREv#cDBJJ0qx*eS zXIInN4AvBEwXe&9d4=dO1r@io(8t@|a%eDIHfF)V&ib#e5V=)Qsq>Z9e}MS@WIoE< zaNkUiR2`CQ2)RT&inmbgjy=kFhU9ND3O2f8L<7eij-j!-ClL(U%k@uXD_h28II?aO znyUkb z!Kjs9Uk+A!(tG%pN0kzdF=T#`H>7**6fyq1V`qM?(qXA}lwE7CYd+qw%PYtwoN6a{ zbATyOB?hSdu+*@3h4gEnVy^POg?9kg6e@I1{RZcGV3JV`|l*}2anCmd#VP>Y~!;bP5ZBpA5I2B%0>c$TRZ{Ldb_Zza zymM9{v#G?0Q`txsm+wSSI*SvRJ0+5(BY7YhM9v$j%pJNm2LpTR@5uFAlNxP#vUJL5 zGx*c%MP_)gQbkj}n^;WwAU{>ckOl7>;7K~da?s*rzo&2Zk5aZQrlLycy8C;|2@o5_ zdMF2xxulw{O^uh5IHj{uHrkGXM%U&kW}`T!b~cJRl8o90Pv%Ok`5DPCkQuAW6T3j( z>#(_Odno;&ki@&TzpP4>)SLbHaXk||~+ zF^=^ualNyZ{Me}5t773Izg%9FFA&=0t-I_v2XaU?F3?e5rY)(OBW0&lR?Ug+>I0v5+N}!Rve0H+*W@^$UGP_KUZ2x zo%P=B(x2<$U&dml7h`c$yVm5;Uj&yzu1Q8Askjro;EUYc>3H5@Dxz$~!Pr)(9u6rT z0&Ha?$x5aWWf1x^$%aSRaeb9%rF`UeEB0bRF%+cv(m-6PZ|C~}ir8!+dK@-dw;pGB z9+NtAvpGZupy0$WgjV1>1v6%;I3hwFe!d~w=ibjy@7~Ig>#iT>61~m{LWQ|OeF7NN zgfGgG{re;}g-*&5{j94TYMhkEt+o^2Rk7|oezl>Ww6=cI{y~~<1y{RJ#`^?c4y|&F z>DpjmOZ{azZg2x#L2<2?O&Mhk?{WzXT1TP=Jg>Aal71oSna9nw@C6$y-wz5_Lb9cd zo@%qQ2q!zzSbDA?K$P@(!x=)CasYUbs3>NuI8d|DqBHhP5XMpTb;A?FwQr?&gv|_Q z`9(p68mlmRNez9v0*Bu}ZN6)%Q;^J4Mt6GIk!Ie^Yfi~gkAEb5L$Of|4^s6f%Vo>0 z9~07wZe{)nm+W;-S9;mxR3sIT4ArV}=q)7IlEq5$sumua{w7s_xx7&~&I>JidTCKt zLR04IqstGXJkCYMVQgdlYpzWem21thqM$gL9jR$5frDq?P>QNK8+iF=uZq25$UO4p zhJ%5b-ujwgvJA(B!$SIK-GL)pY_tL>`eaDYjb=!)1u{&w{h{Kk<5dS;TH-&LpK8K} z>%Pc5AXAg8MP6n@qq>}<;ER_!({eMj;?6xIq{iE&My1qF$s`0$S{|}5`j8>kEtLGm zo$E*B!9+a<1B>O8w%|hk=9*cv#A#-a6tf-^8!IKF1OtyrlD6Py!qaH{dOFl=+8}v~ zL++hw;~%)wt1bALd`V^Aq?(f=Ykn=eSuODe^qEwLdO4E+yYne6pOn3m8D9h(?QG`4 zKl3cc1>%UejwP`p`Mhuw<+5z9edqu(X^U814%d~G2|Lvm6i}BghVxIuX^9g_$?j#pjWE`a(k*=Ft`V>-fq0H({jX*b*P;&e741KX zW$B&Myo#7xs?{_VMPnZf%_C0^0@vDg+>~2MuOLD3tm0gr3sfF0afmMG=J9EEKJirG z5{k+iRIrcoJ&$AgXs07oj2aJ{1hKUHiC0wAf|8BT;74)iZmvL^P$BW$q=;i^!0Jaw$J`Qpylr#(!;4<-!)a(g%1AG-C5ggfO*G z&bu5?Fs*HiX@iadWh4AxH_M=H?KleYq8)l%tS`4U5vWL@>SWttW$P@ z|IB^`9hfaifk&Jq7aIw#H?Rv5IPpwwK*-D#v=QNo*~4XVax_@jmhGxq3qsP>I>k?5 z{sp~^E=>?>yfD^rJq=PuQlyMvKqqcui#CRz04lXMZOou-#FL*E>VZ~7_%&g4+39B~ zYt$w0qw(YoMOZrynu=napeup4=?z(g0O`W)Sr^#R_;4*6_3;Qll|2JPdYbHyY zo$w$Da?pC8^V`I);`C@E@{s*glEn(M+EJp8VUyJRSqhYCvoE~6gS@DywRdt9ogbI$T;?ATH}dG{6Y{Pp?|2ljTQ)Z6ScWT zWQo}3H_ED4vOFV-m&?bvW5XbIVP5gW-q^=ktG3|^S?Q;t*ETwG3kK0+CAcEjx;mC}<7=?P3mrd%X&IJP6#;JGwN z;4dNtSR$ofrjDe?`@Z2`D;A{{TnlGE1-QA*y%rg0D7gNH+>m*h{Hc&X0hf{$%v5Wt zRR6m08DjS7mkdwHkZS`6Vq2x^%VqNm8Qf{B-tEOg`nCWi2ZFRJK9cLgoWi<$gU&h= ztYm)?dy`Y&=t!s6v6;PvucxrN9jn!mbU0U3gge@OKk!4}P_6OFBXSrcPEIhQ6MJzt zP@RcMNUoFi2Yu&x9m`EZw8WsPF1MN6xlz=sUIn9K&eHx0p3}dBTvlI zsD4|!o%L<|r%Mr_3e#Nyz!mL%mPd36UpdJmZIvt&f|>H%5YR2XxD^smwJ5XT(?FK{ z`e~J zmLbGOpUwPzbfZ&s0;u3mpf(oo>P+|V@Gdow0j{>1W7Q%TacY^=MVzfDm_AKDr{3+7 zReWffTBjUcEc&X$N8(O_Q*xG<1J$++{T1g@cJSSsM_{!=I(n5om`8nAc4i}zH9zF1B4T})XCA<8>}P;$lz^lWsa*w2 z+?1Nhb_^uEn}w7;i1TR5CL|)L%4#ASp1u=YYkWZTSbZnCU7E$om1(h`Pn74Ulh@2d zS6dqYoRgS4AtV%hT6~T?BWB!MSP6*cyH4p>Tj{9!#}?JuGt%6+WG z|4BKy@7#Yt$1V#p)9w}Fkx>?L$%nQ;+%|z*W3!z&f)o9r{x(sJ?=`dwUgWiumlk;; zwLHC7yER2K?DB{Zc_BQwA-8R&xTM0-Q zd9ye7E$!s?`eUixX(A@-Z>nziV{- zd9l}bX^DM;l!cOr8O~fUq;Jz;(DGFWFZ|P^WWujsY;@wqh_h-G=^)v9DJlKbVUfJ- zZq7Y+KXxH2r$3_;C@XScl;QKDa0m1!wSp8RK@P{Hf3CYu=15G{EXQRtt|TkSxp>d? zbF%4swYD|KP0_|vu=oloGDVy4+7#_Z-X{u5L6Bf6eLfA7Mb(PS1I|_{>*)cm2Ala@ zFMYd8&@tXug^nvaSPyhetAj~aL)k-RE$6y|OtEk$_v|4KWllc@rALulC|pRlu?j$l zJ^|IC!t)nZA`N0e{1?Tq%9ARBHbKq4CKGpfdM(|Rql_whP6G;=)S18K!FB=@I1Ae~ z{lhlrdM5!~L$C}CD1=KF>DDtsviWTK2lOZ-e08|=YZ7mYVjXVr0tdoEDX+p`gOy~O z@rGm*r~;1ZYjQ6R2mQ01{SmU~!i^gb+QxYEzbAYh#eO#ScywE*auSi+dL0B={@^oq z+854K&S_A&OYkjdht9UuoNPp&K36R5r8i@cw?#V{3Vb|UEh&G*ic*Gf7JagbU5jhL zBM+nne9D6K%v1m6tQyk)XHx|(@9jD$9DZTYhrgSeNGWaZ+w^+0RZ_;hxi@RzJ%Fy| zrdqs>9HN~cE~_Sf+PGTOa(4^DiPDg5@36-q2U5L`hEw--v$canaZb4&S9^jXG%UMD zR9!AD*k(;VIo>i*Gdfyvyik$2{VEdofsMAxteiB8(8;(O3Oe$= zPk!7fI3OT$Jm-5F&-$Kb`mCJ!PKTJ(32Ni3%0xUq%0FdOYTBpW@Q6GQo09*LhYkFx z#9S!7Krme>{gPYNydl%;7u|lmLcvpOHBEG_$tQfnSv8g+-2QrX=exhA9{W-U99}Qba3`? zQ@yDQGylv^z3TqwR`#>r|L5MZWbahUZs!jXAV`oXSBtIA8{AR*`5Vs@o-8p89L^>z zSG*V}iitEU^nuhWW%C*RT5ebW?1fTB?dq|b@3X7NI_4s>XNJl}cPBWTbG4<}mf9O| z_U7WABT5Be=(V>`cy51bqu)EUd}mVxU>TXxRJ^LPU>frroW57g;8`(4`PGR^?%!?h zaIa1vSD?~RMgd>O;UGEbp0i5EX9Kdm7lYZY8RT-<#$G>HePz`^ z=9XT~A0|%MZftxf#>I2&F?$K-8_MCW)M+SLOFW_-g*VudW#opUVrL!SC4u>$6uE;* zntATaJt}9Yq6ET0=aoE!s7+)1h&%c{qRg=(758>Y9PpweC1PqjYUz5s&r=T_I7~!g zcoC|(x9l5>gh^n8%8m^rjzJWb0pxk?m1RBlgyi5H^gxl0>Y>@5S=-yyeDW_>hLd?e*#I9qz}ZY87PmUx91?yN)xJ#gL zdoY=lRe|Cr$(Upew*)%}rK@%KYVC=T*WC^@hhb4u-xYFy6t4T!aPOBThTf=S&*yS4eQQ_X zER2|}Qg)q3f%nWWgV(lN%4|3$yk1vVw<@l3G`tWh)Jbl(U;jV6Diq@;07X|H>LSvE zVmm@;LA+Fgf&D@4+WjFM)bVluiyZg}5%y{{(76u{TJ=5Y-}1@a>v=%&j=J@c-6Ne2Y6Acs;fOU-T0>WsZg-N3IcAQ)wXL zE1ESr*(l7=?7UEwfu9#yC0DA?FW!Bc`I`TLT~@fgm`o1M%xUbIoiQ7w1(ubf%pZhQ z%X?R@Q>6#Y=KSCl{nO|~kxQd^qnX^~grA1k|Mh`BDzs$Ci*o6@4zpEIfZ9%gp@mz` zcHXhiBwCu6(x`X|_vPPcxJi(Z{iKxJYIIAN_$O7FVR#|NLIRHJqrjmhKA}?4#20JU z$MTr`i&`Nr{ELi|Kqu$R@Hs?Y7W8v||FUugss9g=SUBd-hW`h4Rf>Z+zIUs{pr}MN z^CJ*+!k(&4Mx9L#$;5kV;j%{E#|_Q)B$VZ{T{%ClSEp=2%9YUUP|#FSe`Rgmrx>JU z+mZvfGC8GUeIe=>)f=8luE%`7zH+YTE3gWT6Xr?rUm*0jfbLCunV#$yyKl`G$v9uo6#oIN8* zEsLj)Cv{?a8@dDmou!&03{&dTRJTal^OB3bG%oAaE>h&`sspKs>FyqPJJNYE)LDvU zbz&1d&8qQW5Wz)o0HAIk`6BN9sa@No8ZDud%6uW#Vq*Te>{pZ#MOsuCYEb5*(u(ZI zip>-PW(6nObGmy9*+$L)ZPUckAW{j9Yl(rBk&G4BS-y+VU`dCXR4Y-O7!RbLr<;f{ zes#6hKX?&WM#fqlbf>KG13Ww$;(b;Bpi#F!;@(9srC7-BXycFQX!_^;5&2h3JOr>Q zQ5tPnvZQLy+GBBG=BJm*blU&g2SVXCZ9d6zkP$GYXdiUAGX1GL2YVe|(KoK05e{Ql8GEm27UhE*WL z!dgRb*-@a!Kk}rOf7IO*KkU&SXzfY~Ie!Xp;|DL(=I-G^kAG2sg$gIi#OYzGxfFx2 z&g03IPLn|hpS03+2d(l_Dg@z7-GD3|)-nYkWz~~9|HE$k4l5&Rqcjg|9L>JNx~4T> z>o(W4q?`*lc=8e}!M)bnagP&Em>@0|H^&m>CAVdDu`&${}U+Ii<;3Hx_DOH!DSN>=di824=UICpL1 zk6J7onFyAr$+$&wpt^FariWa|8CJr(NUq#bBUej_0h4c#B zq{2hFmrlqMS8$fP%szTLsmZJ#Tohn!FXR||TO%=sAYfUx7^wzBiukB?EN#7;)FfdieV^v+mMR8VaAo`Z@XRSv(ET)F%X*DBM zjtF&5r6kN#8N^BT?nA8~dd!D?catvXoMqY{TC_h1Zy@nWa^%=$^i;~J@sKK^g?@}) zSk$SMPK--_3qY8kpc8_kl-}^<4%!Vhr!yJ}{ zVuJWoK}(+J2-^`W!=xOPv1e;A{GYqm^$|WJW;)(o zIPJ>)ZQj_q5+l5s?0N?Z+5K&F`%&J+NBp!S;Nf@jsgqCYH+Y(AEZxXk*h!_q)0_rp zIYRHz4Q3_+KDqG15jdMxOKn>7DtPc@wb~k1LeZvh_1ihKWnSE#y8Yem9^^9PxgN4> zp|yI`__F}6_iW{QJIObB_8U@3*u9!4?d!hlD;E3UaJS(Wu7#Cmp<|GI$C+brZ%^kEWkx;{2dPho7ec&I|kUGY2!seGgv_L3@>Wa z;oM(K*Nya7sZe&7Gxd%!1pt+sETuGU+}4wLC;GEzh5jz&G#j^>c2Z{#=-S55jDcMr z^E0-vYcuZFJRAWcURTg@wy$?zMr9vtN;55#vJIlJ6fNvdB(s&V=b$`aot~xRow`&W*HG@|8V8ohAaJ`SXbA!5Mgsk=wfgV{xx?#Ri zYrd!Afnx$wYrbAg&7cz_C%lW`Z##}XYq7l;PcpaNMv&BZjbqStu_7x_km5;q(cYibT?3o zHeU>o=5(w3FcvK4*(!R2zqX~eRdsxPTeWV!q{lzJO7|ZU`wdiA7qr_+tkROSUXt*D zzO{|(iQJ#Jem)@HS`1sU$m_*F=LS zT|HeN+W>hjwo?|6Hh^)8`@lwPQv1P3B|)&Y#GhzD3k%lO z#pbToUBmDy@_*v&QZ%{T>1OYIHAuL?1Fc-VOmtFdE{yK4^`JLweX}qeSR4CidMIP8 zMH3Gd+(##bzi_2jt@Yhig~1EqW9$jF`L6+u2$mdd3d>m$A?^XP3tXE*))$_K=K^u# zJ9(VS&KiM2E3W;5YQk1bJptD9iT&gj$m=fq3DV>zrZg=2{(* zk4TZl=I++r!&}Uu1jvB1@n9Wyi(y?O)&G#_%;XM==@T8SE{w!qx;vYgD>39N_2wK zzn=a?7`OFJLB#8Yx}WPqd+O^Q6#Qk7_|kO3$accIip4qyGOm zEisA2q9My5GH2GB8Qt8;xm(2C$JI`?<`zyWg!db2RS5bw>&t{HBX#T=(h@T1*d;PA zYd5KxnLY_DW}nZ_d;Vtcvry&eB3z}AY}}#77iNwMnlA>;SK_Z644N;<1!xRSYp(C< z+NK|WSRkH`?QozSJ=uNW?T{5&cMunaVituHSqjv|&nob=5Qj=&VW_#D`1hx4&Fk3g z#fD-@#SDpm;0c;r{jad(?E>mn2^TDsoNlgz@9JG!b+>B$LR-!ZOX$|fC#eY6rY(4u z;UiWN^1`}?zIhbTMbcly2cdTCqhG4EzU|%L)(|CXLn|Tov?d{P8Et_x*!^wQ(KE6i zH#i?hd!4UR|IohmM}vLqF6%A+r)+VQunLm<+t?BPom8g*^M0PwP5fa>SD;5wqAt5e zH}7S}9L~el#U+@YO*~(`?#j!!Dq5r`Ez!kapn_ec36sM;$0}S>M@&%SrM?B~oPGRYM9Y?Xmdga}qg&tSxoJevA+mRF* znU*~~e$@N8*?H96Z5lEKqqDx%<0uN2`CM!)n8(}z!%clJY31#iE5dax-1c+hgb5Rj z)>Ij%J+0lt5No{EJaR8QXd!-fLaNo8A?d0GhBXEuX&+IGWO#r6fOb)}H?{yUuy(Y@KFIt-#M8?Fkn|tw zQH|8vzsdX60P(qwv_X9`SbiiUKaw#kmkAN5{ZVIpTVZuWkNb@E2i9A`uVI6@PWQJO zb+6PC72I579M~APyrbb@UfBmK!7u`@r7o0pVLwr`?=O*0nPR!K4QG{Jn}K~Ru)~_lA7Umj7{{}m8uVDMgnXMg(N9(adiTts5dbHtc6LU zs1d?Ya-r%*W*QO!POJu>IZcvl3 z9-a};vbUnFjlG*Lq#T7l69spy7E@XY8)jILJ>XtZU4V#wt0Z5GHLGs@L?S@lGN{&b zi=3tPNVJq%t0V!GB>EV-`*k?2`4%A#qwz-{_q2L8`~+`*Q^--Sd{{7qO4EPk4}z{o z1zfR;?#))gdBvKr`6@xIKcL3_Vqq6#r_QcA%w8QwQV|a#)~IL0>Y5^n!aj&$6?;d@ zlU(o8QnYV0@5ih6FJvDd4!j!U7`A9O%<`8RGiYYn9bsq0vg8mE7%}-gEFBzec`tXj zAUj$^o6~Oj?ny%`-*wN6`)%5(q;CCm`fXUi8yBy_m;a6W|bP&G~yI=%W6=Xnk0c$tZ5?z zB{GxwkTO)-GBv>^Bey7AN|GMm#cpi1j}4K*nXe6w0Wu`pP2_^J|+-xK< z9MYQS3*q+ag+=f3ftzckxdDsY&`#hZ45zduRlri>UQ2`p?fzE1Yg@$paQQI$My;o~ z@C9O$iG5wX#n9M)7gz7mI$DNk6f{ZgpP(qF~L@sY!K^OJ-5!4&qXddj?0e8RAnD$tWt zCX_JFMbsO{PylOkSL#$^ZN+U38#gVEp|H1wrE;L*#=g(an?0-8UyT}A2@k@Y?J}A* zRiY~~U8TimWu`BsTGsG4Ic}65j7U!OQjx60=0@!ayBHFOqf=K3bjY}c@0>8rAB4+< z9R80J?fN2^q}cvV1eMs|AnKsdDI=#VJ(yskqAwM{ke{&nC$^LZQQDoEjjXZ1%7+Zq%$f)D&!b z-1hRqMnX-;@;cJw2&a!MrzswA&a!7BLnaAKtL0x6gdttY0?&&rNA4q5X?S5l-Q|jLAp2TL((~#a*Ia2RBlRBr?7h9 z{n+9Rf&d(W|E3B}i-UqKd~D#grK{TJ{MA*mZWyL(s;>Mu4ot=lb@zcB1F?7uIy?Y|G~^XCx3O27(& z@;mTJYzx`Au-_0rL^S>wtkSv$lUusv(z`yA zLvlIQtCqGGhfOX~g;4RHISx)`AIi#X94EI_b1`P>@s94E3(4*fh3Kfb+)nn^wSld% zx6*Q`FWURbh8q=roGp=?$pc$1N5MbURsSI}vB1ReK>bp)p|q;%?gCn_U@?D^RQ&CV zqO-~SE_q>v8~M=|+)k%uLssmy5x^B-P4XczSw2u)4u-}2F#a06wo_q|$|g(rSj3z} zLUCluFWETBL5R#ggu9K^#~S9Bs}8Tu`LY5sh zbXGqxslmu;s4^JU8h8c2y&o38iMKB9OF1%m2SnfBH}Fpf>XYR{v`Z(cVs7 zw>qnzPk*0~Y>G1b-1Wu9S$T#}5IVPf#aBLhC1a1Cz|)iR6#FU>a7xeQNlW}UfA`15 zFpTS0t_5UDm(Y+F-PQiNPWt=2giTD|7B3}Za-r1X-)ndlOU1QV?~4b6?IIyA4oR<% z9m6&7S9e?rU`1&?uZZZ4_HMkJvIc8rTnyIGC3?+;Z5(>eWEi&t7_lX(XSwo9T&ahIz!P*X~$n zTq=-%bWR$VQazNq81wiMGGM##3YmDRPr6yJ*?N7CU~8(%&baC@-x!NCL{*DIg36M7 zzMN`$77AK{!|l?B^fV>Z$mM&|yw)i9`ZXjM@#4-5bRHCJMfsZV#x6&lMm*=no&~&h z48S{1tMmK+3{A`eoQ*H4nPEf8#?ilrQ>6lO^sfKmz@tBRh#@^e8gmj|oE36Id4=xTZxzX|ses@MIH$W3@TRu$D{) zQ>m-OEj6BJi`m^j2y@puvgt|4p%SK5Snh|-4Po<@2ECR zlI}<98Va@6cqN@MT$%O(W!@V8_52~u}i2DFx;<(*7shDCi zDUjs76}e)pLM5Nw@yRk_ADhUxtpO(Hl^fFa`?vO;>vhw z@-fM3qQBp)Yh!nCrC6*X^JKRF6Z`L=M6H7yvp6Fli5TRHKoj455W5~AK)^gMEsJn< za>N=sMk`kftX6L80m_wPfb#%0{5QX>-SU!l+ly1QZ@)l_OS^fMMo5v{h$irDq6OU9 zIwh#BUgMe)G>=zLZl1yg>XE-@*sC5r@;E>}l3<1l)#GvUc!GN5n;9;eqOEQjIK|XY zM&(q7)La}1yrngY#vmNuf;q-$6e?}gC$o|&xSKr}-? z+!p=1bJ8|9>qP&Ke8)=veGXs&%H7Y+BIYI>js+lUZ$p3%lvs+>FHt*!&DH zIVNhY*YB=GAakLY6Rc1<>~?7 zWF$YtKlMhy9Qj=-f7E<4B!)zyiC2T0!5v)ud3iU-;Ns3?hZ%{O!+ql9+@~UZI0?n5 zDtYcM%G;2$`9afouk0h;$&xwD)lWKt-eT%k+Ya0OD=d)!h$ns^6{D?MShcdxIIuBu zimEYLk*eo|&5xAI1PFgs#LS9bPlKzKYhZOR)j&c$nU})w00cDaw8>v6JgfvA*_%Pl zcJL5gBKl?lLFVtO?#y4+o0|I2^4J@M!mQ)&rJxa*E4(p!+EFZa#jln$E_EOUm zwJ{2vNrI~T6`OXHOXsl-`{O&1Lvnsq314BgnC|0>pe6oEHBg*d_uj}dX)Uozl7%3| zKhN%e5o)(^;9c$B1W8L>WsV)rfoFvMqD~gyyN?b3`$nL{(8lf&s?5l?0H97tKA?EC zxdA@BhkB!ndFZOOf)BXl6qFupF^T0Y@jlHKV-VJkK<~Y?O z*)+;XdXdGlE1t`xB-#jTx4Z6y3Hm>9fr#%gWXDt{YCimg@?cg$r3z-zGsH_ZOYOFy zu|376WEX-T$R^XCy^iKb;a;|D?Ac^<_~CP`p6!fWXM?O@LySFOvfbY0SXJc$AR*@w zs%SXyp4NCD`6K3MOJxuH9M3NOz|*R**b?I_Gy+K~ON0)?s3Z0m*OUg1O#k&YmiMY~ zpd+l+UyP;8;rb(#)F6g9ZzN#qq%=hCQc&gfAd2sL;Nvs`c|5bed?>GsIytTIT>PB+%dKC|X5 zhjlu#M2UFpq#9ATDtS+RY;VsKL-Jf)^4(o1c1$#v{aZADFN@~C|64SFu@p473Z}AX z=E&>cV0i)A|A$!qj~teNb4)C|_y21ouifb&S;>CANR}(m>CXRSBm>X>kWBJ1kc?vi ziljUw!oBR(81^Kxw~H$^$RTXxCL_6Isw}-cpO9QIlgGvvxOFk9#5;q~Rf$8aXxcr0 z<*(sit!9n008tSKMyu^b0s3+L*Y#V4=*Hv1pV@9y{=Fbzp_O%lf?H z1KYG)l$_x?s91VtD}K`8l$l+#)qtSlC(JrvkxPed&Q zpWl>vWtYgv?1b2p=|sGlLTvsSUD^`b#L-U~ZY&geJL2ENp@M3-KP055Q(o%ZK=V?c z#GuN?htNdq!>^2h7WVkE zPI@(ww zD@q|P%{4~RT~_w9KH#dWySj_6E=6FW<)JCyBKU~9s~|oQf{KDrN*})ObLQSQEd|&8 zeE0YJ{$cxS@7%fbaOTXJGiT16IkSNpuzwgshTHJgA*(oGwVpx*bp%&~fW4i8xsZ2G zaK{8iCvX;Qumw7-0dP>AzEWmn`iyTUF48V#cp76%u`bQJHN zK|gTnR$WRe4Obh+T_URz%Pd6SajdkALWJ#W8 zNdU8Lgqb{zUS4an2r>b$&d}Agp<8h?eG2hOOPXk~{eo$Yrol8FF16xTPC|1Dd9fep zj<^VikWXDUdcut{*fRb@q3__+3NDDTA{1>THh`g!Nh$G6rKb}<6tMDwsgyfw7cK*U zl_b>RJV#Owd30|_zeQehF_uf7JZC~votnyXAqbQ;L%Q|_wkeAjqf~b~deDW&pf&_- zZDg_nmyL)kAqxo_G%%BUi|XqA354RnmZTy$27Q4M(i>?U;p^Z>8B?|xImf| z4xA%qWi%Y(gGYiSSP&s7Q)5NONHL#knt~qLqjmFWGi)&6E=)3EVe7jb3VoR77oLS( zkQ6Tt;KG!O6cTPTwujx&D`vX0-kZJ2r_R96hMLaX88f`86V-HF=3t=Wa-lN>Kod!j zn$p(x=iqRc+K#rZ2JBtJd==! zg%8xRU?G*QSiZ;hiqBN&{PxKRehLnej})Ygn~LDHBhF6&9oM}ElM5~bc-!AgtEL&o ztvyb24v$ngqogSM!Kq-1rXTUCedw~cQQmn7;IM56Nu;BMvYVKiwjIhR*yMH)KkHF6 zjrTonSfGHX688`bBW)vB1o(PDjCO1ALix%5BzQ}s{dCHP7K#VbI zu4M)exRlftn0@3f1CEe`H{ysNg_43dT13beywMsg=(d{XDzSENTa|(@*l0#z{STdX zdl6|I+WXkPCzDO^1v-phj$nuWYCr^hPh5>eff5Sgq^LDGrW;NFE4cm8 zi!4lXhOfiXPvnMaY$Lvc@}mQx=2LpPKVwcljs1_z2zMs9Ex0H(+^1OYJx?Fa&73Z@_km?@Zq zAb_SIZfTrl4UX>S2p8Mj@<)z9O%gEXu8n2}yNf_Za0JSwsI=e+6iXp{a0E)FP)cwF z3Z+m|a0JSvkS#dE8qDhk`#-xk>jVFYP+?+dUQ%dOa_FWMb!CmZ@~C`BUAa}RS69L^ zn$~Gost=RM9x0?PYYB6>c+fQvcuS#2^j#!y)b3SqX-A4ykxCbHVB?)A3Ja+z3iRLb zff82Av89jC&mkHFvVuP22f^hc1hwG7=!@9QL==@lBoJGbzKc#40w|BX%{w$XRjs-f zU5K+FFeNy)8<$7J6j628%cG#Gi@;3rL|F_g|96oWb?w9hZ@a}CMdFRD7VwQDf6Z?m zItX2Q)RSV6CdRE>L50FAw=Ev71@v#>L?wXC?d|I>T$IXgFb|y-0P*$H4xg zM!GN7v4Q`qqdr*FNUmM6(xd;X_k$>}n;3G!;hd>J1K|epQ?Y?9_?9zJ1*yuwlQVTJ zf_p^TNeF%}g5wa}FM?hK$*Kv3O+inm;_3F{U#?e6PK7CfFx?L{B>Cr&@dnDXr3A;@M427oZ`06AVFN_@$=*ngQ^Z*3eZk!;lh}xF1);mjeU3 z_NyQ?q{<=M2NR4vfW`}bHjddwc|}KJ8LD<`Y(6{_!D1~1|Ho_N6g(zs<7{}0)y5^_ zF-aSjgvU5-TrwVBZ5*YXqK)fI$Il)@(e8I9(OCf8@&H?tAho=Kj>45A6o}YxT!`XG zv0Qr~Gl)S;fs9}=#wvx|0<1kjSRKQVM zEJy74H%-RBOgapa3Co+MsK}p%mubM^um})~2=HGe6{x|~sjo8TQz(tZcXI2UiKi_( z3uJ?iqk)E&V0e;c2ED-^k_KclKGG9Sq!BBx;}MHGX*Xq$sldri^zuY1VbDEE1%Gf zzVKlMJ|J$I4leRDg2PuJ9t$RZ2%Br9Xh2-M1b(ib2VyDBd~s6ve#%VKaNPQm^+0gV z7rN1gt;vdukON0aun`n0P_TFtGX8KNPExB5BYUVv_~zEY37la40&n5Pt-Y`}q)%sL z(B40MeJ`*saPtGH;p9AZ<+ktwn+#tJS}RviyAxqoqV_Q;6+RZmp5H%`D;R7p;ZTa? zrbv6hd~^Fsxp<=}#3|xo6A$LgK${(VUu89P4oTk?fXX&>n+>*QPN7OzP3h@~xP-FT z(?4|-&Q?af@^|pnhLg*~3PE?+DW`OB;07lx$PaTyXV$)X5uzZxq|wpnj+!ieVe}>8 za%#6EfCawAf`@i!J(U$`P#2oDLpa~w4U=ak&dO@AcWn4|G(mlM( z?@ZnA5M3AQ4xe6!w0hhF2NYqn))RWN4$W18-1<1$WYxvn4sD0JsyB&EXcSPk2aUmz zr9z;L9zfY1G=_pe8AL1&lC*`!P%Kck2aTa1P__psgDi9)6DI+eiuTzT?WLwUvPR(O z^}PtH)%985sa5wN2=F&Ugu<{p0?`b|*|hihtY&x?94hRnJ#G#sYB)@gRj)phgX9=4 z58p<^CH%`ISNL|wRgjtXSc<}4lP*_b%@{jV2p(^#72l%axX;H8abp$wYi}kj$BJc7 z?PnR@1ZYTB6?fC0Cd8%bVKc&ZJ**&{qK7RACm{@XGI~R6T@ac)^7kY(!NQVIm5Jvq zz~Vk&aW{p5MtS&nH+<6}l9+2x zz%|b;L_|q$nsfNIFX0}C{U97P!thc7iX653AR*P~f&50pfyVqRXf{EiphxYxkPXhNQO4>1p z>S;9J+gH1{uMkgnm3;-e8_^URp=jMhBWxO;dA1_C!Iic7ffD3pz7U$#S6w+PQPySJ zU1iwj*$RO%3ug?y@`sMlkcVp<&Xf;@gCu(_!mb-l0%d5{aFRJ#@W4sh;UsXd)S-GK zd<6(iT(7Wh=@pnu+8xl{La%Ly_at0e#C9mo)Eda9kh@l6Pyi2*m5A6gam-6y<X z^uT9`Y`}njlM)1KNMbkw!}(G0n#JM>Jcy_((O49;n^Z@8u)7G)DDLo$WOQCn?Im^L zD^$6=G(vOV&M2FI;q!hfO-qUX3!D0#cnt16@j%if$59=%p|Bkk9Gn$(P=u9gn?m>7 z)Rp(6{5UtCZC+!YsmW9;nEM_v4|rV|nl0&{XrIE+g^*-}%7@F8H^E)08SXN18vshS zWZht!SMSs&v*R8zL{o$^_$*$kA~O?ICA(hWe*s5ag2+s@gq?8V=O2 zQ|R(M9gQ2`xD0tk=Zm8>+W*k0FYQlh`0oxcrnGKtaRweZOL39@nu}Mbb{TayrfVWx za5|DKDOWpnojj}}t-N=gFcnq`-h$Bo6#K8-(Ua{ki2oz?} z>#*E`c-4j}?i0e)%ZwB^H2X<94q!+E84YIuR~b04P(ySaY>LML*@ctmxx}JUY?TV( z5!4Pd#uVhhb~;9eUMdnfwY3C9B#?^#^aE2ugxq1ipb(jKyj?Ev77%zF41^_X`GmI= zIG^JEbL48r+u6eQfiMy$t8lf1HjwfOSdt`BP0(puL_0!j2||iU2ryIBVwM+Q!gpgi}}vQ>(bZ5GRls*RgVr>H-@Xq1UJj zcueSU^w;5tFbo7yJ8Zb~s;%>4?=n#uc2(LB@TC%}rdFscuOYdM7(MVNqH8`;Htj|(Jl|BQt|`Ch#R z)ZNp$42M7AnSV7xh;cUTp*h8G%eaK)@(&b2TAGt+pDUuhj#c>o-?Z{c80R8-V6CtoK%{ zt9*#}X;#|%>WBDci^WSZyrs@ z;YpYfkhnty`+o#foEujjgBXfd7BtZ9m3n&74d!a@hETy$j%MeX?m)}Xxub{+u7RTy zj7S`E9*%$@5^W%f{jdgl zP$~9}-aTsdO@n;E(MTA66lMxhMTMCN#pC>(FKgGF%kabnzUnIfHBO&1t8Vrl7`3U@ z-{TnCdA>lSJojw4NbqSl4T?oLziyqn8tCf0O~Ay9<~ZjnIK=4Wg`1~B7gmx9 z8+}+Gwg^=@z7)*0K-8X4V5BVMl!Zv?NZ16+j_r`ap~7l$t4oMkp%ga`4I;v$E;)pT zA_6K{z1SwT8h#V7R0ZzgodXY#TnjjIk=~&$c~zu$PNn)SmR3#eMfMns9#slDgPIx@$mu9~J=aX)6lemH`}^%FRm10_0I3%l8@ z9n_lsD$>i^PCdC(l?f|b9NIy5c&aI`T$49E)l9|yAc{3}u~?!y6ZW8pZlXqjFiq`- zq_`d9U8Ge5PJ&%sHA%HOYCpF{=>&l%JQao}UmWsb{nI3=6=YdNO>HFoGa&*VePUM$ zWL+1CfdoJ1SdsjVORE_fPR#IOP1T4``0siLMc03Rvh z48raOzz!rXXTkw**l{5oe0xMvr+OhG>_|!x-O=D_svS-{K|NdWNOB~+hdX2l=S1d; zigM{XdA;1R!1`w>_k9<3gu5sYpnmJLj`pt(3xSYde)*ohOs9KzKCPMCV-0}h--_BpaZ!*p4t zOWOvA1Ppa@ZyavK#mV*5jP7vw(HkCU2_FeKI-Ccfx9WKF_6D)s0f$5N237So6ICHG zsAVTg>4BrIb2L0P;ss$zy+-*Q=)WTegGw0TC_d`_F+A?*+& zE%RQN(@4v__Xbyov{xHx3%J|@BQ0~^8wxw5%``r`DeVnzW?5*OhhQio6-mN29o`$S zb!$)2#O{j}43p`9Hg2J;Ccg+cmpa~z(ZBByl87mNBX2r?X0U2@oX}Ssx<&CL7_t#Y z|IOhm0h&McQn9mWoKNH-I zJjgL63+dVm?RRJx)~=t#iW0U%$>dDfjwX{Kqgr_>(qityd{^Va;UG9lc?`ynEaD;V zYxt~yBTYC76L@xJ&COJoWFQZf=nlKPF_yep$C-Osx*^J@pJYNDb0rJdFmWY#;AD9a zS`F-EVKqYCNJoW57}E} zR1F?d3?8x%5o+LV7COgU%wXQpEqD=}jc1GKdpI~&XOf~9U?Zb0PnM#?IDnX2IAE5d z^Esg4T8`*%k(zc*LNGuK)PNNCfD~c3CWs?2|624}8BCmLM!Fp{5-Y*r{0PqbJlZ$W zw{5@^8WmeF=Iry~KExBg3DX7+TzxjjnvZEB`+QG$6#O?I@Mi6ulYp49*%uJjHX<66 z1`_Vo6JF>E&$H7GO4gU0(3@>%(qkS0sK&WNebKY`^(hJ$_VWU5U{n){QH`!8MpdJdox-MK-OhbOm1*3JzV6O`3XWtxM~sJxu1DW zesk`lmQO=Ci%F*kcLb`?O^2Rn{opEWkAx)xbke zv$hSB2j6a`SSz_!Ig&}-pRPV%ZSyS#NJ-3B&<0K;Xe2@kAO96z< zoMmjb717;jZHO-!T$rfSnca<8EGFrsgnBLC4v?Vpg-I;uMh9{OY^X4SD$IpjLZd=| zb^>+d`}hXE4tC~sU?__>yE~%cV-TJ$xFiAN*z7Zy3t`hH;d^aNDsGz3PXlC$090Kv z)XKE(%ud9%2rcp9-2{I^EukOjQgA05g z3Jr!I%g2r6G|?Q0%H_vR>Thb{Sxy@{B=A{Mc_ZAn;lyEJV^VNT@7f0VfR}^$DJVlF z5D0@kP=+&`Uj;G6Zgb}xb0zBVceqV36 zKO7Bl3FN91tFnZ;C#n3t6!5Zn_!PKr2tv~la%$gthfYehaWfZWD?lo}+jR=F5Lz42 zuN0Z0;{wYG&XmE47NDoUvYkZrOkL=BJ#Cs^0SJyO$ki)Ih_4`1ub{i035&bGKzak3 z7NCQ_vPD1vU0xaOuP0tk{7pH>8@?W+@U0?55Yt(3 z4tC#d2{6K;Ib@7`c^rX}Q#a*7I2LnbZ4pGRl8QT*A62j1G#Ad|dZxu5L?4l?4WmdU$O@h>QUF@=xiG)vm0M%7erMkTvYWk zRrL~A^*pLVH6RnHVzH42+(B%BskA#JxDjrcc{m0{5+z|#&=+f=4y-72H>_3Wq~ul{ z_20_OO*aalj>cWiHG=TUFp4U_e&Dh2{o*3z_O2KePRu@iM?|}0F-XPuucF>0w`O4% z{JuK7$cdq^NmmK7@0k&MR?tDT5rd!B z%(wHJ85bbY$|9@aT6IYfTu7}Rn|gakl?kVCo0pJ~?$*d7V)H1W}oeu?bKGhn+I z)nNu~7o&_Buw9Ibn*sG1*cX^j?63hiXOS+t05)=w{2`*|{cDJ|L>=(X!IJ{QU$Va# zLtLO_p77%&CbYGUCfkZ^ilU|kmmCslzCJk(MUk8l416cjd~k))#jmp|ig+v5jD3OSz!ALDZVLo-%o8kJunf|s^uV4UK1Ck_KB&WR zYo1z_&Nkdis*lWur095jgIv$+5V!e88;`JHcSvC}2aCi?12R0!NJ-G^7;Az_DPqkX zW6dxxMXb^>R)MK$AYx(NmNV;HHIN7sX|*~6qeU+`ReyCj+)R8bfgf_iAU!KSF@~M z(dr)$0sVFKCvF6Tzu}^A#p6U4j6ip2SgJQ2*IU4oFy*Q%C&`~Adddu`W8R+xOB5d| zQXG0G;lI+1Tp;Rwi0njY6eWo9C4`WMj5a%^p(sJrFN-u^oScTDL^*#JX}&x;4MmA^ zs8-bV)yZinN|ZyjBF+Aj(@>NshiXL{+JWu_GewafdCY|vvA-b+Lfg3W03w3FS&0{R zjVTA0yn--FIDki|5-2LJ1OmRT1cK5ifuKP*#PDGL_$n+gm|su~dETtN8#EDFLhOSW zVDu>@5Mo_m^OQL4+)2tTm=i#mMYa#P!s zlyztSfk8Ex;*HV|8 zAxCm&Qi8f%KY|N5SYD2Yj7r?O^v_BEhTvZ==H#BanUQiR+W7~sq4`(O ze#)(dmI4H$3}xg#4fX!Wi108VD;dvmz_73;zdMxj^> zHDkj{t@sWz_M{v9hoAC0r%L!#=r4Ti3<*OxRm&$HLo&ZfaSX41A?cFs# zL?9r(7Jd=NDXHuoA(hh8gw&q?<^ZQd8tkl7B0PM7`?E1a4+* z@Ps_AF8P9cVZ4qJ(QrMHUVBpD2|aNYdA?#iid^G#bO}5X4AD2axTH#=OmzSg>@Q9J zivZNkZScd54Z*42%&ByE@kl}nom5HG?`6nfXE|U%O-sv|O%H9L)Le$3Y)TH_GhE%= zWCzwZ3a3vnf*Wwg(pH42uwoIQgzW#edgZeD1Y>~QaiiKwdIJR*V~pR6w1e&U{iNPzwO$}{pF9=jd9IQg+5>BoWh|BYkWN{Xrh(n zvEd|(?b;vMC&LDm7jk5pfN@`+f@oo4XG zKr@KsZ^#h7A9f;w7Yf5Pwcm zWivPM1r`p&eH=B|5A zc}Og)4R{xt_){P!!etnBH`amH5^?7R8SqZ6!Hou&xoaExX^qB}7SLp-M*^*h^X?{3 z9!%x#Qe_Ry8?syX=!IZMo2P>R+LPrQQ3nJ3G&-&$z_qOxrZ>RZJUI#~-5A#rZU-?f zVInq;0sUU>UxRaN^G4GCuhFK(|99I&Fb7)usa3=|{(r>Xf2(h(eaz=z6jmm0V&kC| z=h5*T{Or%YACpHUkcmyIats1rBv6iTv?Uu@Yy>J0NTQe}9HW~Yxx;gC4MNogAa*`< zLE19-){FSBRI7Wd8@8z%3Qg&?T7B5lP4(2{G>1D}a0q*=zl2MR^lg|xO|S+i`zE$| zHA;|f6}CcgFb)R`6)--r05FEv<|1NE1Ja7vB_cKxgtA6zOFI*>fHW8F;nw6C0jCit z;6Po#O;0qvnBO@#u01%hJvgO3IMWD**Um?94Y_R=&@|k~_0C7*xZYm^RUBAg1Rmgk z!D4Ua!EN-5eIw%gI9>?XhFTT%M>wzHk8l*#x;hD^!>G%r zJx;xYyQ2K6FH$8sh!MI;f5q~Y@GJOTyu||!KhVY%&QAjAYK285aSVdQJ2+9qE0M!J z(15@OZb{i}QeK9We?x}y$v!%31Qif1N3b17LKwVA!ii`NvOu_`$&a2ke%8U2iKp}i z$vyRLV%(n4-^nCRpsn_oq#(S%c+I4?sJ|d8Iu8Yr?VU5?;6mKtdz02Aqc}L6**}Xj z-B#=g&qyu`KmR(it`QnXzP#aje1!XTp1hpshM1&}gJ`icKuGj@mHd1?Tz_lpOgdNC!6jF-s5{xu_mYpzA+H3PI+RN{` zW@kbz+Ia`|I)L;9$i?+&krUo*VA;`d!94Ornn!N5uD2DHZW|S(N>B(jwVptcX%@R3cv@_fixKgRyGI}T3%B0ZPC*1 zl(Y_E&^9QcY88gMFRPZ>vziZ2uG%BS2H;?bN4*HqL;_oqN4Taw(WGeo9YyB)xqncOeqv3r3`=nYu0P~siQhdY5nb(g)6V*cT^-bfeDX-74-1WJXv9K!{;HgfZ9M@vc1jG66B(W zbF`LM5G|%+v=PKGx=KH=b9y@>P%Cu_P3h4jyn_%D5f>bhhpw+|fts`~ua6Y{0RgZ( zc*TNo@`ZErfEByCYbX-29tfr#e@=-nWQ7VcYHS76iAfGct>>k!)X=E~%fg!np#SpdfN#NS&kQpDq z%j1L>rc^8VR>i~k>IpqUa|v%pYdoz`ojMooaD1{S}3PiW{<)Qb$R{P(D8$v-6_}f%#sG zU7A|8dVY#8@A3t?Lwwr&{;)kK6N|#_LHD(>>1wqb`-WTnlhjr7)6V|seJQi2h zwz6x>k6Zlr>3U(uP#)T9K*QWk8fe@egFl=pb*GgdPn@?~U3J`3I&3}8IA*tg^+1{{ zeVbF=Fm8bF^7#W?Ss%e`Mgtm>LUqE~MA>r?sWKou`K`cL zIl004x#h>LY9-x3cM>$Y8*c23H>Smeb(_xFH}P0-Cl zo^I!=%f*l{MIcW2ihc*~;4W=&PizBwJ=$6ud% z@^@dJ=D+>|9O3SB^0&O8|9bn$(QvwCqfb~nMCe4C8+hX(?#34L658lgs~u#X;Qz#T zxnmIi`fGLm^DrOKA`vRB?p}4n`$qS>Wk-@b;IQMGPo}ntn zMRv!oN zynA1QnqUjm_We`+_u+hx9o{Mufj(L|!MIrVXpd9SGnD6CbxA8sFsKh`swdI3;x4#r zBQXP#1;w4b=EB&KqK(J~8?9XpI6(jx5cI6&>mcBt(GLGUi6lPIk`T|wX*o!n-yXS& z*7wjEW*TZ^IMLO)Lp(c(o3>s9zls0Ed-qYX{UVOxW$R~FgH#Kq9`wY z3VHaMXS!v+XlN;5PoCQ9CV5<*dzNk}9(RzkP5%o^H;rNNYR^++um!A_V{9aU$cN8Z ze=q#n8&$YNe==%4m5w%*m)T2aGtw^w!Uk3AZ%z4CX%**oeYp%?`+?`Yp(!kIXC zXr(~R*Zvf5=mi115Txxsh=3HN&1F;yYOP2Owx^&Saf(LluMwmV2+~e2{XnJp zIOZBRyeTE&6Xi{#B>YLJbFq;eUSq>7-3HunN*Q;mkpM30B5o?jT}6d$KqYZIDxu*N z$pzBM5iulAmu6F^9CYbLmjy#51gmcW`G1;%bE_*)Q%D`*9QQEcHZ%bRrpmbH(W!YN zfHukzKK0>lfanBQEp(kL4yCbmKb|JO3t|ubwDi%NA#b)(Fr7m#=Pr@_Q{sy~Ramqi zJUOl(Ba9Qmi#smZWgpNGKLrwE`)Ek1tGF=1MF3m}I4H9icY%XRYtv96MxL4Ud~h8i zHsOgr{W$I)hf!=iVSk=2Wzj9>GAj>calF3+3%h`MTlt2uG!Fb{Lf3EuLO7@d%@hp6 z1x(;TJcNthdT^ca}az8)5Y}99?e5EyccUB1ny9)ilXBDI{s8Jjwv?n&nt zl!=1r)(m7#5%9w89DQ@h@M8e?er}v2ovAL)!Z35g=T$`p0!}#lNmiF!f*_J4JJSyl zh-qYtJ`-6%#bZ<5bRMFuR3sZGN(x+naYD&wMw1b8gjN#s)%L>-pjlQ6_d7z|?L03Z z`vK{aa71P9nJ5}^BE%f>8U~5JiaIt}kxJSEdZiA=>m&3UnqYJ2J^(&dNbZvn+tEE+K=;Hc0tGD29pKv>oy@2qFnf<+_S)V&GJ8^JE+gz(A$W zaFlPj5p_sq&v3@}9*({YlyEt)en1_-Fu#@I&87VSm*{0TATy6xwc<0TqG?1$PZ8vL zscK~<-V9GHI0-#oQY$YeGV{ZArZaUCPQeCx;hpb$9Uo~$0u$^x#P^(-#3dZxN>20H7+0j zdgkNwKN7>impkjDvbUY-(^AJfD=^pZ;U74xEF&nrGHek) zGf`oAur8v~6)Ija8#`N{$2LKWW$;tc4;AxKq&vKho6j8m4HARMgARIUykk)dy{@5u z4z=KYEOe4d_#ysAKNMbWgi*>0gx_c(+__)sG-BJY$vJiyG&hdj>Hi*O7}7X+l^aqz z*r7AkjlmP03w>izXv2II2j=SUXAqkI075)Fl_79g<*J1t* z;`_jw^+A*zZ`nhJyMp~f8C*%yH(mGub;LoNfUTJP-1c>_X)n&xts#KX=LWwa3PC17 zD;5w&JjpdAkw@{(zz?v@PI>4_2*sW{WtF5HvMdlm&^$W=qUesYN?m}Ns8f55=9PBI zMSF<==qR zA+cxGj)l#Hg>y;3vs1%U5lC@tpaP=iQv$9-%|nIZjlFqFi2QxJ_*ByuX4J5jVWRGb z%BY`cUXNgdjffADc8AVt2Q!zzBzWCAe#g_~+~s1v3ouWSa2?fps=hd3=v{c$F`QAt zFoUTS{8#?gjufcJrl^sVxT<|-l#DTVa72Wej29B zd>Ky?1Up)4fpGIN+)#1bSS#xxOqF%zZ0EH#1hW*$Z^r{i7tX~4Zo|*Q11A{Hz#~}_ zR#nCtJ8q8EZ)O9S6X|xRibWX6sCk@Y9RfIrWAkI#1sA`|Hp2?!^TP0?NhT+x>ai^9 zQR|Aiu(8lZ@_=-T3HA+e28pLtrlxic97$@hJ=$!i8JZ4b3Cay6rV7mxpQYVE{FH|- zC5Hrtw7*6a4kZy72 zkfe=F(#F6;BhK`fq7TS4JpM+xcp~HC`S!$Q1H<5fY;F2QwJa!}b zc6y8b&q=wXH-RY%{>X!e860CaN{ct5Rd(bE?gW)DhPOLZNw{DfZA6&@pPZv>jDj&t z2rZk4JlazF4?(7q7CjJP%IWD2E#m^UrSzc1u~1fUm#!zc-J02GopxW6HYZsdnWBx+ zF@|Fh9rRD48-D^$R<}2~opxd&YB^&B^qeO7`?>Mdi5;X*#NJmByS)>!lhj8GLA!t? zpsTnTi{pUBzo(%|81F8$3#$myEbC*K=Mdz^zD0`hXB5&FK_57hhj1>2Fao$pOYJ$5 z$M8f9W+r%|TsH=^iyd?lagB?=#K{0t-_PF-8tn{zdczL}zpmf(&jOXtoQh z^{`VStwS;$g2wPfXCq*zdl-{{S7!=~60MjiySm1y1M#31;l{=*8r!%eKT`z+eHXfl29|qHT#iqZedE zQJepOLITZ6{@aX7I;ptZYw!4h$=@A%h%pXI5;p^?l@AdLa4i^s>mY*>R{P-_=WCmV z35D=YvLJN`>A^AyTWAPQKnf8Uy!H_~+!UoV#a#e@JEFA%q>;kkd$kA5ae1{ZEEX|N zP9mK&fJf*2v|*_o$R`EyL_W{)nv2M13SuB^(yj}!e=jJD2o=H`)-2yT)s_1lwO^ZI zhB;jduakB{w!qn%_{Ga6_v-FfiXZnHJ#Zy)Ep3d=y}B(T?i1!)Z48{_VyJ3k((uf{ z6S6>lE}md^#mLm%gA8{5@vIe3yWOje8SB+<9q(Rm#JD%Kg|s=7+}eH9+}a#Jo(tUC zYZcU0+FI^0?KPUy@J6TcB7x`dAC*WR0BFCdWbR~#=Z!h}GbT;8PoD490x#gRR|}DC zkZ1MG8MFP9XWQp`-WWJwp#2IYM~Z5Zg63M!>baBclS=$0cF!A==X2^wND&b!-r^MY zk~#L0d+a5iH)hW+xz|3!hqeSh5Gg+86nEU~pF9VR@w{QQ2r0f2DZa%c5;%tc1hZHB zRU^m$&V-IaJG=8^?OEcDeGh7D>98ffT_(N_5^vXvH#nw3c_Z+@4F}U_%$|(8r{3e6 z0YC|U+6e;=NRQ)LZNH=J&N)}ip6q#p+IOwpekW3p_7^E8bBd|{DP?yID4pSXWBQe7 z;+&Fukb*RYNKwWquA=y9Q}5`|!uv%EQa}RQFhABV!y^)S693!a^G%*S2{}tj?AyqwE*)@T{IwHj@EsD|pb|x546VC?1hO zKK{40Eq}($duIdpcTVx!(@N6;R{=hwZP(!e+z-kan0dvZ49^>b2HUSMnLdLsd!tBk zyGSvn4=FS;CLC591LD{09GZ zTKg@6Xzw%p`L#dtW9_Trjl>kRuvWZn6>q!5+lS(9FCLLV6#uC_=sFH^{I8DiBhVz? z6yCfIB=X}|$>OcAcuN&;{l(i5JR*T%_>c0s*9CGB;yLLQD+XFaq#+5X$uI($Mj+P+ zxQ#%u5g2C#CK`b$Mqs89m@fhqspS;F5ARxwAcvR6g_p;LSHy*1j0?XK7hW9~u89lR z$Ax#sg?Gn=_r!(w$Au5Yg&X3+63Cf;2!5Lp*5w%5Q^E|4>s0Z93xo5h)Ff;M_M-_c zDF$1Ijo4N+Aw~_mpDsUs?!2!9xW&#C`;w*vX0Uem8_XlYVcgoUsMm1J-A#`-X3U;m z;-5O>9z+x)0=6k+G7MsYp#ubrwKwApe)>ExTF`9`#A$b)g&0W;lry}7QhG|8;7`Me znVa`-ek2oih(rcBdi}8q+R~Cj6P^!F4-Qg00q9>cz@aPl z4bTZ&sD|vLytp~{*`m^~MFyDsQ-;%lhXeUuNL|K8D=x0kWf=%_Y6VR#+9-U>L3>XBYy!T27kk|vxSO%&6*^4)RxMW6 zJJeg8e`z``I&saeM|Hj>s_cM004WB5j=ijDskVhLx=W#zXe)e4Q&H*XBf`Tj?h1`< z1w>yb%@BMW8mQ_heMWcUGgCE*cBfdb{68PfIs-%513~WuWZ*>YJ%{!t+|-LJrsI?z zbx?X7Ee!kTnjGADfo9T&G?PAL3qE~a7@jsA`jDZae5E*)pIGd;5#{T85NB$CIP8Rj zxAs*mV~4hPZgj?)@Y)*?K>G+Q3l43AOYFBBBsO_C3d0I|u zCrJO3%lbOfu6mugH9=kZHU17lG}mydT^v-`^|6qo4~Xq_-MIb$SqwO^Sy7mh0U%N$T13Kwxu z$DB1-(wUC6^(y$qgA;64PKv`fk1G(2JZuW@VJ0w-+#_X8)Apb0r) zFZ%+yoy$n2qb!Z>RyTNW;L9A~R}ndHXGeTXV>LtxVp9=)%CG<>!T^Y|L@Jg{p;m;( zh180t*R%-56foir=QWbCh94W0q`xRecV{s8!mR_~$ByJ7?T0|4;=gfWGQ8*e2g5+P z40Iw^p|JshMoU?`c67CV+utEv*xKLt8hWWexK^w?ndOM|q+GFUFHS);wE>Ei_HSZe z@uzVn6qnWpFkVvdvK2sIR!{q>`UWUAVdGY^PQG3Vt+!J~wq9P0enj&#fH}8St+J7$idI*(ya#~6E%TIEQug-tK49qK}hNr+%2 z*|B3`<(%IhJ1*~n6|`p?1B@=#J~p7m*uA}$Ri9%_{2^;$g5x3kHKYSpwpUy&a9!!D+{q|E_i_H)6$3jaotW;k=|Ub`2Rd7=g)alF)3Lhr7a#G0_<)LMc*o zHwjWFchwSnTVIp?qg}P|e4|w3NysN@EILAmG9!eWUjfzMlJKARG5#IkxQL-$0p~A{ z$46jw5_Pp&@dh3O4>OgJ?UeO|TsEWqG}@xO+xPB_Vu@7A=7`q5ginEM5L1Zd4Thd( zN!VBTaSxV|9;n$kG%iKS`KjPd`WFU@cO)37xI#KnFKPZo#}S0>Z*4{Q?;6%1s$EZ> zB03DK_L&~~QUPOSP1oH8t)vwFo!-z40V)$xdwV;Bs+VY>l1m6nOf8nViJe}bV^M;f7c$eK>c4}5W5yNVXlUu-?{0FeEQ@7wWIKHbBW&^892O{AH!PRyOly%_1%+jA^vcry2=+rZTpi-6; zIL{3PA3=Hw)2LH@QY)_{+@Pm;rT}8O%Y`6_(ZoD~B$^jcHuWbSZDWE8WzNN^+8LS7 zz=TN%&m||bF=_yK+5d)zsg-L9c3#NF^RYI`T3?a#mM78S>E9wA=o|QzbQ> zr^kb^dObBET+qcQw$y=}X#lW+W;sR{4Kkfk6_p+_RbIzZ=l|4?6Fbfl=*9|%FbsHVkcqA##o zAY)mLe&rv3CpB5y*zMHwgimzt$Noz~FVSK?zVj)}aB2JrImvp2G#aNVmXsUFm=^zM zP*K|dTN&A)B{v>W3LC(Z30r2jdFMkegk{3npe}4PD2CHJD0?0p+lYg~hT11~ghF>+ z-P#&E&=$9+E%bg{2!|>P22WTLLZS`qdJ6{rkSYa&^)1QEt|%~FbjNr}4Z z^;Fud&kg!hFZ9BsWd(g-OVqpTTgbt1_+d`_(X{o6&QgCNoffUm0vv>kRYiNOF zkDdko*5PEI_D%fyf@V$dO3oVFf?RgwN)D_`U5@x}YSk^M4}j8}u~aTq7P;kmI3ptM zVzQXh$aQ@hT9=9?xw`Tlx}es~sPqt57Xp<-jyTdcs})xOB8s~dR}aSC>bj7evkDg3S@?TF6yIT1)V2&%D)(vUII0!}_m!|{LuNNG?zOgm7Bd(aA z($Y)xLfllyTi{p8Zn11MK&HZG0_ll3AxE^}gnc*BLF;KAXu**94h`{%L)J1J^QUHL zztT05b|g%}VL6+M4KDN^xdDK}175UILHRntvHbf1Rnq002j?A9h-`4{$&$mEmdY2T zUPwOg5FbYneNk2$LGYA=(XvE%r$SkF?d?u&jP}OdEWWUu-T5=!|3CvHE&2^Y)In*{ z&)ee2TeSE}dqJnd7c-;RQ(qLQ`?1HE{YXbj+gz9qlV|qKxYgfJD+(P&wY3!(d-YTx z{$J@*(Iu4`gbL!n|8|o*!x^=rQ~q1ry^Bdm8%`(}(*n^LO=GyVYIP>4iDNrin8uyD zSf7HN@hl6n!LnTBi@~^R8{IMtO~440xD{unv|?x+a6x=retjx~!vxOsIkRQqh}KKn zBk^hBZZMTn(E%)M;V{tLx4duR(Ztu7u-l{A6pph$v| zh2d{U8l>kXYw1CHUUF|aNY6|3H%QM5)u%K_&)XN_!Ft{cD6HqTBOL!T>drgI?B!); zeC*HRpE2+=27boC&lva_13zQnXAJy|fuAw(GX{Rfz|R=?83R9K;Aaf{jDepq@G}N} z#=y@Q_%RGjnmv8y;0Y6aWz(ijm_4~<(gYlholrV$#+=C$<_x?V2dz&1-8Y#0Aa(lD z)0dQ%mQ634R^p#LVRqR)_e{O#&IvP1r%&+BE}1@gLg|dMd;EGnk-oHKTB%4qXY%B` zC(N8N^&WrM3UHC0Q~77al{w*#*=4BAH)D3`WGY&un>~5XWKok2*Nl56P~LW+JC--c zUozW2VTNzQ96yjTJ+2&JrmX>UCd@9Grx(#)E@N-{WSoM&x4n1+e|o(WPWm2~l!KzY zNs~))kbJ^Dljr+&oK2oTVFIu;?T(VtyW=r)iu7&8itkhJnd+YaoKBv7Psy~lZ(Rq< zVQ90{AxRCjl2n{8Nw?%n<@Nbejl5YpB)KH1(J8H1=8~qoyhS?niA%~{gTFHhr5DeQ zNb?^n#O^5a*C2o5MoAih{I?_jpYx^Mo}1x)8TpSmCHI3aX?67$spcD(l>59(YBd*1 zyX_Hah>`zA~l&>??nE8Y>{433M6S7V2Bk+XI~j9Pc`xf zk$(vCUxU1p@aIDQyv@=pvP+uyp;MYU8u0JlBH6naNHec-Nv3}lNatQ1k#1S4*I$nO zPUO$f^Ph|7*v-;X;II52PN`-naJFxY^k$C&X+?`u`g})$WE~zUFMS00r5Z_^i2P%b zKOOl9{!j9xn#sT)((c)S`Y#3kzuqFfepZ2$Tji7v))Yt|=10mM59|4hk$(#E_e0)^ z_*;tn^EOL%^j*y>=)ayWDdQOMcQ)GpP@Z(rYXwqxM5O%4Lwf!UBPp%~W3HclIBxyME|6!w4{zt(7 zu~W+JjWR|$rNpE<=?UcD`L``nacP0HerlxroQk;otC0Ty@()D*cai_Ez~8&T-&WAF z%_-S?)k%lY{-vL8k#>$KkfzQ+`xhbq3e;bN`Zpp!`dzvh`CB$hxoeUCP2|tQ`_g=A z^Vxv^T+pATPHGxdApO%Hk-9G|Ea-l*qw*J0PWUM)C-0nFazj2jXZ}V@&dR@py1Xw2ljvP_X8J| zmk<2z#K?iIU-lbl&xJ#gW!p3MEqf-zW-rg!amUDvIn(=Pn3AN7+dbQ_%)j}WD`i{x zm46&I^2#el^}7GL;XwXz<7ZPZstYAj#5z(7^3i+*d(=>xi{yAx9-nbQM)kbzQg@< zwtaA3&iscGa*FRdn0@xQo3i^J{cZNR-`|$~;)|B-VSgILo9_fJl|^MxUdlshDGhz= z>W9jwv{WC}OL++nf``f?_^5m;gX*JtsZ4@{;GsGQK8&L-|EO##lgjFKMoG@U`pn5$wC27X$43w3G}kZ8nS6XJEL zXoq6)?`wDU@9TXiLH}9b^2s+3-2UW~(}(~0AC#);;6LA7_wo}DEtodmJFI_SHg#^# zeR4{VZo$OqP?%G0XgW`rMLy zk!+WZGDHs9+|$(YH_6oTS2A_{r83N|8(W@fd9>v}g=4UJkojWM#im}e_#J4!anb#Kc+OE1es7Q3aN(oZ=Hzb5<|ccqr5@#Ao*f^P+Ch{ zE^hg(`7BFqb5EsbTN!P6PK$9#Ueq$HWsKrfu2(KmMw>^Q&&F@DlCN0I7V{8guyTVu zR(8o($$92fv%};tCF7TX&80S)Gt2``15Lf~E85qO+o!aSY3bFntJ!E<=k^%wY=f~= zA1rRUN-1d}h>F`_%2$Rc7QmBd&NJU&a+$^gt}(Jx22^H(Dc7tpL<7ye0F~K%5vYNF z3E$?{XIt)QakLC%toLi_jQ3OavySiDmNDk5%&)dM&DWbR0gePtisiFSXPffzI|RQL zbFMkhlxi9b+&JW9?wt%Y(9*iO`Qqk{P0utv+Vr3FkKFQI^WJ8^rO-0ja-(IAQ* z%dY0DEwh!`$}jL+V3}#@rgT#-#qU_l7|TRuqH>kRX_;jfzw_j|@||*-e3R^xZ$MA> zHupA{Dt9Q3=F!U8%E0ClbBXyJ{95r_3=Cf{Un1wrL*%_pyPAMm9jh7UJULY!Ea%G9 z+wrt)X+7NhZ1b3Ab8~IeUz^TidbXc#40r15d6v1BJ1sX^d=_e>+`_F?<|x~hQHmRIq69)4f3o?)G8ea`x<^;+vP z>&@2RTYhi348KR31~<)aYE@d4X5|~DN%>kip=?kND*sR%O*_mx%>Tmg=%!CipU9uc z-^y>vjq+3ScPC=z_2%Q|r_Fyce{BA{d8PbMxj}hEc~dDlv0oW|Vxf7V`Oo{Db*J^ONQY<_FB%%xld@%%jY;jXCDSro*P)=CJu?`5yUu z)0L)28xNVjl())Hn7=TuF|9FuV7}k{x#@G$L+0t`eWrb;-{JQS^PkM$$rs8heqS=( zZo1A?Z+hR9Z5kjCkUul+G3}Kvkb9WkGu>v2m=>7cHLW&Y8OPQtg#_tWppDd-8t1UE=@335o(VSuyzvW7~V#99+l@6S_G!T%lL_g8`Mci{Ov2X&ldt*w(!ym$QFh9M2F9~*pZ-_c(k9dq=o zqu>9q>xYd$JoCdv7LqhN@F^M-_%-HOQ}bs{8=HRLw5VxTQ%Te4CP&l2rhZL5o8+eN zPV7DL_K9`Y8P-=%Jab}#^(*TG)@|08t!u51o;YG1Wj$=ov4*YpSiiSkX3Us%^zU$WkA{lI#^^>gcW)_Uth)_vCZt<$a9);Fxbvwmj%lXZY~uk`}!tP}59 zZ?m?VT1?-XnoZxx-^ibunoMt*zBYYgI$_!%Z;%g~c9{MJN?$3*r{%xM zAIpE28{|jiH$lr!ftnY}AIX1~x64QId%$$av|oN${z3jwep22oe+io0BlnO?8b>!4 zSsaZ68~Zg5w_IWA*|^J6ZMn~KzC~^vZ+X%3pk=egYguKv+w$GAwHm-r<`H=jb*CkIm-x3m1Vx=S?!xk&P(w0`*QpJ|Gwnaq+4CMb? zYp}b$9qs>9-s1X z=*3WT==IPGp({c=f;)nnLpO)M9(q1>Rp>jR=Yr1#Z$I>GaCq>BLs@~Wz?;E82Yibg(!0MDU{EL%}P9 zGXpaNHynIC@VUSb0#xFj9ymR)C3sx$Yr&@A1HlV}Uka`Y&Irs1d^`Bn;QfL71Mhxt zTI!!aKrQ&eid3rS?!&)Lsl!t5Or4(k#ndIKcZ8{AJ}&h5l$;Y(8MQ`=D%e-{7dq%KO0 zp)96ynf_hM<@idJiWR90=MDc!Qe;1>jT#ZKE%H^{QDqK9XJqJh}wI0fa>kD@bBH=3BhNN+=*7}Nk{gl zJbvU~T(+WAMO%Ve4!eV|1ph8=hwZ_?1@8_19<7C62Db+H1#jin!C$#`@Y=`Ee*E~y zt>N20-WYzHefEZruM4xshOhqkt?+NcE#Z9l>o>xWgtNkb4xbtRb$Ds`rEphxXZXqR zSHh2`JdKk0mXtk#^uP|3nbe+m3i)Sm%9|AF7UzJsem-`2|F(?V1Zue3|z2hhTxve+tvsTJWaf2j>| z1Gj`ng>L_dO5LkNH+(cLI4u~bz6{FV?v%6?YX4G;n95*k4?CsrXHX_n>$jN8VAT`5 z??di`1#^PsDd7}V>Z(3!vNpYm{$TP^4bvzvYJu)Co-lrIj6rSoNXlt}wSm6}aIRzM z3DjTuzez*f|1e&YeWZAC_WPkJ+54xB%1*%*2%s|xZo0zZPzZNQD43EGPEAcgcHw7* z#a|4_495T;#`iG1H{v84E)S{Ua9G_#g2!RJaLAA$MrvwmFfA=?qzz3So{Djy)S<&u zPr&Ag)Dwmqsl$h+rj8hD06JU^84XVz0o?H6!wmpHGSn3WWT`7HEp6DaVIWISPaiR2 z#HdlD&OGzX%*;$Y69W)X9YlD@$jBHuawI55j~+c{%$R_6op#!3q?>&ykxCwLI3)P| z^UoJ~9wI$l(2XBI9uNw506Ld`P!3mWD*s9KMCLP}`3#72bFoW>$!t1Ew-8Mkf1Jb4P-xE9<&1w6!bBnPN#?<*iJgfgagw#Cba4B zV25jqbPVXBOKLz59aOX1*|`N}m$8qD zHzZJNLPmV%GzgiRKc{R=GHRt7*>)I*aL)OYrk34ndj=_!G2%0$&&kZ1IWwCCG*J|#yIf_%l>pcweY88l7OocR( zct>ru+7G5CuC1Bxcuh;JnWoZf+T+pW^lJ84!#B0oHFsiaxd{{DP|T=nYl+dsIlV;d zs~bBT8d_>v9R>?e^U*8Y+Uu>kXEjr<=Be8qa-*rGzODn)=TWRGXu^DRc6D=GTg)LK zIkjzVS5?atH_LI*(8rChkMguNn+^*UV$m9F<$z-H(#J7LUeoSO(2MOPv>0a3qaBbF zx23@F-4JyN?gHFAS>KeQ%j8#`~cyB)}gbW{OMuT|0sUUKS2B#KS2Cc_{SbUrvC)- z!&0CBD1OX8K>Qd#K>Qfb`eJ9b>$1wjR3uOuZWj_SUOY|O5*@XwXgc>e+|+QPi8b2C zN?S=!#7zx5+9-Sq?o)Boe$=yYpM!fW?(=X@z~G~9W(i*T3XF2}tDH@O)tC0c>| zM%?rb+i&9j9&S26=r!Db!F>cb9s4*L_r`xKd9f)i{B3p)tK6L_q5z!%t=)Xpy z-G+!(A)>o+y3d2yaQox45r0JV7nz3fr|~#Ad!k`ngq;5q%#c1_h}A3e4C4z64dd#? zI3<6XVf?DeFltd~_Fs?4XqSI}QR%JcLyLv%q2FYauj4il?*`l$`%}MoCOF}BdX|H9 zr{4m8!73ZPj}jP0(peUvdU5Z^y&bT%1jjXizEXZDI_s~Zw`yG~UU&_gg|^Dm+W5+v zShcE@ttygf6n{0=f30jseVDKS%)xUQYJHfZ_3$TKU&iHm()DE`Uj^Pdc~Wb%8tdko zqgDiTJi+w$>dvV-1JPI02S+SH^6TP9F*G25Tf15d2&;6|(9!!kmQ;7pdb@!o2tOxAb5p#dy1Aw{+T4t$Q(Y(4 zI!2e{BLrk&JAk&@D}BQE@K?hUt!;3R1WpxREt+Lfv}(|5z)!5hX>s}CS$L=xYwDWn z69^I{x&bg(qKjh97@p6je)e&FZ#J z)W6WLu_@jdZEiq;;cH-*ITBvLkHy{p5kLB1S0xP`@==h%SjVUx=xbvG#D(HJ2)=m` zd~MU!o#<_`Lha~IHrai@1naPUb^1jA_2JP$&^I1yZt6hS_gGD!vs3!&`EgJy`qArA z1fFHUdC2){JCUK_lPlVqJ6ovkw(!a~30>3CQB&7wDV2!tY;A6}sgPy49 zMHRgkPK;lov^w+ zPdV?fxSqg|(HB+OV4$gHIr52ec;0bQP3hE(8m0rqZL7BB!V+>U{B@n}7|#0i{Hzal zlHik4R>2Z`sQuEYQSC;d76W0bEFlnXNn+5_b z6{vz5Bp!+3A7jNS3iyWa(;3CO1Y~Vz9$-NI{rK?>={BT{#b^B04^6;!#+18R zto-Z8&lOdyjZaHZCnSK~#pS&C@h1tt9`hjy8XO}(P2e4~{w+g-+vH4SCFn3zwife9~UpZfZralM$S)EJ%Pgw@bE9MfwQ>^5I4Cuyg^m< z$hXGrkF|MD;fYR(QS)o0IQ0Ii0Wag(SYbgVGWu#2?ZC@;by7TyNBbjHdhmF3G6Kk_ z@#n zc&mpZ_<`bw@CS?^@B_w=@yP-}_~KFiN#NjlrHDyG{pvK zCJ)Z9itKo`e;sh_{8*FaR-NBI0so|&|BT+m3_ERbqrH|wOFUAS5Yhu<{M9w_)va}n?P&6KS{XZmQvn?LXdt1l z#_bt6GfgxjA!Su%5@vuk{y2p!{FsIJ=ho;kyukgpCM>+Q$BYy4$-^d$L$A8AYMiSY ziPlil*-VqUh!n4;QF1_!WwBSGj<9o;3PsE2j9`Y5H1ef|GVo({s&4diAg`&#x={G8W#bRuDvPNfq5>MT=0vnIJz8hE4?TX4R5XZz``eo!ogdkbuRH5 zKaH{IL-r~PE`GJ@%q76Vb2f0{-1_;uyTh-9qhL^HwYklplyS$G&vx?$2zfMBK;8Q4 zHrQLuK6t5YaTI^{K8=``$Tvrk%^WMb=p{Yim+e<2DC@+B%ICyLICw7GxV%WNou0l9 z{mPoFqMbgnNlVDL{M|BmO>-Oz@seB`ePa1iJs>Mf)c8BF3LgvgVK{C~)nkbUtdGGz zZ4|EBD^lb4=5Nx+PJ;wSiO&H1-k`kt!adZCv`z?lcG(0ss$I>KAWrBWyv}OL7k+>9 zJN#Vp48Sj$ZIC2zL&6d3&C8TwJHsGV!XODip7>h;Yo5Ao>I)S$VTv1=WEa@5YS^_ z&1ZdxKEJ7y?Bwp3n*Foa1AbzDHJhaKQ+#cG6O_Sl1X_Tcc{G)5t9av^$luT&l_D+) ze*%j)FqAknNHa$G9HCl(ZhZe9r4jzB6{oFE+DgDTV zZZ`YvnD`MxwB>Cc{lSkPIa3ub$FPdjk3S*(23TY;7=JDDsCxyTu05y!faxczAY0m2 z_*?K;!nfAuxkFZOgYio#o797jk>8rzO;7>+gZRHU|G7mB&hPlIeMqn-VsL&Z{7=X4 z8RWGbRrg1b{;#~`Wwz5MLdy!g-QY(vUm{8%H=%nBqKM;P3GJQdHOCyBo+ z{aanTPg%csa~syysM$!g`uRzZzX$JAsoB&luK`sMZT-L=RlD16Qy@MHpJYuA@bM^S zy0A;wSB4Akv#801SDDKWn;u+vD!g4-#z$A6J%CQ;aylCt^y*#0vfqUl?=9Fbyvizs z>~|>??01L$nrJ)ihoOV9t^T}63D@f=W1?{(_SUU3ZZYn|84xcRJB>ZYKa2y$VeF*q z$9)*j{{UG7v;wa-Y z*vmK)dm2YzZ)1jW0(LqckAK6l`|&vJg2d?)*b|v%48cF_cE&lUiT8IOIUjHY=7UqP zUcwjP#zkj*)AqV<+{Ux`#jRf?pJ=;r(^<^jxYb4W`vCTvA5IDX1SdmH2^|VP8~h6F zr|>EG!B)P0dc|jy`@{JC7{8?XA?r;#1oFGZF9$_%bjl{w&`A8^2ljy$0}`051y|#uHG8 z7RGM?{8GTb19%JIcLM$*6rR!7-+wRgwZLZpz8~-(1AZakFCZc_5BK-)1%5Q}2Z2um zehJ{40WVK8j4dDa_vbBfK9Xyu~98a1ti z&%WeY`1-S_KmXNdU%%|pXJ7x(bIa z0RBSo7lOZ#@(TD1!CwgeLhu)YzYzRI;4d0ga(2<5c4Zaa@PoXf=Is|2&H3!5Mf;vv zUbOhG6-70#-B<*fMJD0*i2Jw@<{qML_5QuN%!$BRyBd#dQ@b3ZRactzchzg~3y zMZ1e`JhZpS{OLc7Hh%TPq766p7rjv!ia?jhb<2*A%sP5vr18PeM0PDYJ<@c789DUY zm`L=S=S6P4IxDhh!Q{w2lXD|QXU~dcpHdVlJ$Y`V{q(ZP9p_yfK^!7gOD~VSbmOwf zYmY@EpWl0BWU(2GY_98!6wp3zIWE+kq1(L z6uEo|`*Y;_BYPv4jNBLb?+O2i{Im35k^39pjlkBCSHJgBByZ>8NY0TX zkxTC~iZA_Kp!n<01&dE!8ZJgU6#wkbwBo;H4=XNt^|<2SwjN)+@q`nK*Z&}+_=&0! z#Ym&#?t4!z9#?Wo@%!(LD*o$NPb)SGMi=M(&iT%7$K_n~*uH9fr*QHG9{b=Zv)PIkdvf|p&Q+gj7H)Yzj6Q}$>IBUx1 z%Sxxrthr>$PZris=^GoLa`WmNrrh+_m#1|7?v5#6tlv1L;?{?zOs@ICl(GA^PT8IH z@|0f{{$@&H*4`_K&xwp8529Q|~WGnf8x|hE98T!-#1wpEY{gnI+?<%{pn~v@^e&H?8eA^QPVZ z)}m=2y<9i#%Xha=du+lD(|&fxm#1~CxntU2(l$=}+4zU1%{{bb+UnI?ryYHA+qAjQ z|9aXTo8OvtF#g`O-qTWY@BG5h+(RuRa#P-7g=U{`K3pOh5j(t>uBBUM{QLE%XZ$d2+l;kozn<}}J#Wq! z@~wAgT=B3mb4PgS%+LSx#F-~Foj$YY#<4SxM6zcte{$x`nt#llIsb1}GnYP7J9Fc; zSI@luYuz)SdUx&2L%+R!=G=;J%q+a}!I_^uf6L4_H$FXc#IIhOdCD(#&NT0RbLNyK z@6LQ^jgj}AKcwYt`1y%>H_kjgFQsB^UR6eRUd;_N^R{i7oA>r3ReAfmYV&sHT%Gr7 ztUK>(FR#s;@x9ygddGYt?}h0P=6&(Q$MW8eKAm^toiFA6cj zW7d~{ls4;6cb_;bkbe5CTh1Ok>nFP}nALLO%vl91=FYmkxoXxIXVlI*=U=f|=U>!4 z>-ziF&RTop?X%{6bkD3MLm!;=-p?PKbujDcS;0$Rn$=kI>`p8P|*9>{OG?XmpR4?dOu)iYnppM1j3{8N7W=loec`}1EMVa#rirp>;y z=)~Ed`{8M`f7Lr?_76HQnEm+f8MC7)b7!BizjF4+KdPDi@v<12F5RTznyywR~Pxbt)=h>d;dS2*xspsXMU-rDx^J>p)J+Jrt zy63k&zw3FU=MO!93jI0sCXRXB8+tqRm(X8B`*2L;-$VbvVZZ;x(ZBx=?SFoM@w?Bz zTm0Vh?-jrQ{QJcRofT=1~2i2M+B$H0E&q;Rg=y zJv`>)`i~#@c<;w!`s(}c>U*MZXWxOokwg;K<0MIY+CGb{t)I zbmP%Sk8VA>{pjwa?;PzrI=p{$|M>pA{<8in`kVW^`q%ca@88hBseg0-mi{OEd;7Qb z@95vvzo&m+|Nj1iXgzdY*R{H*>>AfKrt6$8v+vBlGx|pNo!)m^->H40`cCQlOy9|U zBl}M38-asoGx|=*J7H^jUi#MK^N!y-Ja72c=7v;KpEcuq-$pr(M1i*dBN^urAOXC<}}a3=h16 z6JsAuS(nm*(|fCMwqp*?`W}hHa1R)J(a(7vJ%tC1yKpAnDkEkz8q0A0NVzf3C_u9* z8$ALOeSi$K@ZkY}@BT;kzV5$u|Ev4o-S2e&v-{2Nx4QRq|GE1w-GA-g+x>RI2fZH@ z9Oykz@KNta1t0c)SnzJ|y9N7u_ZPh1`+mWDz3-tz@_ple<00cIbWa{Per()q+=|0Z zZZhsM?ltZ(zGnQ|_$>}LdENMf@h9VV#vAB@y@VdXbH*#itH#U5FE<~3^61*58;j3e1cb{yG%Wc`sX zN6PzRNS5rr9ew-z*7t4c>pr=AWHd2UP@g>w{hQ!;V3 zub%keZ!+Hqp*8z|;6k~? zm-VZQB$yu@VD3Zew8@@ze*Kx~t#|7epzeGns6c}$h{E~7ZM?=akbVQk7Ki1=V=QRL zNzdS(O}~VrFi0PPFZr<&=?f;?`a&0#;H z>EJsr(hko#;5Mty$ZR#onUl{mXU#IR4IBePTniRfM-~>BIL-?V@y%ND-1+5`y>iG-Fj&VR|~ZJ8R;^ ztVt7%1&hkc%yL=7ZmN8)fDyGY-GXr$pkhJk zg1JUgXT1=@)c-jHgWIux<%?7K`s@m_>2QDqgtd` z$@_ERUhEhMt2mxm)>O9FdAVbAc}G_QxS}Wl6j7Uq=hwu%C~NyIJNBXl7cE%0c!3d_ zSGZt7Nm=!Rg$qjTmpK&+7gSZ3mB5EAyaH8}&YkClMM@S_l~mY-Wpf-kMTL=z++rBw zCxrs5R-#N>mKLbsY!nOf1YKELT;dLnA@1O+7M6Qu5y&UX4%icpgGdye7-gdN)7FN& zg%mDYQk`u_lint}-X^);CcEBpTyIlcZ&O`w(_C-4uD9u~w}~EQ+}ccZt25E9&qTLE z6WtnNPmJYV98I@Q6WvNpbZa%qtrbcTUDPDER+HRXVXuyh*sawhw^ozfT1|3mHOZ~j zWVcq69j)dsT(Hns&}K&4+p+#_P7Tids5d*>Oj^Ee%6=JBE$KB%TUX%V!g{l&eL1#b z;6QN;V6QYcsBO{KV9Jpg^44C{ibZ|p(e{?6IPKSmyw)acoUf3Tk!F2cG;X4>H>0a? z@S+2+X{J@Cs}(qIRJFC4IAm+JNlTYaI-VqMt3Yo|faB6Bu$qoWM5E1YZo|o)3()G( z-VjiYS&wrMY0ckiqcrY%Ew&I!qn235YNHUUwbqlJup726YSyfPp?G7psu9e#cGFs? zWa8902&LNbf;KMA#ki$(luLVOjLrQSLkv3v*XY@t}Zqls!6B)r4| zwvq!2%G=vI+UnYx+18FFT;MoX#`1Cgh7E40X=!R+%}frqP?^Z|MONaFKQyE$o*p(d zb!qh{sRs*3JB&i{I$6}mHtR5*Hy1+#5{Ql3NQ;RVT3aqmBpnvrF6T6JpmjA^TSdp~ z8uNJpk!htgmQ2L}ox?|4coY;D^HIIB5$6Y)E!3Q&+~b%6DJOZC6Onr-Mqzm=lQqzR zsdmOud7Gk#20s#uHW)D(t$5;tN}-nqmPOrKQQ;8UfjZ>~XH`!*B8?Ks7G+p~jFqTn zb5m`5P5WwUH4f9H)A~d=&SHqKZmDf+_NCWRm8)@0hkkHsnIAfSmR$`cD zNo##mO{159&4$-)H|dTiW^uGthvaT2HUpgwDu zfr!-bp|n}?wya66S0j!+fONnMnZJaL#(9p?JVJ~ZLPIj zm01AV_Ge>x51=PO7)B8%v)Gh4gQOYuvUV0KM^pu!gpd8W*uAj4xvds!MK3Qbt1Mh< zF0Q$Xilfe0Ru(d|069jP=b>()29g7(Abh~oY|+7L;3c7}TvA?IUSejl@biWlLPf16 z&j6MXl31dP`3z1qt~44~&dBCJqH2F3tN(EqKB7^MqKi>VEXwv%c> z8RHEz6H}BZQ+b~vid6kM3q4hB=W%OvrR$wi*9AbUqr(LtpQ(v8xnT62AM#CIvf6V< zAhmS@yPE9%&Jt=O!U{eSBc}9|#-{cShqHt)Ms`s6;y7pdVq}T5FOCZ57@I0ldCg{t zNUDT56GAMq8t=Rp16i+~t?khUGNlE;FSWpQ5UNujC<*5R)!rAW^N?PQO#sq9aV{e0 zd>F#Qy^+Ld@?qV#DC2O_)8lP3)TEiEZ2G3TJ=jE>iGv%HO(3As$asFiZPCP&pd5p)SUN_l+RHE+W6 z1&s8mlwxJ&b0*}gwh)arVy}cWjOaY9w4d57DR>Qt+n{*0x_EE8_iKYHyWCEkUXG?^OX4a z^0D!y!wgXcJqz?7GRMYIouj*9Dt78x-~whsK6gRrO)M2>!8jfuX>@kognW#M(Kj2fK~(8YeRz?!WH(`WE&-xsVJ__QtCoTT z`Vb?2?7^SQS1(mWSJ6*`00YH5?c7##Vo*wYa@fdRSFNgHb$AkXoww9tYA@ep_f@;m zF|RWR8Pgq=efGC~@bv)ps@{ zGa45bRxFucJ-@K5Y+=N1Vnfapl`=@MQa({@nnz9CSPTf` zIGDIeeL0}V)*D%vsx`7OCuh*S+zithM&eN*0C_;t$ZA`@+{juucdkDj5JHEERU-?@ z=}$-Vtvr&Mb#+^fk#+IHLVr3Sgbta?7@L*T&@g@&Sx25tBYV}@RRZEi0(9NT1~#Sj;yH;J0K+7V<`TL%V{IfGCIGZvvPnGcgKEH?OL2JUnjSJL@i ziwi3;f@rAWaW1%w#Z9d!ZX($0X%^D?%GC45UtWrlnRA}8u(HzN&Y!|k{~F#OxyUF~ zfQ4}F%Catuye*E_iin6h)OvwBl|x&(F(JPxE_F(&Gc-wM1UAcI9$%fZFkgLyBOy;y zZKLWpzal(=e?oq&qOGmN!-cR|AxDt4wgutGnlUp#gY0f5NW!8KfW0a)D>X5wkA$*S zolQpZK|@O3?2|Jvyla0I*SciaYn_yDnZj@$7L3f7Pu@+)uLo}y^|q=IuPhoaptgcXSF3d( z`>ZTgpc~gjTkT9P{BZ>XibYd zutc;sB$d*Mau(Ba5EkYX`%of5prRA0{6Y~>m4;vRxe^jYqAp&0^Jn`Owqx2Qn#|`~2OgkDm)wE|llm5Ul&Dh0sS__g`+>RnLSiZ5&{*hrVry}8z7Zajr9zZ5Gv6mC! zOOMs=IA=;WxmI|J&*_p($ZxEPOWE%9Q&eea z7&6^u4{Dg0-NLZygg8%w8O}`FN}PhYTuqCiVQpG?ufeR+Nf`;7ps|<+GozHVFSJ<1qc@)T+-vP{kms`P0e7m7~6oUSzL< z?4aXu(!QK5pBSE-j*Z}J2cqNnu`GW%3Qscp@mlj&veF;kgjzk@R?DTXVe@U$-18WnE-;yu4F8C^GmIeJi{Kd^;Zlf)<0i ztbAw9^3$XYCeK8bYYF3~DqcMUXEO@)yW(n5h zVmTnPHO)|Cf(h$yYC5pCau&KpRHg`>Q~b~J)1lk z^|8vQ5Lvt>zZf%?^j$J*j51Vy}h zqjArt7>fnDZX?ly&?S@W=#fNlLi{{*-Utp#?|3y^TIel*rP|5%O><=Rj9~^oKiD#dakk%q3^B=1-Pw z&@OIJbNZ~WYLHgZDlu0poEBfn(dH^%YOR1{G3#?cvh&M7?sdnKr> zWix5Hr@e}vtcp)R!HNUQ^Vdr8y0n7-t8^d@>acO!wH{Vhl(Mx zv$UE}B%v*m%s5uliW`?6ZEStCfm81D*lHw`YPWnn5-mHq^i<8;fz{NTz?w{7d8%2- z14-=nDlL<#sx?A2!K%2h(!=e)$Ce>n!V>iK%b)SKhK^5>KmFM3oZvKIWzfc@mK8tC zLmg^r7Te8cHxHR6AwJ}9s!d1zVQxmV?LF-TClTC1d0OBJ0VW9#t9w3WaC$>t3(Y?q zpL9tyuqMUFKGMra*^3ogC|&GDVB+@4{LRl#ydtRH^p@XJ6LK%3pjXqm!oO2pRTa@lZd8@v+Ba)l9cD zB3s%j3V7%c0r$|Y6(c=-YoMk*OX^Yttm7rBN;5Qygp5Pf=^Qz>aR!rQ5!(6>A`gSh zwi@swT>cEQ->y3;(UQq@yh|T_Q(P) zc~#zspSBj0XO&c20!5|6rxq&vv7wdbW}k)}y-N2|m4HWcL?&7F6#q+qHozfHAO+0c+$UJ37*|a_cSY9cWFTmE~O9LELRu z^m)1OF1`Em!s^Px`Q>FL)pN=g7FJE3q{auFF5OZLwbR%bJ_HE))X>DJRCbm}jOqp_ z*UQS81Mre>x$GN}SsGe+I0IH)g=HhlI~r$=tsif8XwRq<;Rp;yR{?vA_z}*soJM-_ zGSgJeS(;lcZBWCTNox7_+V{(wZMp0}%i>lPpx$v3{r-q>mut(!rq zk1o%wvGMU%|02%Oql8d#NU)ouhwV?+gqJ2dF`X@YYedu!YEs+&D8+f&xwEyC_qur8 zDw(26T7^0{0}C#J6s<-QNzZ`bylTowYD(MtLKYyYf$iiPGeVi zj=qWhX{+jX&}96H{^=E<9Mr{c$5(TZV{}lL948*Oe>$OaS;M|hzT)EZ3;%z}LH)!1 zKj)yJmCM6a5IibP=`E z-K=Qqq(%U(<>JdrSD~ipbP`{>@|t)YJ&(4|<&Cy1BJ|3$!kv#Z14=0Za$P$%ew~Vm z0_b#TTG@mS-PxIFUD0|Mv>@jfRu@)Pmn6JTOf1@6(_!L9_8xnYFc}g=oi04$)YIZ-1bg z!ju)Ski&cjeZ@wtC!qDlYA%64@Ivhk>SS@pHZ}(X{Jcrq-3H{In1x%MXac9`;1z+i z>)SkMZ2X)o$pZfPW}Cpl+eJ@3tz1zJNouUAsAiegCRIjj(NY<0FuS!P(aEw%bKPo4 zU2=!>#19rND7>Vww5+fQyHVAZRIV!4T_P)aGR0q(3_g(~uygY|8?~$o(N&z}l)CGX z1}YfjW5-!tN`4ysRF-pz(c0@;k!D+8HI|)pu~HZQ?|7ifS6CAWx`it-6;p(T>B^O@ zMSuuddh$-XYvJihOO0&Jk&clbjy2vXd|^L_4@;CgD6e0*u&BD~((;n(ijvBOiz*@| zSoyo4aBfLObvgd>y3p#PMRVo=umI-*nOFuz(UpSwlgOJ>QIcGq)DH>vLk4e*)-OP( zaq=Yc%53F_=%ryLUD+%!zm9Fe+Ebuu+RNmnUyXSD}^OB2WjEv zOH|i~QS$SE;ZZ1bQW%G%7zU*mTAeOYA6tEUd{C!X@wPg;%Gl%4lAzq6(}~Y^xDaM}A_GxRS zc9dGWjG-)?Yy!J^*DhlY79|=Db>Vw)nBJyUN6^o+o|O(8!xC8TgtS+pWkaj3$qoIZ zm%xuB%CgXai*mu4u;1H&Ju@?vW}WB)L5IAKM{R05Xa8c$1h*S`-SM8+AdPT<2}1OKf~K*rqlw zk)5QRuxz9R!X@B8=b4#GOWEr*fwPZVUdK!N6WM9+GA`N2RM)~;6Ddk{9(<*=734xbVO`=@*C>m5+Uj#+14aO7-;j+{s#>2@%AWt z-o2(ZN=={v=s8uTzL(b0K=iUwU9B{-=?fPXmo7}Q>{e9c_zgs7k6oz2S$}$ouCw$R zXEMOvOpHGX@>Mb?h!#2-iF4Yr?q!QOClyz|S)}%qSp8vV9mNG`Vd{E{JU)oVE6R_~ zPQ_ZRo1mSJ7?GtRXK@Ym05#P}KtlXD^=K?vZE@fhzbXXv@SJ9&*pGaPdTG|279D+s zbFSF8h*9kuqk>BYPTk8VbUbw+(QS1W#zE^$Y@M2S4Vv`4gNlExYFZVvXu>Zj*8K(3 zCno1QXoV&g$3u;TYHDIVzL!tpV@27GPZS{b!>$r6m7&;iQx(>qIFD%v2Z@kzJ+^k1S*xwY#UiTJ1RCAxv&BUp!N@~L_z8jN&~TP>Wg z9$C7ws-mQD{tS$k*@t%x;^A?2Y>Us)n8#OmW?cqH#$&w++9WOH=u(DL?gxmDm6OYo z!~R9%IF=i_CZs%mHNP`XTP2CwC7TwWifEVpHF}>+%$itwBrge+!j@bmQc4#sdP=^d zuSVw^v=#26RzWKZise{7&t4*rxb$@Ir=bHP)PaS3+##1Qaav_&6&H3o7pW6_$+|Vx znS@*d@cBxrf?0`>YE^Xc@ec!^{7@G?TW|pl`jdjAx#_zsNv}Z;{3d=nBRttf_<^qf z>+$^q#U8k0u+M-b10n|r`+w2@Yk~h^3wYhrTUO9F1@tSVzu-CSd8cn+>X-L3gWj@i zs7{P$yI~=4d`8rD;j^Bu3!f2nUFoj3|KDC_KYm+m_I0Nh&)&IXV*YP`xODavqq}Ao zpYd4!)3=P7Z5Y=_45K>_Usx!Fh6Q*o!q-$w@C#h`G{Ep(kM3u7o$xYnI6}hc#@9`I z!LuGT1;xgrfjKj}c3o%~zbQ5hoTqMFg5TeeOwh+jCS-T#zp{Nh^Vy&p}+t7 z>kZ=?=-6FijOi$C8?j~vXnGOuocBXNf=r`i`mJ^O-+kl}dY%iqnTBx`Ho>Qije-LF z%C!e!)3t}_v}-@VM_+lRaMXn2s*leeTA+Rp%}#%N+{xGe@(rOMQy@&ROE12n`zNv$ zuKmxb-yH={|K#8s_ip;jY{h?SulyD$Jap!(xIq0H1tY&d_s`diRN=!E0$(k^y&UeI z{y)jP_3bFO9YpL=;TJrk@CDEG0!WwWt6uQ8+kSFC!-W0UYdGV5e8)wl#)YUD|^DkPJWyCg-O|2**RJGo&du++9CXt?)ROVRim~CNv~ttvpjkp^IP}`3c{TmS2Kxk>@JtNEgAL=O@k# z{6w%_0=rFq3HFXWTYHH)ERnO0a2KU#+!`oKA9YKxDBWBaDooG3DO{MIy(Tr#o}O8l zZUR-5o>7E|Jon=ESAIn@3xxj{nm(3pCrWrk*C==$)+MmL8Xei5E);5f5$^*6BL|?1 zU{4Cnst*XZU0{}7DgE~7@=DV)DmWRIrc*t`X%B~>>m2&CI6b2j7)sAk0_U`vo1SqC z*=1c2M!1RWvL;MvdNEt2&}Ef5uvhq|(7NC)fgH$LCUU++@?kt*IV;?9C@vd>j|xJ% z2==JJvc!1_)+;c}-w3u-U@zgBE`se782Kh$1nU#n=?qb@43TZwl58De$4kdC*YlBV#QMUL*1-2zj+FT*fFcbC8x z;Mpil&$uZ76R!ydE=Licqf>n2LaHK9Or z`Y4EpKP#ETLyGY%;U}4mz`n&)if)I%=$qwq5$|4sb%?$uUjQcu!y$CrsgSfhNLmnDpIwx^&-a7MSIO6h^nej*u@R zef-NG6rS$#=QxtFRd}z!Gx^Dyz-o>H#d(+DCK0YOJ%i}q5m+<9iqkWiRFRBtWugzA zN)6+-h7(aiBJ`^y7&C8jCGeS`2`PiYEX-44a+<-t=?&YExpRelv7 zM}D_mcsN}yNzbT8!A51%UV(of&q~+8EfQs}14Giu>LGjpk;V_%aJ0aC@l1I_Syz=Q zxq>SoT#d>TWdd75Ft*7`J3Sf&ha)OjR<$TV;q(a3o0kZ;NpPI^;A>?X-&Vn~uRuQ? zw@YwSDLn8k(D)7ru3m6U1xGf_kOoBq;R2}m@k4rK3Y>inVJ+6=6$_5rdK_;RJK|d= zI9_B2J}a+KSY3jn@jxT6gu^2ET>>v6_)?XQq{pKI=lEWno{YD*DMy}*|f9O2Y! zJl%pLKQ&NqmPt4p1b&O~1WFVW$$KJ+Ji_e|9H$?`s?)-HM{uW-OoT;kJ+gObH~|cN zei~Q1vNyp;3;Y`%c#gpLQQi!`oI(jl^ko8PKbHJQ@OmFPnSgf*obB%^>yX!6d3&?a zUJpJau#A0$e4;b?iG zFd=w$68JoUf05}gv+0)!yp7>-7?HC|;O{W}N`{jUtQYt`f~$7PJV`>f@fN|4AUyK5 zm4@4r!1oB8{cEA}FN()Ofm1pdmpkwb86fh?&rAX@NCIDy1RhHQUz-HJN#Juy&()5e zPYQei!LM=PJACAjPwW$TF414A>a{+BS#>qhWt>0+20lTK3-vd_#t2NBjO=5%0vk_s z^A%m05AQO8O(QxKaU`$92ewvVlZmcM(QWjBZ4nrk>u5()e4ZEBSBN)B8Q7dy1mf%H zxJV&f3+az152E^? zx3Ace7!iucHsQUScuVZII!ZvaZYUu1oG|==^JER1h9 z>Cg`rF6Fsqp^cJ`stDpd-6L?T4!9WQvI&xn0{;ThbG=HPZWvA?L-FnvnpHw0eMQ8Z z+G0+`iS`|#<+O%8o32g5eKcv21 zlJX*WH+r?y=hQk|qd=Zb3gRlKKkSpWTs`IBwM=lA5-y3{z&y89lG!7CJeGkfvP)~T zY!cjWNhX@+mcKkH@N)@{^tudjBUw8HK9AtYE?>}Oy(2ib2Y9Xk4}n4_6R}~ONq-Rj zrGS^=akRis3E~Cu8K9h)o4!5}{17I~_3J=_o#Zu(yy9b#*BuC+8yr~PR*|=i+F=9h zNB!R51oWAb=|}!G{4@B2D@gSs=e5Z3spYo?Zw=iNUYCl&t-l>V48z0h>*UjULcfaq z$dxyP!w{71)s!xcLYs?cvhkIYE}Z^?`zGN&kFf`o)gV#%UvPufPo&Rwq2)Pwmp*~t zYwGai!a<>3n+8VM&VSq`xC}|)8F|5&FIaL_I9gaUq`HRyFf-fDXMg)mT$QJ7b_CkOwG_ z_lmqf9!nl52)>ZwmjfUt7x!@P7@=y$Gug_w{ZW@tEONZ&3GW5et{%+JTLQtX;mPex z@!BBro<0^k6$Fna%i82Odqvh_@iUTtP+*VYIr+RtTYB!&^lWrJJ$c}I8t23eh{_Aa zr;!ls6`(&!^TNd}3-b>iS*i)TR%A>f85pl5y*CQ%*95~wuq^`Pc7nj37Z_zlx`=L< zz?LvX!QK(rG7V-8(B3RC%2OjxS1&v0hub-UZYxibpX3PsVzMXd;RHXyP}uOmw-X#C z8{{$J-G^uD-|6F8fd{oZyp>JN^KB1&LY_>B-X%N%($Q%Tqro;jFh?s4i8e%$#x)o% z*)>~eS2KsQYq7vKYp^8(dtYD__hy0p7s22sdfcH{Ab?IkwKq_7b2Em*+ax^mhzA$x z`-H%D6Ts6BYS2tbb^9Kn<#rt^l_gT=AM}Bf> zUY7{&b{j`c^0?JhW*_Ymnh4S0qWG>C7_}$qBG>~0<8cy!Jt?pWM1+g<*)FiD1VCJo z*SI1e8T$nHIl|#0Sf9YeRaiy_H-Zd&j{}z`BL}bJ1@}7Pl9i7?Pi)`S3m=ycXm?p{ zGSazQaLY(0_ZI>Sq4jf=b{hppbku&e#yXx5I42?C*4W&3fwS%iM<4UtC%Al)1qWLb zP}U*Yp|c1man|_q05b*0{tkceZzs^~c0#en_FN|X-f(Gry-RRwDDdQS&lsNd$ewE# zzuZT8UgSJZaxliD=c~Zoc78&Mt@6(SJzS5EV@}AQP$#5z1T5LcfgIoH8k)k5053Od>Lj8|aUVwpA;=l;1yZ5|OHlR6e|%J%2o4 zdrZP${|o)`#5GW)MHXnz|7Q~+nxXW^)rOP-4jD%v+vExDg+$Bs1Ug~JafDlv1UC=3 z4#C}+f*0sCK)<3mJr>MQR=1P?_lhizAL|gX#|tSwdj!7}&u%+j?Xn}$4nK#8kmjP7 z?nl9qDVAe!pD9;p7ZU^WU?7s7M)58e_-ul+zr@*JNY`e;brKFdSFp7LB`A_PudEY1 z=|Xmqu>)@BZWi2)!i%{uSURx4;@y^nmvq`IxNPEO8(m3k91r7M0vZOFqnO*g2pHlS zCGgJ@l6AqrE&QI!%^bn$ZIF2aldd((zCvJJ<|4j}MRte4InB5%LZcF~p)zm1E*m@* z!n0Z6g`^MjTw?P)FE~zW@KAY3vUVqd9}qYXg`m8na+TsWd<+RU4C*S-WzsD$%YW7c zXbcK12yG0iSZLlNCOyv-1UBnVmJ4)DXm=7V?3&Paq7k=mCN!P!jVSbgg!fePPmF!q z<5y+?Q#W>Z6W#acUYvsk4w#(hcnTiJl)eWAwvhnyXjb@E+nytNfB@-CILu?v zxCz;3yufAHnC(*_uw?e3IM)l!ous#aoRTT( zzDnVQIFs8`K^*odfz70Fa1q^jfl2krd8|NStX74S_m&9!3SthRv4l)XZrpE_g9k1HL4FnoSnu}9Q6A`dnmcIsyYn=q?PlSz(w6*VtH8Le!u6W!e^9$;m*CRG zhI$x*KPZ*0wi(f16Pz$cP0Tm-8ZSQbMRY?Z($ z9&{1iI)Ta11eepB1Xe>t=#Nn7#y!7Lfz>AZ> zuMoKIBcxA968O3#@CTB>xB9@zFLnz25{d-cLuxfjBl`t~e?ahh9w+#4ZUh>J7d|El zJTD2nDha$<;AfCtNC#_4j5FV!#S>t=!JWn;I%q{*i8zrYGL zeKrg17X(9{kz^bK9bc-Q9gU6yImci47ZAT1XQAT%xp{aEWfKs64=Vfp+Kb3K6tf0e z_pO$82QyRjrYd1kcYwWIWPMt@trz|rQV18>@&SQKH;!RX3Tz5fsW@&I80UKx#|tTr z)YRW6xXXwhIH|v>cBURZR_&_xeugB@BT^40v|9rxP4q@O_{fIygzwd4HoRKd5E}_> z8&)K-;awu@V#uZR@K5XHzPD5O^|tFifmM-AT$EOQ0^@c{(r^OTd0dK}yntj(!XI4U zr9be=0m`AkoeAq|vCIW*-6Dg>LXzsB2E$+ZRXuISxGB6YbW8BoKyXBgpJqz#E|I%Q z(!<||mfTvG+(}8~WspHuT?n9ufQ(sj4c9U&XwD!{#8U@K3=%fM+CtUfU@(MWENWX@H1ri)k=L+Kj@<0^#YqA{rv&*6fJ}PTe7YX`Ot2WRm#GhwYL<9 zgMy=Hx`=+bG$fk|Fb_(9-l@+s1=nriq#-X-+M>f=`+ z=qYIY@#Z2h^Q>ckWQz|{{@y!VY+-P z(66Uc0np__`yctg$Y@XE{|o&5UwF<=&@q^n;QvC){V>hXhf9Nr;hLY15xAe97YHty zpOa1Nh2~T|(?x!`N?_dt(0q;azu=}PiGRow{{o2ECOqSbXP|N?@JGL5hwJO%RB7Y7 zR>Dna`|^sMN`&qm0aW8!Wx{`c61|W2=uP!qxA4RRcp0oO+nW;jcap9wm0#OMmN#AZ z>ToSx`vl$vUT^s|Y8C;p{e=El`CXg$pz!j9hU-`OQKyunRRZU6V)Q{VW6I@Gv%pU# znYhRgx&`(H0+1gdqf!}4<>N-djU;=z^W9r|z9XO6CbX9)vHdiU?MZ&0@PrfPzoW~i zxMt?#53V!lkK`HBzd+#LHU{xrq4Q{V?-2McB#YvVwt^Ms^@3ZLpi}SyM8U4dD9&4j z_P!)>zRoAk`-O+s?zn6k%+=+S{-bA;f{Ag?5x8HR%XJy5#0_Sy1hPh2Yu*<7qJ*_3tI9_fm!VV z%JVq_%OxU=$yz3?z4h&{*?HK6Oz!RR-Rg zh-|S_c=dE6+q@(2ui%+3f*BF|%s*g88< zo?vU4LsfGO^F+oeBm;g+eF}>EGJ#vRq+n8HKRk5jf|;dFk2Mc|p|<`+J&9Xp8;@q(9Y>roe9| zUG=hg8TF3s>WF1nA5Ewu+Id*VfK3UU{vw0@5vVb^R|$->p)NPO!;;En{U)JXKr&I* z`=m|zYIiPRy>|)UYs9C^Ulw>q*V_a-G>3?iw{<8EnL;yyDV1O63CwEO5?#5#a)i#r zZ@s|A5e(y1w1&jQS{v@N0YquDR%ptJ25Do>^O<;k;28L~3C$uO{=LV*pEj2mp+Ei6 z!lyWm5u9H3<_gTpmlTIGft^J%IG&h`#2f?R8a?vWN-<@}9>MA5!v=v_Wedr8RA2{4 z{=D>9;4e;pdz;{v5>Cq90#AGO9icg!XwZhU)(M5EA&yIjQ@lqDTu<|CfmwPHU9rG) z{g?RgHv7KOP}35_>=N|w6>_gD}wDDwsw1I7A}l)$;-fmXN0oV$ep?0iWx{#-LD+)9gI;<963>3&`33PLr1`SI*F9-YHW@RYh_M!r z{^;phKsy$k^vnUeTxee=TBMKeQ-QBDG0(fcxSfV7LpKH21=wzDh3^XDyHf2zBzcu{bFo`;F&A{^!u z*uaiK@!cu7zYy*i%8zH0lphpNb0G;)<6E@u%c?VTlfcV$_!SO)V-k3`z`410l|#QF z34Du>9LkH^1U{Lyg^BUITVQ`6*uZ0JRNVbEi5WP(Gs~4=E~n6TBY&bW3Ixt)ZVYT| zny>mAMkaFo7G#o-tP@$QC@7Rk)aRh|rgYdWI3B(M&Khg$6*w2=!~+*0`dvxr_X}M5 z02wR9pVKa;KxMx>jsc-{;8bpz0_WjXtT|RH(P}r8f4B<-|8@#q5PzTcIrc-+(3Q8R zs>X7_BD~dI|NQ?L-mQ;2|+836yN?N zd}$TLp!~+mHy-dz!E?2NIc{CgReCuDS}J0f2z@J_ldqq_!dPBe@+&$u(4N?z&$hDH zu&DN*$SWjyxN>oC6pUqvGb%}#Vf>N)AkX;A zq&Z8^#2v^pahD5!!km^F{G2|-W`ed$Xp^-iD2|(iW)b-p^zrd8tX;n^!M#ZSZXfyj z+I_AHt3ZhBOGEHyu>1>mEJGxGGcedmUb)Eov-tA>ZMWj|O)0@;1IWvOyiFqSmlS_o z)P;XSV8188U^=5*^HZ2)_lX?t^W&Xh8Qh>X4698;d1{Qn_TkwGtl-Rs>lvb8%>pAoqiZDYZh>7+0L49pEd3CowLv6;lEz5 z*>m=Leb#q9uf6u#Pjkt;gNp-Okb*5v!5YXA1`hvMlI@2!C=Pj9OSUI~^mmz1n6)32 zQ|1^zDI#p7J^9Brc~%h{D6QOC-`WmPW`)$=)WK@gl-ck|MThV%Y3{)-6cd%SSKGzf zOEJ#J@D#e9MMOouoMHDuS+#-ZQ0mctRP<$!u?q2};R*-2jxa_@9z_==#!OYoTd#m&Gi z>j5lR|JZ@68u~sZwAX12Gev&ebWUh(uT}KBpMIOi?9gfcK?7}jDYes~mAv@l4oz|G z)z0bGQoAF{CVjqfF0eYN{^JsS;8@v+djy-n@d$UlNrP>Bi<3D<%%qLJup#d|!+BL) zepZqH1w5_oIVo)qkYFom!%TnV*tEF}rJP&GUAeL*2S3zdrkQ}rR|goUzZ@|Kcenhy z;{e)iA;ZktlJcz12yF-`(74!|OIzEqKcybuQJ(TRWs33~BsLmpBaHL}mK&b@X?u*o zIbHUtvJq$2{F07UC%Pgt=NB>R?t$3!vCu_4l-l_p{nu#~ z)82dXTaU>h|G`l@4TInD1?&}ez4rL0rOi*0@@)EKU_ec8p*n}}*-!0ERj``sXydoUjPEmG^ zv}X?UGRMPH_2A9qz2!INy|@=CEE6@2n7li=yB4?Hub1N*j`z8uSxr6~dU0SaWTrjKKH5y? z*|HI54v%s#g!@(%=H*fPJqv+4pOJ@m-1nj6EdXuj<(TIs7=F8m?6g-dvcCS#RzW3W z*Nf|DuMg5AWrOQJDE~(CjIivebgFL@6-5&AW}JX%V5{3?*@#=rd0m=wC_IjYHzr=;SOau@kRhFu?$opSfRn()L>BwKQBuK_hs^Q1^%Kh?UK z+~)`DzBlXGu$vfm5yDEDr3x$Ser>{{%@mr&8~Lgr!b)mz6ABiTOJsL6{kBJ)r>~3Q zk^1P!NL9b^x-|7ZP0ZBN=JHOmlfE6vJuxA<^>CG3pJrU(*1j#2 z_lQVEpU|p+vM}v`s-#KW^O>?qU)JbL7i9+6LOV&&)(9Asb~2ueC5UGh{mQp2p5E!= zX-pH(8v5;lv7!C^tPUC*ke^t&Y{cpOB!rEm-+wV~$n~PM<3>s7Zvn*?`qiBFy!qDK z!y+Yfvaaknufuhj*N1NiVH~ex90y0XB#!XOL1R;RNsf!fi;Jo3b7dp$Rcxe;Qjb$u zgS$7?>9AR=8c7?2VMEQq&vJbQpAHmnQ~%T-jPh!)UgShP-5O#eZ8eCg^y!y}G*hf0 z4v=6u=OM7%f`d&v>4$#MZ`4ozjrxVu4@Y|Beg6Kjr(BgM(zD_>>NovH{ebh45Sa#I zqtbJJiu8>Ajrw`ik4#~Iy0Q<=QtC6=-%__(`P^C3vDJRNGUnz53EZRrA$BXcZ8Ie*s z-j>SggM8B^WlrR7E*W0i9y$2@8{->@{<8U8#$1Q!Efta{7kKO)hW0*_{0l@U&ODzb z?YGVR5HGEs7^#;@RzpZ`GpS4QQbqKu3A9s-c-wD3BO)!)(AfbwguNxSm$PNMJrvZIvZA@665!e-kuSF!yJTrCs-)+cxDV7f8cX z?8{bKC+Cum68T%euv>6GW9M`&(eQ^sol5NCc)N}^FW`8Tc77tqTbcW(Y-O-jc%f{> z{a^caia8=~08D8sPi)Mktt(;BTvLElYXW&@ao+O|LT2R|GPxnb+%J?Xy94QWKm5cYFU3y3CFPO`Ee|SVtUb=Bt^US1 zZa$LFPDkQ{V32OLI(>yTxc2S&tavV1bQyCgMAjDl^01@b}AMKiCwd)nT3qn zZ}2fza9|FyaD$r7s$_bn-X*dT z_aAEU%vwBLDy3l$5vAfch?+5I6zSWq%$K@`bAwLc!e`0}c-Ik;=B{#@-qp;-7SQ$< z^bL8`AtO8}sGcNgXrF6ouP5@;UjIno;}xmL0L;q4cU=Hp+L&D>{VUmpysLCw1!WI>rXtz6I&`w}TkoV3XH63qW3@ zmqEn!-&v8|VQfo<b+Ht> zA~NJ3E-rtiWWRSk0k#&>2F5#gp9Ipngxsu;%Rc&dBiT(EveRDwj^m!4)I9{Yx?L_C zas6Q{{kSG`8|gBsO_?z_L0fSc^!F3>{XXPt9}^cx0&@w=$? z7+Xlcp77&)E|A6&KbLE$?j2%ffc)iL0g;_!>GiKO)cOnRbP)CC9RzaJ*nFR1^1A^LUm3Od4Tt};$o%6=71@zS zC2J`1zlQ8Zu=dWAM}@`6%(yG< z*gVTW-OY+@zD84%Eqb_^{FRaY13<Hb={!4^fSnEG=J&^6?I-i9)VsQ`e;4bv@J`|hDe#bFyo9!B538XKy2n* z3+r-@jLqhDj`OR~$G(GfOuP%J{SsQ4Z~4bF6QC)1K!g3s409C1Y_>1M-^D)bw%snE z*4$5VB<>~NXle?_sU`GV0z1j?QspBpW))LDyu9phh<6S3dqAIboH{8f-a_%tod*%G zgGs(p%q3!YXQrN~BkV|q?G-c+ktcaVcxj0WjJ93Lu%CxyC;gmLzO@?;cS*B;6BiS! zXs-qK0?&<1f~2jsyj+x+WfBW@?AsZCj!x9k5y&WKcoBn-ljW%%gt2#+#Z$ne)} zVVPv6DHGUR_b1vz9~^YOY{b1BmQ8zghU@NieZpPaIe)C8P5*Hc<4-Ml3J z(V(4fpsoLt-$-|xdc_?|*SD=zj8U;05XkfV=>sn&9}mw<<+*E)X^9m2T#?KqH|P1X zZ^pkAT8uR{CyTT5NGH7+)AtZSeha~_EIO2}hDIH2W< z-)j0Tkl%1fPYc@;8v|J^77t_RoEA0qJQq9wC2a409gBpd2`njmqv^`kewlX-j6U-S_S?#92#? zd(TF4oC!SGmNW*&CCqAuaeX@V7=vqP!Os##%_1?^x~0!-KF2ThRfWC(7v)t#y}wOQ zAT#wW8t7({?IXYOy=%1Jd1Rfolb!b3Z*@laqcq3+Zen6J?QJ8!F}Aq(wr?QUb%FHd z-U_kjEyAW4kN@0k#)x9s9YDXe?axPW&2wVVG1%mvwoKX(mHf>k8wLCAtzjm@9fGot zvRp-5KVxo^-j*D|!r{s^&sW98M8R#c5qB}?A3<%YBs@Ol;R^LJnKlwIR2IpVl{S0+ zM?MVPwEyv@%uyfJ^jiwQ;z%O&7khleII)y|bKvJ6gQNILU-B5dmRf&XK$&|Bu#s~< z9^=!Fnek8}Xv9SRM$(o)4y1Dec|9UZPN#esFFBo60XAyMFKA;!-tV&6gc;*jrm%rF zw~l;U*bs*_d$(hgJjR3PrQpa*jJz|-%b%B6$bSR9Y0qP+{b@_eHW5BNsJ|dRwJFkr zJT;Jam)~$W?^sDTENxp2J!_{4z8B+2ShR_5cgRNEd)Tx$4#fj+lQ89*pe=u!7$|0E zl3$59lEzhBxo)jc^N|AgQ3sSmU4Xqta??JN?D5SF=9DNbTyfqAcKgVU?xLycl6K??ND1Q^MvqgvEFeXV?h)xPM+ESH{qg&2x9? zSCgq-+Wzqq$E3h}z+kJMwu-mJR&xeU?g~@AcP%cqGVhj+ICC$PHvCKYXU65wXlvb` zE5+&mF#P@LkMgNo-cXA4Po}mvv@#!e=VWuq{p|+&g#r2{DfD@wUqPOb-%KkWl{e?c zYw34imiVuA%3_aYL{+Z~(YNZ#T2=w!i=NK7t5z`vCKduo4qm=FFl z>E9RrMZWNI;u#gRfd1p)FXf7J!bIqp&h8FfXqHlQlwTv$L3@XmoVyBdrl!QN!9os2 z&}7~RPtQ9Io7TAG$U{v+Z~-;%yAJZ)T@HdSnT*Q zk8$iEQJ{U`xR_woPqKw^V^9qeB=c%))VN`;fjpW#a3D-M z!@QOv4Au_rP7Y$O%hxc>*%=aOb00J3ZE-aYVr*JTz4;cB(&s8Y+G6JYNKEQE&q(3@ z>Hk=!?6g<@P2uo};A%GYIgR%IjQVW&lWd_JavqS4xC^lf$sjH7qL6X)2#g_UI|Jzd zXQX@PpJWSjfaSFH2+}R}lVT3gl96ITA7iHXAU4vhu#x+GFW}&wE4%shbLWfD$H=a< z`glmLxZzk6mHmxyLGV}6{HRaTtg76$`{O{>Uyz{Bq8X9q6wPY?W1BERm zdk&&h$2Qzp@o@5i4YoEYTWI6iwJ_p&)7x+3X6H7?>w#b*G zQ%+CK+`fjk9zg$3Rll(CPTM1RfykQ~b|}&z_i}7rzdO5i{)Bg67KwMxLlAl1v)Htk z=6L9?R7pmhqiN>|*hz}>yrejxt)O-Vw428&+><=iKf}X(U@^73LM!(~;d!W-{9H~x z5Bvy!9{CnH%t4m@&7DS@`|>t24Dy{EW^z&*#j+9CFD#oau~*e6+??hZi8^0En^F0VwvO)~pbYBB-8fh*Y&qFvwym`1apmDG znF6HD3;JX3qp}g_=9I1Dg}O%rX&gkYsUu0Fd+)?(^6iZ!JGU$IYuScTe--3sK`UcU z^0`+6CmTuUUg%3p80N5`zJ!UCytPa9M{|zY!m#>WBimdgNj^VA9;1HFJR;qNA< zxO}RD<^#Epi2-qkU?X#IS)j(@-He$7=(jiglE&Fn+l-l|)S6*d>NRLhMG|stsx=kl zVm-VcW4J4l!_fL8|Ss{{1)0s5vC z`aH3}mV5!?#r+r8*aI8pJef}c%IAHsNje9Sm0#Z?Gwj5u{R~<;hG&H2MprpP!p=zg znR6|_otXb!Y4*OYnbf}BYDeBzPCN5|gPjIy-*2_^im?-u{nhj{%ly)Q{BsAKvRtI* zD5!^AbHbYZ{93N?0`hFcBMxj3*>;9lR-zbeP9Q^?ypuLR&ohgB8*rIxxMyPK2k^xK ze0cz09l$rF;HbZxdL+d2w!%DK)-O2sH8;u14SuaHAu8U5)TUd<7)woe(ZgYlshn&T z0M|&Op}(6Y5~QJu{$t^<>Wr<(oQh#wSxW5z(E8h3^emTHbG=~=b!LqxNoT)YBd5ov z59T}rL!P%6Hgf+P>SLt*>`(qB&X*)jY0fX?EVfhlp)~iBpgl}W5l^1*dE_QPvKA#P zM`rGcFtzmCReodKz_kN}X&~)Al=>IHesHj5rI)_0Jd zcJmkxZ=L4+EiNWXY0u4Bf{xwsH1CLCNE-)=JzV2Hjd@-|J_TIf*T*F|Q-@6fVb+qL z$1rl4ptWo>%>tU|>3H(VQ^ix5A`I%Og#1jz6N*Q2%j|oY%Tnl3e--4Z(zTF&2g8=+ ze}d#6aV#M(0+;7>P%ao-R*?7Ru`YSMON2gEy1XFo57#QDeae8o`qF|u7Cmh&one+OwS zCO5}E;b)lkg&t>*3uW|2ox{P_EHXVum`|?f2#W*s%gHe&Vy(ojL#!t62`&!DtQInt z4zSD@;A@Y|_>Z*Zk(sb!6Jy~3;W6_4AWS+3_CHHf+`8VCpx%u&usw~;pKqjR9{F*w zE&bX(S2a*}Yw2hDqFU#YRd)IIjeoh}Qd6@yo-{MuudwMK`xAKDy!DV~@|^P`M4qS9 z)t_9a3wenLgegrEW?G6cur-g|UytB50s5r@`jr9tb>zBTWj078;(BAlwF1PO-vA)% zdf52psskGU+UiF(7~Dobfn3|46`-FVpkExIUml=eO&<5e$+s)rTzdn#PEXED5Vp;4 ze{!uKL~h0cxgWvxyV2x@)|_cuWdSxS$Pa;5${zQGqMt1wzZzW4gD`iU>1*$(t48Ym zX#sC0kIHY@$Ls+8Vk5a}(@FhU4qC2T$eK0M(%)S0y5>+g7PK%8l9g=DCzJB(&{H+VY=!;MiPEz7ygQH$ncEkgaaN9`L@lYQC>+Q3md=NSOk;U8Q!B ze5s~xQO1Rl>P1rCQHdvCu8YE%z9Rj24sU(Jw?)vjPzG^ovfED!uF}e5{wWh+`olch zGUqbB^OYKMj74xo@>frGD?s42zwvg`*E*pb+$AKhiNd7sEeVElw=aB^p$EUGY(7Th zy$Zl{LH13IH8Ju<@bvd>a}nPSoc5cwV^i2bolYa)7dFJ9FI1BCMO(+ZN;oXN$DE>= za;~L+g?P8y)><;~xr&qpjXZClt!-e-x9*VB2#|dLBJ}+O_@DqjI)G0O;By1`!T`P` zfUgMPYXbPD0N(92Qw&M>aiSas1n{B&J~n_)3*hsTdCaW`)g<%Qb)u!oyj8z4nYZfK zCG%E&=Ig2Ro1e^E^#hZ6tNoDyd_n-96~N~Q@Wlaqc>rG>z&8Z&oHtUJL;nCiD1eU+ z;FAOR+yK5XfG-K)D+2hM0KO@JcUzIV90mmNq5wWNfKLnH^8$EH0ACuwSEk??ch`~c zY_n(1hrKuLPL7XtBkMypK>iny4FmI!`_bY^!I((2*f$f7iKLYJq0p=O`;jIDAJHF4A0{ccMbVi@OI+Hv1BFntEiXnyU9l|?Xd)D+d%(W@K;$~wbVN%=!6h|zn?m3viu>O1@9ka-POFHTpW^TH49F;m9>r$ixbNozm5yH-S z{aGJStT+Gzc z<{k1o@E)wTAG(kSf6Nk>IZs+g8{0Bn{`En*E5@Dt7;Rn?BJ#W&ut{ojNsqaiK2$`l zxh^L1T=^>{+Y{l%p$XJXjSOqf znYN_NX8jXfx)Er;%*%Z-^(fF?tRCR-kYAk7cp2C&koy z(vI@a{XjP2wzdDvalSv5cyxhH(xKuP5=IjA;v}-wc9|;bM9jKSwVh& z2iZwKKHveUs{>B!&HB~~+PY>-Y*ok#Lz?zkB+1ENB^z-kb8RQ}I;7mdB~zG&Xh>d& z(RL{k$NdSkQvqW#ubpA)=3GppOxet(zrSoSr&>rp1mXPk7PVhP!FBtQ;54~+sk`7b$>MP=sQbk%lvD<94`$jNA&w_lOSIE zk$v>ahYiz)i>d7{;n2U`yEzl&{_;Y6Gs%yKUR+%M=8>JuaXxi_LzDO@ zRaZ0VXbOmLEjjW9hcs*=bH|@<;H%-w@4(CT5xlRfQ1%PR2P17GgRV))Rd1XC`qo>~ zKPNEkdl*#H*VFJwb;oeWG|v`|6%$Kn@9-VAz#hJ@*VH#uA5i(>Ve;zzzVhn*zNI3w z_1^6tVprV3*vPqr|2&BmZ_e8D#XC+d#w*mj$vVH)5EGQ3|0D2Mw&Z4^aOkGwlWl~V z|2x7o{>Ct92b&mX5Ym=3zWSeCk!*=~!6y(&yTvAb9ZCb0yK7PpS*D#&qpd4oOUfj; zoy&=Q+e3I)6KqJi;~SwUyC(8#@Koh3H+cH*6hN5FPa&3TE!b>fn8M!}CN8EY zGfXAp3C?#(V7}{UL+88kH>L;q-t;@d#F~-#-&R%=noSVzQv6fpi}j{q$yH+NaRI|z z77#|SQI&{p1;gBiFmg>O&3$^(MuQHklX-#YZM**S8I19{7+L?3(G5eQN#h{;-3Nin zm+9MbkF9QN<-a3L&2J17m*lKsn5&RB8OKws*Tv*T4Qja#cU0kyD7*HR|2YD4UCdtp zljWLa=Gak4KMcWex$-xXY+pkxOOW;Sv1w%6`B){{v1Axq7m}f^;(L2@Leei}y-2S6 zFT;AnQu-${WJks%|2Q2U#hE?VSMx-&j(QxEFki>IDC!b^*pINqI43Jy zkkvUS%a%9lxtaQfTgguPbjmk+x`pq|2|RR}w8p*^JL1foGbye9ZlQ>Vwo>%xlF*TDI`pxT(!(Q(lOrXlvvss_YzNtq@ha{3SRVXd zFVtD#SF#Z|2^)VosPEq(-U-xp?k_v(%R%a(Q{cDi;u5@$wl>Ib78)##8NOsbv$J}Ide46uQltt0kvJq#VYusEGl9y0OmgHMc6wqJGsYN<4=b96; zFRLk(-Ffu85&b~&wuN?G#ar~DD-IKz^MYe!p%qdFxdVV%lJr{|M z)wD5Fez)7+kkN6N=V5@Q04jxvHoBq8Z5mcM%1k8M#}!yV-~Qkd%fXRwv| zt!%{o8MaDj%Y2tW>OXD1%frV8r3>T3LfU$IOY$f;1Ktv3Ol)C(wvP68mfvt-_T@dY z_KV-*z`Ct7KU*2bgaWeD;Z+pLmD#g7$ilCPe$(M6J%3Kf-u*sWb`$j5XD8W7UmmUB z7L`W}DkV4l0;aZZY|$ZE~scoM3#nt}%HuEc9o)HrJ+GVCn?SpJz_{Gziu<|{-z@U__T$_9UFnL! z;mZSKleon0O4>Eo!rMC!E(ryFEiwFThCLm8>+NBYlH|`und?P^T96^ndjgyG;)#dk zX7Q9m@FW)t`eqev9toTB44ivT3x10O{6>mjBmF+boG$%1gE!5D|C(k_mn$anzL$-- zVfLRlQ2q}fTL`v!9xyzzK-L%+#N{tBGSYHM=ycz#0O2P5&TtDE?)G-#OQ`r({?2eY zKOiE{yA_)>`8!3$SM)o=p+09ZTrb2YYk2OO9sCvq_@Qo=(C-L@6KCq5tatnKU#b64 z_&*&3TBF#*IG$%NsEBQjDQU;?lJG7;T@vY?KwA;{4F@)pjKi@RE9a3-$P_{PHY|@k zVyu)qm3)UFq`QeWmdo#UY~Xt0y+NfAli>LqU_{P6u~B0^=IwLTyuDClB@FWh!?YQT z5%7+-12B$F^BC3~?IS)F|9Cr$2w~&5s({J;8f^dy?^GN~hOrW-e+BqSafXnO&*QlKDOi09wju>z;PDjdf3y+Ym`-KGTd>;hJ!&(Zh~=xf@~8^WNM>HtFpYMXKciq-|0i)UBvGm!9d-LaCoW(9mXnnNm~sn^ur(m} zVGCMA|Ccjlr@j0(WrU87tjdt7R>nmU*|{&EBZw))9si$f#LdIT#%&jWWEb_2p#T2x zH~Bit)Wb;GokhPNu!hrKx}@RllxDtGC?;0W-ZSzW_EL=9iO@Z5I*O^MY|~-+oUa5g zlfQhj7uqj3Jli-pQaU7(7!oNP5-Fc5`-l7X6OocxfdyG0aaA%dGfYW2w$3M`q1*lQ zNwldYDy`^KjbuIKw>g)RK85kAnY;?zZ?}A6WG3F^TNJ63zp9K8$-5IH<dHy(1$3^6O!qc}uFfL8?Y1p&M+fHwy4<`f)ldn5T4 zoGalxab%=S*64;rW)6`ib7mwl#lK$~Nt_i_T4;k4%*#7H?-u#pPTAuMN6KXps49oJ=q2XzQ6degsW(%!l4AA^hJHLu|Z(%ch>a%rSJGX}{% z%5XKAnJY-0;r&TCPHZ4IZ78XJj*1k>WT+@oDD7~Bc>&kv5zx-}V&+AHp4SJ(k$xP( zG2xk@Qb3w#(N0F`9k)gsd(A2AMa9HM zax-U=vXNlYXo`$2_uO%QM_cFqv>@z2@^oQK1HzVXLD=~z!lGX-CO30f)6PdEr8-w8 zv6y$R6zwW%7iG#$d-YTvj)fvKWlcz?J(coTB|}_!Xniu0WnS^BmcQDJ!O|p0M9SrQ zN6O))C^#fucPb&rCo3enW0HwKHij|vS!X^nmV6A3N){W*)78nk6k*ZkGR?*OWSeN8 z`Q(`A!-2)f-1!OWrHJeth?4pfo(b68gP<*^b{4c!Fa9yt|Gsj}Ef-Qd4q8*+ya7yh z2gu)2`dEwl5SumXZ zdh*N2nJjNH`PJmEUY;f&9v} z{2+_HLh_Hv_mq9O67o*l+Wk`d&l^iVp8Qqv@xo0#niD!ZCcx_)>I*QSh{JgS+$H33 z@*OSqt|dR2dwTwPaqFV zdqlpX11&g-d>i2?&qK{(h3D-;z8m>O@@eF8+Nq!&HY4vy>OZ6&{U7cW@{Qy}E%v6; zPLu-x#$LF~s6TiIyMHyy=LYiSEMV8J7L#XSKo#fO)vM(F$X$E*lzbEuSYm_8oQds9 z@oX7lP(I(2-$Q-AaFl1m`4%v_-k#J~MJ?Zp`a$F`lAHTy#BUV&zD)RS)SpKFIyu6_ z%_Q%LgN-=X-YUrZkh}H?P1wuAza)1x^#@Y_i}XXdTgms|-R_UI|Gaz2Zz6Z=Gp`9Z z?W)`gx1%2a!X5`nANzuKmebB;`t2y=udy@Lf$Tx6wB%DT}*xb zo|dzjdNtH17~!t8{{r>vsCVu2J?iVuv_f`EZ$0&Uv0@*joeomONay?HCzJOif1tqv zbKi~pj63~{mN(gd-gxqBf3OYTJj*VAGsp|yw?byyyN-PFO3U3fV|)h>>FKL@J^5G1 z*n(Wl{`DsLQ`BEh{)KSVOD@ZS!bg(A6N6^k1>Z7#JZsYxr`iy<8(DlcDoosq4CRn}` z?HnT9v^VPKk)K3;3H3e6r%}I@dS=_ZlYAZd!PGxb{sJ3j5&3HJUC5n&6M2Xe7N_4{ z4#Y_3Y1F%ZI#4*ux#Dzd*o_ZIlgG(9oOxyBQF52B%V~cYc1iX_e&P6CEu}&O=tCK7P$J_PdM`R>C4IbiR9f6upILzxU0!uTW z{_3)1zFs)Wr<&>SZ@s-vIX2!~*w99h4-gK0Vw?s2$cIt?3H5&=FQ>kGj0L-qUqfC& z&cl*dLp$>hw8FX6zeRn+3CVWWQlHC-PXqOy%)^k*66#%l+`;h9UUS$AOQ=6UILf(+ zcH-n`&`xx;1+KqTP@l_&SxS8^^$F?=$X}+ujQR`7Kcl{Blm)IG{+IgCs2@sw?+ELQ z33v5%pm3zW{~#-5H}FoOKC1K=P+v;D>!;UIZ*KS!Q{5TwgVa}2&t~ntL488m|C0I_ zsGmSPURT!3F&4P~hu(dC{#?@2b_fWgPC;3Y967mbk*V9f*+ya-cPPsN;uTnpR`o6-^KFbfYfYU*5 z5cQqNW7LnPzJ+#Ndp?Ky1F3(N`dg`wQ}5bg9ra$^3eTecW$G(fK4#rh{8m$c7WJkiguc5$Cb|{>JzN5eA>C1 zd=~k2!2CzO6Y_2tyN_L(gOg?fxBeP7|o@B7rd^cRt@C%=j5 zJc)L4X~*@uY1Gf=0B|SuRn#}Jf4OpanEL!8D_oml|Gz|iHIHAe{6D5Xll{ewGv87l zr(UYtxDMOed=01GrDsRsD2F;G+@*g%>OZI6wYMVb3n_H{?o{eW4!7}L#&|2KuinlA zcO1Ew`ZuV5k@`CFyrV6U>=?J4{3gXeCT~>yd-7|FZTN+>^9%XTJTN{$-n*MEheWvr zeaR0Lj`pyE`bzTSs4p37fje)SLjC9?ET2yO71ZZa@5X_9sDDlApQb*>4(jxOr~c3* zt>G(Z|6A(oPPD+Kr-PI`(!Y%QsnqWw9Q7Wj-iTxUZZ$e+AGT8DaE^!e?-pa=oOIn zImTv)-rj!XQ^{TXJd%7ic_GW;V&N!fkM$cPzlHi|sNakH3F=GO?|PE2pnk2=e@%T; znHBCxeTEDa$ZwAl3o^+MCf|{K0Qn^0NN04i1&+_AemM0moqwS|&VI26?KDz9gZcx= zzokCP@v|R!2Wi+y=c7u$r*NdFna71)sV}B}4fXqyUrv2B)6eOkw~+cCqpZ;B|4w~; zq~-h3&bQPbLH+*ZQEBiMy1JItpDq zE};Gw>aVAM3H4Q+Ke&GM7WLO2XN9j(|26e7>Sfos3>hep{?ViD{%zzvgd@K#gDj9{ zX58M?e@lH0k5k3e*HJIkZQNt{!P^HJjUuL+JD|d)VHu-IQz?} zzm|Ge4)2gZNPa2ptS8^8)PkAh`BLC0hr7sKeeFiRj@-4wQ^~hG(Hgj!cFrTOB`+ku zlDwIm-N3tpyzfa?xHI*Skr$J*xV&dSnckMP) z3J`X-8*A-2{r2ShkYCJrdyzk?^!t*(PJS=-!^tO~V!=-2W65tMe==k}&LS^L*nM_; zZz}nGau%yMo%}m;Hal-F`Oxv!&Ik6NH(z*$tnfMK#>pD$cR0=Zxbf;?@8_9bx3Hid&@0tc$VIK8Q%Rphq!$@5$&8n zJJqz~(qB$}zca0!1pDtLRZ2thcv< z{9SU_zdk1KJIe}ryNkD;yx%33S7zJ)TT20=+#b2Y?th(Q|MwJ*@`;~s_v7}Tw=a2x z;zhJ`(@j?RFP6gzwPJQQFEx*J5^R6SWA%BAPawqLXceKI; z^$${i0uAhwWj&TspXg!t8)&DI`pQL?Kg4?Zkosn6cW|zKeog(}HI|=8J3o=%_n_sU zFu#%BwqKZM<;BbOi(bM}{<9yldN&RnMZSrAudS^AWMfB;n}^ta*){G;>UV$I?mx%$ zETTR!+wxrd&s#!XqWG)iam7C*k1D=SIMV;sv)1sK3`P*O{E($~|1sje9fYGCK7G~dSqTnC#J-j`HBVTirei-%T)NfBa3F@Dr{$29x zsBfU&&2JwhuRhlbIZS#lkyk1HG3~$dmen6h`CE+j(k1w zcCww*sc)Wa`R=rH33<6n&u!!h#UCdxQSrV(9wXm|_P-?0CGST5D|t(~1x~+xf1Cd0 zEZ|eA-(NV&p{mRRIejy(guI-*JNa4UEsD=2FClmB;coIKrpMW@7mo4_eP9hoGwlDj zsn1n*z9FxpovoRk@J`mw9v@mzKt5Qw$(PcfO#KH+e>?fukF0@RXy+f~zkFT6aQ*rX z@;LMBj*nj&p5wXlP0-Hw)Yq~7xccfM8AtldY2W2{C&R@K!?*DNKEhEB&#blJ3i6|9 zCq_Fw+^6dR$7cTeF+|J46lzN&-$KbrcA6Yah<597`uZ=fC5 zo-3W6d{64{C66ne zP@gEZ@yf7f-1p?UD&8(~Kr!w1B&&1j+(|g{d*9IH^bDfDiF%iw6UeKSopRc_`v_}i z0P}Sf_2tUWBI>6eZH4EDY`UJIK1RK(mv^b3eS+1ydf7mI^-vqWkNxLG2H5=O(oQ~k zfpFyai<6V>6jNV8J5lOSBX41QmT9MPvuLOB^kh5tP#>qAe$+oh-lXijOFNIAooweP z>OEyAS2_;Tf94dcm&1y2dy{uK$MQn*=I@k^|>mY4^Uq} z-P(8kse$}ho?xBLc)uav;YzDdkZ&g)6Y0O3+#SacC;wdW8RREjW$n0j`y}~vavpxX z&&bDCChL340TJ=PppODAMAAi_#H~t(i9O;anV1=$7PNjY#Z{#`N2J>#DzM19Y z+TkOPA8+l*ux#8b~*pt-}Y0+`@<_X!h7lWBl*_3c7Pev#d_rIWAppd zTUK97-j_TFH?oRbkZtvclh@=}J|%4V8RQ3qEq~8q?_%;L8?60%$ZsO={F&wBY%uRZ z^3k7K{*?XaEhWGEAIbb3$3L>%y|d_F!cF_(M5Yhp-D+Q(-#0(D`oG(MUSHwR=Th(H z=Yz;w&aehte>s76&iuj}I6Tw(ms4L({SJ)x8tVV@wbh@(cx$Pzn_z{#sDGLIF5g(; z6!KNnH&O4>`2+PcslT84T+y|+L=yXNPZLfjx2xNw}f(NNLZokceAMf&p)l5 zS=3)gem(2g&2#RfomiQ*J278 zb!W?G(ar?&5xZFK>|aan?Uro+KJudqEzhH!M)DsIvD}US{}Yb%C#G7V>>8JMfaT3& zlKDR5C7h?ZdK^g}r(T+Yac7Ww;P%!YU6vom>}YX5jyBJAIKytTiG@t#P1Zo&drFXxk2aDFb+ z3FEG#ovp@LJKIMre}MYxQoG;R{_`5h6KrVZHkkK5?Hn}Kf+xtop+1(d2DYW0@PRh{ z>&~^p!>I2k9Q9ts@^|CjA=IzsLc5!HMc~tSUgrnZ? zzR9NlV2%SdS`w!`nKPaJ3UuAO%|*v9+d16IEs z$Bj|KQC}YQY`)&v)GvM5>aU@`n)(K&Q-&$yo~3@+V@wbA>#46$`c5(-L^+&ZZ}qh- zhuwrDJv0h0rgc0tJ~WC^S-D4%w<;Z#)14pZ2B8cwL)iqe{zrMbjQ;Y;V6gC8m%23hP`v0 zeuA~*%Hdk_7f`s&lIa0lu?q`qv0)n8Bj57Z~9-=6v$nJ^=r z-T!X&wf3JE6K?A3C@btw{Sk(D_Nv1c$S`8ucXJ?E2e zL%tjNQRW5d@+>axj}~s~>uf7@?eHAKJ9|-;&fBR^Fg-ilVBV9$5pQLl4dCMag#422 zlX<7XR{y->2a$iN_}S#8J*}N-jCYQ3q(8=baqZ+T>eo~6()kp5VJ~ZEB<;LKJ1s|B z;OwlWelGQWsrQE1^uI#fI-ck07@WmrSFkJHpkiQVr* z``1uErJvP*N&Y1Hw4E(?^MOY4MdYti|2ggFvL4+yu!+2a>34Rz54HI%+uho430Xsj z3r9K=Y(IO^{y6dmmZux{E+lvNvpM@W3pefd;IOga+Ru~ZSCBWdeBP&>IPLdiyg1&& z&H;yplk8wV0sgS!2a|uN_;~Wq4@1(*mqd2a*@);x?`P%yIWcw$PzjBA=SFn68B#%wCd=%q(Ot@)pXIY_} zKfgx(>~pRDXZz0!$;1HqDD^UZGA>^@(sR*tE4-NXbv*UWoVPgrRO)}6Vf6{xxr_Yx z3oMsiAMy<8m`Kk@Gp!w0ZU+cQ`Wue0LT6_b^<6JY)?Yz= z1@$id_fY?#(yyjIuJk`qf7->#_V+Ee>4_hioSvhEBmIwDnyjBq{x112mh=6z;}+)o zvm9P@_T@jE%kPJ@^G{9~UHNP!6KRx>yRpLMcNgJE&y};2(=&nk2FV|s(_cz`*UOXj z&yg3C^Hl)em*mIHvHHQ*oR=%*i1buXwZM%hy9q~n7GGiYpHP1a_081pOMU_M*Ia4! z_2dsb{W%sm{c`GuTxInUmh-=3M|u(brkMn;(8beUy4P{`^Ayp*L9lTh^SnpB(s1d7fo~(;p)o>CdUM`seIF z?<(pOO23HuS8ujLH$J~geFNLu&W!gn@(QVEIM)vUOFKhvvvyoN+)Mg7(pf<}u3wK3 zj&zQ=Jz0Ml_2nENdfRBc+o@l6r`2E1a&9C){BFx%qJAUoG*7X>rE{C3S#IQeQ$IjB z($n!CYv*C|anwi8vB0&f3#s3R6XFE*4^VGjN+WC!avVot|2*pPyeQmv)Hg`^!MWpa z)-g7n_9GFS?eq~2JLlBeboRBuyrJa(e8}?qr0c^?Gj?Pi$ntXS0t6xEVDfJZ`KV5mAXLx6?f$4DRyq3IL@mks`VZOGf{g=sOH3rBiR zY_jS3jO}WJv%~bbcq7MJ{Xwg&p3_h-CLH;VQt#T;5!7#5ZS~Tvj4L<#&R&H||8=yJ ztJ41<^$Deai9D|OhqM!8`MdMVe^DP*`t0LuJMlvyg~61fQR!&Eyq>tuRXcqqMW{wwZ=(+rfIQA|IA#xhy*vmm%wA z$nRr2S#G`|AU?YaM>^xQ@6tJx`XPH;{pyglGnx8o>UXu+yOO+0)^Fgpv;RD->mlB* zcu|J99c(dqFH+yY363kz52^2VjMejUm-jRE)zn9gHTjDD~A!UrPPGcp-^6r@xT;1obZcH&g%JIIB0` zMVD|-P#>e-)z=E@XPj>JElkfk>YEQR(YB_)W2sI5-4m13v$Jrt!v>{~Q(rMDSwEh7 zT$g}z>A#rzV<%hvU#+*dfco6SEO7n(3F^0>V)f>G-6DC9diNrweA@Y%Jj!$Pxkvz2})9Q8QwJR7h1wzv2dQ(r~BE9cY5qX$_76IjmYkvAV`dEEZ< z=8%^&J$dAJ2}it#Uu@(37x{8$r_h33$UmVz>k_N~m^^%v&6mgW--*1ZaM=HxdS}1L z>6QIcsjtBcaKt(LbEt3F-x_xI@1p*)3akIfdV4QZA6MyFP5rFdR`1%w&(xQw_OR{A zHvNCO-0FGzjyHgO_FT)|JbWRrBGlH(in zE2&>X{RrBre8t+?miz?rJIP%+oJL+pK8X6MDiI`8tT8ni=o7E z+1hKQzL^!+pZd?K-}JiG&!qj0)HhJyo%(H9&eK*{z4?Bp`1K(_W|igUJDtK07LIh5 zsB#-g9wXm@_Rk=XUPxfgc^Afc;z^|#Q@ z+eV-1#a%@)-Vdo?@=psUQU5*pj_WNq-^3KZUyYs3ZxHNAeU3CpltVeoa~txV$xFz4 zkjKd@$s^<^2}gU|zMGu@^0KRUHu)XhEqC`JUrIY3?YMGSKps{63G$YKHbU3VSJ3`r zc=4CG)2+9+ih4W`4VPp8c|TCU&0bbNojfr&Gl8zY4j``}A4~lx z$2q{PA|FrQ%man9U+y^LUCRtyOx{2qrJZZZFJ!ztUGNqPM>~IJv~54;`+ySWX=k79 z#~o+?PW{AEt3QzTzo9;t9m~~k_%v((ZtC6p%6bS#KaEk}jdu2?e*KBo{;nC;<4Eeu znI1QeO{D(%gw;Ps{amNt&W7(z`*%}6124oAS5N)()R!pz2juQWK0DFQ_vB5~vsk?@ z(qWOW=IK@#r@j|?)U{{w0ZxBDLCF3em1jS>vTRv?%JiZzmz=c0RO*C-e2)Xa<_iryx$@p-~j)xB#$Zn z5&1yHo5>3m|B8H&;_JxcivK`fr1(a|vlR8b|B>6)zu7x;0)A(CZhUb*oyqrffd6w1 z*R?C}{UX=pmQP-+?DQosQ@nt@R`ERz&vKX1T73sn-`q;{2|4UC2vr?l>8rxpK5rvm(6j_c~79e#R2|5i(Ko=$$Kd~GsyXvPOG(9ccOuOy$L`1R!OJ|q{xeDYeQzr*ls`^{u0mjBh%FH`yl$UjzmG5HUQKSADw#}5}p zJ$Y2|7s&Tfe7WJ-Ua7MGI`!`QpR?aYz0U9Z)VurRoqjdBdtS)#&&jJ)de)NjHb5u$ z{z>lMPvJZ^kiV?#{D&OxjZShCv6tnoRlK9&ZI5eRsNbOUTa#ymldO9^$nzENNxr}0 z{m4ftzN_Kc-YQiudr?1G>Gz{v*ZaZbx*i9U>+&B?-mLO_l;K$(FORoo`Z&Y8deK&5 zf1GG|#9cOQ^&Mw;ZkrjwMCwagmG;NklE)zzC`hz$?Fy0gM6vt1IZf{KbU;E;zP(A6(2#qLh%yvCdJ2) zuT=b0!*jiu;uFc^iccmlQT%-JgyI*Gmn%M-yh8Cx@+!q|Ag@;ZR`NQwdyoS6< z@kb1gc&ikDf_$~&&luj-eCNpT)j%HeL;3xx;aT3dYCM07yhZW%$bVFPH90T0w#M=W z`L9a6A>AR7?p!kmDyq%%d zPG9n8lzvz8Hx-YOzoYm89-(mytiA`0M1)D*ku!=M-N>{(|D4lE0+*SLD2W(OQq+k@K=Z zE8jr=jO*FNkmdcL^qmaP_INu|tKPm>CChxLq7}-I9<;M{2S1hT z;%AdjQ~W&gO2scUJmNLC=E(l2Fubc*sQ6XXuTlJZ>f?&vLj79B7m}}2{66v)#UD1j ztGk`H)%S7gH?$J_qn>=D;xE!piQ<2wev{&FlFO22l3Pihsrbj_dL7_%@*JiA#_+CQ zX_9r%Yavf4{%>;g&*%3)@^T-;&kko|+tr(ie?FH(Ug2Z-xh;96;yaL6Dc;BMi07^| zIqw4UJeA+Q4A1iJQSESl>hqQU5bB>$`Xcf-6+hB&`Ie*N$5KDIlS`rfeO`~mVe6n~Wb z6UCR1|ETzLOXpaiz~V3yLi7Ma8qp@tqmJ>q`Ey;@!!=QM@PlzZLIK-Z9&6-Sc)Q-%jy;$ongP zAo;$E$H|8%KAe1%;zyGw6hEGPs^VkGFID_>^6L~oi+rKt=aN67_)PL=6~B!9HN~$a zU#0kUIL%86@P{Nd3R$A zBUwQ{UDdd7V1@OU?7T zkat&n8}g{)+mr99xP1;J%NwNlF4T`yd{6R|72l71s^WvlXDB|D{A$IIAYY{TDDowW zmy$OqK92l7#m^xBPVp(^KPx_syknQ-^1qmT8^tdt$9ItY?rQSg6t5ybNb%dqk5~L| za(p+*@9rnRK=H-oa}|G*e4gUZl2C3G7WQTg4Pyg=nQk9OuLJH5#lD!w!MBZ}`q`}%xgAbGQj z_h8zoS9XSwzoPgE@^=+4Az!EX81j(1h2~Vl<@&XnCr>0VReUmeh2rOvS1W!Id86X9 z$y*e!G(5}etaYt>On5F89@_cn>8%S@FZk zXDB|B{07C3BVVNWN#u_yKA!wV#mmUwRD3G=M~crNclU|9TDXM#C#9cD-eqg2wEwRq z@2~hxbpQ-e{$Y(3Q6YW$gI|Ha+p!EAvU#s*7kvA(on0EfA>=aX9sOIO#Q2&_HpFn-K z(w{>8dZnL0{+{Az(@vSPa~}Bu#V;gpP`rY?Me(c1i*x*~&GW7&&r|#s@|lV+B(GNd zKJq5TA0{u@DmmWA$u}x}z2RBjFRFZAB;Q}%vimpkLll3Le3;@Z$+uDbWAg13|D1dW z#lIo%qj(GX&Wit=d=JI{M?OmN4&^8>=|`&EatzP%E>ik!smFJ2{cZ>HRf_kaovF%B z0r@n=_oAJGh~K*B?N45+_#x!YiWiaBDt;t+Ue{#%#~PmH-Kf%YBKaeV+wVJOdkJM{ z675$iehztq;?v1DDn5%mo|~M`IplhrzlOYA>2D-op!fpvRf^w39#iB01LS$CzdTBw zP<#ow9zUNWZ&CV}$y=YRVzyr+uTtf2zr&I3wJ81p^@ZJ%%k2~LnTmf&-lX_Cr|0t# z&f34ovlagjd9&gf=OSdb`3|JBVF-DG&x1I>uH*|8?@r#Ncu#WAJrG7i{SD9ZUQ^|> zJNY+???e8r;s=udQ}Hxfr>Xx`@fXN{ zR{Rz6?Nqy6LB5yb?~)&>_(z6IJ6G-SGwLTP{aWgam3}?-bCv!l@_QBkh5T{FGtWau z$nsuRybJkzif=>yt>W90cT)W>O5RKHT@26m%2dAgB(GF_Kk_=o2hsi@Wq&C7F^V5S zeumC%#KWn($->&#e)PJRTBY9XYjJ{32gW~U#@22=a z$PZF{4f)ZEe@lLf;y;j2Rs3i2D-`$6xBcrD#k0t36pxTUsrYu}Zz!H`xGWYa-p}wz z>vy1B``nFo_SxPM`+sk8e2>@f3TZ#4_+iv%C_BT*dnkSs`4`I0XxcAT{AB7!C_AT- zpP~4fi(H4Xs1EhnMeMK;y083SMfUx&-SWSyo;zm zUOkXjOTMS#kCEfM!G8A?`5}rwZ@Bb374LF#Po?t>+L@^AyhD9~(tk*f?=bsaGkJyL zUz67={!j82#eXD^tMqIluTnfb4XMcXnicPCc$RmW;#*T6b1!~iCi19XsPw(5FID=T z$rmWT2YG|y1Ib$yKbX8A-(Q-ZH^lHP?-7-r5!5G?zJ$C=@iFA96hD=`h0njc*e8-V z^LcZ}Cp$at!E1V)PoAgjTtq%o@!8~cidT{+RJ=EkS1W!id4WpLUCxf;HRL5xmm~ZC z5%Ma+SUJ& zzogpF_v9-S-$?$o;=huIl>Ls=k&!H~r{Y_YAEbCU!{vHYzvOb;k-Sv#zT_2(?@C^) zc#OPB@dL;=Dt;(=w10AX4mUi@ds3CdNb+YCKaO^am7SBwD-<73Uaxo=d9&hE$#Zu~ zPUj56v%Jx&oG+n1q4aa9KS$}WCBItnn+)&jEl7^myPdpR@oK~6c&Flh@c(gk9&l0= z>E9m}1y4l<5zHWPlTr{Z~2qZ=w8~j{M!^>uljq;6d^# zhyROwvcsPtzsTV)k$>m#H_0`!p`>g2aMd>!)0R(}2c$tOE}Q>)+ML&>jn__pLr9Udniu(dzk9SrXoS?tvND9YdH z$WI{u&f$9*zINnBzxv3&)c=N~|6uaZ99~cT1Gn)jnn}K&!`sQ{I(#1ajSk1THqsAq z_yQx}GxED*&zaOSU|YXE=acLA5552XPTuD5Ysjy3_|1m*jP!M$`?piRYCErXIX8v; zJ4esM)HB@C^CbDM4u76{^t*`Of3H%0Uq}8O@^*)RL_PaCdj3OxjKja9p3@yYKT}@6 zi|GCLhvB`8-=(l&tIpA1JtG%6de$_&cVw6|Ug%5tTOIig$)9xiAj8E^9D9aQ{{I~L z?G0Z$a+@`fe^b;G8SW3*+3?;G`@K&aI)-}gvw(khCx67@Q^=P(e1Gy69e$|cJtLnu z_Rk>y(c!Iz%lw#Qe<%5&4nKnYN{1g${-VQAwfeXB8+x|kJtMz4_FP2yLml}mDF3G; ze?55*ryu)I^4<==i@dMHA0S`d;g6BK{pzR5H*w@&B;VZOZ;)^4@b}2Kb@->`QHOs; zo^tpPj}G8ZPavlkP*5-^7uBg7T55KjG&nU+u`hLO#;rZyVk_l5n0EAChMr{slQd zD_ugWMn1{mdsF|1j{g0~ ze|LD+@LrJ@9s3)|BQbvlTF9#$-a-8jI{FVMf7#*3k+0*-W1K=Bb@)Q^z7D^Te0_&s zPQHP|uOr{s;r}4t%;9&EZ|?BLqk?6+~+nI+^W zJN$9-`yBo(`4}Bf8-B4{A0sqT;rs>jQl=_FDL)b;lGftlaBcQ z{b_j5$jeT;s~w?YJtJ>8d@aMp4;?-0kvBSgBl2Du)mQqrIrV=%u*CG&R^+_~`FR!j zdjtJEO+M6---UcvhmR%y#L+W}{0oQgV|cH~ZBD)pAb->0HRLBd`E8{B0~~wul(*j> zvALT~`9mD}BPpM8^q)X}o5N2d|G?qrkPoP~DVF}O5?Qx&!Cx1P{5oYc61g>mKO%fx zIq`QO<9x@zs~r`rXK9F@w?g>QD}wdhcYQE#50U>oME^G-{KpW!@{z&mt`oxhhwytztLv^4kcfceDh}kMw1UF&ylY|o*{1|Ka9MV z{B3eOEnXns`8fz~L;2Im8_72!zk>Yq=K=EM{}dk7ES1>M}9r|pX62Kcad-ZHh{ffULrr9+_p>0$!{X>i)fJzq@c7Ndyw4TUptUb zeFuV8&%xvmkPo7sqsafy;a8Eb{eKYbN%@D#*C)5-`9Ar+??UiZ%C8~?qIPcm9>4}G z;qOM|qu2l-_37s=NmZz6w}d`I$=$On7@uo?Lc1(M7|;Ut>jyO18^z%W8_be|3dy6`I2t|Y`*?OzTJ1=_WZnG$&<^$?RrA5 z6Hz|1z6ak3eug3KkM*=$Uk%VY2+*YhWzf!a=V9oI=Q`H-XWjm@Rd$M zx~DmOOY-X+z6bfk4lj_uMZO8`IiLI|@_FP>kdI#p4a2SE-&=Wy4?GoiUbiyj*)5Cg zN#3yv_#M=91o;*`DDxKbo5^1#-^1aDlA-C;MEqRZg&@+_s1@f)PN0FaE zei->Pi?PiZt^7g>ZhaJ zmXTZk-;8|Z8c6p5%BRUMA-|b+P9Pt%7QhSS2axw&8(?qhX(q2Hx6kXN$gd!uO8JH4 zKakt!)b-?N@&MCClz)i4dR?S@9PN35{DD3ISCW57e&Bilww?Te{A_YtU#p&ha(myA z?@!*ZAN1@`d$uEQCAa;zvE`(sD4&b(ZXd&;hBe;F;oJ>B*;eRLJh5QKGc`Ny1a_bL|leg{+{RLY- zC{~)j51$vGl?;{;E9bbGxZtHOv`3@r>Z|gBl{tLOSuf56N9tru= z@F&ttp4%0`*2^*E1#-JD<^u99#zMZGdTt}XXdJ*G@`uUq9}i&5|84Tu9sUjZ59GG| zS2`Qzke>iOw*1#8e~#Ri^H$`alH2m!nLIZUdgw-xeaN5L9sF?oiL{W9-2;HlN8||d zkGK$P^K~KlpAKI{zVY7BWApV8`9f$g`QHzL{^KY=m;A^Y@ZsdAkuR$A+jBGdy7hkk82NB=YvckNj5h+a38w$RBa!Um}0ik^hAJV@LjH@}J3VySLW)D4(5MVP`$<8A|?a9()`8 ziHsuusSUvT)gk14XMsyM)%=@9emS}A&!0%Xb35cWr2JLn)5!;uFCm{#-k1Cp@-xV7 zyYUhE>*Q-u{zvkU9X-7+Kso$GKAQ3yl2;dC=X&JZlJDX0QRFq`wqLgw`CH_6oYF`h z>45&3)PDl`O!9W}i^<<5?@zvnd*U9iC&@o1e~uqG zw9lR84P@;dV2}r)I#XFDT04bkiSp<8TrTLPn-?; zD)K+be{}d}SHb?F=lJDElTUMaBl(HsW2ygQ@@E|WEcx2!u4E*wJs*>gAdg!+$@e-B z^432GTn#%5pwlOft~L-@^SJ$H$sn+}o%{>R|A+kI2cgHdGry8=vjqHT%Kz;;Fd7OOIL(pUSIP$-f+kX3j$+UzCQT|?vj zpGnSXg~-d~=RFDe-S8*!zVIM>zNP$oPeJfe>i;kK6-&Wu$^Q(|v)T=)ua%yLd>!Ri z7ao-E+LW)S{5h*4!XF|WB)`&+!F;n2{X?k#pI^bAMYLx}^8LOB-<*6Z`F!$Q$Q#Iq zeFOP@$mf$EPHykt3xo&Re`5%LAcQ{?!ru?!zlZRCHwN3YZ3rJ7!Vd}I^Mq?ZYW8xJ zPe1&LG~6GY?ztg)E~TEt#<&q1SkC_>zl7Y@Tb&(9-YLOzA|UroMt%rAdC`C^AZOrDGTo-*Dt3QXuNL z$MHe8xvdxSYsqc74JY3#g>*zF8Xbqp5!mc`dn>Ur4@A2J$;oei3<& z+{!N@?^_LdJ8pf6ypdck&A%_LJQr-O{XPGIa!8U}`Ax|`AfHY>Y4Y@r{(Ma&pHFVr z(WaAMx)bDwQco@UBjmO}(@y@nBY!mc@8nad=N$6AcJ|wI1^GGT_W64+`K`M^zF%)B zde6%54PHzA%gI-ee~aKq?|-7)KAsA2C*_Bbr}qVaoqTWdEpp(Gua1BM`Lb5UmfKkJ3(f|AiuNBwe(*WqqsZII-#Qok5%N>XFFwyNe--)L4!@gxqx1dp&yXKP zKA!qNCBMeue~>S8_<&nc4$%vse>dt$k{|ByspLaT3+wttGx1$`c`W$+Gqdn`BU-}>L>FXfjq2%BH z3U13GO@7XQ!R@$pKk|Q*uT1@O$nTPO-t^!3P#?L1eBw&rww-^9{Bm+zo?nrVUK#S1 zuX_jb^#ys9`nM(DU=_&sAs`jkc~)=d~{FnO(=f?`Jv=?-e3{=4!t11Iptp_ zKZx9pBmN-2)sf#?8dzi#$(Bsk@ungL&^W^$j>G3x4J*S3(2=6xB71hP1vzac+>Apw4l-&B~ALO4peBeFE*UEjMKSezW@(j7v zvm5y|hu4s|JN#7gvmAaW`9H|FXS#2aze8^G`wMx$zOXYx`3>)d{Wa@>vssGlLOzS! z-WRpx$CK|)Jr|JwoBUz&hsn?A2mRZTe?q>P-1^TN_rabo$oHZA2=X1*hn`;KHRPko z-z7hSd|-dbuS$L~`B3sY`pLuOmkfaX$CUq^{HzVYt)1)N4?ABVU!U@0$$uud<+C^W zt{Xy+eZFVO&m_0{o5>#}muVvNZ!UT5M$lvXCnu8ML~iw*P5uV?Nb0$ay#L0~WBE8}~w*=pm{yCcbq+#G6@p*ax`F_K}IXw|+B|owXd?4jdAipdIek%FJ}Z zA3hR1!}2+b{LWF}gDHOo`Rn9+Q~q-DEk{G%J_qk6zmNPP>RC!Yc?{(DC;y22Ch}Xz zeNxO$lpjPs)ZrQOvE=rCpFn;(`3UMcfc#nVZOLbo|4eS5<7blh z8xMP4p!^l&pO6nAzk~e0iM0#g}j=2`agv7xt@H%Y6ysv zkJte(xoJh}@Rv)8wy{$EfEW@?QHw|LXk^u!4N>On<(HJc9B$pZqH7 z8AG0GhWr<7uMQ^PG!Jh3C-cZJodYhnq4{?m`SiKq$CJN7{uTLPwhuiYg*}7jL;gO> zk0k$+d=B|M@{YqH-Q3^=vEV1s&acQXBDeV(`Y)Elagew6?@b;jXZ1#oAYXVq3ZONO-55F7S`t!NuHZc5Y8T^+CV< zRPyzg`1#@FZ<5>ff@{c+e+cqpsecLiQgYj_zDfQL`AL-jihS9_&|{yED?bbS$3FtT zF6B2M-;dntPm*u(DC8}lLS9YY$?|L_zvT(Y%kb9xn@7IJQt;8_=aKh%8hkhM+sHS4 z27D{>XUWHtpHBWM`77jO$X9(1`R)HK^qfb&9{D2jL+C$SlCS(MJ zIUM{B>={UVHYGoj+}7{*m^1~?q z5AyZigZ>dr_X+ZS-Uqkk^8tB|+}acQH}s$4@Xg5oNpAbSJCSel0raoKbf=JS_n|-C z!^lUF+xh1c$wz$z`PHfCV)ETS2H%c4~hdGbXppXaQeWq$qdlOOw~U;hg7>&UJC)n7!py-xlJ^>0po!B^D7 z`c058{@Sm90{MI7R{ufdYkvcItA8%}3*^>+&LDsDTfhEm$^T1k^*=zq-FJTdZ;*dY zZuNgf{?l^5{#9N=Ic)enxYfTQ`R?S`vV0Qc-;%G&@)=LQ;s?K;gUE-j0JrT}JNX#$ z!PI{;`3y(?a`KZL`Mbz(a^#;QU+TzzLjEQBMNIck^5cJmovq~kUPk#WC;yOqTk@BG zg8XRmQRMx81{e1;{|+Jlgxt!{Bj55D$iGhcv&jEPemVI~G2~lP{uA<<C=NR&19DXhNMUI}Q$nPdkQvWjYW#sFVuk|MK z8`;=z|6uaX$oHXqHF-O^^}}i8@00&Y`MKopZQ|E|7Wx0kt^VuDCvWPPe~>&+ZslJl zf6S3zPW~aeE&p}iLVj1>%&&hd@*(6_epm7dj{J1;8RXUA z(*(FJx3%6wIh;)1i}@N#zAy#({!DiV@*BvvC7(wA3i$=(t>jH<=&|!T3(4;!xAxyb z{t@|A)bkSg@fql`^52o)K^~|4-`+>QJ|*9rp800Kl#DoZ;`LMBkZ?!en;Nl;cI>XJzF_^82OG4A4R^0 z!w(?OI{XCkSq}dv`SA{ao&0=<|4Dv>!v}o``|o%7ZsgB8yn*~(haX4&t;4S%Uuh?Q zc|J(q*WquH4|Vto^0dP@_z3n-boegh2Ri&<@)n05L4LHuFC;(P;dhW<A=~|CanUhi~*L?D^c`6Ul#dcnA3!yYz_YKidvm zMZSr{A0Xe};UAKZBHzMji$uO9pFzGRd5_OvXMubW`B3un$j6bV$loR(O+JNulM%3g z2>CqnQRD}aUqpTxxpa5UzkA3#M?%jLuBsFW(P(?EKr^ zXMEdlzh?OUQj(#zLp^VjFDJKpR*e4yU6!H7V?9s|0(k5ao~3T4W62};`*{ob zmEezEe?xvA`TxjQU5@;o zJrwfikPjpuyal*zAI6jao1DjUN7~5W-4gP4{qzj-&xV0lF~2vGufMgQKT1As8}JUw zFC$;PE%?3UJ->(jvxb9jLHqlWUr4?t`PSsuI6OnXV0-9^4Ml`K$p;(=zCF{eB_Dqf zxb2^}SpDQDGTo!ehaC+09Qj$~XON#n{a2Cq%|d=}%HKj>Pj1iMT}nQ&7V_Is{v-0? z_29Pu`5XC#4d8cBe&Zido)c$)?@pc~KhNQl$=@e`pZ$bp@`nzC9@}3!j=aZA@V`_4 zb>vq%d@1=(&5*yC^52uc=J1W>M%I2*YYXJ<{M#7v9<6@fOnwQu?O)9!zt7<(kiSm8 z8|}G(d|)2>H)A_+1Nn&A;FDOtcaWbp2fR1+JVAajxjcrefh$d?@f z{y61-Aiw2E@EghhN51b-;Lnn;_9Mz|(9z)5&-;>3J_bBZ`?n-ta4fj(&nL;BB!7YW zcOyUlILJ>X-=F+ba_JtJe~siX9S`|IAl);1AmBIhS5E_fz7P0XzXbOy))lVp$yJv_ z-tN2Jmb~gpaO*$2lJ8Fb72CrD$kW$A{z%$6m;5erJKu7?)qgGIAEf*p-k)J-3sO zAm8RD@Vm(OAb+3y1M&mOAHEs#w%uzapZ*W{3!B2 z$rq6yxdig|{`wdBx#Z21f1UhK^25oOk`;fPgZ%+9-^0UY%k{8JLdm4JyB|m|@$>A4}&nM^Y z7+FMqI{9?!(eEdzzkN&|BY%m!-!n*eKk|>rTgZ6~T;vv+pbNS$zNh^5&q2@W)U)dE zNcREq6nTI0<>cJn7ulNp;}@ale#*y%2c;72#<&Gk;2sv*Zas{4!euw=m|9=kOfcyt?+dtWseErX% z-;SF`kdOQV{Bx$e7x|X|0Y3zPB3beizX6!F8Y0Xi|7iud_5ah!hx`a`+ttg-_a?XH zc^ml;?F8F~iN&bP=DhTNw6 zF!|Mv{43=5JN#4f7s=P4J*!FwK>hF?a{Juhn0z^TE9KMV**{?C5#&>>9`Y=CGx-jG zLjGv-NPA6ZeN%pTU8JQZ+ny_QHg{wj+Vd^hTzh+KUSUmPUTa;pHQ&+H&{S8`(Ufn^ zw&k0fvsw93XqwSl)2veUx!Fy1Ir&qlYj0}n$hT*k3fb8;%}wAu2@rRQ%ANS7Sz|Y*B6zx zG}X1|3;Bi)6*sk-trbPNb}6fdY_`6pqb6I(ceYD4N!88Bb!6*0+Y9;jZi_ePT4!`L zs(5{_E?+N-jSu84VqIkJEzsqMS?}Kj`k)g$x=RB^G$_ZS>%EwqS_m4 z3XNGQkotB}kd-2DZqC=iVe8~~ZB5kF&q?X2FP85sA>Qjy#YtPr^3I(|{(9&jWaErI++VhP=@o}sj3Ptr)av`)UYiPY5Sx})7Cgu662jbss+J_AyP-6p1)lZcxdh-jh6u>OME+XNO3_c*&z(9}9pyk0%C zEP64>8=1QGA@A+}1s6y(SrrWqiB+fLVIirc_m;#R)KH_HP$u5gDvu6pa9~Bos;kjK z@|0CEvM;mN1Kk^yC2O-@F|~MAs$yydElF3Cry>H{kz!?7`^shhy4Jszr66CXq|*PFX0}~M3fgk8ClO5r`$0M; zZFykjrejr^Zfe(la)=IOuVk7!z--gI4vCS-Bu$6DJXee+88)qr6qycedb(X$;d#<%3IAV1| zI(izB{diMXGLq9zbM|)tY#$yTeYD_fSUn>q73b-S5 zyd0QlES1sDw;9(+HE2Nw3nr_i!LtLPTt|)Z9~n;+bi|;s+%V%x7@!5FoQ%e*7^yg5 ztkL0}7H^0Rv6y!F)mVR&(85W^l;M_%7KZ>L!8#!kCpDMWOb(K1%COgDdga~NL5wEBfjCW zw769m90z)IIwOWRwbnIv%0NU$G&0K(+!DsqiFi^9(hMy91_hdusESr;2E6hif>rUN zU`<_JXA7p1+B-24EjA1A$`BoisI9WL_M8q(Y@M4iaDC2nl`NBc-^_+Mm~$kSax%dv zlP5r-Io~0jcbP@0(MdaPDjIV#6V+TZPllC&X2q&vG1CXCZJO07V~=jdkw(irGn(5P zqTP(aR2sVHBboPDa2o>Cz;VFx}UXt~Q-mOk8!RFyhgw zxNUIF9V4wrLsPp9vx;7!*}z1Ht+zt1Lq;@O?-Bg$$hGjA?&$LgjbH8%#%*1!qK=bz zQa}jPz3L zS}Z0#HZj0<{AJ2jC-LN&U18LDZUC-ap}9d(UePNT%5DbvArA{TE5 z42mnx#KfcWUQa@|v84Zkb(v~A z-C4ZJoQY&>qHpyI_dCGLiFVg{#!9#1kcd|%t>5hDdjCtgdEK|3TGXqu6+@5kB z%F2^B)WeH6sys+*W$-1lv7VI`w%^&=4LSg5FiUD)ro%1O?PaFlT`FkP1Qa@CnJ!Y8 z+0>?Ou{PMJ$L)2tjt%#GMC^I^jiQ5l;=_G+CZ3n?ZE zv&iV3j4IX*TYhtcnHh0u`inCw3{)@oMdm{y!eP8!>yQ;V?J(L^!9uQC*8B49!{eDu zEL9X{usmv1S`3j+sZ8b14jJ!DWNCy@)^jkm-=vcVvf8B!KeiM)+vGu`GbUJdm}j|Z z&i#uO9eHW)+azsSkZSG7Tgll?wKA7kyp%R$hEDlQ#*0fIvgBAV{-emuz&5pt6Uzj* z%olJ`!>naUpS7b&8Z1?jH5alx8Szn>4~Cc2XJx9WqfuJCrgr*`Ec}>GyHw$fY{#6Y z`nat6q-8<}O@ai=1V=$uWOUK1J(stN#*Chtoj6hA6mq&wluk2-O=5=lMyCw7W@P6y zwTeI{?onw{l&&{Ytd`(Zx=O|ZGEG}6z1*3)$Ptmp$8b>2JWEZ*ayw9j`FD=%9kTIjCjsnuWmJ%W}04+JjVOhrjbDN>jaSY6k zn>cB#-kiQgDw+2(Eha}6W@4T5>DmlRWti2kpy!{=1;#RgWhEgpdmb1kUX=`)eU4Wp zLS~<39xG%CMCP10X=K_PaS46&>RMTAZjNnMW@Ps$I+CYFPI<1ZPI(R85CUytJ;St)sJD_f;56YMaGh&G1B8H={rbUi*47T+=Dr zigMm3j9poDp0s*{1lkmj#jDNgnG>P2wPF<0hjXITOP8juQTpZitc);qLQS9X71Si8 zG6E}I#^NDUz7k@(#KApl_K#|1z!jcsG?57LLUE1?i>e;wl?o@Ckg-QduEHk6tD-V< z8WJb$mZ^%$3UEjqnZ*qWNqF7AUMi}%JXUcy6;@)=bRxv?XgU?LCJ;@B&F5E1*?D>c z?E6(REG6B_kenvX=%>t2+M3#Ox}xFhF34(SoteOrz6WQClF}>Y@-CMFdMW#WuFI3vTRhCp!YgzV9yB(O{cr;O5V)2jv zgVbQjJ4_KaEa<~Tc3pJlx;Ix;6;Fn^QB^EiEqwvex9?QlO%RxDw7N>9f@@N`7m*pe zYB!;^eqyozZdzkClHMmJD%+m|HN<6ntnO+b3wFi7Li?YT0iY*F=|LhR6W>$Ba~p8S zfPEs%#wJeRcU$NggprpnUI2sC%8?ZxJwSZW}ICl(vg)NRi15u7448kE$@JX4N3l2%iByLDZ*cxR#B~7eU3MUus%0+R;u8ZZJSSk?)5#r{_6xRD?7P^}zre&K^a3UG> z4{N)vs##@(#` z>qJqoWqR|ual7NRscMWxWKRiqBioI~nzX8vXSZ&-(5YU#Z9{Jdn#3&(6$H(FW5%#u z%VGsw_jI(@&C7Nz&mMmFBiJny;^;awz{U|Q+;&Q@z)!(&y*x9mifX&o8A)5wst z0*Y6VBN~A*VyptOX17|!?|B6<5*m<<-KJ(hn zre>M9@a{8L5q+4o*K(x;9XahLn*K*=vtO|B)iL;Kw>F-eZV9#ynsjB#MfMu$iwJf* zfzOBl8^l^WUs$$T+_hI^gLjn&2->pOQqo}5LBYKBP=n3yR-{xtD%kbYr<%hSf7Nv> zu6RaBi{wunli_|>ci5kuW4yt)3${2>DtYp3jsR(&ygH+_*5sgDznoi zV8&Cr=Y4L-s7j_3Lb_S9InB)dcpa{GURIZE>3G@)9%o)d@@yjxEU;LjDx@}E{rbxr2IV7y; z5Lj*34tQA)Q|u|*)Tz%s-MC%qhl*6d6Vmub`2*71M=7fEh-oi7$c}&%Y^GtN7M=+C zCm+oH&xu=Ym(0w*f#$`V(6#64Oo(fx<>n5qz+^IPk}@5WUS*(jrQYNL_gQXOg8K$?%P z@0`Cj&dSJs>A<>8W>RLjr#Hc0R9PL;7Nx3if9nYHuc_2+IDuAXbTk+oqJz(n5ENEO z|I(}=2S${)B|;_@WZSv%7gSZTdu?6aGc9Ag(*YWbw<;N#brS4EX8us{*E}Ll- zSVq#uvaeg|sUF3vO{F-d5Gxu`Rc)r6i(@Ji!+RGMWUr^ZvKo|gS@^^Y0W+rTI!5lG zeavIH!hCy7ro=-EQQof!8PCME$7PC_?;hJNvHA#*hY+Z_gV_(L@QQ~_Nn+EQjfb(d z|NaljY%Ge$p0*WC$t^8y8)VzD>{FN#Tx8P!m8mgfxo_C3uYUz(K{DtQGu^A)+&}|k zvf;rLlrKimE8uFimS~rPWr2P`EEuCesA9RjO+>vtVG?lV7hZM&sKcX9(TS* zks>HMu8!jLb@mFXu$=2vRgB?iGB5vB(queK1awKb)$AQI`7qnj#34QEu*<`|kn7n^ z5>&0S5kubWkf>$;#k-RCwmfBJlGU4ro)6KX33(yL9`=={km8NYqafH8>G1~IVtkao zj=W(+EC(nADvHXwM{tPj{tgYn3}CTxy*Gx(sf*za^7=Ae!BhrDMIp)RRFS8G+&jkJ z21Vsg;$~_`8@1cC%y~flvXHXOjeG z2m|y7nij1>8yh^YXp=4T=hBLCmo8?SQB$xQLm~B` zn_0SJvwJ56yI2}7RE}VnLcmS#TV7 zn`I(CxU^$cvXeBhS5N*i{4+KXW8ollmSgZ=~O;^mkH8QXs zy2_zEljQ&<>1=gb7DdT0pQ*;OyEb2TOdRmAHk}Gno+y=&+KItax=^NuvpF~0EW?x~ z%#v9b%J6EG>9AK+hCWvp%JhVm?pTKXBHdPob~-GZSX}EuS*grCjeeL$>4S&|b)m6T za9wMZSGT&Mu~d59(1;1finmB-YlRjfWVSIbuP_F8I6dB*)tk?4twLG|oGeq(PSs{^ zkZwFj^yTHyyW3N2@&W~SBz7sz>GI0GVi}bO&sE2xobLRK?h@vEI0U7vyn=QM>S|Q5 znrH&E4rOY*T?EsOvV{~_d(n6@crHRVCt=2+EP?ji41Glu$0&7K^rq7#6HLXjH~q~r zrCzHm&0I(&u~!_df={GU@7TLpqE>gAnliy)N{o`?H3oUb5Lp~n_O{oD2hWffZQ3;d zMx*J6;GhKVs0cj_Kvr8r94!_)FpI_U+`ui0l^&C>eIj`}6@e8k3o)kWQ;@wf9a?*T zF*X__WYxTwD$}Gm!L8dC=uWs9EG?tLXk%6R0*bmTxk4-PkvjvShe4Is2k(UGiRGxH4Jr3N}NQhbt9@x=n?M6^cUNJgpG3Le7)YxvUVgQa-ht6&$rt zIiD$W0H@4zxh;0qM68g{bhxuK) zd0{=QWX&DXQmCodyP__iYiNiW=N&Hl_GRJ0kZ6g7v@)_SIT?`ymD)PYxd$bAdzesJ zM)gK)Y6*UkPm-2}I6cs{s7RjI=0v*^2wvZg%cg64P>!3X@pxvnLfQ#gjYJWbxrA=i zGOuWx!-a!e0=!fk>QG&$pOXGkm+6ah23NJjwpCrhe5v)Y=*4?5$ic!=O~#~)=r!6L zN9DW?3?_$I%b8$$EUuQ39Oz&V;^H~2a*S1LevX_cS?NG4nN|slUn!ox02f$mvb`pF zb4FZ3LVP|M4SC5VE<1lhdg;k{*xE)i^a-Afi3P~584;DbE(R7~aUM5n^wf~tl@7)* z8qA_oQ4L;1#-2Ab5h5>`^7UCceOvnbt#T{MnJ}0VGiMAGax=_3?}25RPRbZX`Z5`b zU|te$4|_U^WJb<3=#;~mA?l5WBM)qVF6Pzd^ZKH${>&DnBd4b(hN@19L%NalKn2N< zIcq>}4(W7;jF8i5+4}9qHiZye!0D8png+{caM@Jf={dx~*lUYI&V-ed<7IVQ_LLPm zEGMQ1+nK47wxxKwgvYQ* zU3(oeL5N-r*`YE zSeb>@ezBPWGTv#<0twWcNrjE-GFm?&ab!aUj#ZF~lhO>5lG{gCf+1z6qEH2TE_L|C zsK(Pb$IQ$8*-5cIVsffN%xu0ZqNu#eGe>uZnjq~&7U~*=wayR_mrfW!iyoL@h$>VO zb9ja!a<^sW1Z?@85HsZ<26^zcwCSb1+^IcDJ-wvEbzeSVHGITTJr< zHMo6}um((AN2V2!Le?x+o0wg9KxE^!IX2OpSQZp9?9nd~L$>dVEiz3Jd}AbJ;&WDB zcOcX?=~z*Y1(KRFNcKI+>(cg0Dz|uz7hWYqUMtpPQ}pV*%BDvBZQ@FcB)?_vrvBf=m94M(+r*L}+T>i=P;Nl}VRiHR$dr25;$mHxT@HgRRDMSjbztp7K0<+jq_Ca$z7`rE{nc2s|x zxUzI7zr~UD|0b?%64c))9}`!qQHhBwEu#K5ait?8zhxJ#{@=tEAJX3@t}H+6ZxdG* zYW25?D^m{g8%^H_1`m~8rMQAlIB67K8ikuiQ`7>Ta8m8>s}{Ja?y59b&;n1DBQ^kG zAe>bW`8N>mswXUKJUDC=9vg+rM&YedxN8*t8im8k$%7^y+*DubRV{E-T@5r>umye_ zh2zRcBoKzI$eULpDeL+8W3CD}~EP4y%_)dDw-*}EO-!9V34ABZ45IG7x( zV<7x21_zUAeL&Sy|g0sts)3|~bIJ-_LstBAt24~lyoPo$Y{4)lpjloUz zqzn~-o9dg?<_fmJTjdl3Kxlz~>P~zk30vT%G5Du`7e>S2pE3BSz7b;}w7@@OXiIgF zXu@C%{4)mslp_XA82nRCNitVx3v_Wv$BRPc%S4K-5ZL92#280&)r)>B(5dNusB-H}{ zl*LwDK@0p-UjQ{C&;tLI&EW>3ZIv^ca0OfNV3!$nKvPGu10GkD$ixxe`Rh7YoWd;IQ zPzD#)PMi@z#^AznxNsa^C$ncp1Z}I#hvN#iplyxAcjNHgIQjr_+yQai0daV894@T; z#Wh*DunZV+1zX_4ak#K9y%|XqGF(_j$OgiNbwH#dXeZ>D4_qNfaA7$v5D;46!g08; zj6qBoTv!GcxPlfmv3gL3rT`a?qluLsyh1s|8h?xy=@#S4Xi30@6KG-+aNz`8Sa)!1 zbhxk{%Vn;h1umR`3(L8U2s1g-FZCEnlcNNhSREoOgbOF&!g@xEfv^QGtc#omLJM42 z4;)em7f!&16L8@Kngs3B8xhz77uG!k2ErEhRM}N!U)6R~kui2x*;8e=l|5E=S<&|B ziC(H2J&y!jI02_kpcU42QWZh-tJ^%x6>NdmCE$YzxUdd_R0J-plN9C(8G{Qa;E@S< zWC9O;{l0^dq-qov?v4Z;Isu1Hz<2enWsLxDO~70Adj<;O&^o|2BB&$yZUXnMelWv? zQ45kq_aFh^O~7{(@ZAJ_SN8#EJo+bEVV$`)5X#`fN%*dQWk$mE?FsY8*pfu|APL`1 z!grJK-6VWh&L1}s;Iv7&urBea7Wi%wzAN*gfW`=YVbO?~9LfB!xq@TLTqnYy8V)Vr zIe-XM!=YvF6OdXE0lq7T;FvJ@uFS0B3JIb4O~QAR@ZBVuUpWiMNWyoM@ZBVu-y~dE zSCiCuIBgOxoP_Tt;k)vxsS$w-%WJH-g7F-4!G)6?b#d4Q-%WDh1*c8Ig_H2zBz!js z-%X7`N$}ky+%$>iH;D!}2{+Zl+*J~8nuM1p;pKW7lnFxxz;|_fyMf3NJXsfL z6~dE~Xm^wF-6Wh=-n)bd>Im&_627amLmC~vD+eIs3UvhE)l;U72(-Yxbw=1gV~c#h zK(A8p-4uLR-pvFwbtEVE;L2!8!FN;eU0Dkim#RkH6Q}Eps+FhMF(+F@= zIsVFA!4-95l?gNDnSw*7;K?a?atbb-f(z?3xJH2Qrr@n9_@|!jZNgw696AM0PN7ZK zBVbhoPMd<$rr@+GIBg0}tH(X5B%C(IIRiLt3Qn7X)286GDL8EkcSj0$hpxt|7Wi%o zzMF#Yrr^8!l9mxc5x{p-Xkt_F-4uK`1>a4bb89;k#-0r+hUE(9~EOEv>ww4+t&rT|H3N zM28mmZW_KDV+6RcykBo5;lgRSu)JCi2$SHgY527sL!qkSv}t&`&L0~HTj2A$`^-RS zLGzo2x2ECHX*jKZmOv%p-f6gZ8V;tfESNCl2<|2ePzJ)2)9~apJUI@iH97)h0}21G+bD}aVR1gw7VJlF8n$J z7tX+iGjQPyTsVW~SC*L&-Q-A?xXcw?SYCt2m8of26sB2b3=Ap`f$z*{r$LEQzX zDZpuEwF+0r3L4xDoK|1#HI|_y(ERGsyonBz;JX?4ZU(-af$!>x=PC)`&A?kTaN!JE zVLjqdMc})#!i6go0sJ!q|IENYGw@G6M#02`@$m8tyj%}Q)G+vN2ELnt?`Gh;8Tf7n zzMFy9W#GaYPUXUd_0&F91{co2h4qj{17R*)I0J9Zz*{qLVf|EuO2T*b6gYE*vWC-U z;K|i+(`vYBHT<(0{;8*9NW5w~G+ekE{#lIj|CfLa8v!RrK*Or%VA)+GL<9iVz@GHqbExk zNkl+nTn!hlh6`6qyPF+9X|G*JP0H>yZrna&r)H;)+I7;{tgPP1f~A~uUDqhzZ?0*Q zFDK;dbp=`i%=ee|KxeacM?g(MzKAAA$Qd#7IS&2Wt}c$Y@sNSTk$jg(mNGmzH$Ha#IqN?HGBvf~A^A9`L> zuGtt;umLlM z7Rk{fzeveUwW9c5fGsPVn7*cLf9p41`TBrY45u>tvMF2i^_znzZG<~HGZLPRLCCx^ zVeK>`hDcTs&SRf_5~ZV{3pshAM!smFXFMV45-Am0i5cCkHLdwVb1r8*xfI58tu^cB zxa^`zT$R+}+P*bpG+sijH+ zrHqB@sE`w1ElD!YH`=^!Zj^`WE|cPko|+3MwpOayT7hrAA*YUv*@qAi*PQMkD)lWO z>l~gpf;5I+;^1z_%u+y^g{7cC<4VEyHYySGX&_0qz8Ouh{`8za82q(rwNs6-r=_;a zNjEMthu7Eu`ND#gwO_)b3SQb^)5eOl9*3tf}nX-Wbwm8b8+G3G9z*jZ>sw~z+U*+*7$}Le7r6u#CvO^!efhv#WP1e0? zJoVs>5n4KwSB+Go(L9uPd5GCVc91C}xA*ttxPYqQMrMwTM|gqiOAk$y+> zye!I5x@Y=nr7W$eBx0?qC_^hN%Fx0}GR#G|r9mMyFfa&q1qQ*Kpdee8l`Jilad*nl zBi)_i^on<*WWD0uC}fZLU(2aFSWtO+6vCgn5UNmN9#w_#y7NkfSEEO&f?t)S%>7fb z&ZUQKPa&>Ya@c3*xw9+XW@W+^J)~T^l7o~>SMrZCX=aj522UlG5lVfnmQ`3g%wWdS zy~pyEX7l9$9fo;g>QSV=7Mw9uB&QYCnNejZ&C)ds%mYv+9)N6@0CT3m zv#GnJ*tgfage4`v0R$ckEGd~_Ny!G1U?V)bd{%h4+!~G<0OcaQi8P;#q_2LkG)Y3t zC}qHJMv3byPQL0O@R|V;uNfpBGeAPjD9QQFC~=ACH-o@qh9xE2Eh$qY0k(WRp5dWB zGsyWOtn@C5pCgbmc0bgteG%17juUr1Ag~*5Rm*D!()#Fo-kuoc?^k*PO{Y@&VDiZT zrSj@+RJ(Xy3x&l3nCDZ`)@BpCWU;vnv=_p6r3XD9^y%-jpAqJ{7`ct#yATx8~VZNTIM_z3z3zL_a zBQ6N=oRRJ&623apL&ut>3(~ne2LOt1rR~%wpiK-{8poVeQ93NL6dv6eAHc&_d_MKb9M0sv}|!RZv{~3G~)nVwC2q86)x)YrT}muD?6r3 zRlF*xtk*T9VgjxDafoJik|15zo-de+k}oT_G}U=5(P%y>xhP{&9Ll_3jxwKd4XC?7 z87)rV!#GsRjtlivtgsZdoTUzpBZMoeBw(B*Uodakg(hSCrYj-URBuo2uc)ePDb*!w zSNXc84s+Ls=B-O1)g)g=(T_vPD~je6q_D!&Ty|4bwaPi=^690{@XAqrT?(lt&s20^ zMr9&1M8vs&y|F7gnx zJYGncO;4M+8u?^xP(f*$Vc|C2uy8G;7D+oST;m5dHX1L8t9*T4rikUShRNX|iz`bQ z9kx-CcR9U|P(kNkilJ#(-wCoXEX-$HP{h!7PGg3(Tw0oy!ek{?{Cc*0@t*E(X5xKG zaav8@VAanFmUk-3!Zl6bLn%-Kx4Wme8YsnEzALftbEUK-12tFp%wJ#}yumBlLJNZP zjZQ0C5-%&4Qcz(3u@oHKg)D`u2k1-oYIr%-pr*V(Ol>Kvfl^crE-!k2c;zzp%XU%N zC1Lr6E|Kl8NNM^$k!X5(nirgR78ELDgNB;UX4A6@mkQ9~Ek-Az4JwtTBM?}i0W#&K z8X#1;Xagd2QNB)$vO<8z&f4ahRBgZ-h5c7xr9L zX0cD!^*mMNeb5y7)D zibuvAgW?t7m*IT98HraX-|~}vGoF|v-ncchWvii{2H}-chm-NCXF*@c z6Cy@PLoKaAp{~8DO+V767Rn%725ZK5b-B}1>!nNiT&Zk$l%cy3D@Kr-uyO6Kq&dD_ zjN(omvt=LW>_V$-wrTBAE=KT0+H{&JvO|qeYi67rrn&R`oO^_zyM~iJaV;HXmg@R}Cm%UvfWtuXmd5 z50&Sv)4OxH*;*vVfwc21_mcqT=4_`;c-12gmoSh#i1_sBq33&CDB+Kf{ zikAhH;z%>fv6&Svk&={sX8Iq_rfuWbHA^9-SOL#!jpE>vy!2&ev`U*)YQ*JXqh@jT zmRG97irSW1f=YTy&z!8?yeE%P*(Sy%Z4IxT*CF2`l=GJOTv4TE#S}bvG96KUFqIZs zIrkkbU(go->SUbkixRwdt+-FcFYK-F;6(87_N0;JbGSS}s;VF@0UqhvXas4@$(M#_ zn^B?OYe5pS*dH2#dG_E~<-Qaw$49^04I_5CPmXZ0|Kpc-vFWSX9vDUa{Wrp(KAcUm z*y(Z<1@y)kMg6b50~Z`v?5+g{m%40dk?cLp=b&~ zH5P{k2Yx!pHozV^X`W`tmuF?hwwRjfmV52->*H?YAe&0cLWHyvp}W~RJMK+{JGlcw z^xmpqohhww^)$^>Q6Es9-~aG?v|*?=4HM zupn;bi*H{ArKJ&l0%afcv|d~mQ1bV(AWd3L)D+7C18TTTCh(>xlj4j@8OL{hg3^|^ z+W6X9StP&T`&}$hxa9xc5H397;tz1( z0PTTp93WT87emCus>^;7S6fT_Tc)mfReU*3gES8|pxDRN05#hNnAeUOyY!lqS?)0U zZ2_9Jiqq`otGrf4Y4#l->n&R23Gf-_;a(d(*k`VXdoA~1Zzeq0=BHRr>Q$y@_3i7T z`Q;xN=AL~yaalSY_MJQJCj0u5zOMxrJJdY!+biu|oCpfG4YLg^d8Q?{7QEN;DS(!| z-I=C`Lt_Tde4kk=)F-MXP|B2*w58w^HHY2%WCQL68zb-ruz~9JrtjhDi?Ylr-4NdB zVRwO7Ca6h9xC|EZE&lS5Bid2(lqi*<{c5#S%NE;@z)Q(mq?O|N;*mQGe!uy)Zt(eMrv?GpN065)xsMRoIHx-oTnf@;a8)WHT$kmr zgr#iE1EoZ4{elD(tV|nXVA@jCD*cG|Y+F-XPG{64^^T^7CLE$sD7Kzu@=l)1!fgqa z1!%eOP2RFF?}(_Y1dOa*Rg(v&t_~La@LG()+8HCD4eU}rY=GWn#IV-#|8aI7@L!Gn z~S06=EiMgXRmI_NLI+o9=DOb$qHHFf3DBD z&i8tLPM_25_y0Z~zWTn-`@F9A^}eoio%1=LHPaoljq#-oGYt#Vg2(4GjjeycKGV=p zpGFJ#On3S#^DH0Y+ILNa5t?Ziv*!b|Z-A&h?^!xuHBN*0|Jzuxx0mAK-XTOP*I`EyHWo${{L9f)X@L2qWO;hb86&af35I&>|ZK;O8YMrzIMwt zd;YR|y@^Bl*AI=N|1;b{o9PHOJp`|a%8#UmC((*MiUR+Ym9;2C_Q@al^Wrl&)7fl> zO|`pMRW&T`W&f}3GnMd(J7FDZI9S9Kmwhv2N=$7%s$GrGEGk{I&k)u089OZyeEwUWitZ|y25f0M@yeJaN_>`po8ueMn{q-)%2 zTtaKv%{(&pVH@l{3!mP#VgJ<@kJ^XeMQ!IBIiBGQ~Td-rnu?> zv%c}6Z1155gvWjZ)3sanhvt&23YWMD&c4`=& z1=hWqt?3(cldVY*todvE!q*|!KI5!zTYQ1wj2mkuoAF9Ndv{aVQs=09?O^TEX;Vh^ zuRmm4?dzjMa=tXHwp*XQDK2}J zQbmK|{7iw;`@PEj3*{?q4f|%VIL%+|+!S9=nqu~=eRyBdk5HCcU={9tRBcQ4%9!kF zrl#(v-QxDTE%hzb>d@e&9EVj(F~hHgFI%K zVSD|RQvJ7Xm-4CKSR_+VQzr4%T8%p9ra~i2FD;TLb$De&BX1Kgq)i|hn^4k)mr*p* zHSt2%1d^@^C0%&!MI&7kFLX^H>6%c|)m{(PP{@`-2})96(uUVnHMFJ;g*1`mOe`tm zi?bS9>$Vl*I+)ybIO*d{y&CH4wiWt1nDlix>GPLqG#WUz6lzdILpbW{-ojk-hDBmV z8e;3-%-j?^Bdx_2Z)zrqV9qWJ^Y=gd1?8nf*i9+%>{OlIlqYn*+FNI5z+s8ZVeM<( ztM-^-W7sdYOe4?+Yio=T9n0$xmQQvG8_E|urOo-vI7%?yjzaHc1UM|-+4+!b6-;3q zW*QLEE0+H#E%reZqCBO?$fgNUci}>ArTds{DUvFGa9k;e(6OqJ@I9^MSWNlC5I;b# z_%rK4I+v5k3@~&*y!tYJ+!CRUY18X1n=ZrRF16}}tY&!0Y&n2lG}%HL*+bZ-H#5h5 znzn}_nc4QRf89Ij8VP0^5DdP1uaRJ8+r$3ZVN|=6X|!+Ewy>Y?HEy);%(jR9d5>{< z_v}Jq#;y7LSF!~?`#j$4MV#4ZDrRqj55tl#BWVeWwglojQ)}~p?BPM$DU1-8F=<2b z*^c?HwK6w-d}Gq3iJ9W!2OgxLIuJ}5X!pk)iyh@<7bSL<$#%n)GQnk?AVYN!`P^)rimZ!&=-NJ6rri6 zkc4X^TD%`O;SlYCkP@4bhFIVD8$S9Xe=|qz+!k7x$!1GXyfwUOzhX70+Yt8fJ>N~y zGr$m8_crgQ&>3kh*0*-2*coWyt$QnWiVq8|ZvwAvDf}~T2?d(rjonTA6iZ4PfqD|W z4c?^PlugyP+J42rSHE>TdH!N-@YX(CBzs_(eJcD6XYsrrO;LYgd--HpGBmZ*I4)E- zzDO|7tI;BqJBkx{)6-kEN9?J&`l!aug^q>AFuz2p-C?O!qpF`F^#3F3uQXoOWL<_? z&|h)YrPz3fY|$Jvu-8#_hiWMP%&O}4#@0|z9z*AYQM&@Ey||%v=ePDs=Pkt*D&?G7C+r;x5p5;9no&!q{=W9n!dU0N^s7;~JRy^s3ip3Lhp4$vOCD!m+ zg*jBXH;CiX4lcCM3?M1s)+rtnyzUsD5)z)n7d| zy2h%Comm2*JL!6>;*v*kacNe0;gbh9yqak$d4p@3K7+F-(Xw@6@R0DP`?|lf1Z!XL zlf%P%9n^QfLx*J##)tIJJ~2G|+_QtTCz8V1JMLAxc*$P@obQo9_R{6>O2hER*cpP^ z=8dx%6tzpaQj^)GdN>~P*H4BQ(&g_2wT=8a_Ut|CeH&An|DORB`K2bZt1j|}r~dzy zkTl8aqw`n2=H0a+c}0IJLT2ny?Y`>ZUPVVrw^_4yT*QXU8+uo4h~Z(F(#2TnAe+<0 z*bJNV0Zv(!Uoe}}nqfp`!9y@u73gNM$5@`l4Znq$NH=eGm$4^9W946bU0B8r9+X=*s3 z*yD1;;ltPKOV9+eeQVuGAojQk6b&ayQ^N_>-hY%g5wDN)Kk~P7XSaferjj0<-3AWJ zfB4wV!((1eag5dsFZ0Zm<*AzXXt1Snf@gbG&GFh>(HpmwRjbmNZL2hf@!9;mXzwio={p(Qe1du&O$^&W- zjq-nn4^^qX3vGtZH4S=YNXor3B=sdf1%=m(l+GNr4YdWjF2DSJ1|(SvX?p)jTA21r zlc<(PWn3xU%D7U_F}3>jzXpqydFIV#={4;;^T;g0zZjXN*c6%S*XX=lv9*5hcuK0T ze-7h}sU;r6{=yi{B(gLLGl?vXLyWBN*f z?_oo-?;UG)_~4<3?BA?kcBg8vjn@j_sF~Wmoc#U-EyNd;r4x8wfb1JAQ=w{m*4`Ie zNAp*iv1k6xSH{%3mVH`K-~F;Yv-Q6u_3t#(v->%|0$ z>^l(ak|}M1ZHsYMgt~a;=nq zrRBWleFh&qXdNCU@K<`2kio3&Oq#uXt+qq>t4K5qV4`8s$_#16W?az3VGH*JJR@gHvKTWHD_5gcmcC@C5>Mdd4 z+N`hJCw=={t=-y75{E=z@9gQg>>@tAt~z{HT%@(h+h`3;ovREW)fL) zR-V>M#>%+li=P*i7q@nmcv$xBwE4@DYwxPgo(+cNOG*N@ZQ%wHFZ3{7at}}jtCgOyQ zTS5~v((ui;#j8yUM~!749hsdvYUeBj*)yowC(q>{(*(}GNqGN*viFeH7Ap85Ll5qq z;p|RA(+gVI8fE#Zp=dm$nRd%QYAah}4;j*U>)=C&RcuMwR|FL2FVYEB&TdNPALVX? zO*d)@4j)sTy?P?GNz z@wV&(gxna484vM8vbP9kFA2yVVU?#$*dg5F&jz+xp8-cSiL>J(%#HW~d_#Km>)Uu! zK@SKo;|ROVP}_RGU-mF7JAX74v$S=Cx{cxWTnA?_5ULGK?UT=%1~mWF!=?nAo*2u{ zl-U9>IDCUQpZnOac4gJ9?~$qL?3H5KClJRx`h~B$jGri0JFjP-kyv{XMiEe3tM@x_ zX!hmV*|C?sd@>w2gTucM-T&~~TV3NPYr90PXA-UoPao=UMx-#pd)&)9gD44R#4PcoHQ_O&J9JJ$~)u349?n*P1p zA+`0Y9)&7P!cKc+!`eA}r}_^0`}qr06L!u9q*J&xnpGtHd#fX}moe4uux>jf?3b4> z?6PZkzBOn9uI*bRTMQh~Ye=(ght&Saqj#$fe0^B69M+=zcfR{>gR+MSee;c59T~o8 zxVHDUL+Vr7HFTs%IK^!-WXtf)FR=$*v+K7#vIo-H%k{I)WQR|70x0gOWq)ui6}oQW z#1jTPPoOre`9Jdk&Ho)nKmS+kY%xu;p{wyUy0t%>#x?&d8`03G&iSpO@Xsy7r%l)X zF*y6)-eOdCjjKZ{VnMbYvcu3J1NJW_bl-z&f9_g)U{aglVQW*XwT(Mvt%j){wsgzR z%U!bPaS!ibhe9v1>;BMuZQev*_*;MJZ>Cc`bn^Y20P6DID9nf4m^#r;gAd)m?~ox` zW=%(7%q;w^C>@1GKsYRo;IND#IWeZb@vMpPyk4w$zEjh17pp*Yg?XVV@0g@Gw(}j* zG^xd;KdD92D9W<2tT*M0%C6b737z8S$JcM)GJAha?Q`z7sJ*X6S6@}du$qR zVy_(r9ND)|9FqE-N?V#Wd#FXT+E4TB_g1qvYc~DQ{O85UXU+Ir*?$FZmc@jhf)C99 zY<^g}6T1Fz%yYzo^?dkx`QKMm z@X;0g)e8Pa1)qJP#_hJQ;A<{kAK$ut{`b`-K0NZ-mng-rng6{P{2JJbsnzf1Ozm--$f*YYd+0Au#(X$M;w@=gqVKZH;Fz zd>iYoFCH~x7d5B<`= z5b^r|4%fdD{2u)6D*QhaU-KWF=iPj@#`(_;zZd`CA}{B^DDnE2hnxQ@@cZzuQQ`j= z@%pcX>%Sg84*x9`{+Ec?{|;RL$8h~$RQT6gJ=IzNCUE_o;QF_Xyj=f%h}S;=u742x ze(E!{!v6yC!QW$G-k-^E{U5@eKc7|jTdh%FpIZmye=i2tzYN^tw@u{b`ivt!C9uWHz&%@>QVNSUIc_T09zcBIomxY`E%J2usf3*t#lf(!A z_`Z4mufX-c1%D9#dlmjqiP!%r1|hw%Sd;cvNCtatW5{R_bLFAjeg|I(3{>pzM3 z;Gcea-rikn=l>7!UjKg_dDHnQ*7G~K`TPujgnWL-Uw6J(CvUg#5AT!z{dc(jmEaTb zw~M^o-(kdu{&tD}li~W$ggc+lt?*w&y#8z8`fq|iO8&Q3_^*i9#ZC3uKd;ZtaQ*** zKZgJA$jkNlg!qtuhv=UQ*Z&Lrar}Q&_*Yps&$r0Gb@ZZ`;UmkbQL|)WwWbeFR|ApJ`J8=8; zA%2g$1=i1f<#xB+Am>f(#(M4ux82?0w!3%aUng9|2(+$ zyd6(yx5s{YKgYps_Yt`LnuyT;`uBl9P5!+r`~!&B zKNPNiIQ$v>Csz1RCtm*raQ&CTC*i-U!hZwt7iRI3v;V@+5Ae`#>uxpNtl7r-|7RE% zxOHn4d3jvA5Fh+KqJK}g{n`(%zfXn#T;hX&($0C_m%;U41Amsf-B97bop}A@;QAkd zKZk!}g@2X~sm{Saa;N<7dEojNf+e?KA4q)gPv0@m z|46w0(`QHxLKNhZkT!sHr;)B0S%>R41{$Jtx|E%!0+$66@alR}3 z3&8a+4u661T{`me_zomKl_&+5+_y=y5`@e_l{}uik{y!`HOGRH%pD8h}EnNSaaQ*8>Uarqa#E1MlME|#N z{XfC~Oa9X<{A+BU*Q3aPc$^0t!}WKBhkNA3^G#bvUe3QO@ge`h-yN>M7yJ$U{UR^> zZy-MSyTts*!1a%VoBuoUa`M+P`|BQJ3Kfv|>1~>m^9kb-JpK^U# zzxUv`hN8ol>a>%?)Bb1@DK2hkG$+}w_UxzOOO2T z4dD7WgX`}UdD(w8@pEPBR?&YOT>o8g{r5#)_Aj!1eg5tC&i`HxuD>l@|LT#K{g)9R z^1pSj+ zy5_#n?sl`Mbzs>FzDWh|Tfv7_@H61s)9z&z{I&}I5WEYX7c2Op@$qQrukrg;@FOeu z<&hWb)%19L-UN4CM#Ftxek^|PPfj8}jC+^3ZoUrJ|1SJP){T!U{J#+&{FC};zp|g% z#|| z3jcY;*YfXJOTXFWaQ&m;ACdn}75*oQ5B}mh_!YSRx8VBUtMLCueDIHq^`AZ7&zoU< z;nsh_$jjrqI`Oso$Mt0+xcP4Z|Csu8uJHFEKKP6C-ypdDVQ|NHc!mFS_ztWa9d^mb zIrLY)GrTMD6Cy9xfm`Eo^&H$hUxj}{9p1$6I`BE%e74`Uai04{UgR?(KF&V~?se>7 z_^0GE48Qrj3OAot@ji6XZoAm-VsP7C2JU^2Hj$U-+Xlpk`B3;f!S!zs|BQa^RN=pv z_~4%sum4BE_1^;b`hRqV{~qG?KML3XH2ib&f4;*14%~6MeYeK*1%DWi?S2N=-z8pmhjw=+&%NQhz)y$! zdd^XB{g1`LwHOI^Ga9?+QO5|Z&deH7!#D9b5X85=8F>qgx z{RsR!;-7?PxY^I~eJKAe@#6l{xA3WWeumrbe7*B}gu0pM3h?jow2wU0VIS&nBHZJ8 zoBfmj2Rwb?VO%D)&*Mgw_~avV{v=$_jeYa&As??B--4UZR{iq$&|f`=!$UqryH~-D z9|sTdBV+y(;oc8?7XBl3cq#Ibzt@4w49GzC6S(=`3*VRe|53qLIk2Xwd3?S7fpFL7 zOr|D)XjN*@!-aM+7XTUNpU>O{dy|$;P?LFYw&5*?JM|C@I{YG?S^qF-mkF* z-1lqj0RI_J5BM+e>`l0}pOB~T6B!VB=+}OX%VEU-isu@*{T&VejrfW1>F`hBzr+7^ zbjs8Bxx5Ou-A~}Q+v=F)`2+u^a6S9LjXwzP`g0B3_|b6V=Nz8$`ICGG!j129T#63| zL9tE_f*Zf+@r~n`hZ}z+Jj}P|E%W_PJRx~*CeL?IOx$@m4eoho%ac-k@Q;Z8FX8rU zj+0Zod0uu(;2si#5_%)2nNcb$wlN;ez5dR(AcK@v4C!dq@H+~G<X%mH~e6DEBG+@Jn+-u&Z{fo^Adk2d_MR@_}}1f z!smy74PO90>jkMk3&IzHF9cr&zA$`SxOLbSZXJ5Ut;3UW-%t7q+;!kXxSqW)O#KS; zyxmgy-z_i7|DUB^cfIsxtV>s+4vq1_&f=6`R0W#Y@|f&U%8b__;Pc*@{Hw!PfUf~x z9lj=fBlueI&hWM2yTI3h?+b4aKM)?qW&9?2-bcW_pMNZTT|6g6o}s$?32%={b+FFO z?@D|&c6@wA^(vv|3Pr`9|kx7;rPw}Wa9Oo3)g=U-1lQ%R^fk)c*pBG z;;qm3aF5@0Cxoiy_lJ$&tAdY-Jk&Y#t4Hs!clJ3~aQih8zBS|cOyuQpU+U4^S01k| zD)?oQ&zkKP@@d^W-~R@<`P>dSpE39y$G<<8`wD-LUishc;QH5r>)#;q=GpH04}e?$ zGb;GwaK~}E$LsTK9rIirZl3GH&2yv3%Xtofo99^-{0X>uF8ySlXYlK36M3j}*!Ej| ze(C`DHra+^-8&3VU)H75h!373{w(4TB>sH3c`o==wsZDVjQjMy`QOXHt>=nx>$z&= zAs5GeZQ{43UmFpB5P5d1;K#tN=gk%Tk;p^8wxivN#M|yW74aWd#Lx3|UZ>Ds^H~)> zfPU=_-x_`x+~<`Zk38hRJ^8-^?*e}dz61OV{0GzS($A#)oeymz5AFImVtsg5{GH)D z!gqrk-vhoA@e5B%`5Z=`%SK+z&kAULumJMJac7D4vg*I z1h?JMaN8Y=-*%UOHt$E#ukq2p23-GoaQz!co|Urhxa&xK$iMJ+h3nr9zBA*}y}~~c zK9st>h9|T;^02(0AHZ$*bNDW_`!#;+w&QcTFZB0t+8qEt5`HRt82obhG4PurFUDm= z%zrH0{Kv!1{}KG=KbiPYpB@M2{rL>8{~P$dv!!+ZhYJ7i@T2M1{LiPl9SdJ7@}j@P zV}IMi&1X%x{aqKo{p|@ipY!3v$>%Bjp+1ub=6SygH=oIH>+?Q-^Z5d9yNkY%>SLbW z;KrX1H-7#XlgIduaF3ULA}{JcFxGzn-2M)NTmPYvm)C)l;U`h&OW+{WR929cscHE;m(t_ z;l^(qc~Q4kG5@XM=HC@={=4Eg|3l%9?Zc5`QTCWcV=^{EWzp zeszicx)5%^M#8Pz)%YEkhv3fhXW*`5FT|9!_D(bxOEtX-#WYxH_xx& z<~hgfX?_~N5Zw3!;V07Hf54r$A4gvF_trS>-@)zg&v5(uJAV5+_Z#)&UicS<>t7nK zfBDGEz_f8iNk!C!|v-&($v{1@SwFY;o(4eyf2EeW>{%fY>#UkSf; zSe^J#=fb}cT>lpEZk$ItSNOZaFQ8xj;2vKW;t%j~I~uy$;+uYy|&+$GMwD zUS0=wft%<2@1%bD`t}v!#;^2leV!fS`mheXE>HMw%%9C7FX!3)y_Apb9vyk8&qY~( zThEfm{StZb7=PFM`S!rA|BLXE)c-5^lAfFL%`#TA4{#SpP>fn9Cdn2DU+Z>L&fpNY)2De|&!1thEFW~pMJN%>6Zry!C zxaZ|t;P&fdxcRsEIQe~CFdy7@TYi$_Cpw4T+N5S`k-vGZo@=(t`o2UCu55sHo zHczA3Cneq{@}KZ~zrF3Jc|h>%xiIpq$!52ZPuI`#_`uD76#P2kKa9MX5AEW7_y+EL zmDFd@9`goGre{^DOGnrEmWC z{BY~A7~JQ7mx?^p-#WA*ey(g=;a?N3e|>m&>f9mnvVREN`)p^xz0bDfmwEq!$M_rJ z#{ccB#_{do#vcxM9M6H@#<<)GzYjhR?)c9Bb;@TP@$*L>#&K`zwj}Y#6MrTA9{89F zKJPcF-TR4O9ex1(c)0QR!L84G@CWeB|83rGF+ZpD$^Tvo?)+&3_iBq_1P%$az35m=CcEQ zU-H=nzxf;uH=mB*r~Dsdyt+nS)!<43xCH7|6{}l|G=34 z3vm7ag`5B63jc@1>;DF>e;VBUf2;5h{xPq2QU5M6|Ks5LPlcQRnUR<4e;)B6|H6Mc zT>mJz`QKFGZ#k_#|8_C|1>pJ@hnxS>k(cvdf%uSr;a>}`e*?JrZ&Kkuka*vpJ{a!% z$c}@Dd|Ji+o(VUf^WgUPqR7kry_|UcH^KFfhTGq<75)c^x4#ShR6mX#=E(nEp~R=` zlk>IU=Cc9Z{%#U^xxbx=5B)9tJHhqu0k^+BD*S!m6Iss>gFgX32L2@cRQOZybKy_J z$Nrq^>HL}hmz;+>Od`H5{8{)G@aN!r!Jmg827duQ0&crEz-@N|+;-oF+wRYB+gf=1Q7#`|2e6Kui6x`$D7I^QhsKx6HM@L>h?%r;e-^dF51M=B&mc)Hr&^_{S zp4uP(sqm2J__#it2RF});jRytM_$fz6!H2;!}Z?-cYPRN;cqo--rsV+`oe4VkNr9f zZo5aq?bor9m-}@J@%sM>*Z*(0{Tf-}pGdspwc%{3zoFd@v0q!kZMO^De(fB2xnFw{ zufGpm|3Ps3HK@XWCh_*`6L@HMdXMZ^_A?c3yT8Eg*B_CW`_-a(eccNG{BZq?!R^;l zk(d435$}0<7r5)gzVOiB@v*-L!p-L}xcxmM@^U`M60iRZxc+~_?eB#Z{>zECzwZg8ypb{XB$Q ziT{%LyWo$&->dL^19zVMt7WRg4tO@6J$bU zD|mOf{yr7_5V-y$;D=G?1(r(n*Z=nlzAoHx*|viBfID7;;pTZX++1byuwC#d>?>N{#thaPzzx zZXIrdThFm@>-o&esa-wGw@uuBty#f$hwIrFZaxFxgPEU0;Ch~`;IF}l;CTmbyPv?V zXPZ@0f3M0qTwI^@jXYD=oj0FbHIEP6>y1wBlIL*pd4IJOzfkrVy70GLJ;jIXwBmIF z3&6cjTO97|1eT6G7{VmkMXAFS zJfRLfI%U7IpP%8j`zPG*M{B-TsoiNBKh@C1A)2T-U*^!s$+xx^1qt4COOLg;eP8Ntf)XmR1Xphx$y4^?3qreV&8+y`L}RcN|}bJ6;E_pX#$X`3!?E z2_F}EsGG;dQ^YSp{A=*#;B7akpAWaj{;mtRza8Mdo^6ZB%kyDxxcz+tkMm?Y@y?UE zHcWXsPZo+iv}^nt#5+&6ggZ};f;&$x!M`wddmL`R{={RymfI+euX(N+d3pYCR1v=$ z@%C!~+P0@=zc9`wsCd z)ObJ-}B=gaO;0J-1Fo8 z_+3|@gnNE`4eq#f+#<~f&yVYMOg!Y-Dz1ke;pVw5-1B4C$jkHOD&k!q9wpxO;YH$I z_ui_ApGLgL%UoNgez`uZ0Kb~+uC3v&8+{@V{qnqd67ivKQ@UrrvY&I{*6l*L=gmv; zJHA)K9mlmgrTNy5`L-#1b@+*qhk5An@=xMdBmQ#uI`D7tg#J#7{hbcCzq4(X>hF3o zN95&svK-w0UWKP_{t#a`e~7P}KNa!Qh_9PJom2kKpB3TGpKajIpZ<}D{(3&W0B(Pu z!()HHBi{c0Nxc1?bL%uujBgWpm=E@M1GxR&6>fir!tL+*k%#_zo*fIfzfZtDpMDPa ze0tC}sb6}Ytl&#+o5s=e$jWe!i(Zk3{PkZiA>MI6wIco*;vM(5 z;g0+FaL0YY9r8RwKCUxc!0p$Gk%x7_evKmDe%(pD{Tg2pKTFqCH~Y09+#o-#5A8ZnK7xDQH66Yw^S13yDIe$mnvn;; z^S?XX`F{?46a4SMt;4r)*VP4fPV>Zd^#Zt_?<)A{T~fbXSMP`0-zkxY{_0<9*W_^? zZXS7vcOG^n-g&rZMf?!romZ#BorjO(asB*|_%N^9#r5YKxbtcn-1YM}{LZUp-O{*N zpW`AgAE#FnZ+-3{-um2E5&s(T*5@0z^;u)Ll&9;=-f;83F!FN#_Y!aZ6Nxwf7b@bv zB;Nd+?Vje9`EL?=m{+bRJ>lj*818X&4SYL}$J-+h{SEVE}MR@dGZL{`^*#Z zJ5Sz*d;G4tN9wP~<9cw9$3c;okH@Qt_jr7ac*pA{;vKKa74ft0nesd;YrHtW&j53UY>6o5^o)Lfm??w@wm=RfLn)G;I1>xd!%~q#5(i0 z$cuGmcwA>%!=1Ow!(C@q#_zn{4DLEJ4sQNm;&(pJyHCpBacmuV$lq~Xu_As$;vL5= z;ErQwJkIBRi1%^sL2$=$1pMf1QWWde_i*F?v2U7h&XZA*hk51tGlBT9{!EFl<9!b9 zIKB#Z{dp6=X+ktapa+2j_>uvJHDeU;vXg6@qGsF_`ZP0 z@%@x|$M;9LPM7Z$__e$}O@4AtPI=Jrb3b+2fD)>=w>pv#)@;dn%@z(z% z;;sMJ74ft5PW`g}bHc6vypf0gTK^S@xBlzEt!Fp5^}io({EqvlJgxu0$U{D^x2MCc z|3wx22DtUV5AOQ>IeZU}uOA~X*5?j!eV(OH%HQL94!G;{JduZfd0e-FyFOnDH~$y# zd;ES+yz^(4z9~=V&)kuRe2ib3c<0ZGaOcmec$_~SiFf|&1b03h26z6v4mW;E;}`hSnd`p

s+;v+3~oI)gj@fs;Kt8- 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 C)NmgF literal 0 HcmV?d00001 diff --git a/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so new file mode 120000 index 0000000..5d20f6d --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so @@ -0,0 +1 @@ +libraylib.so.500 \ No newline at end of file diff --git a/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.5.0.0 b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.5.0.0 new file mode 100755 index 0000000000000000000000000000000000000000..f297e6ebbaf207aeba5d5c6f05830863e89b977b GIT binary patch literal 2300656 zcmbT-2{=^!A3yx>j4{UASfiA&lYOa>bgWU*C`mgdp-oX~KZYc!C`4K;k&>b)l?o|o zm888Sm83+`D$o1e_w-!%|My(abv@Vfxvy96@A=Mh&iS72Idcs6W_NE7Hj736mIQGk z%o4R!@}DkB{D7shuDFHAh#ir|zglGYKhNd--;ex18^YuNKKeHa|KH~@>-c94CE{2A zPsTVZ{qw}X`QO+5^NP=E|Gv@xq`IfnKmC96zpvxskz}Xg|2&@T^M7Vl;=ga#uu||a@kU+DVoohAyq`k4{g&O zNm7RBP;>&#qX`jY3ki>+;uOu|sAP(;y*!AH6^q7}Ot2R;@L70{oDyMqgmDBVmQ5m} zq)1{|JR;->_#6)9qLj?y@pvqA!ahpr3W%VPMOa2e4x5ymEg*azC5XfR=4;cWN-?2Z zm`LQwVMz=D-z}Sy&1QK?(h|Fk_{0*X%xC8*@U z*^)-grc!uw7ZOUOy;%}oocTIDZ6QZmie&Iu&UmN_Lv6{Iic3x%cSya zi>B<!h-b0{b0igcGD_CjY?>J9#9&R50v+xMwmP9{Y!1aC zIuwSPNApR5G{={nK$O%8n@%9d6!mnKRUZ)f@f6pOCsF9RZyR5cLkVelik&VaQsj}{ z2~}jR5exetD&X@3EEytA6f-C};z4QVCIz;N*t-eg5p7oh=8 zdCV(mT92>=YWx@+LL5YlrL#a=ph9$sr+P?Xz&&A(DeXR;vSbrBiw@u=5_Oy8)n$8@ zsb=dPW=F-aDK?!cQRTuG#3=Ia6Aur<^Yc*TbD|`wl{AT>h)!0tlq5qN2#c4?3uKNw z(V6_%P{Eq3Lkjh1no^Qjp+m`#WK&h5z$xU36bYYO#AYiI*Hnxr#*iei37tl9g%p1h z<{sh2@Z?z>5k=g1v9f9;uD^L;s{j)y#3Ob8eB3=bJjZZD9&|JmM6*f;@8s5a^p}qWdwpMRho?QrDX6LOem~X&PAIL5#h57CD?p{ry`MV$8nY5 zb7)Hej;3}Jb_2&0n@2Nq9*3Q$!!mWb?k0hqN**G;+ma$QPo_#iZV64=IfPxC$|5fJ zXqtx!>CIQiD|I+TF^=RrJFp3-mQa(VMZQ87;p+%EB8r!TD~>Z^YXnM6jFXT`CM--H zPj#${uOzUOKF^ZWP}lR6lO!yPS)n@3;~Dd{i7Vm9(9V2bGF#7*2#IGci>3l~C;?B< zkZmLp$fk8Tp)Oo0oxo`%0TY~#!x7V_Xr2uB#AgZ8UDT~k@paq=iwGG((S&AUU|6^& zs!Ywzj27ZpvF;I->j5)-ksv>n%WJxxLn@6(o-k1d({6|P2YZT$gtS}XDI06of zFI42QUDK^-;FMv}lFq^{gi8iBtQYB+_&S;n7os{0XvbGT)QP#1J;0N=ZoIkz`!-c*OU(P>_!gA z@p&YJsAm%qMjY#+SR6%4D3EEv&T(YeI7y0S$)OWi)og(=q2dHpR?4|@SOJkpz`!0BjF8eb zYF>%6OiKN#rhpSiBsi9?ZIrE^Ct>OFH50JKDqKFtveYF)CDpVE*9-%^8W;2vgyOlV zR&(@i**QuaU6DG6PqX*CVCHG7Q-qyN()g?x89|yrB3T7<24@MyoS7)Ro|fCfQKzD8 zU2qdx#+6H!sg4VlA(S3IK`|#-LWa6#k53?KY~mIueT-D;v0Mm?%?~8FjH>Z?CDK!(lUQ87 zoDweX@oe_?@O`0##A!QoR>ZJFIYAtefRe$Rc}ojewL(58o0)l!s!qx9EVsn16tZ#4 zpyBJnQt{A^5maFe2!$PBB~iSpLS|2}Bt=mI7Z#28s8OUz5{YBC1hPGG)g}TVYppt8 zJ7#(yM>^M?r^pf5R`GEK;0pLFOx)rMj1=h+JeCV)nSoLap>wRR^R$a-!oKb-ta`=G zW+}1wk|d5M@f?{PYe9-ZmE0^mS2^}5TMyR-T!0tgfYL;VxLC51i92b~=7?C?Ix!p< z1zxM1jEoDXuu4)Smu$r6@st8-PJ#gUM>!NlhZ;$0YwFbC$PSfZ*Qjl6#Y@1fz~?7R#IM9CV0Sr0 zo3NZY_y{Ao&B134i^R~fr+h6_WO1WZ#U`qvYM+w5ZbYY+CR|K{5KJj-KMt`rE6Gpd zUXZptA0PgK`r5db%V7Q+U)N(smoNJA_XLIX;KacOycs9Ii&eWCBM{V*+cP z=4T^M7MD3hSS=MONDyen@rY8U3Xdi5q>Kp>@#$O9g}{Y_jS@&>P^kh{55BK}Vv|}+7VaoY*sQ`_Qo!daIsc)!L|~^apji}F zhf{qaj+$}|FHVjf%g#f)s>a45pTM{Qb8fYFd_9-m?-5{kK#BzQL4O@s{;vR|cj$n|Br zc*(`(+vF%??R?_lOz@_Gw7Q;pfdt8xrZ^hXlUm)WAZCc2X+Gg{aadw-N%4CXPO@@!J=FUl_(HkkE+h%a*NMho{O^v#*|Q;`PxQAnmAJ` z{8L-86D&QKK`g$2WF$JrU7=`swkUz-5J?x3Ez-#*%vCqe#h_}uG_?(PIvh`m6-$)3 z;XHx6s)`aTOs|Ba$R9>&>yU{Y`B=I|g!`W=0q!OR0v?MkYh+37Au??26{#Zp3a%Tm zi%<+=S=#ALxZ^B=kEGz>Ac0`ZVVOc=jFBZHv}4?iXi8IwMb59}DT**JWO&3a#(4x` zv2Y@YIBI+j%~qeFLkqK&%UXkpB0h*R=m<{{u@vBALQ;wF)a7DAgA}WiIeN+2+Xr!o ztUM=x|)tdckXhIGvJq1gdBrlGW&2pxb1;kZP z!xNX}I7?OoA$q)IqF5zh1!m`vAuSx@?M2awxGbKeEJJZOWMxNGf{61s)Fm}{<5vJpOHZL{-LBdVx4HdnBP7SJ?bM!=sSfip%s2v;ym zGDSodxLH#3S%l}eB{LWRb0NK8i{n*^{d`4WLT5h~t-J<>5%lpf6q))q+Psv@8{9Gb{pF%k$$J=xMz z>;hE?2mje}NenxxNWzFOjFaJ1QI_h&)5S%F!#3g4ETV)vQf;9Ok&(e6)nRku*d$Oy zb$2e>YN}iCiQN)amJ1%9N zCE7erAS))olGAiEaJU}DyL ziEgfrHpWyS;LFBcjTaCrNe#PH{A7ViPE@cxYr(FK1H% z91;@GlfxQ3BLvdScL6zou_pOY07Xy?C!qw+!a2AIm!Sq~;VRTYJ=}y_z|?JMgeG_Z z58)9!g%|J=THy`6g?4xk9nc9M;S==0S753SzQZr*hXG(=S2(~09^eO1A`5b$0QlS@ zxcU%fPysa<3`0N@hJh9^L!tu)Fanq|Lo&0MDJ!Hk*n%C50Y?}I6u5vJFy)T)5VyUM zlfVZii~E@82+^Jj)5LxL;tW8}fY~rt+!u%pf&~yP?h8SN!(vzh%YmsC$W^cgqG3I3 z1R7!?4iaEH?1WvA3@NY&(qJ!Sz<$VuJosCO(LMr2Z~{&OQzhaoMV=D3nf@}g%i#=E zi2KhW&qF0t!4eQ1V9@D!fG3wQ;up$*;uQ*V*)pdC8k zBXq+T=mVy{A%DPc_yYsLV&hI2IKTxS$bcLuz#veBzlDn)!Hqpp1$Dp=B}5a3fffir z9}IvgL!^ztOZ7<|Rm<&_JeSXMk z5CAh^Cd`7_FbC$rd z-VnE$<(p{VhP!YN8sR=L^#J);+ z`~?HRlE8ceE=Yqc3<5s_1uR3Y*h6hkSL!5OH4 zb5IGFp&G6LQ?a5JfmiSb+TlHXgf933U!f1a!7um?1Au#K{BZv7 zdZfiEi&OwUD1#ad1`QYjLtz+bgD&WUAsB%vn1KaYfh~*#dvJg;;0R1PiIZtNqwOkQ z_CR`pH%ta0OoeF>05f1V%!NP*f?x=NMGyu{fT`uk2yvTPUV-*1SOaTeJutNaxk=oP zLB@*P%wzFrCqfb=i~CcMdjQ{$kPOI#EI0)JtsE@pLLMCcpU3jCTmVPlnE0_GaV-{B9iBr%tO16+^-9>{t@j0G2QpBHix_<#_6VJi56Kg@(VFc0QK2rw0nWPbg+OuQT+ zPUf){Xh({dqma?C7S_Rf*aS?`ND*v-c-Rg}umg5MGNeE%{H=7fGsMf8$o-HlUd~14 zLxFgidCf7jPe2Krf^w*UO1KD@fvGBFEnJ0ba2@J_sT;^!a7Vm+5BU%t!4r52FQEn6 z;2kj4AD6>WDI4->%~Cd1$IMSCht7xx7qXTVID z1%WUhLLd|t!*W;wOhqDB!#damB48>O83*x@2s!JC)WTJ`26b>9Zo*w?fP27H6Y>Ex!y|YMPv9vq z^-`Q|$hYtg-a`j`fRE4xOnpIq6}NkleefNAGJR72JcY2u$wA^fOCkk4kO4Uu1WfUf zN}vL&Fc>s|sUgT=;x@B99BnNSfR4CdUz~R3dew{Np{H*rJ*G+{Vs15-LkJb_K^Bw!seA1<8;CdjMY)ku=x~8L$ub!$Dx`us93E$@CpT8@~o1 zN1+Ig15+oEC!rL|#C_$+v*Px7WTm)WgRF%*@$$d#fH{NZ8*meD!EI=OdvG5f!XtPB zOuaz1z-xF9AE6t*LLYpC@9-0T!vHYFlE!Bca6l56l0x!82IN5jm|y5Cg9sB21&33cET=5hCPr58L$ts z-~b$gzm@%;cCNUchdd1VPyk1PsUl=Cl!%v0#d!)@2Ib=A3gmgX2$!H5YT+8(f;+&} zUF1EuFJ5j!K7z;a0$##vXalC+BHuwfbU-J3gip{7z3>Bm!2sZ!P9gkz-&ii~|as zfhjkn2aJaa;0=>tG6(^`P#{yl515*U3=p?xA?Lt6m=7Va2*O}7EQRF|2~n^Ln2JWO zh4ruzHUkYz#UNuL4z@r%Y=cBd0;YB#Qy>*GU>{_`A;^JTI1B|)2uFdbW5^Rw0_9Kv z=b#cU0#lcf)#CP5-38hDY!Op29PD4lm$uy%e`!iL+IlZOAw9 z7TVzhbiyZKstfrUdf*H6!cX`G{qVQ`Fm3$O9e*WBBmloFCsH5{Ov#8-4mk+;pag25 z4w}H!aHIgVK@SYU7)-$&EWjFUfvM3*J8|1yoDRq_K!FRmfd`BSFPI2_%NuP!@P`1H z0ka?wf?xpzLnts6j$8~&U@0tz2w*A-xeB7i%WIMAU=z?Ff;jkF@n|Q)4%i9FkOFD2 z7cw9V_QL@<2syx1E;0`eLp~J3F*pvzZ~~Y*i7bIKI1A_D0$c{Bs*u%C16QCHuER~Z z1-GFA?!g0ShKKOC9-;jhp8Tip8QRbPv-|?>7I+P9@D`Z*fcykK;$^0<7wvEG9e%(s zVCoNY0ND8bqy$I;Q(Pnuq(N5PCoj%HNJUTrHBbjl7!F#%lmMv%dg5gRq#>AqIat9+ zU}}^&9gt(eNxVD`=_YQwBRydvOadS91wUYFx;UA30NS%*4$S*ce=ypMUiS&Yr;0=?&2PT6Md|@j1LjW)}3pp1Sz(R3fC^8(DK?JOT zmGHMB(Ow0sAsW^JQyY*QVH0cy8t^AIBp$ZGcGv}}z*IVNA7sIP$btV>9+vZ=0FJ;> zI0h%+6qG?ZFjav(CvIOv*1#3G26a#mH{mwig$B3>|E>Gt8NNU-{DR-W)E{v&?E$n|_@jRgNP#rSf*dFSADHrN+Icl^X_3y>DH&d$ zv|Pe3?L6E!vh?`U-s?3fxuOQgpB~&N``ugkyOU?MlvsE6Lec4cYb+-4R8~P`$ z`UY1^>}i&mz`Z0$jo4ruoUrf7z>`af4=#t)1eE@oJ+nDo*?RnBweq4W+hc)Etw(cT z^jU2<-LRy?>FSu)Me{#iyzzNo-;;Uo7Z3V)K*8Z=l&;j(^SxoO7H;3S%=Fq?&)L&{ ze*Mxh^84x56MKTK-bmN19eGOYZP2HK`-jUf!66)Yi5v@#}9%Fns;q1K7^2gR*uljtCuB+7f&B z+FY6KGbxV`*Q>HoHL* zV{Y7Cx7NdKb)s`7KWubU*Dp!kb4f;v-D*eep1UV|#=3%|{hvw$Y*km;*-rJee&D|T zRrbtb%e~GtpLgGV?$Y6JRnFXYqwG-U^yy!6P;XAd{{R7;V96E9X}@N0UF{E`FC zURBu?b6}R9_1c}QmK(4K&&|+rDyc(XaNqi!`eXBsv~NxEI5U1yn1_FK6l-$Go7Jj{ zx@!Xb?IM@o<%+u7Rpo44&z_uZ5pEm1X6&l4SSpI=aMF5a=+4YJ4^0I%&2y|vm&yLx z7kRLhcjNST&XEX8GF0o?kfQvF4xvJ|wlIB&w!+fq zA-18{!$_3AV%_pXnfmo}vCpFux^ydFe{%71nAjC`@0!&etGE34$qStd(t~bH{?_;@ z3db?zfl6}J)w^4p-^A6aU25JiepUR};tf`orMZ4hxfdV)pT={=2%h7PZs1+nmZd>rl77?)0=;zs4Q*o9&~1jIgh) zZb^F8^QVO9Zx?8kCJ0U*8f}!8f$d#*tBlVqmT2Z7t3~ncMGEBH``H+PaMm=A$-NT;6p;{ib3=voil|RqNB7 zwyo@>{O{Y(jVtOMJS>8;PDykoAS@(hTR*+`?bF4 zQog6!o;mch)mZhBkJ7!2Wr7mSXU!~Y54Uu+WFH-ceLFgtlqiCb=;={ zk7+Fnrs-W8ynEC}^#d820mPPWkIHW+i}*C_w?AqS2HfJntQly?1v_9la#}O zkQLXnRy?aew&ug?JiD1+gY|V*?Q$-urD-_S#QpCExoc>_;;@2J0XkeV8J>p^|kxy;lPdG*z;N7WA%S3V6NyU+JfQ_YJx zBd25EX35m#W!_fvpL_BAl<;LG=e73TF=r8J{of8Kv6=`^)G+o&+Z9ZyOFFOQb@-=aM160 zUr75_pY$J@`R9oB_v-=2me$JF=20&VMaLX-&35=^O?_T=#eT#HtGY&?^eLp%Zk$D? zaLCU2)nD@~2l3X0KpY zV#b)E3j&roN5sG08Ld++*O?$YGAH5fYmI=wY>CJ(%Uk(q_%pp$Mvxrm8x&P z5M_+Mu$$Fup0u<3Vdv?`0TSWH^FIGhk}#lojY5lV6>VzKkg>UY0xrz@`f~97QmqRK z16ofu*(WNTzp?dl&Vv1irA0ZX;+wLaxaIl0%e#u#Zit!_bUK9ldST+}mR_31u{th& z?5${FTG&gQCYP^6w`_>~VY2*T4?ADZkX}~34cqqag1 zdwA;Hlb}oB5^A&1>Aftq!L)Jh}U#OLcIUFjAxP&m-M~AMAH3Pd3!W zetuVZRITWxC9~nMnw8|!Q-^BOJO}qYqqRQ{lQQNXQyBN$aM!Xl>AboHy&55M=BCF}pRT_3g9@uSQhI~0P98ny#2}B)pXQs!*wi1P+^;oDG=(fQzr^e1 z4AHZ1n4Y?FuIr1ZUndE1p)QpphyAO|1pCDlt zc(2vl9sBPSeNlP%xMvUNV|ku#=e-5U#c!lGRg5~_6r9dFx#z}JZlYYw=XnqNQ)Zgj zPF}r)*M7i$)USw9a_^rWKN)a;!kO1=GBelbMr7WlF8Eb@k1~AtVZ58H!{g;;9p+A( zJIC_cCgOOX8W}Y1(O!$*2P5QsF1}UzqLKE)>Bz^{%{w(sj7NV;OzXSs^WL*0YKXgT zd+w|Dc_pi&_`S~+uB;3^`p$2$#n9?lo|(?F6JI*&+cq|<$a(B}Tb~u?IHULHg)cp$ zpZuPdzR`2#>zJ*M>uu+rwevH6!uo*6^Xx7JxqNec&AtBZk=M%daRoO#y`0laIP{E! ziGGjQe(cV#=~77F)PD)bKKk+&-N@B*>gEUsY5rQ}{CLUoCvI0Yq;*%`ciw3&W0pC~ zrWT*!P0uggYkAbXQ};;b1>zvIF}k(VH=;f$GB}~CL2t?my6?g9#oQ%JZ?hEY>*jb( z_>$InUFn20OF(IuE-;NbvEgUsx6IjQBP9R)S#M&rv*6bqVV3a0_I|ze_D8=b8+Z-A zu+}C&{42XIQ}oMLusgkbmf6aOUANoK#(9LyC@)kxJdH;U4k%pre2DxA@~XRjPnm;y zP2AEgW?H*iZQpEJ^6*S;nd$9$OOKh&KDwmitjf)c^7ONT2_?_`J*KJF=6Lodm{%+} zoMBuQ9>3#c)Nyv2US{INnF}g3xnU3bFQ%J1N*7!I%E{b87jnyY2(wdnO=`Ncw9?;b zR@jKHZ5DMkMRKcsYoes%=89KyHux^3l9mbJY>?$7oL*2yy?#D>hGzm{RTzG zoCq3@|1bB~L~WHzbIuNx-qNGn=h)o)T>o2QQhEI3yEUhlD~@8?sTjZSNL@!?7LyyM zX|0b=e%+FjqE=7Jn%v$Ud17(6U+!aiXXzZX$o0dOCPwXCFa1@`v1|Ejzs~KElQWNU zuW#GvQ{^ysdVT+1cdNJ4hwg8YbC%6C@f=jOMQ6>l8%^eShs-i;Hxy-@{h^oPQXlDG zUvXkw$6e%WcB zS@G-z<3bPEJnyr-=-eJ7Rkbm>{_ffDI!Y_|X1A40D>r;uGVP$3r-H_mS#2$K^yNo5 zhwi^09c%4T*Lp1e@gHTfP3`3a5qD$@LG6<*u(?cS-N3 z-|P2Znm509solLNts~&2(!lsW+u4;K)9>B6cwyfS-I;?1Tz>yJeW$)_$^7Hand@&l z9Sf`&siztCdd8Q*m+XyiOi7{rH22wEoH>8w9TS(ljhEl1dyRc>pFMR<+^?ym=W9uH zZN(&?1G{j{19fs9IbM7BQNA~~XsqkFp1q^)Xyw+v7*TR{(=0cmvn$+Bf0?|_@l~33 z*T8t z)I9!Z``xc!u3JA}Dix;r{te5rds@=hYkM2hivJA!oFR2pzbwvV-=60ipFOs%^t;>o zt@oAE6-o8B5$0Hr{j7`gJc5(gE1ftpGUY(UuGD>92{WAPT9-#pN=rSbHu>XLZK17o zx^DE+AyHBHZ$!B-ot@OTD?Pa@s3K#*iFF%#ohEP|oY0F|tGa1m)&7+_^TzzyHnYOv zh28ZbQdhCfvYXoCU_` zW@JdjJCT4bWoNJN$^KC2r()p}oxAge@a~L<_Yb+Y+ZN0l*5p~Uyr--nu57&9;LEuM zsSZ;fye?Sexz+0^_r&lqDLGR&DHNBR9R86lk(pk3^~Xa+&(Z1&ZM$P*v;<1-WA0DJ z*dOFk7e9N%=Ptg&nJ!Z0(VHLSJ=mA*WD**#t9R3GgVHsO`*9o7V=76W((i_d)IR17 z*!AA7)=7_^zG1?_zCo?nr;`zP+6&|#doFz>-`}6}x;}4l@7Ppjb-VXThGoLn)8^`o z{8@SH^NiF0e)7o2OPBjXE-^*=$nbd=my=+C9m<`fvz)$T(NkD+Y;Qu3FscQPw&~ zSvMTY>WZ&SciuXqV~oO?WQk760;}e8<}5+K(z#_iS#NJDPu$MW;iW~lEDnyE9=bK@ z$Xh>?;Z@07>)bda>iC$D;MIgKuFUJI}1N z3V%MTW#^Y|PlipqqgVBNeXMFvZFTnEaYN7ISl4>a5>2Y;TQM=cEb>Ryl^VYrE{)sD z!}I0}*7aDv_Os2t;r9Nv{nk-KRh6AbkZMcSlBnv#d$nMKw|7O|~&HI8g9X&U=zd8@+jD;q=S-z{tl zk}lT^i^y}HyQMcn*CC_BJm{N8&5I5vJZIC(lYah2k_uU2N7PRx{(c%YO!v6sqU?n) zhp_^k@p#$7O~X}LSF9#(()l&P=;`W zG;8%3=T3}6hmrOg6UPJRz5Nw)6{m$d?2IrY6@3mMK4`kcCn9P5@>o_Dg`*)ePQ#O1BhoZ|CU?scIf+ zIQYi(<;!&!NK)IQtA<9VxY4KFZ7$F2OyYXW8+K?dd!=g{8d6!By)8*%%FzCaORfBU zCB{G8(eySk=#$=#_PGZ?zs>9%dSbEhcKbb1hp+nPKN}PvBg}>3>X4}*lZ#_Q!nQ_Yc z_JK6+P^T}{$Th9OfpJ}1Fdhozjmv)Rf!FngsV@`WrkSgGoXHH6J{#QRn<~+};N$JO z@kFKLXW+A^NlG4)2lGc4ES^$kqM+KG-;p=Qr_*Wf*S@=|_KUdZFIB!1^xqkizfk+w zncKURtXc$)WnVguhCZP-{caP6MxT)unMC(f9^Ze5?mOJ~ZIKGwxcPCw_isvNEa|Tn zPxj8XkJ;*>+PK=uID1y!^$Ei>V^=84S9)yFkds(7N3EtZv`A-W&e~Onv5!a6Oe;4J z?*BPtsgAX9Q`yt3W)=TWruhf%^*G2kkRJ!Fu9ry6E>&B9>AK3oQ>K@7FYJ7&@@oII z2&r@IEvs&ID@1yBn->Mgq-|BGDC+G~e?;QU}eZdP4lYWC--ZK?c5C2!S{3){SAsdE(0MrgFBn&dnh zQgzHbA?$$7g*82v!^Zr4^b+UBqvEb*J08c(P?{?|`^x5!C_DK4va=by^)9`AL_a*` zgp2%{bzcXkwZ&xzrhpj#7Ey~8I8p+ zG<#;a?K}6isIhU5O`TKEM};{}^Q6YJocu&M9|mr}+&%9^w!{x*-pbgA^^2{B_fDGs zaIfeO=E17OGg2zMLgpBR54DJHzZfoA9Cu{Wqq>>L*?Ux=YbmpC!e(QHo zfST5<%EV(w*6*&o=zQZ$&drTlPbu~|)ptGje~nvr=-Kfi^H$%F)7ConQEU2R2J}A1 z+m?G~R;oUER%zs*l)mSWVq=l<#UHU&K8Zq$*Rx!l8<%`^Yv_;DF1GfcHqF3_H4;Z1cNRQoe&+L{EN$QB-ecbjVpiO} zTrhBQhm3K5U~h5JtBel^ZwcT1DKCvk9_RB$cElLnHQe1%_b1P_?Jhe1GV5`0!ow`B zlM*^9r4ngYj_YpWwLQa*3_8j$tFCOU;ad6ipBlN_$gQ}Btf*p@lF=R8V?)ZBh(|LmG?pWj99lVNusR-WDZ z=@Yg)XyL29(o#h&uOx5HJ9R5-(P&C5xbX8h&5=)JcUS)?Nc+6ZY|}>n+d99qwJSQZ zY>YLxDmh)=-{+T?68EVJbIM#hP)e$2$-0x6fJgu8ndq5)E6lP$n7s^1!Nl>UzgB)b6J>E~A65 zc_`Cws(j++{MyibroFmva@HG z{{E5_GS+B+X^Z?($Agi@wH@ZE&IebH>frh$dVct!qQuv1e7|9BfZ67%!%Oxpe_r2j zE}5*q%wpIkGO0Pc)bU)&)?+WoBCn!>YppRd({+w<4`eDjtB#qa6yDJ}c=55=AH9+G zq1e{^$a6M}k$RmsUv}gwZ9QlB;!9udQ~FSM<+*PmA^TOzKCURi7)%Xr{WKk85^B86 zPFysq{HZ z8$xerKQ^JAk&L6`f* z?!XBbf_ojy4>YvC(l$Iid;!neME6Tc!0ll>{VQ#{E%-~=dE_7q}(c*esqY5u7P@q{7R>f3r1NS88|u3@DDFi_xtkWVPBSL zV|+R%u1P=WBXh$1`6Io^E1QhYWiEU>Fte{o@u<`;ohv`aw5Y$ z68AgUpT_l3>^8^}Z9`D=tkDl(oN=J57eqhH8 zjX4v}96g=xrhHg<4C|T1IiPVIdF5)#9<$w{9XEpZ+suwNN;7CJ$v+zM;m$3I%2lEv zkv|icWtF>+*DO!PoG@H2q3joH{IC0c#v zbYje*U3}B>r{vp0+m}|7f!?RYl+hP zU)woWw$Yuvdmq2*J!ALd%#Hp^*|t3^Rqi%@UM2C(d!m9*_sE)I{wGgnt<4&-b=8`N zOOf6=`NFWFm6K`SCwA*^Ny(qPN^f!Zmw9sIt+t-boc{bI(IL7n3y)|P`Hae*$rj!cj zf1Bf8v{6|j#P(&+xm{N@)+TJwSt=+FKlSD4Ggm=LUErZJCou2dP0di&+LEREIzdzC z)+V{9zBg`j7tJYCW*8kS+p9SDi{5~LsD3o|cUX<@MAOT``?kFdDOEakn!74BSh05B z&Y^0y@tyoLa{QgoyS%F z&rY?g-rY6s#)XAFueYlNe9wHe(*I=h*mHLtmGgWAk0yWoKKQ|?x7Q@D#b;}Kr5JRU z|N2nYC7-dVN9*#eH!2E_a>>_r4Kw`VSgxkB{p#FcC zlN;aW{J7;bxtzO6K-!)hnG`I%yyg4MNX@w0-z_HHoWJZ&GhCXTdbf=X!dck>JJ)7(G-Gg)_ci%oxSe?4~kBpgP zSLfMd!s=b>@oi_9Umh*`SnjwaG3WX^xzzMCt#RF#jmi!lI1^?lqm=l7J9Bko_pYr) z*hhmWT0ZorY zEepn8yu+H5rgXfjeB-Hm^7?wFmF0A^d)q_<`}&57aaU_@xHk=3@Fww4gulg>MJ=E9 zXuVtS9zX9}ujtmg$a(XNbjmOvZqhoNKS;<;?P)T7c(=0ksj8w5l{9_l>g#37vbw`9 zN8V4d;Sy%a#)VdL`Lu1Wz^p>t~XehrP^dX4ex^1S@)hO2Vn!(|P8HU;&KVKO%*G{Qv zDt$5N$3>~(ooB}Ba+)rwe43R{S}mMc4Qi?y%rR$oz$2)`S z^!YW_(F4V$zwgo$f5^@p_54NAh`?{b_Sx>|4rSl25oF z$(tCyYK!lp&@VFihls=`S1YZ-+-FF6wWd+^oyJ>B!n zv(212bIuv!wQFRHh!U4yV`>*ZI>-Fjbz(rq*UG6DpN`BeC^=_+!=d}yAE~}e4JyC( z^}m~G(s#y#2(w0md+)eDX{XPpWxo14L$~!=yku&@uShGyPJORd#wbtf7O!$ZXV3OD z)0ltFTIgFqe;RDCBx#EKPR<_*;}@C=kke8J1w{VTy4~4 zXsE4Yhl({b+ix_!RT1km<#3K|oAMvuRK}XF8y%)P_o z4!^!|x}8z}qFxF;><*vr;dx{EZ_7n%j(2DO3;nZToDCbh@c$L(hd*fg2W?ABx;|@=}enVV({9{esejYAe*=o z%i_i&Dfh%ouM6c&epMGaGCSYn;#}^JH6UZW8FYs5AUIel7EHPxIO6|YTCS;?wUhutX5cOH1^oo z*3<0v)cvt`e(uvou6Z#eZebUNzS=VsT!zoBx2yiaI|a5Q9flh#txt-Yy24>!@ze}` zrDxx_YMkBs-1_}gi<@To8MCVlSCmh`#$Fb+zpRhXmT%!K0~xO=^O#MEp%He%R8?^VgS!v0CY=dbj^$mp8e-58EpqpS<*W&p++vm<9WL%=5Ho zb~rjnsW$wy-{f~=`+U^0-*n$L{YCSs+qW-Su3OPOqcZwg#8QobfxjSLy{X=3M;a#fJ?s|Ye{g86`?rEaweg!ajZ0g>#_N4Ct#ZIKkKU(0erwsW zos*NJ_qz6W9k;7#r8=5qr4@E@Rk>MWQt)Mm2OGQ3_!f87-d(8F>Ei6WDJZ$!SC!PY z;cI;LOAPJ$D6RF@8gBf>=x|lDD*p?)w}(Z}ZE4efsKEp_&WLg6=49HGdJNH;(m5yf zj-B1qt?!QatnV7VM6t9mp|X4I-+@cqDs_JNlvj`c`L)li8LP%*{nBpv=kesV&z<{B z&aG)Y?4#a+vTs8j@AVp)P+il!{&kDO=SdxN8@MeVSK4cS*t>_FFVA)Ru!oK3zzXyH zA!YFyC)xPQr`!;cPs;F1o&+V)3;&R*KGFxe^>n2FZ}l;%ZV(H`Ym?Nx!?69`}vp4;JaH{K1^0j zmCevzcz*KN1G+hJ71`f=B>LrUoHPB)yZn@xM?+tvcUV!ra!9;mT6D^yX=}<~e_dIk z=sqH)utDRWnhI-gzC1U~@ORE9i^T&YF6}X2**-H%Hpkejug#A|XM}ezUJljQ3q)Q)Iub(CuyQ>=h;|hLt~l1vc`SKI2p0Qy$T4y3ATX>DvKA z@71q*ty!|9X8itVt#{W885}v}==;mhErPFv$CsS=PtE;$@vL)urzzh^YaQ-0+G>Nh zi{aU9=0lA?Z-32Z{<57{9n|hZ%8h-A_Yy)n&lzWaKBL4k-$d5weu)3;&=98TPR7%DbS0W*QG|4izTFGC$Vje|TfsApGp@eHV*H&*}6% zba=e=xO!JQo*37_W3a|O8@m^+TAXjlR@+|clY@Hv@ozBDs^8>WL)2$=oL{Eq-{<-& zozMZM{wH*Yc-*@m@Tc*du?Gj-|1Yt@{6m}D?z3{fyzsThYlC#V*B$!KfB3y@+QShm z)Ea7y+0Y^5Kx(SdAeZSH@7^aXSM)kyq`Ii~S1W~i+3&h#txsP5;LFf=-&E(jOv?Dn z{N~B*-+J@;VSYAQ-gm8*wHy{}(s0I^UFuO+dtPtkSvn?kjAMTEVHXz?hM5Pfjs>>3Oy7>o&b-x39XiZ@?SpyG7OIF8NKOzf^6X((tgO zuBu+ntP{a)HLjdfC|9gE*QHx=j!*A{mr9O}+jZN`D>~y=eTMb!^J08eNIk>VkLJ`m zH)=J$|C}~`C)Z9H8GiDq+NSntY?3IPNDHHhJn zY`lj%9_iLtdt0Bg(XNBsG*(=G++%&_<|V2VzkKgkeMEP`!JV0Bo|%qZ?2vaeK6n0< zKf$ug8uA( zPLgGjEKYplh®-15%it(-^M1Kvtn~vf3v&a9P~ronGC~S?s#kFW~OO(<94u zuIWuaYIm=l>$0_{n=ap0&>=_ZrLNhcEw;(?H}5~~wCBHBRwk$0UD}$_FyqR#y~{Vu zvLA5n=6(0qR%3sh(NWJgkN(=Eu;kdq`!)ZmJ-*zw^%AGgrBi3yhYVVA(cWdnT-n(s zi!5&S_Vawz#J=Y7@Y#=!_4;~0=faAIt?kYpI(^~(+zRVQ4(c^gOvi~a_HVm%mIYtW zy0iXr?&Af;Pm?mD89r~;=j9QpD_E%r^^kPcdtawoM|7UuO~c15R6Dr-km zpXd7VWZO;66OR>MfB%?`IdH^huOokd9_)Q8OR*%pSY>g)J?2{qm!>p76&hTbf7Gwy zSLSTz+UwbFGp-MNzx$3&13jbshj;H7j{H@wWd3xN?dTKpE_^-T@wtNL-^`u>@~j>t#7xl?{D-bZ25l3yp*9rKMc?6bQ; zg9+-M9SojjKIs2OTg@Wu>-nc@$zD6V?0;bXw4jyq$cO1gHc?;G?w_k)6P|FeWyF`! zTKNaw-e@xG#JiwXh+;+pB%wE;`t(!q|;*z0x^X8=NY_{q6_Z2mY)8{K3$&Ieodr^H|Wnky|Xo!O(i`fBsne`SAH*HbMnF1GAFI$t}&uhHdr!}M_dDJ>F) zrI}={$bb5NV$Y#VN-v&VYP9Kvcc%!i#6w@~TSgtNTD?+3A-_cZ^VX=}d)3C6MD~5Q zkBw(Vn|Ys%YaMRgQ{Ha-rT)ZMBYO`X&@f)uGpct*rwO7pTje2-t52X zT6SPz?V@!K6L&anI(>=hmyp%Js98|GkRD+g+Wjsa&B&aw%h%AmajSL>iymmae5lx= zNy83F=Z_z6>=U)-se8w`-gDM@7HO^TT2p&!`RG+O#w)*BX?<{0y?wA=zfXf2e`tAc z_qL{Ob+65tQZJbu>svRsSNEBlPTGGlO3?7o3OKU6b;r_C={*ZQF3t02=S?3+9(@^F zQ9UJgu72cv^%u7H!n-xmF3;90C~jjE`~696)BQpH9_)%SmTfr}kw3y|KvK82{+lvC zls}4JaAw4-E-}BlXHMEwFzdhCxypMKOT!~?ls63B-c&n1VvVX}OnIn!$&pq4b#=$6 zH`;F7_0!dX5n;=WHhd_8sIJx2Uf8z#o0}PLchx*osw``vl5s5k!@zCZ505z+^Wo5is0C^&vs)L~ zt#%99efRoF$K6FI8@HX4kf&^U#x8iU|6AvcyJHuqD?S_SVXtyQr_s5&mYw|u#x+-r zK00;auz{CKYTQ!?s5Kf_rr$z$Rt^O4iUkJtGCx!J+$BZq+d{6@(DkKL{0sj!@u-=VUzIOpvy}0 z{D`0itLi^5J>Gh#j%|2V-{*=QW*jv+y3{(VzU8G2UY7ZzCOv&S)Zkv}q77HgT(|wq zX=2#5->t)^70r%mEy`v7)cH8o!hLDl^CM+5r!CG2I(O>*X}?u|?bhfdcOIKNsK&pa z!C}SaM-*ZmRa4p}dQPdG-0r->)1Zh|+FwT)#b}NGWT7(RvaZ{WqE{D&-`Hj9vvuFq zc5!_ecN6vM^UY#5^W%Z-CxeH6QE==!Yy#2Y$PFKTU zX-oh5xY^h?8#(X2{i8hF_D@zB4>8&NX4=O00YAr24;en{kMi>*BkQg83#;B+t}U|* z^)DTM{o(`d2VrMC?i7Wt+HMrzXxE=@{TGkco*y^j$)HF2f4f=q?6PEB^Jj4}aS;Rh zKli`k_|1PunyTZEs0GIcUNvd3|H|``zOVe>H2!Sfy+$*=vCj^zoaGDmFQ`hI=v)5} z8=peo-mVJ*z1EoI_x9cGn4~v+SEpeLq4R?S4|qEtOubarM@e&g;~mcVP1bKUn0ot7 zN#E+g>&q{0m_K{xDyO|?Pd^QsxNcrz^XHlu!|vD`-zeq00OQ*jr0+?^Yo9+8i zuicA5=__xWCsdZ!F1FwKV0HM6l52^5d%phFYM{-;1zv+Mp3zY=(0Fy^cEb&aXWuF> zzR_m+bB#+MeD~hW`yG^_|G@0={N;*GN9>NDs^Ix~N5I@T^Zd1Uta@uH{II({>CG6u zsCfpf-p{`1ljoUIaOn8y2!|`94ZL=F_fZ?G@UzpAZZkZmp2>VOy7Br>Jzwr(ajx-k z@J-8iHOHd*bhi0?Ks730pWE4aJx|z~#I4_w)TVk=>Xw^p;%7WKKG<`|rl2#WBi6k> z`QdJot5W1#-;Ie)79UvkvE)PCZKsU;!;c&2PLEh+I-yVFBE4mul;66})^x8a z+QD++^R>hQhnRobmR=86y1BUQ$o+zA<>TY_Z#%ZHjmAXF{2n1o7cSTO8^7vGmHU6U zcIiKL^VIORZd#+4W4pt*dT43KJGayWI&h`%(QHx#WC!RMu(OT0^UAnh8^qV$Y77Fe_%Zs*=jjCr?W*Zn$wj!Z3gC z*|huPEuT%SY}z^5;OM)r3olo+Z7}SMzt;{mFN^PY%3JhX&t9uv`k|zApQ)2h8@`Q; zj(Ij-X~V^pe{-8xxwIdh!eT$~_mM8gw$*$Xv^hF?+P0p?2bPXe8UE%}n+)c|g!3U` zy4M|69vN?R!e_!Bm#U?O6_du*f0ON1<&!Yr)yt9le;>b8qR^@1<)axE%Ejl0y(#Z~ zDyd^Zbgq*6^(k77-&NY3J>l@SR98JQEazMCz}J&26Pp^1AF}IIpxcI}U)7esd$?I= z-hyD0C)E#<{JPIPzSeJ7-vys6F5TW{Ya43QZ^c8MPA(^nhM1mdlrY;WDd^-r+v}t2 zCq|i>Zl9I+RnO1zaKl!n$5kHwTprgXGd2H$e`(}VANDMuQ~$}0b*fgJSFzOkou#RD zqp5-aTTLU&d)NEAeA3t+ynvnTE+6>4r`P8p-t1oYG`(Z`U=+ zRg*S;PySIqbl{tJTSE_;c6fGS&FbUF&$V9_@**wk(d<^;n%+}M?>eOO+g>iC##!H= zr9Vt_v;Crl7fn<MuW;-0Rej%?pRGZmhgxS@J7~q%+TU zcS?Bz4CVTzHgz`%$II8Q4>!0d>Gc@mC^EvNh2L@@Vaq}ZFS?N+v~&8zm zs~f+cSU0|14u8s_y5-qxk7asw#KVK@b<6*dV~2Zk;vsK*-8_rs=rdN1eA>>sdA|Ir z8xLGxH@=y@oVzYR=E&(+S&qEL-Maa&pRF6eCC8rD>2=HZlB3VveRaz}Jy18^pS?7_ zuJLY?6K_l9=pS^nZk``cMG$92nV%84s4IpZ~zGu~Zt^bC^2^F&VmhRK;1rpw9e5IOc7$n?}_ z|Kr;sjo@C3B&zB>=T8>|SpRQZaRlDlOkH*xEXUmC) z1Udc^K3GwgeT?MPv2;0g;Fg^FW+=zM&*juNox64G<1A;LQ%{Z`=gL`cJdvaSayfb$ z$%&tda_YkoIdvdZo<4H?6)tBz)*+#8`zXqZtK)Kb2FsCml9PA$OezN7Abhsw!QUpaN@s~o>O z$g$@RIr-jR&OG?FS>5wyrkuKJEQe6rE zqqCxzO{w*eRCerrSX&lm+)jzuMpb?bmu3cz)c|5*f;g=d}~?EhB*o-xm?u z`8A~fWAH?ZD0?^fdGxC!yiATYAHoCrfajn&^fx4YqB!rU$U5b~J5vb{sQ}M4cZ{?x z;YX&S-{^X}A|l!C5YtDnkE`$!O4inj|FZY(u|F5=99{ok`8jMHBL4MXJ4_S(s3Kdw z5c-cMo*Z#qts;AL6P7F?yqg2Y6}k)KVr5NiA$s7i;QH+;)(7^&tAmiYAo(wr;2B~3 zuYWzdgQveD^k<(_5ZhN~SV8|s<^Sq`sv~&%|3o}YC;8uGAD1=%`ejBI>{hD^Jb>ig z8-u4ld!kury$H{WhI~<5#HZw!p6o+bg8lXTq2E3vuWAlGZQlQ@r=LCK-_5{y5naN2 z<$>S*h<>FwKO@#*71`Ucm6UF%;it~nqH;#gy7ljwjv&Pa*Y;(lxJ{8%6BZ!l+ zgf9q$o+iKl)w94CcyYsj?LT1@@Ki2;s|}%l;(xG1SK@yX4}B&D!EVBLi-h*}0r20~ z5dVt-%Z?CF{3Gz>5uTV2`7q%{cdQL3Tv1%tsmS&TFY0HFl^wC=+=6^R_Srb0l~{}a zk+l`;n~LnuY4E!OmR%`;{14$JdaMm3Ja;y5-QM7DO}OwqFd+`(fBkE>JwsrJ?i=CR z!z90o{N5rMerIMBTND!z;-|F+;!qlwHdBLr-&K~fxRog93vtVF2<`0e>cY zChm`^u=o99Tm~dRobcw2fX^blf~^Od%XDOF$Dlu~#NOXX@qB^exe?TrrB23p)fylk zr23O6&hIL+j0)K2I{CLC6!Ll>|FzH1F0fDICLjhId&lY$*rA8;u?NNov&T%*PHfQoFJGxV3f{}5aRo(>`4@fCYz?-hJR z`aD2hu=Et0CB^4!$A9BrRb2n5$ilo4Z_t*#cW@(kre`4UU=8-}#BQ+vBR%LT%{$ZB zhw_9ttk)boL#W^CSn%vz3H@2w5!)#8R|Wa2KG`jVnNh6IAO5wQNep-jwt`3aj-1e3 zw*sH{7J6!szgFuJ4>ymvSphHp`!9c=bnrZ)7g!75FB94%D~#)g3C1hgp`RM?lJ>}p z)g-^I2l(4?^Ug3k$hUC@k5o4dsLoq(b^fR`c)nHrtLOeU;HlY&e%+xa`<4&zBYB9= zy@Z#PVO&u?pt%m=?UI52P(&S&#&uT-JTYIvBgt!0J>0wt`SOK$Vpf7DQ4{u;=7m6U z{i(vf4Fo-3lDu*pG)?EW$A>LXN|GLNE zU;G5||BdjWgTbGr@NfM&NcDfW@L?9#4w3w2s(VpfJ+vmCVvZ+QAN+}*{`J=%%9mIJ z_Br$$Hj?7J@6dw2!D+v{=f|Im^s4ET?qHP z4ZI{Dbt9Yb88YzPFapmg!hP5WHif)CH68YkB7DS9;KnCl{|l6lQ7oJUKc;Z&R#aaN!J}6 zh-dd8=xM{{bqLKbo;1Hm`J2Z6P_SoY^}pjCr4Rm_SK$}o+oeKNqkQxgKKjF&E8HwQ z$0h=Sr;4kqwLO8$xOK?sNZ9R@@F6AEn483AwH|nb6HUaQSvrd?bU5@;DnmTXC%j`P z@KD7#^G8ZBuJ`l{eQn4GzW&!f6R7SLcSU6j zBmVwH(0^$#48zK-*v{yIC*{w-JP~C76wdy7H^CF)i+U){YZsOPZ=Qs4B@@53Ir#Os z{2fK}^__c&PiZ~#mi?iSce%=lHwr7+>+%6INmdgNQZd54-!rv2w-Lu+Z$KJ;ny(4p#|ZEcOgIU6zm*KxLzX~ zFSjmDXA2U+{;g)94*Vp2Ze9XUiB~g`LE`y25d1t!*8vOt~U5O`}EdT_2-qD30O9>x&0Jx(s>IqAK zv5jIAme6l>*}wK&Uk>@T1HiMB?9hwmyJk(mBYZnjXnzVJuP(gAn>FDZqe9DK3Jdy7 z6F$ts+ICvM#amLpoL`K>A^+Y~QIuaq{l0R89n`ZCZ}74p3;eMG?CdE16?=!gJNP5G z_2*{RzcAiNZv8N8Kl+^#3q3Jv_RjxXr2ihoLk#JoSOGj@5F~ABTvvyIU-tQ5d!|#r z5nR7(qrvmM4dUlI>0eCO3qyl3UN#)DHMj=(x#rMkCiQDN5&Z^n>$;4Au+Om8;Au)c zn`T1Zf}7t*IY7S6Zp2$3lD|N9FmOga-%57y9txg3ZoI)Bz-_pFu=&d1SE+%&@`?W; z)tPC+M@3kZ^!#%I<29k{GFCRlW<~Mbz8vzS$PQK{pELjrk{`GI2G6j@=$DlRvHi&e zo_iWR{}HY;3wXLU;t z&;L3A58>8JlPTW%(7xzE;;~!}{`JC#YFJ}xh|PZoa0f&5JC*SJEFA=U`f_nNdiOvl(8o*om@>$$^IPD$yqx_K3(z@mNG2o}VqF+DiH~T1XV-w&yWQTn$ z@rC(4>#mY0X-D!?X6mi`9#_A$^C z-eLR4%v?fz=6(Bjp6${D_Uz2YKk^`dwH*3;l0JWj zg5T-_>ZcjuO-6&qmzz(=xByS&)~n%Df#-1g7nlOikhfABL{m~EdU%2|#&NnL0@>-->-_yL$#KbmZA^QC_33~RFcoqN;stWra(<|WLjDa(?#rB5cBC;P@R|hz4Q?B6YfG!1LF5(1{e5y^n%|JE$kb4 zw4R(t>q%IZeM`**`sZ=`buC6xoN#uor8=3#)x*he(Qotd&|lKW+6_D=Tph5S3EY$0 z7ac|Q$CIl+-&??*-TK0w(munO>ELnZ>fW&H(8sVZuGc;)!$8lj0&ma-cz?2656TN| zE-!lgf&97VEksE#ijzg@z-I^_{A8^O;qxy7Kh_27kk;aF*|!hr{z%3ESYE0pZ>SEO zqBS^G?NvV`uF)~0~RkoX-~f(vo(%dM}*vGO9|A>6*!r6}+_|3aK- zDuAdd)q%)+uyY#m|7QLY;_7n;$otcH*M0*&a})e7U1yareT9B4IDPW&L*6eRaSN-m zZ<^6{_mgReShma)TQ%!W;7R1-XKgNcI?;#6B|FE{b#WGVUHl*U>#IT&k#`{3^V~}C zm}#RfsSv*G3UD_A)MvK57u(Gfz+VU-uVihI_%HiT+-2Y`C&BM-4e^Wi>_S7Zo98ar zN3e^~oS4GGxKg?6^dzc>waMsLs>7G=fv4&$?B*-7uT$-)```6XCTf;Ca#&aUMu`@Ica^+gFcM1y9rF;2A>lsx)6* z*@?JiWle0Oq&zAIKi$5S?F>i17c4QZwj>{>kA8Ew>!8@*knhRuGYmTh{74u0%ZGU8 z=z=GZt7HBwF$KTKxb;9sQ;e&ZGW6Fbo}V?~Ula%bb|kz*7x1KT{F`VW@;aS2km{sz zBzSJdV!SM!#g<9;S-Nyazmgw6)B5L2XY_lPDE;%Q9wMS>?Hqe>DR7Ody`)^~i2qy^Uh!RIpnLS3f830#6G%kC93|k7#}$ppJ1#b*yVO zev<{K#Vd54+UPq>v)lOuf=}5LB6a1D( zQI{Nvf7NT?!|nbZ*M&2{y zC#qv4A9MwHh(7AlbHdB0e(rCD`e{nIKO3*$FULaQL4@C93myS)7>oK-N%he6G~}J) zpl1Ndr>q9P*9bflXuQM7Urya2FU`w}F_2F_0o;Lj&L#qnSO$DH;lA5|8+M0BRug|| z9`MKXaa#9@$6pNKe8~jRL=n+dmvb z*Kt4S+yb(jeG@nV{ChURJ{TSQR&7i0gmBltCWj&asyQV6sowyWXhQyGaqB>1nir;< zp+~7+x!S;w?>lOW42V+pEm2n31^*UkA)ZGPf7(~zix)vsTL08jBYSdoi`xKs^VJv^ zqJ@2%mnE{G=Ob=C6S5xiwvmwkMt-!t1-#2X<{;Me8bG1PL!f{2Enp4?EVH6IdCds+ zk=8$x_JiknH0G%o;(68_`q*>#*A~+{b|S4~@mK8o*Itm%pARiNO}t2hZW@AIXkT1PIhxZJhSD5*t)mIcpF56N4ky}MfsxYi}B7Q`4^_(&*AEc z_k8esk3~JaL3Yl*3taysGYD&~iKpxUaGSk|hf@5RtYQ`LxGCsY%Ey?sz_0d$AK^82 z-jF#+j8CrKHroXG#dMBKij#2^w_z3-FH3*1P1^_gL$u$^(nM_De}E^n!2DuN_;bP^ zwF1uEC$>vH$UfYD$ba9!6TTI3F3m?(1;Et@p?&3@g|(p3A!wWl@Im%$qqaf-2D;%V(@(Uf;e|0c}1GX zryf9@FC|=!&Wpy;b!!=o*LWj%_HTjR^q4<{b|3`(26Fvs`vJG-_5-V_4m)w@|4sTp zzJQA>=a1<3@l@DBimRn`KUcp4kPN6J>pcTJDO^14O#;t7Bls~}0e^6e_C=r3zGxWn z%rJnR!-^2k%za|ZI|rUp;bZo!{UZA;q;+x{w@z+A^N8Af=s!mMEA~zFY0xvCyPhgw zd_p_~a&c=k4EQ4sH>UfHpD!Uoo-{%SE*&5*hE{Od&c zDmvGsdmVO=>iPF7$ls-XPEC@ZxfA%I?uheogx_BYd@`-O>3fxPitNJ{y5kS)lCeD}VG`20a};-mvSEfhTLvP*2ss4lIeb3`_TTOI;` z5_iA56J3wgs=@LjNZy47m=HhqoZll@f(!cGI)DjH%9mB^fM+a#-=*;yz5>3D_N(=Y z|F}E&Ex7eVK_ujjHh{k`$@j|!eyML$5wRwG6f?M>XFN9_Mcff^cHMEWohZq|Ol&Xc zx-x<4p5(7Bw9mHB7WQOeAhv1M=+~aE%XA2D9EyI`xOz2)%}atl&fNV+^EmKK91Qzd z5|5c0{qKWE^-6P*SK^Ni2fmN?bJ|e9@Am`WdKK}IM0s6&3ApMjfv_;DnN0SHE${^UL~!Sw@*IH6IJ>Dj0axSpf3_?G{|>sJ@}2bg zo(lZ)Vfe*@@TSZ^Lch*jUXOJ_y;>fM`2|rblQrHAo;VNiu&@`~C-S@VGvH0hK3iFt z68L?&`D-h4w}9Jl>m{>f@HbTg54r7Y(jY_%W{k4LAq$hX&q<$ItJz|P@C?$KE zXMjEX)@ZpRz*7 zS{~JzZfpZbz&m|Ky=CDlw&yjF@3I8?({TjZJrl_9sDykO(nhwKDIn+{&-qLJFnAWx z^?m^H7f_vi5f8se_;tFz>pOu35^JnHicNw1uEY5~Yy^#$yY9F=9k@2No)QELA~1 zUMKz|PQVrD`Bqkz#pc-y{3aZK4y~U*a_i?AERhBMjcNYsLOk^|fJZ1H6Pa7Zw(A0L z&HAW&Pe{JD0s2+u>h1YK!1Xx4uVD@q?68g7XBc7#Jddk;Z7b2Q{UpSjbX`*sNb+1g znZO(&j7!@Feqre>wwLrg$OL*G#FTI^nl~?U=MBD)zaqH%-3^KVa}V%K&r^JgLccZj z5cm&>Uy1H-Cci>nNb8wWR_+8lgm7_~b`d-q%wXqQ;`u>->~4a*Zcl#6^Z<`GcYTq~ z5?18r_UkTF9f;@ZKzbqim8GbNJr1Qp{KE`972N(tBCVI64Z(P&`sqj4DV=U1ZkZZl zOI`y0qlvKFX2P3&0-i?eH+RAdDev0ReS}ED=PM!pwP?SQrMcJ|egw}xx_)d=_z{Y$ z5N^IZ{~zQx7GpiIh2-bf0@tGJ5o^L#sZI`hggU9i;$CR$9HCG20XFfmwo?38Cd;OC z+An(n4L4Zhx|8JoeR5yZ({($g{=Jk!kJuiIpY&%1zY(RxXew<`wzlFn&3 z5Rc~-;D&VnVld&4qJWS63;r$j@rxgnzmZ)2zFPzN6bp>E1Ia6v13zmI|9X?2>TKc= z?a9@L!!+JD85nN|(#MhFv(-iDvzKsxwq6i;WL*7^u0X#P^ge`HBp>1e`FL*se;Dzf zBYtK^u|?2+&ShOTv9h*-@@_oIPq_52J_qSOuNU3tmFi^MGeW;Qvb=M+-eiwxi!F2& z^bDu#acO?v8Vo(FI6KGF{XQSM-^a?M*p@JUVct2i9eKB%@b~M1=P!p}x)QEK>(3oQ zkeB8)t%2w_kBh^#!-2bVb!^2J@E6hjEO=Qavv~x3GdDLj`}ibJxWxG+(E1 z^YxL{;L)V#^=1=~%YNX#bX{gccvDmGM{?JXOD;p+bQr`aJeW9h2(7O|t(n z&i;WnApgfxRb+TgJVoq+QLtw`7yp9-fbZefIXka|r|DquNb&HR@=oyp@{XBZY$t5N zW6#B5&*R|HqWg>zj|t^PYqg{OLwkBIQmW_Mu7GEiv5LrWi2VC;AMjfXVgF0Szk&8$57UJO+x`;U zZnn`R*!dB6F00xc`sAyi!n1T1TlPxu2Wqi^XHCkB<)Pql=Hlm5I^>UBgg)%{me^*G zf_yY*&!!6@Z|tuq%7s8&){gZn)F>J6SE3D`oz;b6L=-<+tYGP zHjB!vMd#>x42IoI3Ge(1`t*2$2xRUSn*$&uqJmH&Z-LlIAaZ9t6 ztTGZj*Jg3lhOTXGWpllf-jyG~~Z=*E_Z}zkDfx zKE@>9gzEWPZ`AW}!cR>BPXV_cTfPJR+8M!~k{#;Pc-MSKga?qF<7j_lupR1>BYmvserr6P6BtJP0Y>0a=KLNw8TfLpZa<}Ug}w&-&W_QFEp{8m zC8PU>JE>nkriS2`5bk>X2HkfX>Ioi6{tm^%E!r17K|GUJgWt>$_FqK!kh{Qj={;0Z zeQ>7ri5jg>r1<$xaUQ|#N8MqL5aMC*O2mUyAMW)>U3E~@5_=3m_p*s$7*{bj-(@q! z1fG|~<4bz#M*|~@Ft^WV{a{(X}FlMDHNxsZQD_=4NOJql50SXzm#8^xjV zM8u)A4!QFV@?YtB7G_4Vt@;4G{S@RQqDv-gbP)KQZ?L2^Uzicz;0Ex0aGPw!GsrhD zhsD?mSZvu&u#YnrpAFdsvS6Q1>!n zTm^FVvwslqceuBJ^-eXW~34ROiI`oJ( za2swve@s8vVgG(uCWZKy+X8p625v%l<8burVS;{pusSX@|2x1>y+i!7Wt-TxA0v70 z`K-h1fZw9~eX09mE8=#=t1(`{)4<8$w$+8?^qxXR}j7_5q$g6SpVXbLD`Gza%{4kPl zM)Q6tU03E1K2fS~-1S{wb^}Pr_vm`4SLaB+{$A+QEdcZWal$*(b5&{FzP&ZggLi0O zeGqqz^sskZh9T=oVc^3$ImJVXG*#Z8I^t_K$ z&o9vao_QwnRKk1FIgoYA;ISv3tJlDjVGTVu5$^I1xX}dk7)E$GT~7_=uBU#6!e8;6 zo!!g9v)mCpQe6#W=_AC6jN5;+y9)W&9iUGS>i6PyL0(5@$gQ`P9zkA<_6@?Nanbr` zo;t>RjPSM_A-|B$3w0v={6*la&5_X3^9vMDLf-C;3}5AaBFn_c5aUa&m#5Q52ubzK}QM^7^_m;&ab8fRmdH?b$=|7JAtDDnv8O-crb0WW-Ob7pb!W|r-j~=&f>242wS_L7$`jh+}3&u;DtCZ z;^vo$7og`ux}JSN^X9{8kblJ0VVlK}&!p>abLzKk4DjCc{+6zUpCNrJIDM)gLcWHc zche*JZM2?|aq+N}`BTupg1atoXJuc&?YVuqg9+eIrUCyz=SHM?c`lnc1Rh`R z`fJB2lBaX#v7~2VW7z);y&u4e@Y2!X(dOd6(=PCIaYQ|5Wm9bPSUnNze_yO8_fy<@ z4+8%Pf5gLkl0O^{`4@EVLXYssk?2>M+s9C(=S(+ifJfT*5RN$s<2B*pVFb+=iwCYk*ZX$Fla~$LsUPxPy579zkMVxvu21b#A-|2zsm>#w33NW~_yyFH zAi{663t?egA6~+qEeUVj2mD3c^@}<2w|k8B$#0TxM)9vr?^)_jcs-go=cgmDrTF~7 z>X_&+uI`Qw<(uR?!~0nbxc_Qm~iW# zBtPh5$gT6Ae+JLvSs2%P(ti`1;DkJK^TqWVtjFFv;tifu?won=myo~H7CcfuKHC6% ze+=>~f%vC3fWIPBp!jg|qq!CMtGNBE^RAG;NAF>4PdrN~kCxJV0(X)<53_Z?U^%Mt*H3o_n`|=MI9T9^u|J?|09D1ul@Dm)=4CIqkzpah1z{FT}Y8 zH{Z3P@m^bo@vx@Ood_gSi=|S>FCBSd|MBNxhxPK(@o9m#b zQ!;k3T07Xto<6#peQ(8rxye}=JTk`NEyxVrae5b4j&JF{rLv9tv9 zngR9Ohw{BM<-1gW4s-)g4wqlvG#_m=BqJgRg(zL~oozr_+tsBcQd--zUER>BT< z>74%o!b>UMb~I)KWbGm08SKBpcndiHE{F!txJ9rV3qP@$UIkv#2Jy3#;-|qG;Cr?} zeh%?pr@Zjw^5Q-1PnOX8ex-HDxoYrC<<5=klifVIdHK~X$UmdH7fSuk+Y8($5P9*M z@N?&Z@2!EJ6A9lyb=ZK`Gc5^UIScZi>D*dtNuJivYV`hrYlJVN{jpcHKbA!J{Mq1{ zM(a;A!e4I&K9@UJd4S!>6Z|{7GvcZ%$tT~2e1rR_dr^eX@_`>sxOpvxEnEfvDs%U# zgPQ;^;_Nw$O*ex4BW|73itJfV`$cToBeooh!#{LBS&GB^loxAWLVrh+Pq`2MZRvdu z9S9%s2Dmf5KMK($lO694JG|u9X}{=v!saOOvt^#xp3*w7{z&8zOLMVh%?1B^PXw$~ z&*xB{x=Sfn&szLF=D-wEk&MxJm)|-MRP4#}9-(6S?cYi&TfBXJe$3 zF%8J9sqVG=1?JwwpZpa3L%H`h4`%@^_$!c`A1%&7KC1|E&eBb6iDrWgI;8^8_R*8e+d3=4e$r6XONy;T-76e<|aVii}**d zABAz5aQ9EYyrX{ov96H(XlM+1XKo#?SOodGbRT>e@u$;%+PC|#vnSz|w4Y|LiMT4I z`QqU=@C@nsZ~d&GIEkd^fHwxWkhV>_5+{38+A!K_tlc>zX8>M7m~k{ z3Hc55erZ#}?>qqh>MHctA^+Aa0A5AU5nGe|+J3N)8h1V3KN9ll@vwgt$w!AkKAM}S zs#&55bt#9QvtVk7?eA~k;Z3kU)F*sOGH@q)Z!<>C?(2Dj{}C5&7j8h_Y8(uCjK=ko z)<19Qdo*Fh-}M0GztMT5FNEJg4EwP1fJ^!tq)S2fFT0ng#?oF8ZUu*|hITGYUxOrp^GoXOS zbL;T<`p|#RRODk9iW75s-^h;y)HgHYkEi=JgB1V8%UIzO;&UFoA5~ia=rXqo{c3af z3u>9U1U!N}hcJ-*_=xjkXbkuZXkXWY^yyFM5G?2%f)t0bOaX!4g1hf9_9S@p=)JyH z#PgZ*tIKKRR~y1-=0Lu+JK|HyyPL;=x9tXe1<5ZazxS$y-@g;C`3myOI>1v>9Uhem z{PccQJn3B1rLVvbaqqPlM0I{?7UEOSM;k$@8Ri7_)gNNF{jTu zs)y0syxfe|X@4A0H~ya|gY?vd9TcekpAUlHqq+E3Nr1do94k<)MNpi7VgVz>Nd*_5 zJq7~L;p)S6x*z1mJ-;)cC*-xc>%kUL)N%*yO zz<<(tfQ}@;Vh->f^q#JHG_Ko6fbZ4@&rFh!C;f+wfCrhF*mmuPeBL<3VL9QSN&i4j z|5#eL@1^TmR<6ZnNc+-7cfsF@{4)0i_}5k=zdDh8E$v$_Ci#|xA3X{Aa(aKrL*ntE z_}SYO@nAsmrX;_@6XTW6+t(xidUDt4i&#g3-#xi=?7_@_0v^cKrNPt4zudgD!V9>J zo9}+ne6fO?FP77M;YQzkV#^`1Y3d-^-b&a(mEI#KFk3c=Z8$d@_`%BcjATumgzGG3HEg6_CuT~PD<`0PR5ZwIXl4PX@WRhOgvSrU<&;XS_=C} z>%Fu9@F#Nn|6d(}XL0xYa#JPQn=zf|Xc()zqA75X?+zfEag*mo3h`LX1+ynZD z6F!Db(874T)B7C8ihm`OX|Uf5_Nn0Pf0Fc3=JeUWMUdB#+0#BhqKLf@oT(x3gm87K zZyx$R^#uBqQ@`dtA#cOQTMi2kfyaWoPPxn$tX|HRgqC5WJpGIxJr%NN+8 z+dSwa)yZ=tU%|}_`zU{9-2F`}s{fvxojcQf$?GW=I%TAvcMDKYBRlOegyF=y+gmPeKFn$!dJ3@7wi+r&3C&f&eyg7H_n@w zLEeUo&nFkbpV$=_G+|`_+CRX%wg!(b^_wsfJm0u}y{NuTrTSKFh(9Qg2G0RHFTId> z4wL}btcP(iH;L`?Yv3*W0!LJ^=ZDB&iCo>dMe(+p;?0(Ls{dnRg_M85Zc<(Kp?I+2^6}9c@WgZ1 zkFm7Bx{dZ%O-cV@EC7T!2^fet^q_u~$!@wOIxws?hg4Bu0Hg21s=%FvwtT7cjm5Bc2eC?=ITaPKKi}Heb2YSQ{eZ?u&!Xk z7h4-^@PFg-XlE1H?G~L6w;}m>+6T*>j7*g3?VxnLh^%{xdeF&ZawLx27RU(!jBgeppfTW@GSR0{BI&XS5v<4vWNYp`&L=x$7s%v zj{fLZnX~ib{oo&x1U)~pc}{3OwgLCCWCLVvocJ%hzN5S-Z1-=y-PH&DiQM^_>$EPN zyID(QNF|;xUXb_X_Pu-e2OiI@d&_9O+LpT?-F`RpwDg4jM~L4$2t3hTzWASq{Q8fu zTM7B)Yzc5zs?RL^#MXlLXHxsXFH&4JrhKg8^1{*y{bq4?_)X_ej?z8=O9!znX#{x- zZave4-d|V9y+`zAH1v$2=V96Qve?{4gU5vP?;$pEi}A^=e@w;#&*A3lp5))_+`4g~ z3gYuNciy-ojq8~u^2L$#d1nFsM9z;%i=e+2?H92$5t~2dOVnie@d4qpSwR!@&*Szt zHkX2@fi~)YXOd4o3tYVr{>>!+zIy|Fg%8OS{*v+~kjs~Q$&k;Y{e0T~lxeVy3qc=G zPX3}1?9=cC;$#o$lQa(UkGMK~g~pZ2jVqPzLut}|s4m14Nb}mwR>();y(dCzbOCxM z)ndGCJ4AWHvj@Zg7 zfw$)N-x|BYJ~nBn11!wMmQB}X{n{gbl!Bc3B@gAc1jHP|TZ2FEf zD?4JVxdQoSwkqP!TPSYN+yUN?-v2;REvu&p{iEMt-eKGRV$)(5+JgT2%7`DSKL0ob zp0-M0Xb5rH&4G}2XoHCAW`tj~Ciyt-{fD;9utL1$aP|2V#s4QaOqe&QgLOsdw`;hX zNW72ipp^o=JDp$JK>Bn`1U`v-uI+08`id8XF_l*GmBi`>PAYVw=7sxW1Oe+$2-?dnuD3M>reg=M+-s|E= z{4Z|!~^9E4Y1+4c5q`CEWTX&;atzT)moK4n58KLr-7Q zvlrFX2DHyCjwhSw`{0%81y)Y5lC!3H6PIlh~$>ggz$RdfS!qeLv+p zyv)wqvk5}5kBr;@%%i&M+XMXcn6d0L#iuTPe@(jXR=tPu=FW&;eqMq+lGYUs*+eYFl{@Ww zWRRY*`rvuQU4I>?^-KY`o-v@hnxYAQw!I^^t85?w|M?Dx!${(HT8n<0uSXt9`KU?v zcS;9=XA;RPkiV93^*NjB|0$~f(mXzv;@OYlS;B|+#ki`tc*vr8a3`&orjq_fGa#SJ zUEev`0oUf{@x|*gu0(n-4ZHm(Hg&S|PtMK&bP3z5u5QJ;LX%ph(AmE|3~}J zXUD)kn@HY|^o-~93>^bKPgocWaiYzwqmEuezr8%L;$_=|Vkhqp= z$lUQ%-_!}eTn1d)r<(K?JXH%&f6_>wAXZ>SJ8*ISxe)S=E~to-jYvL;?ti(`c?srj zu^EJdr;6M69#jGzFFNPO(qC*l*z_m#Tg>HAZ}RULPxyBm$p_?sCuS(@A5Zv@0pQ8w z`nB`~UdgQ=yy!mNqihxctg&Uk*e2wG|37-}zL4x3JQFNzW1o`jWIifQwfG?%z zn=lHQEag4$ZuH(Wck0(}9q@>Gn17}E|E>?}#v;0|>`L-0$zN)mzmmxQ_T2f9#w;!b zJL_@R>FyrDow;$M!3s_*MbRlka2a=k^GWi4t^#fwt#Zzxs#p?jwSreVc?B45w|Qo z#kPqp*hGFVZm*t%{Mm_+U(gWpb04C0{i?&xFwCZ9gSD=W5s^(^r3T)Qrz~Vyl{Pqey>o!YZ;-y zZ(ZD6WMfGN<=cNb!7?{h`2b!PU>_v>uC~_fkshvD=yG_Z*!smHc({ z4sbWR-t?q?mn;T;hprdw2~VQ+_Ow)JQbG9Qn~+bRhIN_|;Ts+TSEA>0ku@^ecxFIB z{}Aqe-}K**|Jw-hrcXRhY=I=m=W+WCQ)ffowHN%NNAkk*UXV}Z_Lu(l0ItDZKQ4O< zp6>LW0`$(_BTCOh86E{PhvLVH_GgCB{>)hFw}cH)=r@(qbK5%b=hFEf$&bS4Ed+TB zZar*h2V9R^U(F`}&Z6fBt*GA?^$pg|>yu-YM*};lqiyQ!Dz;PJhzhkn*}W<#jK@(}#j5 zm9s<4SLnZGAuRctd@*-@*GwPwF{bk{IwXIx3Ot$IbHO&F!1IlpFD9`Y8AASc zY{DGP8tYDMv#1VC-whXm-=goIvSqf|!jF->1xp0hr25(U8SoVD{MFqvz`O2)e1P~@GFg8X_Cg+o zaO;`R+aPb)OIehRBYDqg;1N;a@g=+)@weUzoRv+neWLoHMB~Ehk$vBD82YW^t~;{! zf3I;z&L8Pq&5mGHj7rkyWeRwD()T@g5w5-!c zZqPrPTd($F7sx^$&7t!Tdc?n#;wqI}e-2^`X2HLKTph@y`81E_Q*R7g77__P-*e9o zj$wupcx2qX`GNL_57W75SJG$ZaLD)J)&l`Y!N0!);)In!v2|f(R^T_`^7kO!Kl;dh zx9G!b@TAlE2jN_i(0o<`&(MG&a{$Y7Zv*e~Kutu}5`L2G(0U@|brtZ7Z!|Bfu0-7~ zX$HLIX7HrWg#L#c03Y%I_@;vY z8Q0r%@bmZf$XGYj~A zfP&(l4z{g@1G6PW3GC>8||A)*|rfI2q$u$h;_` z9_VMNb#%lpppWK0e;vyCp6J!~11i6LY%l1q=J(ho&9h56=5GU;zd8BywueBU!rv8g z^tMC%zu{jzR}yI{Sv4T&vphGit>#4&u3xqfDQnX^{9kGXK3VE~rzP{5tB1gDWjfg9 zj)x)7&pW}VKK1jBBy2{Wa%$hWhg?iDetwjaCz*a}WD4e^BTsG84^i~@eTH^te1q|o z=Im03@wD4U#KA1eIp9^$SLgkZX{3)7$7ST)sr*B%7`(w_lwG|=e-fkUPyGh|U#a&y z9;gLA!&UyjHWB#$)PB?h!+e6auMzC; z)qepWv>v$QH>&r-xYSbbmCtz}^v}1zxH#`Eo?Zt0z6S6cBgy}_UBEvp4Ugf-vz_~F zzOC?|4{%(rpx-<5EAR&7(@+ARv6I{mz&8<3YzzHtRr-9Ger)V+$TNfd>l}wXFYr5u zj{iJ18hk3N{jsK^STpVsD!vbk2Yx`|?cW0bg*%{saU*uAR1Wm9DjzO70s5ut-s67$ zZcdJR-@jxZ=#OoHKjbx8t0wOW{9NS*yS)``x8gvwTVJgov+0LBC_ntDY-k%jpH}x> zFGzQc9xTPDYdZU-=Jng0FU2Y^9b6Iow_Jm9L@z9>CFgHn&R-|q{YXAL6`%X~UA}!; z;M0ixy&@CxTu|}o;vVSjpN?p;AL-xVxz9mT;=UYIggS*#e7*$`a-S? zYA?sQJNEh6P2e+G<&!h&Ko55wgZy>KXCn2mi+V^RUW)sW#rH_ymh$eEsJP}`^y_pK z<`+K`Z=E^|d=lS}P5`;pQ4UUV11mN07CjaBh_Y&397>FxSh zwyW}owY`APQ+}gG8{kcqoX>s)dH&dnxYm$zR;B-Me+c>+P5q=#0{tZJ%Q<@ZhU4`d z@2fW>pQAaT|A_nZFA%@70QmlfUVnZk@2m9SeHF)lHsbuM6odIylYE~01bnJ-f3FMi z=0affxkl|HO{f1K{ukzjGrvBg-|M>`{AaSiZ&!u=JUt8aGE8=Phx2!^n!kH*1^u_* zf*!M2KFhfka-J9neHM|=WAxj_DzAHu`F4B$?q?^`U+4<{m+^e|e&X*|LVtIv{+{Q( zxJ|rg<&2AO5#+gbE#^xK`OFnPTq{405;IABv6SKVpO*DYDe$ka;@3>(w<#krzt)ic z?JvQ<@JHB{q>FZmdsE{ad@<-pZ-6{~iMOqe{*G7yeLDA=YHkAkm;>c)$~mNe zVJh&Wo8dQPnP!(0KFI%y%74Dv2>Q>tFD>biUAl`I82g#5{J`JjQ>gglk$$+MFP;tl z+uERCSJN-8>4$!`;dfwavE7C1KtJwp%nN=7+Io@aycK!Q8%cWKe$Y2k>!!$#kiSI9 z^FNt@#y^kC0RMwBuBNPDT&U0cb$0-^T1en9dN`)eAMccjY4G7H?)**qNR`jOLjMz? z{LiBsAkQ1aF^+|7_bK|@r@7DR#IM8D=R>@QoJ#urPk_&@{GFWw;?)@!dc6((-$}ei zB;{A;#;))dOLU$hyPUZt49B=)VMTfp0@C2#3?ZwyFB|k`0VBHVss<_CjDWDRnB_j z;}>E8hW}QzejoTb_*7H(g@%a0hQ2`MMJqTjVw4@;EEC_@VV41zr(-E+MKJ@zXRyk* zBhrB%Q}#2J_qcYbdt8b18`rLe-`K_eUON`;rr(Kn;f*b8O+DzL-AT}Akbd>UpkJ~N z^v*is3C6+e9tZCD)hziRTYk0wUvVDz{QMW}9HS|}!@~2Ocjk%%mr|YWmTd`nZdLcY zmNCApWPE8#`enDH-3XOGe9QiJ?f^N_x}@2isZVuoTcaKMDE;3Q0eM>90{ukNZ@jYy z{kl=*ym>n@l0iLm-V3}{XPG!sWSCHv0pG>@@MQ>BnFhT2VYKVS zue%=uzN$9#JcINVC1Ei7Nm27L^#bTCEQV!Dn6t|v&fiEy-~TA+v$@}uNBVjJeHED9Oqq@ns+9?nf^wq z{JH2)$dkAZ{cTJBKXe6sp~|0Ey$$+-zrk|E4D7ON1MsHiLuXQ)xH%{n`1{Qd zRXPj&V^!W>h5qC&evi73&CRlIV*WYwQRu;mgHJR5#;7=Tx&ioKPxEzm9pE`olky7$;`I`DZvfPN17G^1awsqO*(Kz%0gy@^(& zuUM1vtNAy&=1bN#-^N0`XenN z=XsSs+`)YQiO;?Eu$=d!Qg}bAGWmS70{oK)A>Z3f{FbkPH$D&l_7d?zQLMdw9|?Un zqNAD2bw_R$_`TOC|AdL4k4_ZDO1Yyn7%f`^ye{u^4h3vg{So*JyoXkU_!r!-$UW}u z*L=$V);*AaE%`s~7onKrh2&m+~_p&!np8s6$_Y`Q!sPfzQHH zpntP25^1htoKks8cFiV}EKF#<(o%@!OhS}v5mZzS{9l?T;Ph z`OZ%rAfRawwor3GV%}p7V^t=HM`s`Zo%lG zsfu?~B+whYK;^e5r-IM)SHR~p`kA+n0gwF{c8gwHR>L0PvqZhGH=THl!n-U4pI4v2 z{Cd~f2RH+K9`hnGd%L{968Iy0zs5)WRqC@y>GKc9ixL$t9^3~$qZU`NIn1KLT_zL3 z=;4C0=SK$vFH-v(WtfkR9R+)U*R`x?B0(Rc?q5AR9_`-F`-;x^){+nYnDJ`N-`{~X zTGqVjpudj!^M~y3fZ^a@PTiMVT?qPjB47`WzcQbfG5y-A)`>6iUUz+UZ@)9wp?QNa z?s9x!muq@M&bm41=}nX;vJ?29SN6GmBjtY;ar0-=Kg#(sVKyv>*I%p}oxy(-_jCG@ z{-?XazgXpm+v(qqsrB9LX=wL@Bar_A@|n-|+U5MNZ#?n-B8Jh=JoVmpVGQsYD!y#} z6#P$r4*M@h{Zytt-{N<8o+1A}%uilre$tHig0QcD0Lm#7WRU zQVJt`k?npee;fIms(A5zFUqgR<+&p8`6OQ^j+Bo%udi~?G8VK`7Y^!U8b}EeWbGI+~+~Rjo+o0bjU7WZwH>T4R(GUuyunB zw~;48`T2j}2Yvb0$j7FV&#(0Jck9DiQ~uqYcQcfq>01o?I=`Yv z``K>2zTjV^=FuaJQ$H|H)hGR2;x}x>csY0?&yRjw06#E?^fxAf{|4nJx1WYQle@!i zZz287tw3L_?CnqP1FUL-{thDjMvnVZ{{DhIZkJ69z<&hq$=^%dmkItcYX2>NF6e*c zd*a7PzvWu^pB?IZU)e8#zHDXKTSL+x=RB%21M|rIzN{(jazWp=Dg4h7j@MuFfJgGZ zPEnU#x=sha?|abiA%5le!2jiWqL_zWGJ2t33)TEu91Xm!nn#b*Po7uvch3;e?^O1a z&hv{HAI3M4{$XDX=qD?GSm!gyx&CX|+e*rry9s#u*JAKe2A4ub#2Da(>bs`fzXSdv z@9S0ox%J&>v|Ft1jStTPUa0ml>PRAF;^`CX;6K-s&&@fYk5PGJPs+LN1muL3%6<4F zkmsxI=-0!JJj?@MNCyA0#1r~}f4;J}bmkk?=AuV^F`cYv8E)eTEak6WIE8lSMSJJV zCyYA{d5@wh+if9^(e$_Z$B?HE@x`;i=S$w-UO{}r6yQCV(%xvFZ&RN0YX5NhWYG6| z0`yVj)A|DNxJ8gNgLsA*u#xAJ81%O{@sSS#AEwT=n=S=Do#zo5)K8s(&`&va|DiX> zeXkn#E#H98E4%Q+6f=?lTr!159pLr|jBh`AX`yCj^H`V=7@UG z@${^C8luy7v^)TY&a~#J-t--%oeP3dbur=egRoO}8yWmrS z-@UI!dE#k5mH2y1ZxNrsbMOaw4(`m0#nKVOzrK?5i>Bz;RNfmIOg7bEwuev9* ziSw=%=bhtclAZYCkqp#^2ysDxR*q4tlti->DGuu*-Mc_q(9(1y!F5 zd3N=Jo(o7HO+9Sj_hFnkGNcIf`!geK%KJ&bZVvF0j^Kk@%PR9f;L*o1zMDv2lk4=E z=0gNhuB1JGbrJM0s`H%_ve9Ymp$z>%jQx~lJxTpPwh3`i!kk?m><#^-sCDA*8-SNn z>-SaMKWXp^;#UVpp2nabtoCziiYqkw@2=)uO%crCh1#zU1l~&BuRg=`sYCqzphN6e z#ti78bT#PHi5EMc0e+?x?9<6No+<H;er} z*Bx>mQ~QUj`8}3p>UZLb#)404b-q7?`!jQgz;8=fx642g!|10-`Hk+J7eDZKBprL3 zbOiiIyam5ki+mQ%2HvIx^iz-XH2)vqZ&rdHq&s%GOw?uCovhluX94K1c+{)s(oX}w z{2J(aFZmp#o;Q38{tr`cCmsR)TAs5@__j;cI%u~<<+0W1&wKNCODmB6@K*5oy+7jA z1oEHoJ@9Qj@55}etQ{HPAEW%+Qw?Ab<<c`j1fSox7MH7OFV4`!mS-0Pll|8??)K zF$}|}sT#+b^kcjGpkI#t_n`ehK>L?zYnLe;mjX2||InWtdmZz_`9455VQAVtuhvHe zx3XUAEn7W)0^Wq*55erVtSB)jqi0L)*Bz$amg@w)VfM*=2AMd9zEIii zCa#+fzXm&8NO|s$p+1#={%{%O`Gnu?f0*>&NjNb4TdDn!!bZUNs(qeK9bx~c*GQm| zGLd{zdV_wlibrc5ThqJM!Op}VLskX{A>yM^i=D? zG;wGqo*v}=gu6)pBJ=!Wa1 z7bmWL`xfZ`H~>4@O}|&+Jn%c!`{~j2|L;b_9vpx8C-s)hb#XG~>@@*=UgEj%TJlem z^@kbX;c8#>$tOU+u?Q=dd5kaDybAnrzJIie{LN=r44<9KFI}L&TBGufb24!Z{Tj9I z=vo7KzOt){O@SBaJcN1dLwvumQuf`oHzvi-KN&v zb%z4qtJc@GH-P^i8<4-nlK+qFSNkO3&i&_)#POPT_ol$!a!Egt_W&Q{d$_j|AIg43 zC_A}sHTc{&33^ybyZR^w{n}OlKX51cw4xvD^90&$OFWL?; zHpEBq-swhl?{pFEd5MarPd^DhZP;HC!!AE_-Sjf=Nwy?jO%!7EGpixSE1vyYL;D=8 z?6c)$(9fI;`kCZ2>m%R``F_Xk#Ge`m`~&_@WhC+H5;*MnsN!kYmq6e2Cg?4N^b<}2 z?-vFA$Tp5$dVK}FnD>h|k^XhAXLqReY%JGzy>Ek^Cy@TG7s03db!hh&;*GfvkidO_ z#>7XlUpKQ~i;34{yG!`~j;PTtQ_q6`-gwC0j`%ebfzKKPeM)*@m$$jUdY1dEJxPC7 zI%vjgtolA)VJGNwjfy*MIqw$z4}LhEd?rXBHu^7CdC>;u2}iyJy%UfAuFvsO>xEw_ z{~`7J5kH@VoPXSm{>pIMC9@;=Tu^cF{_&u{Fa&zQ?69mJ?*Mqbw-UoJ<8^*L{BwWeH*uXc$NT_|6enLD!}sIP`haJZ#shb42cPAeV4qI| zwkCIgoDpgqcX3=gaa_b**yU6O(yKgbGxPj@yl=dM^uN;nhnI&v)FvLY5Av+-FASyh zBR*TmjNS@Ve5`j4^n3VT1FXWbZsob>8NN5SjeHLB9>{0>E`dYeItKjLsJyObBjEWe zf4e&l?Y_kMvZo9hs3Q}>$T?5N*{<({ep3|UrYu+O^2tZQx4eOIA5Q!$+HE24pWH|M z-fvfqun*?{H34-{D<8G{_Pm24*m>$>1g0N<6`$^*;F*EB}A^Yw#If3zV=f%Nn`^c(V^-{}-sYrDuS52w@WvffM#At-zWniL7!U#{$xGz zFE;}(Uk3W*w6JzHhknYbbHKF?h%5j9aU}3qwLdmv7Wj{T9{im+crXI=JJmXO`y|l6 z&i7pIqMYx`#Ym&)7u5PXXA$V^1D!7BXWD&G z(VvU~o~8WZ;ah>9SK}4C0`lZ`h8-?5LP>dxet79(F+3^7_Mh^*VayvFpZ3n*yPgD} zwy7B3{-i&+0eBMMQ~0n2DpDl;8Ts>-{MR-GzEj!HN3w7*<9;9SLppxrBJXh(se4?B z-+}&K-gAJomNoDP;IHv_3XFZ2a&;H9TcrHY{%qh|)q1VUPvBF+^{Hdem)9pBrRNV0 zgZ>?Uzo;*owI0p|p2!W7j>Lz|2ma;+QIwRO_MevZwfWH&R7jj*n!F9cZ|2+ZpAB}+D6Z5vq6}y2~=egcZ#82b{|Lz{p|4F>~ z0Pt9z=QbmrAOvQ7ORvVr9w&aGALK7ke)~o_I570>`TJ9%F1ys?{?B`_V8lBS?=&0y zKjyx{4a6(_1N@bW@P|W)k6!?MpBdQ681Aj@b$NH@|}Y-$D9L5+BUC3|H&o zM)TM%f1gXt-Yyeg175Q$__QV-aWD8(Q|-Qf3iKO!kL5wq&!vBkPqqAK zu@hm3dx+mK5&Yj6i+Lo+tadrg{q~03Z%3~!t4<;4-{bZvY>X4>@JoYnT1E zp}#xTx@HIG<0<|wvxH;2tos6d8lJw^{`bwqpR5f%*ZB~7cJiDGU4S3I263bu+wCt2 ziLsNaw?YHgmIk8{Q-GgYjQ+ME|I;r6Z_WHUnt1DY$X}%9#dX5gwoi3_8hbP3={^l| zHX@&k3&Fp}Qp|UUe+By0HEQ2uc0=%~%lDofKT~rt_$=c3ZYcR*F%$TzS%^nl<#TYMf#%>;EW#jD*8g+vn?!* zahXqfKBhhUIzdiJ1MKn;{oYEY=g1PYyQLQ_a4PeemZDhGZkAeq{dENNhj+k!Vkl?2 zq#uTUhRTBf6CCz@Pub8!6s?4LkCM4c}r_W=KVs4?XB7iK@H_O}hxq!Pz_=&U>Ve{@X49erP)UTPx~e+%WK&q5S0Tb)f(9a>P3)ANY&=1EmJtU~@RY z`M#tL`c<`TGcMe70rVg69&887--Gjd zveNTc{n4*1o#$}8F3ZJu%_jdX^yic5&uftXt{G_e;w1DamH3R8fH&iP^*f1w_Bimi zg`iKOevZ_FJoD5#`U$SH<}HLgE1iB#1)r8HpofcBqT+Yi=r-}U*v6JPGg8sJ~ zFupnDGfm=&nHR&=`engt&|kMu9IuqY)c@jU;Q!sV7{^=4rws4mEdB^`I`)uDe|Q41d9RZ{4CVdmM|r<`J?UpJ0sX$!)F<&n7UX=29|pUZ z_&qWZroWNOPu|@Kc#4WgtKz_a{@+OG&ejK`?TkAY)V-#k;=yN$@(7?6#Qo=r(QXy)8%IpH z&wlynH_GyN&tD<^%F^g>*_D-S#92?>$M>uo@;&Rxr2n1%Hct85YV2>Bk?604GrP2V z2=d(S!?-Ud9=Q|vFULWT)-9{eQ^1#f3ww6XRj=;}Jw&K|r-fgF{xbDFu9I_tpXC0- zK@9}l*ncqSi&g%Uz9Psvrz}F~0P)t4r ziqBMWT*e=^>xp^fyoc50B=FHU!fwY=o*R?Ff0mNJjx2BtpQ0@IH&K^e4mk5m-9vlj zYS6DJg>mUm`hB#MG_}8aM3?#~$N)VHnp7NtFL6{Z&*=jQa-SH{Sw2!xjIB&O@F@)qSC14M5*i z<%cg6fWCG!*e!ZtSsfPvpLqd@9J|})gU5iE9mbHiWGf&MniBg0{r z>3;#gjO#>Emt7k2-r#5IT%&9x_}5qSeGtE++fKd5v|JpB8JG8NMZXr1e|$fT`+4;~ z#h=d_{xZm~h+#|Na>{BFi*~crIb)?hz=tb&=12l&^iW^L+0x<=Y+TKk#%aKpsD060 zT!;493Hujy*=2JR$UlnjWz-{{ZDBg)qczSYrtnb--Avi{oJ#_%kVvj zR>bdTep{n1_-`Vn~+OL?_5%P57{lfy%zrguosl4U%JhWTH7Xi8Kw1zUze3kbl zZYG~!mV$olCzy|`sn5%~zj|F&_@BC^@W8Z(K;I$>{*cF<)(HB~6y;ZU@xDZC;~Q)S zj{d*+27I1ti18XkdFFROf5)!`eF5JFYDBMsilOE z8OQEw-Bh1^eB=Xbv8*{yg3o>2x1Y*(YcqcstMZ3twC5kLf&7j=Pvy8I@^?M%BA=@p z(yo-=7IR%z{v_th3ex|>{BZ6l@E=FK_2ZB;jebnhTDw&L7WlMQ(6e*@eD-GGPw@9v zFv^xC+ts#yB2`|oTNoO>O;-CbE$M$=)BcD1#(j@~vm?&~e2?IF{vM*3pIs7oPp_Z4 zr?>J5<>&hX;$G}>aRKlLXTxrvqTN=U0{p{;uoEXwxM~sb{@e$?jeKUF0RGEGc=D;_ zQ_TIS-rr%Kwk7>vVyH$B$JDwYM;wU3W7PR(&;GFIMf?s}9QmxHK4&O>MwJJB5A{2_ zo4MYPRd&0G?`yBz06h;Q|I@tZbCUP@pCx`3&v~y>=e(V#K@SV~-d_gkuV=e4%Fq8f z68#;l;zfDpE$w)I(TjXCIIoMIhuum#ZI`Y;qum?qkG$3O&m|?J|8h z+AUG}Rm6VqKYOr(O;=9zXv*h1fR8?gcC!Fmb2(m_>ihP+=^qM|f9U%h_}p{_@&V`k zsM!a=JMcSTv&sL}H-Jyz@4b#8UiWL@yKaI0BZyzu9{nm-cD~fnztZ!OyJ@$Z;jem- z&s&Tyu^(WbW)uJQ9khEDzXSgT@tYY>s~!iv<0q#s0{tJn2Lfs3UK#DPsj|cb?{Ff15&UxDKd)QkS;`a^!|5j=}K2`?W#JkFTf65uhY8;oA z>o6|()3T~@y>LJ8i?$~JIqSiv;SJ?&B#HQ`j%c??ou6(g2fVxTV<%+d7$f z=_eD-%+o@3Z}0_ivj*R*{AXE7R1CgE;WPdO|KE78z_I5k^q-69Kija~uf!k?pUP^z zP>u6$D}V3%PUbl~yTYD_RfWc!e4ykNw7a4?5Lph`CH*k)C-*}0JBeSxbyI}0&&@L2 zMxHe)pFBZ7`Nj*dlLGRob_)C#-VV!uoc`xbG4Q{*9>0(Db>9PC>i%nNq%O?b`g#d) z-*(KeZ|RqQdmQ-s#=r-W&utfhH~kXr%I7=ma%FGGKTY|)7bGz={o1MQWWGFZ@WJZ7 z%CnSnUk>D)%XVi=;5PK<)jHxvnIOil_V7IPAn9Km4fKTxEzWd$P5NH{S(5_5K7O*=Dgz2IY)ZayF5H zGyQF){Km_DfDc#uz>S$-{e2MrLAFQi^4P7g+qrx%7*=Fiw{3?!?{0)Vj=!yN6ZmJT zyyBNm;Pc={aJU8RtrcmYudK%9^P#|JsC}NB{)cu?9*6yid$dcl`M_@;4}CsByoC9~ zZ`}6~_hOeee}R79dhlsM{9XFDTN!s8{g3AP%Y!_BftD;QO&&CQPEq!G>pt)w+7Izs z*xDs|0r0MTpEQ~6CdPu#aJ7!UO1fj)xr&=V4hR0ZnlHVmhk4XPL$>?TcWCzy-Y1c5 zOuO`*1^o4u7{?97TeIEns@>bT&wOZ_I9Mq&sL=8<5zIW=ukL$~7zH^krJtyoXm<;L z2r+@}URxXVu__)F?go9U2GHljq)(UsG3}Op4-RP=`#YBNW#d2S*J0vs@m%lBEX-eL zU!|3h89m3Sc2j6S-Dp3zv)$XOfIdR)PnKuDez*m8xR>n~4g-CPIzPQ^Ippuu9C_Dc znA4*D4?PW{3>;W6$jI&zkM3VenzPwVUGjrTSe zt-*{NM>*S&f288SP8`0mhvK`TfAr3>y8H`#Y<1XeKk~`TfSi-nzV7HW;>s^Qz6yLM zpH^Jwj1<+et($8dnKUxhwV#aoPO%!GHUryyk zD?eqw`29ntzrAn4e7yBpFQ0?Wf%mKpI}vwnm*PV3x$0WT(}eiiTA=TA0DS5YueTcX z|4fD+Hk3kz`Cf}{w>mCUKQm{6k0a;Lq|Z|MSYH_+!>6?_RI~*d zLBF(q9q|%aq%kVEy@;qD(_&gQg zPc;Lcuk2^~cW8G!;{rxUeqXBqcw@Eiy+x*vX?L&E|K>Y^m#BUFDj$H)X5Qm{g7Rnh zK>xWq*J#M^?dS4)$dRN^qn#%lzt%>Khcaa?&v~y(hd-BV|90s`|4^Xvkhrsu=SjX# z=h*)i+DQZ6W7z^W)}ymQU!UtB$8PVFgvZ#=oBW*-C%^rjc}u>^TXr%of63oBck-W- zn$SZzweOnvCHNQeeAe-Mqq&b)cmn-xOgR_IhqjD7sV!m8?TODG13pW6Pb`vn>6O6W z<@YqMA-*gg@@!M{?)^!i|AX&YJVW~BF9J`$9)82YE7bs>B`Q9qJPP^*-aip@wadYF zpl_w}pEI97FYxGx$*yh|?VBlx=p(2`|+wFdYV{CUw~fXDFt z&FaMOrT>Xl^SXd>Dptj*i*oQ}+MV<;;#zO=nJ5#)%+ob0|1X(Wq#^NA6VdJi&iksw=ll)4`-_-aiInFw z+l^H1j+f_5zlN)ExqT$?a%vyI{EV-mpRDqh&cC7E4a|QYqdYC*Kp%M=BT_8Sn{qGb zUHi{qQKO+g>p1uK4)8o;8py4B4}W~~=~rhC2mc31KTPV4JWG_{Ud(;hDm+i&uvn94 zfPW``2kB|@Dd__~u__LhrTy3DcOD%7(Cj7fnZobCZ6=?_yeCk^_eWxg7t7y9&ZcTy zTFV6|qqp=r@WYY@*kv={M_ZuIZD(_Rk<0akKfuD%!_(|j*Z;TI;U>Wbw`S#f0p^}(dQuNKJq`A19|efK_$mP zc4;NUVe3cj^FP%Y`b^~g_TJ<(zBcHK)cuxwPlEp$-qX07^f4UYUTS<-Nq{r$=Bxdg z@9F=q$$=k;;=IWG1pIp*LY~8)t+sw)e%_k-xeTjaI?``> zQ}yfI3!snU@9uRa|G~?F*NVnC&L&>!1n>bDAm=*jIqxX&*ZF>ZQ_?@#2JKc>`oEp> z6exLqlIM(^_0{}3APY=0zdkiD;7jRm|0&gs&tOdM)c&r2hL%)&v38IYr z&KmpGkNxud=QlxLgZKYsxa~6TYv9+{K)>E1{w4E)7R(2F67N@r@+-f(gZH&&mc=}B z{9y&oN1r;69(@+=ZesrIo_c^lb7 zyej!Gn2dP3llVgqgZ_ox(8EmjYshin+xb1}Dy09Q5BfD&=_iTjyi?a>+|i0<#XJE% zt+zs+VdQg!{2QOZe4j^rnM^1%FNUjmJwz5(20y0qw@UW`@2>LFgnGbBRGhkEKjeAt zJxs(tSEAvu^tYMH-^QN@{TSu<`pHJ9vBM)}VW0R@zCXcp`T4t`0Vkez9SM2XsD3@t z8F-9ZubpcMJVM#eE^(Nq-Qg|a2kxi6wND2947L7UJrVT3PsRAQD2@KElYSe04p#nf zi6kn9|0>?QfH$zLhh7H$@vX2!XMSzqKH<+P(15e99M8O^U0vW#-g4Oxw7XT=&nfN; zeZqYqSq|7GJqh#$s$YY8LH`}pcfgK+Ncq>pu7-n+^=&%%oL6zbDbGExSPeM~NFT8Z ze7cRsyndbd57(pJ^MhgMC0ySn(XVct3(bhwc9|y$xzTf^+TZ9f3;cH!fIgA*Nfp3< z`jy~coA{Yq!KXx>57yiZJ}WxGp2eK(^1L%&R2=;IJt`2$z6*b^!HGM&a)JNL_X-_6ZVUOhfF2Hz|D&AOTh+L) z5WN{Wt>cJvG!tv!_uv!9?^QZ}<_z<(7x^A&1M<(D0Q&lIm={hyS<(*to2q?-?X@v3 zef~+gtQ+4*jZwXtzveMf>@0Xg@zNubZsmX{AnRciB4F=ksj$ zdB(NcDz5DkH*55huh#Wh|DxR*k?>3F$)`Zvh@mf3>)+xzps%XFfA|vl7b*Tv$&eU6 z17S!ytQFZ^tVLC zsX-!!(a%mbzdq%>sAhgJLQ16lr+k;X1?aaby)|GwidFIGH<^a^xGVoQiE-*5#wl?l zc3I7H;nd%tw_3yxHUyu^D(<8_0Q`bl51zgQ`oBTN&6*sSL*(zok)M}AZ#OlB-*}nr z&VLH{&p(JkN*T|Iy+i)r?w8WTN;%Lmaca<8$bUp#c1eB_e7>p#f6|tC2kPOOG8lKc z_H37f;;0S(h04$TkMlSAB;v?Y@|iFh{IBMFj_rxR&U+Czt9ub;`FkSAhQh8KJ-kYL zn5^s}gZ6Nd`FsuXzm|DL{!WZn8{%I(_NM&&p-l9vK>4v@;y{evR`Yk4pbg7IkL;=GG$3;pCd z{pJ4HM!xsw#KG1R>@#lv9##l*j;3;EZ6 z1wF`c+hqXdyyn{S_P?`;FO$cOo?EHB@eAH}ee4YMfTt|0NfG3UOpdVmIOkbiM6rg? zUgfW*{|)-8+(*3~;#gOl0bV!^dT{*k*^R&#GtW2o-b`sT1Nerjun=dye8c-oA9jPB zP1vsT~ifotkKs(KUXz_ek6^w%aT5jKSjmgZr`HaXVmY=Kg9R8)-D1cdE73S z)6Of+gWnLhV3#^k;9p!Pg}~7<_;_?=YV!Huw^Cj`_t^=-1EcJLm6F z|J7fGo}ZBQwkfYILcgA5-029|x=9So*!i?=h$DYd|KF#f-Et}}KRXTd4Ud98pM0L> zxHROwvU`Kx_yId%Z@$It>{^Vie$&JCsQhG?_dHT)#p0=c6c4^Oe zQKaHU6RyAB9s<3=S}ZG?{Oc?J5Ar_Jqx^0&dTm*;%h2CBwc(duX1h&gAdFp|8Vr0r z?dsE1$iG#ckG$HG`d9ws7rr<2h}w@m$$i3oY2ZJS`dPXG?T(Cx2Rq7jYe^mOFQ@X= zW8Z?lQF~}W(n!1X=DtKb?n`tb{_J+pf5qQXdV~GiArry$x8+*M)0Fhx8(L*qbIWxXh_dy<0hmZm(c-o<;uaCjd|6d5vRllTMOe-M?DO{nf*2fAyBT z(QZ=}AK(2Qe6E}Vy~(t)%V&Fm$8?1}&4_RQ3V1!<18+>c6!VSy`F@QP7v87;pUn5= z50O5B_Ap1;!x!|Eg>PU+Jj?OAxEk$d9l&^vC7;$@U!36jq6+bLZ-f5AkFfI*#7D`4 zX53r1D{CW3#5W%X{@79EMeB)IIsklj8*#i+r2BUHnEJe+^6I;}J}RgD^T^83f2_(6 z^Z1^4{}k98M!~Wsi(wl%KRpLI<+Gf2x%*k*`}q4fdjMPC4gmjrY&!N>W2_``3a-7f0;4;yK>O)8_O zPCR{u?PfFI7PGfYuh+q6nR-vWAN3!p?D<}q_-1~UsCA;*jx%_n($AO%!0W61w7tA< z|1{rAa>iv{5#-tU5bR`8DadI)TV(i`Q|skt>2HtohxH`gvdeo>pr5Do`R*^^-z*O; zE+G92GNBCr0(Eb;3hjI#?Ysl&_tZq3YPlD7h0(OEo_~XXh0WmKm-HtW120z}cH+=~ zcqQ6Bru=h#iNm%$YW=mjBXCRQx3|$gvs9j3i}%1!d;>W@raUik9WinX;{F=q6ZoF; zwd#DiF8$9U<$s!ekABVZp}#WC?J|aTQmpJ`G4qg)sfhb>EN+)PQIzTLRyE&yv)zNL z-6QAFZe{MzIQG+!>y$#(?)Th}`iA>aPoh~Xl74CVCfM6f%2UF;bj+S>ZOVqE@56DA z-v)g;?RGu_d2Z+LoW4Z*#(w}mITw_t$bTvK?bEn#A4U3&r$OJO8|Y|}u%1p+1-9&r}_oKd2dFEC0 zSDT~2--%yqn3u*Y`p3E6OyGKR6ZxlH26<8&Vy4_s0Tu7*_GuWkGK)L)Xaw7E~tF$t7PDlRet#40N^u}e=D~D?OvFMxH*OV-+B)C z^L#($8say93Vil4*wqUh-&)jvHuWD#`Uak~2brsUa>-{SpJNk8oJJ?-JnS+ED$uCz;S=3^zF1K%(5nezA7 z;8Ue8=DV{l+t(ZYdQh!@x3vder1t%cdW{}hF&{=YF86>w0{^qG!hVL^t;+AMXM%o- z^0%k&174!+;jatebNDI9$=6`4{VxNLxeeo(PyTi00Pp(>@b4MNE$Xu-_38MT3wfYl zq`pt}nIuSNUMF(DTG-mFh^OM++kysYBde%^nG><9lK z=46)+Z=l^LGa$b+F0VI+el95g@KIghlhr=q1m*)@FdvY|?eg6?@V`y1ck!jE55Lr1&_jJ?S5L{n+4(lVw+3#OHHCii9{NeAUyqAn7<=BU z_S-XRVH~gF`8BLj-g-F#{=d8lI~VoZW%Cg5nWy$K*3lmx+l2YpiS!+-fWDksN36aa z?XKkSvvec<`ip2cRo!1|`Y8C6X8y_PZq@4#e5bOXzsG=2yt-HOBhQaks`H)iWuwpN z^QXD+hYwMn#qvJ}FU*1;p3U)U{5$aWlc2FKq<>oyKSN)B12n&h_-^iZjY@@`IC`$% z6!I6UyrR-z;E}3djVFSCt#OdYiC@vxLBB-pxAb}j^lwDLgN>v-Q@CCjtlo=nw;J^8 z9)|o6lRn{R;JN&sKt19uI8Q69`xq<9XXGOAar%2yHW-b5YJG&rbtUzA+aus#{sj6J zL;qG+#5Q(2T+0erZ@*h79c;QFT^DV^N=K~+jdm6vd;l9ju z)-tZMBz)MV7ya$cZNSILlb>fiTB_nvCHjFsKY)a#$fwgV+LhXmN~N5aQBIluc8M7P z`oSt*_s)a-7x=y9NYeM51pIUUUSu-ypO|l7#ryCQw(Qbi0qDm)a)tfxL6oy@W$3>r zf2Uj6+T{@AY^0jMFNxZXT}@W=b|2(Po&}HbF69}@^~*4| zep$@-G8*x{49EXeEdrnYJtNRBF8oSM_%rR+SNAb;7_V`Z%@{eHrO62z?#0>0GejVuN z@P!pw{@CTXJZSn=sN&AH_%8S)4!XvcL&Bw9a+tqeQ2T!Wz7G1BH1sQu^w*69|5nNm?_(bR`XT7e z(ZgEtD`s4Fsyu(1BsRAFD|}uJ;KP+X2Ooqy6Zl;e372;HRuT*ozxML`mK%uA+yweV zXRxk0N<8KO@Eh-fzpcP=+2+Wp_5+{(8T4nE7n$!#nPTkD$bUiQ$(@+zU&-H3bmqkz z#?9IME_7#`i)9_W3w+M2aes#UPVex&T_?UY<9(rayf5U8ONE_~^9_EV)`=H4uL8c6 z_hxsnzY9b#BmWTZ01)ptm`H3eQyoQ~jZ5=l46R zuLORW?-7?HeWUk*Kgr)iyovajp^#^4`2^x`F9)9A7J7K)a#XZD1AOoU=LJdfEH#gc9svDTwV$wr`RbzH z&`%A@UuFy1ozL&li5b}C**fq)amOHkGvbYsz<-UJcS~s}CH&sS!<7HAfuPS<_W$bF zX!m3!^fr-xbqMt^jQdwz*lu;s>j7h6=esHY>yls?duy!jOAluL+@Z)Tf8%#RKc+V3 z`%%hytGobc`0V6;MM)>@(scvr%@4Rs`N96vvT_EYUxQViu$6uwm-h)flK!oF;J^MP zp89zIrQ*m?3H%06 zQTrhm99-o^(>ab+4?}N~uGnSPHpt)iIe4}ulxJri@XpFVS9lrtplYC(X=Ru1=})RI zhaXr^eAgz>|9uYQ?({2TA@I`tF8Vj5zh4$;M$e~)BVKGTjfx4RAHNv-N9(eVz6d@) zmIJ*^E4##$0iS!{2HuAKy@UR|g!=$fNdL09BcsoGDsPWvTz*f*<&D$PZmVBmCuQ-M zb=PFz4f#Fc2=Y&79y{oMNFGbPurK6%ocFZfqMZGC53?ulVLJKM0dcTKKUWPwgOTL( zNKMFpOyx_DkiL+=f9=G(Qrr(2F!V;7gOhJm*$@7|9IjyF1ACx>yXems^@jdo?Uq%& zBji8H?;_TvJez3`N0~R)C*HaY4i%1bx=2>NKgfBh@zUyY_b z>U`}i*UPV|_41c5g3p#4U=I(IPs{6|&qGny+sGl}W3$2km^$}-j`mrN@va)_OFaty z2TEbQ7SgUF%YuK#511E=NPou!(9hw%L>=N&I)nbJe=)C}{?6M8`WL^3{E?*p_e0?S zyad0xhWOYfkUv(fQ!YCK`X1c>zk~Emc-~RK^NtweJ!XLZEYC@+5U($SnR)R*J}gs) z+b%b+1O5ls>6;j*wopIgZ-jmpQ9p;rfW8g)^Q)3i=iR_}*M$8@dSI8-$AQ1f_g|cO z@vIzR8F{|A7vm_yXP3_7L4T6-7qic@=6wZx>rc>I2I(6t2VRx?0P~1v4u(FDsQe*C z0-3Sfaw-l^kbrCCxtjZ~^~mRLo<}^J14$Bz%dx-Br$oh_I`q#ghr)iGd3{ea^tUH} zpJ*ic-1s!wegB$rHgbge-@*GTE!4T*Cz7bxept=x=br$d7E>`^tH{5U7`&lRQGV}z z-apCVJ%1-3KD-NjlGX3#yiR-jy)W#%4f*ep<_!P6D$Y*%7ku`s_r>;p3jEv`7{|7> ztAC4tzc?Qe;npkBz%0tM@-k!~quK5$=5-mhU{UqS=d*s0r@q>sA2bL2oAEwXfAX2o z8uaB9eUStd)2|riuX+`LPZRFjFC?Ez&j9~l6O5ztUU`e*;B&R&(?11xD`h`#o&ld{ zye*Js&y*sX1TvIDKEj}?WIjv)wFC(#QUPgigbV~EZXM6t9DKjn8i*)v7 z<)(OO`seyG5>nIrn0cg6e9kC8ke8O$H9o=T{M+W>Zq^3ePuM`e_>APhGpRXtw<&q& z?D(-A^OBN$e%ZQYxa+&7W~Ao$rRW=5`CoNm6{j+vR#^NcZ$gaUQW%o8=c zkuKTU0aXY^*R;&|TsJ|Fj9g!`FWU|E&&^KFNOrLu;LGok9v|qJ@DZrDZ;UT3HaGLfJ~lPq zm)1WwGuxLG45j*^OlhOPF+2`cY-ZZHKmJtnVlPA{xx%C z>6n_4C{O3+W&2grDKl%FK(>tpgm$9=!HM?I8xfk^sR%sL*_S2;#wPu$Hj}ACc6R(Y z57H&gm+s5R^<&+98Tvsn-dHo-E}QR>qdLUl@0*mAcI_UyM;$XMc+)>KI354%jI(JuBOnljAeP7o>b$7tnw3 za{-Awb-~&RSsjM6^K^i@jFg9gEwj^`{_*KqX}(UGV|>}hGX*On+M%=qh9@N0NSD!h z@wus)86Gk-Rr~w0#Hr=_t-DWNT5f8vx%pu|Znkv==Apx1!Tvet#r+dh!DB-7u!Y0A zqr}>bd-8nQntDtS z^^A-tX#DC4xcNYxnw|a%C92@I0DVV{^cj11`sKy*f-3?@j~s~OJlZ42)1^M~S>F1A z8R>pVTU_%%iqauBH$EYye@eWhK@MxG$bs7w$GcKDj`Apa+WMtr(z|CRg zhX-b)CS_*(dt`81lfFbq>u(1&A#^Df>}`*Xq)f>LTy3x-F#19azQMG>`)B552QolE zxrYN~)`Kdau6OD>4ZicXguM$lVp5M%)#FmU`qUJLr+)wE;<`Mk$g| zYH%er+E`u5O_-{_S-OH6Y35I2{D8l&4&wKXen68n*Ib$h6vKy_Yc94a`2`MtOs^iNe67%);7=&~-m1+z8a=ZIX*C6`|$ z)VMpYs$6{!)F7qvv&UwN>z|2X2U*hnutRKbRY|g(<>N?u#?&RfTU=*AT-CBJHQNe- z)pc-PVDT7S7g#w4*Y%Dc7cf{^n7AnX+7Z|-pc@aROd*%GXRfbLYL=`DobE`*#*Mku zIKK@DC=G_RYE(Jqh&arZrdx`xXE{cAaoZMq*fyM(Sy z&Jb1hl0V1ZcyQQ;(W3`;^(&kP{kBH^HOupNJb?JkiBR((B0)4!R1lFMnkYJmNDx1f zXONot1ygVs@&IQqeK`Js{MtUChL(Q2SOPMK7Yz* zs+_H|ph|Hr*cqT{cTCGn7jX|s2yA@C zW~Zi09yG?+&u5=`d7hGq55+ia-26?dV%%kLrWM#GPD>T%e{XzhZvSzCBQ9>)xDl5& zO(FGjJ9Ne+n53(mlKI@CxV*6R)qM&eV}P#v154^1(f(N_wG3W&M0>-R zA9mBaTx}rZ7am5G!1&1)hD#?wJF>yuk^PM^nWJP3y!ygsvM2MB&e{9T%{#k9arEm{ zMun>M4_@#vM>z~a<+-*U1?Gz(fn5GQM4EvefU^A|L-G*PxgdYO;jvCppnJ>IJ3OwM zJT-FU?;lui5D%(#`9?Ejkk|jPcRW?4XKYdD=**U{Q)Zqyx^Xbg+a*{~l}jpJ=ik8y zs_@&SuJL=@pbGyZZin7Ebxf-3WYAp|>k9T756LUm75F_5gbRAHVWOD9L$?qnn#9`C zMB8<=S}58B6~dZ>k{@RjJ?Amb2BBZUo?0*JKCTI_@gtZwLCyQ8i#uv1re@1&f+LyN zkp|ZV@pL~JR4Hk=FR)?n9H1yo$#f2S&@ZV>C&WpKyV;p}xpMj)GSmgC8Grt7Q~_&{ zhPW3jE8%3Hr@}qHo{B)L+Uo>rD34y;OM9#dkh+XBP#xGTl2co~9&xnaCzUSIY+$<< zD6#Rm2`M2Qkr(&dO>BH#jxTH@68`hj!&kFAfvr?O;Gc3t0^6K^K$8TvAW7odeIyd? z&$Rr2=ED7^fC@?J--ilY#}bZ)Jnj7a*X{1 z`zrq?94C@}N~g{}Ozb5To0{cIlWFFdmc4UhU-j_^4fn|#pYm%Su1E3mPv^juA^T*_ z^^{y!vNJQ~90CvcTNi&3j=jtp+z9d}T=pFxFGLQ~Z&}ehT@CmEM+w0PWvXefJD_TP zaw|r*4ZF(bV7%Y63Uhbt>KzzJ|3Q`0sv}QGAsqpndq{!Fi{numOkf)F0YC0nx~lLi zSmWUy2-k8zCyG;G#THZ%rj3B7@IK+1AgUrvFI)#o>VYu5aIL@91L1n%PDZ?s1e}@1 z!*n}vrlKAQq>`#4OfOugbn1a{y>Mqp-bVudR^wrM5jfCL4}|MQV9P)~5YD1pS(|#o z6-vD|K_MYzbvOw_1dfo;yH7Ym6S$mz7=la7;0gqxo_C$FgsgUlm@owY(Y`yZh34Qo zmkCAi9~$_tr~j)5p3|R@?Yo0%7=nNf`uXJUX%6qD@RCYkRfcPj-k8R_kt(2hQUA=r z#RG3R8t6aCwo_7n5LM^dI%;^LOdt#>*x#}T5BOUJhb9j=HV?VWHa&R2gD5yOcV}OY zS5%$5nqDnCDAnwD{~8aK8TmJ%O!{MQeyAND_d1EYduEHp+0Ap}w0F_;|3e6UgyS8Q zkvjtTGhib@5EWKmL9~*HIG2(#(^C_;!GN8tfTI;Evrm;Rho9zZfXV4qaIzZZ=+q1ewcok8bmqBp1=e^z)@=5<71&^P1^9z>qGngm^~F8tprzxSP3fz4#j^kQcHZrBp_jrj4`|c1S5A_hptmb5~y}* z+v!@MQl7eGy%@dcE^pvTGaYy{++pkA)wLa6jy4#7wX=t<2||o)=wXe`%(AVkn{2H3 zk8@+?C5&K{_u_D1XrEP>`RUqdkbXe9p3}y_WDmEiOrH^QUs;|u+wI1aJGybl4JCoQ z%DeJ%*YpTq)jL!b8*z3s9f#GSU&pvE{hP-n$XplKI3iUpS&Z|$Gt|oQk*a4P^Z3t> zM61kP_WgQi#nL96PIEOJEWn}7|lG4a`{=9X?;va$2H9M@Yf$~W5+!Mqg{+)CCs3g+#& z#Fn^J`%NKt%ZVnm#K~@@h~{*`?Z=&PW18Wxda4m|!qg(@xGKfNx}TOHp~XkUF)yr% zrs5OiXwRQZ8vEuvlMMpDwC2)~aj)iXl5gsgTg6;0^&zcFHbk7K8SoF*(uAjJtwA{h^d+ngs~LI+aI zK?x;5P^G)+ph{Px_APphh~EIPm*>*8s$o=h78$D6?2Nl!kpMIIMG{5Nvm=GFuNu{x z-Kw5$-TO+E=L)~6^4`41{V&&(-fGvqF4yRILYi|4iZTb?g$f#ckN=ao>S7#7_`JDU zND_Bu=Oze#dBjz#CYRH^Yqcpjv%u z8-l?7JcmpV2;ob=-D#YGmm=U*M62ZC@3re#HdL+4<%FmXxU&$I-e&a_5q)|t;RUS; zy}RJS)oy*critX3zId@~L*FMcGs@cyiUiOzXqT8?K~=7~rR)5gLqQdOtJXFCQ3$Hgk5CzbOo2}j z55#DVhgT0D4McG7qnBDV1?LUUvs`Tk%fkv+YudYDWXvv=V>Uq!B*fs^?-1Iy;~j37 zdqETqy`T#O@lfkCdyS08Loe+DkB3~}+0Uy*9w)v_J}$Mx$`8{2Q+1AK0g)&!g9{74 zM+mr)oS;PBMIL9b@|=P2+!^uTC~>V4JOrt_!gH@ARHgldXN_Y-kv(zy?en-1ViR#= z>=!44`)76v>^mkw&!>jEGwE!5a39qrjnPbC*TYrsW}GBD%0%^)+Gb+eQ% z_}?tG_07=_oHBb+XS1tI#u&e=P8{RnC^4JOxJi;ilbD^Zz$Ycb@bMCb;e;FSA>~MQ zx9vY{c9DjVH#+gZ>fKC3F-ZCk2A+P9fw!ljWY82Lq);RwOVu3nJO$xM>mX%wbn5L1*n!VQ{7SI?5#p?BMO9ppyM&8#Jer zeg0V!Hv%^!+}$$Ox!B~1%gGzTjSv5P@qW9&y?S;!7)WQG@Z@n8$!T#pS*d|9v-HoB zixl?faj^Ypy5f;1D~~FSOUk+pS^Uu%`f$=sSMw)+-A5$yLN5(hodg_tf{=jqnB(~ZYNyo z;pj`XYbwLHD_03F(Ol1kF7x zKhuHT;ynhL#bX0T9n z?mX0+XhJ?a-IQm8(=od~$G(5=xJoqYd~il9)P8``zj+%m!4K+#eMBjX z26O91PKNFGdc0m5rNVpSn^dEl`0|mLFGY5YCS;{zz`h0;e&)xA!PJAa)&SkN3ZiHVRQ(NUN`CxhT!ORoh0OiUC%IiszM5k zr&P=S+n7N{t}bMnLH4){%vdv(<*u2NLuLlwqcGE797h5Z;`P^b!n(bsm-N|6WXy1!52kqwK3nla% zoZ6Xiv(B#01y?t}bahnNYG?ByJb#BGd=n0Zrxo!g!D4D_a8!_P(q6IXdkvA;jLIH+3*-citAF+C2eH3UrC5LsZ*OyX_$l z-|)GF&12KpY^BN9?d%1V38`)#q!{73e&pmcvY5dl%VjD6%;{bbD8r_3Od2lKT=bIZ zgaU)!_;!0*8Gk(EeAUjwk9EN!I3HznQTspM;lf72^RCX^k9Zbm-imO7d1ATek+6bAg%ixX#Bwt;UvzU> zpSLQk0hsT)g?%b-#3iaO@z^C=lkbFt;~8H3aJJxGI(m8>&Pcs^hv$*-QimH1t_?Yx zJ(Qcl}NJ!6;Cgj5e39Vbl<>Vy9XC!$X zX_x*{>dvm)%_fAs?Q3dqanOH4l4U-`?!RN}W|L^X&F_Rn+;a`CPB33!^T>wBm>zg) zd>JYBmuDn#94EI853Rucw=bJxd{7q>F?h!5Sz-1mm52|@;~g7zhy(0Btch5%$;aw0b|a}WS`OX?Q~bt zBgupFE~KGQHQ}Bz_mI>rCDDu1V8~lauKKQ-$@Wnf)1?qKiJ`DDA;6?in43_2{MAK% z>3f1OS&bv@)JaXs&%7=ZgK%{pJQy7{H6 zqukZ9G2r6w7EEf~0;ww3r&C?Bhyl8|VLx1b4b@BSZo$9ho$4NQ&xb=@4|~5I>Z)+F z`}KTXlW=bYIQz{`Wr5j33Y3{?w^cr%o+hU0qe(%L@h(?jD|?;YNz^CNw$V7pd&P z$*2^XFDq|$(i(=#MVcWUNI~8@wljxZ2Zl=m7iNSmtfhsEtIr7yVaP*jl!@5mM2kuo?OKdm!Q7=bz(e~GE=uS`}a(nU+Pk>1s3-OHQ? z`x(EWIY22Nef=vXMvu8Vx$CK$ zy~SX1*#+)8Rof{1lFD$umtp4Qvc*EiXi=f*JYAf%GG`JwWmRfz$TlH9rDQ=#+E`SV zZbocK5-HV_xRAOjrFxcBq;wB+86T%Gl1d^V)O~qnqBM>}N`QDNcca>=&-+7WytR-pD$Wux4 zYbts&6pfslNvGBI9+45`p=nn&UzQ1;LVQ+Ylq5zPkB+%-$dcT9u5b^uh` zlr*%fB#T$ldQGdPYJzmbMyzZ>hEk;^C-#-l$_R~z@KQB&j*gE{l$di_nvOIyLF%Ii z#`O^aB-50Rr3Ro8xk|@zeYoiCs|+M>RvGeVNaUNXYzJ8`B}opW`&SMLJDW(Bo8>+} z-9jhsB%jpOWl4c(f-0pSO!c&5fJdIBiaeAfoTeyj&EY`*-hshhYUZj!t9dRwINn!{ zvTV6JbT^+DM6s_J8_BRC@*cnH(41P5QX4h7OSr?}_O09E*jcRDU~Icrl>4c(GMuCp zuc=qJ3*F1kiVo2hQ-d;e2uw>aL7W~qjv~U9KFg*Vua4mTR*4xPPmJ|xZ>^0y2if*7 z3ej5T#8a=l6D3*Es3s>y3{>B_G_uelu$M3?nIa;VN+Q6NpiDIJnNeOC1E}v)OM(jS z4S|3aE`*K@u}>3_{`^QN5{n_EMD5ZN0)w(JoRSkNG#E!Y(@L%^DH^U3$pS?Z;VX^(W>Hi&@r1g^LutGYQl5~=XPmXoBBoSi>ww&hlT`TNksK-9c|Z{<1Gnr__(8vKk(&vy2?&J(){^;sRwQz(UamFhqjR^ZwZW$*6_e zg>+Aegk3|VU1LM^zK2$Hjgk9g}* zmC#Nop`EdWcE%FopBR6qE1~2%EyT~SX2VYBsGWN%<5m80DwNR9B4wXubBFsTM|wj+ z?o5@lUBx2XnJMR;uAGx=h=k?2GgV|H4Mn!o7uim0Tp?G72Dpm~SMto2iQ-FnrxxYz zDQa;voE@Vn;GiIc?5Yh{Q#Kxq6=P?*V(g^-03rIN^sZIQet%9FS=4eSEa75PF;0fmA=0Est{LOzG@9m z+ImGbw@TZH>GaZp0`(rIPoKe6;^6rBv0aHjg6m@y;H;*u)ZGy!9>^juns_maS}Tem zR@2C=C?ZJQ9Fh7UUR!&KK&ooIyljN4ZoKZ4>t310h;)BteAMdc;c@!`kvLf02=MTD z2C-ahJ5l}N@jS}X`zFbrlu{+VG}SVQoadAVdDs!PS{tC7@Fn!XPmf4d9c}j)4pfbB zQ|P0&$OXEOZi8sSzGfQb2x=b?;}&WDr<9QtnuzY9dvv9j?$>;GV0{X%pcOpf_aS*8 zRnB*kARGxv#|tlhc>Hj0WoTf+M6T*RZoi7d{G6!~4~>tE#1whlVWpK=VO=S8e-@%o zJQ|$>3!~M+?xEqq?xXx2)Z~hK8XANoVYJeMR#Ej1C8U?%8+K2Ws5naFBmKG>uu5kN z@M=I>wMRb_S-ROIzXxf?Ai0nvdGQIYQHWHM&QMa4u{7d3=x9mL=-4MSJXEMz;YP zRbEdsGrXR$KsN}yWQhZ`rfzs}$^@7kq8dz7`9P>z>lF(ZQdhhk3|34Y9-bg4B@#5% zE}yea3lSAS#eXR!F7qy|C0@(m($EnaHjT>&JC%~fbc(JVuN>>G4D?15D9iG=l8Vek zhTByT?5*Vsrj5Ux7IpEoY?8nyL=dFiQo^d6r@blMH5~WOVUOoZ8GGuCpYr`S4~YG>XU_VQ=w( zD;0W^OS5JZdcPpY@f+Wx-CDdb;`Q>T3OqtYFO|1(d;Y-Jj>a?)$-i<4`O%hqz;R2lLl9bT)yV>s7q3op_QR4TR9F|9OV1$vPh zDpx#K$<v3N9^CSm#bUw3#Fwj$Xz-LZ>W}V7;_pt&)-eC(O0MDrSlu zsA`Q%3P&$5AJeo7GQ+_$5v+jTRdHjcTNBH&z*Y45=X=xdAIj11~)*<>JJpHz@ zqizy(*I1Td^0iI(<$8je;ATyp#9 zIiB`O?3II1=wlXkJub5xl>#kjr$NLpEmq}4O(S&jt4wJP($Mf&VQ_+WxE2OQCI}=i zqWD%*>7#oMt-_OZ>;+YU3#5~FVob=d!{Y~e?X&Jlp^YpwNa~05WW+_9%10~53Ws}- z4X8_L+^o^*xnPvmRr4+z-UlPMvwgMlcx6H+a)VW@=E`AOMlv};1~N@DOdkL&F`y3X zx-=A}V?is4@Fe&BFYp0pe{mc8_&^G zw_TOvVE58}6E64hu7?2*;WK>b7%>h{0Zwq&B%SFXUXXtEAl0qH;K2BxWj8NaODivg z{7(}?ag@?akAY;Z^fgqI^P*%iTPw}1K=+=Cj}!+7v`nb%G{!(0drY}N^7a!3ruZ($ zgKWGwq)Yt;?HxZp#+l>A21Y40WEX!^oMuA92-3z&$;?OQ$gf^X^%%`-;z9r(%p=< zYYx%Q3V!0^ayGYf|Ar3_92cG?$bmF6DGyZrfaA*204+=Fr`Dc zyO9B&NaKiPl!Bm|?rFLFNIvdJV@b)YIK%@i>abIK4Mx)r)ADM0&&FcmA{)G)rqNL% zdXi;#4_wb*1!DoeG)w3~XG$3Vh$@pS6XOBW7|jKZ(G!@6E16ye-Re9GO z>Dq=5@*r6g7HRygF*!;8z+KgnBaJkN&WeY6M@M@zv`P_7B@2-(?Z`t}pdfoacfkEJ zM5e9DBXm#c9-<@J=$s#Vw=M=|B`j@rfMhae#NzO-3Zy}FG6YT#-&Ne>eP z)LTvr(_)BprR(GU`*hU8aJe)-Hqc$Blc%VlY5TIOrxzylnuQ%0{lUyatDGO+8SX_w zfY*|$)roFb3d13G)`u=AMy!lz;q>=cQ?a_~2>9eV>e}&P-NQam;GbGa<)?NDgM)Nl zVo8AX6jJ6nZ8p<^933soTPE5Nr#aSsg)m-nH^XnOoD^Y{vR37#2&BH55oqAXUeONRblqLE)4s_54BN|D@7Tc_hbz>XbC*Si(tM2)ZcDU~ws&HR2D`w@a?D4pj8U527E~k(NNeltF4Ng3 zKzSqmC`~IM(~`=P?!2Vbh;aHxG(k4mk9O;uS6T-_d!wns@CjmctUA3mi;~0qmWEGt zuh4K5xPHV=55mX^)`Zj1__o)r2b(3iJUTf%LhnuGeBnw}Z@5*S4GS4e3zz{`3N&*z zAj4NR*HL<>!?S9sut{q6ZQWGkcpRA%QVpG4Qqp?fM@|fxQIc7;&g+Ka#eV7+FO3t! zI_-9lZZ7-j<{rnTD= zDEl2~7^GL>L4wCdlz)#8(Gv`{z0y>9oDSR>5{ihn~DMJ=kS_0wnNW5mhrmrAShqWvcOe75e zkBG5W1GwBJRe}2MCRC0C;gMRaLfE}+!B{`i@$~&=BG$(fJs~;m{Uf-NdOmqHF@f+* zYM1s@W>+Yv&!QHq%x(E@MSb_ORG)x(|DyIjy*hnfF79TXI$JQmz@6u^#|#W z&LjGhgZW~RI>$jpviTf-%IhI6M=e77A%&+`lu@_}Vca@p&LgQchiIV;G_PGWk4Lsk z!SH%%{T0hf189Or1H>d+HEEZJH@PRfD%K0@3~T? z?J8VKN5Ffk_`9vNL`Pz9J)`=jGbUW|vNR%l#7so=8X9Y&DUZ1}tZKQ+Q?s~~9`>lJ z+m%$m{(&+dJ8~I!Yy>VDnJSlLLwK~u#1nh?TFyP=dsKx!O*=3_AE+%2OjhU(0?iyC z<)^9R{7qRtFUQ7r6op49-898NM2n|XoL0mfqwz~0-CD1uWf=O_gs1GF0$2H3yAW;! zGNDJUqR>mL|D?4g{WJ&dni!#~4C@G3G+u@dhW*t^sfT$l&K)--aZA!cBt(|en3w3G zBDhQvnj>q$j|+>Buh(+B@T~YK|y+739f^?JtL|F<^sIobBO4pHs8yQ%K8;?qjoDA>x#qs z+e`s?B>71OumBg1{J-f2YJtB1u~ugCucC&8_ix_6Ih+-r~1wnVGthV2I$QXWp{KJ zPcQHfs>k8yeqJirOTXbD;K~$t`=V-z@hsrw(TXKcLI>+wf#8(xGD3wE`x>PP3wo4W|(<-sy@g$IP z=w|vcNOk5K7uUli5f1UH$7)Xa9LWKU@FFmeWT@xDS7`bxSQr+=@V(x zM&-r0wiA7wEZZU!_UZe!aZAq9$;!c3x@s9S& z4#{eS;e{q7m%P+88)$t2)#8L&WS*>_*j+5D5EWD+ka$^)(PATqs~|8L(@MGk?agII zIK1zK0BCEus<5AcXll^jUY_#KU|E%D9Y-cGP3on;6kBu0m<;$zslct9sk1 z3=9o&-5(yKE@yD6yE58+TpqC`*YqN0Bt(GQ)E??5>9wzPIS0n9>~>XXF}B1?`VC$v zm((z>cG9q@Kcy*SYzbj;05>^`Lvw1XC~&sglEg>( zijuGL+S|0=gY?ooPndc=tCJy9JnGAros$*+-)sy&wbnC#`bI=qJ^H zgk<_8p`m)H9xmjtia!oklAfJ=46G1zGYOeUFu&}QF_(I|w^ALrqB1P&p2)}vDpC0d z+hwpdbl|*bBB>WjA`vcBG#D_XFAh~=Xq1uVDi#ql0 zWjd5g?`%qxz|c?PQxRJ~$a``U`2@GnBeYM`EfC?DG6R~D&v(ZF9YN!4bF6WD8u!*uUh8Ux>T(vrC#%; z)O#L>P$8yv5J-Tnj!JDSAm2;t=KfX^sxx4eFcPL)A?~|@5g|x~pRi;opm@jQT%`t& zBBE=nR7wDq1K)7TzI6GJEusI|RijBwt1f}*?Jk4qW|v|7AQh4d(R1ogy`aF8MSH;% zD+6&?QZRPgVQckg>^&?8^@qDbaTo~u^DrPz2Gy=C zw85!%7>TI*gx0OXW|$<9YiZc8q2au&#J{=Yg&QJxS7fbAfRe3LDFP6R!d{6YBXz zx4MSvU`0w#?l4&7-eqcZ2c3$-kDQ6d@C?c=EAdV;u%m&2O0u8$!t9`*_S^|XdSRND zi!!P9kSM*p^U{H;jZs-IUTc||CJQiqdL>iRyJb;hNJsEJ=`5{YaaT;w2b?=;>>LJm}Ef{b3t=S^{?Dt*%AbRt7zC6G@r)DD?iH*dlp zqet>si&c}6KrDRMXem%#DI(+)0*Q9*dLgn8k&@zCamm3htpiCD&yvIusmvyF znAr&B9vKUJXkel|towecoJcG*ZOb4L%MQIf;SD-cKdEEYqZT=Y+k_3}46c|jpBSfDwlN`bc1P0=a*bRIoD{dA8`jOa3{fP3YnEL}kon2J)Q zB(h0yN(rmVs%1$%VYItMPSoWEP9)klG(wwLN9a*Jd@1B;uWV1z09%1aIpmqI6r)#5 z+1OP>ee|-EKZZeX{<^Q>#f%yik{qMkLpO!%kqa`rH)2vQ=s52kvmjgb!skfof*94? z+s7Mr>5CHbj889M=%HIfMrpe<^Lnum(Lz9e zGe}`HU=1ZcHaRM*zi9m*@8MAI^T<$uez_&Duw=Q6iTe~JEa*xCrHpx9PDrG8q!0B= z+psWgC$j2L6Tglh^m#~pWW3fbZr&}`D^DWJQ5D_X?5n+lJl9i@3u^HbG%?Mbdl;ki-d))+4}>|8N-gO^tn;8MA-~Fe ziX+QNJEFYtw~lBLnOxJWTv~MqkX9b^OIsjST6s25t`3jT>b&CvBeag67OU|Q(lkF7 zm7!EWjq1nbdjqsMiq^*rpdeLLny7`CebSS55Aggwa%tvrPzDHBvLR}Q35G z4q~maz&_d;L%nGwCupQf-%g|DqErHOekB!8jtpfpWo0JGZeRK)K?6{Fvz)bOqB1Zz zK0MNWjApcRg3J7Qha7%vWPtkJqvI2NtVvcYEko>=L&B&HXR5tfL_5P$)s)uI(9oS` zcSDQG(HmV`UvFt(l-{*TTjSUA^lZi3;`yg+cCg>N0L3m2+jbjw$wRAhkf#c#ORf0S zKR)7Dx4|S=8rUfb(~1O6PcPsnL<`k`<@VTxMGKc%X(2(Xw@fbvbjQ;k{T(CF12PpG z>*n3&{4akkK=wV-rX=O~e?lg9zb=b%-E{RdDnW7L(vLpE4Un z>t^H#Pf0kTAwR5Odq|6|Xxk`?$)q>0&*7Bm$%FUx>u+(tU2qKv0aha{q=RZ|nuMYc z@-%Wz;vSY3Y*C-U%{5WO;~PFUJf=9@r`Ho~+HPL7MdQ!i<8p9-WFpPP>chPEo5vnf z=$uolYFbnYjnzy7uu|?GrfFe5z$PqTOaQMVVhstOuEY4^EM(q|oL7YEfZeo4y1PFlW_^4a|%Dx&~j4Vbw>%f za4rGb8KrMSo0(p2{(x7n1LF(6}M49Ybw z28YHI34I4lnp6J>4W_lC^~*aMvXAz!@e7SHSqmjI57ZgS$th$f8^JFVsh1)NepXAf zK^hw*0krol$PSG0Ix}$^tFX%uEFB?9kBpC(IR@>Sv6Wy!zgoas)A-vsQ)DJjb5P=D zHfPP2Jvawu1%f-WA;B%Af+sb6Sp>{ggw83U)C1u>QP+fMfMyBwX;RaXJfi%zSjqv_ z)%A|$f-NxZ;1;k8<#OAyU@}l7w2(s_QavhP zEb8X(plN-9G%{iF4rWtQ>}zrct$E|20T+s7gCpxl*85b;pHSMqj%1a)ZFieYAU&Z{SvEXqdq> z05mwD&8X@}+Ca@GF9a)i3bLL^uxeWwvvOM*vv4~Z%SC-l^FqwP+#t0pH%QIN3kts6 z&eG`Plkp))pNuK7yE+NNGb zDQQ#NmN^eBZMJt?&v8>qwPI`Rxym!b+t!e*^mY{_E4^L)$Vgizt;?XXKkaPf$B6!; z?5leHumxMJe!8*Jie!lkv3TY*)q7j4(cxNmERt@sfXQSVD^gF!YjYL=^#=gWas;4L z7MIajnI@y6;(nU%qGt$?DW$Xl2Ec+qq6vXS8;s-|0lHFF0H67#j6kC8fn?NBK=2P# z0iY=}j2|7QExXj-)8lTVJT^)_78tKk9n)uS1Gz)+pqkG{rAOMnl8mQ}+UOrz3)^mi zGH|2u*I3^a(~QnpJ95|sGDc6?EU}}-a+zzdCX=>SSiY?il(lq6t_3@26qoY| zMLKrSV}J0bT++c(=r3V)Ezs0>(j)pR$1S-wQ77+H5;@RT%JDq0jORrzQ(J__+{tCG z8zdw@kBR2ARXJWJ$vR$^kdz%e!qca#em z=nb%!323O7Mt~J>o6(HJjOV(`!tyg@fou)`WP=@&XJTNfK`6+xO_{JVFZIae!YEtI z3ha_?ptlEd%QhrB(}<-g6ymXvkwH0q%9W?WkeFU^99pWu)Ba(mEe7=IwhWj-(J)S$ zf6?M2PCgBpTsP3Sb5J`q`V?CN=#6i@7#omTD;4dhH&uxky&{p(lm^jN45Am;AgHhC zZQ4|&>0nJd@qkp(%qy<}i{yX|B)%2)!4`DZ5-5c4uk?R97lI z4)QCwdMUD>sSKqe)K|2ffK-z39g%v;NWD3c5No1yo@x0wtyZjSu~erMO0h0FwrX6y z1+tx0Clq2$c2Lq_cU8`v*iPR`in3N&5Z6unx3<%FLLt@!Gtjw(Nb{FM zd5;*IC|2N{V2;h_?T!yhU*vO9CrF$~^S|M4;G@yD=iD%f*IUaCV?$|+bZ%HkkGnYD z&YkBdPP1NkNVi^iNV{G*$It6*I9?uS`F=XZoxb~JbHaHRZ!aM_LU++SlBx(g&z!6C z&x*lmgu0WbtzKBlw!DaSdqa*{ujgWKZWl%`Q1$g!FiU3FQ%Tuu8Z9o;^V$5+C=94*`n;*ps=MX(0sNT=>X4?Nv?`hw`sC>$;Ax zX-3zJM)8baVo>h*F$U)kA!9h#06xTmGn=IxG)$jm!!WibQvxw62WMTM4&UDAY1tDv zI||b;^>P@mkT-dmXLc+rqsZJ)dN$DSu2YWdOR+y(D7vvuQ1qn}$aQFrOxCM8LfgAG zC&CH*>tbY_OoKvslrpEYYl8ndNNVR%T0bTWXfh#u|KJZ(`DnafAdhv^>pUnTywN3t z-`oa)lDPuGv{)@-v4k)i06UjJg?EDCGOg2!F$C6Eni|#6%~%F_5UrbrW3qnTdy0o? zd=O_2&n=2US}Bl}TIkJvWXi+@J#ALE6-?(e)syFVEfpRz7FFbylT(u`6I6w)@a%b9 z6&6CddZq#@N4W>Ip89CFtr#N4OXR2rj7X2_RmNZLK^eJ50Xe0NIw2g*kS zm_{&eZ}|2I%5jCG=Tmr(AIwXnQHK+!#d-R?PBx^2XwVsRpAMp9WjPIgse)dz>+NJY zEIzP91SJN`8sEr zR1S^{yW$$8pdpedWn%_d)nj2{$sKP2QyZ%ERz&Y@bi4)fP1sQ=< z1QMH;yA9I|mrU3Mtx1w~VM$_fB@!RTl!xhLrj#D4ESd&yIYIggh%wH$#?@y6?9ZZ)E0QZph-^Ma(N$VDnl z@1TBB9m!FB4YeaPNaXjH4EDPLd=UfWM>7CM+o9K5coTaSviG3Ev0aklu-al2?e0D#ZjG2tA=2^jNv%aNR3IP z$>+`1<;M*PpuQ-XDX$=&35ap1$F#?=ARI}Q3b)7feVC2UhQwGow`GpvaFnMR%b_vq zlVX2O_Z2qFCTi`9bp+ASDN|6?6K^lc@;q8YNy8a?an0dJrzU7m9BnJNTL>%7xGDcR zNp2#14~k38Y??b?p7zqoTI6&T(ZUN)QtNz@l_+UpEbsh8^ga#mB>B{L&Qvyl3b9H( zfd+G@k*|^4SbhjMtNak1O3x3=)|7lXySw|5mSHzSa>B_FCoS!9YItU%=^>iIykS~M zG8tEev0x^^C(HFNJ4Ul;E-)F9^0{{TC_*D^A$f*sAIVh!UDE=kH8V!nisegMwGg zh0v1#5gR6H8nDKr*boKP#E!+HML-9nSwvvE9y|jQ)nUDO(yw7+QVr<|B=LmU$8WeS zzg$lwf-5x$ruSaF&z&Y)6D=~L#&lQ>bxT9^DWVg~MSZr8IM1f2td0JFnjh1q)k1v^kSl=^2oHVDzxyuCRlyF8Sw^3xI zY%(OnC&%iA&<-=(HI|9QZjALlUBz;RWBoq~;rIw2d%KiY*Q=$%a*Kc=^@Tb^mJ*j| zS(%2nEn&t z+&?jTy;guSd0n!G)58MoP)qs4gN~c<@jrfc;{7hcjXLU~{4b zL^ixQ;}>`S@jG9;#mMOcPbgpS!QzAw>-Cn~Mx;P`DaQ3-TQRN{@D#qSZ2EzHTT%8; zUI)Hyq?4&027edmY zWpP1%LBVvB8v&e9{?GKN_Ab)c>&#beo8k$phUz~#$E)l~IX;?wQjV7?TY7CygL1?WE$EJtLJ^R5!JhgpN4tYteyqe==cLUsA`U zf3D=8lYSjpahctIWfY|QI5L)cx!mINLMNMMc%;iu)w)NqZhJ|~$2QekEVR~tLNRS@ zClu3Gd_w1iJB>~H*2ya<%dg0q12yf$X-2vF1&02WH2VjRP7d+2-v~S%*_WSrFv<@R ztWHkF9ik7>ma>Cw+7YB7e6yj6DVgU_BDrCtDk8zug0+OkbP@%uRhRD_our8zK4L5t zW@`Ymf#S04NT1B*kd%(p@<5p-NGwV(F@!L21{;T~uOwRk04?Atg_XNxSdx~7&}<%r z>ai;lGgiRp2xqM%>*Q!rQJn<&{tOO^hvNABvHM&o$E8K3x}G_aPm@HZdxAfekkphA zwH`h?B_XsThTb3LM6>WzNIC`aL(W|q9LI%|ip18YfYw{Y*yco)tG}7>P?s_Rv5Yc7 zoFF_iWWv)UCHZtZFTKvQCmk4!Nz-VFt1(If#@u&n@VzzuqN3bqU9_|%MKD3cerUKq#2?ZkO;w+rX^u#MP9r-4K^ zRJW*5hfW_*NcOq2+qD~sU65&u!1@_Ule@DRNgN!PTg8BIYNJLKHzx-(Ms=}bMmamv zAPS`bYa)=Gn2-{4RAh(g(3EJF)TlIKsbs;ZZe0f7sebb3i9|FpI`)CSR1?k+NKOw0 zD~Gog5iQUnAYv}vE~%vA^9+3ujIQ9M5|M~AO-4;%X>175uq!{}>Wm&HrA3{%%m7H~ev3`kE<}RNN_cu!?k))F^ z$JLMK)cFgvYFAz-q&mV4JiSCMCYP4VPmZ(CouLjSHPA2hfTpKOS z8H`|tb2E~kICYxzt&piyQ)TCG=T!{P*UJ8cXK1xeMj*1dL1un&2?7X&nMFW46$&6x z5_?3aT;|Vw40x1>h^ckD8YM2y(`%_h9K~+B>@m9`t8Ez`_2<4-P_^twu_-P!i2?QA zC`E~SFXN&_)B)?4V{lZE3FZRiWo&r#zD1M=8F4q3i$20Ij#*ch8KH;*&bxZe%O}pp z^wJ|0Rm?W}Zb3s>d434TNexwEgdA+rZp4y`k{c%R(gPTXlo!A;PBeH?6(=#uQ9(6g z+kp%kb&`T%h(gapcIY}5lho*N%gGIy+vO((GbF$m`^%jz~5~GOtRXyE6T5nw55!)d`?ag=yAZ45M63 zaWED$2*GhMmI>AZj#l{vv(c9^+0w2dJ;N-c)GYo8PtTML`XQ2B;klG$39^`O+D>`1W;Vb zP6U?Y1cZd6k|g1XWXq8zVMAiQ&|TX!`!g9`I!ZIY+~ey3piT}-E3>jwMO`KAjxlmV z>egwBl~f-eFZwelq^?GaRaawll-Echbv060qA@x$DVPLBdlM8BOwi;-7g{AqP&GkA zlf(UX+>m;CkQa6IrBHY*QUQ4y(x2(=8nJ~#(bN@*w$~MjdC|KLPhhy4g#<{SOpk5R zKHXXXMv4e;WXcpnQa#0tx^m9kx^m8DGcDca3k;p{_Q_IhP2z4ZNd}&zB$=2|qjj zqB1$wSD;U8r&AD@Cqj^bOx);X1X5iX7Vp-Yb^fM(k`sw3n_yEk6H`B6g))*U`C6lX z9^5HK(OAc6@!Q%S&syqkJ@`N*^%Hl$B(VKEzEyG#L=SvC{7~n1B9E zLDUk8laCzXugrnv7L;#$NLgHYGA63e`zxd6o$yEiSMia6Af-)8X}(J$@KrFB3ougd zZs_i=_h42QBgxOOn@iJ8Iucc&5=l46(UZXgU-(X1n|)qLOg}p#sY!Erb4>1dk~jteU=~d>)^g!(Rk6DwQ{{_ludUD-v@lBHMI(PT4k+ zPG{X4n$uWUF6y&Gfz-J&KD?H`1gmS1WeYWZZybnrDG^8*&xTl2{-a((Ncl!I4eN(}iq zJtdW7TqoXn)T`(k`ZP?9k5{41+%&zzhtU;`@e~95hF?QiCAJVwB1`!Tv|(vU&>@VD zf}~rA+^s+XeGGt(m(#PD08do-dziEukh=ij^!>-9glXC!S-k?Grc7@t`O)Y+E#9$N z%@3`NAFmSwo!e2tq52Mq9Fi`q7oj(|({eblTpPsFJmEj0HpU3%^Ubr<%D}kg?`Fr9(%&6sJX6<>7F zr(F#4$0+SYFu7&Z8Hci%A_z=yH{5;ABz=RLniVaB>;0 zntY~rwQxac_6-h+Rt}@Ca76b6B#1vCZDq$2;(G2e6M-;4iGE~Bxn1b6ETqQGJcu2j zs!T6fDZiBFE?pBZs-4!Q>8-H}U$4G3koZ zh`o%2BV9?wx}SEOUn;Gm5K!Sjl|$4)3_E%Lngtn)n2=o~!@X4!mJ5}>LW(vmR!}HX z_*fBPs2GrU!O()7U*C8ty)$|Hrn5-$9mHOtnE|IPA_A zL*wb+rxi~9cgh2&JaEbbr#x`V1E)N2$^)l7aLNOxJaEbbr#x`V1E)N2$^)l7aLNOx zJaEbbr#x`V1E)N2$^)l7aLNOxJaEbb|9|tq8#_-cG}0T}X8M2f-ov*q(3{kc6XQRp z(Yx9i3vZ|E=fC6?XBOza@#l;^Pp;1_e9f*k{uvPew8Bd*teN6#_~{VdP`JUuDY)=5 z(Rb&}7w+W>60G&*tbE@?*~NMdS01U)XU^kza89@x~V&KWKc(@h2Hy zc6`+MisRG9R~>(a@ioWaX?)%BPZ{5E{M*Ji9si~AEyvF~pnfP^p7!Shj5j#`IOC0u zUunF_@j>IwjvqJP;`l!pZ*~0D#@if!tMPWnKWMze@y{49I{r1|U5@|Mc#q>Bc^p+& z`crcJdyi6HbNsb$)0#T%_~!dme#Y_pJVE)aMyJQRmY$7Zk1ni{BGUK*B$@(RmwLVzhPDNZ#jO!jVfO#rt4?VZsiS* z2md!Y9{k_zc<_IVl0@jtym^{+bq9n-(&_%n=e zIQ|anpEn(U!9T11Eyv&3ul5uUrR(i(@3_^+-1FFF2<`>6fXjt4tu>hL+ogZ=Z42m6;D|IfeFbXOd| zq*?i@<9EB8@-@fzpRIh|@$&tZZ#e$KbCqv8zV966TaN$L-IW(Q)Ai(O4^ZCV_}pJ9 zZ*=^-rl-mAkKIG%n;n1d1C_Tp{-y^hZ*~0mJ(agPexylxyW_$C9gYY87ab4&?{Yl& zzsK>HJXq5$IezX#l$RZEyqEHt<9+v5KJ9q0f5!1(|E%M|{yE2k{qv4LYDnAHLLI(X zhcDIP%Z@+O^sm(6>yAI?uIh)4I()MZ->Sn4htu`>_l>H*p$>0${N;n{pO!kjwGMBq z!`mJIx#{ny!+RWm^HZdzv3zCpH|1;-mSdN@edhq zufsd)@S@|dH$5fC-}+ijx9s@8n4LApH;hj^KKWEDcgN4PbY~s^mg$*yeAVO^9RH#5 zMaS=DbVH<86+=%y@_6uQT4|_#2Fu9Dlp4>Y?@HSruA3Lr{MJjf{s)5bo_0j%DWtY_qED<9ACOldCBpgKV5m*@gskyyyo~X{z3V)gEyssnqrC9`bp6?Nz48Xfe`@(^bo{~_RKCga z>1Qc#cKmJ6QQqSCm;YXQtK)B?K%qx|LaeV@5^jC+I|GM#_O$GJylH;$xjq+v3AMgX!v*P%m@m0r{jITM~^h4FN?)dYJZ#aI| zk5qos@qaSD<@lZrl`niCUH^Y?yutA=|F_CFI{u*_D{pdq=_ks=xYAN9-27Ah)#Bve z^gqg59skzPl(#wlz)j`tj-UNs$~zqIHePi6!^XQDf7NZZe0v;!$QjB@j^ARu?D+G~ zRQa0Ym)}nLwBzSAD4%isXU1n8U%S1^&pG~$J1C!b{A*_^UvT^*cT~RUc;U{&#%CP=s_|LJFaCz= znREPKjL$oM*EN-2aQp?v7aia8O_g7A{7=T09lz^qRDQ+r@4s64s^jlBzTx=UKhW{* zmg7yv8q1IKI#Loa29E ze8KU{jW0QV*!YU$R~cV({Hew_9Pcx}<#@?>!-vxTA2r_Oc*S^&AM% z7@u=|-1vgy6ULVupEADU_zlL_9Dla)4aaAUZ#n)#;|(86`~RiJn;d_o@fOElYrM_z zHyH15{4K`29RC;NCC3+y*BpPp@fpWIY<$k~n~X0w{%PY&j(^tpisN52zUKHX#y1@Q zn(-~iziGVT<7xkY$9R+D-#6ak_z#S?IsV_qI~@NX<6Vyb!g$H?|1(~5{P)IZ954Jx z``bCk&oI8=_#KQdIer)8D~_LIe9iHD8Q*aHFO6?G{s7|*H>LgGV!X-mhZ}Eke24Ki z#~)?9!|}%&?{a*X@si{FjW0W1dSH|E!z+%@JV^Pf|U*E5M#qmOi z@>R!M4k%x9e9ic}a*ohn2TEK6i!kcE^{GDDQB*cBS&7<1JmvyBuFL-sAY} zRVrU{y!~qBWyhPJq`c;M`;(PVJ6?W@@)^e$pQ?P;@%3)ybB;ImDxY_J%lLxhZG9@g z=yR!YOUl??s)MU;Js*2FKgSRld>jb>mHrPnT7`+41IUmA5$FQBmINc)6;)&GESjq9N&0`@@dB#pQ(Jt@wRE@vyOK> zOZlARrN31^@A%xal`lBH@^{J?9bbEn@+HSNpR0V?@t)@?Uva!^M)|7a)6ZAF=J?#- zD_?hf@#YsRFMKLp|C?r&H+cRM<&BQFy;OOVv-XxmCrfe{AT6zj<>x<`GVseZ&kkNczHqj zlH*-(Q@-qY`9|d{j?ey!@>Rz>-mZMj@zOh#uRA{dPURbp&%I0ersJ!N%C{UZyhnNA z)9L!(_Fm-;j(5CId86Z9?^oXBc>4#GH#^?)LFFxu7nhW`I$ryb@;1ktKCHam@xn)x zcR1eiQRPL)yFRA8%klP)EAMfKtlJYgj zmyNGGzW!yE-*CKei}Fp!7mRN?zVa27FZ^q|{%?L&d4uB(UsK-bc=OklH#y$+4du;_ z_pB*zaeU^R%3B?u{deVUj(2@adAsAy-&Wq?_=fSK`7Xy-zpK2*@y+ikFF9WL zzVfo;E&rjs=6J_{DxY?|{9npv9H0Gx@>$0hf2e%U@zozGpLcw7L-~T^jXzet=y=Od zlrK5n@l)l?j+g#N`HJH+KU2Qy`OlTFIlj25eBJT6Unt*jeC3zQHyz*lU*%hlum4JU z;bvF=f33X1@xpJEH#*+BrM$`Up5H2OcD(dEg+|6X~kN z9ga5@?j`ebMaLUXQ{LtHmhm3P8&6mHlH+Z+RbFkQ>J$EVL!KJED2?Uc_rzR;k2 z*74QbE1z?G_72MD9WS4ye8KV7J1Spvyzx%TmmFU)zU=t=omGCt@j|2WRmWTIs(j7y z;@y<5J6=0m`G({3=P2KFeC6)Sw;bQRhw{Q_()GWoNqK|g?e|jN=y>_w%9|XYzmM`} z$5;PCd5hy)_f_8Nc+>rqw>iFGyxsBTW|i-7eC__qi;i!ctGvtc%?Bv&alGMy%1e&7 zK1g}l@va9euQ@*5qI}x%`G+Ww>#dpM|p?i zrM=3Fj?e5<-sSk>e&s!muU?|O^%@+HS-I+ZUwK7UyGisNfnC|`BF@k-@uj<G=ASly5oS_!Q-Z&!+2t$5WLzI9~2n-st#ZkMbtR=X#YlJHB#Md5hy) zeac%MU+P!h=J@)6@^;6U2bFg?zBZ)1=y+jRd6(lY*C_9Cym(A`$?@`t^0MQzqsnWJ zFO4amc6?)8`HbUD*D9ZNyuG4)&hehA@_EObCX_EY-ae^((ea+^lrK3xeO&pnNuDPMJb?Rw>Fju)P;eBJS;XDHuryzK_%n~rxqQ~8$TwQ1#r&!y}C+_RK7IKK3^ z${QVDd$#f>#|zI<-t2hGbCtI^UVNVNR>x~I%G(^Df4=f|$5;Mdd57bhFHl}|yy1n) zyBu$Qk@6nLyI!oky@uLzF~ab@!Gt~Z#Z6h zgYr$syWXgL%kk+qDKC6JUH=#VS$TuwYj0NG=y>6+%9|W-TTtHYc-PyMw>Un1qw-eA zm;Ob0o8udASKjV;<2#jiINtUyd?8)`mu^1;<;yt$fk(uJ0&ca=iRq<;#xGe^2>}<8$lER~=vczVbE4SN=o!y5sBrseHrn z!Vi>hI^Oa_H1&XP~PBp?Z1^bI==8@<%x$<_$7dDl5IKKJ|v9c+>Bc&p2NAz4BSdoByDE&hf54DxY_J=1o|kZ#Ag=mg5a~P+s^_y8gGErM$uM zjyo!Ebi8yYauQ}d$ALY}IxBi9l8OMwFRX*!@?Jt$jIX-_s z<@1g&H!ELoeC__q7aiX^SNW3Tjen(l+40r~DqnHD_#ox0j@KTne9iIs7Uk=XuRKKg zhU1&(Dc^Lw>0!#Z9B+TP^1_$X^}lq!@&?CeAECU_@x@l&!uU1{15k4`5wm~aP{3p&$Q!1UCQSj|J$PSWyfFFp?ux(i}xrm zd_8UdEu&{ky3LM1=^Ewjj=yn0d5_~$_f`GVjyJqt{V?zN{obp5+3`DmK>51kANZ{D z!Z*_P|MA(%8yr9Vxyl*1~%C|ed`wZnB zjz8*5O6(_i>zx?KLPqWNubyy(k_a??{r5&@>dt|HsC$L=k+KPkuL$i z`nFL|8MqxqB!M;H_qlVFp9cOs3H&s$XAAgu!2ZHjvHtf!ej9*)J-VUL2>cAt(**on zsBg`{*Py+$0Dm3W*$R9T+EE+u)1jWU1HUu)xdZt7A>AVIIndt){Lxtdfj=Gelz{&Y zq+165Vknmy@Ef5Vr=O($XBWH$(wzbRJg{>X_#(*90skSC<2>-+f}IP%&j&jffnNgU zvIN{dks`HX8TjwPKP$k01^QQkcSFCr27DCkUkCmy(6a&jH{hR5;6DdHZvnpq^cS8S z{l5bCGyp#j^3@3Zi&+1GUkZM12EGaXObhUlm^%5fg} z66ALQ_`Bi0un7E0(6a>m5zsD{fe(ZJ72vxdzpKC>3gxv1{0P*ab>M#oe%Jv1J?IZN zf%ikXYyrPBw2Q)1V*URp_@M!KJLqWyeiyL63HY&UWClU}p#L=Yl_r!23Z@7x3>v`St*RGn8)$_*)^rW#Hd~eAR%z2g-38_?w_U z&j7y}%yy^0ff`)1YS&_=n*BvIP7)VCORMi@*;nz#k2MUIqSN zz}JA!LwT(Oe=X?W06qcrc@y}x;I}Q{o7n$9HP-)MfFBxwzXs$RfiHudO~9vsHv>Ni z^|J-|+riFO;O~O`wgJBZcsuZ6(9;2&KJS={d2%?h59fL{HtL90`Pl6eO?4!0=@+NCt&|F z@OCJd72r2Rdt3$nZ@|}pe;e#v2mWI4!v^qALV0Zh-vQ;m1$-FFtI!?m|8F3_4Zxeh zo<`s=0zFN@{{ZFK4E&?OTYz_fovpyng8rusIkc~K;Dg|w4&akeABw=g2YR}IKNsp% z5AX}Y4<+Ecpxn#Ae*pQd0e=t3PXqrh1MFM|-U<3wfZqyy75HV~pEcm8LAvX} zp9uA51NcXw+&6)r1$+y*9W|~6-y7?{9aXROANa4a{sX@g@Fw7ognq9X_&dRGEx>m} zeQpIl0Oj5W{DshOv;((KM~M9$!1q8sDFVL|((MBNU8v_hz#j|tmwd7kb8L)p1_;bKN>%ec-8Y_Qq0RJV}xe5H8z_)a$9l(DG`6>cm0^S9D0?Mlg z_<2yTO2GTT&NA@FLVjz&H^HCNz<&hx&j5c2)T>$G9|rs9fWHv*&jbGvw4(*!4+8ra zfqxL{+Y<191^+AqKL+-%053qgtH3`2de(s3QT~$pI`AcEzZ<~c4E1Ld_~qb-E#Q{` zFZ9Lwe-qf>0Q_^1ZX@stwBIJ+Gf?i$z;6aSTYw*ga%=_u2B>dsz;6NG4*V==cOAf= z2Kg!ie+1;K3;6TF{vO~}s3#@hUj%=afxiXnZ4LO@V9zx01>iHl{|WTW0{=D0&jIg; z`Zf=|3VvPy{&^_JMc@liUQ58A2lgxjKOOY106zfotH5spJJ*2U1LW6%FM&N9z@Gwq z6Zi|Do@@cXBec6hf2{wH0p0+-4E=2*@Xta$X#zeA^{N?oC)m>hd<*>63cMBSRU7bY zz@B#CO;A5OfZqsq7J;`wx?R9;f_|?Dcp3DUfL{!LD+8YbUIYFIsBhE2-voRH_-|pn zF$?@j;LkbWAB1)>5B%Yf-v!|NAYY5fLC+HKv%#Osz%Pe#UjhCyD6duEOW>b1;I{`m z*Ma{Q+RFy;H$%Fcz=uHp7Vs|6Ul@q>|J7h;1Mnw9du#;$1+b?H_=`Zk8TgODZ!N$d z3--4HzX9~O0e=V7hj!pUg?^v|_<5kG2;4qBF15W2_%lF%4{-Y=n8=rae;e{u2EGKm z27ChQ+cfa6L3^J8eg`P8S>XQw`JDs44((zd_%A`v0`N}Ivk3ej!JZ}H?}28%yAJ&RP_H(CKL+a0Ch%J!-7Vk`1^*NVWBvb6u%`j|Ex;Rr z?}U2N1pG#@vl;lapnbIfzY+Y_3jAznziq%LL4P~&&q29#0RI%o7lD5V{M-fnEx>z# ze;oW=0=@=zmVy5*__+rBfzYo`178F?XMp#E-)4dT4$5~9_>Vx(Jn&CKx(mSH1O3Ay z@SlPHCE(8kdzOJe4)m-5zX{4^75Ig4pIrm~DDdYx@Rx%BH-OJTem8;7ft_2x-vj+m zVJO!BbAdMie>$Yw2>jhx|A9XS{MHP-0{LnIJ`3%u6}WvGP`uOz{N-S0JMeb!e+Tee zz@8%TAA&ty!2cKONe}REft@AbcL(`0@OwbH*MR>R(wzpr2J$n&KMC@)z^{jXV-EOV zLVcJAJ_B|x0KW&6<09}Yq5Uoa9|Jwhz+VpjSpoi6VE-!c8z8@Hz%K)P)`71;d)WZ~ zKH!_cUkm!TfS(V3E0kjW{|3l60KXjk&3p^ zh4O6y-VMAJ_!}W#ZNRSvJKKR@0`_zOUjSYNegNu27x34B|9gN}vHk;Z06k^kpNINT z1OD%j-)Z0XHQ*yquhxMd2mKqse+l|GfnNmmXAAf+$QO>q`u`57 z=MBKW3-zQC_)o$AO~CI5b~XdQ6!f$JKM4J2EAZz-{b>XKE-06F;LXr)bO3)Rq+103 zNAPnO@OOcKdVueR{FZ>f4tN>(4)A{s_zK8R1OEfm+Zo{Z1p8-!KL+wU2mEQ^|9Rm5 z33?WQe+B%o2)qRHOTfPib}j>dBgn4+zaQAS3jAUy$2H);gLbhF{EgtZ4d7pe{B8n& z1=OD{;Lig43nQ`qUjcSD0RIcHvk`a`q}v4i-r&z>;O9U+Zvp;G$Zsp~D#*71esnz{zXW4 z7I+`{c@Fr?zz_4lSHPYH;Lid-ECPQ3+)tN)-vD}+fj&#|_|T!+mWN_=7=y3;2J5orTd@|9^x1Kk&=3{saFJlw%X{XM%h)@CN{I0scp@ zvlaN+puY|HWl-PRf!`l^2k>Wso+9ucL;uhP{9z#91N@bszXbeYz{|j|g7#Yj{wCnl zz@HC#W`MsL%4HUKJJ>%5ybbiv1OI>Q-TPmx^B(a38AKb=U=dq1h#aCp7P4$&ZThz60vqS-_a(I9e&29ZNFh!z&ja>^mTGw=H`?_T%&FZlj& z|8(Ea*L~gBd`{Q3YHh13Ft1+pr*O{u(Er5w96;Y1;~YZ&4)-5HzZv^JhW-lfGl5=+ z=XVNyN4y_q&^N>VXVJ59&gaml@w_t7UO9`AIG_B zMt>T;75xp|za4#B^iK3ftWP)kdFZ|9AK`iFL%$Ty#Q^#__}n4%)v?Ya=(V_h4E-lO z*AwV3Vqd1vORzpO=r`bbnML0Z5bNMLYvKHVg8j-w&%l3Ila2lm=9Pnf0>+bv z{xYsFKz|kUEkb`8=dA=ii1$Vr`UIZ$a`ew}pGx#KaGxr4FUDVk{uFv0`s$ch1Nx0P zS54@L;reFuQ_x${_r-p-qc6k$cA{^Dee6ch$9;OyJ?MSt@8Wz8p!+e-A@nfblOyQg z;{IdkJ7fG4=-=c1Q|K>Yzh=?dY>OC!Of+I9J{1omih<^hMaOKJ=S0o&od*eC`nX znYhmg`VP2$41Htl%LIBBK6eWJUGy3BVcdTf{TTE)^pmlkj=;kCe+KK5iSEEYW~0A} z`{baXj{VI;pU1uwpci1>iqN0O=a!(?;{Ijmw_rTw=yQ0FRibBNJXPp^Jf}72pW@G{ zI`q@=o^L?k0OM~$kKnm$M)zP|t?1|CbKB9K7=I`F7wFySrC8@)^as)V(09Ul7(l-T z?}s7u&2XO)^j@t082W#C{?Yr7*7s*9o8Wa{bKB60s6-nPZ9dYIEN+Z8)E&-(67b#%h9_ro=Ws;oVP0UTXB62 z`YKq@I`m@n2K3{xFHPt(Shr^MJ@CG2MZW;|X-BWcdUm20;XTle{wqGW7rg@O+=qTI zt{*@j#X1k6KZtc0K|cWV8bf~(_n$!j4DW|2^qtXX(9gp8nMLoy^>gU=V?2&?7S8{D z7=I>uGu9^?JqzbB2mM5xt334maQ_1I_i=p@`d|3m67)ix&ocD0a8An6=dnJO=&#_t zRE7RG&QA?`KYAVd_4wQd^gpovP3WCihi3F2G2d479Wmc_^gGZy(ep8$ZuGbD9_vLP z#(nzGPr|+oppWC+4xz7&?-NJRd+@xBq35Abpx=bgokCxX>u1nMu`jde7vlOk^Z?e` zaqhzT@5Fh|ME?~%8+{FYZVtKw`<{n>A$kG&INoDL=r`j2CFrkWUS;SPVP56vOL2WA z`gK_6D)hB5o*MKc@!qII@5J>D=<8v=P3WiM95$ohkKT&@Eymf7z7?LMPV^5k&TjNc zJny~eV>r)!=IOey7kYu+B5+Qy9-IdJfie z4t+zcr=xM<{FmeUO!PkVY;+ISKL>qvtY;qj_n2=1`XH_^LO&eyDnb7R<1a%m#J-oK zzmDgq5`9mMrwaW$d~OYTIrg^>{Ux0926P|h)r5W*u5U(nV4Yjhx5s_j(GSGDI?*4; z{kze(!F+qszr{ZGp|@kc1L!~FeKLf87tZGh`m?xx4E-m}cLIGSuAf3bALE=s-xJTv zEc&{*{~Y@67^maBh4Y_{ea}SSA3YoWecV3>eKp)a54{EBFF?N)^DROT<8w>U%hAiw z7hyc*==&OPFs1`Z2gq6Z$?lpUvq1!1!Cyy*P*M=&$2G zo#@wNoZaZF;{DKz{uTD65B)PdUjyhrW4=S^+hCj{=(CvD82WK|t|!n};Qcm*z9ZIi z2K_NS*R$w!h2=_{d&AlhR`?1^&{vX;5>|>Uxepk0)08o z`4oC5K6eKFCfsKheE{n)hrR~((b2SU{-4GAWTGF4{mn+d0Q1U0pTzZf=%cuQ0s6~0 zw?*h5VEiTMo8o+yp=aWpl%sd!>)uNAKd@g_=%?ZSHRy8~e;xXh*p~+MLvjBm^!?DA z(VxS-^V(Xpl^(IE<=A2<1a`54!sinZR~Fq`f`lF2E7;SUx&Ug#@~Rx1@@&0 z-HUVEjNXKKwW8-^obBl6W1OAnC*pIv(Ko^Pd(p4JefrQd@%K3c=x<}3L+DRpoFnLe zVjsuQ_r-abK<~pir_c*w7ArrkF`<0EJz^Mf2Yuo#(iec>##nv=%3>2%sKQwdHye2IR9acClh^rd~P=S zsaUrh^m&Xw5B*Z?R{?qz_N55D66dD`{Ven{^b(A}9Q}LTzY=|2%&Q9hGVEgw`Vy>j z9r{~X=LYokFrFs#ukg9e=nrDuTG7uzZ%021=dcs~N%U^?zwln_MNeQo`_Qk$x(%Q| zfb|(de;w;Ef}V%xaSZ(sY#Q z{y)WfW}@e!XQMxb`{bZE;JufJeiqiD0R3&Oa}l}|pId_d8_s7LdOg;m9DN6jrxHCA zhqd7T33<|Ao)(L_Y)9ccW*Z z_o5eJ{rk`tVZHJqzcd0sTrjK9gY~RKZ^!yHpkIp5Z9+dE_i0A|7VFT8K8*cp zM?VSAV<-BVSm$o^qi~;I^sBLteds@7JOk(#VO~S%FX8?p=(Xr$=zpP4pudRqoI?K+ z`!a*RD%K&V`Tv~fRI0%HClB3$b5(%;5_%E(M>tm{=x1X5W$0_-bIZ~1!@MfdcjP%l zzX$WJL2t)=>(D>MzBi!1f_XKeuZD3pqyLKQThaS5{&w_c^iK4H(7Vz9h5PrS|A6`S zp-*DI1L#-cIT}Jg73XsV{eHYR#?bG>{!XADi*Zh&pN!{a2K{zCFSF?NI45)Hx!89{ zaN*oOgni6Je;A*ejlLzW&q4ng`{%4Xgm6SIB%WkS72Yd(cKtl zFZ!_KW|OxH1lemd591pOACe{@XCF@e4z#yN$)G0#8x<{0QK`g&OB zIrP1-ZjQ?r&i}4B=b7jMT%V2JgZt;87vg~Cp>K-ku>k!!+@}bA7@u2$zB9&IhJF$5 zQ;z;0>`Nv3`Pi2#^agB94f>k++&c6n*p~+Mm#~jb=mFfP8GSM4+lpR*akishhWU1) zKZf3oelB`1`tKM|ANpqK1L)J($078yaQz7So>+%5^dek8f&K-qpF-aV=X?fzb)2_Z z^g7&s4*h+sr{ju+^M4#3>`e5B@%39a`j^)(pLE#}*f zejV1o6MZEn){TA$uJ1*k!u5UVAxwAx{d$aZ2z?0GkDwRfeKLmrE7oBG9mn4>h5i`s zKZB0{48bvr-iCdgLw^+K%F(iL{?EfX$wYVK`fT*K&~wm-v7UM8*?5i$&|{cz5&F~E z_Y!m$?o)<-4CY&oz8D-qbJdDI zh;!SHUW)baM6ba5ccTwroqN&u#`~}j{T^IDfPNvyKZHJw^&dg+$GpbS*T=d|pl^Ua zg?)(KWGTwVl=v!hu z&FC4JS1bCuI9KiH=c0F_zl!m9qvv41deMDYhd%TRG0p+>GjabR^h?o4(4RmbLyurQ z6X-YK`YH4svA;9u8{VL2>nl-w-WT-(aX^H#Qn?BJ?NF_|HOQ&(DN{!8uaz>-m6331nba%K85=?q3?zL zZASkc>)eX|G(NW-{Yu=Y6Mb8}XS&hdcpiJvH^n&n(4WS52GDbH{~`2MF`g0hPw{om z7NVBNCOgII?g z^w)5G9(okL0DW_evk3hLtbYl50_$0ZzAkz>`i}TIp%Q%@>rjQh8vZ=0LBA2>uS35D z``&;)hxb(z`ibbx=&xcOTG5x{{_W_y;rdSWqcPuZ^bfFKz37`_UVZ4fSkD3U34HDl z`g3@1jG%vr@sFYB;XV`SZ)2QO=$GTqqZ#ziaZYB@zrpzD&>uy2T)lAqU&MLHME?ov znT_6rKd*Dpi}4)gq3?}#C_t~o_>0hg!#OEIufX$OhW50M1nt`dR4B=y_QGR`f41&UW;-aDF<`2XUWnbT8JY7kyv+dD@45 z1on3TeKXu=2z@ceGlKpd_G=7%Ev(xF`uaF0Q|LS4oXns}5it*>6Z-Ma?pdX3ri_o{k^(E+Ap_ie*f$^84?}mM>M4!Yt ztU^B&&wCB}-B|xR^!4z(G@zH@{!Qplqc@{BVjo-4ufX`*(etqmo#s*F@G2SQT=-XgD zE79M>`c$F+1Mk}!^ik}49eOS1+kl>f^=U${$2gnOPsVv@MSlqQX-7W~pWBJPCFa$Q z{szY1i+&W=xextEjAsCSLyTt#{S}<65%h!5$Ivgtdw2r<7hFGuUVwd^LH`Qx=UMbB zoU1wXS22FabqnXe8|#yazAZjC8+|+U9Q2F$^$+^mSmy%tY@CN8^xv?LCFq&BPZ@d@ zdO3P6)~6D^3hPjX{wdB?4f)eihGOq7L z_h22m(f`8d_M&f(`}d)Lg!4IoelzYfg#IMn8zbnI7|$5`Rd|n0pwD1Er_eKS{S5lo z*q2%KeefL3q3?kCI@%V_|Fu}pO!Rj#uWa-ua6WU;Psiuxp&x@@fPM(>Q-uBkp2rgO zLX5u*{S}PA9Q`o~VH=pW;`u0yZHyc*DV#5kMKFUEM9(Kp8ZThVvI zecI6n@wuJoMYz5jy#wc`7yUByKJ=Zjo&)Hg;QmACUd(F*{S(Y<4E+$S^91_SnAa4# z2cJ8GzBBqP`n#Cd9Qq)h7svGr=YIs_&qUt^_s>S3M$bV%5a%ineLc*p0KFaW;Ue_M zaeWDT9j-4!-yQFna`c1ozN$pu4bN8nCsaD4;%_gK#+^t~{iX7o34 zPFm4F#5rk4-vaBM&BLdY(?J_<7r1P#yWJOZ-I5|M*jt$+l&4_&O;yiUijPr^kJOyA@o*^e*}FF z>obP_CDvyGeG#6!DfEMJ{S5m3_}p3aBXFNN^gVFS9qkL}{|W4GCVD>Rn~fgEcyiF6 z!8+%m?~U~=KrclvLO&JnffDo@ya&qAzr{M2qpy$gRH6^zd8tCL!MUnIpG2=icVV3y z(9g%YYC?Yi<7`HM7yH@Ih;bD#Cp!47h@l1(U;@=%%QhpzK+ns`QHHZ%0w^4c(T#| zg>##OeiH7VhaSWF6ri7n@fV?Qi0ezx%ka5n==)*(<>)Lk{{e7*8Jh{)(#vh3BXf-HZElqo0TCd(o>fuRipH z@VNu%e_?%w(DSgKBj^|5oQ$C#kNuiJe+=t0g?<>Giy8EK%xf0?KD-C!&|kxQ#&Ofa z`TrX0mWjSQ{+!B2zZmz)L0=7@n}=SBb5ekQKjvG6-hy>2LH`BUm!WTi^)E;N1N&Qv zek9hd3jJ(+ZVmd?xV{d(2J>n_Ul-@63H<=P$C}aOI9ILcVeCsg`qQ|+6Ma?eS2ube z&RZ{fHOAS8z8>~*0DX6iX9)c;^bz#^us&nxjacUi^aHUzQ|OmtA7{{=I1jVvr(wV5 z&`-g+b=9s6E|z9!bK2E73DszWcwyc*E&!}>I#e~9rnqyH1!+gikdvR_j(C^2*rqD|<&KdNB zFyC49Dx8No^a#f3=vX-a4vaGs{RrGA8-0C@KL`CLtXm%XR@mPH^m}ptBJ`Db-b>KG z#^;uyABA3y{sqQUiGDEFtqR?Van_(eiG8m_zXJDfK>r5&)r5WsKDQbD5$t;_`bC&m zJNlIvXD9j`?$eF_Z|r+7`WJY<`p{i?{|un-f%y)hKaS5GL4O0+kDA%fk6jVEmcrGw9jqAK`h)L4OqU%|pK(>s)}oJ?>M4 z-iYf<&?_+hGW2V49?H@0!uhF0ufg+Gg+7LLu0fCT{G;ED@i(9!ig7lf?}PPeMsLG@ zwW42!@wcNtjNXaNewWTXEB_sKy&3+EvZy%P5+ zKtBxgDnfr2<1ayhvl4wZ>|+)B1kOnf`rEiq9eNS&(}2Dz_N58^ zEu7nC^k>mq(W|iz?dU$NXD9k8xKB6wrC8@)^uutUKJ<67o&)F?U>%0g@5j20pdXI= zkD+gjb(=u1!1$-oH^rX|Gw9>!v*_>O{&VQv7{8-);rvhFKAGre;eC~jUW0wfLBAa9 zoQHld)}a7>O+2K_L+4`a!pr3&86rnfa`V#bwajweH@4)rt=xbqKmFOSiTveezjCHF)zZ~md zhyE=-w*mbb>`N2+tyrIC^v5xtR`iQ8o_6#>+`kjO5$CEKeFp2?i(ZW9w-0?2%y$62 z2A?~GeiQa(1bth4?il)c_}mHfBk_Dqp+AZ7%%C5M^_fK<#X8KPZ;1OiZeKY6?_ysv z(aZ7YLN@vk#+ie@3a-yXzXjtdK>si9Q-t1u_hbor4CkZ_{YLb1^v8Jq(T6b3D)d9p zYtY9q&N}p6u#XMs`(nOL=(BjAG^1x@{H^F);r{LDeVA7#dL5p}ZuBaQzZZR7oaa9D zUabEBdIzo_LO%-kA3;AD=V}bS3+HwM{b<~03Vk=M!wk9$^PNTC3D?h|XJcNDI~LA= z6!XeNAICapqi>7rbI|v}c=FKqzzIQm7^bz z`&6R8gz;3N_v1b_=w9?X^f1m(1NymGpCpL>=u2@P2GHNbIUGWd;r=7&b(rrM`fphO3G^t|c?x}N+-C;;VT@-M{Q+D* zhwj6?99;|NzZm1sM9;zdIUD^Q>{kx@saXF!^wsgX1?cDFoD`wE(M!<1xPKY?Cm4S@ z`lonaD$)HoKUL^um~RdG&$zx0{YUIq13SjwgnkRoTQmB3I1jDpC*X72(P!|U??k@@ z=b;pRh>u`k`|5zMz2{SB;VA9@(`9YFs#`Ve|E?mvRwi~EnEzlw2Apf{sWp*zrL&@aaN z&!X>+>*vtFz;o)jd*S?_g#F4yzW~oyHu}$4{~Yuf?vsbUCjR%t0`&dxToj=PFs~By ztMPs)Lw^^&9K8qgtwi4l`%;Boi}BZ>zlD9TLtl>jH=yr{>zmNm!k?SX=#_Z?w4xu3 z`?RCqjD6`uzYXizjs8EJhhB6K?%#*rg!>Gj|A2Eognk9qe+2zxtmhc|U0DAK^a`A- zDfGXvZZqh4SpQk{4RN12^waQlk)wOz{J(?iGtnQx_1Wn6VBK=i@5XrY(2vG^3(!x& z`V^sGg8eN)-w)#{Lq7ofTaLaq)~yo#Ih?mD^j+}W)u11MeXm1*6yt9|e+uvICU(rL z8T~=5XDfOb<7`K-!a8@N*I_)}=y9CSUi5a{rw@Gv)_DNkiFF=A-vrl>px=u1A45MK z*H56AWBsSlPsO}u&=16OI*Xoz^E`+CJ=W6^UO4|HSpQ7))9|_3=!fI}Ip{lJfAi4q z#Jmd7=Wwoy(Ep3`Q-Zz<#$Seh8OC3Z{txVLCHm1APZfGK*0TnEZOpe0y&CgvK>r2% z-h_TS*0UM?S=_%B{R~{+j=nS2rxX2hoX>9bjWDlX^t;ge&~q@a0dyzcV?*fg;rbEu zf8n_sL%$RIIDx(c_GJpa9_uiJeizQqEc(m1&m8(*n6KlWh4X(0&QB(KGtN&o`kC0@ z9Q2Rzxq0ZHVBHGP8_|o8WBg6%FJt`8==C_yt>{N%JniV?_}otPHSrvEqu+qui~cX%zYqOLoQDDQ2=;df z{a(D!N6>#mA48wTzD%HxVcn+C2QbbVbQkV3i@p@+b`Cuk&!gksh4cR-o{LQMjqzM( zqi=!nmA==Wj$8_<8jeVWjJ!1$ZdkHAqmSc0o#+9Kvm5;d+@}})8}vT(#W?2! z==M$^mB0ka`bc2E77;Zb5Vuf zgIpRhZ#`<@ouZqv@MZW>- z+=u=-_ICjNYuslD{S=II1pOPFpE2}C?8^lD7x>&M^iwe38T7^Y+*$O0qR*l4kMTHq z7S4YSuFpg-!TMyQXX2dXpkIgkXh%N*pWBIk13tGK z{d|nS7yWpwXCL}uI41+>r(k`C(9gv6Bj_#YW9UcVIhsIE;G9gMFTuLapr4Co$j8h|hK0zi|H7!Zut8(J#g4R-zYSovYCQ#QM~rKZJFzLw^P5umODtpWB3f1@7OBemK^l75yE2ZaezH z=$+^;oRe)U<=RbsX%S68jpPP;TAwD+;{bHhbT#`D;OekXb}`la~XR`g-4 zLp%EOcwRcuOYk1+M!y2<){DL`#?y!1jPVShAByLF2>ngme+2ym?8_K>5ci)zKLqD? z3Vj~e&!At1K8rq&b(=$f1^ejeT{!=1;ysXw{tebS8~rV;TMl{)?w^PL2(B+cUxVi# z{T!Un67*lO{$=Q2U>(ZQ7h_*4(U;@gR-qq`{i;E)!+7e@H^u!M&tDKNa`sL%$LGGJw7d&gT&NeOR{<^yjcXW9ScI z{U^|!ct1~}w_si~=$W{F7JUuOcMg3F<8(Z@aQ=&MpG@=-^lbDiF`gXsOR%1K=vU$T z0`$GG&PC{ZW1UOT%W(fP^ktZDIr<)0|4Q`7u?|(}H>1~}*W*5Q=+|L=8qg2K^U{Rw z#&gk({vp<<75yp9s~!D7d~PTD5ja=f=&iVaFZ$K!edum{?g08VxPA!zC+y1z`n9-z z4E&n)_O*vC2aEpZ>mLks8sON=uU{d25mHu{ekXAb%k zc#q|wzlQxPKtB?_2>n^CPYL?Z_}nt|yK&yi(f!!RO7vWevkLu8^cwW*us(I@Yhd3S z(4WKgP3S*joXzNm;<;!=Z^ixF(F1rMJJCPDes!Z?jP>kAKODUeeJ!lR0Qx@YL+G31 zJ|pN4;`%Z4T%6Ad^g-;`6#5NVw;A+8^jY*atp6N(HO`OY;f3>mA=W<=eHQo0M*ke+ z&p{91`N~7@!a5Y7_hS4-=x^ZuCFn6c?`7zD7=JnXkyy`4^uusYs?dwjYtXO9I@F;* zf#y%T)`=dc_7HhgX`dJcLY`bjuH z1L(Q|@5`h|F2#?Vi|dQPA>^8BOkiu=rT&(3@~>3(&JL-y-z;@qCq_pNH$q(7(d-RgT_{>nqWJ!ai1^ z?}K%#L4OM8p$`3WtY-uI+1QsR^joo>&FJS~Jgw+Q<8#~5ug2$gqVIs~yU`!S{d>`G z#PxmX2V;K+(7SP;A@oknYXp4=>pzA*f&HC8-wW4Ip)bO|%%J}R_nAe10)H;dp>K-o z9gi-Y|0{4lGtsZdK4zomV*PW_SH-&Jp=V?K1?Vn3FGc8E;Qdg7o{jO8p>K}&Lpgc^ z`%;O18+sLb1J~)quVN<8MMg0`qM~pFnR#zZ0L^j=mD>(23rP-i`h` z-VeR#o8oi((AUIz4xqoz^N(JH`HrBUj^}F(y$kc2KtGP>AANQ78T1vH?=1Q@Jpbr- z;d332Eu8;tah@~L*TH?V(I>G!Ip`-~JbCCp;XVcES7Tm9=&SR;|3NtBXGkNqu2 z{|NJ~MBf$9DK7bc|JVPw0{?FX{(rs#Kd!sk@8y?&msx&ohPQ8HM|sQ8xvTs=R(|=* znJ>x6|1SRg?TsBP|IYs+`G2gtxg&LbUF!d3d(oQ%R}na`*Y>;pgQ$+#>(XZb?VQ_mCOC=)SnA0m;2PI_u$Iq zUUlkyxpKKjoqF%BT<%t<-oGoCyVR-o?#ks(b?W`Oa(Uvf^nA0$akWbvQ?DnEs@E4s z)EkJy>P6y^dP8wgy^%Pe&Jp|78;gDFO~hXHKgAyPree1`SL{-!{wPb%U%k0FF`u4) zo;a>{i(~37#8LH@;)r@Haaf%%4ym^m2i4n%1L^{?U%jo^r`}HNRc|l$sCN*%)rDf0 zdPlKSy^}ccXL|lc;<(x)j;VJRN7cKCBkEnnVRf-Mq~1*&RPQbhs7u6t^&VoMdQY)e zy_eXd-dpTemx^8LeZ)@nzr=|@((^A9$JJhOOuer-s@_i=QSUDfs~3wy>I1|<^?~Am zx?Jp6A0+mv4;FjXhloAue~aDf3b9LlsMx9gk2vvrdj6H-xY{RLbKq z^%8MNeWW<3{;xQot`hszM~Qvvqs3nJF=CJUSg~7OEq1Ao6Fb$ZAAFH~|NWMpe~mb< z_KRcc6U0&ViQD-Nko76;X*hy&`>A3(|Xzxq_MPkox$t3F-qQJ*1ptLw!s z^_gO)`Ydr`EOZJS?*Fgp`8SK>>YzBLzDyidUoMWQuMmgTE#i>+N^wwq zl{lbo75mj!i+$>A#9sBaVvqVdv0L3HcB!uyJJmOc6ThVA-!6`;L*khFMsZYqlQ^Qj zSsYe(h(qdI#6k6~;()qS>{s6=_Ni|dd)0S{J?cBfZgrQ~rM^q-RNpO5{G6VDw>Yj2 zi(~40#8LIV;)wb_aai3W4yo@K2h|UV1L|I}U;Uuir+!H6RX;5Ds2>r#)yu>#^`l~^ z`Z00hr}X^$#Bp^*98>>K992Iqj;Nmyht>V!kork+Q2mrRpdJwW)lZ9k>Sx4W^|NA+ z`Z=*%Jt%gmpBFpTFNhOArsqE-j;o{MnEFL=RQ-}TqJCK%Ru79q>Q}@;^{e85dPMA3 zzb5vnUl)7TZ-_nWH^pxCsMw``OYBs?El#XV&worDSI5LL^*iFI`dx8E{hm0i9v6qy z?~8-#55xiWgxIhCQ0!BGB=)L57JJm6h~4T*u}l4_*s1{l-r`_$ivz3Okp9`$!(w|a%xrT$**RR17O%%UptC z{g>FO{#%^*Aw7SGGxhaAT%G#GG0E@$)vJi3>Q%)N^=jg%uPzR%*ANHPnPR{C zA7Y<6^@HP*-~X#q|HFCm`+s%n7qKS4|5s;;UFvnjPW8It#P{j>XN%)%mpG{4$gcB(fQCsw5ApC^v1-Qt*f3vpDvr8uHa{X(|n-~Xud#Ub_9;-GpP zaX?)l_N%uQ`_$Wsz3T179(C#mD`cN9C-JBbtDrRSge4_lJwU!D3zY{~Pl z-dP+~?;?(*snfF>{A~s_NosN zd({6HyVa>5l%M?jKlPzvr#kf?8YRE~`6fO8N^xB66UWr4{~#*)_n+#+#SwMtKP*k2 zfAtb^NPVO@sQ#}wpso`8)klea>Z8S8b?QHuNk0GTW5sTD>IZKm=dV6a>{K5wPApH) zzeXHa`^7Q!3F4^wL~%rYk~pkR{Xo6s-~Xyl76;X*hy&_6v0r_v*rz^C>{XvG_NdPg zyVdn#m-{QF;Z>L0!(&;Qry`8SK>>YzBLzDyidUoMWQ zuMmgTE#i>+N^wwql{lbo75mj!i+$>A#9sBaVvqVdv0L3HcB!uyJJmOc6JMq0-!6`; zL*khFMsZYqlQ^QjSsYe(h(qdI#6k6~;()qS>{s6=_Ni|dd)0S{J?cBfZgrQ~rM^q- zRNpO5OsD7HEsm?h;+Xm#aa4V;IHJB!99H*;L+bm*LG=UTfVx-gS3fBBsUH%1)enn3 z>PN(G^)j(b{ixWfeoUPBGClu3aaG={NdyPQ=sm zpAyH_adAxjxj3r+LL5vI_N$kRed=$-UiG(PkNP{YTfIW; zQhzUYs(%nCrqc7D701;HaZJ5Z9991)j;MbUht)reL+W3|LG`cVfO<~sSN|sVsec!H z)qjXR>OaM9^}N`n{!8ps|1C~@mY%<3mDJY*adqk!Jtn{ZQLiG7s#CwfEBXDeI`xZ< zlVAU;GsGcv>IYmWzyDRI{$Wh=`yX|t*so6ghvmudf7NS>z3S8tBuIY!t6p2|R%eM_ z>UG3U^}6E3r|J1;i{t9le|VUjzdH2`f0JMTtJfDt)EkJy>eMe3NPhjR-cTG=ZzK+= zbHsl2#$um(6R}sF`h~E``Kwd^pOI6h^`2s{dM~j@y|>t{E)~1f`-q+D)GvBSe*OP(dj6?@IGTL^)n0K-o%+F6$@#1I z6GzmkADok%zk0Daq)z>Vgyi$DK2RJ`my7-CgTy}d!D6ra5V1%7Z?RilA$F+`6+6}c z5hp%M&%aU}SEqgvK=S!lr+(l|a{lVW#SwMtKio~uU%f;eQm1|qQ*!?5)DQ4XzW>x! zV!!$*u}^)p*sDH9>`@;pcB`w!F7PB%$eV#a|K3^PAH;Mh~3&cM4g<`MzBC$t(vDmFn{eq6< z{MD&{c%GcU`ciS?gY^8H#c_2|98+H=j;b#gN7Pq{!|E1sNPVR^sJ==ZP`8Tx>Z`>* z^)+Iz`dYC^eVy2?ZWFuI*NdI%8^nqC)AMf^$JHTmOnsv`s=i4aQQs^Mt2@LY^)2F{ z`c`p3-6{5~Zxj2}w~M{%JH#IKonp7TOYBnLC3dRs7AMBj^Y0eN)nRc=eUCV*zE>Pk z-zN^Md&D92{o{LG{PP~_%f1fz6 zj)-IG|B0jO$Hfu#6XLMCUmQ|DDGsWi5(m@+V!!%nu}}Ss*sFe4>`^}_cB==)F7@+b zr}_nP;@$N8hs1GpR2);kD2}RM5=Yc8i^J++aY+4&IH-PA98iyl{p#1mKK1KjulfzK zNBySQtsWJ-)NhHM>bJ#-chd786UWstaZLS=II4bE98td~4y(t-A@%#>p!x%GKs_P$ zt3MR`)E|kx>W{@9^(SJtdQ$9Ce=2sWKNBZn>G@BIV!C^UMY^M ze-ua5KZ(QYpT!~dFXEv3S8+f+C-$p<6Z_P^i@oYU#2)pZVz+u;>{9w~!3DUPXE5l7Xjf5?~o{$HK?h2hDsf7Kb{ka~4-P@Ve0PRXx-)tO?y`X6GS zdQGucy_VRcUR&%|XNg_v)IY#ae*L3fSDbh&J^yTRTh;AD^#TSh7^>$*fdV8@) zy@S}TE)=`eJBpp^oy3VZ)ALXLqWa|dS9`=U_0Hm`dKYm-o%#oJ$@8x+7KhZkiG%9h z#Q}AR*so6gLeS*?t5d%iGx_%)>eLU0O76dUZ?RilDt4(;Kae?j{?(~pJdphU|Bdwg z%fxZDR~%EPeqn9$`(O2b;)r^Gaag@r98w=34yq3n2h`Luck`bcq5{aIdN_|Nc*1Eq1Ao6Fb$%ixaP<=U*d^tNr4b`UG)QeWEy`K1m!_ z*NQ{xlf^;xDdK>-PV85oD)y;Q6MNOCi#_Ty#BO!H*rh&G>{Op6PK>1I-yn{w1LBza zY;jb5jyR$|R~%M1ibLwuFEC90{g3*5aX{T9_Ny-t`_vbTz3Pj^9`(gyw|c4ArM^V$ zR9`AiyqcbWvpB8}ieu`_#8LI-;)wbRaai3V4ymsc2h~@J1L{_>UwyUMr@lt)RbMOi zsIL>d)oo&z`g*ZbeSdj8$wxH>G3sqYa-)%S`c>ifiDb&oit zzF!{P!XPP~+! z|ByJYj*4UI7sXNaOX7(7WpP+NEDot(5eL<;iUaBqv0wd~*r$G7>{Y)Z_NdQBW^^=INlG(G<*aaMXHKy^h$aURRuWK0W_zaa^7HLHWu5{ZGA~II3P>98qr|4yzZ5L+aEo+)RG` zr`|{$P^W$&Ve)_fRc|czsW%aO)&CTG)SHUk>Rho)y_wjl-dvm*OwT{{10s|AuTK3S z-sJq%sUNtM{Qgh9r8uJAN*q?_i$m(I#X{o9q_NliMd)28QRG9q!SG|MS ztu7S1)H{lu>Yc=i=hE{}{eYt6{M8s@_E$QST}atBb`U^={&zI`xaflYjrE zE)o0Hdx(ANJ;h%2USf}WZ?RilDt4*&5j)lY5+|Nb&%aC@S9`@V^}gb$dOvYQy}vlD zUMvo&4-f~{2Z{sga0uQ z`B#eLYM(f!K1>`{r+&d_^6x*@M~K7f)GuU7{{5HwNO4g8UvWTPCHAY268qFgi@oY& z#2)prVz;_l>{1^mcB+pTC!S8vzeXHa`^7Q!3F4^wL~%rYk~plc6^GO(i-YP@!~u2c z7nmjAf9g}kKJ{s0uR8SuHG?N^Knv~C)4w97su5haZG)qII6x$98upa4y!xFA@wcdp!!yEK;0?!t8Wwg z)VGVh>N~_9^_^n3x=ZX*-z9dc?-nQe)AR2Z$JJqROnr|ys=ikoQQs#Ht9!&D_5I?Y z`T=o3-7EI19~Ar44~f0%hs7TCBVxCDnb@U%RP0ngCQdw&o`0V>u8xRf>i>zO>c_uFN?$KVR1{ov%_NhM-d(|I{ zJ?c-yZuO+trT$dxRDUK;MAGx0635kXaZLTWII8|a98rHM4y&idA@x_{p!#cZKs_V& ztCx#?>Tkqe^|xY=`a7{(y+Z6#e=l~be-J17((|7c$JGgOOubSZRsSfCsDBcN)jx|v z>R-e`^{?W9dQR+D|0edSe;0eze~3NmKgDkKyx67wOYBttElxa^p1&g__4P$u?G(q< ztB9lORmBnYYT~duLmX1CE)J^K5C_zmV!t}|i`$a_`=@$Mu~)s8*rQ%s>{e%qUFvnj zPW8It#G~o?XN%+N)Gv-se*ddpPaIXRFOH};5Qo)^#3A*D;-GpXaX_6T_NzA*`_!9= zz3P98J?c%xZgsBMrB3}|{N(pP>dnQ8W$F3niQ{UwIHul0993^Aj;Oa1ht>Jwka}xz zP`!;fpe_*m)!T}F>g~i{_4ZG`LA;bZdr zt3BeFdS`J|y^A=a-c=k{7mGvc-NZrl?&5&DMC@1ZA@-^F6noXFU-*#x{ztvH*sU%V zyVU!Lo$7yy6A!27UnY*Lz2ca9UvX5upE#o4UmR917KhXah=c0XFMvw^{fD|->{lNo z_NfmRd)295NS&O&`rl%=x+nPW|HR3gL`PYc!YQH$9 zK0zE+pD2!~PZEdKwc?QaWN}b^ia4OI6Z_Stihb(S#9sC3VvqU^v0Gg)cB#)4JJn~2 z6TRvAr+%<|^7&T>#4+{R;;8x@aYTKtIIM0Iht%hZgX;6e0d?vZKqUYELw$kRr@m0^ zRbM3bs4o_~)l0=L^(A7b`ciS?f%N>F#c_2|98+H=j;b#gN7Pq{!|E1sNPVR^sJ==Z zP`8Tx>Z`>*^)+Iz`dYC^eVy2?ZWFuI*NdI%8^nqG)AMf^$JHTmOnsv`s=i4aQQs^M zt2@LY^)2F{`c`p3-6{5~Zxj2}w~M{%JH#IKonp7TOYBnLC3dRs7AJbr^Y0eN)nRc= zeUCV*zE>Pk-zN^Md&D92{o{LG{ zPTZHCf1fz6j)-IG|B0jO$Hfu#6XLMCUmQ|DDGsWi5(m@+V!!%nu}}Ss*sFe4>`^}_ zcB==)F7@+br}_nP;@bJ#-d(!hC6UWstaZLS=II4bE98td~4y(t-A@%#> zp!x%GKs_P$t3MR`)E|kx>W{@9^(SJtdQ$9Ce=2sWKNBay>G@BIEm%FrGG^G#)n|H6At|H10QEX53@kW!z!hX53=D z)VR^O-niDd+IWd^h4EtJQsZLdLgRenT;oN?S;iU0^JkjY( zZ@kR7$GFS5!??}3#dxW4qj9})t#P&S65|Tv#m1$^#m0rk`Np}%i;T03GmPi!&Hfv& zFrGG^G#)n|H6At|H10QEX53@kW!z!hX53=D)VR^O-niDd+IWd^h4EtJQsZLdLgRen zT;oN?S;iU0^Jkd-H(p^pZ9Hi_Zaiu{Y&>Y(Z@kR7$GFS5!??}3#dxW4qj9})t#P&S z65|Tv#m1$^#m0rk`Np}%i;T03GmPg?H~VkA!g$(v(s)Ogr<(74}tnQ@PCmvM)2 zn{kWrQsYMBdgEH-YU3rw6~>E=OO1<-3yt%QbBz}nXBlT0&!1-Y-*|=bwDF|zxbdj* zu<@XAzwt8T9^)?K4&yfC7UQMHjmGuHwZ_%PON=Xw7aNxv7aJEE=Nso5FEY+D&M=-o z)$G6V3gcy2xTtBsc!R~RogE;TMT zE;Py2xTtBsc!R~RogE;TMTE;Py2xTtBsc!R~Rog zE;TMTE;P_KD~zX&CymFAM~#P#2aWrU zml^jMcNupWw;8t>FEws7t~ahVt~Op`Tw%P}xYW4VxX?J?IM;ZQah7q0@%#y9|BY7| zPa97fj~kB~4;v2}_Zu%W?lJB%?l5jMZZTeJ+-O{HTx(oyyu`S|c(HM*aj|isalUb` z@gn0a;|$|@zuAA|6~@!Xlg8u5qsGI=gU0>F%Zz)ByNo-G+l*U`ml`)3*BjRwR~s)e zt}tF~TxwiwTxgtcoNK(uILkQ0c)rH$zwrv=Y2!)bapO_rVdFvLe&c1vJ;q(e9mZ|O zEyhcY8;$FYYmKXoml#(VFE%bUE;cSS&Nt3AUSynQoMAkFyxD)_6~@!Xlg8u5qsGI= zgU0>F%Zz)ByNo-G+l*U`ml`)3*BjRwR~s)et}tF~TxwiwTxgtcoNK(uILkQ0c>XxE z|Hdnfr;R6#$Bjpghm8k~`;C_w_ZW8>cNn)Bw-_%qZZxhpt~IVUUSeEfyx6$ZxY)SR zINvzec#(0Iafb1Hwb_5;6~@!Xlg8u5qsGI=gU0>F%Zz)ByNo-G+l*U`ml`)3*BjRw zR~s)et}tF~TxwiwTxgtcoNK(uILkQ0c>Y+k|Hdnfr;R6#$Bjpghm8k~`;C_w_ZW8> zcNn)Bw-_%qZZxhpt~IVUUSeEfyx6$ZxY)SRINvzec#(0Iafb1{`R`SKHeO*oZ9Hi_ zZaiu{Y&>Y(Z@kR7$GFS5!??}3#dxW4qj9})t#P&S65|Tv#m1$^#m0rk`Np}%i;T03 zGmPhtHqXED3gcy2xTtBsc!R~Rog zE;TMTE;Py2xTtBsc!R~RogE;TMTE;PcNn)Bw-_%qZZxhpt~IVUUSeEfyx6$ZxY)SRINvze zc#(0Iafb2yk!JsmR~SzlPa2OKj~Wjf4;uFyFEj2j?lSH$ZZmE%UTWNETyI=!Ty4C> zxWag`aj9{!aiMX(ajx+q<1FJ0!M_yB?n?zrO$$W9hQ0ND}QWs$&y5LRU;`S0rG^r6D@fA9NUpVwuk z?z>K(I(6#Qsp^`ZM#4b}=Sp~jgfk^PO2R`WJW#@YB%CJUWC6yhy?eBs^cj^CUc5!a)h=N_c{VGbKDq z!b2rIP{MsAoF?I92`5Q7LBg#h+*HDiBpfT@NC~?oeEo50{3Tp2;SvcSknm0kZ<274 zgjY&|5!a;RFe{l5kTA zH+(MG{^q;YAW&AmRBEo+shi5)Mi@SHcq{ zoGIZ^5*{kyffDW`;WP;+OE^iw2@-B4;ieL9B;i;IM@rZ&;p;u5@t1J9gi9oRK*BpE zyh*}E5?(3cMG{^h;rSAtC*j!=4oWyz!V@H%DdABP9xCC167D16Gzlk5I7z|@5^g2o zrV?%>;aCYrO4u#o>uJ*XOSoLZB@#X$;hhrRB;g_nuaxj22``ZFd431>=pl!S*$c%X#)NH|Tx$r4VIaDs$e zNw}$m8%a1;!jTeoOZa+sY5XNzF5wahACT})32%~ck%U)Dc#(t`NO-=4=Sg_Bgo6^! zmGA@!XG(aKgojFapoIHKI8DOI5>AqEf`nU1xT%C2NjO%*krH-G`1&K#_)EB4!X*+u zAmN=7-X!5739pp!A_*^$@O%l+lkjW_2PK><;RzDXl<+7C50&sh3HOn3nuL=joFw4{ z3Ad7PQwcYcaIAzQCG3{)^%QCRC0s7y5(yuW@JPN_e1z`$#xV!pRa&l5m2ATS>U7gd0gXR>F}Ic1!rWDviH{%OzYQ z;R6!hDd9~LE|Ty{2``fH0twHT@H`36mT*wQxe}fr;YyrH~&36GNSPzeu|a32Y$NjO=; zNfJ(wa4QKnm2e{o$4WR-!fpv)PnO1C!sQY!k?;Wt@09Q+2^UFtrGytrc!7lHOL(4y zXG=IJ;amw%kZ`7iM@e|7ga=BvkA%}CoGjra2`5Onm4us0xRHcoB^)VXw}h|zr16(< zxr9q3d_clGCA>+(MG{^q;YAW&AmRBEo+shi5)Mi@SHcq{oGIZ^5*{kyffDW`;WP;+ zOE^iw2@-B4;ieL9B;i;IM@rZ&;p<(b@t1J9gi9oRK*BpEyh*}E5?(3cMG{^h;rSAt zC*j!=4oWyz!V@H%DdABP9xCC167D16Gzlk5I7z|@5^g2orV?%>;aCYrO4u#o>z$?X zmvFg+OC)?i!aF6rNy0@EUMb;45?&zT`4XNd;n@-nN;p@-6C|7|;ZYJED&c_=?jzwe z2`5W9Nx}&dZYANS5^f~nSPQGcq#7gZInoDNV8* z_^;6Xg#4ZnLOx-;_-Iz4YG>5^QxB{8m%>!%T6J4RMhq0}ykaN_uRJtNf6u*j{duMF zm8_)sxYm)`qL1oN>U^!P!=Y*=84+qAX_~j5Bedt^%F57?%F4>MZt>bp=RjOb?ThP6 z$D$IA46a$v;qTy3a@ykGck9zj^`8t^wX3T353Dy~WsN z4vWoZtdDHSWbF6Ui;;}|m~42Ou{Hm(Yd;sWIc>4GGTHB`7d050MdRjVY;$5SX4zx>onm?CG-HPmdycUmM_RJ~FxK|(dB*mR zuw>6Nwz1Prjt3Gd8E1rJ;ba4xi8T&kG_=>SDDf&KU z>@5^$a~P|NS+2+WG{$Zq|GvT4sV6Mi*BE>3g2lef*h?;}7sDBQ;hwN9bEL2G<#TlKgs=v9)PrE-1i^%vSyjpr;dz0O0BeKY;BtR z?HHR!QPY~S%P5}jW$a0})&J&>>Raf25r9 zGh?45zy8A5sU-UoWB;T~`#ocK(>nAmV;`Yje9hR76!9N3_FmFEo3Upo+iQ%y6LDx{ zk4cR6n5;dD&Eau<6r;nd%*C}SKSzUg}mZrtc!Bc z1B`uwWZN+|o@Q|?#@45pxtp;gDZjK}>_epYF2>HK{BjRtUn9SA+3^&0aZL7m+QT(r zY&hv{#MtJfp#fvZlYe6vyOwfXG-HR;yp3dR{UcT!xEb4$Y;ZBQf_605C)o3MIQ94f zV;`Vcyu#QB(r}5fYsu?e!;3Vd{${dwQk0xvYz9TtLB_5ky}KB@jx=m#>>HHpI6H(! zh_ho#ET3&=8p0_ztzqmr(y*Md3u!ceV(c)=LSHd9iu~{)W4F`D&t~l3v=RguTXD#; z_YKCXWZ5{zK1q5^h2)IL1CsS)&1CPyS_j@^;3)aM)t&Fm?*XWNpUYNjv8n zjCEl@Yh+_LV=s`;9E@FZ(2~72-kycqX^by2HiP_op0UGdML5OSx@6f2#vY+qFJbIa zvf(geKO_zN8QYp{*v;4@l%sYq_5lth3-?fb0Pf=aS*eA|g zdh;1;-(Rg}>>D(*Rx)-Wjr>x^4kG_9WbBkeSge8$)r zw14`Lu@8{X-eYVA^>a{f%vODeFsJI?eH6R0F3qTs zjD4Bd5sW=btJ3p~ZA@9{ImWgoJBKs2z#IeH&cR@GJG)n}vXkk;uKbZkuPb9;rWu;T z*i?#bA7kI46{ZtoFOl_L#(qjODT%SyXm&in*t?lX*xlEB#g6t68A zdyLq-89SFUN*rVB)6TO#W9{*ZWo!kFOax;c)Qeh-eVJP0?BBExsmWvq(LAVp-Ohj? zlV#@_Tc14nH)E&LSp37-CunwDV(hv-mM5<+(xYz3OE+#vL*7a?Sy`TKBo3S1m zw=Il)h-TJi#>SBb&Q>GK{$R2L$Y)y_`zEoxwVo7xoV`MsbuH6ylJ)?3jO{^@x}33j z)Y>A(?xmIMN5=k6+5P?^+rRDU-s3$c+kxisJB;1C+Zv0RjQ#u%i+z`|$Ea^J7#kx0 zPGRgDWWyxJcHCv@9n09wG!`!~Hj83?7-R3GNFB&n5A~uCV~NW=`8SEN-;>W089RkviX^UK813)2GYwfgte*bC z*v|Vbb{AtkG@~|+u`QcO_U1F$ELxQc82cJomdDsNv^sOy&9nwCVX_@e*7o+G{ie5X za(d##gz~|gj6Fx*{xQ$)=|b}0D@=A8S^qj?zakAUG4>gnbuTh@#Wu^^ zT<=865~G>yI_kx9jQxg2W*B2P(mWWz*fBKg9%XDNx_{`)*zKgZ7h_$-c4zEu)QdF6 z+UG31wPj{&_9(W7PJKW6dbKM1(Kx2>V~UD+#y(CNip$2({A$2tyKc3-eJf+_@9Cl# zTR)?u>aD86oE?8`K^bs2jNdBfPH)@STQnxWjXx)ez@nC$bk8gq6e z#bQk+Yww@K8QY0^T%EC>Qa*Guwjte@xER}&)&;+~Q9dYQ?90^CHH;mPOliaymmNdCDrT}#l-0StZ%~%_ zjmgGPG;d<;_mt~rEw{&ZH(B-tW1pv(na?!LB6~k$>@kYwPZ%3c>=N2HbGA9PmcwK-XijD`b~CLH6Bv7lb}m_rwdd~*ddcgrG1+OfGkl4$ zKhjKnma*r4vqpXpV`Da3Y;VRkCfV+cji>D9W$gX5!gOG4&PGdb0%IpqkJ~YJ9eJlM zV;>sEA2yJF;4;uO37(0&aUC-G1G|$#Dwk750HH=+LJ}Y2sh~{rTW51z!wu-Tzlf5e# zyO!9cjD3+}{a40TqqCTWj9o)L{+Y2~&}jb1*l=2veqe0>I|uLwn6H z8QYrtFrTpxQ0#ol*mmT}j~Uy8M(9JvW|8bX#%?IK?EQqXE2uSYgT4NI%Vf`x>`#n6 zLMtQpx{LC|N+$a!*}zBs60KE5OtwDF03MUQDXO_mkKEW^5`&HP3y+C?-pp z>~8Y!F~(0+4eLq{$d*9Xp9ds_6o`FXY3jpA)e)?QP$YWWarYJh>vk+ znpr$^rP9itov$TSe1M5ePeB}xM)OnGxh@QqJC#=oV}hgwi@M`t&D9)>^8>Q`w-3! z&a?c=H9SE5-^etqp}i}Y9Yedx?M(J#$|$_Gy_COpG1(mQ>mJ6wKx51O;Gj8Pr?2hF zbL5>BOv4(Ax>byQg63BNW9|E?X+PL{pI>iz=NBfshUWNU#@Q}~IBA+c`?ESR% zaeK#;&$zuW5L?JJ9HOkod$EjW$r>j6H?0rr7~7au#LbM|op1GcEn^=cKjbskLnE}D zvBwH54ct4Ih~+)rORaIA4I!569Yis?nzgo$`o=XpPBF>ZmaA`O*)YnM+}=3yFK0Vf znd`f;mg#dnyXyDU&yKVsX*l(1F=Jn&40z8dTXrM$>A*`iJ7|?p! zGZ9eJ?lv&-X1eZV2lBINnm1(Z!?sn%W8<;&G3lyy<0`(2&^_2g^56?AZr*fHX7I8# z)>x-9)@RN)>PD>C$5(B7hSl_PGmuOV#-10!S|v0V{M)p2q#2EtcnoGnRqqG*s)c%Cao|cXjjR3uIj_2x3DWC zX-ZdPtU{A5jIlK+j%qQs7g-d+*x9t5jbiL{8bbc1)E-J=b(!o4O7RUD8zk8~82c+N z9nBbt6B#SU$vD33$k<7=X?TdSPD=cp7<(7#?aWyB(wpi17bU(2ne1U& zI(Tbk%PkEZnC!r1H)9{A<*O}|?N2vT_cC@SZ7I2I$x2J_{Ytl7^{#C*T1k+@L^h5ZvWC|pCYyy zV>givJo@HPYdre;(;V_J8){MfHfL?W1CUz^kl4`qWTHOCQ*-{WNan*w`jgS zLiK3Nx{I;D(73f=8j?u^&zi*~%ULJM-pMr7qL}1kZ0DUgCfkI1aSvl_&@Ie;jQxd1 zzCB|bQS98s`qq~`$@MlPdv9m5EhrPjGQ9&S!_;E3TWDUmm~1rZt;n#w-izYlI%7*{ z7IL;PtpQv^KG|@MX*f@L@+xCDQC`2y*r&-4ml*4$eD)7xchENf9Aj5f^j%@>B(nD+ zW3$QLO2($s4B$P^Tx`uk-iwcD#o@hpm7?U!&usr*r5=~D)`}<|LW~_tFl#97=L}=5`$pTYR55H~!+4V?UAD0+k5VviWbF6U$_B=+qka@I_DM5jf(e@#JD&Xa z>BqM9(@4X2jO|3J>1(Fp3Qb?m<`6rd$u6c|e8|`(KUjYMjIl3M!s2=tlI-_P_87Ic zkg@$}`YvbeYm{~i89RQFWdrx*n?G9Yb|%};)L@U|Dr~cE77^`++CJS&QQe)fy{qUt zV(3zGeye)AS=z(a_Xv$q31dGePyEf;hp6o{jCIfw*5grIZ)eh*#@K}vJ*yZyZGq*V z0>;iIwve$`D0Q!4Yz(zl#MnW!0Ig^26k@sT35v?!ne6AZEWP}m-M2Ttx9mO5WP6gm zvwGUH%P3B!F}5M*tFaCIhOwJzOWu;T*4nh!j+5GE=8%7VJei%XJV|k{F*cRv>2$_6 zriJ7k#*Q;*ncZ$<=oInUM>;9F_@v$6n&gEMPuXlk8nvN}ZEv!63quNSJ_DwHVCx!8 z)>gh~v*)TTWe%)6RhP0uxJF;f-u}TD0yM7wR6Y@Fx1K^jsybn^``Qg%rXBoM#+DI# zma%TSZwfK?9vb{V8T;HfR!Hn*Y~VYK{f)7+zqZ%{#(qR$xrDJ_Q@H=Y*sIjqcZ~gq zrv0~!eVBGN-!L|xZ1|F~ztH{e7mU45iDN!vC((ZPQ^vkaHhjX^bd$A1c@Jaz zP~YMhdpphbMvQ%x*t(1@B%j4Fb|qOB#n|aInmo>;X<-UyvVV~uT#QYosCF=R^0$U} zXzs)YktwRC#)B`Isqt=e@XXX0Tk-kL#AhIr>zVYR*>g+02}Zf9_9fU1>*B-B8y{2L z9S3KKRYl%Y`@7kb_$Y}E58(g3&{V)$;>=R@p{A&PbbM;ZG-m38hbr1Glneh1&a z=t)U<7_VVZ6uT3MY5dzn)HrfvVVPIjRj|SermDLGucXWXB14}Y&NYQ&oNm) z1u17Ikbj3W*-13=oV|l`*0W63Ppxsb&u5ms!vOh@WLq#<``oH2V~f5z(oHqIPx*<gU*{Js2Oa}nnhcWAY=DdNl=~MGyA-t>H@Usd3#cfqe-!i zvCq&@?quvq>fIj3t|E&LG4>EGpT`+{Ck^{4#-229Tx?Hlz}3PN@>x`g*S7p_YWJSb zHY?7*jmg-Au_xwQ>>Z5lXm4W8Hygf&&5vkTK8uQb)NbK6TH@+4wgZK39md{oE+=-+ zRCA9mw@{PWwSpFc8jS5qOVc>UW|^^Nw{U9C&3!lLIlB)()9AdLF``$=IbAj4W_GaKeuvV}G{zn>Hv_?hDG%AQchY8b8e==6hsGHHhp`p3 z@XTcFA?lO%fUWldO5_umY)86*p2*ntG}Aw3Y@8X%cK@d##t=I<%`%Z`cH8YK8?<7l zwCiXY;_Ro?)0RwjKlO>T?@<3aYkhxV+c^l9>vp=U9!c(d*0ysDEx0=wdx*Xz*}~Y@ zXtCSK*uQCpu4n88@_iv=hm(e4#@3`fw2rYYDI;@s49&|tCL2y0kEM)#z--O-%5da1 z-7C+!t2~Qb!oJhHL>3)lYyoA_A*_}CG-F3Hw(Be_dVgjbex#9Jz}U`|w-zyW2;C6A zmCMG9G|XabJk7SZnT8|e70!+%cF!doRweJWWo$LdSBZ@Ek?cc^9YekFF*Zc=t2<+BQY`jjYy{c+Bx7%zZS~?A#)c?w zRcAfEpY*yJ+mU+gVr*lIoobBjM;e@reUkiJ$-bxi+&qd4CR8x?O&a-YjO|A@TxIMz z${qYk)Zb}FU1G9hC?8&6>^RDu|1kCu%5~=%JCb^Fj>j8-;iF;X53VEF^xR8A&xwGirMfo#SZVqcQdSr;0t4(VriE6SY(jjFKsQ* zmrFZ|kB^t)@mNRMtxIu|=_vcpQv7w4xtHRn`TwQmNzKsaB#*Yuf1{h5r4;fGDO8fPYzn~De)EOla>D0 zP$&o8f25}_aKG!oCkz}f@abeF{;I&^Jsot6a`b&5uNh>7eSJge`j*o59qIbfE?YsA ztsqWP&{|T^$yOlT(tn62=DaZ61JJJo#onHFqIkrs#P86dPlxyu{cMC1f9kwf>3>3r z|6Q-EdtT`WuuTW?06TG6DbPst6bR$cHwx4Vox&6I~^`q+jKstI#FmD$ymnN_2^?5s2t;>lr)!8}8qmQT zG@y-}X%M~DHNY6yAcoJU_aYTtzEK0(U>byTGT;EO(ht26vtC;l=;7LNq{eN|e65EI ziEv_FHBdcp+mxvMhr<0YxWZL`b*F!#tNNr+p|;f*a7_+I)Jfd@O8v6-T7Dp6x-T(* zOiOLM7BMFn;Yd6?wy{>AtxMcI=19=%^lAlOZGG23!|7cU8_rR>=9g_m?RKB$np5a~ z!rRB&8;^2ipPYf*=G88xXzPcl0aw#_cwE(TJX1io$y2rCOJ|5NP`~vC$A$TiUrWx- zQ*!3%LTA0fPL-*_0dKl|!M>FNr#G>{iyW@y`CU0q)t~Q5N&GD{v=Xuof2DKGJ!;VB zaV^E|j6>&qfhaBB=iKSfhj5-Nam(0pD9=dMQ+e>|%Cg9{u9^<$f#P*z5(2Jis6Clj z=+z2+O4ohK+P?fHjl)>zj?bG==*!KW3W$+5v;w+byU;K~v9 zHJsI~P|HgTw#!ZnzHrT}?e}gwnem`cJEHxWs+|tatEjB>`cFDD%eCDpL0_&T5alm( zdIPn!aIbdTGGVqMm;pimRp;2)1oiPJ3c zkBkNw|E_@uzc;_MrdK=DHQ+)qR5Lj-e=P7>ts*$dS%yLG;ndcr1{(&vfm+&y)S&AZ zZ=iMdF~>D@P}|_mJ|ap!CwjHrn}4Kc_F-X;uf{g7R?8a*H=wu1hGZ=&5HZt$H8yMQ zW~#wQoT-WDGTN)!hQv!s&eK?ey@}g0>S>n)?E?9yYQoY$L;%JmZdN9HQLA0{X`5kG z>4N~eGqi2RuBoEK{sM%{@2{LLMy!dgLFa7GFTxIgC~RCGHGQk99V?5~^8GERIfI>? ze%G7TRR0NQ?)GsVV3f8F-4+4k$EQEfX&9*$=O3?GK>=W1Fvy=Gr`mZ_1G*^SE9+w*I?NPm$J{4*(BPTrI4C{Q&nTLPZ z0+USj7r4~K&6y{XbIX;Scg2Ol36;79%HmYFBhY(lr{K#@En{jYEyk~E1(Mu#K+M78WAZQFw0sukoP zab+Jla|Ue4)l^X|GFap* z=O3=o=ByT38z8@+mKIwBg`g`dKd*Ywl~<@Piyi;Sq@}O^>q9jx_FR_ummOlu^pCA- zeyFk9W~;hvY01%sqq_B5ttvktYy{sx=gXqo+`2qv>n!jE!k_sknt;bb*Z4~Ag$yKc z_e;192y_b1+E@)gNgM*8bq*K*BujsjKYG3F7!&VoiMt@4V2d}m#IN2Ueyc@ag!nDC z_*LB0=&gnu;%G1=s4NvPrtx1=Ce?@hAL7m@eVw-Ot#H929N!Sty7jo=S5%)`@oA;H30i!MQ5i9_pBw=6eQ`7&~nv1H=k;!4$u zvMcY)bT}sdOP^@D+m)OTp-kdh_OAohVS>d0ypV?(6*o+IVJ}Fr zeH6Q31Z2N_eINVScEn?EPsA|g^m^sqbz^Jko3IGztXmjT->$4IJ0)&b{S_U?Hb@*> zcYK0coF}{sV|E<6xb?1Xh*HsfFmm7L(T-&&gylGrc>+gi!K83Jb{P7lGfWIdt`OB_ zM)g6Xx)L9uS*Q+ltDAUce1yH*`_x!yp-oC}3fnRjY``j06Xbiwe5Jgrc%#`sPl%s{Io>E%r6q8Y7l`5JU8cC@2g}4tKa5Nxk|w9g`X% zC8)uOE!s~J;Iy}+@K@vpUBv3z`A^WbXRxTEYquC(%fd6mAwQO6Bb$xule<3iaW#D{ z63r+a&#ld=wg#?nWLMNh9A-S9T~S|rjzh4Ef z;*WW_FjG)t3n7wG&wsgE=3+y4w5c0mA*8EL4K#HNp#zrs)L^@iZu4qK z6y(Q2K1I7FC6H0>utZ=%DAeSY8!cE#iB#`gFYRh}g%d%LQ8T-un)tluslw1}LDBkJ zHT|lZfBY8MtcgRV;EL*TFfOzaDY9&jnqFyEj?^o2^h&iD7NhgUokTapC#=&y>zbc& z=4ZV5+1mWN^IfsVzJUO> zy@@*}_VEV$yR-qGD4({^*X%cx8kVLY8ZgJ7!7o~tjW;I3^~d$ZQN0%?!fPTvf{|TB z^#r5(Pow%2K0;3!)gDnj$*5j!R38!59gS+YsLnE~KQ^kji|R&3^)dXOX<4>Woo!SX zi0X`{zRdv?(#rRPPn6*!<$&F1lNHL zq`|jN_*)77Qz4w+5zarT1gndr6zu6r7B%$*NQB#!U@I{P)3+m{yvpK+9lRYHMrD4W zrsKYAyeHfnh^d=+d*)QH|GI19_>^Gpy0GV9vtsWuvDRq9SWOrU*@mjNO>MTPv$8m% zO^2FF?)}i~O}wJyl);K*QE&;@nZ&Mu`5ce?sh^<>*h*oq>KLm z5!`!uaciOELlyshX1Wkm9U8F!h& z+B&_#$R|XDt79HZJg0n6pe)|*3%WY{H0-@Z9z(DWn};Fa0TYna+lX&3gGr0=5&9mt zR;cbKs(&}C>loFait6b`b-bwFWmKOR->3(Z-WJs_qS`zsEqj~I-RzSckX=)>iWKdl z*4u-YEvG(SQ?`u1pYVge! z-_*v&%jc<^8vK66LX?AxSNu@h;ayT&Tofma(+b2L{+KgJhQZ1E7a8*5DZx1%A(#^U zwIeR`F2O1bdHhke;!p~NmxzmTijuXW`f^A(GL>LYjB&`RCW*nzJc=&FED={2Li?cE zkr`@%rz~Epq`cf2HQwEk13kezE^bHRVll=0OZQ?AlFxCA}@!|$8zz)?mRb}NBdo~^jT7knIH@f6N0p04m|dv))4 zmx|L6sNHs>c}VWMd10n$M&GK9Ef(epWu@PUX&s!U`yF2ObQ0kxoa9|1EM0ml{)8Hy z5<>2cbE6&J6@u|;hs9ZvvN$Shh3-;^l6zi^H-ZQE^{&i6y985*)YeBgH5mCAE=&#P z=z6ViN6w3JB4@R8IL|3R#7uU=blkZ6FWs7XRKE@av#N`L_bNZknk;64DU#$6!FdSv zlUE=jo%v=EC2g1^l21%^)GVyNQdFJOugw!P$x`1abH6438kZN-#*`PchU6P(?hkbI z1SeNiqI(GM=gOT~jx065JkD8^e_hGH)TCLFHqsLw^eu1%ebvMA4}~S>E5UMj$v@r` zh5Ja6mh@x6RIMUayBIot0$;{p5ppaOe@t>a$N;8W_6afdmSO;`nk7a}JdSZV{RwC< z&P}fA-wByorh>$I&BP9BuvG+lmmD18!N?^$Q=Ds*#mVr_ESEkxMYx#P^usl(zX(TE zC7JtFF-oXYo8k6sH~wkpYB-#mwpI+SIZ5?1(eHAOLa0={>EEkuEL9Lh+V$K@W!hPE zDK&kFr)6r`5Ko*}KL|yNh(i8~N!2`_(hqQ*7Y03u4UIA@Pg$IoeZ3N{T`vA8Jr1C` zDh^v*YB>xSTV{U((i`aJ%FWAsIwkPXlqSmJ;whN(yDx5?(yiJs9Mnwd7N+`(T`Af_ zsp)^EYDd&SJ5T5~Y>U#IcQ-rWMVHlV7uG(6^Me>bCD;zei+pB`TTVKrU@3O0mHNGO zvwZy^&UD&cqILfyY#jYqMYP#iCfeg_EHWEY^kw4JN3cw!B*3)+mnRUFf5NQ~xq11~ z5cZPw>?$$U%&PUM5|cPJu`J^;Rcq++1@7``CH|5oT1Z(uRUf`U@0?Di_A z@tgm8RK|b&*P}DPvh}iIen~X>h1b7Y+!Z;LX{|7JX~8eWoscn1xZCy^8%>|q(vun( z>4_^9N3giz@?6}DTe-c+@mU-hXKWz)Fj0lRGsFI3zIWK4R*op{Y@`Zo2{NY21&rack;YW{q^mwv26n?#X^dSfs&|R%QAYI}Ms*)i zUD*cdalEJHgNQ$6YCq`GGpZ4}WsTMJA`FkKxOuZEBzrL9wbD0YTmr%SAs zE@gTP)cJ65Ha!;wt;m;Hq6FVXQAKCEWS_{vq!SR?1meYK}G$->~wR7m1 z&(l$OE)jD|&oauR1sIf;NJK56wK24c)9>6b(IU1^@fZI@Us?*+-hNuR4eA9UszUw# z))$g?*;kstdS&_)agEQ@!GEcVGW|UO?3?{LGj%tqbKx+3wL?Fg$}~|e`l7qe@NMa8 z{SsVNq!r;ohiO}Zz0bu|*Y8D7L~Gdf$ISEvI^#reZT2y7W8~9vei3nmLt)i<$zO_d zfHe~eFu3*qgTY;E4DNiNKK9d-F}QcO*2n%TewDFogHipaQT?K*4nsA%pE=5h4!V4a z8J-wro>){x$K#T?K<|{5p1I8cy@!wT(>5yDAd*C4~00ZU>-nNp^2&vR#hjf zpjw5VR-vC&7;F`WTZI>`!Z@RlN&c)#fDq>X8W}D=oYTRWgi#y&D=)Iz+FW4CyYTt^Um;#5z>jw89-C)QWBQ1Efs-+Q*JSnNWv;T2i3 zAoHw>?Q&p@)*h|yxfVDv$6r1UWnOo&WktKJBu1M~N?SyeC4LdI(Iic1>T`^xauT=W5H8uS=Wp(F@ z{6kT`8kaO*(2;mPBVOCn=B%=Ez5i^JCD4_H@3Hc6-5rHBeoIOGBXgbCzs8C07Rm<0 zvTv}~*1m+`gmjRm?=ihWZhilsHtHEnZppygZM;P?sXJ zN!I@I-m%Y{cvZ>ihmQKR3SYAeFi4nD;!P}4rrilze5;tgSt~BRinjE@^{&vz9$66f zLH1}$`sUPN@2OGA+M(6BqSE-r6E|jFeRV8*Cv;DLDR(%cM9@Zf9C$P$gxh)jyLzl> zHztzCdLl``pgJp5t(^y6QG>3U;%pQ%w63^?YmKO0Ivo2;5klhFLe*yJq^d3SbU-B% z3z{xhr$B_T*bZ%wnVK$rB0j>n>9Q@@R|QowT!PYZ@!0LTi~2QpPA?oo0*Z=Q{j7C z%uVoYZUz>5ROs^`!*11XcLp@C5`7Wv`T;N%lwU(cy(mm62u#(lWsd{m{0b)sy7l62 z$|xcwiYCN=B0Y98%i7k9TZdt7%Iu6sEU=c>Rh#X_?rYM+x#bxTYUQffNZ~P#%Fq)y z*jAlombw(@Y5i^`^GX zetu_uE-*j8H$Q(6pQ6QFz7(z?L&K&!t&gLh%W1d*aLc(h_jic z2yVwR@h7wvH)>*iNe;Gji4Ekm<}glAC00vij|%mzL|Y;f1^5Kh4EANT#M*)Ih%mxr zVZ_^LH>g%qotu@#k5o>nDV8WT@m%KF;DE3&Ut*aO#B&t7hCdI9vB>bW)~ygakNhQc zM&nDaOLZ~^_%B6eOi|N!Ov#B6%7afi%T^1iFK``oxxQ(}{2R=eYMAjN%s7jkq+!E` z%)f;VrT8)k-`|`L4H9~U0|eNvH~o*2gG`8BEbEe`t7cVQwMttEX(R!o_eRhm&Ds$s z_He^4;4mTm=p(^)cZr-RVovNuV_3*_fruV*rBkq}w5H(jtH>fatw;+_s#Y3{LDA2& zl$=aaG!D!squ5FWllVp;=-xb8oNcv3?zKbYBDRp&x4t5(RyTawStz1G7_m%5yXgG$ zkVs8GgzN8xkT`9N6Z9(3T0s|OwQs1yxiuAcG;w%z256INA(w(Rx-<&~BZ<~DlIWip9c!dk zUAD_Vql||ig!woeN!5-CU+zC3wkmpY8;YU|^}?gr8LbwK-k+0tL@A4_i^q%V>bsU2 z8)_8fAHwrQV)vPUBu=eSkfPn5qV)}jS-77OIuK1zgs=4TaDOGriG^cNlpcb`Q1$=B z&!sb=EL4eeF7d7JO->g6VOs;^Fd>-G;-4rHUzI!XMR@O__>vUQYKf=#3h!|^R#$7{ zz%S*Er#*DG;%-D^(Ea1TaATu)BIy3vEW=gqg=QJ2MebkBatCqq(g`Cg_7Qc>PyOk0 zT|K^=JusxMqcSQ*E7F^I98IJm<;39xPKAz?;$lo-3=D1xFY2SJKT(nz{5QBG;@grm zJb8s(LhTg)+VGS>dpxa@xveZL%~>LzNNXtWJuuf29yx`RYwfhIA@o`tVgWaib;YA= zO3sYC5O^QyH=+UewAb-9brkGc@T@545>{Qoi&d!8uU4U2K3#?S$y#8&gx=BAsn z)yRO@NhTGB?+6vTRAF7d`jslw$>(iK zobw`7w*4DawdCiHMj=joI3dQlk^T%&>1fOoqj)FIP|V_JJQimb_uIwgxRWs1_mJ_; zVxL#3I5L}xHQu1&lNuFQzD31xQ>l1)8WnGuNyQ)DqvF>0kyx^?iRYq}=_lc0jCS8= z#8V9pJqDxUqt#)0@TX|S#?gXzm55#Zf@E)!2&7VfiDe#(IZWP_ho@M4T0J(m;$q8fuV*#qlu=#=RG7(`V4`omXXiO z8tyU#J{w?acuUq$%@BCTa@2#ehQqrJKZw8=-E1WbL&|$41so*qk6~!VTM2pOGC0OaO8L04|Se1ZRjWqlEhAM~pp_vo-*VId*@g&1V5619>dP9+ zw&{Mj)tVP|WPuHazy@o$>&Z=gZ3rywYmUXSM9EQ841thk!$Dc#Swmos<)}YZNkdmd zptdz}4#)yc4S{*q!n$7;a2WzQxS`Nva;$8_Ut4uQyl;)>3$j3gA#kOasbRP*@QESt zuGn{rupcMekYxzWwFElL8lE-;PCssH=qL+3WC&cay4hA1Xk-YuttMK_0@t?a-SkRDaU~*409+G8&dkujLR!n+jfk;E3k+{bcF_|a}oZO`Q zA?7htpsg(Mn<3D^ipl$Afo}|fm#vU%E(>Uez)RNbZXyc|Hw1cGp1f5S=w=8g)?kIp z0(Tn%i>+<*C7cf25Y=u&V4!8gEPUsDgTT>^x*z`TZTexetf9~l=x)VBu`KYZA+XF^ z{U4K?$TkFCwKVjU1qK@eJ*|Dzc)5v(4T0*`)N3zmXlw}lX+>0$EO7ldy_-9&i1Nt- z`wfA1R-TNJZCGvy^wPKPY53-%c`|+j)F@3m?G1LVObccd;iTo^&<-4<;DjqYEwLi= zv^a_>0Ab$7_nSe*gLX0OZDQ}Si^J{WRJ*vzF4q1JU3R}+e8n!#v5U*?;z7HZI+HXk z$KAhapdQy+UKYiGyB1QoAFn~X4d-yLxy9L`ap34j))WVh#(B}bztDBLcJZ7j2HgEp4Hf;M z;_s98ndPBJ4HdzJPs(lfEi4Jf8-m_DWwR%dS`2pSX`5Yz&46u$e<2wWw}^@@7VAdL zM1Dj+l$^iA#5rif-aGBS%)vTlDF3OE%{DWSRD%gi89Vb4OZG>mVG*<&8h&7G6Ox_9 zH1vl@4cYe@I}>TiU_W4NIoU9eu}!cT7_uKSc0H0xRSi3kFsrt<2n&+IzRNV6CJl2L zdlomphU`0xeUN-Mo3V||s0b#^WbA3O;XjPkuvs+p&S2~aY(fooI%6Zr-XLQY?1>H8 zsf;~Lmc7N;Fs!hKtj5@(WZ7iK?jrV0#%3d{8ya#LyMspF&)9NmjkBZ4lbrREUe4CK zscagJ5Vzr1(vZt+sF7yb%X`s9wOB4&lwz^mhA(M^-e7v4!?w`yLl$FgdnYk=6P77M zb|PaxLP9Xu@r-@9pT)k;*fL5IoQ=f#XlUTt4Wh^_j%OS^2IMW>QfcvlRw!~O$yR7_dwHI(FB9ipXH%5Gq8BEAydgjwetY+*S z@-Al|!`{s3R}qtapJrw;V;7JQHZb-gWruByeVf>wjID*urqS9S#xA0WJiyp5X~yqo z>|+#rob66?`z7q0EN?|p(6@|zANwuC-me+k%FJc~ccC$oO3s*C z`Y3$Bq#mUl@*l?Tp;4I1*jvf7e#QU`R2jR4)>a>5Qz(`m zW^7nDOYeh>ZAuy90mlA7Yt_As%_jCP#z)vHzmh z<}>y%`QbgrwtdFxG2ba2plr%_G`Eute9bPUe9Twe-#S}*Ut_Heq zK*sJO|Mp_+dWxv-jQxd1Glj7SXm)pDY&VJ$&ekByl9+4@+Dkmh*a>9sLyYZ9`@KZQ zZcDaCK7q0OXuh>(Y$j#pmW;ifM)MxVmUgoA-o@Cq4_j;MpISS}*!h$R_A>SdnnS-cHk&kTVQe}@ z>RQImrjcL8*pDdNFJf#P8u!!X1 z82fCJHO4uN{e)Jh@r+&mkS<#~2Tw5KIj)8dWr}zs7Ixj2k*|&C^mTsXBj6%^oO4d> z3GNQ~!IrD0Oi#h}H$1}gF!G8PrQ{@`qBMCw9t07O09jAJEbSs{Grli%%QeNY7&Tv& zR_xOsG84uYDvLjxOU84RuV_ z#NOamKEOHW#7uC_Zs>b8Wm<&Mbpai7FD+R2C}_QW_(iGMX1x?SX9~Vsn4+?GxP1kj-6*{8D6PI`j9*^k_)S&Ao5><7`Vbu`>Q2vVhYT-Q}ND8Ph@ zut{IT=l1lu9}QrV;1|7kK;?$f7$?sCqe?^20^XhsbFqkkuWj&l+gWLOceUUFpPQv>8fvr9*t)t|irJ zR}b$33%Z}cr>eQD$1qaTS;_G zt(EA0KKz(Oi|i#-32SjzUDyh5pb}4^8&4_rzE)9L_U2l53s{C11-Orj1~hjceCWSk z6GjHyb)Z1}v|GG`K)mr`u5M8<_SpT94(3#gL4@Lco>3jdpBG)??{NLyy@Mk}xnGp{ z+cQS|RmFQ=qdMXJq*3GI@aIJs9W@*;IE@;Nca%o;6R$EA_D8AWg`%B0BBa)#6k(cM+@z`ccO*%=uRE|t=d0`j{B4D z!-pd?B0H%U8qfWC<_Uf=&uaxw=y37zyq(zkTD*14K!+? zUvWIN_6rd>qg@^)It-twc!x`Lcf4P9bZ-wvs27YIJ-~w@daAW}Y*$S8WJe}`9U*=T zSQwhu)CfEMrKEGwiW0w@w`TlQu1y|X zb3pw}lf4l!B%)ya6L*hp|MnspiG=QxtVTdNwiZX=v?95LJpy}3(?7H@nV zJpvuYZy!;51s%mhwkW-hj^ZZ=l?y#0>i*Xsp_B7|lwqFeW^|?@hH&f$P!bNy38~%^Vz&Pvg*2VjE^;hqX#P3hz zH=!2)>qO+D{&)ia-hAb~JmUw0$ptxi8L`G2+ytu#Ldi`OYaQAdDHe+1P>n~Mp~gKC zmxt0yD@4;qMXLUq>sAAW-gvyZdB7iHilG;H&2PSVK{DRY+rI$Ki}&neP(dFS66hg{ zSA@h7NE{K|0KA|@iAP%NpRdI4$2Gfgjp29jdxY#hRN`%P{V(I))rGibfd2mC9DO|S z1DKEDO7S1;ID~75crtLIcqw&(-H_4`Z+wjY+>;~Zpi;D_SFcy%aZ$g+dhIOKLgD8^ z8~y`-5c~k~cHsfymBYrsLi2Azhj=YB-ocCty`MQAG0wRBEB#_U#K(&wDE-~2M)3o) z7V5t9dfoC> z7Qih~USY=X>!PKFo;>JPqF;#vFkb0`>_L$&rW5THGXIU}7UEA8D)C5DkCmfWBRvfj zycqCdM2q{uz9Lf$!sY}BzXpZJEuA&k*pe_UqFUcAK_>k7gprgRJz&d}9P*w!rz zx$ZC~4JD?VXQi8EBjl4*7$Bzhw^aQ?kg_;$fESRQ5KZr7Z z0;HFp5@YwdnU&H-W8ayhI)cXT=2_{pCjTP`M^)DcrxOOU8`^@ueWHk#P*g>+wO&jW zMVDUeDT>CJ_7+9B1+x7_5$i3A14J=gFAf&Px_WVlD8}o>;iA|H_{hirS4xk^MH}mH*KYJ`|U+O9JCws z08c+qBpi|79@Y zcNP5=0nkr;>WzHy7!oxu+H7284wC)?;yhS|cfcB3iQ8a|7)=Z}q5%^y6}1!vN?+V# z3_7UC!2l5l`2Q#_J*o69Ma3ypjI_p7Pn}QS^M5m@c51bkMRUU!YWqQzF}-2qw$PlU z`tn8#-~VBfX4N;w6v+a2s_tzq^_yIAf7465g168H8dc!vLVMk(y`l!X^wieopK9V< zyR9P7B^7TkKi$Mxysa|y{_T~OtHpg==qHpy1Ms`~Kra>Q3UFfvTDac5Q?HJW+=fpgjccMK*BF(tc~)hoDM?FE?ldLgXM9YFT_FBOeq~h)U!bj~ z8G2j&_n%i<{-!JzFAM%1#qD_i35pw0JlhFx#6uYwq2(o%D?|UT%kE`OJ&jr#dhid4 zSQle|MHjb({+~3!CihVzK>(?nSSA9MP=!D9MEtZ-_^xShk_O{jb?F+f|UfTdX)R~R`ndp zefcjpKxVwbDTOVB;idQCD&;+nxUpxpyFH)ri$z}o|$4Q~dyLB}LR zhw*BGgu^#pQvkYDyf;V$Ox0mChj(gQVTQ1D7)&si8;^#^f>UKdM?k+=1Wp;vglyr~L=b%*J;@dNbmd zRzGg*z;5Ru-X<@%a^g6DW%#7Qcq9Iysro|fI&6G~A2B{7{xUwJjvAjaCB|pnW5#F0 z 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 z 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й69CVd{`jwdxuj(JW8L*0J&i%E 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 z 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 #jKA+5fe04*nr4m@|Hl{1TRa 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 z%0A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
pVPdB+5_=O3RMqmh}< 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

rbjGh7q3l|TnDVA#K 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 literal 0 HcmV?d00001 diff --git a/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.500 b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.500 new file mode 120000 index 0000000..5d745c5 --- /dev/null +++ b/raylib-src/raylib-5.0_linux_amd64/lib/libraylib.so.500 @@ -0,0 +1 @@ +libraylib.so.5.0.0 \ No newline at end of file diff --git a/raylib-src/raylib-5.0_linux_amd64/lib/raygui.so b/raylib-src/raylib-5.0_linux_amd64/lib/raygui.so new file mode 100755 index 0000000000000000000000000000000000000000..7ffcb0770bd8ddf5792ac3b100285c5dbc461f19 GIT binary patch literal 1320304 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%0A8);{WLLb!$18_@cDp#as4FFSE>6x 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�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%0A9}jnl-oWVam%qyXNP}WI@Bu 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ˋ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 literal 0 HcmV?d00001 diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..8b1754d --- /dev/null +++ b/src/main.c @@ -0,0 +1,349 @@ +// DoppelspaltApp.c +#include + +#define RAYGUI_IMPLEMENTATION +#include + +typedef struct { + int lambda; + int gitterD; + int winkel; + float dLambda; + int amplitude; +} AppState; + +AppState state = {50, 75, 90, 1.5, 40}; + + + + +void DrawWavesFromSlits(int screenWidth, int screenHeight, AppState* state) { + int xSpalt = screenWidth / 3; + int ySpalt1 = (screenHeight - state->gitterD) / 2; + int ySpalt2 = (screenHeight + state->gitterD) / 2; + + // Calculate the field size similarly to the Java code + int sizeFeld = sqrt((screenWidth - xSpalt) * (screenWidth - xSpalt) + screenHeight * screenHeight); + + // Draw waves for the first slit + DrawKugelwelle(xSpalt, ySpalt1, sizeFeld, screenHeight, state, BLUE); + + // Draw waves for the second slit + DrawKugelwelle(xSpalt, ySpalt2, sizeFeld, screenHeight, state, GREEN); +} + +void DrawKugelwelle(int x, int y, int breite, int hoehe, AppState* state, Color color) { + const int apertur = 90; + int s0; + double phi = (state->winkel - 90) * PI / 180.0; + + if (y > hoehe / 2) { + s0 = (int)((double) state->gitterD / 2.0 * sin(phi)) % state->lambda; + } else { + s0 = -(int)((double) state->gitterD / 2.0 * sin(phi)) % state->lambda; + } + + for (int i = 0; i * state->lambda + s0 < breite; i++) { + int radius = i * state->lambda + s0; + int xOffset = x - radius; + int yOffset = y - radius; + + if (radius > s0) { + DrawCircleLines(x, y, radius, color); + } + } +} + + + + +void DrawInterferencePoints(int x, int breite, int hoehe, Color color) { + double phi = (state.winkel - 90) * M_PI / 180.0; + double s0 = fmod((double) state.gitterD / 2.0 * sin(phi), state.lambda); + int nWellen = breite / state.lambda; + int tempR3 = breite / 80; + if (tempR3 < 5) tempR3 = 5; + + for (int i1 = 0; i1 < nWellen; i1++) { + for (int i2 = 0; i2 < nWellen; i2++) { + double tempR1 = i1 * state.lambda - s0; + double tempR2 = i2 * state.lambda + s0; + + if (tempR1 + tempR2 > state.gitterD && tempR1 <= tempR2 + state.gitterD && tempR2 <= tempR1 + state.gitterD) { + if (state.gitterD != 0) { + double tempY = (tempR1 * tempR1 - tempR2 * tempR2 + state.gitterD * state.gitterD) / (2.0 * state.gitterD); + double tempX = sqrt(tempR1 * tempR1 - tempY * tempY); + + int circleX = x + (int)tempX - tempR3 / 2 + 480; + int circleY = (hoehe - state.gitterD) / 2 + ((int)tempY - tempR3 / 2) + 10; + //int circleY = centerYBar + (int)tempY - state.lambda / 2; + + DrawCircle(circleX, circleY, tempR3 / 2, color); + } + } + } + } +} + + + + +void DrawSphericalWave(int x, int y, int width, int height) { + const int apertur = 90; + double phi = (state.winkel - 90) * PI / 180.0; + int s0; + + if (y > height / 2) { + s0 = (int)((double)state.gitterD / 2.0 * sin(phi)) % state.lambda; + } else { + s0 = -(int)((double)state.gitterD / 2.0 * sin(phi)) % state.lambda; + } + + for (int i = 0; i * state.lambda + s0 < width; i++) { + int circleX = x - i * state.lambda - s0; + int circleY = y - i * state.lambda - s0; + int diameter = 2 * (i * state.lambda + s0); + + DrawEllipseLines(circleX, circleY, diameter, diameter, BLACK); + } +} + + +void DrawPlaneWave(int width, int height) { + double dWinkel = state.winkel * PI / 180.0; + double nX = sin(dWinkel); + double nY = cos(dWinkel); + + double d0, d1, dMin, dMax; + if (state.winkel < 90) { + dMin = 0.0; + d1 = (double)width * nX + (double)height / 2.0 * nY; + dMax = (double)width * nX + (double)height * nY; + } else { + dMin = (double)height * nY; + d1 = (double)width * nX + (double)height / 2.0 * nY; + dMax = (double)width * nX; + } + + d0 = dMin + fmod(d1 - dMin, (double)state.lambda); + for (double d = d0; d < dMax; d += (double)state.lambda) { + int x0, y0; + + double schnittX_Achse = d / nY; + double schnittY_Achse = d / nX; + double schnittX_breite = (d - (double)width * nX) / nY; + double schnittY_hoehe = (d - (double)height * nY) / nX; + + if (schnittY_Achse < 0.0) { + x0 = 0; + y0 = (int)schnittX_Achse; + } else if (schnittY_Achse < (double)width) { + x0 = (int)schnittY_Achse; + y0 = 0; + } else { + x0 = width; + y0 = (int)schnittX_breite; + } + } +} + +void DrawVerticalLines(int breite, int hoehe, int lambda, int winkel) { + double dWinkel = winkel * PI / 180.0; + + if (winkel == 90) { + for (int i = breite; i > 0; i -= lambda) + DrawLine(i, 0, i, hoehe, BLACK); + } else if (winkel == 0 || winkel == 180) { + for (int i = (hoehe / 2) % lambda; i <= hoehe; i += lambda) + DrawLine(0, i, breite, i, BLACK); + } else { + double nX = sin(dWinkel); + double nY = cos(dWinkel); + + double d0, d1, dMin, dMax; + if (winkel < 90) { + dMin = 0.0; + d1 = (double)breite * nX + (double)hoehe / 2.0 * nY; + dMax = (double)breite * nX + (double)hoehe * nY; + } else { + dMin = (double)hoehe * nY; + d1 = (double)breite * nX + (double)hoehe / 2.0 * nY; + dMax = (double)breite * nX; + } + + d0 = dMin + fmod(d1 - dMin, (double)lambda); + for (double d = d0; d < dMax; d += (double)lambda) { + int x0, y0, x1, y1; + + double schnittX_Achse = d / nY; + double schnittY_Achse = d / nX; + double schnittX_breite = (d - (double)breite * nX) / nY; + double schnittY_hoehe = (d - (double)hoehe * nY) / nX; + + if (schnittY_Achse < 0.0) { + x0 = 0; + y0 = (int)schnittX_Achse; + } else if (schnittY_Achse < (double)breite) { + x0 = (int)schnittY_Achse; + y0 = 0; + } else { + x0 = breite; + y0 = (int)schnittX_breite; + } + + if (schnittY_hoehe < 0.0) { + x1 = 0; + y1 = (int)schnittX_Achse; + } else if (schnittY_hoehe < (double)breite) { + x1 = (int)schnittY_hoehe; + y1 = hoehe; + } else { + x1 = breite; + y1 = (int)schnittX_breite; + } + + DrawLine(x0, y0, x1, y1, BLACK); + } + } +} + +void DrawSinAndWall(int width, int height, AppState* state) { + int xSpalt = width / 3; + int ySpalt1 = (height - state->gitterD) / 2; + int ySpalt2 = (height + state->gitterD) / 2; + + double phi = (state->winkel - 90) * PI / 180.0; + int lSinus; + + if (fabs(phi) < atan((double)(0.5 * height) / (double)xSpalt)) { + lSinus = (int)((double)xSpalt / cos(phi)); + } else { + lSinus = (int)(0.5 * height / fabs(sin(phi))); + } + + Vector2* points = (Vector2*)malloc(lSinus * sizeof(Vector2)); + + for (int i = 0; i < lSinus; i++) { + double x = (double)(i); + double y = (state->amplitude * sin(1.5 * PI + 2 * PI * (double)(i % state->lambda) / (double)state->lambda)); + + points[i].x = xSpalt - (x * cos(phi) - y * sin(phi)); + points[i].y = x * sin(phi) + y * cos(phi) + height / 2; + } + + for (int i = 0; i < lSinus - 1; i++) { + DrawLineV(points[i], points[i + 1], RED); + } + + + + int RectWidth = 5; + int loch = 5; + + DrawRectangle(xSpalt - 2, 0, RectWidth, ySpalt1 - loch, BLACK); + DrawRectangle(xSpalt - 2, ySpalt1 + loch, RectWidth, ySpalt2 - ySpalt1 - (loch * 2), BLACK); + DrawRectangle(xSpalt - 2, ySpalt2 + loch, RectWidth, height - ySpalt2 - loch, BLACK); + + + DrawVerticalLines(xSpalt, height, state->lambda, state->winkel); + + /* + DrawText(TextFormat("Wavelength (lambda): %d", state->lambda), 10, 10, 20, DARKGRAY); + DrawText(TextFormat("Slit Distance (d): %d", state->gitterD), 10, 40, 20, DARKGRAY); + DrawText(TextFormat("Angle of Incidence: %d", state->winkel), 10, 70, 20, DARKGRAY); + + */ + + free(points); +} + + + +int main(void) { + // Initialization + int screenWidth = 9 * 1920 / 10; + int screenHeight = 9 * 1080 / 10; + + + //SetConfigFlags(FLAG_WINDOW_RESIZABLE); // Window configuration flags + InitWindow(screenWidth, screenHeight, "Doppelspaltenapp in C - Raylib / Raygui"); + + // Define initial values and bounds for sliders + float valueLambda = 50; + float valueD = 75; + float valueWinkel = 90; + + // Define the height of the window box and sliders + const int windowBoxHeight = screenHeight / 8 ; + const int sliderHeight = screenHeight / 50; + const int sliderSpacing = screenHeight / 100; // Space between sliders + const int sliderBeginY = screenHeight / 20; + const int displayText = screenHeight / 25; + + // Define bounds for the window box (bottom of the screen) + Rectangle windowBoxBounds = { 0, screenHeight - windowBoxHeight, screenWidth, windowBoxHeight }; + + // Define bounds for the sliders inside the window box + Rectangle boundsLambda = { sliderBeginY, windowBoxBounds.y + 10, windowBoxBounds.width - displayText - sliderBeginY, sliderHeight }; + Rectangle boundsD = { sliderBeginY, boundsLambda.y + sliderHeight + sliderSpacing, windowBoxBounds.width - displayText - sliderBeginY, sliderHeight }; + Rectangle boundsWinkel = { sliderBeginY, boundsD.y + sliderHeight + sliderSpacing, windowBoxBounds.width - displayText - sliderBeginY, sliderHeight }; + + SetTargetFPS(60); + while (!WindowShouldClose()) { + + + // Werte in AppState aktualisieren + state.lambda = (int)valueLambda; + state.gitterD = (int)valueD; + state.winkel = (int)valueWinkel; + + + screenWidth = GetScreenWidth(); + screenHeight = GetScreenHeight(); + + + + Rectangle whiteRect = { + .x = 0, + .y = 0, + .height = GetScreenHeight(), + .width = GetScreenWidth() / 3, + }; + + BeginDrawing(); + + + + + ClearBackground(RAYWHITE); + + + DrawWavesFromSlits(screenWidth, screenHeight, &state); + DrawInterferencePoints(100, screenWidth - 200, screenHeight, RED); + DrawRectangleRec(whiteRect, RAYWHITE); + DrawSinAndWall(GetScreenWidth(), GetScreenHeight(), &state); + + + GuiPanel(windowBoxBounds, ""); + + // Adjust sliders position relative to the window box + boundsLambda.y = windowBoxBounds.y + displayText; + boundsD.y = boundsLambda.y + sliderHeight + sliderSpacing; + boundsWinkel.y = boundsD.y + sliderHeight + sliderSpacing; + + //GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control + GuiSlider(boundsLambda, "Lambda", TextFormat("%2.2f", valueLambda), &valueLambda, 10, 85); + GuiSlider(boundsD, "D", TextFormat("%2.2f", valueD), &valueD, 0, 150); + GuiSlider(boundsWinkel, "Winkel", TextFormat("%2.2f", valueWinkel), &valueWinkel, 0, 180); + + + + + EndDrawing(); + } + + // De-Initialization + CloseWindow(); + + return 0; +}

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