From 5adeb405685d4eeab3c53db3e3a16299d4b3ce17 Mon Sep 17 00:00:00 2001 From: Daniel Hooper Date: Thu, 2 May 2024 16:00:21 -0400 Subject: [PATCH] Initial Commit --- .gitignore | 2 + Makefile | 90 + Makefile.Web | 399 ++ README.md | 13 + example files/1 toad.shapeup | Bin 0 -> 316 bytes example files/2 among.shapeup | Bin 0 -> 316 bytes example files/3 MikeW.shapeup | Bin 0 -> 1304 bytes example files/bracket.shapeup | Bin 0 -> 472 bytes example files/rubiks.shapeup | Bin 0 -> 1616 bytes example files/wrench.shapeup | Bin 0 -> 524 bytes lib/raylib-4.5.0_macos/include/raygui.h | 5521 +++++++++++++++++ lib/raylib-4.5.0_macos/include/raylib.h | 1588 +++++ lib/raylib-4.5.0_macos/include/raymath.h | 2134 +++++++ lib/raylib-4.5.0_macos/include/rlgl.h | 4740 ++++++++++++++ lib/raylib-4.5.0_macos/lib/libraylib.a | Bin 0 -> 4502584 bytes lib/raylib-4.5.0_webassembly/LICENSE | 16 + lib/raylib-4.5.0_webassembly/README.md | 144 + lib/raylib-4.5.0_webassembly/include/raylib.h | 1588 +++++ .../include/raymath.h | 2134 +++++++ lib/raylib-4.5.0_webassembly/include/rlgl.h | 4740 ++++++++++++++ lib/raylib-4.5.0_webassembly/lib/libraylib.a | Bin 0 -> 1288642 bytes src/dark.h | 593 ++ src/main.c | 1929 ++++++ src/minshell.html | 55 + src/pinchSwizzle.m | 35 + src/selection.fs | 45 + src/shader_base.fs | 177 + src/shader_prefix.fs | 119 + src/slicer_body.fs | 9 + webbuild.sh | 13 + 30 files changed, 26084 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 Makefile.Web create mode 100644 README.md create mode 100644 example files/1 toad.shapeup create mode 100644 example files/2 among.shapeup create mode 100644 example files/3 MikeW.shapeup create mode 100644 example files/bracket.shapeup create mode 100644 example files/rubiks.shapeup create mode 100644 example files/wrench.shapeup create mode 100644 lib/raylib-4.5.0_macos/include/raygui.h create mode 100644 lib/raylib-4.5.0_macos/include/raylib.h create mode 100644 lib/raylib-4.5.0_macos/include/raymath.h create mode 100644 lib/raylib-4.5.0_macos/include/rlgl.h create mode 100644 lib/raylib-4.5.0_macos/lib/libraylib.a create mode 100644 lib/raylib-4.5.0_webassembly/LICENSE create mode 100644 lib/raylib-4.5.0_webassembly/README.md create mode 100644 lib/raylib-4.5.0_webassembly/include/raylib.h create mode 100644 lib/raylib-4.5.0_webassembly/include/raymath.h create mode 100644 lib/raylib-4.5.0_webassembly/include/rlgl.h create mode 100644 lib/raylib-4.5.0_webassembly/lib/libraylib.a create mode 100644 src/dark.h create mode 100644 src/main.c create mode 100644 src/minshell.html create mode 100644 src/pinchSwizzle.m create mode 100644 src/selection.fs create mode 100644 src/shader_base.fs create mode 100644 src/shader_prefix.fs create mode 100644 src/slicer_body.fs create mode 100755 webbuild.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d5697ec --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/ +bin/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b61e130 --- /dev/null +++ b/Makefile @@ -0,0 +1,90 @@ + +CCFLAGS = -std=c11 -g -Wall -Weverything \ +-Wconditional-uninitialized \ +-Wenum-conversion \ +-Wimplicit-fallthrough \ +-Winit-self \ +-Wmissing-field-initializers \ +-Wno-bad-function-cast \ +-Wno-declaration-after-statement \ +-Wno-double-promotion \ +-Wno-error=deprecated-declarations \ +-Wno-error=incompatible-pointer-types-discards-qualifiers \ +-Wno-error=shorten-64-to-32 \ +-Wno-error=unused-but-set-variable \ +-Wno-error=unused-function \ +-Wno-error=unused-label \ +-Wno-error=unused-variable \ +-Wno-gnu-empty-initializer \ +-Wno-gnu-statement-expression \ +-Wno-implicit-float-conversion \ +-Wno-missing-prototypes \ +-Wno-missing-variable-declarations \ +-Wno-padded \ +-Wno-pointer-sign \ +-Wno-sign-conversion \ +-Wno-unused-command-line-argument \ +-Wnullable-to-nonnull-conversion \ +-Wshadow \ +-Wstrict-prototypes \ +-Wuninitialized \ +-Wzero-length-array \ +-I build \ +-I lib/raylib-4.5.0_macos/include -L lib/raylib-4.5.0_macos/lib -l raylib -framework Cocoa -framework IOKit +# -Wfloat-conversion + +run: build/ShapeUp + ./build/ShapeUp + +profile: CCFLAGS += -O3 +profile: build/ShapeUp + +sanitize: CCFLAGS += -g -fsanitize=undefined,address +sanitize: run + +debug: build/ShapeUp + lldb -o "run" ./build/ShapeUp + +build/shaders.h: src/*.fs Makefile build + (cat src/shader_base.fs; printf '\0') > build/shader_base.fs + (cat src/shader_prefix.fs; printf '\0') > build/shader_prefix.fs + (cat src/slicer_body.fs; printf '\0') > build/slicer_body.fs + (cat src/selection.fs; printf '\0') > build/selection.fs + cd build && xxd -i shader_base.fs shaders.h + cd build && xxd -i shader_prefix.fs >> shaders.h + cd build && xxd -i slicer_body.fs >> shaders.h + cd build && xxd -i selection.fs >> shaders.h + +build/ShapeUp: src/* Makefile build/shaders.h build + $(CC) $(CCFLAGS) src/pinchSwizzle.m src/main.c -o build/ShapeUp + +make_the_bug: build + $(CC) $(CCFLAGS) $(BUG_FILE) -o build/bug + ./build/bug + +build: + mkdir -p build + +bug1: BUG_FILE=bugs/render_scale_bug.c +bug1: make_the_bug + +bug2: BUG_FILE=bugs/keyevents.c +bug2: make_the_bug + +bug2: BUG_FILE=bugs/keyevents.c +bug2: make_the_bug + +bug3: BUG_FILE=bugs/exportpng.c +bug3: make_the_bug + +bug4: BUG_FILE=bugs/textpadding.c +bug4: make_the_bug + +bug5: BUG_FILE=bugs/retina_scale.c +bug5: make_the_bug + +bug6: BUG_FILE=bugs/gamepad.c +bug6: make_the_bug + +clean: + rm -rf build \ No newline at end of file diff --git a/Makefile.Web b/Makefile.Web new file mode 100644 index 0000000..a99656e --- /dev/null +++ b/Makefile.Web @@ -0,0 +1,399 @@ +.PHONY: all clean run + +# Define required environment variables +#------------------------------------------------------------------------------------------------ +# Define target platform: PLATFORM_DESKTOP, PLATFORM_RPI, PLATFORM_DRM, PLATFORM_ANDROID, PLATFORM_WEB +PLATFORM ?= PLATFORM_WEB + +# Define project variables +PROJECT_NAME ?= ShapeUp_$(shell date +%Y%m%d%H%M%S) + +RAYLIB_PATH ?= ../3rdParty/raylib + +# Locations of raylib.h and libraylib.a/libraylib.so +# NOTE: Those variables are only used for PLATFORM_OS: LINUX, BSD +RAYLIB_INCLUDE_PATH ?= lib/raylib-4.5.0_webassembly/include/ +RAYLIB_LIB_PATH ?= lib/raylib-4.5.0_webassembly/lib/ + +# Library type compilation: STATIC (.a) or SHARED (.so/.dll) +RAYLIB_LIBTYPE ?= STATIC + +# Build mode for project: DEBUG or RELEASE +BUILD_MODE ?= RELEASE + +# Use Wayland display server protocol on Linux desktop (by default it uses X11 windowing system) +# NOTE: This variable is only used for PLATFORM_OS: LINUX +USE_WAYLAND_DISPLAY ?= FALSE + +# PLATFORM_WEB: Default properties +BUILD_WEB_ASYNCIFY ?= TRUE +BUILD_WEB_SHELL ?= src/minshell.html +BUILD_WEB_HEAP_SIZE ?= 134217728 +BUILD_WEB_RESOURCES ?= FALSE +BUILD_WEB_RESOURCES_PATH ?= resources + +OS ?= "NOT_WINDOWS_NT" + +# Use cross-compiler for PLATFORM_RPI +ifeq ($(PLATFORM),PLATFORM_RPI) + USE_RPI_CROSS_COMPILER ?= FALSE + ifeq ($(USE_RPI_CROSS_COMPILER),TRUE) + RPI_TOOLCHAIN ?= C:/SysGCC/Raspberry + RPI_TOOLCHAIN_SYSROOT ?= $(RPI_TOOLCHAIN)/arm-linux-gnueabihf/sysroot + endif +endif + +# Determine PLATFORM_OS in case PLATFORM_DESKTOP selected +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + # No uname.exe on MinGW!, but OS=Windows_NT on Windows! + # ifeq ($(UNAME),Msys) -> Windows + ifeq ($(OS),Windows_NT) + PLATFORM_OS = WINDOWS + ifndef PLATFORM_SHELL + PLATFORM_SHELL = cmd + endif + else + UNAMEOS = $(shell uname) + ifeq ($(UNAMEOS),Linux) + PLATFORM_OS = LINUX + endif + ifeq ($(UNAMEOS),FreeBSD) + PLATFORM_OS = BSD + endif + ifeq ($(UNAMEOS),OpenBSD) + PLATFORM_OS = BSD + endif + ifeq ($(UNAMEOS),NetBSD) + PLATFORM_OS = BSD + endif + ifeq ($(UNAMEOS),DragonFly) + PLATFORM_OS = BSD + endif + ifeq ($(UNAMEOS),Darwin) + PLATFORM_OS = OSX + endif + ifndef PLATFORM_SHELL + PLATFORM_SHELL = sh + endif + endif +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + UNAMEOS = $(shell uname) + ifeq ($(UNAMEOS),Linux) + PLATFORM_OS = LINUX + endif + ifndef PLATFORM_SHELL + PLATFORM_SHELL = sh + endif +endif +ifeq ($(PLATFORM),PLATFORM_DRM) + UNAMEOS = $(shell uname) + ifeq ($(UNAMEOS),Linux) + PLATFORM_OS = LINUX + endif + ifndef PLATFORM_SHELL + PLATFORM_SHELL = sh + endif +endif +ifeq ($(PLATFORM),PLATFORM_WEB) + ifeq ($(OS),Windows_NT) + PLATFORM_OS = WINDOWS + ifndef PLATFORM_SHELL + PLATFORM_SHELL = cmd + endif + else + UNAMEOS = $(shell uname) + ifeq ($(UNAMEOS),Linux) + PLATFORM_OS = LINUX + endif + ifndef PLATFORM_SHELL + PLATFORM_SHELL = sh + endif + endif +endif + +# Default path for raylib on Raspberry Pi +ifeq ($(PLATFORM),PLATFORM_RPI) + RAYLIB_PATH ?= /home/pi/raylib +endif +ifeq ($(PLATFORM),PLATFORM_DRM) + RAYLIB_PATH ?= /home/pi/raylib +endif + +# Define raylib release directory for compiled library +RAYLIB_RELEASE_PATH ?= lib/raylib-4.5.0_webassembly/lib + +ifeq ($(OS),Windows_NT) + ifeq ($(PLATFORM),PLATFORM_WEB) + # Emscripten required variables + EMSDK_PATH ?= C:/emsdk + EMSCRIPTEN_PATH ?= $(EMSDK_PATH)/upstream/emscripten + CLANG_PATH = $(EMSDK_PATH)/upstream/bin + PYTHON_PATH = $(EMSDK_PATH)/python/3.9.2-nuget_64bit + NODE_PATH = $(EMSDK_PATH)/node/14.15.5_64bit/bin + export PATH = $(EMSDK_PATH);$(EMSCRIPTEN_PATH);$(CLANG_PATH);$(NODE_PATH);$(PYTHON_PATH):$$(PATH) + endif +endif + +# Define default C compiler: CC +#------------------------------------------------------------------------------------------------ +CC = gcc + +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + ifeq ($(PLATFORM_OS),OSX) + # OSX default compiler + CC = clang + endif + ifeq ($(PLATFORM_OS),BSD) + # FreeBSD, OpenBSD, NetBSD, DragonFly default compiler + CC = clang + endif +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + ifeq ($(USE_RPI_CROSS_COMPILER),TRUE) + # Define RPI cross-compiler + #CC = armv6j-hardfloat-linux-gnueabi-gcc + CC = $(RPI_TOOLCHAIN)/bin/arm-linux-gnueabihf-gcc + endif +endif +ifeq ($(PLATFORM),PLATFORM_WEB) + # HTML5 emscripten compiler + # WARNING: To compile to HTML5, code must be redesigned + # to use emscripten.h and emscripten_set_main_loop() + CC = emcc +endif + + +# Define compiler flags: CFLAGS +#------------------------------------------------------------------------------------------------ +# -s strip unnecessary data from build +# -Wall turns on most, but not all, compiler warnings +# -std=gnu99 defines C language mode (GNU C from 1999 revision) +# -Wno-missing-braces ignore invalid warning (GCC bug 53119) +# -Wno-unused-value ignore unused return values of some functions (i.e. fread()) +# -D_DEFAULT_SOURCE use with -std=c99 on Linux and PLATFORM_WEB, required for timespec +CFLAGS = -std=gnu99 -Wall -Wno-missing-braces -Wunused-result -D_DEFAULT_SOURCE -Wno-pointer-sign + +ifeq ($(BUILD_MODE),DEBUG) + CFLAGS += -g -D_DEBUG +else + ifeq ($(PLATFORM),PLATFORM_WEB) + ifeq ($(BUILD_WEB_ASYNCIFY),TRUE) + CFLAGS += -O3 + else + CFLAGS += -Os + endif + else + CFLAGS += -s -O2 + endif +endif + +# Additional flags for compiler (if desired) +#CFLAGS += -Wextra -Wmissing-prototypes -Wstrict-prototypes +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + ifeq ($(PLATFORM_OS),LINUX) + ifeq ($(RAYLIB_LIBTYPE),STATIC) + CFLAGS += -D_DEFAULT_SOURCE + endif + ifeq ($(RAYLIB_LIBTYPE),SHARED) + # Explicitly enable runtime link to libraylib.so + CFLAGS += -Wl,-rpath,$(RAYLIB_RELEASE_PATH) + endif + endif +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + CFLAGS += -std=gnu99 +endif +ifeq ($(PLATFORM),PLATFORM_DRM) + CFLAGS += -std=gnu99 -DEGL_NO_X11 +endif + +# Define include paths for required headers: INCLUDE_PATHS +# NOTE: Some external/extras libraries could be required (stb, physac, easings...) +#------------------------------------------------------------------------------------------------ +INCLUDE_PATHS = -I. -I$(RAYLIB_PATH)/src -I$(RAYLIB_PATH)/src/external -I$(RAYLIB_PATH)/src/extras -Ilib/raylib-4.5.0_macos/include -I build + +# Define additional directories containing required header files +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + ifeq ($(PLATFORM_OS),BSD) + INCLUDE_PATHS += -I$(RAYLIB_INCLUDE_PATH) + endif + ifeq ($(PLATFORM_OS),LINUX) + INCLUDE_PATHS += -I$(RAYLIB_INCLUDE_PATH) + endif +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include + INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include/interface/vmcs_host/linux + INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include/interface/vcos/pthreads +endif +ifeq ($(PLATFORM),PLATFORM_DRM) + INCLUDE_PATHS += -I/usr/include/libdrm +endif +ifeq ($(PLATFORM),PLATFORM_WEB) + INCLUDE_PATHS += -I$(EMSCRIPTEN_PATH)/cache/sysroot/include +endif + +# Define library paths containing required libs: LDFLAGS +#------------------------------------------------------------------------------------------------ +LDFLAGS = -L. -L$(RAYLIB_RELEASE_PATH) -L$(RAYLIB_PATH)/src -Ilib/raylib-4.5.0_macos/lib + +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + ifeq ($(PLATFORM_OS),WINDOWS) + # NOTE: The resource .rc file contains windows executable icon and properties + LDFLAGS += $(RAYLIB_PATH)/src/raylib.rc.data + # -Wl,--subsystem,windows hides the console window + ifeq ($(BUILD_MODE), RELEASE) + LDFLAGS += -Wl,--subsystem,windows + endif + endif + ifeq ($(PLATFORM_OS),LINUX) + LDFLAGS += -L$(RAYLIB_LIB_PATH) + endif + ifeq ($(PLATFORM_OS),BSD) + LDFLAGS += -Lsrc -L$(RAYLIB_LIB_PATH) + endif +endif +ifeq ($(PLATFORM),PLATFORM_WEB) + # -Os # size optimization + # -O2 # optimization level 2, if used, also set --memory-init-file 0 + # -s USE_GLFW=3 # Use glfw3 library (context/input management) + # -s ALLOW_MEMORY_GROWTH=1 # to allow memory resizing -> WARNING: Audio buffers could FAIL! + # -s TOTAL_MEMORY=16777216 # to specify heap memory size (default = 16MB) (67108864 = 64MB) + # -s USE_PTHREADS=1 # multithreading support + # -s WASM=0 # disable Web Assembly, emitted by default + # -s ASYNCIFY # lets synchronous C/C++ code interact with asynchronous JS + # -s FORCE_FILESYSTEM=1 # force filesystem to load/save files data + # -s ASSERTIONS=1 # enable runtime checks for common memory allocation errors (-O1 and above turn it off) + # --profiling # include information for code profiling + # --memory-init-file 0 # to avoid an external memory initialization code file (.mem) + # --preload-file resources # specify a resources folder for data compilation + # --source-map-base # allow debugging in browser with source map + LDFLAGS += -s USE_GLFW=3 -s TOTAL_MEMORY=$(BUILD_WEB_HEAP_SIZE) -s FORCE_FILESYSTEM=1 -sMIN_WEBGL_VERSION=2 -sMAX_WEBGL_VERSION=2 + + # Build using asyncify + ifeq ($(BUILD_WEB_ASYNCIFY),TRUE) + LDFLAGS += -s ASYNCIFY + endif + + # Add resources building if required + ifeq ($(BUILD_WEB_RESOURCES),TRUE) + LDFLAGS += --preload-file $(BUILD_WEB_RESOURCES_PATH) + endif + + # Add debug mode flags if required + ifeq ($(BUILD_MODE),DEBUG) + LDFLAGS += -s ASSERTIONS=1 --profiling + endif + + # Define a custom shell .html and output extension + LDFLAGS += --shell-file $(BUILD_WEB_SHELL) + EXT = .html +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + LDFLAGS += -L$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/lib +endif + +# Define libraries required on linking: LDLIBS +# NOTE: To link libraries (lib.so or lib.a), use -l +#------------------------------------------------------------------------------------------------ +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + ifeq ($(PLATFORM_OS),WINDOWS) + # Libraries for Windows desktop compilation + # NOTE: WinMM library required to set high-res timer resolution + LDLIBS = -lraylib -lopengl32 -lgdi32 -lwinmm + # Required for physac examples + LDLIBS += -static -lpthread + endif + ifeq ($(PLATFORM_OS),LINUX) + # Libraries for Debian GNU/Linux desktop compiling + # NOTE: Required packages: libegl1-mesa-dev + LDLIBS = -lraylib -lGL -lm -lpthread -ldl -lrt + + # On X11 requires also below libraries + LDLIBS += -lX11 + # NOTE: It seems additional libraries are not required any more, latest GLFW just dlopen them + #LDLIBS += -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor + + # On Wayland windowing system, additional libraries requires + ifeq ($(USE_WAYLAND_DISPLAY),TRUE) + LDLIBS += -lwayland-client -lwayland-cursor -lwayland-egl -lxkbcommon + endif + # Explicit link to libc + ifeq ($(RAYLIB_LIBTYPE),SHARED) + LDLIBS += -lc + endif + endif + ifeq ($(PLATFORM_OS),OSX) + # Libraries for OSX 10.9 desktop compiling + # NOTE: Required packages: libopenal-dev libegl1-mesa-dev + LDLIBS = -lraylib -framework OpenGL -framework Cocoa -framework IOKit -framework CoreAudio -framework CoreVideo + endif + ifeq ($(PLATFORM_OS),BSD) + # Libraries for FreeBSD, OpenBSD, NetBSD, DragonFly desktop compiling + # NOTE: Required packages: mesa-libs + LDLIBS = -lraylib -lGL -lpthread -lm + + # On XWindow requires also below libraries + LDLIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor + endif +endif +ifeq ($(PLATFORM),PLATFORM_RPI) + # Libraries for Raspberry Pi compiling + # NOTE: Required packages: libasound2-dev (ALSA) + LDLIBS = -lraylib -lbrcmGLESv2 -lbrcmEGL -lpthread -lrt -lm -lbcm_host -ldl + ifeq ($(USE_RPI_CROSS_COMPILER),TRUE) + LDLIBS += -lvchiq_arm -lvcos + endif +endif +ifeq ($(PLATFORM),PLATFORM_DRM) + # Libraries for DRM compiling + # NOTE: Required packages: libasound2-dev (ALSA) + LDLIBS = -lraylib -lGLESv2 -lEGL -lpthread -lrt -lm -lgbm -ldrm -ldl +endif +ifeq ($(PLATFORM),PLATFORM_WEB) + # Libraries for web (HTML5) compiling + LDLIBS = $(RAYLIB_RELEASE_PATH)/libraylib.a +endif + +# Define source code object files required +#------------------------------------------------------------------------------------------------ +PROJECT_SOURCE_FILES ?= \ + src/main.c +# src/pinchSwizzle.m + +# Define all object files from source files +OBJS = $(patsubst %.c, %.o, $(PROJECT_SOURCE_FILES)) + + +# Define processes to execute +#------------------------------------------------------------------------------------------------ + +# Default target entry +all: $(PROJECT_NAME) + +build/shaders.h: src/*.fs Makefile build + (cat src/shader_base.fs; printf '\0') > build/shader_base.fs + (cat src/shader_prefix.fs; printf '\0') > build/shader_prefix.fs + (cat src/slicer_body.fs; printf '\0') > build/slicer_body.fs + (cat src/selection.fs; printf '\0') > build/selection.fs + cd build && xxd -i shader_base.fs shaders.h + cd build && xxd -i shader_prefix.fs >> shaders.h + cd build && xxd -i slicer_body.fs >> shaders.h + cd build && xxd -i selection.fs >> shaders.h + +# Project target defined by PROJECT_NAME +$(PROJECT_NAME): $(OBJS) build/shaders.h + mkdir -p build +# rm build/*.js build/*.data build/*.wasm build/*.html + $(CC) -o build/$(PROJECT_NAME)$(EXT) $(OBJS) $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM) +ifeq ($(PLATFORM),PLATFORM_WEB) + mv build/$(PROJECT_NAME).html build/index.html +endif + +# Compile source files +# NOTE: This pattern will compile every module defined on $(OBJS) +%.o: %.c + $(CC) -c $< -o $@ $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..412b58b --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +# ShapeUp + +A 3D Modeling tool using constructive solid geometry. More information about the project [on my website](https://danielchasehooper.com/posts/shapeup/) + +This was written for the 2023 [Wheel reinvention Jam](https://handmade.network/jam/2023). As such, the project is not maintained. This repo exists just because a few people said they were interested in looking at the code for educational purposes. If you have an issue building, I'll take a PR for that, otherwise I'm not accepting bug reports or new features. + +This repo is a santitized copy of the original with commmit history removed. I was never planning on doing a public release of this code, and I don't feel like auditing/changing the original repo's commit history for code/comments that shouldn't be public. + +# Building + +for macOS run `make` +for web: run `./webbuild.sh` +for windows: PRs welcome \ No newline at end of file diff --git a/example files/1 toad.shapeup b/example files/1 toad.shapeup new file mode 100644 index 0000000000000000000000000000000000000000..953464118997419a298391dd947546faf20f5c1d GIT binary patch literal 316 zcmZQ$Km|*0GCII8vJCSb4hInb{r~@PVb3?52SA*vuOQ-+< literal 0 HcmV?d00001 diff --git a/example files/2 among.shapeup b/example files/2 among.shapeup new file mode 100644 index 0000000000000000000000000000000000000000..7e33d00ad3bf113acd463c843868a15172d28b89 GIT binary patch literal 316 zcmZQ$KnD%>bHd~tg5JHhN0za^xE9RcjwG1Ak>ddC=1zMJ!$N!i4{z+R%G+V+IeX@e z?N*Q;Mu^6W3&sv}KZiLyd3V(whLMb9kV~9of9vvfd$2u>j7+YVcIs1J)PU z+WRc?vJ;-b4-(2fq{L`{^r#p}PlL%M9(x#usRz*@dsKeRw}t3oWFS@#Nbmpu|3MT3 z+p`G!_!xDtJ-4G9?O+%z2_<0uVHPk4i~N&Hx1YaP6Rbzk+20O^vFTwDfQYVIHNieD zwss$gw{(eyUo+VX27*2dCAzHJ#)quqKA=zWA1a?=?A*(|F$vNXDF|=ogj6~ z_DQ;{-5DRp{UA*y#)2R>fWiMf69xuG28PQ$26htcQ}^eY%GhuE#B2B2?VR0uAf1*b z1h(76IN1&q)^=RscEVGDVGYz1INio>bL5l#{+hh@>|*S8Wp(T9Sb_A6nNRFMh95Z7 zv=3d+j&+uHo6j7!yUw{3#U8WI3l4zvV6$ga^J2T3$D-^{emjb)=kR%`o|_o^G_8k~0CFNgv9hmj%ag^K+b1tF63WNh=czcG~w9Ig)U zcH8dW&T9w4XU=%T!x$VlKuZsuIsvx&)=4}2Y$f*nOv|R)A?ry~YqDo(;NG8>*1r!$ z4=}7BunF0xPUqZTe2&u|S9KzfCC9gfZ_+lUg6;Y zq8PSt@3yNGW;<{vWu6@@y|F;ko00M4{TX6Q51^+vn4VHLc6b_v={dVb;{Z(0V%Kf9 zuylRt_ES4;3zh>DYaZFLLDMxzkBPC`{uwi8A21PK4YmgqM=(8#7QFV2g2A5(x)5F^jfZT5Gzi%I?JV4Gr01#Z1-T(jq literal 0 HcmV?d00001 diff --git a/example files/bracket.shapeup b/example files/bracket.shapeup new file mode 100644 index 0000000000000000000000000000000000000000..5b3ecbdf6057bff8fb55d5fdaf1b20134d8ea1c6 GIT binary patch literal 472 zcmd;NKn1MsckC};b+BV#Xs}0>f$-ihhygKJK*Y8uYk}%O0I0UihA2G~6()eqReU(Z z9)vfG>pFmqfD-SF-h$KHnaM*_zpb`VausZ4f=T`agr+X4)@ji_2{w6CiGb=y`Wg#Q`MN zU?^-Kpde)j!XQ2j$lotQ3Ij%#yURC&`N`Uf_Q}c?#L??O4!1ORO0R001 D571Bh literal 0 HcmV?d00001 diff --git a/example files/rubiks.shapeup b/example files/rubiks.shapeup new file mode 100644 index 0000000000000000000000000000000000000000..7216c41a3b4c96bb305acba87104d47d32a8ac6b GIT binary patch literal 1616 zcmb1VKm`+=LL6WiS?27SGqxZ;6B84NVrgWaY!709z}YiCwoxZK9Y7c?fJA`w0rfC4 zFffAke3&X@yJY)ZdvrbL&m7+m(+1T8)B@47FRuk`7rGvh`qO7lL*>BsFfan`S$tB= z0cMt>ZM{7V!^A+eyxvc+f7U|;!Fn#0@j4_63pv2lgJ?o}P9^aiIB{F}04aKo|KW20 znM+8||37~~%HaNya1eAz{aa-Z!yri*fcfYDOt1)CPeQaHLASy5gvbgyfOJn26n97g z+5^L26QKmm9)_i00hWe!1$)w02s)6WNAsVcgT+aH2X$d7qWuH1=Z9s(UZU)=Dgrr< zrKDfLL31h30Vf7=qT}?#fjnDM^{lHGI%>ER=wSH7p%~?70-lPgGdL>}k06+uG`_l*99QA%bxV({uH%kb_dFq{EwU0tEHI z(g94*hO%3GVd(}$WAhJ8PXdeJ0gyed=S7INhvB}jO%A7|gFrvmURXW=(b(*PrR!!j zfddQr#2wi6g%1#N8!QYYBLokeiIQ|saNTJ`NDl)vz3B-_I;3wDauBf;AZQOP4BRep zJDj;A?l8%Ya2Wzi2Mp!HyI(eoI|OtQk+-2`$e#!ahiS4r2O9R)?;+$LSQyOmlyLa> PjPt;489u`C0}TTJ!jgHd literal 0 HcmV?d00001 diff --git a/example files/wrench.shapeup b/example files/wrench.shapeup new file mode 100644 index 0000000000000000000000000000000000000000..2091101b938dce48b82938c332494304e6096f43 GIT binary patch literal 524 zcmd;LU|=|r(%}H4prFD2s@H#e28IS8Mu3C=PutsZh1q5It1vP+9D>lZy(4_mYzTD*Tnp>14$Yg3xf4ttypQ-f9R_XL=PiNtW)~|kUR(^ zdh^*=$M3ZV(GU?-5~ip5KSIyeXd!#{6Nl_UG)VPqNuT{NU1!hufcyjGBK)&2IQ@W5 z_Z&ODJ2`d=^I7oN!vGHhY&xvLUFO+?Xk@iX KUNZK`;RXN?Z*z(O literal 0 HcmV?d00001 diff --git a/lib/raylib-4.5.0_macos/include/raygui.h b/lib/raylib-4.5.0_macos/include/raygui.h new file mode 100644 index 0000000..871743b --- /dev/null +++ b/lib/raylib-4.5.0_macos/include/raygui.h @@ -0,0 +1,5521 @@ +/******************************************************************************************* +* +* raygui v4.0 - A simple and easy-to-use immediate-mode gui library +* +* DESCRIPTION: +* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +* available as a standalone library, as long as input and drawing functions are provided. +* +* 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 GuiLoadStyleDefaulf() 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.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 4.6-dev 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-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 RAYGUI_H +#define RAYGUI_H + +#define RAYGUI_VERSION_MAJOR 4 +#define RAYGUI_VERSION_MINOR 0 +#define RAYGUI_VERSION_PATCH 0 +#define RAYGUI_VERSION "4.0" + +#if !defined(RAYGUI_STANDALONE) + #include "raylib.h" +#endif + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RAYGUIAPI + #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +// Allow custom memory allocators +#ifndef RAYGUI_MALLOC + #define RAYGUI_MALLOC(sz) malloc(sz) +#endif +#ifndef RAYGUI_CALLOC + #define RAYGUI_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RAYGUI_FREE + #define RAYGUI_FREE(p) free(p) +#endif + +// 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 thikness +} 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, shows text +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, show true when clicked +RAYGUIAPI int GuiToggle(Rectangle bounds, const char *text, bool *active); // Toggle Button control, returns true when active +RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int *active); // Toggle Group control, returns active toggle index +RAYGUIAPI int GuiToggleSlider(Rectangle bounds, const char *text, int *active); // Toggle Slider control, returns true when clicked +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, returns selected item index + +RAYGUIAPI int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control, returns selected item +RAYGUIAPI int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control, returns selected value +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, returns selected value +RAYGUIAPI int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control, returns selected value +RAYGUIAPI int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Progress Bar control, shows current progress value +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, returns mouse cell position + +// Advance controls set +RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active); // List View control, returns selected list item index +RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *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 returns HSV 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_220 = 220, + ICON_221 = 221, + ICON_222 = 222, + ICON_223 = 223, + ICON_224 = 224, + ICON_225 = 225, + ICON_226 = 226, + ICON_227 = 227, + ICON_228 = 228, + ICON_229 = 229, + ICON_230 = 230, + ICON_231 = 231, + ICON_232 = 232, + ICON_233 = 233, + ICON_234 = 234, + ICON_235 = 235, + ICON_236 = 236, + ICON_237 = 237, + ICON_238 = 238, + ICON_239 = 239, + ICON_240 = 240, + ICON_241 = 241, + ICON_242 = 242, + ICON_243 = 243, + ICON_244 = 244, + ICON_245 = 245, + ICON_246 = 246, + ICON_247 = 247, + ICON_248 = 248, + ICON_249 = 249, + ICON_250 = 250, + ICON_251 = 251, + ICON_252 = 252, + ICON_253 = 253, + ICON_254 = 254, + ICON_255 = 255, +} GuiIconName; +#endif + +#endif + +#if defined(__cplusplus) +} // 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 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_220 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_221 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_222 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_223 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_224 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_225 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_226 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_227 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_228 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_229 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_230 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_231 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_232 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_233 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_234 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_235 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_236 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_237 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_238 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_239 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_240 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_241 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_242 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_243 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_244 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_245 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_246 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_247 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_248 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_249 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_250 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_251 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_252 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_253 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_254 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_255 +}; + +// NOTE: We keep a pointer to the icons array, useful to point to other sets if required +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 guiSliderDragging = false; // Gui slider drag state (no inputs processed except dragged slider) +static Rectangle guiSliderActive = { 0 }; // Gui slider active 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; + } + + 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 + + int result = 0; + GuiState state = guiState; + float mouseWheelSpeed = 20.0f; // Default movement speed with mouse wheel + + 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 + // NOTE: If content >>> bounds, size could be very small or even 0 + if (horizontalScrollBar.width < RAYGUI_MIN_SCROLLBAR_WIDTH) + { + horizontalScrollBar.width = RAYGUI_MIN_SCROLLBAR_WIDTH; + mouseWheelSpeed = 30.0f; // TODO: Calculate speed increment based on content.height vs bounds.height + } + if (verticalScrollBar.height < RAYGUI_MIN_SCROLLBAR_HEIGHT) + { + verticalScrollBar.height = RAYGUI_MIN_SCROLLBAR_HEIGHT; + mouseWheelSpeed = 30.0f; // TODO: Calculate speed increment based on content.width vs bounds.width + } + + // 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(); + + // Horizontal and vertical scrolling with mouse wheel + if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_LEFT_SHIFT))) scrollPos.x += wheelMove*mouseWheelSpeed; + else scrollPos.y += wheelMove*mouseWheelSpeed; // 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(DEFAULT, 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 && !guiSliderDragging) + { + 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 && !guiSliderDragging) + { + 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, returns true when active +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 && !guiSliderDragging) + { + 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, returns toggled button codepointIndex +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, returns true when clicked +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 true when active +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 && !guiSliderDragging) + { + 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); + } + } + //-------------------------------------------------------------------- + + // 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, returns selected item codepointIndex +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) && !guiSliderDragging) + { + 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) && !guiSliderDragging) + { + 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 bufferSize, 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 + !guiSliderDragging && // 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) < bufferSize)) + { + // 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 codepoint = 0; + int codepointSize = 0; + 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 = 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 bufferSize, 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, bufferSize, 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 && !guiSliderDragging) + { + 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 && !guiSliderDragging) + { + 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))) 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; + + int sliderValue = (int)(((*value - minValue)/(maxValue - minValue))*(bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH))); + + Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + if (sliderWidth > 0) // Slider + { + slider.x += (sliderValue - sliderWidth/2); + slider.width = (float)sliderWidth; + } + else if (sliderWidth == 0) // SliderBar + { + slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH); + slider.width = (float)sliderValue; + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiSliderDragging) // Keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiSliderActive)) + { + state = STATE_PRESSED; + + // Get equivalent value and slider position from mousePosition.x + *value = ((maxValue - minValue)*(mousePoint.x - (float)(bounds.x + sliderWidth/2)))/(float)(bounds.width - sliderWidth) + minValue; + } + } + else + { + guiSliderDragging = false; + guiSliderActive = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiSliderDragging = true; + guiSliderActive = 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 - (float)(bounds.x + sliderWidth/2)))/(float)(bounds.width - sliderWidth) + minValue; + + if (sliderWidth > 0) slider.x = mousePoint.x - slider.width/2; // Slider + else if (sliderWidth == 0) slider.width = (float)sliderValue; // SliderBar + } + } + else state = STATE_FOCUSED; + } + + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + } + + // Bar limits check + if (sliderWidth > 0) // Slider + { + if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH); + else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH); + } + else if (sliderWidth == 0) // SliderBar + { + if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), 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 && !guiSliderDragging) + { + 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 && !guiSliderDragging) + { + 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 +int GuiColorPanel(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + GuiState state = guiState; + Vector2 pickerSelector = { 0 }; + + const Color colWhite = { 255, 255, 255, 255 }; + const Color colBlack = { 0, 0, 0, 255 }; + + Vector3 vcolor = { (float)color->r/255.0f, (float)color->g/255.0f, (float)color->b/255.0f }; + Vector3 hsv = ConvertRGBtoHSV(vcolor); + + pickerSelector.x = bounds.x + (float)hsv.y*bounds.width; // HSV: Saturation + pickerSelector.y = bounds.y + (1.0f - (float)hsv.z)*bounds.height; // HSV: Value + + float hue = -1.0f; + Vector3 maxHue = { hue >= 0.0f ? hue : hsv.x, 1.0f, 1.0f }; + Vector3 rgbHue = ConvertHSVtoRGB(maxHue); + Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x), + (unsigned char)(255.0f*rgbHue.y), + (unsigned char)(255.0f*rgbHue.z), 255 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiSliderDragging) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + hsv.y = colorPick.x; + hsv.z = 1.0f - colorPick.y; + + Vector3 rgb = ConvertHSVtoRGB(hsv); + + // NOTE: Vector3ToColor() only available on raylib 1.8.1 + *color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x), + (unsigned char)(255.0f*rgb.y), + (unsigned char)(255.0f*rgb.z), + (unsigned char)(255.0f*(float)color->a/255.0f) }; + + } + else state = 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; +} + +// 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 (guiSliderDragging) // Keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiSliderActive)) + { + 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 + { + guiSliderDragging = false; + guiSliderActive = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiSliderDragging = true; + guiSliderActive = 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 (guiSliderDragging) // Keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiSliderActive)) + { + 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 + { + guiSliderDragging = false; + guiSliderActive = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiSliderDragging = true; + guiSliderActive = 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 +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) }; + + 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, returns HSV color value in *colorHsv. +// Used by GuiColorPickerHSV() +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 + + float hue = -1.0f; + Vector3 maxHue = { hue >= 0.0f ? hue : 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 && !guiSliderDragging) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + 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 + bounds.width/2 - textWidth/2; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.width = (float)textWidth; + 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 = { 0 }; + + float spaceWidth = spacing/(float)subdivs; + int linesV = (int)(bounds.width/spaceWidth) + 1; + int linesH = (int)(bounds.height/spaceWidth) + 1; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiSliderDragging) + { + 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 + //-------------------------------------------------------------------- + switch (state) + { + case STATE_NORMAL: + { + if (subdivs > 0) + { + // Draw vertical grid lines + for (int i = 0; i < linesV; i++) + { + Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height }; + GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA)); + } + + // Draw horizontal grid lines + for (int i = 0; i < linesH; i++) + { + Rectangle lineH = { bounds.x, bounds.y + spacing*i/subdivs, bounds.width, 1 }; + GuiDrawRectangle(lineH, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(GuiGetStyle(DEFAULT, LINE_COLOR)), RAYGUI_GRID_ALPHA)); + } + } + } break; + default: break; + } + + 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; + + // 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[6] = { 0 }; + + if (text != NULL) + { + memset(buffer, 0, 1024); + sprintf(buffer, "#%03i#", iconId); + + for (int i = 5; i < 1024; i++) + { + buffer[i] = text[i - 5]; + if (text[i - 5] == '\0') break; + } + + return buffer; + } + else + { + sprintf(iconBuffer, "#%03i#", iconId & 0x1ff); + + return iconBuffer; + } +#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)+ GuiGetStyle(control, TEXT_PADDING); + 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 }; + + // 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; + } + + 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); + } +#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 textOffsetY = 0; + float textOffsetX = 0.0f; + float glyphWidth = 0; + 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 + + // Wrap mode text measuring to space to validate if it can be drawn or + // a new line is required + if (wrapMode == TEXT_WRAP_CHAR) + { + // 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; + + // Jump to next line if current character reach end of the box limits + if ((textOffsetX + glyphWidth) > textBounds.width) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + } + else if (wrapMode == TEXT_WRAP_WORD) + { + // Get width to next space in line + int nextSpaceIndex = 0; + float nextSpaceWidth = GetNextSpaceWidth(lines[i] + c, &nextSpaceIndex); + + if ((textOffsetX + nextSpaceWidth) > textBounds.width) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + + // TODO: Consider case: (nextSpaceWidth >= textBounds.width) + } + + 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 (textOffsetX <= (textBounds.width - glyphWidth)) + { + 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) && !guiSliderDragging) + { + 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; + + const int valueRange = maxValue - minValue; + int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + + // Calculate rectangles for all of the components + arrowUpLeft = RAYGUI_CLITERAL(Rectangle){ + (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), + (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), + (float)spinnerSize, (float)spinnerSize }; + + if (isVertical) + { + arrowDownRight = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + bounds.height - spinnerSize - GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize }; + scrollbar = RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING), arrowUpLeft.y + arrowUpLeft.height, bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING)), bounds.height - arrowUpLeft.height - arrowDownRight.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH) }; + + // 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 (guiSliderDragging) // Keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && + !CheckCollisionPointRec(mousePoint, arrowUpLeft) && + !CheckCollisionPointRec(mousePoint, arrowDownRight)) + { + if (CHECK_BOUNDS_ID(bounds, guiSliderActive)) + { + 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 + { + guiSliderDragging = false; + guiSliderActive = 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)) + { + guiSliderDragging = true; + guiSliderActive = 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/lib/raylib-4.5.0_macos/include/raylib.h b/lib/raylib-4.5.0_macos/include/raylib.h new file mode 100644 index 0000000..4cd9e43 --- /dev/null +++ b/lib/raylib-4.5.0_macos/include/raylib.h @@ -0,0 +1,1588 @@ +/********************************************************************************************** +* +* raylib v4.5 - 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 4 +#define RAYLIB_VERSION_MINOR 5 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_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) + #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 { } +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// NOTE: We set some defines with some data types declared by raylib +// Other modules (raymath, rlgl) also require some of those types, so, +// to be able to use those other modules as standalone (not depending on raylib) +// this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (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 +} 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; + +//---------------------------------------------------------------------------------- +// 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_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_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, unsigned int *bytesRead); // FileIO: Load binary data +typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, unsigned int bytesToWrite); // FileIO: Save binary data +typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void SetWindowIcon(Image image); // Set icon for window (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) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode) +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetCurrentMonitor(void); // Get current connected monitor +RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (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 primary 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 + +// 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) + +// 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 int GetFPS(void); // Get current FPS +RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() + +// Misc. functions +RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) + +RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *MemAlloc(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 + +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) +RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write), returns true on success +RLAPI bool ExportDataAsCode(const unsigned char *data, unsigned int size, 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 +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *GetApplicationDirectory(void); // Get the directory if the running application (uses static string) +RLAPI 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() + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) +RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Get mouse position X +RLAPI int GetMouseY(void); // Get mouse position Y +RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement 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(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 (Vector version) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out +RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point +RLAPI void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points +RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +RLAPI bool 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 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 bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient +RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image 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 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 *fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool IsFontReady(Font font); // Check if a font is ready +RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount); // Unload font chars info data (RAM) +RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// Text font info functions +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// Text codepoints management functions (unicode characters) +RLAPI 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, unsigned int *animCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI void UnloadModelAnimations(ModelAnimation *animations, unsigned int count); // Unload animation array data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI 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 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 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 +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 +RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/lib/raylib-4.5.0_macos/include/raymath.h b/lib/raylib-4.5.0_macos/include/raymath.h new file mode 100644 index 0000000..422a42e --- /dev/null +++ b/lib/raylib-4.5.0_macos/include/raymath.h @@ -0,0 +1,2134 @@ +/********************************************************************************************** +* +* raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions +* +* 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. +* +* CONVENTIONS: +* +* - 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) +* +* +* 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) +{ + 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 = atan2f(v2.y - v1.y, v2.x - v1.x); + + 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; + + float dot = start.x*end.x + start.y*end.y; // Dot product + + float dotClamp = (dot < -1.0f)? -1.0f : dot; // Clamp + if (dotClamp > 1.0f) dotClamp = 1.0f; + + result = acosf(dotClamp); + + // Alternative implementation, more costly + //float v1Length = sqrtf((start.x*start.x) + (start.y*start.y)); + //float v2Length = sqrtf((end.x*end.x) + (end.y*end.y)); + //float result = -acosf((start.x*end.x + start.y*end.y)/(v1Length*v2Length)); + + 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) +{ + 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) length = 1.0f; + float ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + + 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) +{ + 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 where v specifies the +// normalized direction of the incoming ray, n specifies the +// normalized normal vector of the interface of two optical media, +// and r specifies the 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 near, double far) +{ + Matrix result = { 0 }; + + double top = near*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)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m5 = ((float)near*2.0f)/tb; + 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.m14 = -((float)far*(float)near*2.0f)/fn; + + return result; +} + +// Get orthographic projection matrix +RMAPI Matrix MatrixOrtho(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 = 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)far + (float)near)/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 }; + + 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) < 0.001f) + { + 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 > 0.0001f) + { + 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) +{ + 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/lib/raylib-4.5.0_macos/include/rlgl.h b/lib/raylib-4.5.0_macos/include/rlgl.h new file mode 100644 index 0000000..86208de --- /dev/null +++ b/lib/raylib-4.5.0_macos/include/rlgl.h @@ -0,0 +1,4740 @@ +/********************************************************************************************** +* +* rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* 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...) +* +* 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 additional 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 additional 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 +* 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 attribute 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_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) + #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 + +// 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) +} 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_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, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7, // 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, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z, // 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 + +// 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 rlDisableWireMode(void); // Disable wire mode +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_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) + #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_RPI) || 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 + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER +#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 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) +// 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 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; + + // TODO: Add current normal + // By default rlVertexBuffer type 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 +} + +// 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(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] = { + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, + }; + + glDrawBuffers(count, buffers); + } + } + 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 +} + +// 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); // TODO: Filter message + + // 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.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.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_ES2) + + #if defined(PLATFORM_DESKTOP) + if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES2.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; + + // 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_33) + glVersion = RL_OPENGL_33; +#endif +#if defined(GRAPHICS_API_OPENGL_43) + glVersion = RL_OPENGL_43; +#endif +#if 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 (change flag required) + 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 + + // 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 != -1) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, (unsigned char *)data + mipOffset); +#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; + + // 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) + // 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 != -1) + { + // 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_R32G32B32) + { + // Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB) + if (RLGL.ExtSupported.texFloat32) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL); + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + } + else if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) 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 != -1) && (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) + 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 + #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; + #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 != -1) && (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); + 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) +{ + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset); +} + +// 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) + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset, 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); + glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 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_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" + "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 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_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/lib/raylib-4.5.0_macos/lib/libraylib.a b/lib/raylib-4.5.0_macos/lib/libraylib.a new file mode 100644 index 0000000000000000000000000000000000000000..4814819b9cc408b0f4bd3251bce5d9ab157ca82c GIT binary patch literal 4502584 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\sgnBz)D|0x>VohF^maoLgJKLu9cJ<|D>s=;= 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ͱ|+|wv*c$m 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 zÐEl2bjK%TIyyv)s#=cN`!6Fct43aVU}gsP{IM(Ho~_CN=DO|0&!Dns^FT_K!I% zR{pL!B*gT0o^~$WRe_DMcADo9Pl?{A$v96UK{8AqwB&@FYbM%6Py4K}m z^t2M+Y$D->7-Orj-#_cGRgYktL$6DHX4OGz$oM83B?uh}J|lY>?!jRLW)333Da%v)8=XMjBjc1?*ye@^ctqN>>Ey*XjqF(eZo7$-wf9m-Y`|KVAoNwUgm46J?iJ9@i8QPoK2lX!3)Q6 zXZ$CsreoUh{EppQsqaHMjgqcUKeGrFM^#kiMNd&xH4U$iW8aU)qjI3C;022E39HuR z(FHqpe~AWX>i(~w!I~)?5#Rk?FyXP%=BjB=?O6PRmghY{^f-k_sKfJ-?HB;+d(of# zE4ma+feKl|r)d)S!pDz#K;p=He^s-qdQ{ccp_5g+D)AY{XHbc*n)TO07NNcGpZD~H z>esO;L9&=LJ%vq)*ScTE=0Wb-n%<{yW(b+A+Z%>B#j7g$ckDor1nofJYu$D8-t7ME zJ3 zQiN|7_U=}{s(Qyib{w~r^KUNLvGX3n@S)QCdhE6=o_apDSTSEmeWFm`V_L>c6+ z5&r%OhE_eSdRh9eTb{n0@ry@d^hv^`?hk8sZ79L#vli@_{8f4*EHLz!3wDfu?DA*v zairgoaLw4`3wkGi6<;HNtmg8=HDix0=q-H=zI)*tdl;U3>#-88+VW$Jz-YHmqVB&| zwe{~M>+i0@ec-cec5N!bkKFyo=c2yiTXl=)4d*Vb>3yzd$NUGY9{=+=#QlTEkB`GA zyK-C^G}!3d;^vv5%UhO|Bt5^l+r|{cX-Q`dnx^RyK7rR>r=-srT%I$ zUg^?1ytVYhr%>iwOTTkkJ;t)dy@x+owQxtny_m24tnTqYjoI=tGBUQK;vJ9wX&iV} zTV5nZy~B?WjjN$7tGV~&yq{&h+xxRVd_`^R{O`na|9$++-u{PrUdvbWhf&|Kc|+xQ z{DMMiXugMTx)$hcx#?K8PZ;&;=r8YCQwih)?*B_j+ID5yc z`v~Ob#JRPPpv3NU^-q6zWH2+!i_|s#0U%zq!ruL5yl|KIG z(k-vh@3BuKaLybA{`s^muh5TOrT6wezU9RgEAU~LV^@;1tF-RhWtCH3d+r$J9@0zt zc>bjNz=mBLP$s-fwe|0(W#;x8hd-%2t9H~pc(Q88gsR?#2k|1+C((zT0Rg=EjyeU^ z4pEgi95p9O-tM{4|1M8#ee<-;6?}%K_b<;Lm+>3A@EN?`U$Z7;{GSX>B98?pTGOu5 zbLS1OhatZ>esiG^=M87Et?@+F)}NFt+%f)BSd88<{=N;P5LDAU2&t-h`RtM2XM0QU z!wUJ_n%-YP2S(Jv8Z=8x+*Ez9>wT^F4Qy6kwB3K6LF1~v@t1yTc8s2abl1##V#5Xe zm6Dnr>Z>$0^PZXTk@q1_e4$YK(!Ie~sIm%v$W?tLhkic8YUt;){LvixNpF0>J@5BD zhj)u+=ixr(v$)T8(RlR6jZaLtb@XNUg~x=Rpl5{g^o-D8@A>r54S$IRpZ-*@Q8``- zLA)dN{2{!KY(nGUgj>&l8NVQiM^n}FMNhD-dUZ?h`IXS{^l18@E_@y6r@fcd;g^0R zihd*F`{>(*2XJ%r{GVei#5=518RC)2z^kL&pUdLU`moKMezqLhR*Gyh&z4BzK*nb- zMP6qvGE<5Jca>x-uH*j-;W84Y$(S7Q(%*0ztG}*vHhK>#$GTqiX$7-HMo&dJ<^56q zf)N*v`nVeXq{j)7mv|k<`+hxP=F#jT%3FGN>!bJ;e0EEhi!yWCPkPTs zON4Q~qbXniK-&Yo>S-xx#mhiOze6c|93^}sE5q|^Qo@HhhYAUv_IU4EO3SY?N0Rvh z?SJFQADSsYc<+0k55F+3L=_gkvT;`LCDUO9UiMQCC$K}#`ex|uVVy1Dw1_UiGm$*=iii}82oA3lX=u{8h82tM~;u<2tzgvq#lizln(jAw3XV7-rm zrhAt-{4I|oW5^HC8w( zy57=X88O%IsQ8VFg4R-n*zwqhx4Ja@dzC)yana4&?N6aksil3}pW{91&tP9vo@2o4 z8%y@ViY;$W0;3xrBK^;;zb)%7+w%8|$&W{);E(6VJjJxaF{Qsv_|U{EJlWrUcJH3; z>bR3Sm{c-t4`WmF}p^ zr()0y;lb{ax8rziKm0q+=g=D;+v+t>Y(^g5vBEpbj~)aso?DC$?a8ZSIqPuV3?gQ; z{=?Tvp+s}zONK&uC}6AlYE8)>X#T=xl{`HfGY_?Or?eVRIHDobqm8fWS3T($4_uH3 zLT@?33gAXEo&{C3n7j1q_?H>+@4EIa+E#ofTpu%4Z(p=MKioQ+PjJ0H0f&irVbQyP zi#iH6nhtHLqbu7eZayEg<<%klq+>%&-oASb9jj6IG3|$^F_#%8@t!wIy2s(@jXKMd zyAUs}yjXlC-FSyL)!o?fGw=gti_Oj2-Q=nSPdKmess|iUL8joFh}2)<6v|?Lv>)+n zOJF3=RL+q}NPn2a-hRe$sID z`~+Vap0Il~zav`hr|-J4?};4q`yYJp2hrYncqPCe~;qd z!2Hq7pG^GUM)5CVJ`qu8FCqR#SVSm$Am_U16RNSEs6RC351D_ULq^GIr9OF+OTUBs zFz%1vg6nw5%%b)Z>Hp&&=)S85zW>c1iIbiB>cJ1^pFO<=`5+$jTXZ8x#i!jK@hdkd ze=6qxSJKndGa7$m@pl&f#ssdhf$NOGH9ByS5&nzPR!ASPp1>c`DU7Zj{1N{qb}Mb= z56H*2_}%d#KW+;AeaOrssD6z9NUgeh@W1yLkiBWtMX{LvqaIKHCKt~y`usMW!puKJ zb@R1ve2i8ddHhwf+jH}UKX}(%9Mh}jKT6->1;k~S!s&O<&5yq0BN#wc8k9c}?hDhp z;ReDzJw~{)Cl78V{@`+araNa&_U5j0w_Xq2l%wA$PvRHCFZ{u?NRQ`#jBv7j+%La` zN96Zc-}glK{H}9HLDz6qEcRujZy4#Ncc^?4*niC*nwf-ue>KI2zemWWd;@ln@UMKf z=7+Do>%fipdz9m0yTLig`HMX3>5+WX>4{h2o%c5~?%7Lq5%yJ5Ix6vp-?7TieEQSS zJ@-cTbD8<&?y6zidu}G3ls?GGHGK1*=e_aff|)N%*buwPyEK25< z=Q63zwXtOliyE$vFK&TvV?3K{X}u%fwLY0y)6umdK6P0`)8eX?_-kBNzp`n0V^#Gn zP0Q=wQ#&n2Le(8D>(cRcsZ6FT6W@?&!SAlNWW2L07teO5(_NWdvMoM!5p>iqTefsr zQ*}et;zU#J%0?Dn+_EvXu6td)r8AZ7%4NFJsn+mDBY0ah9C*!L(#oLl= zTDm)OidL)A*OtsBTOodZ90{sla%)vXeN9vCk`;@Kall+rTa2_cQM;_Fv3}_i7m@RR z>8-WP7B(!sEt<7rNli3u>59gtr3;%D*DhYV?Ap&WvY4J-_Capn2+F0DzDX7SnB$hVnV$52jrJ4}; z)4YBqQiTz>ZuClxNXMskcFkCqO0R24XQ!jI-^*>*H7^nLz(TdqRUOu8~H zYti4S4l>@g`u*tPOfHWNT$$plTXL=KaSRQ}l0u&vZn~(Vada8+snv-U)1-a=4^-T$ zbSxqrR5k6zf*MAR!P5OZ3Mf)wwxyWd0*(T63pk3-E)eQ88@VFdT3>wXm8p$arsA8? zj_JP?#$;8wr#ZV(sn!L&CYjE)>)LLMq(Ck7nk14@U5!*BOSehJ#aE|tSFP_-%;s-<=13Fll*ORfb)hM8h=eM^VVcb?`^ z`qHV5n6;UyTDV|oVc1`oX<3()ih>DUcW0qfa`M_+vgl8!KkmS26mQ94g4(_gnHY-{ zX+a{gS(+HSBv$AlevM((noQTaxY6-oL@Su@Nk|vilF77SqDXlXlv`d`g&CNo)}Y5- zCw(%iYFl!8yjxi*(@lY5T3#1$p^zviFdx$0Fn8}t)d+-;)U}j%rUfA}8aXHiHHlO6 zhoCi>Nub^rlqh~+`WBQy*$1MwNpa35y0VzKb#=zr+nC%~-PM(86Ymo0@jJv*O%r_0 zYw1K4&S{@W%?>57keMB+&O3B6(wVNcs0kr<199AWkzg^c#nS(UG&+NxQxWfhAm7F1MK2v7xR&TRTyG-vh# z^H&u-n5xWbTDE9`_oIq_&7mOm>stOrGZaO`kJ-K-RWX`ds385LDn_%1rizUfEUbKU zH_m0>iY2!!S$f-&SjEh1WA%E~L%kn*sE*WXn%*z>78(+UrFwTqGOHI6nbxjM^7@%{ z=@D`2x|U89L04weG+9<;I@WeDCyInhnTBFhQ&*ZAbW4Y)NCr-@yx6RqfJGq=Z8&rk ziL0f%E!CwIS>h^Gp~7-8z6g66?bwZ|QERT)ZD?xP4QcJ@q7{K}nYyT9;caF=zZSK4 zT^EV~-O_FKOKO%9YK$Dj!p5^v=7m_Cbbr;;Wqftn3M4h z9II!RYO0>ny42eCcuk`If2Cyc@~W!;k%DE3`s?HMo!F}BXlaGXYTxI7k{r%I$>0<+ zA)Z=COOkcn*&JmHttC`jteWeaUSLf?8NWQ)p*CgWv{cMuTA1wA*^hyn_8Qd6)?Y^4 zpJ_>5TEUW3to5n3WEZE7COFxkP;62C!uYb<>ZQwS>X$5vty`atVcKmRf9kJ+)t`o%PpXl%())yk#TCFAL21~U%K zrO*eL&z@O6XANdM9UZAGI>^p8H1&5cZ>(K>eH_t~{g_*0JYNDnDp_|2)vtKE3p*CH zIfBZE(KOYX>gvW)xMh7;sx5x|)$fhBwzp)k8p$1!w%g}*zt-Fg}oF5smc#}SB_>NL!91p|O9>-Su`+FKNw>77uu4Fx zXkf!Qp#=+#ybBvd#;T(&g;9liI4^+(Dzbo##BQO-;z3Wcf+k9|NuY))?D=F;Yg6dr z;#mw)Ag1CoZi*9UrWay~B$J$>%~fW>9@^ugX&&jOHO{)^I@7=!50r@gaZs!wQ@n`1 zDzRc&!~du@sQkP7%IwuK+LnSAlxu5y3Z;l?4DH^DRw+}pP(wk;9#-x08P$v9rmw;9 zc|Vs|$75Hv&AhTLwzgwI2iBJhvG;`E)g8%}jCOhICxL49s*&ZW+pVb%^3wEhaZC0N z`i&l9Av!DkRBX|yehWqYMx9-&NU3bg>JIfQ)3RZK+9H8$ZKs4TM8}+MN65mCZgw+W zojHjCb$>xu7tHNk4+eZSUENS79<`y&;R`Wi%t{zW_?4ig-Ey>) zZ9emVay__SDQj-O;ycO#+jFI@or6t87J}D6KDGPLd z%&LKq_RJQKmnyOjV8KthVFr-FK0gtt!=~F6__+Y1E^ykHhOfFSy$L>55GrCbKt(PA z%ez;HNIFdMYA|%Z7ult44jcU|yn2<@VAw zYcP9;91tC;&L-`*89Rq^kL*x&-iRN1RB9B#P^$b@>Ly9S2;C1RDc{UY(0iylSWE~8 zE2Taq+GfddLqH>8RT@#+kYhfD$||IFIqp|=B&+HE7PlBM*G;cE@ekUP zAw+dg$OG|nZR1c?zf|obJ*g!5YdhPtQq;8q51s;vIx(f!Z&D$c+P&9b1x)}=MX_|X zngdC%WCV5Vo=Sx&PkolPz{2{h3dXO+Eom=wMJIL*JztgD4dMkZWdfQmg0MbqkcBM; z()ghZ)hI}+ADBsa!qv2;n8f&~b^*}xmEVIoLklqb4Vd<&3SJ&Nc%y_(QcWH9P~G7K za5>OuV&ftExS_E)B)yOoyxNx_l?TZ-j+=B6FPIAm6Wi-?{|MbW^CV0c1nclIIB0oS zcSenz(8D2GL~JoK925!ELzH;6h?!cWUxS>9v`K|A!?Z#(OzKUcWa_hQAyPc3{8^CNsVzx?>ux1+)vsJnTm}5xHF(u|0 z5_3$63PYm8l&CNyDolyR>HvVx9uD$F$U&kpYcv5rg;4GG2LvgzgAvURMWnLd)WT`@g#;s-oef4bCm7M3P(-TKOtqYozK~!< zb3zeSELk0lyJCqdI8#x@5{qE>>Og)~Ea|o=<9^t$tvjqPEE&v#icl7)YUtCf>Y^_s zoR(mwRD_MOq{EVoa4Mv~LB2@Sl4`%vQp;y=^tBvm4I6Du#Kx?!F)Jh@HLO=-wXQb0 zTQE_k`}HtO0gYH5XK6!sVKUja8YglHz~IK?#)1~?7?=Ti#X=O?XQw%U(IHE)zV#xa z9OG)etRa#V3(ZN1)RD>=J68y)Zcnz}VFWG5DT{6@EOib@&!W^KjV)b6osH?Inr!%0 z(Hnj)LT}MV(mc)@ky3mdXr`bLY9vAh@<>doc!|Tm+H84`Ns%q*)%p&TkaSWCKly-H0r zQPE%shTdTP;ZR+D(4os6xX`Rn)~}u})1nZWPoGg~KtD3cBh;%}5e)Pui=h&_wI#EO z&ao*)(yBeS+0%H6eSu8%7Qkdseb&fb2rWYww! zdcxV@3t>}T89-$&$)D9t$tZZJY{fU*gy1otIVJ>;0acg~JOuf2aTY}w2nmyv7C+0P zOHG4(ES?PcgTlHbH9ne}AO%7~c5%Y}EQ?(gp%JiN&8B>UJg4#pg@&*CitzY_uuvY_ za=IcssMQxnHQJ5fzSmd_dK(S(oj4fRiT!#M7Og|{iq#B9!{c>_RG0cLvoR zDQq?0){@FC-=sDVWyK~QBlR?%a)CjaHCsXq)y{S9`Ot;fdQ3`;MlS+;Wk(5l$d-E@ zUh29Es*(Vt1HG=o>q5N{VHo{|nn^*3B2(Flg%2k#v?JlO5DTL9U3VapyfpK!2yMAh z4TPy`yJU8a5t$J_ClGFAv26mPN=(%_LOCj$=tyy>t}i3wm7whNh9X_&NUO1XP{=hS zu)7c{y1ZQWdjAl>O`UR*jqyah91eu*+~#1UMOjcycO=yC9Mr>6heA2tU@$F%LSa<; z!9XgjP*|{Ut4XcL*=ovfvr9_w01*rd3MY85@X;)tY$Du$Qcy@+xPwbb2UpnS^4FHo zP=|C__j4#Oe1I1~+sb;;?h7Oj*TGOMRR0QFd@xDfB$7bg>I1Fp z4GYiNXc4vrZR9-?UnE$kni>lwnB^jr`lwDH6?WLDhZkQWl}_S#mAZ#QckR@zHR{{U zeO2L7{%}(a2&;xj=Tg;pt9DSCtAh${r*P|zB0)>Cs6vh8+i>3Ss_wpdJ`q7Gu%u90 z^rop!jc;o-5QEoHBvX>O!-dv(w(pjoVwvCB_X zZ8#VdPK4Ub3((a3AP^R|j`w8)G>dgIWcrD!BMAnDtyBAK0h+}+wOk3%EG5eWb%4k1 z-XCc8W>&;vgTK48O35CX9pfI%fjQ&j-pnS&8-G?rIz|WPj!QaTyBzN++Aw#@B4i?L z)Eki2xTJq~U@C3PaL*7+Bff1Sx69NGd%kt=b;oimzt9)^1E{vL4zFWf;oUh<(+=w9 z1NRSfhf9cYAE6<1BLN{4fsYir3D6L}3(yeSz(+_(lWKlG-CRh%pu*}~A0zOxMh8gV zP!AUjqBv>XRBNunGSQrW%A%cCaeAc=A?HeUBpgnFMPq1wq_ycigAjoyv?dMXEYAh7ErZW zN?9n0(p%cb#0YN@Fur3jL>w&FvPoQYvof0LLiW>-p&Hwgl}kB zjT4B9$N>p_$)yk`oq^J^1}CL-SxGo1(CRj@s?4koV?dTVGyAXF6UO$t0$UA1gMQ|4r)icOijcCZ!@-Nr zwx%`MAZS98=>}Yzj%l^(Lz=R(buaO^(n6+5ur771MGG*LlU+W|r_+a;kLT%I=y7tD z601EFNM}BiZB3%6Nj*>%GK2e+rmR|Mm@3iJG_7yRr07gZ(^{%QO>`KwKuK>Bb9_N5 zb<9vqYojiw3A+sFw=}Db)?n6zFw#oz0q~OpS;3thQiA5&)S@2q_W0O}72Wg@vdW(} zBdkf4lMlhfM4gmtT8$yGX}y{t_z2V@=wNRkPzF*Rn(V|0U+jiAb+l|kg1y+28`E?m zI@i>qj?pw>2b_{%?EKpgf+O~Lk6O*;<+XK-?^SnTl4ebDuEsYQ71D^>-G6V ziNS-@avsSMuIfP72Av>J%wIJE!A&U|dudzWkkhyKnmW5E*>a1|%Mz&Y82*}XB3XLq zMND0r?7}(K%qFR(6@~CzlccI?HLtWiiJVvQv)!wkeARMoM^iSP!r53&PIrsuYr{cJ zYtq*hBJ`M)@IrVyCLc|zRdO@aYK(Ay%}VLJCry~5(6LQ1MP;Wqm1(+D9oCD$W@|wl zWz&rc8(=u;D?;n&j3H%?*B^0+Y8An%t)Q&hiuTC|8emszD~>6n3i|B}1be2XW&1|8 z*i;q|l4kvaDwW!Le~n;cyhh>WlY~>Z z)dix$(mWIGOzprob)^e&+6X}u4<|R_woRAMEEdEgKZRz(t%~a^GdN}Cl@@jgZ5?WngsDDOipE5XI;lFg%P0UCySa%-Yp> zluj(t6g@;D)({k^KAwn#bE6GPB|FzQwX}J;s)hJ1G)=~fX@Y{nSeL?q)Qus~9P71C zeoYQ1y(!n#lx!=scs~at62FilsMpfgwPYt+cDic=^0sSDQ*J|7P&DH;I4u#F+<3to zQg_{j#~uPXPa~8UhKG{YU$AKzPP(I6(+;)V^It%3k3sP+=-P;N0gwf% zhmds({AxYlDEF%kzp+Rw98F^tfrYtRX3?W7f*R{>z3{gny!HJBY^>Fl1KWKm-1v|TWKdEv+%)*=e!OwpSev_vt2krN@rh^BBrFBp;9 z0aW=LMATy3itrY3wO0=$nYuK>PjgTvXjEggRbT%rku za|G(lKW8XyO7gubBfkoPvO}TwDGLDIJLP9ASlT@FRbcV0O?B>pX_8k3Mrfa{0Nu(v zqTaJZzK0Dcln-4a0es}q;CqO1sL{w$y>FmT3W`y1&cnkXBZ?D>KM*+8g&o#+aI7?iop@(Mo3|# zG6TIXSp^yulXmpEk|8=bNF6~CEfkCeTxLFn8I&~Zy+u|kgd5Rkl9gUlSs?KiXfdsG zW$CK6`>CV$GC*Qxzs~Mp{p2bg3g!A745r&Jp)jgl!9d!54}}>-Nt(Vbp~e^gtqEU{ zHJzeEjXM&T7i1SOpD@)D5~lBnm?Ir)4z^FuPP*|!X|$s{v(>|Ps$9K7F&ZcjB{ZF( z8MwDoTo``>o4sn6oP|QW!v&$>7O|3&Nc29jFD}_)w^_)>7DK2x6x)E|B#F6A38XE$~5s z0z-$WG|@F7l>F*MFq<#}m#1-z zNxedKx!Q{22tbu%Ms(gb7^dbqUSOwA)%lR6}1kC}HuDrA}w;J3%fCe1PIk&#gCL&?Cz)sMPs9&@rX z%o-tjXr&-E$CnmQgAj!o>q7DdP;)>d31;ip8F2J`^1|1V@S_kGK+Q8iRj=2ZC0%VG zQ1ZkdDqUS5&`Oog$4}J*fIn15u0Wto>uj5?IOM}w;8QT$W-AUB+Nd^Lak$V%wb_cN zge}xLHd}Gl$VRoM`!Fl=p%}OnDvNkg>kq}+K?^fk`{j)k5)a;S zg%^b+)wyH!f-5n=7`3^1(nLVr`_*|9T!A@g!2|FdFYj}({TxDLy7wXr2~zu5GNSsp z3gDsK4CjpWhtPhC8G>BmE<`#*j*3F%4HQh4Y(RJ&UjEe~^A&jI?6fDwbZ?TPa|g@- zqVpdJTh4Ez@DzzXI-i5#hGJoAg~sb4SSYMsBxXrv_q$73liAte6-&$ z?R7W;&+*6Ybq5;uOM6{_z!iRJuYqdVFYPr-f#tBS&O%>k&=BSpBJj?5nw2PU%#*X- zSA*;MUL+%2FI9svXUwPxMZ$Cu*Jne-P=IeztOn&-H3h@?L=FZ?h0Jy$b8Lv7Nm~_a z(5h2|S}l?swv(-Fz@2EdlBfG`TnaMeSP-Mvw#!i0A3#K=Fpc4Od6GlBUZx+07lOF_ zWH!VsbjbmK=y}LO|I17{U>gkf#iZXH#F1dHjz!sPyfugea2Lq>-W^7LyXIH*daoGq2eA7;_0 zyEh+Er_mQ^iQ1bpnM6Hh@`qWX)_tRoXp4G|C2DU9WJ=TPR=5`ULv4jaFI};5yI0#o z?PR-VJmqasVztduPTrKwmk3K0@w#gt(Q1+<2fc}zPa4m*TTJ(+Rer85nbM|M3H3U> zYZw~f^&xY5;}?_BqHJ8tt{d)(%f4S|*NvftU2D~{NR06ZwgtTF{r)upufTyfsxT>f zUz|CV2gbaz5NHZ>sQn!+jB#&lD9W1QrY->ts)@3c0m^D~R*egp?L_7Xf?>f>DDflE zjJFVKyvBs1M8O;4JR_wOnBMd$9c=hnXR=ZO=eeYiswqjX3Op z+Evw&Zf~K@U-2(U<#3KoduWGQz3N5+)Gc*WTm^&}YQf=&q|ynT0845=9XOuj_pE1I zl%5I`s@Uj3o$I?g@K|wIrGDPiX2)PzZBHl>|2Z)SEnH{9e*4F47i9CJ_ z4UN(GCCV0N@Q!FNvr(|v=kR3*1>xvzC~YE7b%qY46ufmf>8RfSSICC~*nrm)=fnz# zVv3DVxl@O@9nP|#N?9altw^cekceMJFD=G=uWi>M^d4TSR;X2lck+5ZRWkV4oymSrSC{UQ)L<5>NGg;LL1`)T zt+F~Slj_RgO)PhLudo$h8P19&Gx%hO&PXFbQsjl`6dM6Siq1HX;$_-0oafhZ(oZdk zPut|Q<;!umO8*Ylg@Rusb$~X!;13YA*_tp%$E^dj(FK1&12uZ?f`J-60DRQ^J;>+_ z02Ru}BNT$Pa=Lqq)3!RnJh9TL(LN!wSEoe#e4tJRgOcx8tmn_h#plc^S6_+?|2Gcr z=wF{~orC}AyD<9eEjO4<;mj5eQmERgjZ+~UHDdV)P&f|HX;5Ud=>_;}t!g|@h2mJ% z#K(2>qZ@eneXb&o*Y*b^qPWz{@Yl7ZI`NKk$2IN)4!{T=N54&T<2Qz~!Q&`%J%Z18 z#ldqBI)lN2;cr83R7~|}{q*>(ndQ@Nh>yG5FvIb4T+C9$UU8Xb2eL>wQMqgu1-%;I zmmF=6R}@)(pU&(W{e7%*FGi0;iNzb{^@kHY0+jv#T3jj~ROTexjI4%-PFGA7w|u&< zNRipFfRcpIMo2TjF)zQqs}DSX|4o?q}j zmBSjm&+6!p4Fw{we-#touUgZAhcl9Q#MIB3?XgyTn&GA!Pw=>iW0_j5zN%ivnxccnLMtVZXuVF2|u#v{;W4!)D ze?`RmazZtI`~}}6F+Mb+J`O@(K2cwL*hn9(h=+6te|K` zdSupR@pY7rNZasz6yyOuJc9=guPmRFnz=T$#;Y~_kqG+2G3F;aP zFTUtI+Uon}>KoWP6k!xD-?`SmHJ4Z(2DzZT`lh$2@?;JDiZA-LPM-|v1Ws2`dE&|+ zOR(Skt>ZAm=(i5n_IS9&?c)T)#P8W>!A*>Q>&qAZSRsujPQMk8aNz`T#WCc4d3ZCk zwXAZ%)t6@j$s2zfC)XFhaGdzftjENa4w54*fRkV08WWd8neX9`v2HD6a!lPO?uC=y zk;oT|KY)8SXx(t>qPX>`$ACD}FItbnCQhdCvxo!&UmkRljd8#I5DD z9uFsu{OPcut8me)<+Y6I2IZ6=ayEI*CA+i^9Y!u+=(gw1YoXuiSnTpsXD+F2#FqmT zwfOkfs1o6rPSt{HOjQ=u)xYzWhQ&*kCf>DddE<&(Z(I59_q42T#XM(id+Pmnbgb*_ zO5d5m9@hE|8#momK5O=zifgZX$J}|>yq$ENhCiEbGak$Dn-F$0>$(1h`8R4t$!ViX zN1uMin6cx|9Dml?6Uxpx_q>VcUvS~1i1FZD-+INAE3dkG>a@3AGkwO) zx06X)fpWmgU`Ay?}mSL-47bo{xl|Eb=P zz8-|c@z;;PJpL;2H-x`t{FUQx0Doop>%-qL{?hmx#9snc9W^6kBM^}&f-}?{Q z9~*PV*we?2KC^WEsIyKxyJUig(T@`3$S9YW72&(w2y)Qaj`QI#{|T3UhKlyTVj{Ru83U|n-jYsRvlX&YmH@NTVr2} zJsJC5>@><;<0`>*8m>{eN^yIR_}C<5TQjnbmo8>=_e74n}bS2{- zf@8CPSn#P#gBAWOUd4VFo)EkmG@JhZBJzVp7+WxfQw>j(|6x?Nhd>QL^mapLVI_w)-&hmdg&2InTtHY{N+XPX2D(Q z8xY*pe|oqAKC3k%DAf-A30gzqa*dyZ zg1hoJb|=fb@N&Vkj{apJ!}8aRv8Qk7F2>Ji2U-Hx2iSi$J0ZMG@Hq}VA^67~_^{yH z9C*)W25yE^5-SPCpBMZ(hkWdA2F`+{O}^}djL)M53Q+=A;=>$}ME_)y&x_%IP{LvR z2JT_`CRhCTGQQ7&=eINdO$VO-DC07X4%y!$_*)(F13OrL7aZICuW~2jKSTYotslzn zXZ$jDLh+Xi{yOpxR~UbQ1utYLgeL@d=}!wT)BKQppWrf$58(rX#~twx3SQ~J%RbG( zJO`c-{CdP}t3Q38VZn19@&kgO=fDSx;KN1mvd^+&m;Q3Wld!)9+f&Rg{NKNaf4lIq z&ol0-pK-xm{Y$yvF8dNi@U-9?*^H3=!-AjVz{?(Fz=f9=!4pOBbP>Eya995H7m?2w z!G{FD+?D?RBIz%JCj@tuf3x7O_S;hg?=PZ%KybO$87luF!CmDW`$9}zE<7$cmd|vB z^p_XGD+PDuPeSkthyFgnUG@zK{v70O{dfNtS@G#5_Wo(`ON_hvx3ayA%QOmF{8x|Q zpFsa_i$DHV=HD>NjyHdu@l~ujq(4s+UtICgcKM+J#^1wENWSvh4BQIDHvaX0hjE#v zgyiGjWqgZcd>i;4<7cuHlFtk7D*wSE_)rmixCkEmJ{#tWzpMxz7u;F@1)uFmf4T@h zAowiE+s4mf!Cm8L*$+5kSNW#}{|lE)xO^UF`6&+jhXtqkoo)S)_#q2E?5O``KVtkV zaBS@(FL<13A^U~|e+Ia%{ti6Gf{!}zbe?f)|F-yh9%tOu|KtUy{YP8;gHN#hhu~QA z=Sjwe1}*+8eu(|F%(l%xdWzsfg1hDqu^+R37alKyR~EsW1;5E*e}55tNbt)bZ>#^Y zr`Uei{5dYTt9_Rj!7BwnpQ8ztPqW~cIPf09UH0`09(Ty+1uu8t!-Big7kiooU3i(` ziyZo!1&=%M9>HG&Zmpk(S&-)cHat%a7uP+G_LKN2<8OmwEB_wBTY%g24;R6kkFb83 z=7-8R{{JxE#!d+D7yP#lyzgfWWZ~HCEBiU)G(K4S2f?xYq$?DEv*4#Y@N^ORo+9#n zMezP2`Ui^0=ZoNjMev~__^{x#KV_>wm4lpduKvA8aF_g`;I~1It^CTLW&JL^PjITg zxI*O{`vn6oJT3TYNZR5bdXDA43*1)!`u~OTbJz*RpBLOUzZfcl$NrTSU+T~w7yK#* zo)CPo1Me4ntOFkq+%-ST7m*(ne3C=|a1r^~FImtfA1{Je3hpYO<|25H;BRr*-!J$? z2c8$)S^k30bjX(-jZS~L;I8tk6#Qa`{${}^JMbRCZ*ky*g1^s!m;Z_Z8h>zw+DEhC zG{3Ro{emYP_^{w92j2W^23+lq>?-9Jofe#hID}T>|ryTN?FEcP>oN`0?lOAT=HUH}oyxgIGK=5xl z@aESTxWj=D3VzIi=l_#|?>g|Fzc6t3Y03?yFZNf)UHyMt@JAf_hXl`$w(IXd$%3x( z9}@fmNBxPt$?`5dE(Pnlzt$|b6kPQyFZhFq-!^}39?gc`3NvhYUhsE2@HlOJ;Bv|L z2!5j@{`?s%Kih%F#xm}zf8~NpHDI!`i2o}e$3dq#^jDtA_}`cwlCK=kK_}P=<7ab_ ztNz4jV+WUO{3{dOH9x2PjTRR!8bYZ$}&!0#)0Prmt}k?|N741 zAXobHg3os7kDbf%OB{GY@UJ`Y*m*2}k{$k^x%~h693z^`HLBsVSqh`{R5&{y3sH`nS*2+8^Zf8;h<_q|2lLTm5iV1kWUCc$$_T@ztMpY2;T3&6IXHk=Q{AT;I8)5FSzUe<3JHS zUj!d4f)5FPg~R@`t2uqH`FFYClz+DJNeg~2a9jP1O=bP-T=IfD<)^Xy#~t$hf`1#h zZGWQqZ7fgw8`k~xYZ!N>uWUNw*E-@)2>ulZ9+QdXWuxr(2jVhuoep`Wf?e8~go9k^8y5To#t&Qm4Zn-!pM*ji zo?piJ4IE)8{@8L3a@iMeWc*zY`5wVP5BqHSAE%0qYX$0u4exm`;}ojpc|vOXn)5hpBMZ*#R4U84GB*BYc~0^W)^YH@A?E^#=6!-BioPg!fUe5K%B zsK2)O2a+s*nFAkO%eZU*Dc#QaGqB%QKPyv=Pj;lQS@2H-x3!$+&C&nGoESe`^Mjruc%R^|`EkAoJ}kJa ze#N>teRDa_*kj~hrQnqgyr+nKUT|0ZgMwe_&>u^)Nwhw;)t>>uUGs~);7>!1O};O~ z`d#HWAh>IMiDy~9#4&$vUeEZD!~V(*jOXFl?2Bz;{38zeKEcVc$(MbA<@Y+|^Mbq9 zH;K(G?;0O^1V`j_@&D>4|JQRj2f50pPjIT=Hv98M0<_tm7o4iOO@H||R_U65B?PDS zl})}!aM%7oUlF`taM%1MFF5r-w)ClkGr$rK`x5tX`l$b~+AsL+XrH$6eP}z&Uk7-|3{_$N4o$sUSVRP5v+*ZN>k@Diql(eAFBg2O18)}m zoeuj41gHMZrhiEA=??j_kF$NhbI8X&!T4ElZ1az@-Hd@$qlLf%$?ngw^wpZf)WALMbdGXBl~f0lz>{d1Y% zuKn9`!QTUIHv9Snr~5;=Lh%m^{w;vE{ORArBA;~Nm7imLDI8n zvxsZ{R3`Xa9r`Pa;Az37)6Dt$(i++?D@{B6zdl zuKPPZf?w`P-+Kb24?o1XtADQi8sifj_9X9CY5ir~^O#7gd37Ax6UR#G>Z&@s z>?5aDpLP18t*7rC{jpMd?-gCdZ@}LJP0XkFp{Yyr7jHdd=jppV2|5q48Gn;jGoRj% zrY_B|-dg%Ggb|PS&IXgrdk1GnEN0;y0q@uv=G~!`;Xe!S1cJ-gGVi$v9vyu-HUeG^ zc>V3HPnIjzcxfwq()*c5?^9Ek#XeecHs8rSS{J%_2f;fkJbJ&Hi}w=g+sOKE!EYCD zJj!hQrsC6E`6(jO}(3W^nMo?ZyR{|9_G<|*j&7Q;5~3J^Cm>3<9YCU zwlh!H&tN^E`g#()V>_5f?`QMHdyBt*Q$3uHG_3qI^JzY#E=&0}f;S*M>30hCLBv%3 z2k*cLczeOi3$I$_gXtlC)JBhuK;H@QhDV@paw+QTXE?o4@z#J>DZHrkc7Rtm0)4x| zOOHU`LGU(?fcFx3JtN?aAC3Aiyr}-80=z-t(R<<4WvK_Nz-#{^=U-I5Yy&SXyr_8h zfp=g8yywA-eW`f4odj>{2zXP_CKJMo>fai`JG{4eygBfOg(uVJLi;fK{XO7q{0i%f z%9lgn<%M^f6o;*Syb9jy!i%cU6H%t|uNE)2`QS|z-n|k1Q5$%D53xRa51qO!^<^h` zE5A`Z-u>V;kAU|AcayhD5%7+EljD6%XtsKA0=%AYF)ymVOva+^fbgR1s{t=R0$vArhlLlF zFT24T79PF#&XwMS;JyBx;`QYv@M7O(UR1e_ABXlPyeRuB!0Q*@H^e+!KCc3A>VA$l zs{L*QFD<;N^4JI7L&A$HkLSS~7=gZ%;2j%*eN)cFeDQmnj#nbm+W_9{!i!384!p|m z7cY-J;2jX&-y`BZ1YX|{SRcJ-PhFPw@hW)j2bmW&ADcKH8uHAGst5DIn<~7h`A{2p zJ;IABx1Hc^9|3Paczwc?+yB<_;|1`JJlyhiW_g*Qj!z4l?~+id9jcm!`Rc+Edy`?f{!j(~SqcsB=mwOdtBLg_dG-jML< zzN@-)eGxD5CL@ur3-7Gp_*PfYR|DSAPuV_s4#}D?9i;E)%%k`HsY}Oe=-Ulm`WV_PJ8;?!c!~eoO+4i&YD!@zpl6k0NeCc$E zm-25FcyopK)?ofE;QX5o-Zti1!e9@e%M|CHqFen+T)IM!=g7-WcH}gXvwkRqgdqdfUKDyv*s1;_U?Q zfmfIp)voq~*CRYMZN7B<7ca&80(kAhi^{)JfXyS|O$TqK@HR?3wtCeF-hl9s<$PJ} z+YH`ABjD`?uYUx*BjD-$i;DLIczq+#HyN9Q+l3dE&o$tsN1(3*JY619_U#5wm&fHg z|8A9iNAXkn9vq>*mkfPT@s7vfugf>8{#AfiDd~;suU3IKcLcm`;FSw6D&BqIO%mQT zoiCPp^*nfS;YFqQq@gd0HwB3-6MdLE@MVd&0le3xok#I<;0*~cD!qHaJ1o44hEq0&_dG`N$=(y-_xy?ZtAgngand^(H`NdPnR#*A zQ=-dZ2kC79|DhAir}IAQ(tPof-W+&C!n-vXe_*~tdiR1~_E*;X0ny{xA%5Z=0k2(n z^1jG|y$0_Dc!RIAJ}im&3fM{dCSQc~3vYY`uLivS5%4;|+dcx`Zt&70;2i{SML48I$+XtRbFNSu$Eamn*cnPuZ zJ(|}L9zRZkr_19n!FniiR1c=$aKOMDTwlnquKKXP2Jj9DFSH(6#P_pQ{ReOO@2rpB zTd6Lc4omyq3x3a=%>Rnez4{;ElYP&FA3MeTc#toCvg0IpuZ!Mig1kUGB>r^V5PU%N zJ{sf)?w1gM75GzQZ>sx;q5jii_fGJ~lrZ1b-;>_`;KhX(x(^hvoATo&@MEX3-l%zs&$ANxZKGc}Bh33*NBsLhI^!UT02+ z{1NcRjOKQEPq04^^iR}|PlDfmI`iKKzq+)YMm?NzIqH}2T7o>o&Ia%fjDVK|FLnmU z``MsA@soXfzyX6VB$IKFf~i3adZ!z198UV-s_1o2J>?|~8M zYXq-n1ia1QwU2ct^mSE4*sSSFb#b`g{VsX5qQUSt^go_;2F~^wogZFTC4= z@f!7|1H7Xn;Oz!a*T0saKJkMRJBa^QO8txCy#!vr@K%?I0$u-PUPk)HUy1#|aa`}^ zSY%=S&`{XVssOKNJo8-ZP13gtyp6((ny+pHFFgX@KJeOwhoOuwoeuF*yw8KzEWE2E z+^Yu$@1&t`aRhG)l=O){x|OIdOS}!>>GVdeA9CPn`=a#i0k2Nt#gfe#?;-FiM_}Kp z;7uKYzKK_3{2BpoK6sOa7gZ11z$+U8Zzp(Tghx|&by@OxKX@_WVQY&o3-1N+UO$uT zX;l3yor>{8crzpPO$Sfwiz<&sLtj++ZU*nD#EYevGaY-u8x$T*<<(_L?-B403-1=q zTN7TVoiOZspXOQgO`cY$FQNH?$WeQ%0k2%js4((w{_dEtF9f;S$CoOBk~mt_&W3h)xb`%DCH6?lh*7d5Zk2Ht@1qUPKCz%J;I)r{mjkbP1o7?xuTFS15&3+`uzLyos1h4+#%jM|@f8)qL=dj)2z&-k|WP>r$6R-%dkcTxhm&YrmoI?g-us;7vW7 z>vPoltaJwYd*MaJI~}}9!fTF*w-LOA@XCYp4UwaMV>5UwC$N26BlPVBFE6|q5&DjR zcesr8-5$X^0bcA}=3N&N?_>-HlZ3Y-f>#4xLU>IPybkcTkASxuyu9#EMd&*S-UH`x zI^_Meh54GuQ9i!}UjHS`J3T_*__xD8;YF>hE5Pd$-nSz3tpab-r5x`a5xi~SH4E=p z1aBXBQ!itE-;Lls4_;n)^4?o(zMLfc-pcx-#@{K(j56Up5)p3$cn=9LKU#>EcAf*T zaw^9gRsZ&Yw^Dc)MAYX);3cN9z9`ivB19uVGxLHmsJ zHf`XQm9xHEgZXEy%XWfSC%kt@@b-h(GXi}tfOkN6H%8c3ibek5EVgfU1aCTc$7VAR zS;?2Bd>g?V7T#YXc$>jHJcsq277_1W@CGWF_qParN5I>DE%QzU^@$wy2PeR5eh2fS z>ht6|nC}X2d_=r8;0*~6QwqK;`O*R2u@UIo4c_1g^c@86sPM`n;(ZCcyznUf>ay53 z9-9G&g|{h!R{>spF6UoH^F9!sXRiWpqwo%Eo+aLGq;DSUi^{)!;7t`CijXghzURTK z6yA~u-bwJTV;^K9I^}#N^L`(Zj``qiuVUVRM)2CeYhJ*-qY=EF;7zJ# zp1e=kI&SR;udi$9LJ5c|GNADR{m#$YvKRzA2sqf@?&x}Y%BY0)P zi&`gd25*e;Zj8{km+TW>e+2Iccn=8g+z8$Y@cM)o)gMfrThMoQguWW^dPH9ouLHdH z5%6|{mly%>Ab4|yhb>LMbh(LF&Huow6yEs}yz%o2`aG>_v0J!aMd{lIUc2x<9-;4f@P>rjSU=cXkXNFzhwILNY7&C zhw{gm$25XBC_HpIeCcvAc$>jHCcLjWcv!;4_JWsQ!tv63lGUa4S0YYizeVPImh%>k;HQOup{_TU^D>*kYwuvau6&~S_k!0fJbF*Gx^z7V zoFgIr^Wc|vvEC(*>?oI!<(3QfzWL6o&YZ|y!IeZ`e(|= z$(3kNcd=4=Hv0V>c+J8)kF{Fod3(THDZH6Mo}urMp>I== zCw|JGSHU|V`qo77CRPF5%;}gA!J7}>G0`_Zg4YJ#;0Sm-!PE9d#k(K8e$f}T?t1~e z?ZP`J!oJc4=wC*lZ#sDGBS=RhcnRTMRU#4VdSmogo55Qt`HZb7zBEs~RBn60YZjiX zpHTIGg!)bx`slsb>eBHV^=fi8`qK|`J)rkvyLdI=_4hFEQ$h>2J8DlI;7!`Xyk~+u z%XqT~`~$+D9OR3i(tQZL0pWc*$TRwfSHYY5VU9mEFEj4bPprZCCA_G9WIlLvg%`CS z)Mn_5Y9~9v)AmL2_Jda@@ka4p0Pl6lmndFoE&6NWMb)qA;2jm-#ld_w%A*myLE$wA zd1n0wZ;YhF8&@s$a4&e}Bj6nYZ>8|+gYg>m`UH4A!mAAO#6KPGTQ_1GTp4ht`;Tn>Sk7hcr7^HsyXDBi?H7;i=26_V^=d!B;u z`QSY;0$v+<{lbf?hdaUBE<7w*`O^6phQhpqmDKeddKb7-N z@W$N7`l9N?e(;7xU#NW={oD)Sy)L{ceWkY`|Ago27pOi=2k)@(J{!yz%Q|}%_;V#a zQS-EI;KhY^B&b*Xlt23@{t@KQ^WY5#kKTK(E?sZmS$MD3N$^&Fob&s1p?URH{FLq~ z4VVuIZ*7ogTmOOIBm8u*yp8&^8N9=v;P|7~0eivA3vXI5ena08LtoTB zdpKVF3F@=-Pba~j^f|WkZ9%?K zAEuy^#)UUEg4Y1vRNf!Wd7*D^%`mu!IOP7bSU)cy=d@u8& z)|s2Zn=8Ec1@(zv)qn8P!Yhm59RY8p@Ggwtod7Q(y!QloMmi=hNB#)!)*w&(l1tR zi2Qhn`P+l`81;NQcn5?R8iz%W^fiK)7v5Wf`V8J?Lti$6w->y!ud#hmyd&VX3vYac zz7yajgy+p47lzL-OkRQd6y)jpZlt3Iyyg+a+W}sk@X!_UWzn}AytMEzWq0xpg7<*% zu%+wdy#(IC2=t9dB|ka>eHGvh3ok04R~h=E#bjDVK|uS|Hj1;v-89_#^cs_-t2;2i=l zF1!mOc&~z|(|dLVZ{kXTqR*SpYWs}wc|LerUsUMu**js8;fT@vhH1N|lOE5Of7{?L2>)ur<%(0`L1ZQ%ERgX@_$ zZtDKV7;kohcUX86M6Inp?gwu`c$Gn(q3;Dl--|(>_{qLf41#_8*uGGGH2Z(>9unTH zpgtqsM)2~&dpVdt#yoj5c-z0p@rK%!#7p_Tm+TYXhl251^80!4hlGD|kS~5p_et=M z3NNz#-;VSMZ)}9V2Jjvd-Zc@t9C!o5bB&Lb?mdP+`u>2r9QBO&N5FsmTb!St3-SZ? zSfwBQ_HQ%al`hgdWfjIt;Z=@6ZzK54-(kI>`8}sXz1Mp)cR-)DX2 z2YKQrJ9FTb3GY;p7bqvS{O7^1e3cf8U;*T=#mLSj2 z_X2oz!fOrkjB+b&LjNMX8zXqr!Fxz}P|cSv2k}xm8o?V9-lY=m<-ft(4Bk=U(f1eB zrS%!<-3wlGp3_?+G*6$=KOX^ayYReut=1=UWZwz!`bNN;+>H6<2zWK%^$YK)#N*j# zpzFI>F$d&Wk%Wapi5&w>B_;%|j}1oH0@w-N69Pmj%53U?2}E8vp;%f)>Q-0vga zbK#=T+jS<~&&FcwPCcdctos|>nWx2Oyat!z`6FD4_jin6auhDvb40>_4EIjN_bs>+ z5Z(`$TY_rP5T{${vjUk)zCzgFB@xcCOej2qw*f4aC=iaTE1fB7-v zyT$z|+#bl?E&hzScfh?8;kSuDA^vLd&lPuuxL3n{8~AS({{`ZXm+(>I|0BNtLiRl> z?svr9CGLmCeXqF7#Jxt`DdJuX_ZKLSiQ+$7+%v>2f&1xLY{u{Ly&H<}SK>Y=?qhJ# zMW6pYalbC%4~qLKaqkniSKJI-l4}>YPQq^#cec1!i+j1a7mHga?iu2iz@>WeUr%s- zIR=;PeNo(h6Za5Y;vIlX_3GOa{ta=zEbfEiep=j*i@QVIZQ`zj`)A}|67DGITP)#= z#GNPZ9C2redjVWZ|9Ejv;d?`5?|+N?nz;WCmw3;K`+W)jhPeIW-Y@Qba4CIT;8ObT zlJKm!ZQ{OH+-2h4BJNzcBtIQ4$$u?h68kC2ze(Jy;r;~v?><%%y9B(?!@cy3*o`mX zdr#z+Jj&t!2OnV}|1aS_1O6L7EQwtN{%_$@_&>wNp4yDva1SHhyTrdv+}q(kjqt^A zpMtwU!l%G}7;=ApgyZ=+T+;W>hf87^=${JrVz_$XE_xOGe|E0J;68B5ueoWk2xCasMT)2-w&joOQ2=}je zF$ej7Chj}ol0E0c{Q<&X#P`rB-+l`B0NnH7QurC--iPn4-3$M*0rbysw|tB9^L)7E z{|jFHO!<2?-0zVb-2HG*gZo|L|8q%f0PY=dvDZ7JS^U-Fp9{Ae;bY;hhx;a8I8FZF z!lnFs3NG3E7~Jn5{EKkE4fkHSIp80HOYPty3|_?h&DS};XW>$O{{;7&aMxpy%YuIu zT2SBeoh1IReU;Ps3AlG6d>dTCH^KeKsMsYpN%(ni z55hm1!`Hp=m6F&=_`eUA+VO62GjM5~y#p@UzXI-F_-o;Q3GNKI3FyBR?o7B7;FA0p zabN#3`-j9mD(+!%^Wyf4`+&H8;%*nWN8F9#t`s*RZk@PO#f^(QN!-zJe+qjaf$?PD zN5#Ef+$-UB!2S!w{~IKZc=w6BRNPZvs!uX6?`*haM~V3VYY+QhhPx5?QS!rm0xsF}S-8~RHo~QLbSGTW z(*l?D+y-|v{5QcR{w%nq|1VAV0$+3C|8e|mSRuE?G#qV&#qg ztGSicT-FfUYD5U35psz#ml_d%%%#Y6MNM<^`fIe?Wj5OF(h*nkJk$nPV^y@-U z#qBu;?fhOxTQ64gu4w1kN%NNK8ffR|hjzUc(Drk0uCx7lwBd{3w`6<#lG~-F(-Q*G_FqxUFU{ilo%OTP_P<*FCEEGTRnNc=`Fc-L zr^o@!5g1AkJlq;kBe<+_uFiI7BkeT>bGz*^M2~~=t~FU6mF+V zX#4qVhLoZ25v<= z&u`Gqa|zmU=c8SJ8rt?TIGUf&Yv6gdyZaGe2i%A@pQ83d+rE@6Kw2nz}On#rD2v$1f#sOm)ut548DKwDVpo zm*XY2`&`REmG7XP-(a-!i$*(M6SV87jds3;Q=IvqXzTA+XQOTR7V_V9^Tgv9*cPv% zpZe+tUal+j?`X@{U?A5!53}hHaRZJ-dz`$1h4cX2idD4S7w!J?wA!UEoa}6W9c}q} z^&je^>I3Q>>hIO-)GO2r)w9(Z>PhPN(9V0LdYC#^-AmnB9jOjeH&oYFKd-K=K0C?z zKE4n4ahzpXiQ8qNoQ|it-QU47%!f!1-ez7K?dupIpOao%{%E4J{Ej>$f5D4v|1R2o zhN3+lVl;o4=FBgk-Jc53?r*=ztyqKec?a$I!Lo|nWz?Pk6Gm<#(_E z|Hd|#_iJ@q{F?Pzsq1KYS+zHQ$o2l4 z;_T-inTvK^TjeIS<9~}Ma1GjdEI~W}_t4IJB-(k0p>5wl){y?v7j1uK(6+zvp7Z#e zDI3cJ?>djm^>~B*evS6{n}e6>Om(Uph4%RFfp$AIMmw)MXy zH`@9$kS~#EG}`$lp`EWA?RAk0?e)j~FK}KLG-;bK0ou?Pt>y_)HdA-7M&SPd5)7~@IK2&s^5@tvbXFk+oA2RHICst8fso!2FT}RdHJ+_Jjyx#U9|oD zgC6#C747SA5leBNN6@}M?nOJ_omi52Hrnm`mF6kP?@QdH(Y_xi;t2NB8}0WPEz!1b zjP`o8n!1GiZ>00Qdl79v`SLK@?>`Qpo!2I8#r_wf-JfRTO-?-)ZT~%GM;R_d(e7uB z)FCoZR+44VZjT!yxPP+#6&#DXX!~C;*I-p{uVw0maxTVje$&)ru?L-`9wrCM-ttx1 zNY+K$e+_jt>4&!er__bRo%8xb=AkX$tNvQ9(EKy?RGBRMV`H{^P2C#1(P8T9X!nE4 zXs^RdtG%%qeJ#n$)e^U(JwG(XFuFR1;y-UW^W$ji?Z8dk&Qq}+oq~4zc1GKOE41S^ z#@4hOZ98u*zw@TE{1P^2eh_VWHrn>fw0xeHPtfvsEsxRiaBRW)0b2ez(b>-*_#*RP z(atMZZk8+LT$zD`SbvK8O|-|ytJch4(YziGqpPVapM0a#J<(rRz@k8e2p{~m4s zbI{%=8jSY*+zst{uOr%dyo9#ii)j0;gLd3N^|R{VUw5|KjkewQXxptoTR%(l*_uz* ze7sD?er%Vheob~q+h2RM{WaFSp5_6Xm(#qYyf(}^?nPOEw*TYmopOuZsO8Jmv*gG4 zERWZ5>M`me>H+dKe1rY>P`8uevKiX(YpW~E^0JhcKN;$r_ci$!HsJWbsgKB?Fp>Rj zQ7=Qgo#vt4PMMmI)qJ?-ahms#ozc!KT-{h!N86t-+Wwx>{PqxM{ukQ(B-+>aXSqo( zlZ(;zKSTY293d05e1N)#Y=w7u9%-r$#6tQxbusyPu$QYn`~Mg1Jg&*#P# ztK~8+pQD~8$D-ZtBh+umc(mKSySlk-j9r*})PdNBuB?6(@8#-1-$OgkOY$tf!aQGn z1Z}&$>NRM`Tdbak_PjAw{l0upj+6;?e?bTL-9@Kao7m^Y2FLH>2BzUozPz2w8c@p z&hVgp{-Xxk>!vDNUJN~~UpUbDIrlOyVEI9`+j$SJW0kMa&gXNq^O>cdsveE@{bK;y z*X>5E^L=_Q+V|mfwEew;ZRrl`mUxu?2cvCQIKVm16}01=QJ+xnLOae{wDmv1c>D-$ z|FLN2*#m9+SI};+c4&{^m(bP=Mf-WRk-Dy|iN#nyKwU*vME-`9ryPd!{po46<2>r` z9Oo|Des9RjXv_1pJWun(@_?3a*YfW)UoY2a`4?I~PxD#wV=Yh9@)XVAmPzt;IY{=C z(P-z_3GH@@M0=b!)$#`F+Gwx){5AK*D7uW=2fNc=IFIXp(9gLYZew5O*YPvve`#KT zJ(>TGbD1C4{2=yWz7OXx->LZ)?8c)O;fL zXFeWhG9RP)aExW1fS)jr*SsGNWFCVvn0M2>BMxOAfzz2c)I3B6VFQ+zMSI;<0`2yF z*w?vT?#OHMB4%}p0&D+VAvZ<^k{bV`$ zUmxc@|3$lwD`@9ap!rF8OdiDHthZI2Ex(pa(5~xKwEcXb`A9iP#>mdHtqhk5KALxex7pen2~)Y_!Mi*IK?%Jy$(VzKynioR;_1JWAb8 z-9%kqT}@q4ddo+zImf*s&!e6HarGhfkLvH#%hU_xY;4GO)9_`SgdH&%qj3~|%=IOr zUFTrgUq;JTc#h}Crs@Xr8MNEWg?9b-V)(h3=fSi14D&qoPIWdG-JV#U<&!k;hxT(z zQyHvz6)ekomC&{;i{Eh`C2<^cZ%oIB(Y*i4ns38J z^k&UhY5pZ)q(0t>auEY^}}Ay_BYVB zzoh;{eL}roy-U4W{f+ud^+Gwbhx0kAcQBpni^GZdvgVEDPu-pMR^b$uN27iI>HAlC zzZ6%a&1cA-_yO%Jmv!U!mE7)c<0R%a&^~wcM_1=~pLF5(@XRM8|2ESThW2w^MYNym z*1W>+Lzz#P<7H(`W&SwI@s?bO6F6Rf9FNgxpQGxCzcR5ZZ+WFLzmE_ZC$KT$; z`Tcq_+Ik7HH`?+#>dLZ&=6|+#j<-Y3MSK5atn47~w{zyZ(5@#F?RFlDcKg4I_WG{| z+Uvi6+VVaD^8&2H`s>i%Px~0{^UK3EccZQMB+@zm!)Tv_cpvTSIS}nQF=+egg!Z|c zOKn)6?T+H>n2RIuN6nXLK1cKSaTLoFwfrUdyp{(=IQuJwwx36>o%K(lUGEQQpI^Av z%F8v9ugAP_K9A+&a$kRmpNCohEZTP8psnwRb{+q;bk6^6Ok%qq!<^eOTaHFM|Cgk% zyw!r|Y1Yrj1demAx#QPp^J>kU=ed$HIn>#2f{a5ukGg2b{irGDiyz>dINsXFmGlzY z?d*?sJNu%2Jtj2a>xA7g0c)b2rw`io?s(C0Biei#+V;KBzD^Ocv8*ABp&jp1V`u$8 z(Th^3j3pdU+9Lv)9uwQ z@FZPVeX61Je7{zHAwR>S$A!ALjF8P`Ls?svL_0q(wBz4x!0$KtesL9TehzK^tL6ta z--C9%?YM;X*P>n5a+-nbJpRNKdZl_i+W8JbJI{8S2jK+Pdj@Sk#jzL5 z3+wQBz|&~+Jhb^nwCyLNT~9N#{Z`ZbzYyp6f1|CJgSOuLXzRU+!*Lke_4PwL&kktE zsgHeFex|mw{!Y0JZMy|%pW~Q@cHVuoyoIcWww^EAanID!e&jMN+7A}(2krRr*qiOT zqHPzh`SWP&Jq~vK7wx)!!#JKV_Q~(%N|_-iA^$ANGuG*({+h?g4vv|1)iq>w>4&y` z8K*OgYyPli(eaaRqup<=I_*A(w*F~#p8BBEnY%ULEI&rO-9M1yu?Ek3?QtEqLv6I{ ztfu7^aWMNYr}#d4*etyo}T~@lZ{Qe8h^1sop|GfM|9+yAM-SP*yQLd7U<)?Bg z+VLl-lVzeDAiFtcwpZ6fJO4mgL3+zuLC*4XGEeT5IcV3jR=peta~@fm&y&;SIJD!v ztxl4?<*R77?p862lardH~-ww3n zZq@P)adpe!eQS%7Rn>n4?Nb?XGDE(yxSyFn* z!T{&`bL9_?nQPImb2-{|ey-)|XpjGi>J+r|9_n<`K+R)hkbLyKbDTnXQSL!I&Newg zj*&0Qy7GK==XrcL+IBz4337~VC~M0Cx3m7Q@(c84`;2PN^G_<;{yO3dJRh}IzbMO~ zJx>)^SFXzMdud;^?e14``VLzEuFg|`j6tm5Pu*6Qmp*crzq9@KXy^BljMqFyK7P(Q z-bu9M?Ug^uvz48Bw4Y-a*-9?1#`d>O|kXzS%X-y*^$BXijkF)$H+Vb=2BkKRD*Q#UH zQR;t7INM)A+kUY+T^(E8IiFY2mRD1I%QeNE?SHuMDmriP+m5SmIWConGG11e<>Z;0 zuA;BYhyOU+9sb*~!9~X>XI(|dFGRb2j>x?->x?rWUf@{pr{g~Pj!cyIPCLi@3+?gK zCEr=U4tlfy27fqR3#}jVBHE67M`p{_G8JvTH+XSw>wU|MXuG}E^23nz%V^7=M!SFh z#}6Ggzb$`8JCE=9VZqj$fwp{_jQ#&PKQ!3SZEvIf-1Qa)@$a!>u{^$t{I>+$9kB@= zs;(o0@I#hY!a@8zd+WH%)s^-BLhIe?9Q8u=Y_$D;h#PPu+I|LN3fo6%c`KYshoJqO zUI_=X(h4{J&Fwi+27?(awK1+HpQcJO8ojQE2Da743Z6s)NYUdFwEg{oc3!y{%PDM?-^%53flNiaefwcF>-UmfWCvMK)|Ay{WqI|8v;BFQFZ1LN za+6#qzmlD0D~#d$+24nq{hdbZZ1q=ip`0l*(AIlX9Veq@lnj!UE3wDrDF&s2Yaw%*&=m*c;QQ@P*AYWZvGD0N$PsJekVNL^K3 zR{fOv@qXv{g_y?vugcT-m|lr?U0GOkJENWNG`z?8jYhk!XnaV>ndsZM{IXuezlC zXP>kD7qsoR;U64tEr#>;`wWXQABc8;>y5VG&S?9M!0Ie-j&(5@ZM^`^D{KCEuQR_Z zui}30-@mJm$Q*p1`B&SVO%u`X!GZ-aLHW@yiIwb7oB+-S%5!BFnkg}Ki2+c~u7 zsUv91w_pT46GQP`499L*^!$$X>0q?y#R_Qq_d(nK)*h!Xq4h7gndMv2o+oFh$EmwW zk1Qjv?RM7x3GI0{TfGeJ`TtGLduZNH^QX~nhe!W&Ziidw%lhZ=6ZZ2HR;71g04~D~ z_>mlqwqCewh_=5#^x<}WPL`85cJVh-SpPiQcIk3Fj$pq%FaiJE=`8~%OSd7P=AKLq+<*+Z$yZ3(NZ@X|mIgeXd zejIK4g>nYke$vqPlYqr>5RPQt9j9?#?a^x3SajYP%l@Xx(Q<(7D9fTZ`?>pr zv)}7z`#mLh;2F;2Ewtn2M7w{w%_M)F58vH+U&P*i_@2IBK!FjZM&b)w%d(%obS-CbE(Xf@5zB^=i3x*{aR?} zRTAyEf95#*JBkD7SJCDzWw5LuAARpE|4SZ~+vH05sZ5oFWR!eS{`j49UF*@Vt0wm6 z_>VR_->>hXoll?&WDwWOc)k%gO_<6o3{GFN_v_I3FP z?ffTdK2Gxynh(`{pyoX_@1%KK&6{cN(Y%)CRW+}md1=l6+vptkE=F@Z-9S5^bDE#j z{Fvr@HP4aXX!$BFU!?gAIYrCg$8WjcyrWJ+J5DUxb-#x8_ZB*99eSWBb%Qkq{-1}-^Y8SoktI}@As``J?Srf(7qo(S?_$G zzAZ1we0c(Gy}fAr-H3MF)iO)Yl|#|KfA^LR(QfY=Xt%c;Z9kRKzOO!`E`j}c-n2hD za);;Dd*3?iU6sq_D75cmucMt;f6ZgijuVA;oVMy_>bhv_yU||9{P&Hs{~Ktp8;+u# z_m60=8&;zIT$h1%zLU{j$Bb3KjkaA3+IDTxwyTG>T?Mr5N}+A%rGBu^*)AV#y8~$3 zZ9v;@KH7G((6-A^Pewc5FtqJ@qHX7gcHO1WuKV8C&h2wS9+NxeEVTXKSmUg>8EyNO zXxlGDTRsQv=Y<)Xf2jHU@;xmdt>tfO9xwZ8d9;>y)x5oIh4ynxb1iSAd2Jb}YUjNFMLX|XXxDRI^Ano?g7$iOpL&=40qym2Hrn;C(R{h)pKCr@^JF;! z?RD2{Xs=ho(7xX{L_2;BwEb09KU(GVP0ZnV`Dovt52JlQ-zpc%X>zn2Alst7ehEf< zopOJr^ZkAs+Ut=O*q6sqf3(*t?a? zhB{3>Mm<CV!TD;SCRLZxLj+wAKpe=eid!~e3>VIk^AK5Xpf&%w8u+-EXH;n(9R=N2FucD z_xr0^&g10(+UvL#*qg`uC%6Yk${1|U^F&Lu?W&?Z&K`c@Jg$C1o3BBe&%+uxPWIFC zmRep_{cy3f{&}?L$HQpP2m7%l+i%6*Ec#Y{g?77qj&{4ulH<^}8-PVWZ_C$# z;UedG=Q7%U^3nElT>gapSwBZELtF0?Eq@Q~_8hF`J<)FGI%v<&CA9qbLT5j_(U$*! z_Ix*0rl9RN3GMhpWIwdycalxe)(g<`r_qjo`*UZ#b7=eDf_D5lXv>Fac`q&RjCOpt ze7wNve7Q|7#PO{6Cfa^_$u4N`leShjk=5n1n8NZW^PTOEqpiPRyiH(nXDsyWodbTu5&(TMabs^uAI?@zvjwq8lJ_bLCHC4+IqjE?e{p^dO7NBwEcaC zw%!cQKSWz^xcYUp^&-)3hY-zQK>PhgId$_-T&~x6T~HhCc-3TiSzP`*!&&~fERe_L zLA2-Fz3MG;BcA7e8G+~U8MNc|o$h?ydZHb-sjP^$pJM9sna=WG<$k$Uu9aWNnR2om zBZs5i4ujPL(B4mOscwRHd--dA?_=k<|DerJpsoLn<|{SNMBDE>n!hglqJ3ZTS9{3^ zA34vD`_Qg?r<^9!(G=}=-MV~%TRw7%)Bk?p^mw%6JelmY7ux=BPjY^* zd>yTK$(3>p#<1P-3C{NY(e~dRy;*ZTdewQoc z=W@2plv8D@94+5M`#v3q_We9Y^KjWrHk7sGjj?>ac;Dy>_TqYu;(6}(d(if?9naD0 z)vNI=y+}P5&(P`WNmxLSQ4hyI=|Sqgm`Zn1cfdh(3w2|Rqid?GV=uabx)k=LAE!9y zSBO36%j&b(oj##Hgs;*&)myL|y;i*fyVCR3v#<+2MV*SB=~3!Le1#sMj=?CplR6SR z(M{F$u^Anxu7V!AjM@i->HF_F*K-SN(ihaHF^E2*K7fJrHuYunOG zPgIXZH=U#&hClH-yN|jD?xowSTj6fHk-84SDZ_?QHS9i+M^D}k7<9k zFMdRqP(Mj_xhBy!(H;+1a3Y(bv$f=OV_?C)GzWn%<+{j=kvh z>ebkcUZkFjp>(=>5|*aNsE3>MAa!5#rn{&+pcmaj-53w^dZMPfI_{(^s7v7v`tdu? z`4{4k^kwx~{Ej}MK7{M&o$4*Pl3uG`fnU<|)wA$DdWt#~U#CZ@6LA_azI*T>#;pt=gaMwe0hU<`f#ZRdJ!VF-OeeHw4@ef@~~0A8oJsW;68i3F=X$PVDt$(M z3dhn1)j9Y&zXw@>Av`Z-YCaXaaKA`VkH+@&P<1Tc;&$q;j>3&}xH=U1Zy32l)Im6j zuB0xD<7qGTgHe3mioS+Lj|&`0pHv^k;q)H$c1)z#t5;(+dXaiAK1-*oCt(iPJw`no zKcfe!`{GQxi@F64D z(>dyFY)CIxFUI=xOmzmp<`w7M$>({0pYScCScgE5HqSNmcBT|)h2 zINvYnn`q~M1*_5d>O8DM?^o}_=jcu9b?8SgQ7^!Xbf$VL`qC-t(O8}ys*c67ba!V^ceMUETjji`{EtCi@F2eqFbmN<3Dswb#=T>S5TM2#ysvHzvY~NAvUBh ztIuM6`h@xr)}wc-x8Qv4r)$+K@MC(udKPx0r>Il00X<5ch|_qS4N!N&zTD62qutK~ zHLrqpKQE*9LA#&df73bdTWI(53+mHo_wys_18Dd2ZR*Wv_w!ZirD*r_IqKw&nKvp(eCF7>UgyKd9=E#Nw-mlq213t>R`0{ zxxd;M?S5WD{UpJ;pWnoy$2r>lJYSuMc0b>*-i3BQ-=toLc0XUDUVwH#&s0xEyPv11 zN2A@(hpJ=I?&sarQTQwO+i-O#9;ZXpL3oU=q%Mm`X)pDIH(ahG^ffGcoa15or1~iS zLhn&;$3ygb^=dpwFH+CNj&!Il$IeL^j z5og=uT-^!#@HlUbzw&jesd;rA!gWab``@36nKYWcYsrJS$^xdJ(d0)ro z^cnRjY)T(g=i(O}Cr7;sU*kBluqW3)Me|g&&n=8nC!&4cV}Lpa?R~0F>J}KoeyZb- z+|Cs=FNOYgyAILqiqFxP)n{=l`#qsPgmdVf>Mb~%UaMY#pVITyvv3wYMV*Qt+3l)M z#0Ntw7pe}{6cHV<^-Z;R{TYVCHvY+i(jq6>n`D*-|^I4>x zi66z;|c%O;B zi9Yr^3=8Od^?q#2aaZGJZr??k&&5r2x;h0TSg$XxW8Ovc4%mTip>B*nasD;c)$ssb zL0t+f(vRcxb;Z-1&t>&V4Cgqzur;^W2F+Js3+A&hpZOHcQ}Gl%N}Y&@=>h5(+)sB> zN8&EJsk%OHp##-b@O!$9+6On%_Xj%XdkeGa3+mIjnm(dFfGg>3>dm-}UZq}&OX)f4 z>9~NNs2+>+=p^+poK5#p_rO_ndvz{;D@wZ?S~)GCDqL&wueMjHKqWd>iqVv^xSe)Lk-i1%Nzim>l!+d&)dI7#qXR1@Mx!v#a zEv~bR<{fYr>$OmaU?}VPVg|=6rg>q1m+M95XK@7EA45COT;xwIB(1|$%$I1s0N-T$ zO!ZXkOQ)z4us++x;45s`N%KhjhxMAO>*IAgP+bMD(q+^>m`304r~5Vbq%WvXV-@;{ z`T$Pmdbg=pVI9t6IxglsCTczw7tu-TVYra)qway9)9ux*Z~@&&T?gmWZnYoIqf4s2 z@iY2vU)_IkHho5Y3O}U}s&jD`oukgine=k?V*G@jsm{O|^aOP>PNx&p@t8?RtGi+b z-9{aT>9j{3j33heYG0g2mry_H!}odmCKla)aSENU&chGr{pwvfnck#chiUW@^#XjK z&QwpuR60dH8Yj?0)v-99?yio)adfyk6vxsb>L5&^E2+!kG42;$>Ic2qKYb1DdQM^p z_mf@NfajSFny*0qBt%jMzQ_J1Xr7E?=md2iti^g^n8kiQng`=T+F$L9^XU@mC$Dio zpl@Q)?TVRnzB&&-ruVCJFqq>kz@Z#JQ}d}fkjFuaIst34UJu;HyshS;Sc7>GZfE|i z=05lW^II{z-^=U3b7<$2hx`-!q+Hy_?UJK;HvT{_S1-oz=$Yya+)PhUC*xW=K^>1@ z)6wd#_!Zqo9fm7tk2)9^(f(>*Tu7HtKZ)k?M&HDu+Y#r|`RY8(r1z_L;m7nQ^*WqJ zFHtYRsdT1#s!6A)M`HF(+%^rFMnq4?~~^;|qlr>iI78G4L*IG&~lsrzC+-9_C2o6s%P zjqydgrn)-5Kvz(g!T|blPv`tEBmeY2=@1^{cG;=<7Cb_)Rj1;3@ssD1Do`hE}Ryl-I^eL;O1zo3t(58x;C zHuYwlL9bFT#WZ@3dOE&OPgIXZH@8!gx(`<8c8bIZ)_YO&VB}90B$dKv?RM?%oL?b+ z#pC$0`XutF43f6v3D#S$`D*-`UZkFjN7*i2or3)7f~0uNW4&n2yJ9lywNZ!RJG4g~ zjBnHa>XPWsehOdZ`!45y8SVai7VX~?olqab&Kzf_dJDFr*Q!_GP4+uqJqtI`Q`D(A zjUJ^=#EJ9(bqtQ9JE+A4k!F>MA&bE~ECrB>H|g-48HS1_@?xXI3_I^@( zbt|;@lNzb(puHdDR{Np7A5>E9jrM-f-7e1gUq^dC=#2Ul+WSEV)wy_#&QWJ$D!p92 z814O@nd%I*_j@L&6Ocb)krah(ST9`jP;5qrsQr;YQIYhZGe74szlKH6$JmrUsoszL zsfwg*e3$E9uK8kone}F>Gq5c^L7j}P=md2iEX95z@f*&!spj=@Egh(?f~)8&H zCevfo!*L8fNZl9Tp}VL%;M;Tybz>Y&*Hl->QFH}$DI7^Z?&O?*A&#IgtIy(a`h@xr zCeb_9TktJKI%@cTz{SdN~cPR6oyf;t|{(9!Cy_zc}f9fp7Lxb&!l@gnW7_QeZy3H6f>ykAD& zM0>nk!Tof;IuG~J`_;Q}FTF{<4s+=x>IJxm&Qwpu-E@k2H2#kss*c4Kba!iEP)Ir#VuB0xD9@i%wTh z!vARjlQfti+|H6 z)Q9jYy;Hpff1%f^SKuLfzIqlOq^GD;@n?FJIuU=O2dHE40NqI)iCgHV>iU>X2db;! z=X4qM{kGixd|x<=tGOLdpnY8qVL5uIdJC4J*Q!@wX?ngo9gDG_(Rh>n57s;ey_rYi zKg?g$JQ%&0`(k7EQ%v*1NWPxTPvMKq52Bqt91# z|0445o81MPAJ%+74rcy8%{OTNHO4bvq4`|RXCVK6+MTX>isqv+j`>@f_t!ic`P_`V zo93-GZ;pI!#@$%+AkC{HpPO-4(!7M`Pg)gy?#2Bt+U;-&?Yhn&pL22luK7=z??yfs z;NGtJI?caAevjy0qWMhCGmziYxj)eS9nF)F->bP_*ZeijUqyaT=8n=lO!F5pnz=`F zx8{Dx@2lM9HFs%#KfLJoPwv}j*L4oko#x*nzo&4o)_j5HpJG$ynVL_~JQ z`Td7`m*&};uR#y<<(kjYd^*-+{-NgYX+8?;GJjL^ewz0}ey`!~s(CBTn<4LGyBld9 zsCgCSeQb9{&5LXPxOvh0*6w>~UzfkouB!lfpV@s%^8=dy4|!kNy-oAAnykv{?IE}{9|rp|R;N8V>~UqZXC-!wmhrJ4Vv`Bu$0BJY#9*J-|3^Usj?J=`-j zpQ!m*NQ!!-}ZJIotu9-w&%3Q8{Sm zpN;nUsO9R#XrGUosm?(AeAEPWGTP^(64dc%pUa6>cg10J8+8~Cp*`wg>`42oebGKQ zQbPTt5zjO9O|FP=N3q3|X9Dk+ zt5;(udXaiAwxiS4lQ5DVqaKdU=|SqgXrDjnqHcl7Tt_gz&g02nb6*@rmry_PaGmr` zEP6a(Z#rL{hcWbi^)8I2H>uZQFM5f30rsRb)l;ztouVF%-RYs~SbUZ4u8zWPbhtVc zPutf)9fZHz*Fjwt?dNtc^@Do6j;60+(boaP=#%QB*n-}p-j4Qj{(ALl^rsi8=i+m8 zx_S~;rpKshXZ(>C5V~SdKoS zK7?iIo$4)EhF+^)fzQzM)w8fPJw=_0rRY)WL@Y@UP{-iYbSHHrK1DZG*T>>?pt=ec zqsyp$&_&;`<6O@z{Ez3e3+mJOgg&A^fRE{I>dp9wUZq}&59vAT>G&@_Q9Ty#(MjrI zc!%zz?t!=I_Ucx6i*BT@gEwin+7JJsORBx`27Ncgxt{CzH+@EZ3a`=!)wy_y&QWLM zU-WYIV!TMtRA=A?dV)F`&(jI&csxf(tGi+W-9{aTf6^XxF#bXNt9|izx`g^kZ9Xqa z-^8NFKc1xX)p__EyV`~7){Itag^E2+!k8rnRByop^jh@_+)K|_&qDir#uRlb+UGMysS|MrJwP3U-_o7bk@yYWR9zpl z=slLpVQ`kc@ur?buWHR=d1H@CB0w03s=ya)a!5&y+pkLKcF+!DfkZe^I;gr z_wPQM_rQU4dvz;}r5ma1-~igK_QU>kNwqijqwfak>wtafGwM^=hd!vz#ZWp&oo&ti zYPotbHl=5(Gq4FgL7j{*(h2H#Y)nV1yJ91{jXDgg(H?a$cIAHMulB`4`#Pwf1oCqg zeG`km4tR&oSLfkvdcS%X{!MREufxmq67>SK--l$Xr{ZKfMLinb^iXvy&g1LWT^)t? z`;%~W2)@nN(HGy~b}XU!lK|)6Gu*_Y^TyY>?tFC~Hl+8fcVQKJlX@M#%k8p6y#QaO zGu2bkMW?7oqy2k`q3T%NLU&h3VGbRx4#kCZh&l-0qARJ(Vt?98{or}$^CH*KuID1Q zW%)_``yW=jrw8)p(rSZIL=1M{~Q4#vi%vp_<3y%XD{j6dvF@!_}eaPlu?3 z@Hx7Yx-4$B^Hx8o?)-b4YglyNINQ!!eH1^n^Hy)iS$5v))fho9QqRRuI$b>p?e~Ub z)Wh*3dXTy=X3$;KEpQaq9gJPMzxZqJi=FNMqkiJ%=Nua*%k&cU0_;F%s;6RmIz>Gi+tEYSvDlXGu8zV;I$Rx!ZRikn5Ju3I)Mc?X?WKND zjr#|E4U4`G7*3y5AH|pGJ?ib)l3uS~jbZd6^;~R0r>iI7cJ4Q0)WdNrJxJXb*U??n z9dHfZLfse_(>2xA@pHO@x)e^QA6IqGzYss7FRRbu1p0*f5cZ>Ys<&WYdaZf|)}iOC zXJKu6iaHhTbJU~MiP)1KppL=LbSHHrwxgS>>tkCwP+bK>=rU>_tWDpq;#|)ytU+H; zpT>&x5%mFln%<_~j8D<4)JyR(kBd3#>3EZ#s2+>MEb73b3NB_9DPQ83dhg~)wwu|&QWLM2zt4CF(%P7)ft#TPf#c0 zKsrGkkI{6rx+`|4+o;3vRobHt#)h=N+82Z966z<dih49|rH86x@q489%X_!Awdu7bIA8MP1YrtkYX=Xn`NaGV2Ze@||k=9}?FdX;)9HlpXKr(*+p zqIxWP=p^+ptV{P%_rMUky}A|Fq8q8}U`^Vs_QMzGl4@@Zr0-VJ{U4vF&!|tKn?9({ z#j13UIvf4zM$%rd(^>Ln)X-wVoAD$ z`bkBeU+9}ybpOW^biO(di_!blyU>f?q+W;r@pW9HUVxA3O!ZWJNT;Yr<9&LlIu`HI z-PKWemkw8l;%z!a9fUXOO6szBgZ5HCc$Uv$(bur({*QmqC)G#sB)vzy9e<(Mt5@Sb zdXaiA?xfSzlQ4%KqaKc%=t1hfxPk7X?tts*7V5^hims`yj?3u^>QeY6{n*zz|3X|s zUsj*R`Sc0(A)G_+RBypg>9y(=IFp{Qo`vc36m=?2p+~6`aWXwX9fK3;PU=YPKsQy_ z$98m}x(Y_pWz;?xPT#NKT+c1+Yv2FWr?H!T|5G2pm+kwXdNVe%?|Iy-gAaNBcdPyIK3!7njrZug<(=!fj%VpJ>Qi`v zKB&&cd326C8$Y9$s~6)Z^h|XIend}DCu3JSK^>1R>1cIVtWUR5hhbgXqYlREw7=RH z{pb?vC*^p2(>Jl`@sE#r{?AwE;UDyV^)6gaZ&I(rsq_-{0!*Vb)hRff=k<8Z<9-mW zc~>0F?cPQmhEcRf9gGpQzuFgX*m*F#y zP+bL=(q+{5pW)|M&g&G`=j(Y8?R;}_8P}hq&c@4Zw_Lp#|DtEAGw=dEL7j}}=md2< zo}r`FUGY!4jXDg+(;l@yzR7ucV*=-Ox3qI!*ReN!Mtur9aGnR%xp^bbECxJi>7rsq5eev|H_m;dDv0H#VW~meP4+0DVS% z3JW>UgX&zoYv--b#yj+K^^t9o#~@)qa>mmsERW9DVm`eI2kjeMWr>Bk6k_i_y{QuK0-iK^t`#{y=-w!T2rhulB{YbP4s7r+7b= zzKKQ8llVEEug=4F>HX?m7)x(bufqZK67>S?OlPX6Vi?VTbGT^#{5MRC{x1Jebu89o zd3SXb)}X`Hq4)wFqUOK#TJ+z|sH857r?}tpx3-J+|A31)OkYF0o{Rj?Uizf^DDI*6 zsJG)bdcArzuBI2M)A0=+2k)Yrzo*N4xJ7?InfGw)_w8=p3$foJeqZ9QgS?;Y z=4S$XKhj+Vd4J8#YjS(P$z2NhdC6TI`FY08YhnBT=PpE^&)xqZ&!6rq$n%x^4Dx*A z{tbCNx{n~|<6c#q=QqyhGh|nl_$-HO5LQC4#<0UuJ+gz z+hHASi@Yc4io}Z821{ZD@;5D9t&!&@`-rmV5{6?wzJz>M-_;WNn!3V}&-A-m;CgJ1 zy!Y>FhM!|7^0Tjf*cgXkBkY3>u`4#fwpbsVqlf?ZU_A`Nx>yJ4URWCoz4&<%uVOG3U`;%MHShqwfIngoZp1)bg}lYiHCT3)1r;^46Va z0`k_Ehx?L?w~Rb|Cf~(dEuQ|!TNR$}$dC9QK9lU?M`sV8$#wCgsHY+FqnwA&WV-kf z$irt6UHk~);WK$IUV3{Tx%hbz?;tPvJeQG|P@dDsOApU6! z+C5((Pl=v|$Ww}ECh}19OhxXOo^i-s*8WVSi@Tg>DDtJYKP%zlCbNIG>f%&9ZIJ)- z1n@uhe8#yJ-9P6!`ee!f?@!bp$~5_&wBvDnpEqQj>@8oF9c6@UE*r|)GC)2j%gd)F z6di8|4-&4&CrhTuI2j=Wq)Qg?pt9|D$Sj#A<79*kkSKz08tn zGEPRw0O^tiJV_NDUuMZP87CuTfON?Mp4^JImsv7R#>og7AYHPct+tn0GEK(G2pJ$< zvLI61%Pg5D<79*kkSmsv7R#>og7AYHP6Z-zzN%Pg5D<79*kkSXnI+R?oQ#kG(j^P{rd_nX%#vv`PDaQ8>5>I}voG3SX2~=eCnIElbjboOQy*<86g9tOBV1AvuJynCDUY_jF17+B@1}bRkXd#l4&wdM#uo^ zk_Eh2E81RW$ut=!BV>Sd$pT*F6>TrGWSWeV5i&r!WI;V`FSBHtjFS;EK)PhX|1owZ zaB@{u;w~ggWHIfAQAA4CfEYU65hAEmR??D?CLJIySk>vSbhmW6imvXY1E?j71ec** z(12TsTM*QC95wEZq7xh)TgN4iTaBYLnGv-W9W(0R`JZ#o_ujkr)vMt95pI9y+;i@I zcYF8Uci*dLVNci~tP_?93xs*X9AWbu>)BW#|HJz;~ePFNx=5atPU zgv}+`6E+CzgeAfPVV*EY*gOk+!UkcTutZoO%oFAan`dHA*dVMEmIw=kdBPlF^9<|> z8-#Vj5@CTbPnaWYo{l|XgRo9mA}kQ*33G(a)37IO5Y`DxgayJpVUDnQD)xj8!a8Az zut1n6%n>%9i9KP1uufPaED+`ibA-)2_Jj?>I$?>hK$s`Y5jIc3p0Gh!CoB;b2=jzF z!sauuCu|Vb2}^_p!aQM)uz51}gbl(vVTrInm?z8;HlL0?VS}(vSRyPC<_U9z&6BVv zY!KE7ON0f&JYkNo`84ba8-#Vj5@CTbPnaWYJ{5by24S7BL|7oq6Xpn;i?Jtc5Y`Dx zgayJpVUDo*6zmBbgmuCaVSzADm?LbSh&^G0uufPaED+`ibA-(&V^7#1tP_?93xs*X z9AWcG*b_Dg>x3o30%4voN7#HK_Jj?>I$?>hK$s`Y5jLNIJz;~ePFNx=5atPUgw4le zPuL)=6P5@Ign7aoVY35!!UkcTutZoO%oFAan~Sg~Y!KE7ON0f&JYkNo`8eze8-#Vj z5@CTbPnaWYo`5}JgRo9mA}kQ*33G(a$^#h$Q1SSKtI76|i%Il|^+u_tU0)(K051;RXGjKA6E+CzgeAfPVV*EY*nBkhgbl(vVTrInm?z8;HWy$|*dVME zmIw=kdBPlF^Jwe|8-#Vj5@CTbPnaWYJ_>un24S7BL|7oq6Xpn;M`2IcAgmLX2n&RH z!W>~Uhdp6~uufPaED+`iB~TZSx%qBg-&~N}_ugDCFX7;)Wna03fBCwun=Z)R{0&{7 zT#(x$FGFis*m#r-oeOfO%i{a8IFTu=14AxdAaPkQV|-zoDAJw{2t zF7p>Xt|on*SLyM>$p2}^mqhkw8DEHf=ThTmVXyZ`dR!fqN0;$GNg(fA=c)x`d57Ea zJp5|(x~`+gb=RA|7k>S<#tnG>9OF57!;rDAE9r6JxyDua{?*vStNV@T;lEyty~NYw zTjR#P@ZM96>+t_{Vh{hjoTr}O%%x`kxhdl&{0nIZs_)%k`gboeo`o0OVBE3M^fMA_ z{1SYnl&i8n9MR(<&c7F)rhVwk#CjZew8gK&`g>SvKNsnxT`A``Tl}pbHSUF<1ULIk z|LtdEf2Hvuv32>m%J_cjzY{*8YWfnqoAQ`}ui*T9x0?N}qZYpb|HpRHgXLWzmtNx~ z7XQ!7@&8ievtMRB3)hwz&%^(3*f@W+#otZ+RpC9)GJT_D`n?mzbMP*yXFcC)zv=(w zg~qe+^T~g8o9XrUyEJ|i9*};oTo^F@OE{k@EPEB5eh$8n{1gT){yk@#zO!sxl6zFZt4=Z(3NctyOvHOb?Ca z{7FC2L!K!+?s%o~Dc!+^skh5;PT&X{(eSz_CCk>kCJzn9(=y$UsNUdRCrb&%*k<*wl}dUTyFkl z4}{|;EPEOpPs1OUaYo~JZnpUQq#wHU^ueJVkGsJ1RrKFH%k;hIA3JG04bOENSJ#;R z&~D@0y~fYf^yJU_hw#6|cou&9Dq+dbH0d3Ue*Qj-|7ZGd{=>#Snx4e(?X&#%!}Hi* zuj7sAXW#+2gZPhOJZ#|aE_fE6`2+)jI*zs&gCFE)MW$Bp&(Dm1+c{y)a} zSo)ahH?Fn#jlVZOkMf>_e@%KF`1{VO7JqiL#s4XK{c#sPw$c9bR~a{-PyC|sW*PUj zyz}=PpTYI80PACYtn*$0hZfxZb(oM!o{-(dQ;KTlZ3lcv1Pq{lKHKZOs-<`6yhYyT3SgSTt> z2=~fnMm@IZ^;Mcq;~VC0nfe#~kI?^*{H?qNzDc4fm*D%yjSs?~>lKzb%{Q9A%XEB| z_)YY6Z7<5tv-IzZST?ul@!9BnbOVGO&tGBw8gDg!7ZZQ}2Gh$s8!o--Ueljb5tjB> zWqcWjXJGx^Le7#=DM>nEwkozfSl}c;=&~f9A(seiqDAU(5gA zIIkNN=o=d>y;8TyV@}6=@jp-gZeDLZ2S0?qlk3k5G{0inF>Cg^KS#L^pHMfRh5Kml zP1?)TcFHwW;?L^F4>|f|9;K|Chx9n{&Bi6U|Iy>lHyTgxHoic{dyU`3{zY&d{xUp! zy~W=RPruUmXc-UHzIv8%{VaHi@o!-Ln3x^|mzZ8ZBBsY*r2VUX=^W!HZ!(^Hmhs2s z+OGNr_BzbD_;;Cp?KmuWN#q>KU|N5BmYtZW^E&$KQJR7pqOb0iNhL?uAb&7;k}pE91YO-&XiDa=li5DXiZ|Q7*yf zYWou&gkMX3hv8F}nSK=3??`Fp~l z;2h)o;N#@_toj-Flkh*l-O{X7zaL&+GyWWW_VLEE@I}}^0KY=}lh_}CFND7i-@eK8 zbMRLmWBeWXu-reZ{XzH%a+y*75&Y1MaTD&Y8vh)=llnXazmocU2;Mhp@#o=%w3pw* z@~vf;-eGvr$Bh31FGsH*xz^(*%69?$Ozp3d--Yl-x!+bk9{yk2YX^KP=|2g+jP|h@ zemCv+>F~ueA5(vMcs2EZI(*KE>6gIoq`#dTai{4!Vf~(u`dbcPMER|NpYRW+e;#}_ z=@sCw%Jo|9*TBb-zxD9Nl*b0RLHq56kEJ}eMD{YjQGZ+Ezr4`+rSRfQj7zZW)pzj+ z;U~Ppco_c0tBgnC@5tOh{a4|;8BZqQZP%K93Vt{3@dkK1?WYbm$j{C2^h?Zs4}1#a z+3VpCU1R!b_!j#2TVQz?!sTx-d|2|T`F#gmroI~R<8Lzk``~Y%ZM+YD9rbY^{Li%4 z8Tc)XH~#=%O#SSK4{^Qt9Q=^nA8CGO;h&#r`~bX|@;LyXM0#I`fAwLDKL`J}tV^iB z@4%m@z7E2N)|&oD@c*qbZo=P%e-6K&{&Wa_)9DufA^87&9DDibjvjxaz5N{i?8i)h z2)>W;<{|jEjCb?!_3-cEf5QJ^_yGR@0^f-~$9VEq^b6qINPi)G9qAtr4`JT{4`Tl$ z_$urd!|SnsI{apxFUY^Sx5)qGIFb2U^GxGU=y)uDHuo5R?2X2SUB>dw1*h*l*Z7TR z8Fw=OyjJ^zs5)Tzt!ZQ8-+G;K<2`0yIn}tA`IvrZ*xA3#^kd9VbDD8E&b`(2bFVkv ze5rAc`QY%2j7zZoezf|VW_~%Q{ZDuX{i{j8<4xvo0r7ivL$(~3YWq?9yNws0VcdW} z%=vV@&-8cUzl6REeJ|yE>lo?7Cow;5z^~Q$g1D-}*AjmYUO@a=_~rP|Q=TRAJO6Ua z&!ecHUe+((%lS2Tn0`C@S$T;;kKa>%RroJ*|D^fpfPY?wM=kyx#BW?}{BYg$dCG5j zbUyDly}VQF{MBzU{^~a4Y2yD*$1_pQ6aN!%2RscI;H|We4%+kH0sP-?{?|n3M|pgQ z{La8vpl`rS-)#1CuQU6f6Mq{0Z#bX&&8Ghn=Q|DmdBp5zxL>${`k48E#lKdsPx5CS z?!aFOetUF&@J_fF{@18Ike~meeoEBGi>A$g1HMnv()60t|5Y1|^S4=k9-x1hIN#GA zOa9QmC2DWFTh_NeeWe^KL@Xi;-6yn`nxrnewFsM8~q&olZYD@|9t%A=uZvo>-6up z5x*1u6+8o99NE)8PolmW+%KZ%UW9$M-_lZ+w6Pcy>J2U#(xJq zfxZsEZP4uX#~JkalwM!u&)M%f%nhwDuHRw$6R7XGw;A7#zJvOFa1Hsn(e&Sz!1;ss z>ikz^Rqk)kqy0DkV(Hz+vn(7anK&ojSkLKRLhGG2WKQ-=E<;`ZrKNv)j!6o$x$-sNeiG zsoxhcJ``y0XPifQ)y)2TryF3aP2`NY>3oaDHk`N7BI8v}gS& zx*p#?n)HbOR`k8-|D_*2_TQqura7NmB7aXbf4`^x3dBE|^5}(EM*Uqr90HLoCgbA}<9m+l%NNfw`x(ZsQ+tdH74!Eq%4ZJ!HTavm-Spcij|Su0yE)(7 zEvCPG*!=avkGa`+miW)O)wue4i+?}Yi@71=2JNdlOnUTZefd(42QM`H(unc35@^+w z(0?x)&zY~BgM9)0t&9f+%KL}cn0*0%8z`@7%KuL*O+P(u>77OYnWsM1QoqxTx0grb zC)b1P;ZDZW&#p0ly_Cm|jGqO@)6SbruRlJa$A3lFn`OrOdk1>HGiMlILI0hlJ$-}v znS;Mhd!7BhbC-KD?Qi;Djc*}-#}AD!XMCy?|9Z;10bjGz(k~sf_|IMfqkkIhv5LQM zo`#P{{DvA&!d-bd^qkTKi@4I7vM)z|8@9d zBc`9Bd~QA4xP-qc+D8NaKl(!l_D?<6;?HBhf%40dzhm@%Tkj zso6gb`y6`x9SG+S|FfqV*GYfZi;QP~Z1(!QEgHWGf1dhm{=4aqV!Uhq-1tQLPaXb` zqwz=nze;`1lb?tCP2Wj=-%ow!qw+*Qjs9%X&y$~B)OVir&Y?bMe`onQi}J7k%y^RV zsrTQEe@lC4klsSMF#hyz zH-FP5DP%dSw1+(H>yl~HH?K2)XHXwT@~-!7qJOmXAJ$7AbD8mB_@ZHB{n0-?ZrEqM z5WefR#vSl!4dcb|DQk@LaC4RM68JwKW!wqB`7OpP;Cpu)7hwIJYR&I@_*E}7?uCo* zHQoxJN_r*u2X~u(82+Y~pZKf72dl$5)9~-f?_RimvH5Gj-@CynEdE0Q|xmjpyK(5dR>2`%=?4;k`E-AA&!E zejXmAJ`Tex=`Z@D7GenKx58HxjZ5%H$nP+GJNd1`pC`Xl@P?@V;U(mE4}2W? zorWjL?_T))O_qKGzNTip4?c?LDKqfZ`%J$dKAZMA3%`W%_5l3C*IE2I_}JTx55hkr zeiMG{-Rtvr_-ZF&-_{jkI$7g8X*CpL(;!Ukv|=_Lzq^ zzRC1UqWI`L;W@otY5l_!=nL=yt`F1qd*QqAzZL#I_9ggaUH=mQ!|+?sSK*i9 ze+vE`{_5}~_Iu#lXn)i2&2KROd*Q#(z8dgh+Sfj~4$r`Ep#1j3r;+|F{2lZM;FqJH zgMUT&9fVKke46lQh<^xvKIbzJpS;}ie;7W{WvoAvqsLpAA1s6qz1#F1@WU4vFNXE^ z=d`@@@NWDqffvJ_@XKg#DL30>(YOTP z#CSLiUqty-;pLpq6#U0Av#-Oe>c)HEacOIs-ZcDq`rBT3?kdwa;GYZ_?}JZb{G5TW zI@|R7;X%r07S`WU(ew_$r5lXr;JfZIJ_!GCr*RV=d5!TQ_=zix=VASwH}!uQzK!zH zAI;L^!ShVN5bit1xC35H{ujdy@|TA{P5zd^N7ElW;m_c21^hwsUx4?J|Ml>RotAzt z{8sF@!r!NVm*8KLpJDjB^q(sH1@u$!F?xR|c)Fu`DUxtKm2b|{YMW_)*@v9eGdJEy7!X5B@)%1(uXVG8t@X}jMzXZOA`s{>nWV~4cABVmGkD^}> zKYW|{>xH-eo$*$9>`LPjd?)kqVR(T2RN=4ewfIwTZrHdEuX?lb9{8{1ZyG+x^>i=% z6Z8#uoch@Ze*ygrd@Y=~0s{LUh{7vjT;P-HSSqz^-`^v*>@V^B94E{UeUoA8LE8q)A zuK=IT^wI%6|^-UT*q>aQTJC zO?VaQAA-M_H~l<3%lzsv{JUqGKKFR5|I43Xybyl=+l)KlKI|96SG?8qdH6);yG!7U zDc??b)oU&O3ius0;{yBu{bN1+Q}n%X--N~A3KyA=m*8VxYWiXL&i5Nv;XhCwQ}E%F zOkan)=zn|Qv+2*%@EzFig`aku**D<37aH$_@1lNY;IkfY`u*@z=pVE2LdyRDdShf6S;9K8rydQoV>CM9b{1Ve2 zfb~24YCi|xi~Ye!k9`w9g#97-SnTKF8)=`1;Z?NH+!L+-Pes2FzMk>0173;0#qe2h z9{v>Ny#)Rw<6S2_NqMe-KTdlqz^|dbt%rA_?}aZo!OCMRd;{s1;Jw5jhIinv3Lh2K zKm20i*Wr`#zX!gT@ogIZE%mz>z5{&&*6-tMeeHwS(Z6TlrB62fez@y##gYbjrTKpz_-A>~}@S~Yu%)`Uf$6@%bjF&n6AgmnEy~^wt!b7x&4)|o+ z%VPMGQT@Z8d%f8&f&Y*3p%cD}@q7jR7S6W-Pt%{*!w+KL3;&t)w!;69`YOSX$KNpg z={w>2JB?Ss`u%+MUx4-ZU6j|uZ>7F_;RVFs z3cru~D8ctpAH(ow&Zi2$p8h)pkJEqa@CxGZfxpFgI}Lw;^4JT%gYsy=2gvU}_#V!G z2L1%)wI6;vT8CT)@Ta2gR8@XSs!#$+G2Yw>@Y4~w#%ziI?`Kyc@ z@UMrA_rZVYGoFF(T41~%emV1{S@@j4GyMVhKcf1F|1+w8SU>2j{iO+i1%HR&mtSW3 zdH5qy|A+6uzy64=9@lZbSP0)v`FFsR#9s_gUt<3A@I}%14}arzrtgFg(Oy=-571r; z@T;p9e?9yb{Pn_T!dv0XR$2TKyy#lvVfaqUqYAI0e5c^isQ%&UOU-@{Jn}N*X}FK_ z*bBda@@T*>ru_E772?mpR}gOIDb;b$;@=HYEo{lkA?J*pGl zL;hC4cay&Y{0{QB9zL4<^};L2-&S}R`76Qu$=@*ipLbY(tMKn>k5ll6$X^}qBY%6~ zYslX;yqWy%h3~q{{5Rl*n@C^Bzg>NN)2jCZyzd86BRnxn^M&yF$uVfaJjC-*d~|1IQaA^dyBzYbV`Pf*ia3_p+j z<>AM1zp?~g{RWHQ2|st6@e26p*BTe#k4_q|hwnMdxEDTrtMOKN>ssRyynyyP9PvWa zSK-q*-zoUja@u-6b@*QyzxTkuj^=;xN2Bo{{%$n?ga3^EKDdMaIRnpOzaRc1_OtLu zDbEA&`SjO0_+Q>{`8^0vztXq~H%>7=1RvFJJP+?X$@nn*&{pHzNml>+KWw}Zo_x1) z2mDVb8ZU_QF4Ug>eI3_6*~F@Fwy<17Gtr z)9;60O#Wx#%gFx$_!#m(2VYG755kWn|4n#;{2zknxxbi)*O33i@Qvg@_jId&{l2dD zhlTL}6pcIJ+Ea}e!%rdqdHAX1e+fJn)j#~jC!75W_(P0m1^D^oe?9yu^4|*|c%0d9 zg>R?4OYjWkI}HDx^Qpp1(NDqu{&e$KhtKEy_Q0>iej477elPrJ+G_(ollHj}{s8`G z;Qw80>FtMipr3_j(I0>haDH>}f06%#@TbUM6aFpvI|N_Ecs~!1Fstrh9bNz7-$mDd_yNZACGacJcfxzPey@Ok@El9O06&58c|H86*PFf< zzU&3YTjA$%{Vu^Te2wXc;rmC8t8gCu6ugP{SBIZU{`bHi!vA!{`^?{7_zbSE4R|B% zdmp@+_BsO}Pk-7E@8)_s3vY?We^`H4Q~To_d@cDq2tV&4(>LMo9&3CE{_$?(d04-H zt^N+feO&+a$0+r9(@xVbg!5d_I^eHeZTiLVZ|*kE!?(Q3cnQ3&Y}^S~m=CRh&p}^+ zUwMheUl0Fo(6|@=Nx^t4{BrIWOYjET%WxE*_FIjZ_B#c?8GRkT7X2Q$8~rr=Ys!Bw z{2|(R1O5W@lYQ{Nke?ZN0rRW<@QK*Z!tZ;to!eVqRRcscqxcopkc2jPSGYr-$# z{13tJW;~dO@7-?sI}GooJoHB`^|FVLSyN zh5tHyF< zOP^t!hle@;CGhj3`iE~}{;~qTne#8eHO_xMJQ~$Md}dVt@Wb36m0q+=eG|&j`U{WACUk3@Dn-zS@^0G z%-;d{J1dRn;14t3ItV|9>su54(q$I^5PVF-cph%9Fg^@_i1_+ruX=pty{2CXkBk_1 zz;{RUe|S6dqda^H`X%s>|IX|?;Tf(cE8r3I1^6M_*LwKB&o%pAc-ym$x58(@CHONJ znSK~Plk%&=D+;Ecg4cE%*Wu5;(s&Pi@I%Ja@Hc2rd*MI4!}JaKT&{on;G?)-n1R0= zjsNiI+s%F!{?F$cAAlE9-*fQ8$C>^heBoP-n{Yq*KLo#*{LjM`@_!iq0{Pb;|JCEa zOXhDO{3*uo4tSdUFNRMc|9NPs3j(|9j!D-(lz1fG^D(?}K~Z zX*>h}>`BJ^;jc12&%(R$e*nH3|8wxkb+bPR|Bmu$!hfZH55XOzKM(&qd0E5OeznSMQd8uix; zH=b(xt?)+buLM8D^=}w{Qgr=?@1}mI;1TM#4!?=>-vi&l`A@@(Isd)zvpN3;{Kv;x z{`SGYpnPZGb@<;8uf+c>e8S7j{s4U9^Ni=^tF2*sp-!fPDeJf%07s zufkt1ya0b&;SW)sC3qS3!|*)wohp0|=}o~!?CbDNl;<9J=J|HM)9|+$pZ3DPpuaWX zDfIi`ThY(J&p^K)-uVpkKMOzb3gZKC`DEiccpdpW2)~*9HR0b=zK7uFQor-?9q13k z-=jQoXIcH9kA5LsL*D^^pYmJ`cc9P1yU5QH_&VBaC;X#}?0i^|Cd_c z5`S*5@%eT9!L>EU^#i7V>`RPG1W?yH@_i2a%hf%`g*l5qwBC3Q{#rCXz|ThC`7Mio1>@7~r;RVAeKqjE z@=WvBL3?XP4ClM~dh$p8o_d*aFaAHV%eeV3mVUop&&0m^ZR5Xt zj&c6u#$Tho)$cdHKmv_lmv*hka8!Ty8sE1Pf26l!C-MK$^jDCd*$0h(P5aA#(D+BR zzuwOpucAKZDX)c(Hh;6UzpoXH^R&NfD6cyFlu6TfNV(|o#g`e+++uuP$#|Oa^BC%D zc8}?w^%&F7WB*3D7oMTKs>~6HeNg-x1aCyN#bj|CsxP@dqf+S@;C{L!)8(3uy11w6Arv_bU8C z%4eGP+yUokKaU=;{Lc{os5QnNl*d00aejANdQYXlmA-B~MEN$pVSL65EdKOA8~+df z=c)hG&oq6W`2S1!Xd&@`hgywxS0HX*|_f|#)Xd=zm@u} zb3QMK`WNHHkB2S(EaTI|3yeF+&p#B5OYkWErtvq7eFyeiqxfI3^benB_6_)*CF4%c z@10wXd*Kz4{tmOh=`_<JoWTd-67#Q* z!Sk1!{vDBiqwz1t>^HM4wOsBwr-uBQTFCdE5%Q)~{BNf854<{z|08K{ma?Vz`Ex`5 zxSX%AUncWopU;r%wa*u)(*Im4{m)5%^5Y+n{^9diFA4df-jIKCR>*%!=`YX%6U z`2N3{ivQyjuaNfd$N&DzLM}*u@b&kULVo6}LVoS@LVjb4kC*o4`#V*xk3PRi=Hos; z_VSR=OP%jmWPJ1EH>AJ&{Ncxje1h~BUw=VLufNOZ>;Ib4e`zq(KlPfBKT!$!cDcU$ z{wB7C{1KVI`1%*z6mlU|Kkv9O)c>qAK+52PylH$b8RlKR2cHTT=c$o~qB6h_P?~ z+SK`O@tzc$Rz+fwIuc53|nX)6A^Q}Mr=s-J&PrT5p=_%bZ>IlsK$o=WfQBcXnH zUC6oO_~^#|iSd!Cp270i#E5)PyO`$7C;KPL<6|S0u_Vs;=!Q!FV8WMdSh=Qn$%f*} z&8vz7l^xaoiIHt1qt2bLTHDv1Ru7H#4;F_;i=*N%@}SYW(h<{sS|Vh7YKa#5X;Ei; z=`JpNr2Mo*7#iKatFJt9)yUXjW!I)^|9~rwR>>vhiFLhwONU2l6P0l(f8mwY>gdRT z6k=s;&B%CpAXZ#e8NX&^Y{(O?9_}9-DtiL0n7-lu!SeXJ@yd>k>nTR7n9mxdHZN_xSUAFN7sz^@4B))K2e@pX_4Y845Siqq}IP} zw49Qz9cvLrbuRrc75R!W9c@xV?KgpFM{T?G`N}oL?Na;YrQ?I;>cnu3+@+L5M^bJJ zlw>PBjR_fow}mGjoRP1WHng!aSu1bWqQqP8$W&Pd^6FG937YZ5c>h?fTB&I*=wL5{ zjMvLEwB?D_a?a!ZSB{i-+4VrL6up&d1W7B~Qi)`eF|(4!{Bmh=(pe+b_^7m?E5=52 zsEK5W3pY@aF-c{zHXOwfD{Ea>_K!}MBWavaEbz`|SO&D>cB$Zr;!f9|vWsL;+FP+a zTHYa-y;^Zwzm!cB-7lLXM2m`kyt1>RgR(WAI5ln1Yw^EI+^5v8>pemoRd3ee{Rn=1 z7d>M#3Xctx2Q$)hEu>E_BxS9AyW~jEP>N4vWXH&abok9>aWg*A6KKVRF-p{x$?<{m zhKgOGTH;a9t41pW*R&}6Cbx}OCMV>Q(V|NEZ_%$C?;l#zKhclEMv)!;69dE2PY27j zrGryD`qOQjA!z%^s9fxdJ4VJ_6z#qv?yqQQR6`vC;wz~e1lL+&$z^wRa7(3cV7y!& zQ<+}d*GMsqS9aTAXri8hinQ@S)Hht&6-DV88(}(N(Kq%_Ns(Vyj`S@&G8X7H)z#x= znT|ykt4F0%N1$r0JE`MHltPWMeq=CKD{E(}3{?6f6TkJ#$Ty@NB)$gLWMWa-rDK8g zOzV9crRYa@$~d7?an>TGd4&TK)nayjl5zoX*9_BOyTyb$8s&;M#=NLs{zR?vYGr)F z4WK(?ao@m5tyURNN!REw?s`>9p)EWbMiVC@U8jRdBC(FV(hbSWFPp5j(X>Gdm&da- zm&w&-u)W$Z;wWY1K0lCSzXBw_Yvz9d{)mBioMhHdk6L5zMzQmb~LQTbd;2>-{p7W*eS` zbgkMiPN6NTRK#C(uX* zdi}{O!ARkEr%{)Two2_DJQBS*7ZJd%$i#*n(%P?o#T zHVzmf{)Q-74zSKrWsb^TMM!B|OItZn*)cM(x-zM4(oV&T=G?SM#n>)LUQChEXhWf; zk__gVk?5{jmc)0{@KC=+ZwK{OY+boLxUGNSnoy0;UY2$;m3^?oT=~IJvNYO;ihMv#viDbU*;*K`2As^$5XYFYb~a)eV*Bo zbe5XVaO1X@O0lg@O#PGa&B8%@xtA9jfiLo%w3GMviX>sL8qW7)gz0y;rtgdV^m}|o z=%uUGi!Tbi_=?cWvQ{s?DDdJdte)aJ+MZlZ{6^u4!)u185Krj_;c1VcvMhuHoM&lj zZ7pr1^yUmO0j&>Ld-5N;E^(0Rb-ObV8J&pMBE6me` zm2S77%RN2Gw<@v>yQkWkhN>*%uJ*>EDm2bW(HHrr?aMyYu!HS%%A}{1`#jLsgb>cYEVd6&h!x=!^XG z_T{0IWvyrIi+m?eZYyTv=(@>RVEIqQFai|K7GmLzZU+(SX8+=9RonG87W8I!2%TRi;7b7T; zP?cpYUA3KYs0xiUjC_$_AnoKEd`0M;?%g(Ho+8Uo`mh%xRUp19%UJqwJL6Cl8fO^! zBELY|$v60l(EGC1Ecqhedpr4tb_!V<+LrWh-_`PV3RwneXL4CPMH_j~a!(;ch+BFc zDJB^b8H;}@Da(H;Y3rR%=*tGblo1KY3^$D2>g@dGVT{-^$gsEAF*$Pn@>ZQqn4;yw ztQe+yMB{V>ce@oo;ZJKV*?0z+R{LwT(Gs7<(PvINNz4`PNvb|7G1ez23CS~p)uSWT zZI%AjsO_gR(?ARFoLiNr~YvNQWA`%(+PM<6&W9=HqWbHXkC*Ocw)S8Z4$NhxfpOv=rLuKK$r5GT7tYO&fsxN>TwmIyb> zGckE4g&q?S#lnqpa;qz{iZeB_dUAZ+$>jvSli66==^hko=>!k% ztqbvZHfdNkY_=%1cVw!pGKR`y#Zmb;pt-e+-Wpwymxq@9u4JU?NjBG%xA)8LkGS*s zBG>IqU>2nQJF!{U?`;pd15MG_P)6B zKFEXC{MX<4>)eoN8}nboWqYY}5AbPAVC7dqE=B=h~y!?J8>X7NcUZHZnF) z5urS)RzZ^7mdcj?@gbE-6xogA{b_$QvaG4-bN|7~0f}j%u2xa^>hVgg7RO8XaorWT zLpLlH2X)tl)V|x)mh|>#wDBL?kmQswv{IPf~XgT@|5kWDpuUn$*@c_Bc#hT z-7V6N+Ue7Nv=Zf-7d^<#%+Mq0uhs2(MS5?Pk*tI`vsBEer)yTSV`TXn(C4t}M15D8 z5wbi@+7729`Dzm-%UjLu;*_pik(osKNKTI&(=H|QAVD^IX=6)f5s8cjnHF@V1>Mp_ z%}Z8}2P&hLxFp>ktgt;klHP5Ui%vAdUN6yd(Xj1Zb|qNnHm}D0LxxYg7|9i0wtvVL zv{ZyEU7vB?-L`OK>)qpnY?Us8o9Tw^2+p>RE-~&of^n?#TVZtaJ4VLGWsA?C4Dwak z3lvQiHpo`Rl|otdG7@bJv$3KU)=H}uAD5KJyy6lo2sc1O#8xS~wK<-S2Y#M`@MJ8Mk^dh-$etusWX zFv&zy;>bl;CM7b0yP2fRhfGELM*`MJi9Vc{q=&|_O0hqFcr5<>Jo`grI$p~*+33m> zmz;mWiiL48C(&j8R~?j%WL8tbOx2yA%fC7c_8+Q8Z&Q1p>|Jw{GBL4P#9&!>|I6&7 zwsdsch?Z}Qe9+`s&6Hux#{E>Wq;+m$d&#Iy24zIBzLb%iNtYiG|x4w@Rk*gX?6lt&BU7Yp`pz+qOxZv+H+{ zlw~)gd#0R9zg?X1(bclQTDDimck(VxO2!u^-I~WvNp7r5w}{z8We+=(*gAo4i7TUp zzr7%dZN9U0mO!>n9C~9w+Fz#1+-0i5%GP;$QxODD@Y_28;X5NbT1V}lDiht8C;SAJn?kwE&qFIQOlCv^|WJrea&0C6@2)5wyBdvMA$Gc}(XW zUJ66<7D<+TyKE;86!u!xTF-@?nw`IHEf$yKqxznORjAvo8q1>ou3K1>v^91V&n>2| zy>_x+^~oeKk}w4fu`9x)(X=dsCaGEbIYI<$N=Jy$qPkMvxslEFl7qTM=)&MKp=+A`Ft zj#s$)c2p`8vgk42k$bb2M`x~i0x*#gv>@k+H?c8kVQyg-t) zJ6%Q}QD=zk{L)f8t+e!tTA4F-8<)gMvgGF89f$-wlGh1rJe2|HO4%`A(QWR23$d=M zW3pa-m+q9?iV>MJcbMvTB~3Ef*Ktb)GHm z&K7rNiUJ;c4B;>QYPRx7UO#l_z{E^lg#?`F_9aXc)>(pCvmGaEkRcv9*t z^7^c-@GD69nTc?YdMdS#r zZ$+eUXheVONm!GXhC4PWO(M~_%NOlJ?<;l0a4(1M9Fc2boIhq9DW#jI`i)8#bw{!+ z?Or#nlhSb$S}hSb$ylxT{&Aw2BAG^pvD`cv(ZH}wuye%$eWS(wB`Ks|cU?MQ>+>>{ zxcbR@Pj;zX9GqTS_Q0^jlhFQP-0)_H47wZi0Zp9s^js{Aq_m~7p|Z=f(9veMd%mH< z+JL?#q|ZrWkz8(Es)@kfdiKlTJxcMM`nnBAQuf43dg3bSEdw&mQD?fAzC~ZU^{@C_ zDr+ZYzV^u69nl`$$Y_qHn$Qy5cZv9HvKII}HsbOKSBuge` zG*6^G^1^AdhdGYyRaT}xU0IotG>_Q|c|PE!5U1Kx3#8I}C#!)ZDxL_rI;y~45m*}>x1X6$!e<#-NPSW)RIeC&C5z9xHTH6RHGHxaP}K0a7`oC z(Z~L@y9AfTmh}adGVrA%Tgik{uV_L=boyzjo_{FAh4k4dUr5qrn%rB(Z6HHr&fVG} zD=8_rJ+(+6gQAq9^?*cXv$(X>bs^VRyqNA4<#bFv!?euZ4+Pen;}!C%Be#O_Ny*GP zN~2G16#W~+I1b}o6wj-Ml*lFEN;0L8RI3|V8qCOen$`$L_ zDrSZnNTb~ATwiVn2IU3Uifo98j8Mx*0NN{q-m%jjxzt>NhyCLSs_oHjXktu%>11u# z7bo}PeR83cc!}V$v|xjaVE-piKFFk79q8O=hlOMAkLX18VO~@u_8>uKTrw|9ibB__ zqZr#L z=yU#U*OkZR531nB9&{PlrN@$%TjA)b(WY_PbEQQX|Dm@k?pqAHE6Mg1*g&hXB=_x= zv8DLu`wtnGtxD@Q?#_GZ=+qd+yQZ?s{pl5OBnpbyghlDpy0NJ^J|R|;lX%t8jrgwI zGeq12%DQ0^jg3u_M9)e;w-LliN!%c61(Td!P+q>6T6Z@;y1b^BB$q*MH`iB22iHtW z$1u6~ZHw}heivwDq8L3zjutAzh7w1UhfMNak$5@NC1Qi5YzD%A+!v$Oh%A*%9QkSk zOBPv?`3e2FHx3WP-#_i;ah z%xXua_~gQ_3%b;&OahH4xZ-esEm_2MMQqO$SqIkUoD$GWH&^7bW_i`_WVDZqD!4~l zwR^KnUo-={8W6W_T@m)0x?#|lWaC(_XrH>!zkJm5;^ zb#rC0wtGi3YONcel%0Ko(VrKYCdXzu{7yAwq-I_ zSV?b}4^|B?t;z;IIS<))Se7tqG^285lEK}5FpY_0)w)mEF4MX!`*?Pl>7iANj~?By zr5!fTm7RqR5V6kgD|N~yQ_2>dKM6~jq~emQtS8Iv%P`$wr8>@y%^K5jiHc8KyIe{CT z4)+UK(dV$Pl|DH%Dxz+J)aM!K{mO`YQO(_b$R0+y%^Z~v9EIH# ztt?_@X=HI$cA|_8P3m^8CQ49N1Y zPmU5_m}LsRDP&@hDa4ChqNMYu;--bfjkc60u~Aqqqi;GT>UQ$LOt;pgO+p#{Js7~^ zRud_+M!>ii_S9NN$5`hk0`1kk{W2qNua+s`)XE1~;w)!~ zWUeL?JDXYRXI$dAzCyp^5-URY^6`~egL_}(d+BYb&@Z^ePD1zc;gwi}dtVf|Z>P|& zx5Q3D_wvz|Sc7|C6u57v&@Z>dPUKcP-cFQA-Q$N0IZp*LG%{z8b_r)_)60YzQ8>>m zP4LQll1a(B?i0(f2yVj?gZQGAi0p*)5|zm08Y(ji8Q2q%n-!!_VtYz&>zSvw^ks-4iUznav$_lg_gI=vH1Xk=_ek;SkPc|k*qIJm`; z4ph~lL}r9;QP-_bMKE3-(hsScncihsal4n4)RWy5rG(l_QX;SFEUEDT9X(b zvZ=ppoRvilfn=(0_gFn++vSOLprDbr*F^h;GGh2s3g=d?#`?L>Ac2-EG#j;YMK^WO zQjt+HSCor+{5PYL+a;~rr-`6-7s|X7bc3s&vRnCxUmmqV*W}U&TIBI9#44FZ>j#Hc z%X)=NFM3YYqVT8tI**sw$!uMx>dsu2OXSPQvM%l@Z6j;4T1&E=Td@e7Nw65T)1D#q z+v40dnG3b}Y7+%-3{>vRPCAvcjM&Ut+DcNOI^XZJNvs^iDOT}^zE?f5OaZXwmZ`_kb3wZ^kU!uw9u;slnTY23s z-P7*qa^dv$w{d&V_w~g}untVk&iJn{~ zG=>{ShUL9P&9yE4xj$V;lBa&X8d0bno$_zw445{rQb*;AbPE|-Iy=!wMPf9X+4bFXr zJYFBql*X^j5m#K>m>k-==c0kg9+e`JGm;KHSlIz5S&^4m0<-S4peqs3S)$1dGaOFX zZ^zPBUHJsx)_2z@G>8rFDk*V2;)W~yBsxg z^ppW~BdM*MAQ8vWUotb0(&CvQLRX`9L(}ix!ijF1;)cr-|=S$#M2@LaT41=91PJr^o4Y$*x{JmUK4B-kZlA- zdAJj8mWVSLq%z>%EzV5l2&zH-MtR~mnq}%IG4z6=FR|$dGh`AlF(H4%?p?E&i=HlZ zxDi`Mo@%)kODI}d_>1Bo@p^Gum0rn6>us=%rQvWFi=+1qJpp$Ep2P+jPoVYaza0^m z@eviC1DjlW0`Fcub{14vaGiBe>D&kP!xqvuQe42yC!)KoI4v2v{l`}=dOfig+vq|+ zCY5S`cWu(Yt!K%j0bOm)74OU6i z<7#=|!B}VAQKPe0VbTwxjCH8ru2W_mK*YDZMB96r+JxlAh&GpTFOC}$#g^p>XJ;38 zH+&gW#uCk%9y7FTWy{8e>}dFK_e)U>S5(pJek62z?&G8r@1_@pmYqWKF{7pO=+KFz z4JG=xMTm?Fk2X%kzPP5r-ae2Cb|guOUU%K7lz1>-+cGktvUq@oDYv+_r@!mqhCRD& zOIrI8Bc(n1o0KxWwT+PFsjY`Vfu+sfwz~I~x<^HIIBn0- zsM8(oSkVtWtsIj*AHfETN~T!fEbtW4-2Inr@RCSniavypp-vYd14%bD&PzF6fi@y> zX_JxlGLP1r>g0d*$hcf~GYGXw{oXE$k!V#A|;l?8;%du`%9PgK(B1(n^?aZxOI$AOVtI2(gnxT+hV-vPeyfNCC9*Wyc z_EM2-G|Y0FWFs_j3&N77ym^>qCK@+VWa&K9wsDdLnXtH`aogW{s~xU9=#@}BKx+YS zvkzI-Y&|dZb|hVN#ZG32#j4&j%iWk;8I0>ANG-}=94VT4`U7{YY(MnI-rJ40aRe*j zzEq~Xf=#Pzb#ArX<$HYn5tFIlwA`C3ZsjB_Kwq9^Hzcn^#ziu@%@$um z7j2^8O)@9#-Hp%j8M}Mg7O8x(kC|bMN}TAOwN3gH?b<2*nqcVL($m?0i#%}A8Y9Y; z%xFT>AY(1sB*83IOPWa}TMpgkb`;5uEUC!k(xjAC9XjilCF5jKUf$LmogCCg;LVNN z$Fek~Aayj3X3sV@Tk^7GCsSS3#Xqy?h}o6<1dP51%rg#N{4|L?=Lpz61?h8(c1Z*e zojzLOj$?!Zrt9(h$8oXn6*w<1(k`@8V@CnU4@0h!$8i=VdJ5u82p6S7oTFLP%q)pH*7L~>`pJtkvMjwHqqDJ zYVPf0_w#s}@iKiUG2;_5KYFjl97QG)&UJLsa+Z-m-@v>?-g+38pGI9%-YGA7M{8kn zaZ{imWS%rOA>WJ*i$_AxygHFNZPclfhWBr zB~IQ?kUKGb>0Dw)FDb+l-B>4&z;v%%QTDI-?)2JFv(@Pd?n_21;=~Op`jk!AzQ;sB zpEt#77bC(Yi(TSl@ibXFR=xp2>qkg;r`;pur9XAX8vfbal>7*xGDF0vK}tlXtgui zE9Q&jS+)K|polnKH*mN&j(hCUPOOnEWXc(r($RHpB=`Nn*7|guWFix5q-{j6#midn zfUG~c`7&?Hdm@{CyRC;BN9<&SVy|7s)Wj!kaI(eE(|X(UVyPxAH*oTWS$n%CR>br5 z7P%zC+sH1Po>yNSc=Z)}_rn(|+zmBnUbD85R7$*^MjMX2J|~Y2qc;=ds4~3DBvh94 z`{Y-5;!2AbU9jj74y&>mnRCAraTEH zW}gB{BKl(ad4V>byAuVTJ&Et4jaa_Z-^O!SqQJ8!@jbT@%Lnhg|;H0v>p3Hp0qmw)g&8D^Wc}T{ycy-YTHWSMPez1xXI>{*o%#WnR@S~Cflp4MsE4lt|5`o ztt)Tf&9z7<9m?j4X$3VVdRr&<4BTZv>SUr{mWAYY!0xVeZAYdp0pTRM3v#!nZn@lU zzs)Fa9r7hvyQK}}8KT5vhSE))yqn;_S&O_+ZhqZ`%H{tNb1XMufj|9Ff#o5sk)q31 z*woGzTT|Y$4bo?uPD%6NomW~d899PBU0P}DBbiFN?tVA6@%ze7Hfm{WE^d=uN6~k< zY|0$B(rB}0W&E0c891WLgsqmoIK-_l5`mnLy9m4})Cr2lHBS4}McNuh5{x3HG%tQp zEZ9ncNTQ_l8G>0ltu{t&G1P2M5*)2#VA8+F^N#nd~y49j-f=nVMqj-O=s85>{YIrDSm zN6{I1TV4368s9AVT8*z@h9B*<_f_Gm_r4}Nx$VBt&lM|j-XoDmi0P{{CW2{o%RJAI z5an(#5GL;vY_U7g?lni&cRhlBndzlp*jMspiP3dC3)l8-xnlELk zv72e?_KFO>dloJCkF_J{GtAtbSdfsM^xCnVfk=A!2K_;SK-ek?eoi2WE1O(HWBCkQ zWnA{`UKf9=Fo^F4VK*xX#BR3IDwZ6_qeBp19%k&Uj85vS@7WRDV`ZDam&XIs=nYT1 z0tKp7BNOtZA`rPb0@lTU|@1bAa0eooW8hH3FEms&=t1Pz+6XV z*_9)^1w(nJ&}G5R3Dc@_rxi1kSsL>;+49TqSM_#YSYN&fo!vU)bHrR7PIIsgXZESU{}K{Pkc z1rqa@j6Q)Ee!*l1HwVg((ECQo7hxN-j-sojgY# zv{Tq5p9Z;N^9Gyo=yc{1`FryQ{l7$HFQ~q&u%@?1?yNU$UK>x2yy>uHPoG_NuZfi+ zVU`&RHCm>^-NSitqnr5hptx#PR(ER(JnHn!vZaBu3@g2P6-$@7OrLEuf!}l-x6H5e z1kIkT>_>m>=LaOb!B{Xa7)Er^HUi!)7DbW0>6IYYn-_76)1fDQ%c&3cuU2VxaY66 zq?aYtkd$;N^h(-O_$BR$qmuSS!AZE14wOMjdm7CS4b_td&NB5aCGAosGGcETwJIkx|38ic_SXG(w zUD)VttBA4;THD!Hc_iIspkf6kSxOa{b+tE3sRFZQ?afju=`D6I z#yUw*V50Oh+9rx?6(eawC$%ryOomF|rPR?8lqsEL$MYK6iOv#>XMQbu&NG^mwdi?l z(IV%mPmA0wS@L0l^x6C87#jMT<(GvzaQn4oOOrNz*$O%Mb{B5QaUV_ z9l;`{^M+vCB^EsqsBI6*&=v0A8d)lzN|HN_xB-L?TN_A=9v_;c(e_?A=N4N4`39V5(DDh?^6q(NP$bbfAAsvx`FVRq4_q(MR{ou5!j6(rP^nNUg^B$U$m z38hpdv@A>_aF){f&QhxE#x@wV-Xu;~Z7s3QX1!&XI7G-(sBWYVfI zwdHAbR4!?GXx5!pW7Z-M&AQr{wa7!WWo^t_q9|a%X)?xieS)L9@zLJT&M|*y4xCsn!u>5tx>26 zjFz=EYOmq9VEnRhud}=LI$!EdvbaBVKeggV@e72T0AC&bqJl5;e%Qbl%c`a|1z)I- zKwG7K@=XAF(jpH#?6J3Rp|`8D>#tRj3`BZa)F)KFnKf(q+H#gsb741*Sz0x9pD18_ z@!iHBY4wHjpeOo%Uv-t26_&dtdAiCHfkXeD$!cnr{pGdOXJS*%4pqp8Q3x z(YMz`FVVNg(1$)p)&@55nC@pHXzI(e;&%taAbzOAe^>kXp^Es++Q$!7(hB$%lYast z^(#p}!j#fd2X?RM>)I;BrFVPjoAlJ$DB6f^JZ+;)f9c0hNQ>D$MogZ3Z};^XPsRg1 z=jPv$EzgROn!g57qV^I9gZd9$`U6#{!Bcm8Poc{96l$V2*4|TBpz=M1nyB>!(Sx&F z7N~qrp+;8M+?UXFT$GQ2xL>l+$HabpwT|aR%&fWB^&+RTgCw`O@zvFV{+Rc4En=UIZQ)QH1Amq7aY@wMMDp%w~eB--GVR>Sj ztxfw#67Wm|Ve}!D>hAL;O4{C~5}%-c`dwp1+0WKKf{*RhBe*c7_08;IUA8<(F|Qww=vZ{qZx%Qmf9tE9i;A>UR_1R5<6BrkC4CmVR5WlM!WT8kwr z!R5v7q%;Cyx)35|cb0_{wzF84W#NQr3#|_Kaen!gx9$3Y!HMFv`tzJ!Ngn^kD3t+u zyI6nfC3ax%M~sYChQwPs;ppU+7rmqcVLOZNEDI-WXR$2H!U?U_^vee?#=9jSmg5x4 z57rDP%E?jLx1s1a=m}orWPqr+UzCv7UAH+q`Q+uOeEO<<&C&sRyK(6e3u9U0I4KMf zwmY@%VupniwzKHUvT(w77R$0MoY2Zke!su${%SEQ>&>y`+|Y<9=CZXHJjPmYvttnNN;o=U?#LWzTu;bGt9d z=bzKLOcbV;_~$QQp3irmf5EczUG&ni2 zU*l2ozr6gD%#u;56ap*7dQ_z!=qw|Vf&OZ%x=^wE_xxng?&fiR*#jabB zt6pjO19Ojy{va$C2lb_(_$U_FtlY9P##|@oz68;{_)F(0iLLn=klVoi0sRHCU9zTB zEN)oi>!Y&FQ{aoQGJo}3a=B#|(La6hS03i8VNRPq->Day(bk0)uDCkP-*LIzuxaf7 zr%TYGe;$9VG^7(;SuYk`cxx`Fr@i=fxm-aiRP1uS@=p(~8vWNL|GMR0x(r41h{qM{ zZ~MjT*5+?}v?ji2$rT-o9{*%DT6E(5iyr@I{p;#4Z(q9Tl$-U>-1cdW|L~%7{!#w@ z^Y%p-KJ)&L+rEEDRabv`(J4}*s$Y54$}9WU-}KOm+y1=h?6q?%Z~N=Y`+wcB^0xn5 zdH-(~zwY@O+nIb(8@T)H;YA%!{@LY{>Q%Fgu6odk7Jc&1i$3|sm5V<4y*0P}uSu?Y zP*OcX3Lz))UEUsE^s@WqZzo%H)wf0c@)-Ox64NCz<)qeyp|kUVH7e zpXVIqVG|;i1g`{-!$x8EZeY+pFMpKbS2CYD{$&Pur|?8zCR6`XyqV9!%sr@Dip)(pGFeXDySYF5=J>&so>9zSlZ<*&C2wtK8KZtD}b z^|{wt$C~q6wXC_9scVWu+qyaIHZEDqpG`W#%@EZk-t9Wuek~_E@vK|i#qJ3@1M&2! zFWJ-=f3&U6oGxWn1FKl4o9#uy;;_@pmcqvM6G;s=!%Bh7u*0;x%|`Z4qj<+*540ZS zO>QImz+t2KLnC|tVWVijk^MOU-@+4zjT>5wo8K`8oiKj#W7hSc?Q_el&k)pt`gjA; zb{RLHeKV>Nm+u?d$XfAhhmD>EsM6PQ{VK1wBl=ogcz599FfIab8rev=Sa~)ebrhm_ z4P(567>&4?c>uyKMEsr;4w{j&`j^-WbO93u8R2aXbVBV8p0GwsqhFpQcrx91WHln& z4O3UN+d7hu_GoQ)S0C(Sy;>b}y-bd7>orB`u?`q3nvE5o7%N`&So@Tp*E;eKn!x-Q zPqwH}KLh-&9l-{tS>2HCw?5C$p$fP%_VU-aH$&&o+TrWcU^;iGpjs7FtAlv$d8=7@ zy>&vz4z6+L58o45BCeWbWnp@DF~*q-4rU=cFfI_vLLc&EJg!# zk&K+9i;pIY_FD^SP)d*n%dZ54cHxRJss|a=qEeDZ{K7iwxZ5b+iY7$d5pOfdZxOzQ z2hnCeKtZ3@g1hyfW@xt&8UPhCvKi+f^t}o3K1GI>Q+P)9ad@AA_s1y3QF<#Gde}ga z>6{Ur2^$by(jc?EeQIeX)(pBLKY0>wTs&J{u3};oKD2fT3tN~jq*q3^&Lt6ck zn^r@hhq<7JDktVdMN#(4$VS7wweP?mK(yJbk&&~%#mhmj&h3qYWL^LV5bariW8X$; z`*zm8ndyoObyXza!m~fQRuOon|oV zLbl$<_n;X(_6?)r5NZmh82!vXXhqSxM)o>ztx=UxM9Ufl?;3pHfhKJLZUj=ZP>{l7 zxTdwHDSm_GJK+%hK~CV&fRF|fLa8?y*>4ixGO|@I8rjDX9p6Imx;B8sf+sTomf?ahU_v{BcF zCw2{F2Yblg8MdS6ozx%L!hMi1ZQ(^gn7*Flpg%B&$^?#U&Zp^v3Cs_+KyRXu4bvHh zYy%@hSV{~BVf?m$Tlb%iQQ;A7JY1RcmAe@Iv$i&92Ho$1pOQU2X&K?Uh^9ysgmJD_ zbVZi?dQG$j*sq?;*~l6{Lqvhhu zRwrgziMa9cEQdg@zI!nH!o20>0m!#Xgfp_#Vq)N1h>@R~mMwEzpSr6*$g-NM54bFE z9kGw)-NY#v+tccXPR4lHVppa`#sv+=P5X?TDdozRPTY9dn6L{~G68B-3~hpz-YGx6J<$8H|NL!oB6F`OGoOQH0{rKo@3?Q0|^GM?m!M19f!DfZVFP z!qbmd&8Bo~=2)y(itmb0KTu*P6*I4l`z8@GXCe(S16@g72>phS4p|#6n zeXN9>GBNA$q!g1!|6)Z?`JlqS%%qVyh4?Z19ZmTbRSQG(^VtRE@PKV8^e)5223)jC zkD|}|^68>F3YmCO=EGOVO<{);P7zqgX0lSyLT?r8M5WrZgQ;TF+hT;qz-}DzKJGLs zevIliR+K$~s(jK|QBY^B@Y^%iqy>Thm3l179O?eoMESMV;hMaEE#WUwhnS`(lwK)n zVl|>LX+a>xEOQMhZm(#dvMg_uOB2-xv7AKn)u*kw`fOB^xmv7x*@>_Y33J8nmQDQD z%vTY$mBA`vgM1nOG+2u%;T6h}Fj#+r+itqu|3k-2wpB%%cUXla*{Q@L1`Ns(7?ZLn zF5aPa@mNPa)=7``w#RBztSK!$U{6}Nx=LrnyIoRO%?(*>)y|_T7;~&g|D@V?6rBi) ztW2nw$V4Af)h20aY_9H`zu(rXoGP_=3x!yvg+2!Ij$|~r1`TvB#>;JTA}XWHBPkSR zUeQ6mDs8>g6<=*?r$5YgTbnG5a(a4Sv;y0)=4I6@HLD@2ei6ui5ldrkYcrO^vfS1d zbQdnJoTx<;l@fa)wFU-GQQalcQb8ErT=X7mEbmHVg}27?)&T0z-vTzVyItX}x4iXK z34B|q5sBJCe#2!e!-1M`L0wo36$ODRb@{a#geTNndp*_>kM)_oP?N}tt9y5>wn9S^ zT>~f!UbJ-ve01NSd9`Nbj!fvPivs;A%B&ulRHLWk<6iLjt*Tpn%lPp~)T~_=0I~JoTwM}UDTrgG(RA}q3v8^XsP<#OrYn9SswEQt*LfaMzU_J=>=k87j zbZS++Jg)Aaj%Y_V81d-#1WitsjVCfk$pUo@wndpMK^#|a3gc9S3yxD39_#Sz3R@0+ zlH}0Z-t|F|k!?T6GEk7fcI&v?dIS0fwR>GJqib1YKzMP@Q!QKy&UIHQI9AW8aiUmi zAQLXDNi{XdI}MhtPf7CGd1V{<6nRn1LdGv*4huyITMOs6piC0ZDX8L-F@8KXNlTKY z(`tR1`q5GOK ze0l;VbeITp(L)Wm_Y7;@NkY4()O#?R#)x|1-N>ntGqapZyM6wAq?EY~6zD#&nq8Q= zL|rF(&nK0;XIWIl;VRR)or#Hs;)VRP?{iI|Qg**bvr6t?p{Y0c^r$7U08L4Hwr)yU*L zOdVAAWVjkT2Wu4&$tzevF|zlnE>neLs4*?cuG{OKsrG%r!6#srq{%*LH(Aw^ZpK;& zO1ruiP4<8>9;>6Sp$`pZlU--rwDuHD7E6f}KhaHgb5fK20q9c4wbD@8au+9B>wQQh z^FlSh(1(ojD$ zg14b9daa}E+`M{F@706)L`To2C*4>3BW0GLRB5XM>ZZu{dux zcFFVv=syQuc9X=Kiyo20Yr_jhY8u{?S4Ek3f@OkTXe`RE&Bww#C5A8HDAg&JK(8L4 zwNQkqNn`JXyyMj`GZ4gOI;nA0D>{N!)W%Xm2s+!(VKKXH)zRdg&IGjAj*+yVGD+U` zj-8_?61v6iNouhRYSfT5_53%52B~rtBRdxfE#u&6C@csKo8pUs;hOlX|9ZR>k+J!}U-J_zea~C zlM1X}897tX=T50=+zD1FY~M1RO@WqZe{P)@$e9G}++cwW#|SVh>D`D6bf>*PHf|oe zQBh#+mTS4(dqD?We9XvxkIn}C6z=0*1lII+Ab~xwc32pJGsn;Ffn2ysj@8;iY=~nK z9#lgZt+wcJsza%S^E zIlt_hn}JgfqVOp!Q?l04{x2j(F{)UpAA2!oK}{tJ96vCj_uIcnzrVP>c&yDHYlFwq z#x8kJGqr!j`m_~*(&KautRbg9pJU>O`5#XZK_S%24@Ym9kuSD*Rz**aT=pEj#;TKP zI}nkgr_`Pw3~FC{Ui)e*yJ#fbXZ7ov52M!9ISS0gwuiqCwNmGfs<`hCAt9~xK&`D| z9JjI4dLwDI;H!?=pn4b&#uLH%g+3Uc~q~+iK0>iyllgj7l z$dJph1H|s+Geu|zSbM{PdKES7-)?)Ja>Iw^;n}BqxtZU4r!i>jyiA@P7+?(AIJXDQ z+<#uGO#Q2|p2nb^bGy;&7ustp3~mFc8uVT=CUu1|*j1=t;oGpQ>@i?8(7_bqTl^-* zJLpnDz&@u?ZRY6SjH+bqRi&bxp{KXXg*s38`Wxu$U+h9$Bqx!gt^`@RB8!r&L3~l@ zd$9|h+#|Nyk6LhW2Sf_tW6Ya!T!BkC#-Peo}3pt%mJHXdH2JbLdl2Gtl3 zS1HE?>`ZbLjGe`zCVYoJz{q5<&IoQigLU>H7w){)N9b2@ob4dj?t(4p7!C)}r#{;s zJf(}Owk$x$O6B{GnKi5~hG*(#WIl&(3kAdpPg z)m@Ejl@9Wk8OvcR91g1mMC@Z(*pg8DSQvG<&fcQJZ>>lE3LZDIu|HdgP2Aqx-+e`r zR+EL|b!s=Ra5K7FhZ=dY;&l$W!CQ>2+@2ip_Vho8A1p!YUX~s&Vn?3+0R5x*DX4*d zl;dIom!1lq;m@Xat*0mK#r|2e`anOAGrG0e3Kc6hF7M;WA6bP8;gP!=Hg7GyNAP_E zUoeT9;+>>{Fa{d%j^XnsNxKai+#nyFf zOaM|P4Azk-8{uZ&bBQ&Gb)~ za!OG&I;FhtdEq2HC~6)^wt_2 zALeR4I@zzX*IEu6OCx6+-L_@uSTjWLMOK_`q_Fx54Gi;Pn$q^Teu>7D;1(~gnzW{D z@g&ViI%dbfHLoLi?5Ge=S>mrQM<}TOnUuQua#Cb@6TH3_8S)IvX*1VR@hKhTP$H$A zUtM<4!8TmKob;&CiNby@(hK$fS~ZZ|5;??`G6`QvhF@5}9kY|IZOqpqz4pykO67K3 z`@Uwm$x!mNO{1ftYhzhd6R}q)5{H^ccedPeEKqFhl1#3;3tdB8Ow}VOvL8Bnsh824`y6UY}T8J zC@0Qx(hoOlaJbF|N2BmvIG?7WQIv(4;PhO0n~wGLG@=J<^GIqR*kan>^XVBnQ1#xr zA_~Qe0=x>w_~4+0U6olSMbT5V5GsQ`zWmG~)m1V3DD?>PZOr=I>Nc!iNv&$7k% zDZmJ)XW0_`OyMjD%PcsEDibJm`67SSq-jcxy2LOVlO_CwXnTPRhiHrp6Zc4Q=V^S} zqcLQP+XplT4c+ri=+aNl#uTXCnOAPqv_c1zDy%r1ye$&@w!PnEh9iuij?7zirX{Xp zm|69}k%6G9Wyky-W>_(Tf>f-POoym*%0qG=qV}1Q?#;**{4*A?gw(+BBBd)_-;R&N zF=khanPQJ@i=41a?cG@i-ij@-d(*j0E50j&EznRs%7fW2mIW6s!zC17HKq98pyXRk znj*}y$_JQz`4M7-?F}tUC#`m1R4Ul1-;ZjCNvVqfp>sK}vE-5+C%8_8wv_(t*` zNjoypIi@Y)=J3BDla88Yk@~+P6E%0+h1pu;6#QtDQM?XjffLVSxqnn|9=xvXL?QNA zdhbR4cX2goBNmfhm$jtEt(ZzA_61c-P-=jqRVqtK&EeDVB34}NLY$vMdtkIgd(bYn zhjYO(xjirhT9arGtX}0|w+HGz+QWf9N$r7+#uI*4H;6n3dwPA6PoED4z1^<5_fm98 z^Fyc;s||I=`L}9rxaNjr!q6ueB$Pro)S}Ea=Oj(}I>O8yT#M6ow8M@2kuXjrq5XQ9 z;gen-Y)%|N{89@gvg7EAj7JJzwH2b^G|?{q<0+gVoUgJD0#onuKbgWY#bR}=HLy~2 zZ{~`yH&gs%koQ$($nFsQBkTuHozH|tg+NYu&ocOU(WSZkPo;4BiZVpk_%#glz$B#l zc$9U9UDmHhhTfIT;fpC{PO0S%OHT$At_TMdDg3^g3`2KIEtj_Do088CYoj_c<$q4) z@N1GGOtdR;=Jd<Nak)jAw;Gi<^{GJ}s|2P&0c zO5QrA8ps>A8s&v$U|8qY6K^?|V}Z&XNr?nPqk(oQ8LBvGZLisb7> zG1Y0ux zfmx-)@b7KkFsOMykHzum1K`7}z@cKsk; ziATDgwh~hd+(y_%nJYlwabd;BVK}rfEUEu(Eg!bGFKS^ppRylyt~TBi4RbN_*!^Nv zs9T{DuFSsbTHWfw6^5crS0cwndO(Nz#hE#@?Dlu!(OkVyVDGZltuwI&{&lp^c$M7Q zC8P6d4G&qm^&r5^k(quMW)4DGVnWNOBQ}_+tQ7TNH~Kv8wa#D&FjhoS`g^I*~kJ4 zrXE&<^Y}%0+D9>(|E-@O&xedbO>>_)Qa`{M`_J6y0Oy1?Odrcztdbpb&*wS5K^x}w zHdb$SV#Vv6txjY08g&(QUQlPphj?6>$Dz%9T7o`r`!<+k@%)x|j9X6VGhOc)*;lnN z&UjowZiS6Z^r*a4&x$4xg==cZo6R zlV#317eQ0zoR456QuGcG)vPutYJkuj>P!6mGxi`hunM>Gr-46^L+@>l3;TDF%#w(ilH*71qp2g~j=SWw@R@Og*V$b#pp4FpTm0^j^>bqu_JnrW3}X z=>1TbiFIyc(C5a(pJ2S@F$Ogn55KRj#%Im~2l!-umz=IbZmW^l>T2++Gsfe@HR}j> zVil}5ZmRYggVx`l36F_8!EUYb@Y9-I%y{@Wn%&U;n%&TMFtVF_1=!V)T@Bf}jqw}c zv5gG3#~Ho@hF)Xhb}+1+SBMlon|Gtf7~l5|F!-wzIqUmxxLW3%n`dNCX(B&ihubC^ zB!_W+#-MjpY2Q@bx+?nPpv_>Ds#tGSTm=JVhFXjYKEMP*?D-x3Jd}}aBE;UHt>bw> zP@FpcY(>u1!=zA0s7O==kEHirjVe08DpH5eKS0rn-UM9?VVCTM0$qT-8{-eMB2g$j zQ)K)gvu*xoU$%0n-WZqnZb?Tg}| zU4t^MNDx-GB5G9ZMU~_YKQv|YA%wA+nbh2P|&h+yvCntc}Tdx~WlgZ9ksVq~l3`%Nyy#wo+z|HPB< z06XV)$K6e{&jMk$SJGl<7=w1r?nK9CEPK@CO<3b_l;bw`s2k-4<^kz;M77(INBr}j zF1bqlldkg+_T1=KHf=)Kb5|qY%Q{Z^%e#&BDs1RykBO@=>&(62_KQ~&3x5gBnxYNl|e!4G~tRDI*Ux#DJXpt|Hc^KEJ zZqD+Pzn$Su{jmH>2FiPY4kSs+2lsBM54INhX%mhoD5}q25Hi`B-X`3B80|xdwY4y_ zO?WvP4nKF|+a7(BgdbF~+NR$CW5UlSeB0x{47Qh_$H1pO{&^ypAL(dq^0!RFF9*HT z;cOG$grPP+pPzz%6Q;QQ@H|0#`K!X@ou3OdwBa9>aBTAP(Ov?|F*wNfQ3zDeAAkG>lWx=Sev3j^(FK`sEV-?Ni8q*|#*|spy*|{3nRk zo_xx2N|>Mh__n8?cW0|$$L-L=_UIdEsqk5QituG_9Uex>+HF6hb@)<1d*MwI&eezZ z(qHD)^w*w3J`Pid_df-F|9l<(_fya}{6L3)M+3N|eq287mS)f@JTo50GAGF6E1Rb zIPbsF;k?)7bam^T#V4{-t#sWg1roize2zrCEQu#(yiL6`ecoSg^RxTwI6r@CeKP*zh+n>3r_X*(ee80z z6Tb#=mOZcIv!DB-_@5xY>+d>#yhWXc{{Tq5LE^I?{38D25x@Qg&7b|^7sanY{AK^p z@!3y)QT*o+XYk89KKsp-_+wM$NxkE|blGYhU;5ED^~8AHGN4ZqPx`}l;|)PPn;-jC z^|9rbr0>OuXRg)ho{nDy;^j#^=_lKyOTBmo@d_m#``eUsTj|9B1is1mwL1ON@y)G}3=;cXp{{djxvn0_}H^=bQcJhhv^h^Md89L1DoH4;@@6858~PUWSr1$x-$?jE2i^Tej0v{BihlAgKN(N78*d2WE&EW%lW|3xc)!KC17_#!`+%52 z4cv%v3f%?}Re5%%xNEN0?iYa!4~ToFxGxoVKXE^f@et{M3S|6OFn%Kb5lH{_K8@#V z9JmhSLrnSyz6`_y!N9))^MDZ`CddOTfVmDw-}``g{6*h;1gD7q55;|>;I%-~UkDrm z>!W{%?tU9guu}3nbkyB|I$QLBV2w3KJPyHTjHBuQ0dNH3{T+y>gAH5?q7>20Fv)EAo>0mkbIv7lJ8<5 z%l9iF%kc=1D&WkI@5rRHv!1}-5{7R{@)k(_kg792P9o@2|q)^(*=)uG{1vD@_R?{ zO(5wv07+jBWV$OP{4avP6aQa{`!OKt9s-hXu7uwy;S&XK7JoO8a^XXXDUXYQ)Z1@L zc*AHdhuuK(-7HuwxJ>Z(fXDcAl$@;eL2e0Bx0d@WaNIUE*@ z0qNf$?j1nVZ3L2THIU)Y11Z0yg1;C4C&XPPSP3NkJRs@s0+PN2Ncvj@uNQxhxJLp> z_Z=YVz6B)RH-V%x1UrlW3AZl)`#_ez0m$<229oYSfOz=Szy&~zp{}|gNV(hzWIB8o z6!9t`<#-m5^xc4r*IB}w5sCTv2uQx~0GXd1g7xCRR@|$A_#gNe{E+TxAnAS$B;C&i ze~WDRT6%= zgnvu$eDOaE$a21qAJVM`vcFvgOhdo3Nc;ohKSTVBf%qRd1V8DB_cs^~+Ks31a}lrz zNPYu=%*Qu@%)bjr`D6&57_R+42GYL~NV;c%%*PTS^HB*TpND|tQwn7K8G@6GCD~`#`35x!@(@-%s4<07=&cNIJgAkNNx*M5Oyba37HVuZw%L;5s1b zmjg-v43P2uL&E<}Fe3gx7We%?(&2@$itbhkA1C2s1V@Sg5TMd8AnDEmGQF-6-hxDN z+4rzu49I*mhHa9VNc?{;?w<<&7)birK+;bK;=k{$_#ypG zg4c@wC~;o_BwY@Wbp0j#Yzglo=oJ4WgLOII1(NPHAn7&%5v6Z6km)TKd{+E_C+=SZ zNoN5`S1#cJ37;uAS^RGj_jQ8T07?H{An7jwGTnX>evaT7;_nc5^LI4eKY^rs6G*zP zK<0O?;41O|FCgplcR;517?5;7k?;qAq?;vpyZ9H2dpwYIZXoG~N%%kszgX}a;@?Bu zodi$f@oS|25J>ue0-4`kK&HD*aGm)7L)?D@lJ56F(*0V(ACvH)-~-}+H<0Bl0$vOp z4kZ00K+<0TWV*e9Ot-6Gn)n~Z!X^Db0+MbE5GH2e24EWO;7TC*ECrI!Q$WUlQm{(= zL*gzI3;@Zm07!m5Ao+~~lHd1$_p3 zn}Fm~Be+uhpB4Ahf{TFUR|aIhN`d5eJCOWt1(M%5Ao=}3aFqBD5%*<4^63jCT`vjm zBH^E3qUk>clHdD4%H;_l`_JzHF=QBcF_8UPe<0&6%+dJ?2o?!`AIN_5QgMG%&=7nr zThlEOi~!kR76Pf4R|{Ssc!uEeZ)>{W36=oQNBrvqhYFr4*zhffqaVT_2QuFgAp7A; zAm#A@kn)%fWO;4}QjWI>juU@V+<8FCK+@*{Nk0@w`W(Rv#J@L?bQwSl znFk&lpyl~7koEf>kaBt(NIrK1`@wxF5dQmsf#ouP*}` z{|7+I?+PGPdEn9h>ixt6_W&u!oj~Smg`fo_eFc#8^MK691PRX-%o5zzPse`+$oMOO zd59kr|NF&%CXjrFNO+du=JPdu4UqIN0vYc&K$df=_?v>+K(_Dm#oa?NP4Kn8n$IFZ zFR(k}Uk3a>@M0j#eGZWM{O~-{AE447pwb_~b>jaIasLfSx}N|krv*Uf`wrkJxF-Y2 z=O!TeTqk(7_+KIJ?+AVyNPbQr>G_NY(tiLX{XYeFivMPDuLF|qmq6wt0%ShQf#fp} zNIo-w_`+=1E-Qu1kI9~8V!S}zR>7E3R zMEpu1^LZzb`J5`@H;VsI@xM&``vRG-J$-b(!a(ww2PB^#0?DTU$o#p*e}MRZQ~bM$ z|L5muelG#91l>#^`AqOW3{~93k^wEkK692qgWp;`RW^e^)Qf|1}`PR{+WXuRzj2CH}txl24hq zZv_s4y9mg5SBw8e;(xCAcL$Pg`&pX*a^MiS{|qGE@5TS;K*qZp$b1z^_$a|EfLFl( za&ccMc(&l@XKH@i1j~Tbv$;UZ?;aq_cN>s;dkc{IHx_s~&?7if{By;f10-EnAoHCG zWWEpg)O_9tlFwe?<-j)tH;R8$+$#l_0m<)YK=OM8NPZ6inXkFPT=2OQNPZ=PH;cbd z+#VqLTmdBAAPK)n!p{-JJ609H3?SvZ+okDV1Ty{SflPlfkbHgx%tgA70GWQd;JxBM zQ`}R4O#d1n`M81P^Bo}hd<#fE-vpA+S%RI#|Ae9aKM_0#B)?aHjlS%|41O^vcHGcyPZJl&2}Ku`zw(7_=R8? zNIhI2?t27p6Z8pQB=`n81@;RY@IyX-1|rFUvw_shDM04;I>GM&nV$=RYzK|q^m@xH z!0(}pUI!cm|DT=Va100j5JGlCK-Ts{%{0zJ@ zQ}eq>uq8vM$FmlU|8GFbFASvo?iHLM_$?sicqWi?+>x%+s{xXJ6_Du_0P%nJab%wU zZvx5p4Iue$5L^W$zdr-XZw8R@ZkO;I1xEuJFBiyoA33!?9RM=^ejxe24y1m*0;Ha; z22!tA2=d&T(syzH21vR`fna_1kAbAW56F0T0ZBhq@Q31my|~8+jslX;hk^8u0ZG3LNV=^+(yaqB`~|`P68}E{DUXG~tAIZRs{8{fpL>C9 zZ*zd;;{~1z_xV8b>m~kBM-}dXejsa|8lV@%sNiD3a=}T0d4l}~9fA$e3q>!uSg>4h zl3<=-e?f;}1C&P53oaHc7n~%RC)i)mA=m&RD0;!gg5`pf1oH&@3pxZFK&@VmLY=As**(oZxSg>4hl3<=-e?fqvyBpX84D567D^M<;L9@@9PQ*3c_PN*B z5ua}Roar%?gKqoW?61XbpEHHoQsMTw*O|iKK8IT`@$GZ7b0t0d9P9@YZl8-UxA{?_ z@cFL9x6h^jRNVGC_?Hof`KvlpMR%NwdZ#-IyUb6ConMUK`1uT9hTG@Vt0bKD#m|$% z-#(XEDCM!w{d>f1-zRVzXvojLZ{ZoCx9b;O9DgSsweGIUn3j zw|#E@DWUH#^n=80pF8K-SH^F^;DDd5lD>T|zrW zIok*0=Z)6ke7uE95BcEd7m^?Qob!C)r$Zf%r*UB*PlLy6pAh52ZHjv{_~AePc^p^C z?sV`=cJ~5(vU_l=@GDxmFKOj&1aUI`mR9_}-O7DcEBd=zxeHpk^IN$c6Fsvh&l@{y z#(j>7qo++NxpVZa88fEOnLg{Tv9qS%RjLCR<;E!`rIYWvea4hAvnSs+eac;>-g^_Y zzUg;OnPYpzW2X4h!5H4jbEb?A{AhYf{$1AxN;Qko(`T0?7&|6ToH%FtT_v;TOr1EV zboLZPDxGrgxM`E`o-(IZlF8)bkil8ARhq4fBA%)k)9<=H$>~L5@18Ry$tN}UI)U-C zr>mkTMblYM@`%&jI4f}1ZBuTOpj4S^DwHDC8?;g~9YGgGr%gUrPq}~kl-UXQxYF6v z?@rB{cuk!6qx+}Ko~6U$SsF{9*)y)5a{KhVQpv8F3=fFAbaKg^6HBJuIdSUb=`(bc zvD5FJB9}KpXpV_@&zd*YF>x~M#W7L;&Yp4Itl2Xs&-gBUX3w~3%4}5B`%3YAA{sw7C& zADwR%b@mL9&YC?W@S|3lwVUlt+F#YKTr-<;2_CwYi(7MU9cc41v8SK=oy!OJPkeH} zcg67Bp~HuNcXEKs}0Z@7-&KUYLapHJy zq1b%ek9d)KUJ@?AkI62pOmiINpfoGO1RGJbm47lLtq!?Z{1{ME~W?r9Rg zzQ)NRZ~W6*%?n8Mfv( z4D#YsjJ&0}P?gn0U12S1)?uvI&5qIm$=G8V{W~u>^e)?V$d& zmS2P9?*t}6{4^kc$udjk&G3m6Z<|~?nOFMLI)4qjbqNW*QQlVkQtP)qLzifh5Y%@`Q{`f+uNsco(QzWF--7&bUE~mLO4G%g{F;hf1apII|6Q|CeJadZX(z?8Z zN9gF~uu=RB&P$aW@@T8N3Lk)9r3>A#z~b!g$PstlyJ?PkT$3A?j2%zBm*)5(9K*V& zJ9zenWgUwzKVy+kexJv6XT%w&eE+o{^&A5I=&zP@%&;T*Aq@6&S`LsUpXvb#GQP!0 zfb!7qfwPX8HU}#!e!0$p$C{)*myGY#%D1-UTif%kPZd`)6fGTKT5C+J)@Oa_v)=Yu z$Gq|;t$b^pDNp&08F=;25U9K&^5!1#Sxv28ot5-l8#6LA(~jF-dCa5?n^snGl+^s< zx$w;>smBT(#G@+mtxfsXYo>KL-#VG}fJVHf-4|KKhXng9{2x(S#HDHN@mcTttbLxa zBG=_bQBmaHVehg_y(`U-g*3`glV6&G(f;1I@OX1`O9 z1r63Dzu{YD3(sk$z9m1W|Nn>jNaR<^yEfl~ykBoEZ`7_W?;enM=^#~PNbC+RpWYrc zg-}a-f~Vn#i<*LW#a$Hq8L@BMLO)+|@P^Ao=)Jv8C?@27OxJrGxu?kctF_k(+z+Z! z`J(okkk^8PB=B0B{T8IQ$+TXDYPW4|>Kz6?OTSDAsG3@`=`h1;++~Klm?Ql9Z4hMK zx)q6jnYCk-DXtwe7?B*c53eNPV_MJGYlsp`R-4Wy(|UM^@_V=rklfbd_VIM(G5=c& zq@TkzZmek?H^bMsOlwSk!_~>?IR=+EXPYb8v6ZXbj~Sd)%*dEwD3&hj!%>8*YBR$@ z7SXhVs=&dTEWETYML%F48S{U-zW%r6o18xFkze%nl~d{K)4F$fPl+|`?PFyO@LBKq z!c$N!x|2BOx0?LcJ}r0j5q5vtUgPd(H}2kUWlYa;hkJO#8R$m$YWfcMBJJ4Mx=M$` zXZg$h?0o%Cm{!4J^ws&+3B@{uM-q*}NW*6ZmYI=Nu6ZpjFWn6a73dFrP@0ur>xD$H z29H-#cvt4`R&9UE5}!4*F7^$i7xvcReSawW5@SWd8x`A(&>|=$q+v#ulbsnZC^xO0 zieWwm1;ZPR$D@8cE$Z>rS*rtEOlv|_IHV)`7h6vBx1R9wUW(9|C?b3%jz6P#VY?1dE{3jK4Z#uH5yBXVP(eh7|cst(TDL{F3dy z@XSiDvGkw$B_~YhUY~VRWzSvxZhC&nI*djjSx9iDnNuCw23b^@#`QZvQ->6c3O*M! ztR8HhkFMU@W@Y@W(GNc}ys8fbtV)Cnp&kg$9M5cHN2!%<;&+h z%(o*1-aYkrGua-H=6}r|qQ6GBxmk~|Q8ZNml*k@hf9$oIp_&(ozZ!~O*D73v#fIr9 zh}>TrnO*}pl1TT4zmK7MV)(Eo)&rIJtUcOBov9H;@}r4U^);nF+UY<3C;G>DeSNj@ z%~OB-(&HPM1z|4n-#WUH`Pw*ea(~(o=!s-)dAQZX(^agb`DY^SHiOr%EO53TJjYg*2$ECsZ|in-H~;L!V^7sX zx>Z#oZhU--r@?x3eT-)*To@O_pu}xu%CvWfS@M|{5bEhxynlDcN0=m+Y%-nb zWFif4z%tX%wD8t#{W5H~8iFb+5cTzkj+7eVP!l3u8fwO`+v z$wT@bnDH#AVeZ%uBq~A6Ls2BHSD4nk{`mH>2k>LEt?LJStaTDEq0RPuz}otPBd?v= zbUWjvEaX93UG)OvPh0C-eX@{lfspD^r2LXsw2+i^BCF`9g!Hz&F}%68gbpCarAkg( zLX?=25HH%3ke>7~cS${^ikMtny?(=*W=!Zc=UQrY#|&d|R0fZQOu;N!Z#uW4R#_pa zRr=-bwpQn^PpZ&xB&!LzjJWU{Y<7NQcapY@@HPc{blIrZGgPL;lEl|r>^xwijK^rV zmSV%p@%qpsFl!O@E5BrmmLtW3Y$=_y)~U+VlFW^^mLyAXX~=;*YDw}+Ns<@sNwOi( z1G=Uqnb5T4@r9lDFC#y%;+xn=SIKwJ_j% zT9s_TbynnMcPdrent#}yHLnkxt*tqeZQW4f_A;KovGK)A9rMj za!O{8z2csf$%D_Q$fVWKGSNai-XD_dS+MCTl1ATZkGH6!3~MdU|B3!kcsM}c4EdxK}Gt%6Zy)xXDz6?AGIhtV(-|^sncWo!`9XI|1KjG2S zu5v($jS3z$yNb(qM(DS=L|zAeVM=FttOHmwaBt1(ujGKeyc(A$mJgIX!=uMvVP?XZmCC<%!?epK-yx=GgCW!I5q3-*AD$ z&W>1>-5A-yJh>3yd#aKrRtuH;#9iE#3 zXD_@wW#mKy9 zTARbYb*Cb(n=+D}#)`RFW{F~LMogy_A(y<$A?fa)Ue_fuHqBb7*)CcM|4LuFlTRAQ zE2;Rd5PTQoTZL~q-mZE#CPx6i!3;1~L!O4g8v1K+Y2a)MG1(^r8Z^`cAXaPnb967= zjAfzgGD7Q(N7tZDns^ayNi|+wTZzDMh*5Ijj68u0D+>QAT)6+%lG~CS_2#bk=5F)m ze&Dfo`>a(<5E8pRtcnx4+G(jG8!HyAhrchZUek)T4l}%*1@(nhe2=kW`35+FPj3Wb zI#AiIlLwhdU!_vAc6+UAuXV_aN3)Mu#Y`EIZ>oH%S1FgTVh%F`ozQHHN2Rj`kHU{< zl(RAiw=R zc#`{yL)GtQb=iZ9op4%s==+LlPnYQM9f4ahsNqXNBW`D~`TJ5-l<^dWEA4I$UqwM0 zp}we?^7YYH!h%3WJdKADO}Jxm?27VgMn^p`IkRLrRVH$)(^{l-Cmf+j&F~_IR-TuO z)j4Z9uSZ9QSzHM`Lr8JAZ6 zS-ModNX2;gIb>wyN#l`ch)(0Nr-0?h;PD%E0iU1a!X4e8;Vxg(KiZI%k>$zSQC^*v zRb9S5ua(RiSTvE@WNB|#CejFVD?$k=o{&nN*pC`}KU zH@=v};_nb5KTb^Am3~;=ItQa!Ix=)?F$8Bh8(;oR=2$8F*H(S?fj+*HPHvj49>{%X z`nXbj%#uzjv~o!2_+_uoiSey|@7aQb!(fEbZc^=i!q`IT`R0i~AgkK?8x>RpH($lR zFzP;9%Qb9cAttsJuIdD>NBDl|FZtA7_G15o zCR_DQX362)ZSKD+!~cPo+eq7R3PaU^wR{QU z!ssjm#JZWzL%!jMjL1evBNUyV6^ynt{yVO7qn_clM&uW`G)wmSBBPxUea3lLvCl2- zJMv_}J;qqkE8`m2@{7{&JL97CU~NVtH&WUO$h_KEQF;;HJp=jC*fstQ@vJq~u})ar zoTSn?@83=5;gPgZ4~FTe9auv|)I+&|TJ=Xe^_Af4bYT%U!xf_<~8NJg+>6kg3-9m{a839i{eLdP0JZg2ccRmIRqm;7r16jq+7Y$iMPnCc*}2n+|4yqdb+*t)dKeIrZ?u0Txm$- zN!S?G(*6iPrt&$ySF(-vt6)~u`4F=Nn-FfN)d>R6z(m-crY?O346r-h>V!VpNQ>N% zVf8jv_>6QnI%0SAK9{#kHF{xBm%1*PlP2?1<44Q~g9lx*1`!z=`%PkQ&6eWh(nqA= zP1WM{HXFS$maH{P3f@%90vNv8TbcHR0_TEMaXjI`o3Sk0munEg8drRpnwTKR*TMB5ImUWi}bznPfm12_3poO z#+Vzu!*Qy=X$WtbM#D7CfnPXVlH;b|(f5hz6<}TGSey>eH7#DJH8iZJdT`` z`7TohQfEKf&aYH`twVo{#qW0ZvN}>%t5{d65YWSKp?{?tx@ql6tupQ!=>tEpG^klh zuNdg5b{*SPp}oGN_ork>N;O<{T2Af#tX65mu!nYI1kmn&k{Ny|OT}t^o)H!Oe^Fl( z?PrcE@>aoeScfBS>}mZGqe~vA!10c#wK?Z?^sd2^X~vV)m}G^H7?pcK0a;Y? zPCR$zMt5*yntkA89voRt%wf`TE~FgYg&OC3F)6mnmgH{36wTU!c?DKCZoCOwaJIfH z*`bN$=}L1)uH*i|3*hhg#x_rvLm{k&c(+&uPY&OT!wAv9J!ZIUi6UAFrFO)wS4nyz zBUN&`b)9`K)^V(zI4kN4`=dzl=HwKi!YXwrvg5{$5f{`{fg#3D6iZTr$J@J& zrN<+4TCBhm`6aJ~qAMYz7Hts?Pm@`KJxFyj0+U4?Yr!n`6=Uf}^s-b|tH~;R%2--! zc^6~)J`FyQPJL{ET0h2-hLvWznoZ*nNM*Voal9*sd!IBadNU?ARxE#IX!rcr!(K4q znNW;@yj7;Nmhnv|6I_O+a|}E<7mrO!bPjBf?uhpxV+9YkEJ-qW6eElt57XqX_gi|A z7p{69T}clWf)Urn!z#DKcVN&?-UccLeXxaj>C&~nlIH6o14em91fK9&%SmBG9)r}} zk!vuL(x+*hC+#i(b()6ud*AS#Mr1!?`Kcjnln~Rf zb=tln)ApHJ&|i$B7Ea%Yr|(5_BrbEA&R6rDuPe&n=MT-UXN24+&JWc!2EnLG^NZcP z44m2X4c}RImmm8PI&qBg^Npo%n&}fHaYjiNAUCD${a-HFL!5T{WjM_Wfgycn8;N5? zkMymzehY6xjAiNc@JhQV4>uX1*%+CC9J5uZBu_l)&XG(o&}EJI!hv$*(fbfDJfY5) zUbYPON%yNB>k#Wn7J?`>=Not>d`qCA@mfSr-gwEpr2!|0l2_1A}E-3B9gHjdWCsLGltm*P+_nP%>ZrqEWIX{ zojDkBurxN9Z7DmmzjmobwCqfmcDZyI9E`~&wW+nCJU~}Re)z!wSvVy}&llW?;BM(P zz>IXC@jEVPV`jR1EJMl>0;SHy+lY5y%Fk@bTDM|=#)h#ADA7o~)a87a!&9r;`4h66=8I%3U~37hqM>t!f0JEEcd*t89<#Acua3eetaq!S)|oKA?Qgav z#`B5(>;IGSMO?pie`{@2yVy8fR<@+pTZ0O5)OxoQFhs2*zRVjuw02OJUd-Ym^;+0j z8ouE1PAfU*H~j2%*u$8SvO3inX%e1HEHO`Ty=Ux+bs1Ur(yDV9e@56mfp^i4FqRn%L=;EzWH;aMN@^44qTjz_E)%YTT?KlJDvks|55&hNuT_#{}1-A%P zr!gXL*@%bJA9Lq4=$;;>p-T>)$naTH7Q;L)GamT?M#1igXTax{w;V@2Sgc4lhvlzO zE4`CcDKpkmI4CqbQ5*<77w7T96P^frVLE3nbMCO#jKJD-!~s@j$#FBi41HeNN|nEh zTSh5Lc2xP{@oOF2m~n7G8Q)`JYhV_5qc!-C}-z;4C`1qJ24P)W6JRo zmU_{WKH%swuo9drV_mEA(ck!oe^ff|y6^zp%+X+8>Rn912@qkW6C*iRIC|KDth=bYoM~2iQ!{|H~myQm5D~4Zv zA}|;>g4jnI5QKWKrQnG3X5Ha5mz@q*b|NQr7RRlA_rD7Vq9-b zYY22^cj+KAGT({9R;g%8jQ;S*T5gbB>vzmw596fm1G9W*&YlG)TONX)3q!jiW!qr|QBDWy!gwr*ZK4IArNKHI zkIloiS-S?3fq9%+!|{^wyr&4eN^6|MSC`>No+H8Iz31H$dBFJ+H{4X>)O5CqV0GtM zah0*+`wLn)?$K!lwi^#$1>V8h!3o(WD6$$yATU`zk$?OV#O=nl8=IO|>vE$JVI~tX zo6X>{v*wMEav9HebE9lI8<^1BT?%T<$k|}(z-oufS%)L7s?Dadkzxx6v|^EeqWtyq z4_kX*qM>P3?9BEv#zmSR&%}C+wJVXY8{9dYkt_GB?|QlfkguUSU%f7OZmgJR3%M=r zs*W&MWr-B%qr@x$goQoEZ06F8OxRu}Mwhk}Lwvns9gi2-hw_A>7{h2<&ZMJHa7P{)a1!l=vyAEM(;d!ov%0ar$GLAo zHNCA3)$jMKKGwszHPX$3FYNko^Mvu}L#UnFyb~NNW8uhnbQaudgb}EV-I7pll^+@z z1lvX?xo4^ziJJlGaW4*|*XEZTHPZu2FuT&qfDn&!+6k}oBk%C{jK~>a;<5I7a*i)J z&Zg~N#b1x%i?!3abw5?A5KKABHTHz@WQI;WwO2ePAxJz{tn$2nmB=pR>5@76suqLY zV<%EEDpp|t74Ni-$Y0=WT!9}YckWr`m(-Zkqf7sI7Y!#N&g9-3j z``kI}-Rf5A+}-Y#_mp=o&qW8Kh7qx0w09n>88e`$S$*I;)1x1^K(INr){a!KoHZUS z_x_z6J;UEF8{@?;AXYICd9aUyDoeiQ0QL}jOU_!4^SIuc-xByB_M6;j<7db#vY@ge z8EB{CPCF`TUzVpQX}7{oOX9JPf7yfr(B+#>xUJskGVQ4v^qadDZB`VNk|)-m)Um71 z9HVs)o6VlckS^}vI%lkt`z5wAGjeY;!c4=1!!1jXm?cNd;5xnJM3R1HaD*e!xi$~u z9z=#71go=5>kQl`q1LM;t#XFO&wGtUpWYC>GV4M3V2*MGHnAc0-6||VC)z7a9EJ}5 z2D9Xb6Oq|Y>z)&p89m+AgR;Wu=!2{?g3ZSK-l)a~=3;GJPs?72tyR9fB}|{bjrY$? z-*~>WvEuqPEU|Z~j%2*TY~|Kj)zyuePMrU$ZphHCo^Wlbe)}7_8@S!q$ysloXAW(f ze_3#K%Yx6GFbXUAV_dx&qZ%k8^skq3Wv?DwvaNQSIL`9ngf)BysFh94S3p z&u6S-!F|rHEs+e!yCv{(^5HXOznI_T`Nq9|o;@oomnq=O*4XRDbnkj@SC8eb!L74a zK^>+{heAg%JvxHnTd+A3mI@zOsspk_6pKQ>xxsWpt8MsSg%HpcXsR=yvtaz z%~?-P$REBX@J{UKQ>)a>iK}73Bo1RLr zslx=BOkrIfy2BDLh8$|3{L_pDOvA(sl1r79Dk>dtge9q`86hhr5T6yZ zc3=x%<=e?iS8@^V)kP>wDFSko&t%r+IXxQF+#1uzLoHCLwU7-H!stvNJo7nc!l_3$ zNMG*SP((V*;H9#@4$oc?UUpHGoRiY@N}AV6JdYXl)?>EXlB@6Ehj*1(;_x{e%;Dbp z(w@5FF;`O;@w09BCaocBd(+yU4D*F2;Kl>5%NvUN^spVfF_4@i-|*}TpBMC4(WCVk z#eaNsr>woev_uWhW{e+uzQ;v#0SORR$DI6#DO7JD#rMQ3e1`fKnD zPlzHN%moVS%$(I`dck5Y%!j>8JdtTwK^Xc|YO__aGIoBViB7HJzVgU1l|x44v+WN* zUV0;&=Dd%uEy?%`?sjfzP!X=VWXP4Vo$3-B;Tc!fA8=={i`Cg4L$1UTExB1HGV}r_ z6fRiFk~7+WKpB<tTCNuL2%}A!98dx{1a#y$PGnVce{_1=;Z_+5) z81GNm-ZR{n^csLulIb)?`5XX)8*TsFu`^+fH{_RW^>G>bU0qATnqf)RqS$hRH2+=2 z8ncp;jb_dp`A+O1=Q(Wtoyi|vIr^09!27Wmgv?tvf2mor%}2qOY|KBp!*pV8wl?4S zs+qGjcbl?D{lFum*Jw-^Iy-B(ew3Ge++BIzS(K+4Tn&C(1G^e;hy97?#CVj`eU%$5 zqmqm@AXu%F!hj1^O zFXG4P)mm$h+lp$X!T{(B-Zf^=uHe3mJBcL)@2K$^aAXNU}a@Buk)kUC(|_v>)HGH$HTs>4|TWHuadF~3-ki)ZzGWG!5P zA|O-i+%2!$U65ljs~+Y&nIp(D%?QqS99O~v7xxeu_)uw z%W$D?cwe3kKCr0n7k>zg>NULku!wov%G=<;2&Tq9lYV_&@EGniUpN@CA39@YB_0OF zW4^I2&h;zn5I3hzI$BJ|B3xl{_;kk`>x)w|eaAw_VH)(|<^`W|F~q2-K&-37L(*{H zdT`z4)a>a;`h{XQ@E+0X7^ZzEFLrX-3(+3Te2IWv+pZ8T8Ii}q3vKzz|6nUCy52OmK-l| z1IT8olYvsw2TU0ztwiPG6a>GE6ST_37pFjJbUX!B5S>Y$#cw$ahwZFY84$QSNVzEL zk6hNNHe|vB!H(LHPp+`TaR4uB#!B}!tVtu%oWZezsy?nGM_6gbqeWTJ?q~}(&JfuX zxeq&7sF!9qYC|5xpgazHpqF>ujk{cN(S5pHoPC>I^qnXd7ynQ$1{Uzba1Fdc<50iG ztMY*=fh@4jjn;++NN!^TrdEX)(iL3o3hI3@OXUTAIU}69NN8G!>M^&8*-E(*^8WA$h4tl*m@k~uGVMcR9Z_G{*)r{@ydFRR7-|vNdO~3t2z$SD zhw~?SN;kNTz!t|bitL4&VY?pT(lc=*?==N!DC#hCR}sh`X3SW_`&y%DJNoF=TV(?C z+;iNh+GiAPlXs?R)lOcjcJME6#GkFKJFTqPC+n<6_1h{Zd0t|ozs0YUhz_1_^6X}| z=d6@7XRzO8wA{g*4k>s*HHB2i9j7NgDdTOlyvAA~iXZlDGr zXwHA9mg*3 z0iWZbwVspJ)Atuf$I}N&@c$hDoqY^hgyC}jS<+9d^wTQ+v`Rm1r@t)2$)cUrutFAX z*~T2_eZgpxFL)y9u{-||NkUqZd$x?w508s)FDR{P3@IzL?Kai)ahu^hca%WjD1$SF7 zBfn|AjGk`2Tz5M!DeIm9L1s)c6DRbf#0EREg1QB!3dh$!4saK&e=^I)ZLrrrS>Qan z6rmqH_5vtf6ip+&_DL>T`>>KSpVVs}q!W0`WK?UO^GUtt9Z)E%);v&l;F`yIE<9pV z={lCXUHEM=mT%*v!m5@tTrYRMy!%I5%UwhguF}gLYW8~XVbx>VQdCRzeo$Ync}Ddv zUe%JfHD$@$W-WPp?VPNRJ5*NIyp?3F-YEZ86V)Lvuk)goJvC35CPvFGOb55Dc&giu zGXO}2+EDu9e{Y_srOKWsvP51mPXu}5i0#um>P6=X%f{cCC;!m2W0d|*aq$INu=l$5 z`!pJl{*(1G^0(GY!7r_s+=bRl=A-grxNdq#KgWMtKd<{HPirtaK9t$%HpZ;?Tyva{Yd0M?YPRum-P7D(VifITu0n0Na(_mUsRfZz zO`NOXCpyful(7BFoAr!Qw2C&@ZZc*F?J|aG?V3d|YMACb$td&+yXS|`AmPI6O1BNwWL*Q;RB16FKGd>>35lb$BmNq z+&I0vycS*b7t|+pXFo_pxUY{vItjo#O)Wr zUTUviE6IcLm&UD8jgRLyR@f17e-vyX*9+(5lpv9L-eVMX7)8C(D>;oBb!u%MKa?j& z3*^E^5hP;X0{|&+7AO6@+MQ&~^X}%g@?HJ~4p`?WiB{`MBe2P9pq+W%Lq-uxM|H#~ z;@D8l$z+S{r9H-qb+Danixwa$xm^@T6QpDpl^8Cm4$vDFng6EHQFVQdQN&3^NZM*O zG>wOVMIUv^i%Y6@d3mco%kKnSRQkuE$Q3x?E`7&P%384uI>wl332b7;RO==D$>5-^^M`GIDEl7{EVsDL6DG)! zvJa|BgIc}7(%$l3lYm~VT6VmoIDMXNFqP5o@ED#wa36V~g?Qwbr_P$a9`nF2-KWqn z*oah!H7CE}JlXXV=ua@WQo@>NJ z{FhV0`36O9lzbe-q*!w^0Ye8U8Pw4ms!WjU?!PN}L%r!+1i_H^KnJyI433M&H9T`w2r5Il)9mQKn~ehFTSB#TOQPVRtRM{N3Xo0 z5Gq@M&#?t2#sptoBRtprWOt!l;KJFIxFq`VRF@&wdL`1(`NUc%FX)H{F$zpc<6eLM3?dy;aK7Ao-u}t%=oI?`Iyo zmwFIZhP*Pq1^-;5SLYe*65GYhjz8NTuYa1D7P;?GgTnHE_h9>HvV39!tXM&FTCd2l zyufyl1S(QysCI%Bdw*)NcUp#R(`1}e zOTEulhl+0?Dd(qY$<3BJJfT@sQWo+u1`qh8E@yIG?#gM?q&99k8LX-rcdey;6|XLJ zzxo9AEvZfdnN^?T|6+Y5gVdMtKd7$}%$+6BW6T<+g=#INu0$$+x4^T#Dye_d1dTxj z+05NDLf#@~Gk8CZDHmtzGK6us+WLEO`wsm1+tsB?8>MoY*X{h11Aw0Eoc&T7gyswx zTm@gaSfju>8dC&j4Q$rk19%Q%vOGMgscLEtY%k;gaq#)a!I6*;3x!)Gw&>hNZ*I$`V{% zWKF6B{VC(2tjVrNl#8v6x|8EvYCAY@FJmFMCEwKlAW@4`qiTtIEG5cl{-bLB`2Rg1 z`mBy_9S~i@`c5Ga6a6Z(EEuY)%hB1yD zu$q+8`_e@d=LyD{USXFINpueJl{8*_sDRm6V*%Ac6Ti*m|^^P`)3WqvRL z5*iz`P%`wOM(DxMLTJ`{k10OLRhv9!<0dq@u+8=w<>v#A4>)4j5c8Q>Vketn0e^FH zmdC8i>6&a|&?a+oew+qS6DoP#2!CBfM8VVfv#-#sgos56d%&?;6NbE40k(&Im!S1n z-W@refvcQH3xnq~9{o)ChaaxYqAw^S{LmHbI37HcrQ~nM&D~~qlD}a^52^WDc#+B4 z<=v@)GX4XWMtjaSx7W|H@h;pDcgiPg$q&)R8DLWvYCsLhKPpS`D#sT_VJlpTC0hU& z9sS>R#@BaTdN9*g%Iu1xrM)nTnwZ9e%f-CQqO53~q;KE*O3G2^WiUA#(CdADu!g3El1VgzjU^SPmF;c(|ukVKTP#bPR(@;`eeq<|Fym zpn|0Hfs?}ESOKB82*obp0G-lu|%Bhu#O1sg}D%^NB`4su7l@oRLp2jh=V zz*!#(%78_Tv8S;14VhgyZUacUf!cj_Xs$ZCy(V6Z_Vw@9CfKnXeBl5BJGWj843{Im z6rcw69ERZnkk}P&(YsDV=U# z_$4-$e+WJ?ZFhOi1J)R!W(6THYE~+OL*@Y+eWM$xj^d}K6wf_K-Q zGupV;-m6tYX22dZ|vT-j6b0y zPf=HMmqK{_X(}GKBY7zk9qQ&C4bJ8@^`-VoZkePqTU?>9XTjbNeLaWes}>IyZLIQVet1LtmcTZ0W&ul^x-7*iU z)lK}o{Jv*B<^3UkDfm%wCnOPCbfSFyWd<@-J3_Q#KhLW_Jj-P)-zp}d_Jtde99~)V znP)@i4yQeD58R-SA-Z&jr}hQ=(r3%6pTSW&8B`R$=ne9ehn%C_xM)N7E!dHPSvBGg zl)BnUf|SdA@K(j@%)MVf3u^RpNbeZ)TqUp@lmqA)&JZ_7sQ;uAf|sn zOwMyi37v~E3_;obsL}jIX@9Ukd-nUc)Qwo_cdY8)hg!$=tu@bmWIfMY&;Cy5bN#W- z@;cPzbB0Ux){_h>jLQQ5a7U}EAwBjq=7tZNZ$>^CYRq^SNsO>@cEf@`SJpcBxsN0v z6DLrKG=wfX?R;?0)jC?_F!G7?Rn;E#!ecA1TT6?wbPH>;9K6s1e^$EWidHhcjTa|9 zXr7Klt(udI`AFi2Tv&s7wl@~sXVtrplFldBUDouTqwM6averq@MLPteUL5hDxh)dS zNwgF0lpYg_&kF7_E=)QvNzOr&`h)wd4}|Nb%gT8!I-R-(?`{pSW|2OSUy{tAWJ#kKys3Ki&L7Mm(GvQQp*RX;LZqh0Ft z?(e`1<&D_;stwn8{c+nliE)kBdD=R3s8D5V+n__b;I_RwRHoC8=@9=Zumg_v~CFL+M90IAzgcuTZeS*P2+S(*WPrEggE>D z-}awt(-R2uMP>G7ks{di#scMN5JH)|l$7t(*p-RdD*LCg0(Gp2gB(V9+OM0=TsixF z=k8W_e{4U#io{bVJs(PkP~>a*Nuqlae1u?m_?0Jl$o76abV>MGX#v-Ca%!^4%et*! z4^R5MZ+@4R@p;K;?hPrYq*f+3n)HrN$JR`h2RA8>4=D0Cc1~Futem(pv@$`>&mAc> zzoN527h8E8xJI2Ss;24Mzv$c_XaX?Xr+wBcmjfp`GsQ+P_Jx$+L&W3x6YS5oifxA2 z1DdM>rRVCugpKS=udiRf9*a0kY!8eIJDVcA(;+8xGwZ0IX4OAWTW0be`%g|$I7RwE zd^ABH%A%)Tuu_RA373({stbKZ0Ww2qI|)^%H|-+B+k8?{PFIpYK{-v5kWfyTgU3sW zudet2weKvDr8kL^Qfun~{-3!HIS=<~i2u^cP1wqu4AdP~cX8P#LWr_?a>XaMEQ-Hk zj)26_Rx2muq~tZ{Ui37t&q7&AZLrQ0Hot6|s{Mq=T!p6`2zzzamN>Yw$uw~|wy2bT z$PPOk!R?rcoXBGyGirrp0$9~}VG3|l654>{y2*!}X_Kfn#-_p?x!Xup;oWjWrPKx`HGR%p@{Hxs=C|zeX|H>Mm zgVq481CoDdfQ%Bv(u0f-76=kMV0?~WI6i(eQf_u6?9*Dm@sYdrj`Qx;ANIRjzY=iZ ziy_kAa3FdogCqSaH-~u5c?{6KDFZZx0XlNQ044aVw!FE@+~_t>dQF7RAT)v_OvG9T z8>q#I?9HvXlmRjQoo4NNIly??_VB8Jp8zJ&Dr3c#NNhM@N4$*8`K$yOp;aCedUTty z0&Oc9oOWiETTLfd?!UR^cvBt0Z3QW!8nq1>#(KaqM&z?7Kjl5ptp@86$;s60fdWOa z=P_#5NZ~S))!0mi!pymGXhXYY!NPkkhTtzh$F zF0q8QYr0|Zt~cFD80|BK{em-u)m2GL&VcMdf11YkLv}r8+&nFDtWOw5ta@tw)?Wca?_W>=kmGeQ8K?YMV=@95o8e=u2~7k zceB~hqj%Z!5Jj&@V->!@hhiO_R}IibR$rZYJ8XWCpyYs;$qk``v&d%2opy7l^UrDb z-rVK+Gq`zkr{~WZ{X(q-O3&AS23Iq6c8Q+S1C1MR?sEQ_Wu`xdD&2@t3En#`xsdm+ zckAT7r0`cP|9n2_4?1<&^qX&p$zNle*~6kDrpQSfHxqTGS=%FP%y1eCPB4kPu_@O} z2ndaGoo|UL-Yu8VM+R#p{m2mG73n6?OM!`++kw^Wz;^#-e&QN&DHC)Fj?u`fCg=f1 zYMIAzz*?aIp(qN>)N>VV!2CwTkCWxK12WMVSAc2dD%dqiRx{Vg9r`(X3(r^a5v2!7 zQeM+31uy8Qi1Nf<#Z}OzBC1&fm`CX2F>8LutnvJgS>yR#|Kv{R?-(e2C6w+nTDbqT zKl(+z0knZ%I1|&j#s8kcFwB=cXOhGV7w!jhgrr0L2*cOL#e+?prECF+4@98|Qj=N4 z2HhvxMYsdP6_>Gmf1vIh$oY{BgN2-3Ag8cB8Pz58=7lHs<5LO`76bt;bH8?Fe0-!Z z_o?${WgDsmp!x$V$MuIAw0|Qh-*E_8Y#Rx&L_Dm*C5f@KReIrX%~TpN)ICtM`snwb|$H}P5fWf@fK(m{{`GrEVt(3$F?2S_Bk>WiW0P( zqGy3VEJs|0i04*bCk9ye8`QeLK5gC}wE*By#aPbzW`@NV2e87Ylp866m|%4xf1_;i zu7(-!9g7+N+&_Fp&}gP8yp%-HHJ7hYFjB7NUlz4-Bf!d1xwO@}pw+X$!7shjvmgWe z6pR`tD(5@`Q=|DVKGdpT6r(-;nPGAFhOgVKmw1ZCM{X(A#jdjSBb6yV7bP`zE0>F> z(~V}a-!$>+sy@Vk95)+tw&H`Xaiiq~EcU4cP{bzO>p0~Lo=va+lPn32t#e|&iQcwG zE)8ZUF3IUKj}@;4_Q#Adg6STNFo9vQOlj08XRIL}KfhcFtvw~+pusDiW*e92%?q6} zrPNN0)$%n*T~#G%LO!c ze?eNVLq@d+eH<;D0(2`Kkx1-nd@%K%bw}R6+Uxk6yZ57(9V?|@#;sea!(-ga)^f;g z?oxhlUJ~s=97KRO>uC!Nx(C>^-mrmWiJFS^F&fKeM2cF-fY6DZu@0fb_mG<+f+)*J zoTx=gMSpjEfX4)*I3O$%MtgvwfJk_hyC}u}v!xnX2^dA9Mp4p^=;^pItX*xBA^>9$ z@v#g|B+iGEn1;08V?IQqYFFAL2qAEGWP!}+Hic5?)p;@++u5n`&&vXW z31f;#BQe1jJiOQVO3rHz`M*AwZfrHiZhSZ!a!$pklbby_YA09iHpc$#;ao*1*7Qj1S_dEP zHi{@0B67@Dqly#HFe=(8*&qmOHj(X`wJu}qYqP&*jNLc;EAHUjQLc1-BUE6iQ9P?{ zuEi$TdDS-MUh86D$PG~CjIZBWk7Hg_1 zmBO{>zv#mZ*JFDKt~Sh$;G)U5KlyK=zpxcnTJfzWM*ocyW|5h&zcco!)AD&fVZ^3aW~`IjjgyKV+`!7 zjiN(FMbwziF}vyzGAX9!rGFa=9ztom?v^3gchM{-$RY#7WWPuu=OTNDa`ZkK*`LXy zKYL5|DIjpKIqB;c898I&|ANej#$Zgw$0O`48*G?}mR`4$HKo@r<5V|&f=4ocdo`-i zR-bey9#wG}3zbVoC@G4|5hEGy&=$8DMSmh$}LoSQQ0+??z0T!{DgK10Xf=x8q1RXS^X@yN8sO1RrK{oK_AQ$C6?iw1e58msE8+JFE8b3$-tDZiue!B8Q0I*6;+kd zBm()&k?5-O%(b2cSL*P{0{tBA;3+CA0ZV12Cc6s0L)9;{r-uKVx zcaS`9tZ1g#{!gH$sN7XvdfI6I4YMlPmp%Jnd0l>!-_g;(7YSLZCREwiW*$%#3=-Ej zNZh$DHvXos#hxy&+khTPo-PJUp?EPD#8J!zap$;mH;;Qyg;=)RARS1Lx@A~i9PuM_ zd*mP*C{_l= zEAlKNUbQPajY&9Id!#8tf_u?kC3*RB^h417 zAM1RL-T62~)JS1wX*F)7P0Ot;VPw@MI-)$hqv;1D;mqmKwfOjE(yUG_5H@`;nZ6bOJA(_L2 zcJs|D@PiyV{Wp&%z!3&+TVs1@2Dcr{&1$fZ)r9B#ivvanS5V?0iASX2atSx&pzR7i zq(z&hyZT-Dw@7ysD_~#m*^?26($F+KT#Izr9XSkR;IO;*{K*dNS3Nl5-wD&lcskNJ z#Qhg3sx{CJ9|t8wBE3Dtib_aYkg|1?kn`v!Il6*p9ma}EEN%nckB0fe@#tfkozSq! zQ~HprahQ1bwiNn8fu*`R(%>I&r>P$E0K5|fynjn@LExeYpVJ*VbhX>D+TDv=Z$tw7L$y63 zSdKF)J7J)O8rEA5*KwQR!_d5o^CL?p^5?_|Q$Y_0QmLI$k_%tfs#f?y4NEZ(WDl@e zC7ACCH!)b|axfwpwLQX|Im8$oq7@i_3UG~Ew<*idTla*f<(s=`m^J9E@^D=DxXrg| zK*ItGYE#EQ5fjCae*=Uo>U?XTKW%y89FF1cS1uLk7=eTE@Rg6ibAJ~726!89<4f+J z=*(hOFWaDqyvD3ULbMop&{D%StIf!}XH=n)S2N0GoE!w$RqOm zj0f7>j@L43*H47w8)gG%_O1sAoYCb5lcn&e?3v#Q)p7~H+r*$@hU#6S-IlF@u%?6O zuYUAK{%0G_FHsP0mo|LW9lAukU0&^o^q%GdDMyFgz#xr}1rrUzUup1sq0#(f{n^)W zD(+n`h*=(*T69Y|=b2DNx6|W5o-UsJHW13nVA>-Cg&8c2dt;2hd$@3kdSti=db&rH zhh`L_iR_E)cS=gP3+ZUh7je~9(Ou{>WrSRwZUuWjVU=hPH9W7-FJ7sqTR2}zm5I2* z^2obRp)Ndytk+c{S}JLezQ{t%uqc<+@ProQ2caSTk#Dp83-f5HYRxw=UKoEC8dz!5 zwCTGM-67Z?;aAESR#ht>H-Sk@*{g)zbcCnyo=SQrKJ6z@!%%6W${7u(g-a&5c1q}}SGzOcQB=pvn? zsB$SL4Z%n9wK}vxQOV11v{>qz@xD>~$LlH3r!SqNFGPyV3E@MY6Fy|0QFV?{h7ZYL z95KeeF&p0D0f~7pceX2*CvOLGb@<^711_ZY;PR%9Vmv=G#-4uoQn-z;OVl2RQS`bD z9!pWDQMH~@rM`zRx{{y7O3zm(j``Eqv$o^GvYx-V5cC(*OiM&@>tRg)(ha&uXTW*oglDPXx=i3SKSn# z)aEd~>q#)ic0Bw!uJW4wPn@7Cb9phVs5Umpt;)lZ*UDl`}bu+5y5^>7xKa zXB1${{E}D-%)M3>D2&}}qAYnGM%8LnAoQUwFg0RuYk77UG9DjHPtVy;ZOu}YojWTdK z^K+(KvAUR30Egn>G@uc>6PCM37xe`o7Ah*JB6JZUA^WiG7ojTF0v@vCB~*QlA|>f! zAMG(C$lPd;OvfIxa-rO}CiZg#aevT<&wcJz#rDl?DWcx;I+(Z-0>f2+8){n$dDBx` zmC=s)k!f8LL2C~$t!jo)0CK~Snisx|ED@{F0(-3|b2}VT`NjdCv=LTu7Zqj

WB= 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%0ADnL!DU;4>+7Xpnv=_ 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�N3 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�+#=}= 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%0Df!W@3pd1N#VoKB$2N& z@@hhjP4pk30;T_Ov4zC?n4>?c@&F~qmPJ0b>b3qP%=G7rU!XQ4kgzPay?;py@`Odl8a4H z%+`J@_gNVX-JO`I`uoo2KImJCBu?MbBl(fR_zC*gY`S^B^bK);(8JFjy7&7<-Ae<6 zw(Uzte>X(m%#P^xR|#!Tc+|d>qZJ{0a6&_#vFT*mAf3#GCqQjo{8N!fTJt}|TuLva znTrMhagHd^e230toeMHv*Y2WcL*DDGr)vM6FXMCb!0{>eNd-{HA5Nyx5QJ!$k-M}V zB4T`3`0jVZt(^Zr{-?@#3CtU)*abGIcktd@-tO=J`8)mn7sG$Ah3_`gzykPlI)b&K zlZE+?R(8w^r!4l02RH%w)@o5^xwg?57KK?CrLSS~ICOd~kmR2bL924|Y<@(knB2&Z zC>4`y_z|UIC?QAYfm{MT%>(tUv=Z`J>n-BnQ^lPm?sUhThholebdgvSp}fYOuSVj| z9OCd^UE#*Jim96w7cLzAx@&+q7H+?kFY7DJ3j^bmY}c~A^_A@d)>o>-@kzY(72I5P zQhAsb82@=~bP!b94_J*(^UowPCv|q{T?JlK*KtP%7E*@d@^mvJKbS;v8RitT#}-2l zAkC6v3I@lwC7huNJ=XCV57_i4lDW&s8z`A9SCH4NN9b|MtevH{B}y$>Lv$XYtV$`% z^OT~zAX;`~u@S=XtD^n@Z!I!ipUV`=oQa9*{&94l?fh1uq3Tus+JhWVY_;Fa*OYUY zjCEE_R*B_dVBjh}Ke_K3Nx=l&{yaBk?PRDqfS0h6x^^;I&gHF$;hMyij%L-~jaP9c z7D>F0Yjsey?5s6LWOiiQxmnB9gUVPr0R!Q2Zz6XgMmmE;1M0i<2IIcjxlDZe$Cjqc zV;h#93N)qg=LsNr8CYf4t+rHRc~Hb$eP#R;46ey@n&fewa2^x{{DM+r-_&y2SiOz4 zu943rEDy4Epux%<8*7*n$;5cC&Ka3G`Nr!Z2Xjn_qrrg#oZVw zB*;{sKh}F!8oWCp_Ra4|s`4)C@M_ISlTO#NTi3|7Bz-(q7!A(vxhS=Sn2Y$JQFFzD z>ItQp^Zi27AC@c#Cnfm@sY9C6)|swu+n5%M&S zyjf>ZToy*B?>`~z=7VagQlk%^%hWozb~ZsqrTeqy)I^JA}D z(fnD2k3he8T>x-UC9pRV?bCJ#iL*X31V;W&EdD)d79GpQ6AZNhjRC{Hi2kn_5d#Mv z3_TT|nUOUS>$ay6R%Vgn`Shp681bdp8sI>QDj_nnF*+u#iF;skY9cft^HQaMOqITo z9J43$yF8@xB&IvfRlwdM^BeX>X34o-^cR#K=8WDnzPsf-cZw3E_gOg=pjh}gG(OCX z_%NgkK4^dM0Gxo2lv|VMq=x5{4clqTb}=Tx{pYRxbI`K7U-+m8(d!vuR!5W4)oY1Ri0h-65H+ z>pmlD3XX&^_mVni^)0;9@x#Q4#bZ@T6aje4zCBL+Lwr$!l{MR>vp?m$=8kh)jKb_$ z#&LzbRZ2~jzH4V!3&2P@w@7*-0q{gUOy-wV7=C-(I@?(XncpZ`?7=rmdcXZ8#q^wCV_;^ZL%`Yf?;-$`%DXx_G!U+Z0xz)Xt?cO1+ zBPxYYOMPNHW~Cy4wOvj$khlZ}T5nFa+9e2&R}ZE*v46RW4-X*QT`fIgn-~*R;2ZGo zmPs$=ya5|`M3A@81cK5|m63u-F{K6sp&c%yLkyCfXQTjjiQ@^oqH6^g_ z$Q%KEJwgL<5mZ9uElr|hJFh+(Ed!iTL$|dV%%nals zTAuzZZlCZMkq2sh32B%&Fw!P~5IZ~y8*2`eKRjM<7%QV``JzVw`QTyunhsl9c}E8c zU^O+anlG9g_F3(}XltB*eOYWs%WUA!mx0*hlF=Xamm4VNGfrUX!ORP z=E`hB6#;jGDEqW_DU&vK%EetSO|={Fdh4>S$(x{Om6vU+xhK)E6}Ip!8KuFAhV@K| zq}fGRN#3M$Qx6w^1SG8HH|Sn@MT@7(MJazCciJjC?L#ql=`x{N>$Y~y>wZTq0qQO8 zv`bQI(@TTGcR4ZE^~Q(mesY&k)gRO2!AS=hO49W)_pVl66Ie*#D&|qi+)Xm}RG%=u zAJPhiOc9XF>DbOGJO=ysi6AXHMgu%0!2B2eh9+~j_EHUe@l}c0!YzzsE*Eqdk5zc> zwc7WES%h*2fRro)m;^d0qhGU8rgqR^MY1if3g*T5+zK*UOGV=aOQz!GE2Vz?)Wwt5 zJd9s{1Me1IiAY2vzSq^9t4;K!1(57J#OA!Cm9J^bRr1WA;k}^NMN$&H1+{j$Lg0v> z34$^&a$1dZ%mAJ*Spn0mgWchD8WY7-5aky6xRm>Aw8YzWl;UJCTm0&5|$1 zn3Wc~R}!i1)^Xf5yI(f)1Ry@Z+$ry5+$vzQmr7Z2zS=KO8R8;IWJ+RCwD6Q@cn2o( zB4EwdC!dMHJ%pxO?^R(;nTKIe$uVp_TQ1lua3%PPB&JTG`qp~`7R6c*9O+T|#0-bk z^CVer`CKmAE%bGbn_VVD2H2$#*A25ANeFCuY0%O^N(V26Z!r5R1Cp}6O4H-zRG2e4 zOV1m~az+E&UYd+NbffSZHHsKtv4rzXewd+m@LgaRw$va#2qxLRKF1ja$C3B$O{+)| zYrU^l(UU~bk{pCk;sWP60Cv5m3UEp1O#**N>-s7j+DP0@)?)l=t~F`_tjK_s9DJ*mKK|AfB(;|Qi=ffuql<(P0?wlk9_P8r=RCR5 z2@jhR=P3aT%DxQ;TE2{&0SEf1_X6a!N{J%fB%LwBder&fV}mfEB5_ApkFbnCk@W=2 z>w&&oZLzn+P()%vg=~Miz zHvsqnzd_*wZ08fYwIHZd+yCe0pEgyEjDnVr%1rU0)-__-Dmcf4!T*YtoRjQaQ)zRaK4D%=hWZcPM(j$cBu>-jO3`hUmo5BzrV6WF7G zqkFO)qpOEq?&P~U3W;%N5}AV`Li8{4{t{P8A~rlU9s zh!ft6u{A;xVv>;k1g4YJ78VwmjsIbwPfS%KC5I5D&t-iAfSMr&){`Lwf4)JY3(Dl^?2`^?S8aXDrRHr>ACELYV=b^03Ca*pZblaUp zd$%z)N$W$ThJCP@-zn!+7lr=>b_NkkrQ2CCwU+*bXJ%@v?FagSrK{=K(Rdc0HxD>fGUb4(23F)@UfrgC4xkbvFNICcQ!MeJu|L-~~zV(w%&XS|n?0ZHe>`Ez2~ z4JXC2FW{oSfRo+!qd@MuzedY1=pjTHKzcewqz0n$cl-PKHZ+YcWpXYaN~>5H?a#kl z7*WQ5ThxnI)!}_nO?^-lef?i&eCq_eg^O#PXBM2KrnT8aO zA*jE8v69vMwOFAfwqd^&*E5@xzNAejxEEGAo0sg6qTGem&MvKgOi%sei-s7cHCWCk z(fL0#AO3^1@-k`VY+&XjE9b!_&q*1ykLX0@`7%?^wxZ_QF5&L0O$&(AnPJ6;3LOp~)$bP{)rZGNfZxBBW%Y*F=YLiXS?DszIYn^F zCS^8utX=Y~JlLhLH}qzrUdQ5B7o!vN7TqB`n1+to{7FeQtVii3Oe|_I1osU>AQV{@ z6e%{qaD7t6+RP}g$P>IG^HmDzy5gFpB0Wn^>0kO*&yUgOI$g*X8?6L=AKG8<#q(z) zn^~|+I2&Nznjto3gG|A4ezUHPDgAr#YaoY%<8A3oMx7P-bqm828i0V!7I@@gf#(B~ zNaDBb(K=AEFdFL0-=WJh>xl%ld(5OSU3a)4Z}>-HJ`ukHLOuHn|4*hfapwU7K|863 zk`6I0#3!N&KZqv$Ae!)l7)&IOMtX~*{%~P1s~XMD;$D>5Zg|h9@kEKD7H@Ym4{>?P zn1_VFCp-(R@eZ)?fN+``m2)-+>-pienm`^ARN&c~a@NA7G#mpiI#XkRYg(#ab_MRj zd?5JK^KLYOiKi2Omh!ay$OpLf`6sQXXUe{7#wt4qe@j2R*EF)rv{{aT*Mex^dZw{$ z;;j%;M0FAUWWycmzrihP-3>#&Up#?znE zoUpzcZfFJyI>0Dkz@K=@fc*H9fn1N`|y z;Qw>;*B9#dG@|zbf$uL${d)d+pi32@w_{27#}QJN^vnN+#vLqIR(ClE5afneVXd<- zt-71Tjb`-|wW;g_ycacL{T1eVqjz2CUH{g*e%iZMd)K$VVbVYEUAK7GHQx0{-t{W) zdWm<9dDm0C>rn5yZ;>hQDet<$yWZkmzw2GU?p>4K^&{SOsCRv7p(&@!yZ+F-X1wd) zd)G3MU&2JLF^Y~rB?_z#)_&rPJZ|E z+raM;evk8en%@ijUgft}e(&EQ4NqPqd!T0$sh@DIo<7d|s&C^f zF8h*4a}b7{9W2q9D@T7vT+eYY%RCj<`J}$X=<|EiQ&b_DghDb2g~UHcTon?LTkxF6 z93bw@<)Wi-jeJzk$`ZU2c5cP@H))w_s#j$t&5|*vZBUMIK#*n~zxWj2dZkAQW9? zyVEg}8EatQa*C4Gzj!A;zPBfx#W%3hiFc0e%<3pm1SLp8rt>KUJXmd`1PUo@48A=t z*tygS{f-=qwQ5D8^Z^1FT5Uh35wYxn*R1xJxyvrTy(Ha|bS~>fA-h)^2z6wL9u@Co z4*^zYC<|EF3VwM7DU$AGy?u8`DybBUh~KV8N%{ol$xf=%RNo0wO&%*0cQHn(I>PqU zQA}W*OphcVIr3k?jv@9!$`}1Vc2}vG*-k-CUEwaiMc^ZH!b;N~lrl*t3UZ=!eSVAt zv8a`}ZqiT35nW9xq80yCz!!B=QM`>+!&x2aqmtvlvdX<^-hs8^1xIW0kBa1#Dtv^T-3@A-;-3g#<^*6FBF<`9#$|?4m+#fM3ci6li`vemXQ}%jF@#C zWtPi8lGA&j2=x1Xcur}Mt}|uvb%+~ZA9IFMEtG@*BYu?v$7yJ#b>R{W~`}_}K2?y^Ui_Gjk=>Q-7v{OHF_JB8fLJJv`umX(G_}Km58=bxpS0pTq$8$K z8>qx`3ZEqu-Lw75cZZ5ID&e8jmVLJ|CiY-gkN4y&^f9bRhm9UeXmniW{(O-=Q)ucW z;cc#6F0?R87f|hnh0*y#?7<7m`w8wP%uG8b%*;IdxQPen4Yfmj7yFiOaon43GTz(a z(1wPHs%3191%()O_9@jcgi|jOmgltd%HcF%C`tdiKM; z>5qr%`7pE+73^XbKTU#;4Ur~ks~c;i@`%h*2Q^XYr2s#{nuJe#kr_jW;QkFAwNuzI zVLgi&ai)f#ou|gPyToYchIkw7vc~XF^#hN`4e0a#a(&YO$2q%}a)hxEffwFR(E;OP zCEZMztPBjg`$7)Vh!&yalXNd_VP2S>9J8H4lN$3{qM;jStNk*ie#X7hb{0S6 zHnCB{jGkt!*cfa(#qXbek{q(kvfuXP;7jKkPbB6}GhMmUJ8?8m4!#m0>q@PFa;^3& zA*bx(t>WC#-J~tvZo+Vg@ns*+KO!XBB zm*a6%%3z^jV=%lXNeg3=VuI~nGCS#hu_Za?IlJKr+nV$Q^gS2Btk<1vH@jcs3`m8C zmOsFThV|_AW6C3-;z zS_mZQFQ6Nt^g&kY8b4(=XT>Vv2l`MjzZ@5uUxv|u7H?K5fE32(UK}+FA$=u1gr~F6 z;nII7lzt>_nGHavO=$^Dha-Eton=}aTB$M?GkwSIA=Q3BHkJB9Nf;@ za#J zOhmWxk7gIyUH)`DJeuxG@W30Cw8{DZ91F6-~a|0{QzrY3V= zo|nj7Uc(5{Cdd(vEh+bEHbkBscjrWWLRt?YAri8AyRRm;MwY%aU(*$GZzm+Y>ym`C zUINY$5s}=-#NA131MZfo_A}G^C{F?ADcW%~0H-#q%vvR1m)&1?vUDmpP{@pesT;@YaeBwxZ`ot?0BG zEBg7d9NtVkc{wOVV#~)n>>Q4edhWehVuK?^T_Rw7Ilz?}bY<65mXER3im^<{r$D5p z%fJ|NZ8Zm;Czd=QQE6;U>IoHl*6~=~cLf7UN z%u~=L%swXzESTqas+uxj39Oe&`Qgryf{&J$US|!M5OqEdfA^;2z=2P)8qp-^vS8zAD|KMyT=2E|ZZ5K_{5Cgq~PL_E^d&mE-_{<^Cx8vsA++93+ z6rO_oRC5^lC1_uLsC`%jrj)~P(T73-4e&Sm9MO4U#)P)rDE?#x-d$)t3Nj}NXdnbFLZpB~YMF05+~I&H=|3#p z5l#R%m|TOR`>TaDnK$gEDxnsAmki>H@HUQHx%e)v1%VH@r_3&YIC{1Ptb~4%G1|Q{3UqPOCbStv}mbLlbvwS zHYu5Rl){@tNWe|NBTD5LVH`>Og85STH_mk{AXckQc8X&(SqX-0w;YcMw=shJQ@^)6 zzSTfM>|kf{&CNJFxU+imBeeY(6FTuBVFvsiiHKxlWjAw^bgx19rqn)pi?h|3T`BjA zj903aVcPZdY*#yyr53&~*d5*^mMd3gvKk|Gm5T23s67pVdeS z+f2L3N-+d!{^IOp=?lrhh;Ysqkv1n!O^%;kzHq+Pei0KZ4Ptl*toRf;Q>GH$LPbv< zPgeVQlJtqoBTW_i#VU4sFdjBq?I+8Z6Zwa^Y^BUEY?&L2H%CELKFBnta0T*P5x%D? zq6I&wrs$C(&RT6URzPg;<+wYcX}F7QuW6!k5S>E;8sGVA{1kYyyePnl zDYlhjMBK+1Q=sUMq`ROzRr;!!6&wDrFqUd~fohx?Q|)CojEs{&7dlADjvixONr@uxLEO|LP=oqO(Egy?11CEl+gE z1##j%8`2_Q!GeS76IoEYYUDjIOJgL+k1`QbHt+(8vhcx#EfH1Rcoa`ZWj0}7z}*N| z7nm&lH+{=A+2T&765>79q(_9m-up+!cpm-QTk{eJWy;{Rhg2t2vPytLp(OH|GLGV+ zA)RWo++uR)(Mt>%c?`fQLL94ID$a@z>TJqC3#l&Tc3i-ov0nuE4J%?Hf0ns|P)gWI~oEoN9h!8pW-Ms4ML*hf72*~p<6K7ZJou7uJN`PnF8 zd#6u{0YS${kRE;{{R->fn;u5`gJsGN`4rXmdG3G(I0AX#5aSJ!k)c-U2W8rn^whKP z-0bVie@=dZ&)5r8N(!2)ZNxVu#DBLC>&G9TdlfgnU$rr=vi0xNP<0L)h}9Ll|bmkli8-{VOCB#I1xWkY0LqZk?w9|nQvd`@{mnvva)wR3mK zD-|e>>cQ3usVKzb!u?Z#2Y+D(qd7p4O%t*E#27BikzZFBHGYU}tZ-62_t%Lxo@a#- zo8oyarKS@Gp+5g2Rtv$1d^w&V9)R}|V>JHqTnL4dn&xrs;kqc~2}??XkRw_hWFVFC zsqmhUjbU&43*P3pztgpk{_NHBN?7!jL%N7!-2YoxzpuSAfgB^Y4gZt4P_Oy{&6CJ^ z^GY(6&Nk#bLR<$q0)Jj@lj%dHp8~#2|LGDY%;D{1?k3ZD%uj|>(4C>qljt}GLEefY z%l9U>Hh39n=RN~b;pph~-r>5gK+V3rMfaE4vdIM_En(2u_~R8NuJ@F9oLt0)7sSap zRT-r8TaC~2F~kZT}-oRlznSZ`n2p@rI`ePN@0@f^T}LftnGeBVRAOvW7ZPe z7wh-q`SaNxWADQfZa?BTY)sE$CJfChh{%ukKQ!!GFwA!JL;fSSbC;B!Kfx;i!DQd> zG^$e5{VEVxYMKtF3O+RL+5c|OQCK2H)bB;Kxq&cmxU&!AOnqeNk zD5WE?IK{m(1~g+8{OTY+A;w$;mSV~@os{QjOl3`e=>kN0WWv2m(M!+$5;zr%{Lk3X zy279DrTx>U>KYXcKpGxYP)x5W&sTkXkB;4C;B^j!}-@mApAmKCN zuI2ey33<}CH*;+MG@qZx?kwd^`gn8ZNLy_y<)F>Zzdk=4Wmyvc0b?%1NxI$OG_Zwh zSLwe3l2r5qw2uVm&I#M)bhYf7Teu#Q)^+Ky*tbCcm{Z?;L8Nh4J+l8z0%f%=j>4gCj)DX7sQOuk>+*@ASV8 z6hXht5AH%+hzOULCPok}1D^*~$cN)K)?(+ry9-&RpEYQs1vNCy7AuX;PqwS`lTsLy zlrS3kvvc>}z$KacwPf|DeDd`2DBEb+wCKOhm#G5lIZOufgq}}K{IsaR$V~dKJs=zt zlbUD7@V8U3>L!QRX_&7ExJkH+X;^gnYsi&&&l4EWQwWM9Q(+W(iLyGOHVhv6zOGek0Fp%MjZ$=CjKXdcy+;Zx)eaOzSQmp(5fzSX!RKi`pjf)?- z3`_yq+4UQhNVJRk#AO+SE%EgP4g;@Xbl8J;OJVeyVAg8?3F-R&jemZd{zWqG?Q4a8 zh#e=iLAFH0Z>_Aw7XsBRlYB-$byq7QZxlo(oZo0$G{9F7xeJJrPChy2?PSAq3kN5h zr)(e965?$h`MeI$d(ryOkPuj|*0KNgoT+47Lby`wxA`8#G9wWT|39#vP{!7I)?f zzYw}n?sc)cbRG076^XlBaZew>7JR~DCW-j%VNOB>6HkI>cxQm}6c$es=_zM&50jrE3t{TkcXJ+z3S2uH0_ zT&j4`fiOtzi0)DW$RS>;*mFK$`z0gPZ&EA-j90~ukUZ?kb9)gq3yZR>K&gqqbJ6hS z8|Bx=KQG8ez*u$OE@ZxdiA2#TsMxNxBM~<0Tl@qEAeB$2xS5^qz0v@*(d`Wf(&c{O zamwjW}&Ijp@)KJyeHHa;2GmNR{D?-h0yp`e!G<_L;fTqz>U9_C7;wD71kGe zVE^diOi>agLZ&Ivw!DccY{F#>MTPPqDKP;~H{MKW7_#o;852--Jrip#XA-}L9k!?7 z4j@XY7Q<^q_22pGDzkwA5}FN)`o~{?)%7+Jk+aI`_5<=tYzH?3&I)&p5Rw>iMgMni z5K2^`w8XHFJf0T*bkOvI0){Y$26T=iOUVmNHZZ&pB)&e(hM1WMZ9iCt(WbW{U5LW}sU83Y;S(U{nBcgR=oea@r=oe~*P>?itxVS1cbjF|*N z)F@zusIkyS8K1(vPExa-xMJ1ti~7bz&Ofdw1p6>iya92jE2=gR>k&v_0_K|7+W0{O#?~U@5d%>CH6gu-}!RpFd64M;Q+640*?P9t}mHsZ=W@ z>hf-1J`8M;Qofmw&s0@vGSi%db#!~4A6K0|SuHxUDLg2Ka zCE9YC?g#f@I5n*8nf?@FKgGImi&Z(ws=TmhEbW%T#lI=lg;7mTx6y?Eri0VKSFrumd^RGJNbNe zYz$t=g5>be3zrK{it^;me8cX9b?S!Q){Mz>cUvu!=SeH)*s__iDBNwvuTxU|Ic0H<40y}WEm&EhNubrM{-6);MI`pVv`zPQ#G z*ZShrm!iIn)VD?IdyvC#Ia4Y!#hk;$w}wsgU(Da6)%}t>M7g(aizgjamN?!@Y^qzu z+0@$qDoe9!yib2acAAm==7Bg^sZ_*<&iF$hBEC`(5dfB5oW$s| z_@VU8h(^e0&v(S!j2%;_Ta}02x?4u8zb(=nwjEC9D&s;^w^pbB z3iKM1C;!_2f9?Ojj{m=o|G)D8|9|j*5k^LdJR>5RFK8fR6vUc>?BlO5N}kg>RoAMt zkVFrbPvdBkL%Sze?1(ZS2PeH1)}O>OS0@6{hmcNvlay~#BX5*Rl(~}K)2yRm=#wd| zE_5CnS*?lA~WUm9}_FPvS(pAQ3OTVgQ?>CcKl^rkOgI$JmudaykhUvGATy9;L9P8CrUrlBcB)>0?- zz-jZkBiGU*WVcSvy}W?qa{F3Yx0ugvOsXD~ISWAwUHHn`vFz1!>M5MJ8^p&T`)rEZ zq($jjjN~UQ;)_P?37>A&Drtn&1A8B9{t1E>}0A!zUn(vAgx;B{elOI+02n29_v>7sx<5nM_l>%5qPAgW3y`%KDO<+*DTWB z5}SqUBZ2;77e=L@U-EkTN=Q2@j9I>Ch8UGes?vfBUyZ&Q;6v<*31>@!Q7O`@v3yDc z%(&8%Q2$N_wM3b<+Ah%Xo$BDwaI0;+JU|St-H6>Si3Kw0uq&(WL2_r`EVbJHiGoyb z5tHKae(FWz+{Ovne$xC2TQmnE2?5@|&vAYg@ru2Zbuj|E=#vCZ!4a3@Pow~`H z)?yUT8Ry!&t&2E~y?_qzEs93Pcg=y{y_wfV<4BdROEzrIEbnWvye1Zae#Hm+r;#ww zzc>i!(Ettb!@cWqa+OBBfA|61y6{Pw@H^n&CUlQR_(ATUK$Vg!?`M2o+VmuC^65j` zGy0J2Y42NhOwgWYcb@5mKhh5Eh0BMSkJ&}i3mr7*yj(;AmWZ|?-SF8DnigHeRk|zC ze|l|q>OA)ou%y|}KDE7PUo6dB;OyzjM}Z8E^u4uK{OPV|Bf0sd&NE%Fm1j2%YkSg) zziq`IcMf#D8p&N0Y24dwS@C^V{C9NVYlCvr1~u;8FxZM8u;PzV+?cnr&sr??Z~4;K zP5-;!m~CH5!1bpM4R9wmX+r}WoLybpPa3nKbPq-q5cn7#{oo6T>%iH}(Y?-$7JXG& z1?(}=w5$Ig_TC0Q%IeA=&yavYBTrDMsHky`EwR)kEw*IAnjtgrjLt|}#bR5mt8Hr6 z+8>1(WvgKDnISyC$7yLRU3Rx@`EA=RyW1}8s(>Px2$JAyq^@GI8q_Lrd_k-sh?4*J zd+xo@^UM%bTH9^^D<3k?+kH9r+;h)8=iGD81y0A{evVTX`C3#}v7AoP9nXNmu!0I& zdj+Mxd2VE{`&h^Gr`7F^bYtU#s-T;t>yoN*{|I{KGwhk|#ncun6M7pZ{gY^TEb|(V z3kJQV8XmE7|H(D3=c>YVwM@~K9td4y7%!;$*fGbM0nu1?g!Dvo;O{a(eCb63p^7y$ zetSK(r~y7G!lUN#Tw28Q$m|UbhadDN2$~yL3M?X*u2Fh%doXs}0In#>>!G?P^Vd9p z39CIk+#1ywXz~$^&0xELV9dlg&X_}Z|GAOd9J`A2W`Y%i&Wv#QnTMdUuc9K2 zv!7R{xX>D3W94Ro?f1?)CfpZn92k@Cizxz3^|AUonpgDADL3F;Z^f*#96LwaKhL4D z&!DkAdc6My?stJUdByunuVmw&L!UkSx;6gM`o5)y?XShXe}A;}*D9FA zFw&eJUqfW}GV(+51c~`f&+k`a{TEW*3&1Nq!R?L$CWnD@BTu^rI-WhP?&%2BDav;b z0hwLyHzDI)nqcd;6$^A=0A_;C+|t_y<7o*r>5*!*>+5J<$smn9^}E9dpp^Xflo~DH zyc~>h>|=PK04Fz;;PkjD65IYEfZED^iyZ4gh-oGA*qxYZC}G|wGtSIzb>3bmXLdO< zVc_)sH-?1Yp1!Y5)e_YCm)j6=Iu();NMaBq_iOp)d~eEr0Pagr``oFs&i5+tZse#v zh>UpE-l=F?KYmA!?Z@++sZPcEh^Yy+1f=_r5~MKCzvezfLFzTk^HYljDOKL6epE?O z>a* z6dUM33a2Mhx7B&x>ZOkn1p!UZAGefLc2lLECqmm18*w^BFq_eyawPOkVU6_Ct>{}x zlv-Zf3&uL}BBQtbYtZePeD6vuKpQdaWs=BuIE4)|y+ht(+zL#)*O0?vJO5JAQQoV3 zriC+zX@If=Jr$D8V%UBic@?AAo2R8PnYCdJF;h1DUkKdZV~Mv+dpxoaVi^4I{uaHK z^sa$WcCVhh|62)V&G^tux6KgtZ$oaDqOYTQr5yI#VX8NNcl^uvr9AdL8rNfcGJb2> z9~8*sh7#FdlQ@k;_S>Rf`F_wVR&E}F9|quydghHP0e`fU!*11Redz5gNx<`i2D%w^FJv z!G`_5wB$q}ELVD|r8GHU$#P_gb4^GZd-NF9zt7=HX>9CJ)&g#KoYFr76sLbqUe|-M zAB?z`rS(V3??k@Q{LYu4Li}#5&+lr5-_`!E{4OL&`TSGnhD$$Bk}{&y=9VV6;(DL$ zRRN);Y>y`>h1uTGe16~A-fdue5XF|W=McW(WMBVZPdgs9rzCujvuCJe>#?wk0HIJ9 z72)<)g7hI@P=t!Nf9(Q22f>(kK`lA2DK^t_zBlnr4E50+!$}f>2({I{ z0FzM_zCnZnk;`OMC7n}+&S}z<(O^vNKD*;ZrF1^x-q-QWX?2g3D4qA1@?@wCy-cbu zW^?=Oa)?rqPM^VI%vRa5UWs{HU5{S zu_*GCu{i5m_5l-!DP|+~aNPR_Vx+vBo{{MI4VWl4xGH!U!3v>W=uuIF&|YvYm_ zONn1jLN?1~mPis9{LgN27Az@4puPO;B{KgSpBOrbYD96hOOj=t0WWm6%n^qhDIu`0 zi%%KssAx8-kdFqB!0X3J*k$RDrt+IsAw_8anpxCQ`^}~S6P<|Fxp^+SQ27QXkOkCX zXxO|)p~DmTg;z;U32z~KT@g9blc*C73u`he9sxiu*?+3>!40>WB`C38kB{(B(aj`& z)&8UOS!meOgm>BHbUYe^Yz9H0+rrZUauhzXeqrK&9xi?r*El|{_zigsMz7*CozokE zENrHoJ`R13eLB-8=x6$1517yX3Z&sT@GtZuc?kTz{|nB0#)zZmZLmuR&e0T0;Bdf?5u^X$c(LgyDs~42`Ha4K{-ab#^sQFPwnq!eq6fN!+NWps%oB1IeME z{3RZwl-@IOr&9Hvgj+VYF2~HcFk)=n`%27^0=%%}?h8@pg#)>EY-PgQ)kY@KJ)J@E zGb^!@Q)%aOlmtMr2yhg4`yppH58N)Oxt$1;4CwqC(8|diNuhGE|AS5Gy;{)mq)KXb zo#z-99;xM`5}K|yMR~WgYH%9H6;Mqag`yA-*Ty~*1=jV=I0SH3XH)uRB#riUR#;gE zhLY4+l9V_`cwLF(+RT=16=-BVGiV6gn$ksZ=QmCQKiLGuUN3oix#f6)y(MMHgfl0X z;0Z|G!%KB;zIy6WPt1z*C~dhcnY zg`-}hLM(cSxJbIsqR({?rq3r)nF#&v=9uPK*e?I}3`p(n(-L?P#(?^E$-;JcdD2~5 zw5V4LQy?@7DSQIBV6!AWD2eDLd(fQB+sNGV5jmXxmt$6Zk7Pvr!yu#DlgFftWpgO0 zX3!Mm@4W_BDXe%t3FMVUFVPJ_VmCaDW8Xw zI18K0((@QU8}dSaBhjEcQPhGSU`U}RuTZm0P*aU*w+>6abu+;bQwZ=GU+Fc?a^ufI z4sZ6Vfu5CMi)N!jLA#3>ECs9oP)@RdCRqO`d{<$_6fyc9;mU6iY<*NA`OwRFUjHKC z5x1@W!@a9gL000b{iTzsn+c|y( z>)_LI03Pm$!tpAaV}WtV^$-GYASXrkGJA5oCvzGDyke)Suo}T`Q3-0VMKD;PFK}?` z^BmHL2B22*k@C0yi1^!MbDb8e1Y~bsv(GL?PSJZYiuzOKKbuqrYWt||ZfFI}in`pV z(bS{lz7P_3bTRV22wo#ER*4d`$Lg5=#h^;q$JibfHF8lW5pZ~)g{6Vg>?O9@)h;BI#MU$Al5`zt6bnc;=gxi|8;^hu@&?7@M`)TwqeNpqe4S2Kuy ztSePuyo^1jk#?u+<=oCYhz%>|2QgzzZgFBE>e@J>Lj*Q71Z99e5!kKWc$B8o6+fpIs z(eIy+_2->vqB?n4O{2kC#hP9a0kEh((htr{zZ=W|lP7%Xe!{*f+2d(tzm2!3Oc4%m z0Nt4yi{=+h?TMvks?R$D*pcDN#3$I{31& zpsA}#bD1+&d@>KqS2y9 zI%Bofzyp?s7)e5DOH|9m|Igst><{fiLOEj?`$ORbkpg@4XJ~4wog&M#IGF@=074T{ z13KpqFlpgvU3+*pY$2K92!~;1Z^FAJx#?`ayKDk33`ur$)M+TQvMrK6FY*MAIyT0O znA_{@f&z*IogR$352BdNsdPm}a4;od6tKa3Bg+zOz*b}|6HrVh;dN5&JjGkEXWNr% zWA3iFyF2Oql(nVYT{x%sqJd1clt7F~d@*@KsM*|3Fq854a z28;)0FHto!@Tr_x(|ZO|v~FZ8%hG45GV`N<5T_>6xe2X=En2}Ufk7n89^%mxo!MD9 zsw_Pz+IMe7CWhZ305tPC^aSj2TB}l--K{VLpgJpeD>74y_$TQM{gMxo5K)3wRa)6A z01jj*8y9)q`x)FN^Z9YS_(h{0`RZ4Y3f$FsFhI=u_!c86eo_Mg4h|>JPes zA0@xOH|9(^tEwi0urSgkFcY-dl~9f_A;xNYrbIGzeg!L}I-|^a8`*_{q&Bn0*+{(i zGnTKE<;(}VPDLY~o{IE`qRwwB5#2V_PNImhED&8+(&OZq5G6yk&5TxRZ5I$0(s!g8 z!GKo#E7f?yCf7rTRA1?k;&_U=U2(TV?V62wGvSmN{j8qlN)E(U`~u?@r&-S&11nEw zyq%Q70DWZqF*nr%WhCa#+znYnPruHVMh@LT-w4+SAf?K_k}AXL6=c4NDrl{q&j}9z zp_F9+DXBfk!uI<6gS8zmyuWf#{>1YzG$RV9HTE;gb(!6#SJXt1z)_cqwbA=d%o$fRFKBkSa^!rY4gd=mV5p_~_L2fHIfdF_5dZft^ zXRI7O&7sxz+#wpF4J+HmN;GB@Y^rKtgP^a%3tMUZvv3QowcQv1>flXSonsCdnmDGQ z>T!5l)hjrppzPuVi^=`Zs2J|JY9EC51I>*nZP11l*n}8 zdTLVzSpL2eYfIF9x&YxT<71~V&Ey7$`Gj9BTAex5d~y1F(qn*nr~g47ff*nsje{(J zHH3I9k0IDSBi#{am>r{E3e!aCe70P={t$cX_Vi@&%|Ezl2gVyV*GmVOc$qI-*~jr( zn_bhNEU~vv2&G#s>9oD|pYb3C^)AQVAx2jDWcyZ5_6~ZN7oTAwm=?C?hYY1r_sQN1 zP#8A#+c1a4qKL2#&wp|WN(WG#YG98YXJ$n_Pr&me^Nj7Bjpm+G$4uxZqGRHS17mdG zjKvg+C8rb++-N~1HPExoSFG(Y{MOD4f;~QmkrReYVr}&P2Pru8x_1R$5K^b7%FRib zjQ)y{iB+vCgmcgyX<)>A8)DKXxas-SPD=$W9GtU3+G4(_8{FE;tRVYYa#?njTvp8I zrEUccj<9ghAPEZxZI+<_HMp3nl_3*hpSti8W>%(5xZunZZ0M zlLN<}vQM0*q<5hwKLZTUB^iRL#FuAn?>kEXuifz4JXEj^u_N6*(8~AW;Hk&#wsjm^ zoE=(0Bf)yIv8S~CL_W({D}w)bhbORyd|;0q)IN;$yhSh3Dib0to&mx&sK?Pspaf;$ z6u!j}S+H?lE__cjA#K>KL}JAyJy{m`(=%+Ei7MDT=p9Qs7PEhnKQ^-jB5A%Lc4h)6yp4 z68x8(B>3_nqy#62{R@H#4wrqQD5@Z00IbK{-`;}7fZcZ84hk1YL(M6#BQ1ez9bdmK zyDf7?;cG#Yus5qOJt>AYavrl{V|^S#d(3?kqQ34&o_E5C(=e_elHY>$ad!_q!!JY917?fasYTyU=QL>Z6(`*gz%f*0hKKr_FokV{vzi= zdO~Z)a$021B@e3f+PVWq5j3bserQhOP+sixQ1%z)G$OS~FSG%roHz9;z+9=Vgmn^c zrFZyX!YbiRJTdc0=w8S~%Irei)f<9xJM`wY%o*5DFbl7NNoA)=x&8D5mzvEIgsiC- z+fsb~DfD&mMfz|-ZR!<}sc%Y&@t4@I$gMce470ijP~?VXDNQ?w$N?lTsdH8dXM*gzVmKn zK2r}Yq&UC~!|iNLT?9uWarJV;47?#ANg~?V(}Egh&^5+Z&SfGS$~XBj`h~_1cvcS} zS9T^zAUNW=LIDzvmGNgP@b?$?A!Aa7C6lyP?zs>WAi&z*t(>P+Trnv;R(>m62RD*< z-COfU#9Vo-Z}0s#=G0O?wjcNm@cotY4U*!mIG}uq>Iz8t_1oHRmJW)!KNjRmr|s*8 z_pvLtFjLuD6_93tzx4pfV)T}bADIuBsuZ`wiA~ZL6*_O6&%a@7BHY$+YlJ1DG zx+wM?g%8G4qFbP{WTDNqeNC}QrW%5|aAF+_X+-gJsO_cv*C2R%`eSBK{#%=N0~Vuh z(w=!77nF{TdedXBvxC6b_W`5+=Q|J$1JOLCLfIL)?tUgH)$v~ejB9p;91&Vd{|aLzs><{gJi*Nb&V2ocld zcUadKs0TBZ!4q}%W`F*IG_?xDF3Q+$&>F-X0q^;tKmJv@Y?$FyA7G1k$WkHZSD8w+ z(^4IF!NHP=dhjQctXTknLZK#ovwF2?3+p<>_-Eh`&NFK1jK9?r!LXMjjr4k1Apb2z zDX{-q*&f_TWI6=v7$~+0BAQD}uKkW4h%Q#V3ma~3uBD6uFxN;cP&m|^_(}#>L!`NO zUm`GuKAKg<(+XFpRC`V2YzYN2ub4gM=7UvH`!ZsP=1_Gk7biOUWv)S)SRz=^oygx@ zD~?8T9x=-os30D|k|-4_6}vE8?BV|L1#G%M%>)$4{$$@HK4d$5^XUo;zt1lGOsQT+ zLOBQXp;)}07sRRHrD$8VEYIAIpR7*}6>i-A746w#2C92?g0 z(L~ntuZ0~U`=65EKq=Cz;6Si9Nh@Ow{nsAPLay$gWS8sZb_le^GHcMihJT=sE8EsR ziczlFY>>q8J0p+HuO_kN8FAhY?5Y^Row?`m4k$-o!u{!PShTU8ymf;Y!tp zk!%6Jy05!=#_~4?0r~2#=)tRo9oFK{BT3Br1yf+rR3h9*-auNj)uMho%{&v43MTA! zDd(qiaDmnwbet{2CLj%v0hUl<@0l!T5k#$NTT*qe#;vBea_w&JW@JxaiM_OLeyJ3= z4*(FJnEMJ0*qXRjurjb`K*dzjnVM)&F_KC;Y_{KG=f^rQtTVlrV?$zfJvf)OFdRSn zMWkO=^0kK+_?NmvpLsdf41*w}_PZ;1?k!i-egHg1orBnX%c$F(x!rhA+{WCWzJyz> zW3xJ-WDhQ|<5%`Ij*6tuh|!VwRh&hEw*sFM-@?Gdy5Q!z@ZHWYW2tsN&oYwvoD}T7 zY6gQmyVBioEg*QkpTk%)m1z*H9Cj2U1lGFQW1mY^y)2>=za#!TUmCbQ(8v~yad&^ zz&>@7a_GLgonF@L1#cOViHKy}w~cwNf(^eMuY3&P$cg26j=8trg^Rml2h+RD=Ht>S zt!GB8>!+vUz=FJ>8lzF<5dkLhw8j`0riG!?hjWljy=FrY&sUy-%l?5}(F0Yt=xO*A~6LA(Iz zmY65-djh}i7Fxq{pGFnEU&oJMDWkh$Qx>5J@fe6QpapMIJJu6tctP z>U=l*8xABA_(|>)bscV=1B%1NYaZ2i&yb9TPpPqPem7oYDSeW{lX~vEry@OyG;%7| z-W9D_*`EPF^*fPk=2&apYYmTGI}~DCYAnnpM*$|B=zONLk%g6Ij>GV;%v1$bTc||} z*tdjU1{>(AD|Ti^TI+7xNg0ta7;AHINKbjRngJ#Kh_qVeY|u?O8SudNgRLDX zs6h%!&y{pOpCBomM=Fq6OZ!>TQ0BumMM{RxBx$P*Mv%>J`UCDtzT6Mi2Rk|%u^n)-GuajNe| zp9{&G_zDvN^cm(KFnZ!#!W`ldnB-gT;lPO{`I*?I zVph$qTs=N1v9(jAWFBhb94w!UV;-9-SvJCM(rcVoQ0g&-3hX+q^cFm7I|Jo&Pq00# zBwtW%U;X$b28(o$$BcD!;X_DM%`>{3fe74!+@>+T^sLK)K)IT=per2*{r-$PU&{N& zn7b)P!#7g8pBfAn$+(s_p!y@~U7W`(zxq*Yb$252I0Ks54G(2@EAN#7cnxE>bW%t#X>ku{dTkF&VohT(a~_p&Ug($eswTVhYTWDLfmJJ^sB%Z6G>l}N@p*hAvL)qywc1)ID+yrP)5m~UNK?QRMf0M73E3g5K zXCE$f5(@==y_|4v#J11uHY73$P{k|=T49)j5@|&M;eHj{5wPAK@d>t@M~0AyjSx^$ z<5p?Lx=aCb9Fp2O ziw3Ct&-=JAoN3s@I}Lkzr-AVdLs;HMG`9?#va)f>!bYD9YUNJ4-`HEpPj!81 zFWFJ|w?P)zGxWL@cuZ$1KXEbW&t_Ph3=A&8GK5Bv#<#V0I{HHKJHI~KdzyhgE1N?T zz`)%MVjF(7TC##rCx90J4``7PYz-g?)qig)Uz=6+Bb?szUi?vHt25cKyI?ElvjAR` z9{K~*!)047#uQK3K~+9}0RQk(_?6GnRmS~1n03+@gSQt>HuS-O0p=qHeM9HGi5SxM z1^Ft-6kqJB;Tl~ipx{#5n{2I}S1DMqy)W>4rck&ev}_axuuA#Dbjk_%NXUQ4V0&=Wj&$S7dOOjXbnFK!K zk8|+D=JUPSCnr#IJ!z`7Hu=e;xz?SZvQ1Sy-58LS+BdKR^ zR_k42pR=+HK}cAVs0SM&v%btr_>*(iL`F6fTh}5oW-) zrW*MjX9nKZrlZRg{hCxLVc6?S3wvH)>OmT4&+H2vcm%XCz7By`)>Fwj#+&6sbPh^9 z1A42^;X`be@f8Zg)cRntEvk6EuUR>ovg8|JIiiS`#*7@ji_5;rhJiF@u!o|ECZGpJ ztYP=HIF?9FXzV)fQ8E@7SPSvVsNW6oM>DXm?J=a1D8JDrH%33(<@3;Iz6%fLFck>} zK^**{<;y3Aes~@t2S2Sas?QW7h`KQULXu$b2_msUNQefZKtcf=uABfKh`k-E%Q#75 z&#m2d0nDQvxYQu%VWRCq)6q}ZZMNUPC^*m#Of7@3%wm2OtbY%rKc(b{%NicW?5S{P11=jVOo~@>p#cCXm;HQf{*&! zF76!1(h$E&;2g=1qBh{87wa77`&+Vn$%Tyudd#XyO6;+qhv?m`of#U`3V>-jHua@H zjGi(^p@yF8PAKX{TDu$eM6DliN1or6KEI&--gyaBgs>gjRU)s0v|xabL#1Wtur4gd z?7(EpI6M#qcSBwVQOyHI(Q#}-FunuyV1DuGS+8GA(rghb%0Hvrg!`a!t3pioP2%zB z$LWAV)5;XyLbypQ-KEIKPS!mB8j;P1X1?x+4Z@<%N>V$7H7*=sfk$~0x~Y}A;`YqP z>^uzpNPuEjLZZglOuD^-d@1u-6aY8E9OZP)V-J<6!t|v3&8H`&KYDkE^vfdsaggu6 z{weqh`U9K3N#Ix<>yldDr9WcmkIts?&;`IWO1mZKZ-2dH(MyvmkhI9qt~3i#B0GtH zo^1G-^5iI1U0^QG{uC*^rt$W<6xpmcT93U8#<}?i4$w_9eR^^DKFB-n&C9y+%>+K& zV^x=1)d=iVms^R~@FZWuubhM2d^>MV2j=-5He;5IZ|l{Ql%-O_k}dCUXF_o1(8?er z<4_y5llE>{B-r{87ZwzU$yfQ8hWj_@pJwp4Yj)u0D^KEQb`O4LB97q5)NcI5U-CO{ zrRq2;PZ%*6NLblKWCRt>ik$GJ*CnWHH8Udqsa4Hl5HHiJW}yruSIsIIq_CP5e*R^U z!%7L664Oir;}L77h_-D?uSWcZkr(mMw@HwZ^%!j~S$(5ERysas1>=)bkBm>X+K4zh z7!YPV4|URSM4cOI#|_Q2B=Wc>^28cIu*9@~6~-LaVdG2C{^b~)r7N%y zlgA?>I1B(^fu$m|#`K{XnnKXCLfvKHr$95pUbHnd-lR@r?-{2%EwnyqFWSu1;F1Pj zg_}TL!2AoI2zdZu>Eb)0?&A>j)kq94Q%i@cWojLs49nQMYo39JE>`U0JK&owaDNo>zYqEYBkPYeKK?iN$I|~r<@&29XS&xbqv-i ztIVv}rKN&ZK>B(U<1)Wsm7YY3I|V(Xw~t`PXHFaaWpajQdRzCR zL^}d`89o+jiyIW2xQbng8%ou8fgw%|6qrC%KGa^O?F+UjuKy&g4Pk$Abl)3Tb6me^ zc}NyWe?VG8!jzkwHJ7t9KAEIwAJpr6LEEhPop0;4U4 z9YuOk< zC#7(gs6{e8-q`62h@yhE{0=7d#@D9Y)#Oo8?~Apgu*?N>zVYLXx<8_^H0s4_5#6IL zjeC1N*Eso?aNEjI3!++7;=(skYi+D{ED~1nJs(cNL$!H06%V8MfZ|B6!+r2wI11n; z7jVKavE;2FY1oWSbDdHwYqImRmy1b7E$pN79#C9SJo?wOSojACwMX^}%T*5O3XdFL zV5V!lF$l20<|RTVR1j7(FfUZ>{tAv-#=i+P#SfqpK|X}ffnsinF*sL zz|=L79?r%!S6tcU3%HeDZGcs7(H4%P(EJ4_!`+fh`S;7hhu8L7lwPs~TlAf^AM%~! zRf^KVIQKZXT8v_jeD^O zYj$m5tM3-#wtoAqZv}tPiqf%`#`U5r^0VGY5Z{7p_V`R7X?0GY z&!<3KDWMO@9Aw!dZS2PlcKHCaoBA>E&6Gob2gFxjQG+oGR;znZ!f4;QM9NmDL13sy z-E1udq*VU4+V!|nI5jg3m=gJ60!g@S5|3n}eC**Pr?u|_VrRi^Wmc{YcXyAmg3b@8 z%ihLX^DB11Be!VL5nPBs-bvm7UauhaWFH%i9tjUDleDDYd7~py!B-3 zmYb_(L(Mj=TqB+kL}(UYdLpc#5L-Rnpo$!arxt`d48SN%o8yG1oCe>))(ND6-| zM?)iA0CfexO8DhVu$DM7UkS$mYh`0pOG#c~E zBvC%kY7xOx?HnUB=E)v+2~cK0B|23mK!a`Ag=3;yv$ap4*CJ~o?(9di*l_T7qzIjh zb&mGh<{*J9Nb{y6I@EkX2ETS95u1su?Cn6k!lTF`=+*3JQHT(R>UC)g8leITv0u5N z8fSm$_Qboq9PxTCH%Q#UA8Tq?i<^1?tP~41bUIc@Q;v()S6FTT59tU^79SJ&AJ+Ec8H?2752rjFHTAe#rFcx7L?I^5336FRI$(Tlx#Y{_ zlG}scLOxyq8jdHEyrku|s3+=VYdHl)=yIeWf^*ay9#isvy?B;L;S398d=x?8bL|@{ zkqL28%*eA=Z??bI{>#)A)i|j5!zOvcxl2Y+S$cL9J@_O_;6Le2eP6%RS+EAf=y9Ne z$vMKHCUoJ^l&$?fKZaMmYw#o8)k}|ceCef|?%h0F$EOuDY>C6oC@oCCz|}aCEuzs0 zu5x44)8*=k6bU@;mdmn!xvUU6uUpY9c+|*MsK#*?c$ol2lQ1yYh@NQGgMzbx9f)miZ_1I!nRyaAj5ugmLXUK%Y2onDeG&oYK};5#$_1goe8#8=jA^nJm<>RiD;JJ)Yk zxTgwoTvKoz6I> z#XpgF#J(WuL-MH1=h|O~6{}s~o&+Q)5opDpW4^P$OTSY-V;LiCuT4fAM#(TH(jHLI z{B`vKeU-xVZqF?Lz0w=genfzBUaF>bPkG}4jQT#B>-3|pu32PjaRHq)0R?80`pR~^Idfl4c5woV_7;u16aN!Xc zUGx?Q^Son~H&r;=QUIgSpYka?rC}YRymmDG-P-41YofiVldaUwACOw;e&v&@*JC z+i(j81DeFhK1%OgE=4i}GrIRB^^StDMrruN``upP_t=}itMMCjs*m5p(u4chA@mmZ zUm0Vf_COqc2<@gyLu2Yaa*x1h+cU?S5ru7=+z>aj9r9%&e>Z0)*zT2bpYVRfDF@O3 zXQDGf+*u;gpMxM4PF^rQjkCiwb8SV=U|aJEYqa zbyn}j%SgigHQ^H-Mkl;`mYIwa?!EY!`B8Keg`&b=!%bGKFbMtE?rC;{N)VBvqz*(^ zFMI+PBWWHqBNUkElvbi{*dGNC8VhV4_H(Y1X2Ad*T$mKaLbCnm+-eRnkr@7zKyihw2r;8@C={+Z8|reb zoWa;id5&s2p*F41N|6UZsSi+QivX5x^!c6ae*k3c3gp&xayS|_6=}K(FDxVU6{Dr1 zx#yx(3h=(%XCCYzisWo>we#I(db;4at`l{caa28;n+Aa4)z0?F~-Oymv!Vjbl7?e{h zO`jr0bgdh|3zu;)QR6ZmJ&JGv)tt^@C7pQ}g3fQ@Db&!Z6orXdIPS&o0%B%33)%-V z<;V&Pxd_eh90GSU%c7DNVe4ih<(Fc4rzh0OD?_MT5fa32$~I`8RfAF0jQWYIZTq1Q9X7i6U}ucC$$~t2h~G z%TI=g-It?y$x^?w_hL}8+{;g3f8+Tmk89_5J*8p9e~N1~rzD(Dmk}D8o9S2&531Gaao8o+A31*G{2 zRFr`E4a317r3F{7pf6IpcY3cy^YuxySCd=if4T~cBBah^HkpJEnssOpUolYn2#8J%>wcZtlx05&LV@vZe_U1JFJhfF|@%3MR#blQc6?OJ=Cm*da5FYnTx4^9E5HH%w0}dehbh?BBly+v1ElELo0;DD zJB$PM>DRt|Nl>78;vkW?O!3t)q${--LUa7BLOEt1z)>C2NBYtyC+=CcwLl|ARQ z&}J_~6WsB26hi-U`C7(+Ae`;+WJw#=1S-`5yh2*&PzjuW9)wJR>s%(veB6vOsP^2> zk;3YWlJ=p<s3`w_yOUaC&|_+xtIZ=zwk*uX^L zY&wE{;5czoj{(JPr?#KSPaK9F4^;Q*4}!^6PwBGZ05GO{q+#+?I36!X|CdvwJqzTe z;-^}VHS`!J+Hilq)Au87Kl|&CSzdTNgxXg$9^MI_KT!Tb$8!iipI#1A|Nol&ioW__ zM3Lailtm9UtrU;FB7XC3^!EGW_b~L20XX!W)^bdDVQ54i4CsG8=1a{ci~4&!3-#Js z@!3X5E-XKl+jl&?@1kda`j1;`?0viJju)Z6`F5BPdsX|p*e3F$Q2B)CUvE4NJTebp zKdM%2!!V2eI!1WlA{X9IrOndV!hd)OF?}l_g;S%6y8X%@(cK$N*~Rn6`(59AnU6+d zDTVS0ai1QV zj08BE_<)S{&o4;n=#K8@!ueuPC^S)W#Hiq+9Oeq$ca%RXc%&rv>mBWRt3X3hx2l#0 zuMVUwM!|$QzgHU?jZq?S91(j2q2hXh!Nr{x-7693oKcE>JLP)lBVBOEgqvSejqO}NsSNSVoa@Jxt!EQ6a8|#5LRotFdX!YA zAsZJmECeD`V6QXwDVkof--OXzXf1imE{bIUCfW}(3v0pcIL%LO@4SSUt_76KM&K1f zK=R8S6-Xt>p_P|zO1U3YB47TTFF#pM4;!X682x4xrvNvy+~_{sa6Y$kyYNUKXHz)Y z_#uU>lBcj_cg1c1NB8bV6wlPEc*IqRqFGKq$~+zkd#B(DaO~Py3WqxQMPNaa!&Y8} zZ&EZWud;HCos4c(ey#y>g+E$rZy8ER{_5gNAmDpQiQspLD%)R`d9Jq_A3_bBxyrN- zK>8I_TDi-ZEx$nTadi5dt(z{ut5DWuVcb-Qa#vfq8s=8GL8I{vWd+zN{0&|{iQxCe zJz`~hp%4frpc9w%eg&9y`fIJ5w&QiE;s9p9yH$_;8`7cVHYr(y&gGNuu~_fo+D7Ni zAuxvRK)IR8p#t-y9pJ(5K2Q(yImlPvE&)ErAVs!4Gop8zyn}6#Z%i5RT)G%u{9dxQ zQKK`NPbt)~91D58_|Kho_~7jviWnOQA>kp^>%Sq0zLkAV9@@_>L-$*4&#F&r<g-$m961pK>s802>(bT1Z|{|GT~L!YEx>0`v`DP+amA5pY&#vtMG>98H4~AKsQ2t zumqrF0xoJ`v}fkS3d!dv)`|#(rVJB5647=W@ikF*uXR&95hr$C#8yvuH`FRbo7E+- z#g8TF&nNJhlEL`U}H%79qid)yMl5wL{|12Af!Y-U0V~T(#{-P1$>mXxGRn$ zz{DTzl^Z$c%dBM`H62Ux3=|9rR4|rb!GJ%?1CxlwpS)D+IDZ+AAz6D+<_ z4&XA`%M-I=`&~&!htJ$@(0(x*5!oi;n$0_zJ6bogO7xNtGVDvDTrniTety(>8;4cP zphGN6oNp$#5;?elB{g9&x;qa|CX*75$b~0pfk)*k}N59i#7Q)1&X`hrKppi*sCW-U6CoCu7-mLK9 z$eyaV5WD$?+Vl`lMh%aegRLNrpsaaLfXtnqs{%;%uEIBc+X?gqP%)FnLpmNnRLQdP z%UF)4)s(BYcc9qH%>S_!1pNxQqRv8mdmAlCmj8ks6bzowAUp*h*-FN!a^()?RHodY zOY4dUNAC%MSAkx5De4RyW##q|IOWYt3R#0kpp6YOx9kE-&k!7Ogf5hUq|7Y ze`|@m>DoD9(`yk@E>=5N(-lFa%7)MAEIzfebWfxd3=Av#DG(5=n2-J(7zw9uJo9!4 zRt<66`#t=~Dl`~5bC%f%XJqAe;Ps$u(IB=vekqe>vmqr`bH#piytm?Vyo1B|Rk#Eg z*u)O^(J+ZA9cg~0PZO{?A8ziiWO{$@FP`eggyjX6A+-nz)Q-fa4x($$;{;D7}b3P)C-v%UbGRC$Q zbt0~{y31~O!gji``u`fNZC!R`8$$Re?7Gc%WTzxc?8Bips)r5^vD&`LaiQb#%G@8d zmfhR?1-u0zl$77c@O#$kJ$A!Ww(|(8K)l`69d<|0kmB;~NLOzkXkG9lKgRwp^7$nf z#c`^Odm!a@>3&L|-05&WL{rcfSbyrbn`1#JP>aFM*MDuVjpM}blnd_4I@?4N$6Z(( zG4?K{Unniab{~N%03U^5Iw&SrQ!!bEHRNjfU`BDVX7XjxOpH=;33ixvS?i(|Ep8J=cC-@L zXl0^ z{9q-rc;&zvJnOpC6BsP;N(_bSK$o`ExWV&kfM#Zho5t>bg9U1xIzA9XEI=)-DTx+ zEXRYVKt5Irxia343U)qJ0(;UufMZxv5d`$#w+VrN6)U4hUF2=NLhrY0pmm}mSl(h1 z<6**LV45?oTdEA(o82Y&Ob;h6KL#1)62P&c6pjE0HeaeNd}MHp5Rgsd*fmP5m;Os z{U1^92V^r44}ZL`oPt~CAAJBKTMFMsk<$-bWI%0&k0rfpx^YGbM)P3wr8~{Y7(!xi zc?gd^th?D^_GIL99CF9pz1D z?OPG-n$y)@+d6COUhC4KpZq!wpR=v;?Qq1{YkhI(+4{NP?l^d!efmCocxM!xCVe7) zaVk(8W8+LL`ndN=8{BqmKJlMmSE$sR8rZmyeO8v14%TbISB_ZH`IC{?aTLKA1URT& zPwrzkbja13+M(8zWW6GA9l>IG1mO_cuR>SK&RqHaUdp#k`Lx1y?s#xD^v*Mg9fF{N#!at; z4ujgXeNoy=D;DjX0tABf@vmz2C=o!o?AJ3MSw?>1wY>v=S{Bl-urD9$53< zQC=*+EP9C}ieigInt@nUVt-_(=tIHRLn0iY%Xjt*XgT@>n=x^N)gUXIz>U^^#1JE! zb76U*KC2BdfjMT5yri854xn{$IDjHnP8}yhF;T#9LQ$WrK)M0qHEQS*IJY9SJHxHR zLAnNM%*-d62lw%UR~CW6f{wIe_{bPe=N&^#r%w$icIlFvhq6&#(y5?f5&iJ;)~vk3 zm?#Rafdj3;H(_@mq|%cAjAXZEPA;4#51M2V!G$jJ_1kdH{jh{{9*EcW)CPWUxIH=5 zjgzkzZDB8k49Ze~T7NeENp234lsa($3e4yhtd3)p_DEViN>9Nk?NKBH?1BThd!pDB z>#OKI800Ya^h3%AMDJJm33uDz+(`2WU!LR|K^y`BL;C)=Vn%(cnMKS9a|YrqlM%g$ zvo+&xzgcZQWO%Ce@RZvTmC-D?3TqIY&$jFNY$|6IFdj86hUc^Q4*z=|+|q>bz)onU zRMG_DZ@(}66a;Ke{#c>$eXCIsJOYdPCuxkzyIM%0`*(V_bOu;6Ch&My%uV5theH|a ze!(m>-?NkMhIUX+(!I5d1k?#dRsECxdLEk`x(thjr@J~2q;!7<=0DCB32<-Q`;L_3 zwXqz#u4C>burj;h5lnkeaNZc3C|}&pPniO4@mdUuCRy8@m3NPAiM7o0aE z8CVU!!*sd6h2!ljw;~=9So~zE@!GoCo88y&*dUK{U*mUIpeT%S_w3tYU)jyCkIa2s za>^GWGA%OB|u!pU9mhD?@JxrHiC!W&_tp=s8LE-`T#T`{NRX9#)|a z%S@rEDvMH-eyaq-3W#GR)KEGe6+Ju$kge<@WY&voe=GB=66z2+hxDMlof4gKsf6ZP zy?m2Yp%EZn##|iS6K>b7JCGR7>%oPy%1DP@1d{2;h5v+PKms$>=+{mK^k@u1k&!>D z_EgnI#pEpgtf(99;f6LPuSP4Ok+vsXrCo)`H|dQ-1Z07x9kiVr;YfdNbl)_+Zbo$i z&fl%LNa3LK580h@xp(h@x9x6UP4K3n7#M(zs$ykjdx%k78WP@O7E`}1F?sPy+-!h4 zJYdD1D4edmWTv2=HB7LR&{QS7YiptdmrR1Hywg^gOf(EjAM4*wt7PD#g<}*f5GA)j zY`<*w=3;QITng3nUWT8jcVVNme@J=(BpWOHAgY2xYwip9!eTa2$*$i%(2X|0?k-K% zT9Q_dq#`s|J32E{)LXj**_^F!)o%x|2*zY(kCp-hlm$6@Uxl0@b&U$@I`bXtGG5h^ ziyCuK&p%6HYg_RWRTM6fB-KH|h;&s1M7Ss)?*5>>&q{fNX6gMTzA66U_G1l%3W1tm zu)o^rktK2cjIM+C6;u?U@mSltam+xs<_dzoK-|#&SRg((^A>yjWJP=@f~ejSi-%-T z)GW6p1!#Eo!?;pI@sz^xzV6|2`ZbXv@~IHFo9Qp9p#RQFBzTt!WPIhPj}aGwm@W@y zL3h7+!x=y4B7Xq;UB3JCJv@@eptFi)QtUkdpjNg3;Gnn)^LbkC!3x@z;x5_HpR}g- z(@*Iy!II421F~z}+ygk~k6vZilfMv$eZe*A&FH{~AUO6eL{@HW_@25Jj$!}7tblwU zgHa|~_w2Q2+KUjJf8fTsLpSikB5+(Wgx@kn*qLsGj(Pw_|8CSG`c^1o8Je=5KepAh zL)VT8iM21*HuEZKs1Jr>xa)u_s0=Zf!(s==uA8t4zDv z`>R-V617o54grV4aWfDBBaJavqlz!VG?c8JleAXvuiw7!H7-M^^PhRM1*_e2 zZNO9xYdKk2t`}Lc2<`NjTWv28pZQ~nE&IxfMX**6^bp1gXiP^1HU&bmM_iT6-omNa zBw9F;-$udN1@ut-J$xn>){@e-;&$PnTxQu--@eqVa;$A`m1By0wQxT_ZADE&AGTMu z*|xB27#CgZO9h;mH<11@mJ^07wbnKrwALQ87(&G#LC@5R89U5(m4&>$}Y$W;xCXd^-=j? zEw=E0Fq0fqg}*>57&y%aHjJA)kQrkt)|IGx5RaK}iIU1tb}j46DtTb-zH70RwIk8+ z>x4D!*8vQ-D;Sk>TR6K4F2 zWZEWAfT>Y+;aNmqMjd76(3JubTD7{A;ewrB_~pNX3Wh3s(U9iLDh(+EPce0whzmr! zEH3|k>M5;mKXTw)Lv-&Z{FPbBt*%1=Vy?$h-R~0sL6GZ>kr!k6dn=m;J1SO= zxWgG&n6|9kiJ(6qmw14hY)@{QZ#hHpP8O@Sz!2wbU`CASpW)(cV5j2YA8=`LuAhSv z{t+*1@A@%!(w_q&$vp!I1-c8RAC;M7Bb+curP*oU?>fwCt&QK);yM+$g# zp#vPA@72%oyIg0Sdev!?)Z*E7*dR8*OWoyqY*(ic9lfQbZK_>IS=s$~(>n#in1D8- z1hf%WZZlu`;O#vGJV3e`kg8r>pw6`qAl+)fBIW_PTEbk8t;;^-%3O?BD_t1`NTouk z;MGrDhwZ_uhfG22J1_MU*W>7Mol*R38p>9Csg>{0Vl-$5Sc%praq!@W3ugsm91JLd zlgMpH`Z?kV&hTn0Bq#>f(tVu%s-^@*2EV}<&M+O;x{KztKokAAnXjyM+pX2#7lP_| z1`cJf*maLt>qafc;=`!voWYpGZs?wixA&y-Q>GVM17I)@88XV=ges(i&_G~=v}5Pb z#k~-t5a?%^1pVX){S3rNK`Dfc=qOY~^B3%iXWOGz;{KSs)p_2Ex%YHDGq&T+)0}7a z4Bs2`zE2{u*4;{S^QNqG7u=y8eX(75ahjmhPqF?qKdlbtd+6k*5Q?+fvI0!{8g2#<01mr+?z^cLI&p#@OA z9y!=?5S*Ypve)MXk0?&CNpXV56ekc9060O#Vs|TYoJ&R!wUT??TM4-<4RWR7o5Y83 zAF2}?EBOgJq|_gEaQ^ufuplF8Unci(Q}y|$<&4BTEY7Y<U?9pY3>o{%`!DDVNT>!CKqy#^EZg_C{lPuL;$CZbcUms;=apLM57cV84PQ89UoQf{to#Vr$Nc|~kK;tv1I)?u(xCbEyv$dQT zA`CjndhxasJvkm_`Q4bFm+)?uWQobiT1+0?ze^Qi13Kv9THzb#;^=DMH=FVX_ywXCi;6+S?6!I|A_lJ3m)5Vo_-4(dp?ABMbkp`C0mk@!|BKdl)k$pR3?u#974mllxq6_Z9j^|J5ICxs@^jD%CZ|FlOAoPK}gmyxI3z59OE*wC>l@sb5Y?<6;A za#adlXRLh69dOT@b;Gde-6TUYSGZ#SE&LV+O4|xoGimE<=s^T`>a^?j*^!5%?k#t* zp(Tx(>W#VsYo(9J+?^fIp3-sPw9|jt@g^J)pKx|X_C3*YaLDNo;XyZK;Pi*lkk=yz z+^68RT&oS4pWQIioR)&@zakEr5_H1(|lVc4hUMG?>WJSvluGCsRP^7XRr*l zCJQA1i>~m}8Mvs@jwm@?twfvg#I!~Bfp4*#4EHmjC~Uhp2rI)JXii(LbzhoG4a#;7 zRL&a;NxLw~?vMi{0&p1LGOXRvFaka37lX;qggGbaM&w*Tj<6PU_*bXIBddJ;b zzYQjb*BhR)Zu%TESgW6cLUj#x9hwZyz*D z2G*_p$e+^|qv+kcIme=5V^KF0K?&vyg*KJgYP%k@ z2Q##ySoHnP_cDXnT=cEZ@?7s{kkaIevtlP_z z4ZAWg^wMG4WUkazHkKV0zFs#rHRY(sN z%$EGLEM1HmK8C+@0L@(d8Ga%OL-rnJ*!v;}?&mma$9XjCIUNI_tLp1O_}j2ba~_bF zxUy{nS3xD8|^0ymTwBCOh1nl~MOqAhv)ASMaOAx!h`r zl(t#j;1F7AWjX^qiba47iT%Tqp`o|HKBM?AZ1V4^zr>D5Z9d#L{dj)ozIhrc*eQ?W z>bD`>DeMQoQ-u5a91juRggw1m|6C&d!_ezV_w~~LVUf1(pH@lo>YyDnBmebGSEDIMz=C)-yM~ z{}?ajSL~l7qW=%@UBYwTnZk*0J^zS&F8Ig#J*Nn@pO;=CAHl>5_I?Qk)BETG@F6S{ zNP4XAK-7f_3QYSY1Aa1RYdMn^O4i$0{)wjib;-p;{0vC^O0jhwHKWI-1v_`tWh=))rK_7ZvVBg>b{&wU-sPpvJv})_DIQ`1n|T zyLJ@`7vCuOM^9GSVH~|k+z0v)@$>uS2jhamHIwpDGs`NLkIq%{(Wk(Rekb{;W$82E z_1p2+i$6L8@^26R_Jy9!`@ycv8*XoSzV+oJ?s*AK@&jm&jFIcK2*j0X z;o#)16oH;WijWBOOFa7D!yI0TK+LX1pl}D0-z$0ODab=u)kC7e$ zdn4r`c&zth0EgtEc?2sr*GY43Cuy38cL|B`_>`yf;ZOM55h>MA_&=Nt6Qf zAtdV4=R3>mVfuUrd3{j&ERof3_35)jRtJ4TLk`g=n^DqZMs{(GQynUn*nEdXUxB|gc2Sw${#GuA3nf8_|YF3|L-m@o>eL@ zo@nGnZ{qi@hun$ZHzMP!B_gAe&j!*s*S9Z?7-!qlpH`CE0mM|Jq_z*&fF$7WQ#A~y zQoL@R^$0{W92GJP*O8;zXxE~w_;gqr^X1V2Zj$N4CK;5EPz#g?Dx`DHz;{ktjMe3kjHV17hB-Z}(ZcPQSS{i!f;)aS7XJMCb!qo>kZd*MLG zuIkwE4r}eOj-D~YyXemFIb=Jl3o;)5KELhtsi^KdT>U_qFq7SvDT)?k>;tU-9M(U9 z^?y`JmK#2);Fl7s7W+kp8}Q8R%?7_`Gk+cP*M=>aOVNr7Z1ws)a5A#OZ+R~T#8z+% z<^PEK6U-lD{_}iElW4sBFT)sUk^YGSsrKQJ`c$}swEyNilwa{aln=oHHT;>&r|(rh zh*wkHly zH111(n)w^F{Hg4*B5zXGgp^6KQ;D1+Z%%b9ie$@2QLtZLkvvRMcHVfACn3{SEq)!c zsS+s1!#CfT3d8a+MA1H+IsMGeu6vjlc%U17 zc@d=~UJY{?H-8V~GuBd@v63v52s6_O`dK;RBhrw3kOivn=H;FY!gg;V7|@EMU()Nu zfwrUd7oWetx(c6#AE7?(BxD>EoM4dZrnwJxzU$}P5k&BsSK}XU2}ovPJBaN;uZKdf zLru_yHFFML2v9U`9pyEBok67GoD4%BBd~BYOw$}ULc3oLPIH={z?Q_qhg1L{$!GGz zd5C7l;*I^1!tbv?b9}EnJia?#81g5D@W5X3XH4IJ*7#Pj#}TXcy>gO4xJXhD)Zdqp z82dqZ{Cxl)M)P}Q#7Bz1?f&#oG;16(OZ-pu?+5S|Pqc&euR1#m7XBj;1_m9%Di+P} zJA{4z%z&RW*3bv=y~iP}T%A+`xdm0XoYR77y_et(KSMsvX z>dQ0oyqra-`PP%Y>%n@Fd~dP70b{PzUz*=m8Ct=K#J*bkonfWTdbPE7l=WAmMj%YC zSc&&nXI@?pd697(eR!<3mbD4qrSQo3h_!Y`#M*R81otQ7ehBV|;NHT0Iqne^s^Jki zfXn!MLa05BM&cl-mWYb#3`P;_P?hiD;nSmv&o1!`-?qK$Q~-sjv!JGIVO{;sAOnuN z9A|qIcbF|8*rOXsTp6#i8#dqYY{JWoGanMp#vN>!mHjn-qt3==dHVLlc*3Uf$p&5z zLFmUzSi%z&t!Z~{A`OXceSC^%+rFeE1 zl-AP$5uzjK)*~T>>8aM*dAcJWD z{{)jwkwA_afUXIogeOoDlbIwSB;b8o{m!Kb;QQgf88B^=m|drxI(f}1)C#?a&RZx{a=7{3Jx~FDXbHA z<3$<9OE|cSS$}fwZsphX5S&M-_i%^DuXA^ne!1yNudNj~Jkt*U0{(*d7~X{y?u-g= zgll;hR=P7Py$h?|8CBkeRql*x@7wf)ePq8oW0YR+fj;J4h@A;YT!X}T7-u7);b&eO z>8?|LaYJ6>4{)-A&bEGFnEyK4szu#J%R1XC^=)UHfQ!#t+kQjs7vH|DzlDqP`IE1| zG9C`p*47)pSeE{9%6%C737id5!~BnG#Tv}VsIR>eN6md&HtPv`5eRrXs3e800q%nc z`Pyh-c~3F|@5rX+PKRycKckp}jeiUKCLcu{;sjdl&Gks%!B#E7^ergDWU1RY0(@B~>Z0C~Olo zi|j3H!;aV^R@;j8G&QaN>Ny^=x7s6*#GOc%%LSZPPw73{a{oO&fBv@*>9IU20(%1{ z0VxeaEf%YQFVgJ;)bcL5zcJ@pd+$W-Ip_ZGcklha%lDDJ)?D*3=9puSIp&ySj4AW` zxetZ@Y~%N~^W2BW+M!e95+8%BN5H#E5zNdh~?+y?@!CS=rv7YLu z#wD(@Ql~zhoSFwXk9_DQfRdnYi7%$sEt4K4{*=8TwN8ymVoZ=B;^->1K0>Vt*(>su z2HB*Z@?1SWRNUGesXjD_So7N%gJ}d;lfF#@km=~F1d#R?2hi145wE-&-ehg^zmuce;HEBel6dDQ<)-?WQF{;@%ex=lk+t zrMj_9s&FFCb4y0??zAr%&5upo+G%cN;`zLfYByyFi`{BBJ-$fljkrHsB*5}%t=qmx0Cwl>uHI#Zi5GF>A3KPgEtBb% z6$?Ji74>ni?tC1WL_TUTS5N+|k1iRZ#_(IotU`-8k9if}x7#vOu~q%Yh*RxYII?`1 z&iP*i5w%9Lp=8bq&5ESsh3x4d{72H<_U{WO9K}Fuwn|9ECo;|wVN^9~XU^_ywRm%4 zB+&1uu1eqB#}}zGU#v7M+ZRbw<_I4#f+a!V>mZQG&dij;s0Mk89Aq!f9n<~bQhkPb2xxf7^(St$+$H+}CfqZ>dWJW0s@=Bf4PNEE{K}Z|k=-UCu8Wex#fkyr+HfZM zmebQ%`^}r~ACJy0e{mlCL|psT-3HcrsXjX<+@qf&W|Zr=^S~+o%Vh-^MZHetF)vqBgPGl=_&7 zrQHSx%GWnp4(_8bS)%4W8F8N$j4P)P3AqA?k2vpXu|q6U&jGH~Lx@fD8=H1Sy=Z?d zvmZN^7qg$rqo8@IcrV*cGm%EO&7aN96${>rz_P@+Tl23O?qj=@yk%eyQyKavjABAd zkt=sSNZWEa@XvNrKZzA7_3CSxOIE0B<CG@_t=ngnJ%-a-1tjR|cD;>iz~- zdv1`n6;PtW7-yN4Lx?!j3URrqPX4C$9dp!!lafG0g+XV!8|q1sB(;^{u{$M853{hp zyP-~hYnUXz%Hk`auiX6e{nNh1SbogXSId=#f~;n*5VtH#EWL|fXS%H5et^T&yMnbs z{LEJ1y}6%XSdy?<-o)10dUTO+*t)Sgta)9%+3_67VEw=2I|plfR%V`RLK;}kOY3_1 z)NFQqPrdw@m%Gi5N7T!|^3sx=-@5)MJbWveXkGtrJlvK1cI*28!NcDszaDVQx^E=E z6g(ru%;0&$XQ(4<2dQ;Na`KtsNPH1W5g>fH5*0xisOWmB=@M#E9|w-P*)dhTX=T_2 zqXok*g@#G88PVH81#OaRXWIzteO0`n!UkmXZsjIr|bvW84gLlJrKW|YX+Gur_1v0 zXX0w~$DHY+3^Ln)J%$}QF;2%sosaTW$J|+?IzyjQTg~t*$%8Ddqhd`vx?@)2AoQa%o%3X>{|ePxsfB1x=84z$Xeyd8!wv28D^qf96BUKG z%>QZt+h9=LSrcYBq5Z08s%~GA*&gzN{$#Naly8 zYqXkoYu;e81R1QZMe>?^mjLcTr-E-7%kK;F>lqv;CV-`OewD!o>HMM!pPqxn)Ui^g zGnw;1|A&Jp(K#uvR41x0h*6fKZa=yEkmxpo%43eY2t}d&^^4#Da^DfcEO9F#(wX0}~s}j!%Cq@k?fhFthmGKbJaHv#zQT zT@=c&f=)2T1Kv5^hXw8^C&uzq%P8xdHQ+N2^8?=1u;fva*;ko)z06$mLOGsYtGAT* z5D2_iAV4|B&on1e9g^}gjTH_Zg7!0viWYK-es0@+LY4IUIlhjwq`I0m&tU%>ZYaO)FaoYuqiTi}Y6Ea4u zNsXvFsMm=Ie~&dY`TM>Ghx2PEpoBsv)hiI4C!{&snO%n4+Io3ra{Mg}Z%{s?huy(N zK(~S{;`IEeCUM0ZeT2Y8L;#gZIsoFDtqSJ$t!8@!Qlw_p@2QdMx6Q?`1pT6jKlM{5 z$IahxgEyIzb%ldSZOy`8#F|doB?>@7Bl|a$(BLl(xK8#*ex0eQMdso~)L63@NJtcD zTe)x36o7KW#1>JW;o_4eUD&(oLWpgjCpcjKTL{*_H0s7B#}4XCmXNDzjJiUj`Xwg2 z*?u=jRybzDZkLQ6f+y8eO@*#C`cgP$sw!*(L9}`qswbLsXpe>nR8Du~q z=u1SJ1OuXSA|uMw3|%M6mI2@55FC4aG+IvyhV7x#Wj7Iw+I*ZNeGdZB5}ds zYzUFuz!9U^22iDkxMpw7*6iQpaQq+EYPQcta$t{kSG=kCPI}Lq_d>HEKBu z|2i&qLG_H~dYSITXb_wQH$w{ya<%s0x}0e(CA%0maQ>C3HmpT3o7z=5g*Ehbz^0j{e({=2Q(ittj@?-P813l zh@@P|3eieut=9QP@C~1*@gO7aPD+&{o}wK@R~As%_ydYx%%p$R)X$}K8KS+ReN*9 zx%@V+ebNk*0EI6~$J|xYa&Dk=;EOUQvCwCvYQi*e{PE$u9}a9;!&V7w4@w8z4jF~k zsYdcPo&}4K7Ik)PBhzcK1m`_tKgc8araOS5+UEF=;HnX4 zRWIp&t;C(u<6^t5qsma-x}lX$hh#uh=vE|614Y?U8n4`vp+(60c8FHuLqwd{{T@Z! z3DNL7rniMuS5-mK2*r5_jii_Eqcy05dDbWlSqiw%rCE%86iyQq7V}>LoCA$kBrw@; zjF;^ubUPzLovr@}X3K(}MZ6}Xezi<=L2aaVoaud43o~lu%bcF0KiR_{^Hj58-kwBmhx zU7y9afKr+g|9XKy{^1U{@n*;Hzgmz<@D7U_V*it%{XDZ{Io{=#J|9yX)TO*j?_}4b zdgp9LGHZKXbhZiDWWNeGtG+-^9UDGC07m`))_^j4Pm-p{-G}N5wo~j$MWDV zoZ2Xvkn?`Q3ZZr%LbBb866M2y_8WmD7^QWy^we2vyQJUN792y>PG-`#-HLbN5o9(xO4#dX+6>{Ft+~9=% zZkZL^cBZJU(_dZ;f8nSR~Y`fg;eNQZeya{kQ_Eb0j-c z2)l_muHl{Y4ywkFmCUH( zmAkWnnW%Di5-J~C6+s4Z^u;*kY1dmp_Hd6mtH)7~D-Dq_cB0m0T!hWYu(J(M)27~r zt3=s`f0M7-VFQ^Il%waBW_@Clli61as&X2zMSDn7obMKP@Uf;f%5Ep~R%wAM#}Owm^-ff79^>>Pi^ z!n@vFeJJymsD2ckfIba_mfF~%Y8~h*m?ZECD2iWfrLc`64d#LYlkNc@rp3T+mrP3`eDj{}R&jA9vpr0?5DiOI#nx}P#xF*^X zI!--L6xl8Pi6^v-6)}H&sD-n+0+ieCSAthG45}spe-L9{ z#aQO#@SMs|Eq&(da^Ikf9Y-khmMC)-(zq^qERr#EWifLl<}Q&l5r3;_u0Gek`$eVa zYf6j=*%S+i+pnGFz`lE@QnYGermrbNA{uI*S87Z`9eI^pMu7@_c6>-7BKC{sz7=$t)?z>PYMoN~K% z>a?+NXI3cyb5w*5O)4%j+n*&(>85?Ps9rS`j#OvtrrDJoGwwDYi?Omn0WvLp2BN09 z8g`W^45S(fOvWoWZ8XymE3wSJkTA!7zW`_b64* z^hVzg6A4-F^g=M1NNNNer7%F%^C?kkB`%RZ3S6pk62?gaJY6S*jO+*vjbOY_LTZSq zhOVkW>FQ{~Kb`=`X0>Y~M&d(gftCn*gs=D6Fd4G0ZhRR(KX>I74ZvSt$5l z$OoCxZOdI4;#^k&N)0~KhI}-GIBQyGX#6MT;bUYx?VN=fi{!dB#27D@+oqI#r4im{ zE`FT1sXbg;!>lC^8@Z4p3!@?E(z^jT57st!n4F5Z#Xt;qQ5d?$FjMcccks_(Fkaw>nedi* z8?&FIy3eeY>f|mAf3BX>6)HyPm9_j<@}`MiwsYQoYZZv_VPW3h;S6EmhV?|S$UvgEFIy}ftURmFU4C+8+ zEEj$j(E91L{zA+4iyyPJ8 zY>t4I90CzsAK$;wT+|MZV&0FAkpef6yt#SO*>FnU^L=z0P7g{DUY{SD&W68mi^1t4 zv*X1#m^a+dZg%wWq_Hpj!SvSh?lTO50=S2Wl=TP|sVT(u%H6lP`Ip-;`0YL~SjQfuQ;= z`>+#|Pv}CXhpcegGN-3GmZ*pYR=Sh1)p}eq)Gq1dCwXJ6>HAB0kjtif?NVj05$@6F z*NRKuLzOHy$`&m#%<7(gC%KEVxwCs}zf&1T^-U+|LHU@oe-V3#ycveJ-@W;!nzWph zCNcKpqM_;avT&4M)?f=Od`MdwU)C_yHyO$svjqMKh4z}GEM?oIHVo?YHD^EyhyVEX zp~|R8ixjl^N@|@l^)=f?vlt0K(+VM(i~h)qo05T!cy;xW%hs*n(aQAW3whV}?57I> zVw>>VhD-UZdM)>5zKa~Y$gis9AwJt4m(hB+Y_UD=M)jiHORvKx)BYxG?=Fk>mZYTJ zNchnGBdqm8SBR~@_U%ov>YN%0AHF|#$#iy{qq1XKCB)4?+EA?rzblQt2O(nxmafn2 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�zr>ecA^$0|qPtMzfY81~3PDn?MS0@I9av}F+< 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�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

ffU>dc{9V$3*piT=m+B{%ck} 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 literal 0 HcmV?d00001 diff --git a/lib/raylib-4.5.0_webassembly/LICENSE b/lib/raylib-4.5.0_webassembly/LICENSE new file mode 100644 index 0000000..ca631da --- /dev/null +++ b/lib/raylib-4.5.0_webassembly/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/lib/raylib-4.5.0_webassembly/README.md b/lib/raylib-4.5.0_webassembly/README.md new file mode 100644 index 0000000..d35ad25 --- /dev/null +++ b/lib/raylib-4.5.0_webassembly/README.md @@ -0,0 +1,144 @@ + + +**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 specially 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.2.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) +[![Android](https://github.com/raysan5/raylib/workflows/Android/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AAndroid) +[![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 or ES 2.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, 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) + - Shaders support, including model 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, OGG, MP3, FLAC, XM, MOD) + - **VR stereo rendering** support with configurable HMD device parameters + - Huge examples collection with [+120 code examples](https://github.com/raysan5/raylib/tree/master/examples)! + - Bindings to [+60 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 it 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. 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) + +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 for details. diff --git a/lib/raylib-4.5.0_webassembly/include/raylib.h b/lib/raylib-4.5.0_webassembly/include/raylib.h new file mode 100644 index 0000000..6c79d6d --- /dev/null +++ b/lib/raylib-4.5.0_webassembly/include/raylib.h @@ -0,0 +1,1588 @@ +/********************************************************************************************** +* +* raylib v4.5 - 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 4 +#define RAYLIB_VERSION_MINOR 5 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_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) + #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 { } +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// NOTE: We set some defines with some data types declared by raylib +// Other modules (raymath, rlgl) also require some of those types, so, +// to be able to use those other modules as standalone (not depending on raylib) +// this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (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 +} 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; + +//---------------------------------------------------------------------------------- +// 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_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_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, unsigned int *bytesRead); // FileIO: Load binary data +typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, unsigned int bytesToWrite); // FileIO: Save binary data +typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void SetWindowIcon(Image image); // Set icon for window (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) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode) +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetCurrentMonitor(void); // Get current connected monitor +RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (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 primary 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 + +// 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) + +// 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 int GetFPS(void); // Get current FPS +RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() + +// Misc. functions +RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) + +RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *MemAlloc(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 + +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) +RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write), returns true on success +RLAPI bool ExportDataAsCode(const unsigned char *data, unsigned int size, 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 +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *GetApplicationDirectory(void); // Get the directory if the running application (uses static string) +RLAPI 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() + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) +RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Get mouse position X +RLAPI int GetMouseY(void); // Get mouse position Y +RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement 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(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 (Vector version) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out +RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point +RLAPI void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points +RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +RLAPI bool 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 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 bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient +RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image 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 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 *fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool IsFontReady(Font font); // Check if a font is ready +RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount); // Unload font chars info data (RAM) +RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// Text font info functions +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// Text codepoints management functions (unicode characters) +RLAPI 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, unsigned int *animCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI void UnloadModelAnimations(ModelAnimation *animations, unsigned int count); // Unload animation array data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI 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 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 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 +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 +RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/lib/raylib-4.5.0_webassembly/include/raymath.h b/lib/raylib-4.5.0_webassembly/include/raymath.h new file mode 100644 index 0000000..8eb2849 --- /dev/null +++ b/lib/raylib-4.5.0_webassembly/include/raymath.h @@ -0,0 +1,2134 @@ +/********************************************************************************************** +* +* raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions +* +* 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. +* +* CONVENTIONS: +* +* - 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) +* +* +* 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) +{ + 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 = atan2f(v2.y - v1.y, v2.x - v1.x); + + 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; + + float dot = start.x*end.x + start.y*end.y; // Dot product + + float dotClamp = (dot < -1.0f)? -1.0f : dot; // Clamp + if (dotClamp > 1.0f) dotClamp = 1.0f; + + result = acosf(dotClamp); + + // Alternative implementation, more costly + //float v1Length = sqrtf((start.x*start.x) + (start.y*start.y)); + //float v2Length = sqrtf((end.x*end.x) + (end.y*end.y)); + //float result = -acosf((start.x*end.x + start.y*end.y)/(v1Length*v2Length)); + + 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) +{ + 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) length = 1.0f; + float ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + + 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) +{ + 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 where v specifies the +// normalized direction of the incoming ray, n specifies the +// normalized normal vector of the interface of two optical media, +// and r specifies the 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 near, double far) +{ + Matrix result = { 0 }; + + double top = near*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)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m5 = ((float)near*2.0f)/tb; + 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.m14 = -((float)far*(float)near*2.0f)/fn; + + return result; +} + +// Get orthographic projection matrix +RMAPI Matrix MatrixOrtho(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 = 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)far + (float)near)/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 }; + + 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) < 0.001f) + { + 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 > 0.0001f) + { + 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) +{ + 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/lib/raylib-4.5.0_webassembly/include/rlgl.h b/lib/raylib-4.5.0_webassembly/include/rlgl.h new file mode 100644 index 0000000..abfb52b --- /dev/null +++ b/lib/raylib-4.5.0_webassembly/include/rlgl.h @@ -0,0 +1,4740 @@ +/********************************************************************************************** +* +* rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* 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...) +* +* 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 additional 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 additional 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 +* 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 attribute 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_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) + #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 + +// 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) +} 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_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, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7, // 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, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z, // 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 + +// 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 rlDisableWireMode(void); // Disable wire mode +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_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) + #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_RPI) || 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 + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER +#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 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) +// 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 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; + + // TODO: Add current normal + // By default rlVertexBuffer type 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 +} + +// 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(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] = { + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, + }; + + glDrawBuffers(count, buffers); + } + } + 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 +} + +// 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); // TODO: Filter message + + // 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.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.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_ES2) + + #if defined(PLATFORM_DESKTOP) + if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES2.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; + + // 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_33) + glVersion = RL_OPENGL_33; +#endif +#if defined(GRAPHICS_API_OPENGL_43) + glVersion = RL_OPENGL_43; +#endif +#if 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 (change flag required) + 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 + + // 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 != -1) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, (unsigned char *)data + mipOffset); +#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; + + // 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) + // 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 != -1) + { + // 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_R32G32B32) + { + // Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB) + if (RLGL.ExtSupported.texFloat32) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL); + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + } + else if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) 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 != -1) && (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) + 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 + #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; + #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 != -1) && (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); + 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) +{ + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset); +} + +// 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) + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset, 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); + glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 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_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" + "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 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_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/lib/raylib-4.5.0_webassembly/lib/libraylib.a b/lib/raylib-4.5.0_webassembly/lib/libraylib.a new file mode 100644 index 0000000000000000000000000000000000000000..fe01d7de3f237c5b6100064c741d03341672b7a7 GIT binary patch literal 1288642 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

Z`vH;`ZZSCCchNkm+}r&@|W-ys95(GM0Uoj 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

QD1%y$4B!&=DHI1LxLaO4Q3y{#*J(b5hO z$wlQ=yx1R9Pk|bQO+MKpIddm-ZcbkhBf<(;2F{%-CW3I#!ffENjFgP{1`zjM$MM$<&0xlxp;^0) zZKA@n5H=2Ps59}sIl45(x9)kkieH*@+`$XH3E3CcAbWJMw(*{&YQpgqhNV{b^=Yjz ze@x3mOg29+f9(`HXkb|R@xsz7n6oSj%OQCqf|0QJ+6rvNDhetNnhh+YD254DAkkWI z9c9PBItnt7M;VX}X|q+nUT`HvlQPJz7K88ABILp%0rAa?Etc@2xlVFZ-Wm!oYC0VT zmJ%3L+O@7!c5F4jr{&8A^84E@V_aB5xI?+=@Cv90VM&>hz4w5~euAuZ+X1DKVT5C! zMy=>76=gvFT@^wFr*zT>M)NKV8tL*oY}OFKu@;#5+^*{D3`ujB7ag7U3Y59#muO%= zkTd==9T?x&@Aw`(CSA;iX6XVJ9cigh*Bp1{;WLU`l`+kPe=GJJrg`u8B5;~yD+x4o zHXZIOFH(LuJ^V}~8K&_}qX8$#K@FE-O7(+x5b&^{`)C&5nO2TWjXX7;rAr(i#vZ!$ zv8lRs7^+(-xENq9SI`c#&GnsGLihu(jteY%j9wDPB84aow{djMHevqeJ6q-JKG=Zy z?kv|*I{)8Tv&jJD0(O#lZHQ22eungG9t*nEFPTU3P#f^&)g0>}lU|_O@XH^7H8B&Y zu$f(p&AdV3X-+vHXUp4Kn&cVo8c%oI(|%izp2+*H^O*u7{T3Ma8dh6)ytl>C-t^y) zKF4gU_n@flb`83!XkE6S#RA+XI{plPHvb-IY~tq0n_K0dee2qqp5?XQ<}Ofs57Zub zdrOYpn1Q>XYGku!>mU@L5P`WcJ_W3yf%OwsAjl8*)G@DgUO9vwd5I2vQN)~vgE(_` zWZKvb4o=h%P2O@FznL2+uyfnSZ>}_c3-dx0XTZ)PW}u59X*f2-%)lOG{M8s6VyHu# zk$MWf$cPRkIu8S@O@4<=^D63{qlC{lNUGu_Gs1&<+Ttu)8V*z_xBU{EcNzbU;HL4Q zkZHV3+QP=;bWpol)3Vg|0IOpYH0ri6ueIN@$Iqj zSQHsYefOr6XO1JscmnHYFLy`UEwEalsOP(%8e;kRENSZHhVlC89vFg4jqY=rf7-0X^0lIIx~!pEeF0wO+zn189M znh2t`NOLGC$rGX@D}^XSdt@`IlflFAU2?E-%8o&zgm0rY8ql4BQze@h}h;wpDU$-$L!VrRygfoih9ds%98MH$I)UH!ca1`hv5#?FP5A zZuRUV%jwe}Hu`keaz6N@#s?p@5Bd!d(c{b(9)?H(=@!uX^fb>@tk+0gvgkmB`9QU2 zyW9(f!@7C_tp0HW@;i0y7(O933=n1${z1w!g8*sxS-DqxeiS; z{aH#C!Q|7Xj<%b8=AgqDgMd_fAKHq93+KNayyu`TQN8BADHI8@T%om}*sf-VWYJQ$#;qHllrDa$~6zxjM%R4><)Mk@%!|p)ona9-= z<#g~b^%K8jf1tj^DW)Ge&F=9EFkqz8cuo!FTs9kOF~(qA>3u_$7B*MNSVyd-pOa$oL-8s=o73tHY_jjtt zvZ8p-96ro)!6zdNyqvn3$;eu>igHx4U?hTq^E>T3J>aEn6wNT*JXOkiPl-+qPnr~S zaX1B`UzC;J?Vg*cda!XM9#gU=WYL0k?P_#3k`;zK++we;Q0e~yLSdYQq252TD?ZXQ zvm5~j>y}RVN+NUt4K1Tb>*NF)kxkNK>LFMlm5Pt{JK;s!o)-Kt-yxTGSY_kmF{Vz{ z#}gKeKsWh#!jgun)=_(^AAA*~`j{owAEYk@rjGyeg~f~US&s#J5!^O>a?f5qyQis% zVC0a5{-rFAGG(JKHPsV&RF>ZgHZm^09AtBlF0_>+8=fD5u731^(w8T^(8NpX#*xt} zbDKBHjjL=-V*ogfzea^!jJN3pq4T^*&vmCecdE#?m7jtzqePiB2&^fkzGDSxDu;*U zud(?)KyEH_VuiScb%=fdNqjwc1jCcR(JJ5f-Nuv;;?lUz){59ci+F2B+f`EnBc&xK zA)4F~XH>OBn2VNMJG6w4$QEJQ5sOl=b0B85>dkV6)CEYAx}Zq&j0m$Gzun2&bu@2N z1prZW<)BeQdWyEdppVRXT``O>+ca&CR7f?1SW4V1`ua%cKUf1pUfT%1@13(TMBxLFcojc1ySh(584z@h3~RfWhKYj=JJ@vM+YveF*sF3bPI)#G z@DkUAs0T^?sbz`K{VMHgkr$7C6(fu^a?TlD&PeTKbc^HhAde`qL2kw1ku@~2Lou3F zFIDZdV_=?RimoM^TneckWSOQRz~j6~PEXeJ7V6S%RGCzeE>4BBsa^ZerFNV;#v#Uw zEVuLlKnoZ@fR9BgHjFdprAu}D8XjIw_)CXJhym?~4T4js8nsWqMF8NOn|l&euI3Uw zEca-3dSbPno~V%s->Ln?m8629&zZE{h@>oIA=)_CLZqqmlysus+3(Rr1+F&Vw3tZ* zDY9WIqrCb-GgJ<0P6i8|&B7a?h32HuV0N6KrKppJa#c`_Nd(ocr;Ey7RsN>LEw~c4 zzaLjZQ~b)u8*guz_xAgZw+G(GyzuWEqFdgfyHN9o=e@nR@%GMnZ=3CYWcaO<8j`~f z8vI0WS2lU?dm5^W_6yPp`cFU4bSj>laHP4#1qD3u>QsoLjam#AjJb_*b0i)(8XT}0 zIH$O?ZfX=r6j z2+qn?vl^7mLXftF+Q@kg08B1$GUwzj7LZ80 z?`fc2w1PXb%eyjZX>acyyM{gx!M?Gb5I7_{VtgqBx%+hp%oOf^KcrLQhS!pT23^Z= zr9-pPQJw=t>X;PMzDc-rtKi7^Toa_B~EaX}<3MtqjtvWE5Ta3Awiw z1L2rUbBAGd(S`)gnt`)MoST^Isu!d=QI~0}ifn0j4;~v%H&3sb+?HM)@U;tsjjTg+ zKoa=&v}|YCZxa-xF@bH$7Unv_q2USsG8O`d9kJ0W=M6fBqBpNH>R)kH`F?_(`lA<_ zo@G&+W&HklF?#hrkj3wXYo;8{s4MM29uF^wtnXV&4H}x76zV7TPicK$oIS+6D4w%10I`wRt9HXsg8$G=L8k3LnJ|8cL^pYao;y9WJ!}IaZ=3vkp z9kWJN8u*`8jDLYi*-~Q66N-pJ#!SVrmTOg;)NxLsK`E2lqwvPKp&*+n=I|8oD$>c66!MPM zTT0>wlvI>;CB_&Dm00^GU8)`?FfFN+CMfl&@?i2n+MyaNwFjNqy`t&1tLAv4^MGa#mnS3g2z8#E!@Jk%Q=)Qh8#1W`~#v6tpeiY+Hj2aUr z&fSLSBL=_JydVgp2$KvvALynlAin9~GpBNKkNUZ@R}FhU=;2|K0T#F@+%W+&zJsKj zeZ;YT=fBlo{o*8w*xt9NhUFUMSO?E|laif|K*SB$(6 z5Qrk4#_}_8$cT@S0$aJOGDbSASAOdsYL)-T9~@Ho$YRYX|?-yFBA5* zn_EF_HFQ!bW2}Y}Dn-k z%8N;y)kx8|5+Y}b8N9vjMtx>1v0B?a#jqufK*t!1=Z58?AkQ|O&&O`{fz zW3W&)V$pB9Un1E+vPbdV-c>@UNJ17!g~=){YA6?O(jwCcQB{bsY0}Ux_f~FEZDDLm z!`p9fm0u7a#z=zlu?AOuaNgTD{9`RE9~yqUDN^LTlOQa;}Zo=Q1T-*%Ymz&x0c%>&Ct7GqwSg^sZ(bm8xkA>3Gp1K*Y zBI*@J7V4-`FXV!=YR;6RO>r^0$AX!K+##5_@>-6`4}!O&LMQkQ&C3~L*tXa6(Yb41 ztNhfW==`}j=NBUeD2 znllsE6kV(PAAQ*~uer4*8CRCbAT3ap(i}yG{gEVZ-$1mD+0qKaYI5J-;e30jiOltB zdbNGC^tg=0^IJYJM+FiU0@OtzM6FbkK1DpWs(W$;w=*7|wU>%f0F+atwD_l-3IWRQ ziD`PxOv5&qS6Z=)CcH8E6naLfT2hC5(1VgTJt*l#i+l)54b+C~W#Ge%Wcw&54``5b zJi?ln)>3gE<1Z5dtJN+%GkTPC?`oWiz$$CYwWb_uMqBp^;GfU%42&j|oa^*D^U$i_ScV^hcVJj73os2B^H96rL8Oc;+`B5w$U0?!eMTm{%bS#&;Sr@GqW z)kwHzQ*S$5u7{h$mY`DUC+goN9G-3qR&WvJnXbqwzm}y)5uR&xvQ_R4VqusvMCC34^H%XsHIYV|59pJ? z_ka8m(#`8W^1WEfK>3tF=|11s(YQ7G^T8j68YH!+-ae$ zJ%nMWh7c@PNo+fWUx^eYs3=Fz*H)ipVjNGs#lU0kE`{;095u!tUN**`6EW`QZNMy1 zG+#E{_7}vhubljemFWI=hRkmtH8LOn;gR{RBO>!V|FV#I^YS?JhU<@37d-jHBXheN z?JmWcH(H7Ae_EEJmFU)jz2CKO(45Hl^z7N6`o!Ts{q?x#a8wZE4n;gj+7??S_@gyhAatE_LKOD;6{xnhk%A-Vi&DBdG|C#0AcONzX z-togB^F99qBlCSnjm&#~IArd7n#jBa&OCyNj~W#}%B?DeI>Wr{Nm@I2mPbOe2diZh z?f>A$6b2R^9+gE6n^%*(sMY4z+JN=Bq0Rm5XaJe1EF0h-V!9A*D_p{|T0dau)FP1- zrF7-Ob2!ZtWV)I?NV5HaQ|3gtB%_jz6F4*4MxuEc!c~h@bK^#kP2T;V7qp^=tx|U% zxW&3lZbtCc4G}Aoi6O{bki5f59o&yzeD@N?c{g1A<|T^rPQ|ZcB8ci-&MXh4g9eK2X%8w_s%PpARDuq&oU z<^nP7`ZPkwkXym`nbA8QhkT`tD4%v&NBOX|-FA_9S@$z)`JfHQGS{cVP?rrqjY`OP zRD}xJ8X(LFjudNvgSeV)t*83r9CO8%_YoJKly~Vb@k>g1VVN(K<3gD;2y|3)Tr(PE z^fH8O`uxauE8?shrT$d&J_3m?-jYv}5JM^uGD)ufQ;2`TE%U$C{19$7NAiOnRRgLb zYpIMHbkwO@;}7wdy?1OkQW;XKHa8BmiKnm8rl6ozTzP;*Ijbi4gm}6^fR5N{5nN8SbxU%)m3=MR+v9pU3yEtRYnU!6OAcp0*6D%@2I(ro{ zpTc>zym>P!=;sJP2A9mDpFmosvt1q%j&HMKe4%Hbp! zrn8 zNIg=(*a$+{;h>`s;Na~UTulu-By)kdJjUe~l!R161QwVid;BNyyPR9Z?^0Sr=3d1Q z9oWPVyw8!F62yx@cCOtzv`r(*OOlm$XS4mJ_f8WKyq5Mf-2l4 zZIYap+@@a~ECN7Mxra-@s>k%K)DYv+TWWAZwX5KP_>Hw^Ouf^(&LUu=hWtEkzxtlr zZfw0MrwjJx*6;uJBid}la*N%6`>Cfs{S@~s%;;YKVNVbpU}!1AQ?wHMZNxs>DFZ;n zo2XL{0MG?=m56;gxI{69cdxcpC3E@;F?$SSd-K`eH_dzq_;QfdA5N+U2iCRwp{@-| zrUUQO%4N&;4B$(7x3H}dDXHcgl5;KZu`N3&pH_Ex3+v7EAMI|%^*mD{rb-)flQiVU zT(uu<7)}hQxwl2f>2sxx5-Am)(PP_fq|wQI={$>mDRK~L{onko@}1M8xx~w%UNiu3 z1Fxc$ghPtJ>z}c)+0+nWg7t2mtV~Z&9(NQGAVd}+p`seDTiuz28mg^IB^2Q9TcQE_ z91iBraH^J0rY6G!dvpOW`uIwEwJh^RnWSAm`q7~0;e*`9OdP zYLB>iup{TWeHA}0;0_E)#*-yiM$F&292=`{`GoF;M+w)mAla~dbUhT%rRBKQ-FHmZ zL*l`_vaEsyPx1zL---o1@nbL6seFiLM`Ic?5mkaz4?M z+nFB-Jkhp1(2)b#60xzBTcD-o?PLoh*8p+JK>(UHz{fh$i&mLnRC_6O*fzd=H(1Sp zi5kOFXi9hJ0mhuV#*mRI=M;M`y`K9bZn#B#J*fAGbh=&nWIS$=C!7=@{Y+gt9Y9@q zQu8K;VCp=eZ{9B?oR;0D>ua+!(!E@$+~bscC|u8hJ%%rP{shl&x9bzL?QGHC<#gkV zM{IDS8hU9vLk~9qVd|#&RahIt{Ix4=M78xDzQjBPyKQtX4-WA_qD$Nhh6t}%^~GFK z)%*bs1&7|DTN1bWQ7Pf!@AyN64t*nPX}`ZmpQPp8PB^O>jRg^_RIq%Y$(c;OrJ- zd9O9?6vwM-@s!pp0Yp57&fQ=jY068Y4p6b*$FnoHzbL;O7nSPRPMQRT78dsRd^VNd zldJafZZxBm-eVSD4crDlUmWJ3aP`9Fg_aOVbbi@-sX{VoJlmLWH=9 zab`YP+0>#jxUx{U^$y@u)Ad~9ZnHC~<&Vr(8DLQ2~5@{xoMMtev> z`ml|piK0r>Fd0LX8Uu4T_qbt$T^mez&-G4vej39yV5&d%Y?rXX2G}*KU^n4Fk9K}h zWsG>pv+0IfMt@LM@gm`G=s&TW-`{LafCop?#Ii65*gDU=Rj9nEQhNcMo_Eg?IBMg*^H$m>`u^9@j`Vgm< zAKYYtcJxNO$GG021;ff4Qz4rQBaFABh6y3s+tE1Rlrwj7!I|DX%QwcU6E*v)n+tx7ivnt z@dMS2(29&e77GnN0{7;YEG3v%yHyF8qy=ghBUp9)%H(rKwQty0f3s+!?;&AmJmAnU zZ^Fg=3k8;uMc>V3g0}a0@AApXPSe%A*wya+sS#Yob?Zqr?UO#T@7mtt zPXIV5jL?kZ<#4MT4v|M{b7!A!3uxw<^E>97^CYSHH?=hvVBl2e$WD@52CFF}jY%;T zYs8Q>f^nI2RZ<8n`CU_mBrZ3E@d#XQ9N1l(2rw6gs=SEk%dd86vEfjz2fB*Ra!pf;KVJOQQ`@%Lwnz5F2#liR zoHkm1r&2ki<%2C8zl^L3bC;B`DZRX}MXVd2XbTH+pw})dR*+D*P|%og{CPOPIFA33!Pa z9sHrZDl%g)=`I67hZaE4Lr)7q57!9#$}oc7xfFsBlP7;grjrN84I)YK4I@eL{aBIo z!~#fqmN!b=Lx>4f8t=lO6wh;S9(|Ic8t$$mj&&wvXJXC$IC%y2*YtWNbdeS`-&ly8`;(12hf!Twcm~Sf1fp{b%cWwnT;5UkNuyNSLOUEUG)yt4Se%Jy*zB44Kky zzWCSurySiThgmFckf5P3dC;>`17@A5-)`{?nnhKaxTRd(u`W>u#*u$V<=DQ59eJ1< z?MW@;(cQK@;c=^pw?u4+ z0z2^V8SR73lm<*h8;X()0X8gR?l$c9P$SW}V4vd?Ose5uY8ZKGqYq zpy@}Oobev7^E*z1nt|xr76$0?OyVbB;E%FBDp&xKo12^EGeW(=N(#|@!#oe%IUCuW8h41l zyz;{sp2D6qsJ3}YFY$&s3OR?1e5DwwHUi;!zP zrMtf~R0DBd8SBjTzOJX;8yaiF2kS*Wp;Z6qO_X_B$;7U^Y!Qie3sgdeeiLor>RJt` z4BEz~&%UNsj$VOvnA^eYDVgV@j|_w7#Oy*Hu%6=xmC@o0oZhil`Px{UmPx&!Q=B^P zi-K%)wcUG6Vu6oQa~E@?i$%4_A*_h^_-z5Dt%01)4@zW$pIlB!Uk=ex2fj?g)p{-L z3Z{I6EvD#dqph;&>O5P2QJoi%v`x6toQ%rk=jmDMMN3zf$vv@?R(F zht+$Zlf?Lnv139DvRW2X=XJUko+}y+Q&Jyps8^KavAL#t@hJcsR^eisn5&fdPI?@e zxLn^Kwf)LPXJ(rv^o9N)nmwlBybk-|y!wNUNBjVVi20&w+>>DR}Qd;rTT`L>!QVeL$LqZ$b{i;?d3A*-zIiZr0eR>0z7spVmm zOwkB-nW~DNq^}$463Zp)>YgEtJ??_B6nf>xk~&$X^(^N5*ygf%ZZ{lsugr870HC41 zO_j&7i$Du@(n8Pd<#>YDa z+MQ_JY1ok$#9U@`XN8~tYYh&xxlglckqLr(e3^EvO$ma3gH z28zZD99Egy0f*%y`LL@Yf`pI)Qh*vDU^;oem-bmbk#`?U;oMfts5L(x62LI4njRyx z6iA^xu&+h0g$e-bUe*o4Oz#E)!;;Fwph3F#T`ka2M}|wZ&*W~mu5{#d+pb9LT8!+* z?b$K@xp){m8pRc?3J-UF?Is=7u#=n~IJ8h=Bf3Pda@p3UEi=ZjkM8A752hg)eT6mb z^GkswQ*R+!Q)QsF&D6OIv=(CJn04S6JS`rM$)6Bgl~e81D4;c`myM2%QFy&}prfFGr4cwFWfg z9gt%|4ao~>$fhFM ze0pIjp+1_^C{}&LQyQ$F`lsGtcshXHuPo6U-dS&&lzw=j@^fby^>}CHeIZOkT2fko zK9hvJ_XX+8ZufZ&)WnxqwV59Vam~!5ow-=_HCc8|%F>rcI`POsUt(5tB-TftC4G|4 z&<0_ZXkL4na_i2XzH&Blw>P}3%JtFb`#w@+`#y40^_rEd-ERpQ2n=pzDOug^o^EG( z2m+oiVhp{I&309Oqp1)3xltuwue2&V*rr{mp?R8d6VIyi-B0Lt7udjFeO+x}Ul$sz7xxdN(tK%OJ(^?Xult@f z0Kppz0uZ`v;z$58*MYTVl*6X}a=lC!Pw_(04NACV3Q$T?L3`g;7q#jmT^!yEQX8&Cu{&1LxAbMQjrCyZKfhX z43iTUoe(p=4Ka;2!ud9#^Q9iUq z@!qvJNK%hj>^dv|9*=kQP z`&ryTjZ+PTgsDcb)tG8DY&Fe(mbQqOHc$n?u&wsY&v|}gm6t!U%B8l=8Yq8al`lF= z_=#1nIn^^|m75a2)%30#r2lda<{yzibG{vZikVb~h-%Un>|QcpHl}AK&UP&M(WHFq zof^5worWtf*kjQm)?rj>`GcpF?~(kD$!c?>TFTsR$DSnJX=||v25;{hqDQ3*&>jPUVZ>T!mD%A29fKq0%i7s;pNu=Yz}@QE z^7i^})ol42;ZB|{8-FeKxHZKRftLC*t3lVSgvBb_q=g0g784_5 zE4I6DU6YS&YjI3rh;h)y(qL|SR*Fr6^+^9@>W2-+tVrBbtflp!`-jubbV9WA1%K?36*>*-BNx|*PvJ_ zWBr~q>zclhuh(8aD-=BKC6mu8$yFT6oyx7OcFx)kchCj@Zh!MLEy>5j4xC~u=y5$@6& zovzh+VnGQY)km6H8E|x;s*4qQJ8A1-z%JDG1_>--4?+XGqA+<3$I(*7uX%F&fN>M^QOjOhtd{Aw2Se50|lWi z=R*`@`?t=FZY@S({t0Ju;a)+}>bL=5z{s5tkWa^Z-x2n801--cbNSTgFP$yt?!WYW zJvarW#zv?uikO3A$~i)d?eS{|9v@72Y)XkQuC!M|H#c+X6nWZCNiUVIliDCRN!UaP znsTyJ^v4`UJ2j$I?6M+H(nKSGQ>s6yHCv`x;w5zZdcP(TRO|*`evhX_2lVT=L zo@s80&5$1;a99%6lKBRxY-ig0u6pmRv$_x6F64+N-as*`;r?pzR#B6ZgSO_;aDaY! z#c)X3QuM0}x|$QAtiRJnJ{$<5nlVl>+!b)8B`sJAx(nRi-#ZnlLV8zeKzje6N8B?e zo>}vNiH9n5@vD%-Aug;Gk>c^G{9Mw8Lrww*mEe2qoGnwM`9>cS3v%l+vO8?nzFMa? zd9l#oT)|UB9NIq6W6Ntmd|pDM%9>CGl<4 zb`I)|k2_)|f5~2bA0{cfS|Vpdtm&e>s$VCANY!9laQ2>Qldr|wal8FayzMsLvU35} z&A^hZY$E{_^huXzv!5}Y zu>C-Ap+TOn$dXi1M}k>{_2Mx9Wqj)}dl#UM*()p!I=!Zw=8D{G0jZ3T{fRI}qW&i< zwDRy$;Gfyb5UYJXhVs?fw8Xj1na(_Bd?hJ;N=C{k)6x+{iee1grnKN@>t z>1zL*#ZtL}^ZK7EZ+K=59CZnmu~2WN0}N9z=85Fj5O+ph2AUHB>s+O9T3!fhw0bt5 zmc2|hGD7J%kPCG6+9}CTSJ^u7yq%H0!tXZmv*L{O!XQZ~giZZ%QzZq&x~NzY#xmF# zscM%i`N4T_OqG@$JBYgcnOWvjMY_4nU+dw(O0vbH7!ABadUH#u(YtWcyj^xyTx;009CS&6rHEBxPDJNU!Wq%yIq|hZkH^bT8b$ z^_rP~l)<3?5}s_GNpCF1=dkcW+JYZ2wn=YIT*Fx>S9@usNIWPcxURJQ&Ra?b`K7vV zIrU@rZNa6{dHKm%Bu9Rsg?AoZ1v>p%n7n9|s&jF)oAXfY(7|~qW4X>n^LePb4G1S= z(i^h;zRPaxIZHS^|3=0_P3M|0yVhmeSTc${C7Td~=IE6gfUi_ifz?-DaRn(DEdZ3| zM(i^dSs+pc08^I;03$?N0npNfr+S6rqsiwdT?S=-#<8mS8Pg8D=O?4E5+=9iJ)qJ2o@T-_e=%{O!zaxN$r7 zYXk1pf?Hf-L8~!}q{zDW4xD4EY+oaeZy6BTM)=DY(?*b&XofL*UX4v5`|n&GbK}NE zF$&j@u!y>yR9&!jRL~+ zvXGP6T$i?Dlhnm5oq2S{k1}THhB`5$V}fL-j+~MfXQbh(e@2R^$edfJ+-7z)Eq{=e zJBb5bRsMe!=dyNY5s2eD)k#sF%yzV6iR)t4uE2s2II~joB?0rC*%I9v+gL(7?De!F-f6%=6rOO$L zO*T>|!;6Z2#Hb+oy#6?B!iTVUgYhC-oWV_kF<7+)rcT4w>Avkbt(1t(WBGs3ng_Bf zAm7(EcVwjBJ#Tfx@HZ zT3}|}Z&iYY|88b2DIa7rkVJ$3?;xqbvu zVPYGd)do9u*oU!-q9}fyb433nq7<6>V5;x|{;-eb>eq!*V^&gyq!jj^q|oD2EN8Xl^6xzpt?TV z`;5>^@)5uv1vu9>W3ZplNo-BYeu}!oyjtg_x+9mvCFz?PyNAe9#B;@tAbi2P;_PT0LcM2C3QkgM@$JngCj%DXlde7-J^#2*7(mle@fcYI0eQ}Nk=s3WKH?g zNy+-a>EFU7$gBk9>6iG&4|godPxI%95X^@}6U;?ilaDcL{dQ-~38A zGiEBwAtb9G=`7UEU|?vENbBG-W{6#uJHGxaoTKD6kTp@zCy+GI04Sq=akT-Nd$o&I zs>+ZX!Mp6rq>lueAVi@#gjlX^w zsNZ31)m*VtJ^_kKzqM=s%I8M@l{85z zgXVb5k=FTA;u?$45O^@c==N;08s`Dx!hhjUnZB=xS1Ml7yYWbKCxl! znD|fzhc993+ChBCo@0!`9lg(q_ot30jVFYD*1{G2cB7)-w`;HH!MdW+!HVqoWk*^Q zA}7B?bZ?`g->oa^4OX;rVTk-=uSjdV3v{g*tf;qeMa`}`6!UO&Fd3}rm?PKJ1nIuI zZ*%EjO*-Z|uvQaGpSLf(bB-~G$!j&b&9P0jNjM#zy+BP)p!sNO!ZgGJ6ARbmJTt$h zFE)DDPGdLCQZR+p<`Tw1 zAg&BCH)LhP+V_e$UTE+kJ%SHALPb}t{5&*5bXiC#j=#Epyr!Al))O#vnoQ&hGD&1> zCcQo`z?8W77Wu-g=N zF8olNM2&y4TQH&HOlk@uYvx;cxn8%sK7kYX2(WR>4mxVfZI;j!Kmer`9Ja?1H>7&W zrXDI|kt^-~tcMegcx{wdeUi=Z`!Z&tMrM-UleRjG)iTn3By)1ezH{Rapt;TfU6DR! zf3>h6apOw~n-hK1mNU(P))9)z`|Btr!o??OhG`TNFhvZt4C5n0#nD75jX(q!oz7d75`aKdrYGwt_%p1dQk!NQI>^Jw z?NyL>K(yDN-exPLg$aMhWLS@@r}|tEra*uKrFKAv@>Evhz22WCT{u^z`Gq>&4~(!~ zM)~{<7Z7eoYCcihvYV7YJByd9$gaWi&v(#UDozZ$EFjMO`9HyHiPD}3pKR<%5f$dZ z@t>8}5duk?!RG9-vDKzl@1Ja;ns4@j_udb5H_PkKHeX}=n|><~*wbG9(afXC*4|U` zBa7cD!)tvcXv%}ls<_{_cq_(7ggceYRfPCM1E019*xKsrBA;1TH_rZ~2nX34;w3?J z-X$%Hh*vZfH1rxO5^3%75&5ahhze_^SAFJvFjsc$8B5K`=5%PpVm!1KyRJ9)t6eE<(oVRfWJr1<=rDxy0WB85fA z31Ecm0uaO%)BczF6?6Vq=t*lT<$*!17px>AEKHNy-B(p{m!>}{sx&^7HrbR;3tF8V z7Qgx?5!hE&Z&_1*^w+qJgL?VV#>-oWUcQO3AO~;DL=C)JO_tf0#CJdW)L2>zzo4tV!USd|nVQxuyzPP6R z(?#KVVCd!I_`$U^1dkRcojO^$LTd=i!_P<7lzT*>1?hFy(97>WCmXLl=?4if%^mHs z8zS2qTsG?Br(|53B67)(Z|9ffn^;e{LbNv4{8wnoXD%*tf_BTfCy&wcG>fZD5Q~wi zG5mYv?}R;@pT%p+9n2f$N5#cm(x$B#9nDtcD^{#%p)AMY9BHZU1hsW-v5cR>A}=7~ zluB$+iSn!L9G)l%D@C!GcL@FUduCe$w~x_;x4HECQgc_IF=P0Bl{x`w;z6q{2JT1e zdrs}vN}kGzoyWa)zdsIk3il-&`!wWQax@_1m7pA(d36$Y6cHfc z4f6=7&YB7?J2h@vbVe0P^Q1NFjF)3W_v1tN-JyF}Z{YjMp?fq*d~aY1_R*=a0PUNH zp&bnzW@I3#zsZnj=v{~mrmm`{z+al4jH*Y%g*`uKQc3%WJ&VMqK{YyR=7NfV0ob~4 z$yozl0%}R?G+Pl`^cWKlD2A``ok9@sA_vsDGBTzjJ{BJ+OMA<-W8&4~q zs2W$<$P=3IAm@@oF@rDgzz>8#iP*0nMxW`>z}w?|hOleFo}xi&DsFD_Ec&Bi#+V>6 z0#uKpED3DJNj8G_9+Zxv{)k-^!AP??3a+9Xfjps6%>1fObxGBoP(K=IX6-;TbeGay z=Jx%`VDWgJlQYGR$^=r4WGkL_drV4|us0zaMS3cJiAbv^)RjgQlJxZk|2lklN_u*2 z?(z1_fxCYb?yN7o-RSp?mUCuRccmWGs|yEt za0;!?qI$e?26xRav=~Q0pK4Hsu30e+K*CSDh2f9!HAsdv45PneSSADlB##xqPr{sr*v7gunivVPbE8PWhJu_S`*Q4mAk+#j`9rMIF~Et*TpT704_{H{v8>Hj`4;bAQ0Qo0XBsW%y3(bGo9w>z?2u?3qPh2 z2ox=EHKvri%RfMOTdC3Vc7LPNfj7>Xghh=rhzoE^OBuF}5jiNLjonTGRTem<8`-2V zZjDw($G(uVV}}{8p};?QiYxwUu+1WzY}54pO)LT0SfF6HeD-X)s^}6uk9Id}#$_$m z3)_lw8m32itgxI#%Vtr~ttY{HwUxwXEy`k8jGdBB_z1>u!;-8)Fw1}bZbd!zQL@(@ z`?xCiHCPv?0+(yQRdw z!pNY^cPpA{CTBkIh-5}Nx0=EzSIs3%J1BO@1{><*yGb}TFB|Dw@gFqx>DPw!>Ai1| zgt)WgFNR;r#2*{lMZ8Xu|HsUT_J=Lq%}g?73%etg zzG+1l8l7OBW~;;LjyHCNt=meTBU=gJwf$bWhEQZ>h2cTx`mOSzhP(M+-=8e}xpGU6 zbXO&g7<2n)z1JDm{{4WDXryw0NCB~36c=^*PVJ)X?ND(>3XmtKnJohVe7pCndf~B( zmEWpkr}2^fh9#Mx$84jtuV2WMB2Xam^)h#qW>$k0Uh2uDw_T4kAirJ}_i+Jpgo{Ek zb2|hXc>p$5TmDzGl|G=qR5s#^9B!`xn6Gg-puWao&KEG*+oMlTphfI}PWNZTINPRD zt8-8KQUO#EPLK%vsX{ zwrgBz77EOUGSz#<6^WQs8#of~NvKTGWgfyvXsG~?=TW(WP>>Vs$+Gf2TLO`c!VC^XdRo2}D>v>T~t2QNpJc;Jz1=N6OKMY|mv3t)Obk>lxnFVDL&_KNp8=X~UA(GxYMkDF~o(0VgQA%mU8@@NE1+YoBN8K+vH8 zQlR&aaFRGP7!-wA2Mk|!KJ!VHiAQIk>_gFl6kW_&UoK)zDHaUt5Iv@g=0JnPYH5S>n0E^IH+c2zE=q#`S zy>6EuG{*T*#W>9+emkO3{-cUOzm}(M;~=9>;GzRH7g1m2 zB0y+eR%9>NrhoWDQgS78P|maLTV6fhogWSmyG=`izH~zCtE~#60jy(MwpW$5TCc@@ zZe;hj#EmTChmptMGfUP+Fh;D%plvTk*|i~HLz7|cx(%QExYQqE-skqi5C{M6bIUuM z98i8icfrK|y`h(?^fpWvk%9r%PPOFGU7VZ_ujw7oOMswkgpiUd0g9AY<*pRgqWXx^ z*2~Sd;>{iO*%DQXJgUZG8M5vH7wSrCYMF6jcpRi`9i#?^g0^-2FEvjxJx9)6VhmF8 zg$w^>fZAGvbZcKt6ErHqS4=Mvp1XW!qV&#PY?jiIea%(ZZ$GzuM{`xN=50m_cGm^o zwv2`OfQBa+N;YOQ?2~a}5mLPi*SKfl1b5u< z!9+=>mBru+lMfGM7-;XRdF=tYwO6h7pAfh~ZIBaju{L~410?hMuBpwu&JV!C?xdk! zb8AqJ0j4o1}tafPl+;%S;*S(t<5__ds)q9`U(v5fo;$uwhda_0|DQ+L3iL(!LD=w)lO*N_uZk81)|{hQwR@XBEj2kc9axD z&Nx=EALr-Ls0cdentOO1+Ca0_4r4z?wDtn1|C$5nA~K>3ZmWUsLkUJ(uV${Gj=4g{ zgFcC2c3z#7G$VuUw)C1&C(UA}g+#^6i`IV9qh4MZ>90a>cYaZuE3T4bWUiQX$tPy; z-ZUd}ZyPi8TL<1>DPUoJ3-c#1u2^d8oj9$IgC)ThJm9Lv-N{2;vN^}o?;>yDJr0PN;4*qjW_ z-gsXTj7;G{=E8$|-x@#dJINXiP2&5hzu{d|@0#r-)r+z3p5mmCehPm;TLN8=axAARmJ7i4X?Knv zu@E@|SFz#7*d1ppk9^1hWP=Ygw(}+Xl7=mWalzaUjtaJo3YSauZJWs--?FQ9@GUb# zH46LD=;otzdF9I_3+S*z93YO{9ao!=A0crpNUv2lMivnB0>q*Io~h!Ut2Ik7;-iUn zo^B;TwQ(7U3YN|JF|5mfSt~wMQa2B4@?yg)Da-)8g*p9 zBnoFEwVs|To~zpiK?h}I-D#*ckb&;+H+7V*$wqXKNT)XH!@iBWsHXS}I~N26OND%Y z-c&XmJSF<~eGAU9rDzONKA3%z>WjDL9;n@WR1#?W8F?t3L=^;z>*sC8WjGwa2Lm@{ z(~SwuTiA@Ix3tnUc`*STi+TtB>9LIf(&+uFiFaG$R-MuAzpOZI9=bu`xk~?HW(4Dgb^EZt*#xD~jn8BiJhv>DESVsK~l^r#_2H=^%}ZRg%8J5e=?n7$)zsQ8M-D z=2Ud#i{eSmpNcDEW-T9=&)Boi;Y5)&Aj?V?=38NCSnFoSGCIK+kaqv)cpLY$akaR+ za{Uq9mzAt-gBVfBTK`CBU)ExA~ztL2Gd9pp22JKW19E!D4DB-kk2vxEid873?yT6 znrdit|7NT}ky>6>eUUz5z*9~J^sZbNDt-cYsG#MB^%I#%I9k)&ff^1$@=h>XD%S?K zVCe9eP6|Nh5&&~uQ4x!JYRthpsRmvvO-s%lSHKv+jg9fClZ=iwRW~X6e7X!kk5vz+ z^x;!!K25Y==a_Czr}>027auo|vvhsy5u%}5r}LR2xnY4(pG=%DfEfL~0Xvi^ggdz7 z?~TN$kQ8HFUj1h^CfR&=VwpOqnicMF!vdQDTgA4c#m-~Jt%tdsIeesyEgXn}IQH|R zEf}T38A=V;Ilc@u)H!2yM*bTMQ_Ep8#GZ_Y31DU69a!xzumS?G+TRA1tSXYLmZjdq*tBXy{ge=Gja=HO* zj94fPo@ECc2US2L=h-}CE(4MObi>k2cvbL^NQP)mBbHJVOr|~RfatPmgr$$R>rc{u z@L&~($;G{iB6-roOBQaL_oR~^TPxM;Y|%J&ILsE=F_2a4kc#6jJ$6{P+x_Xd z$DBUR@(f5~ht8vV)uFjSj^>x%pKOq2Q^;}a&M$|RL)4;x)`t5vhp6}G7gw9?yZ06iocR1md8gouP6nP8GXi?#`s z!ac=$u8vE^*o#wxRMY?@naRMTacu0{v%5oUB{Wye-@@>8=MyW{@bsR&#johLq|Q@q z8=jgcGCE!JH*4mZxp__xn(LxM7N0qSBn`~V9vwo4eexB0_Mkl*yBJc;v1gu1J8G0g zkGBx(#Se@KT;m|Kj%~v79!2qVP)Pkrz0VGYi3;<$c|2e=beO?Tg{~%d6PhePlu!FY z#qiD+_3QiO?isj(s5Dj2Xt<*{&Gs0cAo&Md^8d(uk_wOrIHT8DS=d2NNAj?W1!(@qG`D*}B9y!n{^bULEtV8GX*Sws{kVw)U zq>^efC6Xw*F5Vcgu5en9=9;3s zv**;^w(`fSNTmu)*q%3qsO|iW!uZ$C`RkrzmmUA)`=E#kSEDsH*32-pGTaO+!CeX- zP3p@7mJg72D|fMysF@J1t6)Z)K@tN^W7$Mq(;vDcU*Pi6RI50x80_rm61z@Tg1j)8 zEm4!4K$GyYb5nmx^}q>&0}_$Tdx250?U=}CaOhT@n+el8V|b=S%pDZ$-tp~shJOyR zryuI~%90>rl5KHGBV&vta|hA?=)IYTfD3aYE}o(-P>3zPm+@cDsX^-^8V07ux@p{2 zn@S5^QZeOMt=d;DbQFULL;4ko?a_|YZ~I0HCAOrV)>@LfxFW?v!Zb2GfIHaq<_0x%ovGYzpaVE(eWE1hbN8g}E^%&j@1{Hq!@N6d%<048&^kuW=w&Mz zkwqeC+TV z6JqftItiQM4&Fzm1T7YZHt~=Jyk!H@i*8~vq8gsMAFOM$QH=?dkXQ<@#A5W*(EfC3 zp_q%kPO-m!Me&>OrmE5e8KT&8BQL+^XvNhcwCZPIOV~q0D?aX*hgR8hUmaS7i?0B! zqk`~TuPEMgPPBe(oBkSV&Q;8k>(l>b?5q2I=sf3Xivq&y_Mlqa)jF#w9+s+PzJok4{SuZ) zcMmYXL*O)lg7^$GLGA=ORG1Tuj)uG-dwcMm2HmUA`Dvyhk>!kPNF4s~Th93*ZPv!c z;ji9dQTcBh0aq;SY#P56n>N>BQ+p;hZPwVd`LIVTJDZx%(mOAArdt5RK>VBmar-(z zL}r6w1xRGrX2quKGi>!<4BH%G*yj6QCUDoj7+$MEr>-4`JNMGQuMb+o-#;{KQ{RCl zd~PfFE3kpTgyDN_WdakZh*9|>CU7eo8*8NIC>b_^;r4aRh!fskuJDAO&*t!UA=aW8Wcn!JG<5Us1%l5qEy(dS19w>E5z_+ZvMei zU|#*e2hLIJdbTkA8`#2Q*up*Pou#j`g?ptf+>FSV%f$NP$V(eHG-g)gMr9P+NXo=?)F{sC^R$l0ydIO{EnUaf#f5s7t*b~W z<`eqCDC09ZcKAopac_oq?^3v2bpqOx6VUc{zwUBP#u(ksSNH(mkd- zUW}WV8Vs4gawuyeUpId>537%?|N2{sKYQ=FX!GF6%V9h1Yk+BD41{U@3@~jE4b$1n z#WXVhwZOD#`L7n!n!VOB{a>#ve&?K+{=1QvXJNYJXttLp!DoA=&%-yFqm+gM>xOuJ z)K-quxX9YNL;2x*s7>R<+UPrMWkq*28wcUX;n`e`!+Bl9yWB5wzYZpJk;$XU+^S6G z0Hd>~1WSGTAxS4vzlu4LD4bRjfomtKW(uaIL_`B&9nB{R;8VUWv~*HaB9-yEo>0h> zS0~lSuPlD~oTU2X$V;D-+ZIKsX>g>#BrWh}hjHvqOZ=Gq&JZ7O_GixQSF?+mIJj_N9e2E#DnKmGH=LLPpz7!VtLm&xiO=r-`E2i>xw3enuDzFSKg-C126S@s*X%dk z&IFm8;_4j@P0iR9{zpWpJ>!@d*7wUXY$c9iY%*W$oBdoflPg>PwAu0;;C+X2VWVdc z&Tq@huZ+ORpZzkT5i1M-Mz;!wS8wW_UDr%lw=375ud1`DyKX(NJ8wPf+X(AcR-Cso zH^xoY)~(@t&R0VTGub4K;c{IORSKk~r2Y_#7UdHKKWXDs$}+t25s{8wT- zKYexaW50MVx;!)T@+^xElWCo)^h=+m{A0GAzZxu$+ReXtb@9wOx&I?0FJB^-hi8Ic zm36EQ7ca{?9$D)cHjUc@(-;+q6+1A08}8f1RwknTsM4u@=rxJ`_f+vfK0o6BnjiIl zVUnJ$@629ixp_TX+vd?~%q@VgOyChQYf1ICMU9b=W*uw~phU;YP0i z^(F=;I0J`zT}oeqm)fLs-DZ!y#AeTu*RQJ8?>ryEhVA=-2&~(OmtI@xDUWvAy0!gq z3UJX+{wYrJYwyxpL;_tbdrD>-^KDBF{xqhaM2cE2L(De<2Q19b<2KsbhHPFHay^_; zA^}^`X%SCC9z@=0KYgqBS@FK2+DJ@X9i7nX{uUe26u#o@pdaFJeQk-eXUQHfsI)IJ zB)wl&735iA$5r#8L3|fNS8cfmG)-7>&XgHm4327(zPUvPW!|nX8&oaZ=2&Y&peX0k z_XE569t<+JFzH3iP-d8l4QA!W++jdVsQHRPDZw}fyw^osddQ@?9O4tly){KFBz8U_ zLG`Wazi^=V)w&^B)Bj|K>pP ze4UE#NC(-9q)}UyMs+!_RH!S0>egl6HL8qOR7J~lDoZo`ADW&j&GfFGrznvu>Qgqf zu#>6Mr(@l(FA%N{zQI5^H@^%ZM({sEo%55!(yD#6{jy8?tZ<& zaFTq(!EmCS1;#7QKn0~H0~q9~oou2cGN~|(>%U4lht-wz?v}yS?Y1$EE>9Bs-5r1T zjND(!{RHKDPiwU4z6$a~zlJP)+=ZGUelI)DR6$le^!7FRqbTcp@# zVjl-(R0t_Mj%+b+UjoE?6SjKN64Cm)@h$7@#MMo9o$o#ACk+}Ek0iZk1d!~oH`s0L z(;u|cw%MWaxf0L&D}AY~t$-L4d1Z8>s(@5Y!0ihM{)H9So@wt+&}UuQ(q)@`GF11w zjp=#2#uwfOOF}}GK6y83d35STP9i-*a%GLP4@>K{yu2r6>qB#2GDQgXW4&b}99TY5 z=A@>QA}csn5gnbw7;CjYcn{K`YGM!k5$z2S2DlclWgUur zFQEl~zr5?5=)4D}uvT*zurolZ$iRf7Zj4h%$2Q*stL`5m=|n zh7gq0TX0H`k~nd0gdZLmQ^3oh0ri5X?e(5MTYD$I7-*MRy);rRHw!r%V;8|5lPGd=p>k`rUl5-!pB?v(PxhJ+@!tK6`#3 zd1k`jzrWM{ znW+a;!JT5BosSQ5jEPDR-3ztJP>C{C5PbGJK4$+D3Fy=U%m5P*U|+n=^-4#aV2z~& z_vhnik;0E!9cN4^XzkR4c=)B7JDhDnNJIPeQzQ#77PRSrT^H;R=9`=(zxHC17k1!4 zBXIbvq8K7T?Hd>kTH0pCc0G*W)}n?C%9i{&DToDRgMZqa%4yukDav*aD|#DDT0ACT z#QD7K9KDUQn+W`k+aour2K#W+@#0Hul-_7*&)&O5##Yr0cFu-2bxRNH5-g6rG%sWHGoY5TG>J4HH6*&A? ze>#i3|K#~;%0Wpr49Hf^6#xajQ9RdMQz&yeOnRDPAF|Z-z+1OxW~OAJ=jZz zOV~-9@Y%N9HvZ+Kue>J3&8izOU8W*51*u1rSCNiuZx?@>x&3r{U$p*A2rGKZwq|4q zwu0L!&Y_W}?#_%s>Zo5K4G(JqG%gkqUfq<{wspC3oQ^1pg0EG4fD(+Hj#8dxYRx2> za{_3NlVdC%1kTE*U|r7of-k7KDGtl0d4wn_4KaM8o5`hIEp;uYgCM7xjtc`)wVp7r zAqrve1Iif+9d`WfZ1-6bkW&G*n3$MT?~OLNk>OB0oh#QdeWgca3w<^!E-5zMizsCm z#Jd8IsveVyg-Na__aaH_0jeZLrrqz9;6oijXT{Y0PW)QXG-UdBBx#p6Ecqw#PXZ<0 zfzfw&`*s8+i2*q7LB~U6paDK41IMDzIYPVpTmxgz2%xdlddIiVPB4-wvo!nxG$xJ> zw22Bn-N~D;H+;g}$W(ErBQ2D(-4AofBsc{;8!vscbrT7uBB?sQzmoBk+-i#0YI00X z143qK991ugp~)GsOp2zo;`tc)=8BE_d{~=eYTC#kafgD%ZB?%4r(&S z@xS-V`#VN{KE;w1+=>lw%ri=LR~H&PPGoN@z0Px0%5W!uP$T*>eUm0qp6cH75=Ra0 zN`DP9#Bvw`7@NwRLC;TR3|VG$(d}gp2U_e;fs1L7AYo&-Jez=-R4^}T7N6pHIpsviXBJ6t;Ch_8VJ{ulBTk?m zYQK-Y2WetLv5{VDKN+pu*HECUcat-~{(IRgb`~xcZhEmTPJ2$W;=_}4W5d4W{n9JN znMdQWmCyJ7UY|)yGOt0~xAawYE7ic4hOiCAA2LR6Bv#_1{BGj+6^oqkzM<$Z_BZo` zcx)k)jPjN*(BsWvOIWaeY}4QVcAhJ?_JUyd`HpB|-IIn*{>V)9{!Yr!!4(-6tO>Fq zai_ng%@-J~h4)05;HpBy&(!`SSf8=HP4aD`1IVi=p5#8M*3o7u4AnD&W= zt)glmn^vOB#T=|^SPk3zWGGwElLce-n8!jKDAf(!*#F5;AqqB&JK5*@DU%9vMop3m zM1uj$|A%Z!-O4W$l>P!zFe7r&>H^dtImk{#4A(-wQ8(MfS-j&(lK1swhw<8WdJMnp zJeG&sLRf@f~Sg7^(v~AB&LZg0XNj30p5^rGrdzh<)%B2-eg4frud6m7XQT9XL>my z+;7!aI!egr*!`UXH3J0{R%VA;sN0{hR=f@#Fqy)(n}rc0A*gyLvZnaT3)&OY|LQr6 zW>%XzWHSRhChk~&0YGB&`Hp>wWqI7e*w)`3c4(Xlz%y$q0wAQznmJr9-V7211D7JO zC9h{ouo;Vxfg056IsEA$Q+^u*?wsqcZHv)7hsxbn;>*y(_<{36S~Se%JH*3te8+$&6m2&ov6ozwl$=H)A<^4SO3V9_>RXLP zG;+@p`qR%1x}6{+pV6+p3lAmy_b-8mHuCBwTp03`{avzoF6{5p-D>|rkb734RSLl$ zvCzr>g@{SGP%ss!%Z>|?T}017LE|W)cO}PErpP?~Pr^KJb1ayd zlA_=OAY25pNPW;jJZIea<50>vF+*lP8Zs|#sn7)=x)1lcn;;j+1c5Q4d9no^wQSj+ zG^$-7h2Z44z_jUfxS;qQNVW+U+yTd#{}P*G6FNw;h1#4owTZzYB6{sxZG2wtZ>GwO zS;wqt&J8j*H;0)ewEhMux!E`Ow^L#RY{)+*HzAmJLMlc=3oXr6iM@3C*JLk2*07U5 zwr?z=KVZJ2khe->@4QXgaeLT4xS3sE>Z9)&$hVpe(5Dky#eah~(AyxnPbC{QAkE&8 zZ^Nv9v8L%POt5WX3EnKha4y)O(QdOu4t`ifjT=Ty0fLDI!7A|_^rwGe4H)<=Ce1Jg00T#h14fE5FKZwQIlr@;{Bfl!~8;Dn5vn!FM(B z6&VdGpc>bUm}Fer1*Gu<6fF(Ry4Mxo5wmR5}k68(myrMaEO(9(}J2)G5*1! zcG`h`P3JO9*vC5NagcFB_r^etR~^S)`j&e2VhpBCYRj8G5VCgUB7@+cEnUfd3ypeXKQ-=(Zsp}o+-hz;I+MsM(fFe>Iui)H<(K74l? zU<;c*aw(4vuR5v?=YZ5mOTKZ^_V9})o1my7-zTUDaxmpr84k#ka*+cKt=yHSS<~5j zNP=k{oH4vQahsLaOWXYF&coo20q>nW5=bh$_e@v>;~7hh1!qa;;Wav=)y@iRJ33PD zL{?%qb(c*IUg-M!W#!o3H+=xl898zfm0PUZ?+Y2 zcOvwZ$gU__O#T>yZW&!>S<;FN&7ClVT$G%HnQ<#M-~CKuB7qVpgW#C)7wyXGd>so#`!0=3Lo80 z)?8K*46NIgy{B=kFIUNs-2U$7;%O=DQcR?3^i9jwhwS(t6Iic5F&?HfjPg-L)@j5J zVW6AR6|kr}i^{+kJJ$VgX_}pYW=M)vtG=P}Y@7xm(45hTi?rBmtjGD;=D+||Y4N5- zzain-q9_uEXa8seBdHu~!nk#u+U4kxj)cVah-gXm2d7%o6ZK~kjuFe9)h;W2;f0<4`Aog&jDJ2~e>PwH z{DpWf;FfxUE&kDt`m-JQBazhZ-!-e{Y|zbui2G(5)+4y-CHQ7Qt-11z*;U7gZzc<9 z6mzLGYQ7m~B2cM?S<~iRJlM-y@_&LO?l_FE7{}4AYrR26OrpLt;S1LO@gqHW&K8a&^rCURc;e4~|7SD3@C)>yUZls1 z&%W=o?`!FWUogZRG1Vy(I6aPPZfHGBOICDL>a=-N-obav=#6o)6gmv^(U=#=xQM_m zeZoW3h@XflU7lFElt;?K9dg_dY0xN=ITur5oQzv78nb{9mb8!D?eD`?SwVElY7Hy` zM>AiVU<|{FW%7XDteU1h$sS`v+1>ycHH^Esq0xx0@tG{8Lf%VUD*Xl`Vit)@t4s%r)6{U;&KWkGdRZACc~=W(9MF+5E%GP(k7c-G?cu zWnkis2&UoOl0Ik{#SEF_hbW8hM1&FZQ^ovZf1aX*lWdeH z<_4y3N&f-^YLgA!o0--n*INtumLsLNm_i+pvo-pCkdO#J=!67vLAyUwDC8L$XsU?b z;VH4D#>I@-i%Qjwci7TIXkR`Q|z{Yeo)|7TIj9 zvr(62K^v9ha<@@gb>fo&TyVXOdGE9>K5?Uo@Rkbk+au!VRU3X7s?MiOS6M51YW{n3 zL0=&8lB=;qgi*_};Pl!N=J+Jv85WjJ;uiZMz>})5-=|?tnr31xxKie=tli;!Bp4pM zX9w%s{T%o%gb#5-_Wtl*CIQ}3H&Bf_-DkF|`ls+{UATlMV0Dqy_xc@Mj=5=bn1@!V zY3fkIf4E*)^?aSBFc3DW1}Php5x&a}?K%ZRN3j-u+3QQ01aWCfmQju-f-FDYK?s@Mou%yAmZ2|uR{<|;@WPG=ohb%2s z_psYyenC;99w6*gs|HSZQ#N@x(%(6(jOc)r(GC<&<9fHYrHnvJi_Qnvcl23I);3<% z*#;ULU<%yZircY$%GlV_P#uZ;h)x>kx$7jX5VwlPRO}_{B*w(LPEx!?-7_y$wnit}fCZw==2stDLB8&Aq1eT^t|}sJ#P^l{5f8flF_iat$!peNQ8`r= zy6}WMTJ3`SUDX(0tA9=gB|pzRrjW@4Tg4T461NF;d!Lrh&|&rxH`lXm6H*wdqBD{p z>OyC(L~-e63Xs}e>BmYHi9AN?;TIv*1?YaH;6 zVIt;@>oQUM#hFN?#>HZ6gbs3=zZ6bF(ZSpbONo{qZuhGiZvu!izNGtmTbffRns1vs zaY3|$bG%uwdwLA{#quM-LRKjX3Nhl+tWvrWt~c&+$`UY)v?llk$5d6J@iI-dzw<=e2 zt<9Vk=nuG0IY$Chmi`^u>0wgd`v-&{OqYdD;ALx)Jm zy}Se#S)+}RLBzY;!Mc zE<;1eH8?xNZgk7f*>+>tRleCkgo%yedNa?BS=zd}gqxjZvE5-K9NxcFKS_TN2)S6V z=>0|dg>|;O(1Lnf7VTdK!lWniy(TRAJ`;wv-uFUJFD|z=D0@5;E)SQT%r6Uj*21M> zZ`gM--|KSF#PRhz?#qLyb*%T#Nusc^%yVt@cLrwL#vxikvxEHic zroNz4>P_jc-V`NYq^WtyT)kIn${tot-BN4nO+!uTuHFq-^VS8+M?UbxxQgB7pLa?SMyh_=HFyY)(d;WH~9!b@XMtq ztu=VW>bsPWzK=rj)rzGgLl)oT82;hVy@lu&H}ma7b^Uf_jYb;GxYR|&p-;T0$I zefI2P$~j{<89p|gB;fBrxQ1~>Sep%(g}suWOT(U%plS_V&4zCdS0YD<)_zs8mS4UK zJ~TpZrLO%}>r7eKET3LRnGLkLcQstGmNRBuYNaQ`E5p^Q{F1QyWPZuXe78oLRa#bE z8>!(^t7}`}gN&6O~ylGXoUX8Mr|nGXdKtJAz5b1 zt#vcScXXJp(Ks`CMVc6+NlvdevwH@;Z8yXjGm>@uh9Qod$?{G7mU&`SCmOjChw|H` z{;h1A>RZ_tgy6`&05I7!=z`L|pc~`-Z<8g48EFaGQSu1WP~lrw__m3-jhjVfO0r1| z%#1XnvGbga1ve-l;@m2Rf@@Oj4e`G*xsk!x?b5ZAaIC{W=V+go9)qH5d}}D*3MHHj zTOh-%5yV<1sEtY^4)U^POpJQV9i6%0Vp2BS$;)On(^QNl4^^i>jCEqRTAiJ< z>y&Lsor+FqqOD3emj`hAL)GaIW1X03R%i3bLv(Ne?8i@w?sBNtrA4LxT6K8n4paiS`6S?*)aQ&~8@P&cwHB?f1rokZ(B%hM!eR6S^uZlFgrw=wa==dJ~ z#o+j7v9Z(mJ`p0GQ8Gwlr+E{9j< zX{NIZxT=3ny=OYqyMq@rlNG0ZqX+W(7c5$j_3n%?gmho>7i|l^`ZFuS{a^b1|5x6h z@%z6m@1ODer_1}l^7}t6@BiBG{~x=L(Imwe>URe1#pdYV<8XaU|CO6uwp(#Yb-0Y!%)gTZXT>GG&}>-t#Kn9 zUUSVP@yiONvf5e))PnYyo9~BxF}B6fo-{S6Dk`q|lDf8ybrOxj!}uL^Fuot|W^}F6 z-e$nW0aH>f_FIHikDX0wq)@C_?;cS=2vVR}?4Pko-WYx-ycnBOe`Kka#RX|Cv)sAJ zm9`>oydK|m<0*~;OsZhkE}TOFfoofu~$nIO&%f#ZMMCqH1Y zd(sBo8*mtz6MW|`Wwpm$i+t5sO;LXs`L83uwN~Q8Ox2)r0DLU*5yI$eiwgsQ^#0@L zdH)}V-w(RO0;0C?DaQad_@GkG_hWBQdiaRO(dw}YTSNq3);}OwHuU2FHI7_70$%*v zQZP`Gjy@f1PJQuC(HYunhIf`giUY|7;6%$Blu`Jgj{&jI_QYdHy?T4g-YX9!@XZsD zBpaxmj%34!gi_#}#RaUE8n*z6c!_@#R=3u6Y?)JU`EZ;SActTOEGGqo_%fahxM2)! zL~&2n5Jaa5d8;OTY&7WE2dVEs3T3NM4|OpgL#l0Yq^h$orZH=y1WODe=FkGkQaz5& z!u%BY$?{~N5P(^G)^Q7;;owAC@vyP@%DaH8J#u20gscurn8fwajYCC+fC;I-V=OtV zmtxVL)u+SB$;?UhTGEpJJT{O7E&kO6VO(^^gAGhl;e1nV7@;6l#=sE0DKK!}dRPzN zgq`>%joM}E1v}gm#$!=Shy+jaJ~sF_Mm5$4U#A6IiV?D4pW>Jhf4F!qeXRi?baCvn zxf%hRUOdt>@Vi5UMNkh!|7P(B=K7SA)A)#;!b~LmJAY{mGhqxhDS(BIiF0CuW3f~~ zdjr&@F|d@1HEC3|W+*mVXmaotAgqE6gPn@hCy~bN2&v7Un7j8wo56@7S}qQ%4Pg(05-^i}1|LO?U1 zPWIj0(q+;A*7zi%ZiH1J6(Iq(i9dEKK8asKm;sDubD8$G){=F2RGcAqq@5v_ zY}h0NiuUfc!B$GK8I>I>O^zAUhFDUW+oDmS>4otZ9|ZrP_hYI;lV;U2^3a&HtQsah zkjz`LsGSZZn@o2`VUC)zS+G@N8cpU$*dr3XA6FYdgPSp>l~OApn9HV*D>KS?&0a%Z z(TM}moL7lT&LntrffzDIZgIyaaXR4bWl_PQ{Cspw=wXwRIZ<51i6GgjVW`T8#7^3b~v#w7wj_XH5zVGpwX%sl7)@ zNf7D`3%&@ds1_r8$|U9mGGopHX~>yj^h;iB7Ga>2><0E)5o`2bG=w?IejCTUgznbZ z$(hM{GzExr@Myz^$(l|&M>&*E4FTo&Q9bgtY*iCeAc1I2f-S-u9@o%iir8cLS@g3v zh;CdwBc{g@8ATcAMlw``MwWZk5#fc+?E`+k4*{k*X(9LxuNqrzz%P1%+d1DZV*pzQ znmMpbth@L}yX^UqU04I6&!t`sg!i);txHOf|>E15}`@3B1z&n51Y#mD?&o zR0;`mJ>gl`cd_fa3edjLWDNLv@(W1;6gw5C8hb%v7K>g4PLxUYu~x2|(!};m(Lsnv4SB?*cVN=7BZPG}i^g~$k{0nbLq3QwAnD6i6!LIFqQ{-JVqfbHMV{b#VE zT}ClQltobE=4Q@F4HA(=v3i!f04W&HLZ@cGkUgqkT2WU} zRRle;N83)eQd6;JYcG!*fl_eWEPh?CvEDE1uY)5$g|L3(f|eDT!NiT9z-6PY-f56& z*yhmq9>&b@`II8%y`3&)L2mq@^3uN7)I76?d6ePHbWo}X#O`0ZDM$;!pwq=@P zFq;zQCk`awFSG@|=aDLL;*8f~F@k>x*__mt_7a$eBNku2pNM-PvP%(D_~0JQbxjGF z@iXGsuxDmTR$57Q!?0^`HUG2Mqo!luEsm?rgp3aqGEPy;H%MWUc9U3JJWN@CDxwwh zp7lu4`Ur(af9YPr^AVQ1?xi-1>TBGDvqquk3hN)IP~0da^SX8`Seb5H@a}8*qV|fO zC?-o!21C$+WYV6LS_6Jj2Wna)gZK@DejKaI(u&!TqDgs1mr6xtDp&}?=yOSv-mG-0 zJYT7lbH>39=uQ!~VaPRolFNREEN8O3BDqkvpq%51@?O|v3cR%_Sr zWNdA=6A7BgX4Rn9VV;jx0SFM=quh1eB^+qB%V=>LDhF+0Oyh2;EJ&avqrx^)06vU@ zPs8Uk(IRY{3_|hYO_-vG$Sdf@=H~N{{aL@H7fJ=3_6)`EwaZ)FrsQORX*hDvo5sd8 z9~*s+K`bvBL1gkdwotg=Rc$S`uTjp}YV=WKLuDuolRyyoxK9}^Ge#f^ZPWt^!Z_YX zh7|~E{Y0s-trW+Rn4hNM8R`&A*%;o39SQ!HPLKydRm2J!2gMVm83%f+>ezoAu<9^S zgh<&GFgCdOt|<*JRU5A#w$R5^dBf_AnrAD7XRn*A)Vdee#E1FyfcVks6y%unO`579 z*M?Fvjr4x4p<%ZnC`zEzFWHAB8%Lc);rlhx>m6^SXyGByVDO+x5&ZSS3vESWB-)s3 zX(CHwMp?faJg@u^w90K9pk&qz-D>2im{}HR3Z)uXq-Z(S9%0inL;~IzeO#HV_p@)f zvRmkb_7M;DQ2E_LTng}Q%)&cuuv}zYyZOi?8A;xe9yK#YW;=$63<1c&o^H`Y=v+~x zglkGEM&7k$ww3Rg^L|+7*#=BsJwd&|w}U2K zMFA3oL=8li6&bD2?Y;Zt&#`5iBK6N|kM!X7s}$o=JWm{eb;NTcz@H_|?k3U8wFY@K zwcWUA_RXV?NhHP1D{K(ic$!2tL6YKjWM)|IMpRFk9|2h=3y<@aQ|EuC5>BNhGO{c)2z%GEIX*W(Ag?U z?>z#tdz9_b>O$k7dbl^QvTw-#BcY-9m2?)%a!m^njp$TYPZb5B%%gji*ia)7C6H*n z2)&;d)V__8A8Igl2idxB9BEXE$pOH=yAs0%q?IiupgL~18VY+P$1w92ey;3r9z)>t5}e<5s)>B7!8zRE|iiSM~8lTnI;~En|oobRul1 zkg1TCl}PL7;4ohb1t9{b`{$`|y-x>-Ch11vD6i5{IzEZhI6-%xpU_)xxx~kFOfp5e z3J3rasNxg2LmUrJK5Jh>l`?mw(4mo#BC6MM_1r|428^qp?x2-CobV5E#((*Bh=sl&WD z9kcg(ZJUgMpJYo1rOXKIL}AOZDm!du!3*wQOPCjfy)0c?5uG%Z4CE*;fp z#I#+9FHve9Q%RZEEDxztq(E@oSsGo^KG6u&$K=PSiwrw13zG%u89)^soaB4lISsSF zVoSL#@^$D34cus0#qWU?34+*WO(O<7Id_jT=htGi=@vE%#f$~Y#!JQm?CmOJL93pz z08~^N3tIJz1%O{=ENIm;7PK6t?K(=?9VEP1x(^LCxSY7hYvMVQ47H@Un{@2**mD&7 z!Z9f9ieN45EyJ;!BT6VUH72(&$ZjpsKeUl-73N%U7lvR&G%EpyXpOMgwlLjd9H-h0 z1%F)Qmfs!Wmf}xqFF!l_@=WdJ7e-#bvkl`{7=Y-`o_Qv|P9dkbg>FB{DwZ&T|B1VR zA4&!T$15m&pduHM1d&|45xJP|SLDj-LnFJ`8tv@CX>XIT}piR{!rYNyXy!qO4 zpt?kN&5DZF6|i^?Fds-B;Xn@(kJae+(0K7v|98#6iL?RF#cxV8Mjs>f&_6?z`e-Y) zjwsf>3s8s#Suhgf-UX51stuvrKH-h~U$sGykHHFdUc{s42<{AFGFZ8M{OipUcvh^R zHUY>4pfLudbd{`mAn8b$n`_gZGE91J!o*Gaq*w#{*Tp(gS<`!hMq7=RmdaZqW zR&B%w)w3U14kol8??peJDNR}Epb^YAEz4MPF$uk*Vm&zsLi~tm7j4ylJ3`9eZrE5~ z?9$p%u~OzFRKG@vh5<(xWtP2=`d_jEGz^%21}zaH5B1)y>-+P@$T7E#_qmGU z?aEtCGKA~L4<*UUwW}Wr=?C%5{j`62zEd#q#HW1BNc1`}Y4&(NR#p@12+0Tk_ej05 z4>3`Q6|V!6FzZK@gHa{3QU95_nZ3M4iIzF~Imtn=e$tzS>enuGe`9Q{<4Cx@0V0e5 zhzXjTqe-M}W#SwyZYNH*K1F6@g3Y3b9}{EK^JQ0WfFXvRI=q=T=T)#Y~J^p@B1J9@q-V9?l0z3y(fk3 z4`?M^1=AyWOgK)ynxC~->~u)5dH8;M_~X|k_TN+2K2TKy0g`JiKO`ID$y5`o7(50P zRJL@B@MC*pRu_5KuitZp6{pf~ni`~TKH6d(Wh zYafV@1uuPqSIV3hl3u~YUL{~^5PeqMQSyRiloa6$Oi)Ky%1?HjSg>7iwk2s_>Q4)C z*+DDBVw02sf6rrPbZQE!Q&&(Rvr2}+Mu7UQ^zqos0|5Dy?lTQjM z)-72{?7$i%+@JPNS}afoGTXkrq6dEfLchiRI$=f!0EBOG`rFgD48MJ&y*(8sX#<*}ELK)-Uwo2J+E0@A zbdvvPD5Kx$TlkILeYSXGD6eV4mboT>h2e%ohlmBxq99mUIlf4JcSQGFR?>xeYSQ~@ zk%d$svtOrBti(NX; zrJ7H*eJ*5mg*?)_xJc|>`j9NL^`35yD~DuW*6Rr|F}-imRZU|+1AS(;ReErI&I+)C z7WpM5fd@*y6+97q4Q%BCVqLQ?7%u)3zdRjxFMqwKyY#|f!&QJsOu-s0Ht9nF_uAUOGL%Z2GN~iCtT6x-p@Fb0g&bOMe%&+RFk#&;xB6U z?ceVj=AGibHOBgp5ymRMP<#2wk(adiZf`Mj+Lx`~#E}@rlECqPGcN#z17qwNm$vX> zYXI4@V6`lw7UBa(!HdR-MmGLn9W-Fd^5_)Qq*z0FdbLJTEy5LGidRszQ|3FxGF@1d z@2vA?W)Ah-z9?7E?OP;VIyONzHR7Z+Ovk%_dBYu#zXoOmSl5) zZ5u@=$G!K=Vh9T{zp|5Nt2BjGr&EOjF;U7C-LpKh%FR8rxI)PipOSw$scbB{4yQ#@ zTvWzW`4#^5Ke24s?zVc*#l^kvN8yzEp?E-daf0)6BQHxbZWR%&o6#%JO{3Vq=p!G4 z>+ff2s~i%^gqZpZCp3fYU_gY&HS2PWK0KCNyoQUIX0jz~T%B8>g$)>zXl+QOMU!aA zEQyx#VqA}oUzceA9FqplU{18?f~`?U^XZ3$on69?a2*>(|5)Zp71G6Ir5i?Sp$|p} zTi0OfrnHi#s9x+NQHOd-rXp!j3z(v;``M<#YRj7`N82ms#}i50Bhvn}4(M`Xe>Z)( zgR!->pk;ZwCNNZyhI18Arx~xsN{L{olpgclF|Y=IqtF=h7y7&>xlBpTr29mQt<*Re z?Ih|!B`xb7y=bJw_Zy>7(zwYEY6+rgNsFKf_3nS3rn_VntYJM0< z;ZuF(E1)vFXfFU+bRjzvdA)kU+g*gVy;t)E+{=HHG8vCn*(tI%HzIQ)`sG>_C=nAu zfrUr`*b%N%K-x+pE+uh&r-j_a2!qR4h2UOc!Xnl>r!91a*PtNbd%B=zx-N1*V~7;8bIb8v2A z;E)#YGL1HAAN(xK%FU1}aNtW~c5ES4+2Ue}8BD+bV^QU=#xf9zY%DHUj#|a32QerF z{=iXQR0+P9ag4_ee#`7u!`&;tIlZJl`w;$PjZ@3L1gp@DLn42y4^o9C=5TNcs@lhq zUv&D4bQ8lTcblc#_9a^^HLS3gT$OHO&c!yjacnDM(8*Kqlt8lvGu ztWOv}g8W0Ya%NKTFY==pCAe59F$cQx!kK(4!I7&O$lJ7#V#1+K@0cV(Ck+)qC*p*~ zC?3u3|HisZl$*Nh4hf=XdKCYeDN{Quv0Mw1x{=O-Sy6<3m>}mB)$~XMLmhZE*>cf^ zpX0i#@N=-#iN5HDma)Cxu5C03`oP%zgB1A0lKQAxV0I?zqa56ewk#8Z*8hFnepjyX z>a)oDfBqG{(yDO+P-TTwXN$&geccWf*ltEt_FJgB>-#)4QZ>47SNeEIOFS0BCZmBi zoXn(sxT^6QQ91(d$lF=fRz5#~5zMuZ8vqlp7#^z~)#c??jW5WWu%gNkRq{3_<!{nF$; zr4erkC`qeh2R$GHM=v9^D9b-pPM1)hu}TGR(ORWK0fy65W!G!QtZ_!Y`6QR<*hMkT zYe1+(M3jMn((dV$CDZ}SH(V41hy%k?=&HtRY&HN8ESi>66DMN8@5T@`JE^I|{VKQ> zC64I|5jffaA;5BsE3VHHt0nLO>kOuV=5|r=GMvjFtJz+sFE0M`kYV;$wU-|qdHHu~ zI#%mJRQwM8h`gEY)DVp`iE~B}2!F7ROq@k(%|6bUW-!A@p_!BV!$A`IDNhQGV~SFm z*A^g{&&z>?m+TBdYn)(dCo!Y%>#5?6%e zSYi(FQzho0-epimG?;AXL1GRuwP^=HBR@%*mSZrZ0GxjRFN_3pm>D3Y_)aEJkL`29dd? z+$>GY&C)7!vly9qZ)9fbW@M&MmYb#NxmoOXKYVILx4Yfyw=%WZ!>c9qqBwV0v6iWY z0(DyBp&Ow!_mS3IEweJBBrGVZNNa;hv}TR*T(q|Sj?lWq39!cLRirx=JKYVi8r|`4 zRcTogVoK^ZKt#HFYhhvH18z8^)U=({0_5g&6pNG+NqLVrT6fte%sBFk#t3{=32)Xt z)k>#JrKOOKc8#`K5rbD7tgh4l%tu}K1rei;SBfH@2HFD}Tno{-t@qohyTF0-xzAzP zM2HqEAClFIk|39TFfa8?b`X7(6jf{pxq>;?2ruDGm?qSmRRAU0WOR`ieg+NI=j6LS z+p%~`V(BoqSe&w2_a=$C`jknYqNF*KzEfKp_(0K+BwsYWIIo070*Ci(01Wfm1t>o} zgNpVL#T34TMJ|%M%KbH}f);VCdr<9UU?1P2Io4yfRB|XuP9IwRa6Zqh_{%@vWpjFT8N)FX)N=zIH**@!{rXFaYstYD>JiqG)^~XgV`kpNGbf0UC3FsxQ-T@KKr5 z`~WVZpRBm_jObkYjxM2-{b^`YCr7V_5v>hOJ7&J(F2vQ8cpl#d_cv|`2|x-eqDw(P zsrdzrpfaW?z(BbRUnjznU`ySl^Y{tNsEzK)VZ)%315IN+Jd(9eK0_cB7Ng;`_kcLv zT#od!6-5Ol;G&}C6JaZ)%fXH_!pHSy?czshDv==!2vhx+R8bhyiB2`KX>~s{*60q> zB}s6`YJx-77?YSH3J#kT)gXEsI18eevV*`y3pnh13O|KP;#qLSiq}9C7zsEBo5=^$ z4=uhcgjA)$o;aL?6xf+hEz_dD|IfRzWdtY6#J+@x=EKDui_@(%OR@$g8OD}Qwc)(G zNQ{0$6%s?8ugQ70IHe_MQ5(o zMT#~hUNo^)YTEUHq+XN(JHTxlq*=JMb2MU4Y^m+Y;5AHgsuUv@PfBE@jsgjX@Zy@H zl0bCR@Mn-`^GGH6TE1)6-wif)RoDGCaR}M3>9d)9BEdz_hB9?VVLTJjcCh{+_S8|v2 zK~H1`No<(to9V!TCz5z(fMTH~0CV}4Ca3&STeyo`T9m8?0@VVvx}QjgJeH-X`)QmS z;3TGWG&5fa>zX7iX&_h3L9x1I=I1PH>3F-0<8iRfP^JsMU|xx~j%({gxwcQVQi4eg z`DF!Dojzpvmr6tOwQ2;i3F};@1Dfc-A+>?mI#JUNS@-c5?FHbEmEilv^0UDA(|xp8 zRjS?`@&ezMXfQ#o12&d>pV#StHl^6O6|`hT2VNZJvF8ufVq2b) zF3ekKFm^tQv#`E3A(4GUxq(ru2i@Wh%Sw_IQ%609Rj1)exad8lEg7CtW+uht(Y(`p z&?=X6g(9H4pNN^gfpIBnHi+I5={-~@Ac7?lxS)VOv>08Ca(`sO@t0 zOI=KIJt+iAPv#y$Gd0hJ*)T}FMW9dEv2&C_n}rG1_DfC1rWP5uOY$7W1--6RxnMoh zjSG?3T2Yy>UsKv%$@-zz`1xgVy!%@(1%Ec-H%BSHqRf=mS=xkDnP9iG1jgk@0%7AY zj)`BC#g@cavATvo`9|4<$8EG7J&1;ZVi<`O014%8i-?30dss>kSfhZ|E4$C@G`r7g z1gDkV7r&MP$6#RW4wc4B^np2TT$TwQ*o1O^^mV#d(8D+d*Hp=N(Ye#sr?k9vRaNAA z+wCO9$A3e@K0)i6O5U@-d-B_x7jcYOHaJS`zPqvUY7#Fjs-{Ab$NH|g_sVF?3a3eN z&wivzknE#ETy8d+;KX`N>H#u@R2*~H{@$zOZ1EzUOdT2TJstrA z2&Pr&dk0L0MOy`if#S9T3SCRK1Zoe~|>kDh~S z3T+zH(VXUYn)B6~yq&uYLl1S~Ww$0B*ER8c4oULIA zGl>=E{b7pIZSA<9{tmD(J(V&Qd13aoB=nchjQ;eDPp7~<%1Ek$ab*HDX;w&JE%$$5Kg7b~c;URS++iTEzd1)^$4A^TrRXdI@-e zrbE{m8I|lC5SvQo0W#D{Nj!Z)v{Vrp&S`!48T0@T?BU}1a+a?rxTkN+$B9tG(mhVo1i^BlWi)c%c>#jR zI0$Xr&b{$RV89+0Gs|G!zAg4GlgvjgGzr|f^TTiV;x%lpUHWI|2Zkt|3vv zc$gH!AP?81j8xDd0+4!1X~L@cMg)p&H}V14Ze$EzCsh0Zs*D#u@?{c+%&AtgGq|Q; zG6U7Dh4>}wL#WkfPs1qv4I#AlACc@#oo0`V!&^P3gQQ(t=W)AeVF39MoLn<#qlU!tt7h2-IX#A| zr)SFc0IsxnJ6>!+Z*Zl=Qlg%za+F@X*m>9ra5ZuKKq9sw2^|m|_cw;PSy5vY-3H$k zX{Y$x>?WDjobhJUSmA#2fOe5Q2a+vk)j*-?V)8gyf)6AM-0bvta5UqbujIR8bFXz+mVtC^;;`_Y*UZ~GVX%^Ffy_UBu|rX|EG zp;}_M7dcvGlm6Yn@u`eAmL{7sFz7!Gpag)W^Jbj~GrpwQqw&hJVUXbbfb6J_YI?V} zaG_Mz_zhceN^4LwW4;5@aN5i*_7^D9Il}Q4EVv)(Z|CQcj}u<7gA2gpw7FLC=^sY* z20i!~Z~9!^N5s>Y?DWF4f1xxl!$&SJ(5|>yZdbS!N zvGUISQD^aZ0fo|1u}*Q{Csf70M48sm)sXNfKpbuZ^*VM@6^HTT@>>)*#fnUhETIOy9H!X`1FyB;48!1=IaRga zv%DIl-;q}n&RLd55a*bwp~D<4v{lE5bP->ebwhEhG80{@!%!Ri$W*~adjFTfNhj>q zAtt*6Go$Dx2`y=FAlbkh^>~`K4MWdlL`{!@a5{1c;sN3!&|Y5Ffw*tFbZ*L*Sl-CQ zIe|4ZrBia*OrzuTWFCm@V1rFYkxEmgGNhBU*DXkT#g4+b1f8K9>G7ePP3xRQ#A|wH zu&H0sQivffz@tnJ{9Kc`mYh)6EVmw%Ccja@z#W%Q|5CIS?*cbd+-xduW))I{r%)p! zz{(FXvuIn~FCPnJXvZ9X3~FfRMY<_pGCPm$jAspL8tnAF2$?d=Uz%b_GmzN5c~D)&&;^TOHl z>|?>QU{@pwJwIiYGZVy@M;tV|uyO48<7;buii?F9*~LPDCtFnXRQH!~;#-qz#UMm!@wG#ShLQShK)4Vh~Ekz+~bP-fBJ3`d&L;FbJ=>;k)pT;r+P~!T> z2OE#jW^u0_Z`gQ5&)SENnhE>XBd&5~$(rUtG*{-x3nB#s<+WI{*H|6d9Lv)wt!O~= z%fLb!`eem31AU(^>GGvvA15PnP#l0__~2Px`SZ7z+qZ?vZ z6ux%N+1g0)`KN_Hb$Ab`2Kg(6{u}~Gwrl0R1@+-5I<6;|^R@3)|vvQP7TA;VzJq?(d-HV z+)fX0%Ybn`b6MlmS>YC+`e7SJro!x3h}#+AmNkg8aZC7y;TDJLC~l$2K9OJ_rsb>TVyUhZ=gi1MJjiV5d zO2fTbcO*e}ATGlA#312k3iW@HhLu?c9AY}yru6M6UTH3dPS|OlrAhhrMK;VpYyl94 z7BSwCbz+v7i~+oo)6$GKBE12M>V&W6k)cPF5{GbTmM4Y9@mXZI+Q2HmhWu1L-7)+{ z=f{+Fp~zrcHZ#knH|L-&PcXDyOcRf8lijWZ=1hytto%hZ#bM!EcCAcxY;m?_S;o19D{It#=m+4$@_4bsU z=`ab(c{%IZ4>kL(%;A~BZCaqA!ClV%G=XL94emTogT-mL`vF=0k&CS!#F5$9_2@9? z7|7`Et>~09_ZEWuqx+f5!IA_3Tz9lTBR2N`CD070(R7>~n2wxjVj3dgaXITP>vl85 zelj!NAn67iDFjmv^j@5-I{6aT5qgDevnEZBdOSk>>9!*lNfiFIvoQch9jZ4ETZOjG=>Nic0g?hRoFb?sOxr~WevXVZu%r)WcR5{Ykm zNZxKmvkn*lKT|0JImeB*i~F95@{#Wc;90pAfZBQF3O|ZeOtOE?Sl5`wStTaSoL2od zb|5)A%j*vy2sRNnCZP=F3llAL=u>xuOW1%*rgia zxNuf|>T%o?RT9GjR{~4=K1B!1pNwZ%2r73a^%e>3L$z~{??%Tbm-nF^uT++Ver;vV z@AZDepxn;0{b;&)%h{mSwOVmv?ow}=VaSliLKSAByg*gG$*!X;o(@BMAxIqwTI?`P zLO)mulYSt=nq*37ZFe}Gcr9&c1QGj)U#6AlTP+nkUduB^4o$C(1{cYDbrFPsy(Z&0 z7#6~=f=u>Wu+74b-UqCE7Dw33H#*5OcX)RWBYEM%!#F*B5#~Z~(dKsA0>^%CTwA1_ zYeNZu%8rYRH7R{T=YPDwVxF(ccr43ij^ykWciyf*F1@`8r&l}jvQ8G>^m^b&E#U{> z@0&|ACQd6EK!KlW=EK(==b~I>Vr4<>9)%vKd4}>FV|E1Qr?Vt&pyQb?AD6FR(uUv` zp=24a27xOcc^+=0i@|mXHyB#+pYZ(G;`1H$+#KrEZz{)(u*SgmA06=K`^N=6;`kTc zuRqSWr?Cb!vw!7HRF9WNv|_bvviO8IB>;C63p`G*U*NZ0{7Hh7ezJJd-^;Qg8_|j- zX+|+Ko5NGU;Cts-@u@GW7aGzv07O>}ok5Y%Nt^0<83`y0IQtUV#C}r@O*uQ{HI*5F zub+s)w<{zY+0^O-2?}iW!N%EX#(JyQ&iq`jh-O z1xuPLlX3xJ1O}ssK9=6?ITM)^sAGEFmPDc(USLlbAETYR%SlsUpimWbuci0k(d@ez z*Cso9O4Vz%x!@>Lw<9#7$SsO#gR!fRVe94M{{n3VF&m8LNjc3&)}k#NozY{_7smKk zWN)Se+47RY(~3`tep3B%;-sVXC!>y&Y_WL9*rJ?gJ_(?ZZwjKz1e6!|?%?IXS34KD!DhIeSLXZOr!x3{ zFQt5{O05M&p&`qb<^n#n(>9=*X1{aHq-3FX8Nz{f0{LP2A{vvnvH?<&D%n{Yw|Y9H z11-g~8R{Rm@g62I4iOb%f{=F6LpUS>@|>T5F;6TK2`B8=&6*l-wj*yozMg#)38O*h zUoDa`S&V+1DOtIaC3UIb44%_1>?0vx!XwuqHn4z3gc#Z0!pyj{yo7_s8k(Zh6qat5 zF@}F|F5n!J7r`lOjHkE*m_8%5n_3WcC>N zYy_(YcP+q1XXfS1Q8~E9hmUY*GVe6c>RH7vkO>OhN z42V7l61bYT!@vyo8g9sMV~Rg1-nrk@K)W0PQ1TXLz+!`j9Xy2Ss9hH26vn&X!v<7p zWA&aehB8{fq7!6JrnezwAUj3><*A-Da<=?L@4LD;wX}(G zQPva$>%CFu=b34JuV_T|dk02GuDrRhT>L$;VvGUxMd++ZZ`1I0;x?*b{&4&)tO0-N zg%@z2A$jc84Jiwo-G4^BJ^f4RAB}nrLST33o(1k_)9b0_%Uu1x>GkTDhC0m?B8*<< zI_oe1OkUqdM$_&uq?VCNYg0|NMQ|ZAMp|mpQl`fpxiQH>)sUB?bzF~Bd3KC#>OgY1 z-=K7+;TWaF_enASdbQHm3JdbopvN5Sj9s4{(WWRwov3F%O{H2SS+qlZB)>!XsU5tXdl6Zd zD!=Oah{W!+Wy(Mx^geg5jNfMY8#o-kNl^tTa5>2(Ql`s!E_H|$m)p49Mn4!QVFsH~ z5JM^BQ0gdl&A|uk(|;95oqTeQ+b>kN#M*{2D>m&mK4=iEim}Vbs7=LpdBrH8sWoXe zPT8J_rI{#nN_?pCH452hHbHQgMKNw&O{u4koSAhCX@v&Dz4T6Di%%s{aJzre7-Qo& zK=_k~V_$BQwaZ&(E~ zu9zI@XEQM67p!WY181_9&rdJkvdT(5S4mE4AmlXPwwiBW&3731)6Cj?C-HH8i&Bm8 zVb~tFo}`8zOXl+@SN%;sfAY|=Z+l2ZsFZi}tA{@Gt_j_K z<(I3#wmED$8Rl&9WHp~V^lQI%)2lh-eZ!%RfBo@SbK*PCP9FOAW4jJg-!|&o$fHAF zytASDo8F%42RY@Zy#J$Heo*h}zfs`OZ~fOTx>x*8(3I0Bmaf&D^m`hC1$>mj%@`2; z9PH17(Jn5bG0==P1&(B>c?a#G;hs0RWuJ0U5D9Of2rJvPBdl)x|CxIiFuSTM-*-Ls z-nFZCRkHIS38@HcZzCu8Q6_q0NE4K-@D@FyhvW6@ zwbzG` z6H4;$!CP_^hQs%cQn#x}%air|sGg~+0{9`B$H!VQs8*IuA+^M6+xGiBB=|}$*CZgK zE%%?7Ws+)`ZY>>s*wf)K$a5ZN9Jkvc-kS7G96bly{ zAo%eFwbhN`8gb1vR+MHO_jj3J7`qA~{0g#|uY*y2nL3Gb$;2|nf{J6>IQ<41nxAjy zqYmtK6LwtTb)vYIE4`NFQmwL%vG!dlLmQDoK_NuL59jqn#f+H~tMH@aeSCpQE!++5 zvDUQL#m;H%SO`g4;V{Xv#m;R5Lvd-ZQ*PM_&{W=ev)bdAXkOU1CE2Xqdaqq}Sy^sV zg0?~Ae41vpUVvb2^gs~#Bf9y_{95b~EZTjYF(Uia2M6u`=g>ZWwbuS(Z@>9$v>y-z zVvgSaTSEJ+rmg)I-u|*@qy4AT|H;rkTejBzN^d`VHrjtW{bwy?<9}Ib|0HjJ)w9w5 z)9L?(p?y~3*8jEM{+ef_{ioCai$eQbLi?wB`|F>L_MfW%I2y*-AM|$&&JFjkw40|# zzkA}WH?gegbP_Zd-k*5lo;Qv~wus>kH4;((ER^;$zUZ{m_+%ye39zP&XjeP;fp z;v+mh4{e8YA6ScEt%@ef;aP8Kdpyt-Lg(o;WuE5Vlw8Tx6n-N-J`awFzoa+Cof>$; zDj4oS2Qi&Js~wcRrqrv>v)wDMmOENkMxW)bJTG5;l(D+@+3uCb>V;1^R`qAOg9Br= z6@RwyYVQ*VVfIHyjl3V6m>2Y)cRRUri2<)g;+ zu??aI4vvdL#wxozmeRGIPJkymd-t=9#aILiAa-Xek2+y%2HZyD#co%u0+%0*k~jdo z{K#WbI6fT97=TIVv(mA37{A&$kXQ&Rk5&TkT!Xik?h+JWkA69AxqB^Lj8&7)bV=~g zLdEMQxCpuOTh^k<=Y&M**Z~)A_gXud6PU4hy^&WU{@AMw?pR*2b(sMc3kq*_3~Zqq zy^eb1Xsbt{s2|iJ=y=QssY0{Fl?EGGvW4FUASu)I+R5hMsdEBvRr2uGw&lXOO9VRQ z$52D)wzXNh;2Ob0r!0bBbYgnz+LM!O*XFSq8;M^ueHF`x{AW7SmS3|Z|J-kQEsl?m zPMrXdxu=JZp1#vo?#F;9@*+aMxy-iV;-kiv9iH-Ri@BG zTd}bQk7)*m-aQ&}5owOuxH*eugPd&swRbqxxF`@PW|VMny~-w~@Ukj-bZdsUF!wtZYkpNo)Nm*`G9mrc?+(F<9umI5+rwK8 zVkU=~nt_MaBBr~|-j4Ks|ptl%it?l_=`KVTX^w)zL)O9oqVsx8pcRJ{1*HA4#2e)=n zRbVJ7a8z`&YKC~jq(v&F*u&H=?8rdPA^U(kXji>wbKGzS?#O42fKBf5DDVfq86(jz zA9t^P63l7BTJO{ydUtTEM<6a{$Cgu=Br@yS`P*lQV8!;k0R*e?fiM5I#|OT?IDhZ& zN_-&yl->f9c*ijVAHQDuc-6qiH-;#rB48SkS(c|Bt8PK&&XXl$zygezDeIh~V2SW1 zTDObR$dLxNZkrJwjE${RiOGTe7wy8H1KRjCq?v`z~#C@Sj~W?{hrW! zZa018b~^;1B|chqeIC18%^QqmK?ux~ zw9y2(oJ@!ryJgRU!>JVcJ!aXNjZZ1sVu&@drW+vDaA~j+5MW)hl9{?}lBi#)m|e4Y zQo^b%)eon_?K5E(Dk_|81fOZny)XJ%HQBsckijw)xVO1oFB*Y3|8t89s9pAa@6}gz zJRFr+M6Q7UMn&395x)W{aI8w(ZrZ5o86m#F>Ov0?`!PN*adVWJRe-itaQXj8itMuIL6n!>OZ7A)9>1)cJzT;7Dm%e7^Z>0AyCV zoB{7l8$j2ty>LHUS_sJt#zE)3CMbu_H{1*f;%nEo>-(>0*C-CfR`%hBAQiYZOs(4M zWQ%JbF%(H+?AUy>b0fN;CR&fJp7GukBObHbt4;4-8VvqHGNmT(6 z{h!g5A<$T)l)n}RFvZ`C$go5 zvZ}qt0a&d@g5=37d_;_L*UqR2sm-@z)HezVg#>_d(cdBV+TMA`B;fZ6= zu!oP_TGK|UBHk1+7Vw_0Xsj(F5xu_OlxgeR1B{oL997V2jekS@GY=S5Nfnh7VJz`$ zs0GHsIYF|TADqa6u^!>NQt7Z-z~IU_H5szIyE!)|fDgXvYS`-k6fb10zy;4u_K>S& z#Giy8JaRVKeZsHN(S6`UH5=NOgVdl=1a(A8n3xi_ms^|Oc3$_=Dby> zCDZ7XN!~_$X6!OHY^{N!i7{~_^UIo}A#-@4wVynOR1SK_cb}8rqt`-6e=_dZeT=kW zn_6i=@_`C~3;ypS#*qb^MbV^n$E|)fnSI^M@4YO)OjLq_K76b1v(=$no|C`33|9WJ z63qJtKE6LD(rfh!AWQ|J0VKHX!4L+86*v@vs{E6;2yS+;PfZX!pn%oKw9V=R+ClFZ z5y5J@MS;E2{IcdXRnwG-6NUfzVgJyo25M4B?3_$NTeF;WK10;1=A{1xk8d0bZ(GLU*JF=&9~Rn8$upz_cQi zIDM`V7B+=_?PJ1AI&IpvHLLDN=*i_}e+T~AB?L`|3VDrb$yMdW5Py5*0yvrUM3{u! zj;JFWxm*xHOkh^(A}9|;Mwi61q=Kc3cUuoLK_+!MaQBy zMDJ7FR(HurH$18XajfeC#nNtDYhj~zu03$QdkRHw2qcxo2eQibS&D^smwoEI^7WZH6Gd+_zq`uK zEiICu2u*oV9vv_zG7QBaJd0$>&?@x@r3LMWkI#QuUJAdkZ$WGGl392r6M%bH$Je1f z_*~8O@&Kl-#vj92ipbW#V-nR?N=QaF1+d=%jf8-H%nK(e1kUFpU+bMdbLprjuQ0HIVBx-E*R$#$uPDLR@nc_$Of zO*3ZdHNT|h+Qa9EkW6?yXG1ob0IAi``UV~M8csNjWc+)LuG+HV?Z*BqHYL}z$4qOO z{~Af+eR5lYceBI44|;7#m!?NR_65D60IfFdBFRSUfP-`2A5PX1vypHfzSkk_Q@IPhwpFdubvFexF*UCDG5bKdx zRIJYJTnjs*;pRQU4Y`6`(M%DIm(=>k@0AoDJPIj%xF7|QL$yQ-(>;d%l%&uj1e8*G zEd@y|vA!Rty<)92(xZzJ(M1CW2mb0My1>aJYn14M^^^$aN$7$#R@|ct9N$2((*;iA z&|H}=;J;nEsF&!%Kza`P;7^I zA>P>{3H(D5EX(|(_WvC~PQ|kUx&XFYMo^{1L?vFK#k6^srhxGbyR^^JW7IC^k}wEt z-aRgvHvUbOI;3+~$_NGJPq(YM@dAD!4KfMlAX{zf+7(@&<+f4!5VE+ot{oeXh1xjT zq)w<-qt9|e+ea`PxKL5-8q+(im_0TcFJ--)kwfjUgkmL<|NPrmAE>R1D1^XkC!6X! zPK{(UNH#Tj!e5-HWjuks#@~+&ON{8BG{OXNvalEi*oPMT^hpYM7QdK|)~pWgR@F9T z*PxPZT7S)UQrA;ol$%NfktRf)$`@Zah3hwThx*0%wF$FjM)oY(zo}`3G78CzU)!{b zCvE77+XQ$u&xcjD1Fc*JG$;xy_7MbFjE@)FnFRhEbp@=Bgp+g|=HoDIr+EzyTf~}2 zK;S6CDd=`{e|y1p9f4>s)K}tpX-9m8eVf0(y?8q_GB{SdSD9`qVoAc`FPxRL1pz+d z3JIC`x;b3-4j_W7lK8e@XT9ewd#dU z|3zGh;9o}cqPq2k*guP`dc8117WpvX6Ug~|7@c%imdECZ4BAX?p$%_o9Ru50Vw$Sy z@`<8j)$_&FvY1nD^-M9#rdmst!U>+K{rGMYp>C?RjB>|<*kiM$lda|aaCl{$F*sIZ zpb=QHXkHg4lmnG5|@RZgS#WY3CjQuXD|%B zDiUoye>+caf7!TTotCC+ip}!`LVmdWF52@7$xXFZl4`BeD~K>~!sc6a$omQ`a%eq^ zFf-5{fT0JKOBE!CGpyaN5p99~;X4WN^o~8b@l4&--T^g24xFqrf8Aq1FX~x~&|%&C zLh((uG0ILLj(#@0DZM6p-YuFb(2xjexw)7y62QS)g2Ck0Q5G-H32PdAXTf!R`5m%s z74NnZ(tV`E_{7y(i*V_Z!IViVgK4%x-!q*TKCY-+C3(;M-B(Y%xBZ>-#Qt3~6yME- z*R&VFkC>v|xqj8ARo86SW9PA3YI`}UI~9a&>}Hw2l3L895&gd+0X;>q?BU8QH<%Z)pdqzW5lcx3p1ZE_8fL@`g= ziS4|d7?u3hhK+bCX6gTZGS@35P<8Vs{@rBWS#@EXb91Oe&O!C4K#Q7>VxlfA>@b94 zuZZ&vv3IbkGyTL9@9i{&t07n!OKp1^?LI9IPn@t(B=D+$hTm3?E(fl6 znQz^h92}mLV|HZEdyx&fX<0T+eIi~yvXiKuR|&3UH3)Piv1UOOvFJ{xR>Q{W;L+xwaxN{0}tqv`=0>}K|WG_+x( z14qnbLSy{W@vF?ICVn>wSV zsWV!dI-}jGLsgnOtx>Z`sq!&ZKGv(8$D(pQ_9`DMRX$d#e5_kJRaxa@3`4`F0Ea34 zylYH{xYz_9t3#cmc9Br?QZYZUC>ak3*^Yg%YNbgz!1HZXKZ2B*K@?SEj|yMTkYPs@ zKlQsz7&)B>1#dKy@V_6@feYBFJ1T%5a2E!C>?82q+El9vned}St^`M;05Od?Nvx9< zioNKlhm1jeWyikO;w%odt)bYiHz#Z!jIfnbftA^(Dq!0~O$<$+hJ^5ioULvh18No; zY6t=}NpxAFZNk9PjRKy3l9JLC!IR$s!|Gh7~61{k4Gt=Z@yC5i07ze zBgU1gja%Zr`zO+sVl9ykKKze`$9Kft+W3&sFZ11CD%!Qegq~pO3B&L3fsZxY%0p-> zm_EKXSbK~S$aZ1tRYs`!U0>mwz1dkNXSFeDQwm08TfKD$(HJL@NMwL?pzwfuM`@9X zWjR1g;}vKRuYu13OzEaC66pd}(DJ`nKUk=+An^@+t?858tl~Jak-S%Z(QUZ?ozD9b zqzpr)u~#ryb7g;mV1kPBB-~S`9L*1_Mo!);PFS~I_hVx@T-;qo*2EFnHt(Mjd@1n3 zm))}fTX`2Y`GCaD?-@F^ZZt?U^G|6!9{2p&bOmi(9@M_;&`e>D^PN)e)RMR3Y~B)S z!wJB`z6zBE&@SRD5@u$9hS4Jsk&Js|1o>x@AjuJTx=ACyB`G3Iz2nkYm^59 z=n^|X&=-b08O((WX%B`9`evxWuy3d^iMofaZy85G2^+0K1uh%NL!rW+gbI;z4+oXT zreNd6^2ynB8__^kGWW>n7m{TOb22EXy>OTOXQ?K^VA0#gF=SDQYONRp!!75UNBrWI zCp59WpcOG<+X>39hL*!Fowr`fAwng7cB92PcrDv1RhAgiFQHOp2RGrkPWFy zhmdqntaBJ9v54q4eM2Y1$bhe-GIV)K(%4woBPiU(k!rdj=@PktteUJjDV@|}Rqst2 z-;DhVRr+qeeRN;NZ%f+gREv>wu4rPBWD4rwpJ<9%{3A_V;|V|3Q<1V<^qeLeRgX9d zQcPMfE2_{%c5BQf*tP5ZNn^ehsDDOPR6g^U@^P~K-2}PPS_SCyjkkkI+lw{qfMt-L6NS2MG{NE# zonH#2Jl2qutEQ|?%8NCY2tjw=ka`1t+_B@JATkYI!FbFGnCZZfyf;p<>u~lsgIA!G z7EBbn`?=6cB}V%6^AcOCfZfD!s+7qV8OS2HG%(DT%jwbMPn?At_`6PziZeRZo6PA+ z%Nx$)JPjFDUfS} z4G~yXspoT`v|SSj(HpIB^A}Dd`Vc_iYv=QR^whO(h7dB1e0EMmR};R-%1%VvSv#JG z-v#Z}RsHJtMSLm9a);b}6rth}Y`Z;#Y*#UUZ9A9~q4@Cg- zcq_dkY%5u_UW9!u!${yJ;poDTmQ{yr&N1({Iz9b>fe(WcO+-grED&`&K9Xcm{zUW} zWX&nj!@NyIzfGjZ$Wi0B`kI^)eP8b{kabdvJH1$p7GHBv;^CwftK_e#m0~3B zUSxJvGlU@bn8QpoxK+=LK$seA%Ra#vI@O2>n4sTNIYtjY@mGs;qDWbtF-zWD@%u8K zDsToxS-GG4o=t$l3!CqG7u?NM6Eq0jG4Oh%I?!PJupliH(Ho_8o{dQGL+9$h*fEsX zu5d%N$HkfRD~`t6Qp^&e%drnGRwW&E!WZq|PqqNCpo?JWu|+92bZ*Bg0KU{W@kbD> z!4*x=8Ge6lltMiQj%IAiu(Om(FV@(re?}p++@+9EiM~8s)GAUcNXCa&qcrC@D%}Z6 zlw!({51Dba{0BNT#Aum+g^d(;s)8NH&G!n?$woKq7-1(9(a&96)g-SmV|4 z8uUWGACB8qt%7R@vg(2B$q_}n6jV{0zVFn(3iORr^+FfR{@oV1lvS(4xMo*n{7&^G|mq`vEpaU7s~19-2Mt? zs6Y~j3XH#_DS7d{qJspgfg70oDKR3v)h-=}!b6pQA#@2Q*5ZjMaqjx)tf{N3d66#EF;mF9X!bL6Tj$$`g7wpuVF$c?65S?<+RLD^Po8if^*)r1< z5gU_ukyIWEhLt#ucQ~`pXajx^@77SZZAsW|4qfrJ0}=BlH1NGkVrcN-R&9NlZVl zn9Y%=1dDUoSBu)az!lc5^72FBvE+PT+vvk?5 zv0~bpJSmuzL3s99eH4x&U?|l=tcb4Mw)1tbq{`?8Qd8>&UOX{p zUd&C{2F&8Ao{DV9_df9sb|a-DGafU=3+lKPd;^FXp|swjNRb%qK@z$=SoqbV{)#25 zbArZL@?n8P%)!#n%;Wl1id$aoI_O_(nN4{(W50@93y^*v?lu~bh8odHh&rjCs z&w6gYpqq``!;+y`XrYf-Or%(=gliRIFSDeF86PFhs2f_f1aDC^6<@VLVyojHxLUS> z2MBxn-wl!f^DJg^-&1miP}$x6P$4q{oSqkO$BHJI4; zF1OG*+(Uy^v>u4ZLaQ;LPpe2)KhP@WRLFqPh{NeVsMVY8VmYKMtdAIV*C}!)u%6R) zHx!&{)s==RmnqjA={hMqg0b)82Ii&~WV`jeHQ#^A3IkQGMS{mTC5Ai(JpB%N=}vgk zx?ZX_u9`)~1aDWs+ibpHFCa%wqS=O4iNp);H8|O>_5z}jQBUXdn9LR!vJbq82%@QD zpxaylVS&UEWnFc)waQaQFs4wuT|Qn01?LC$$U^Ur3J0{X7@)D+QSSj)#r8V)U7mXU%*k|tgt z$i+9p@G`gxY1~8PTpf_iSV&2x3dM9a$1JJ{)g>q5W!dIKC>*U(zn8-5W) z@jpXv%Mu~}3b_j~8oCnA@N`~#Xk73r>V2H)G7_Yfs?)1}8zdodhQu?x*F}%1Y@pNJ zFDfi?Sz536gn0Df!y7>3VkSEl#ogX#*88gG3v??%=`)J>KtRO>G;FS!)UbjfB`^wx zpV-1#6^2yZl~u(m*W;+o7T+*iu?>9Rd|RFCb!XbS!$*=xM1;CEgR zpd{jUl6B&C&g&YIgdoU22`u}@;vcq^fdFyBf+-q*qr^c9z~I)44+e(UXk7dM-efzM zy*7G$(^K1PwZ1SBHOpQryEc$-L)-cvGHW(|mB<|f7yo3VI@$b{QW+vWAJKEW8uob1 zhQ`Fp6S#*?!)mpGT?b77JDqQKDcXXJc5LR{tL@P6N@b|jJBfn#YgNe_h0P=!I>r6CbyM`-=j-j~j4I+1J{kEAE3GYs-vx&i$LQsVCm zqH6Ouj!N78lo8BL=E61Ht??h(Lm(!)6o@!Kl~oHLlKhw2(1lDFG(Q3u3 z&Xk!8Cqkx3{-q+{S)8}hD{EG!8Wune#Np#F_FW!L4oaS_k}0Psithwm_6*kO-$yWD z!0@dw%r<}@=YJoCcF(1>?ECEBZ-EyjTG(uXpY2H4Q9b;`6EueE*X_cc1!x=1*666a zv#2b`dqzkwM;lxSuyfS~;!9y0(dy__0|Hn?$8r7=2TZn02|#5ehd$`^CvPuN&yp>c zcA74i3RT7VX++(&0;l1BP2njHwY;IUQ+^^7IC7qSZsiLPcJ zl35>EN;fnF^VK5%bO|Dc3*C7VDri~@to7&9t+4vS)eA#`H(=KSwpcl{5S&6%5C>K_ zN{(tQ6zCKLDQdkh+wcY*sF<KLUJnf8)=TplL@yhcEfeK1#)z7K|ObsS~P=?3R2E?N=E$|=q(g}W$IkNZFcYPY|PKc)&F-;vN?z?C;PLYHA;a@7C~Imq}jMwArg z2yy*mQPfh+2gawsn!pg+yW~0m24n`I6j%ey0jw5S!xNZkNXFh666ABBQM4j1 zjTD7(m`OKPV7|<43ST^qtFSuDT{IdQyFfy@$tH&o64_yd8v{?6-0US%L=vv?#nnlh zHC)e)pt2H9-VsT`hZM#&CioyCGvQJN%;&H@E>|b$H2^GTzZj#bvP*@Jl(@O;Mv@<^ zvL|@iKYS)-X&a-UW?}Dt+JA}J%Eb75e!}`9sn^E(G~LMq>$9|%;;P7-m?OUExLr;} zVt?Xx%-$pyZ-zc6qK$M@uP{lv`vO3oh;oRG@o--;)%pc;BV8t<&QrItAnWnbeV()p(1_wni?Gy zret~0DO8(6w-PV9H-|b*=DZ`Xi@sT; zWJHLU?B=lO7LJ9ebrWDIwR$Pj2tuu{5zz1XQfU^^EnQM1Ss;l}H;G`^$z=<{E`!Ss z@nULH&#P%cj;Rhw&?6DqVsv9Ts>MCirEqKxyF`+XIs2pTM1}Fw>_o)TpXs(=5ll<+ z2okyLS{j`lrbUehs*BAQYtT{CMIlFiv{+&ZOv3?cyuWYr|08u5r;HSjyH#)UZ( zIK@R*Hz;Y_Nl>UJrKz&GsI2k~D-$sfR+bc%)t_NyVi|*#$?gNL>>ehK(9`TBt3OpW zq~&|jNzyzlh9i{POsAkmD#KfcJI(v*gBk~B zm(@o-K8*?eHZWI;dhpdj=@!S8{}j=3khMW)u$ltQbL zyOV6GEqFxIOqOdFCk7$}!2F8CT1dhbzx=VD?S+?u?xknpBa$fot+K&w2-TSCfkd%)U(cmj>C;YFo|&g+7jYk0(+aH5PdfM{rD)&0**+rSCCGSP^t+OD8Xy8 zx_&}k5T``_!W=u?Bevbf9e6M?iE#8@{DKzdk3e*c9%WJt29pK4$ zLwA@dGB_!mp`C(Hk~RL*xjQ1<{Ty3-t4A{bI%i!Y(uS(paue7!$`l1urIR z;Ae9-P|cRHPDMGYvqzN8cpI}(1M97tm0~Pgfr^N+!a&k?7aroX7#<+Q zGcgAvu7|dm25Z{3Wv2(T`7F8z<7pk(lFi$)E?HrDk-?*Y+I|iM8?&qzqZ|^J3%1QE zP3}2Xmg6kTBFh5fcI%f_f@;r|V6SW+Z#jl72N1Fd7zB+~2eErz+0HDd8(dtWDFfG@ zw+=6A^_)cranoPfZdv|ibAiYGpT{ao+p-)x2Y4fsT)9M!=UR^Cec;X4c=2z{nrrCp z9dbU;a;_}u>cidqEp3iutdz0_r^gGxN{-4v6NtT}DN8V#55@+0ub6knNufnwZEy+B zz$7X3w>8EcYMikTIr7++0;VluH^$70gF=e6)`m;kBMP50t7TA6GuI`R&5OBCb*X?| zmneLAZ+@~S8EBd5nW8l@J2$l;sgw*X+ zxW90yy!Qpx6Y}s2@AAbBSNF)X$E3e>7#Fb53tEi#d0k*?Qbl))sFjH1+(fm)Z?jcW~{g##kTm@ z*zS=PL7JvcWDjz0xN{x&sl#+oxQ^M70DM}+8_Bg)t_3&(oM7!+Zp|vWG5kCG(sipp zA+v!}5CE%(&&!(ntg*pv6Pe$<|7KEW6k7i7!S z(m)hr=p%@BV-CwE;Q|J#)Bk@OHnXif>8Oo$*E4AtrU8a7vzCvgSO<(|7RyJH^@fOz z1K%QIS;LS&*$^S+bmrs9hp0No5QScu=4ittJ%x!I4hL)E+H!$aH_$G%b-O1hl8M{u zvu5KxF-J;mZUn!3J5$IwCfFd?$}PzZ2Q3jdwrLT#XdsK&Ajz>&!miJQug1nQ%qEKh zj229z8E(MJsNl10EXOYpa|9Oi!^gEM7{U|>+_!kJH#d$EYrv^1lFgtvu-F*kRi`?x zP8)R|b@r+8TvBxQLK$~pCfG|W7+<3n>GJm_U*mbogOQlNU{9t(!dA@AHAGe{5)J!3 zcG6n&-FJVqBP{-C7-=k40ZiGNlQCvdp~=6mv&Um+H@ou+`?5;i^HT;Ikq3!j7->@B zga}5J^nfKbUR%zn0}^zooKZ-4xH|;lqwT|javjqMNp^gNT?Cy{Q*^J!ve~d*q+leC z_UsQ^t%r#*`V-TQjU~!bLiwI;R`RO2VsV)4yq-*fSErkzR_x=1%P7lkI}vAYfpVpg zQh$iv7U$pWEL(b(_&m6P%sv%jB))MVM&e)F*&$Vq&Mct>(oWGqxVZ7&MG0Y`%#TpM zym5%5Y&GI2(`;8bK9OHOIWLVPaGvq1qYu)d`n(P`5b9>lU3;D9MeI;8##w46Avqvo znN=^$4^%9$pU93}j!cDzK#rXJj@5u2yHmv#ub7QC5vwc{#s5?zzf%rS{EO{jP^#YZ zY)~J#alO!Q-2$|&#x)s!&BGyX9Y?IDVeLZRw!1dM#M z>8z0r-r%wq>ox9DQ0QrCsEZ+g@?X_%Hi8yI&^t#nHgA4&>C&YO__uKBqNR)ZJ!YxV zlZA6z0(8uZe~-HsR|P1%il?LREk4 z|5}$U_R0_71L!DHmQ|J|!^?EBUh(4W`|LI7OXlSS-dr_kUaaJ!szl@9*aJ1rRacR* zXmJH392)J_ZT*xVJMIq!)`K*+Pp=po1!ss)JGLpLoWjXX^-pv9v`}0)MHVXDm7x8_ALthrKMw5T?;s6M>NiZDlY zL`4Xnh|YJvDTDod4Jp0V*&LG`9L`}SDA;s3$5~SOe2&JC@hsQ(s#1NgD(dsv4m^2f z=Kh(ozFwESS-2GaZ2RLp*a6?-#Kl23P7TntE~~~(NHho2cP`10W&YM ztIcQ(lMozqY=rKDLr|+@uadz=1^6GkG!DE}Bnc{poU_`SsZ6D^Q#y>m7xhTGtkzU< zemqL5ifZTGE76v_o=Q_7E~Y>nroh2&MNBT883c7Nr;y`oLrl%q&W3nX(IOco9mx2K zQc?;KNj_gd&@WED7^_QQny>Tf{J~(R1_oX=Yz;W|M=XvrD}ESD33@VJC+jw8&bT>MM8cg&2NeT#Z2o`4C5TzJhWwn zcw@7NYy!ULxtod5UJX2v^pcN5oD zk$awH@n+MgUb1_>+`l`g>Cfkl+Q#_~z(msMT-Ay4pWg6+_i)$u-^@guLm^0p5`n47 z(O_nTb$Pv2|M^{_hx|>>I9{^by$~THagPR2hUK<2DoFm96`L2^P*a0*6 zaWKZ;-lP$zWMglX=AE=SOo1u1mXFG1&M~K}c>zshjDw1&;XSQF*M(X_)tf(gJ&-0g z?i=&n**xz5boDwMej;K-AHp>+alv1qACW#stuWPQjZ=-R#SrEBUAaux|BCC{`E#OS zRdyNUC{CZRhi+g>VbXpijzwakq}R56?kQ4*KBuJI;o#T%&Y?f%2$QXahG z@t5brh8P>Yy7?Bvf)XZSq)NFYq;RxVDM_9f2pD-j}tMz(|2fLX@ifgH|~{ zr%zUS#VRj|4MitJ08+TRzf}d!_OK_3ygV3{R_Ag4asSGMEE??f0a&8uM-6;Fdp`(0 zevMM{YUocW2C7*ff^IuMA~xmuWU2w-0dv~FMItxyEALPpDDzL&tGM|wHO1!cN1s{t zxRvDpXn30_w~!Wtl7`MOOGLD+)RM;k5;I3MzbuXkLtXV%M* z6K6fl7U$RR98SElhxt{ZIU=bn zkG>6Q#aej8G)6WS^4qSGK*17X%7wy~Z_9r(tA=a;*6LIZZ>9K9xA;td@e@@%WHta= z-JG56eGUC(93%08F^rvhnLjoWP9Pu$j)U@Ef>eEblxRd;BT+ zYeK?zhVhkb-1~WeoP0sdX(uAHzSSJZappld;xdN6EN-^n9mhk0Lk?ML0ZmMzdWCW<$5FeW03-`}hghbty{No8R@v43N*9m&V zHf4^-T+TKRe_5Vyh#yfNax@-2K3-CE-VCN{W_A4C311ln9!oK9&)8uz+IFb4`hs}4 zghnylDimU4D#{;9raYoCZ?{Qf(l&aV5#D{Tt%Cy{z#sz{{7DG~n%Hwd}%K^M$lNly@py z^3JF{y$RQLO0-5l8{)QTDEI|;xMxpIO{lafwd8w&Dm*1xsC>(eH81s&D>CrlnkkiA zkRE=m3TnncsR1wN&6b%m+E#0Zkvgp{vpUF$qY5q5jU6Q$jX0$w+cc-o*}_*q0p_}j zL%H2Nm+wRgm*+pb!Se5YhNX_pFWN#u&Gd3ZttHw=Tq4fAq=l`rk}cX0FZV7lS`j}) z!^b&_C^!uW6FYJE6?g`kEhVtUSj&TRrUn1uQo#-JaSe9(w5B-|D_$Mn`cQspTW&R6G*ad>i6>#u%+8&rF@WBtdX8 z#kCac!0ki$y>dQadQ6$=FmuMQ)v;n^H9kZEw@j*=lT+z+aiO<4Iu+7SN%EHGSFqi zEJG^*jYrngJQNOg^nM99v@>kP}L0 zU8}*>MV6u@#f_=4#bYyUp@ml9%NyM$Iuq`8X0+}=c1iA_m{g}UqW9w9aLI+)FtI`( z7}HkOaNg39DhB)%K9+Mc*~m$mJL;ZW8!JvPWV12W`r4?1&1ItmR=DoEBGjQ-0lGM5 z#W!UDfBZyx@n%t%14GT9KXu;GzBWRMkhnOpjx zHB<&F=9U6d{^fgDIF;r1Kg<~*4J7^vszGIxgPSb8K$jZ#-oOGf=db4%<$DRE8_H%L zPYf!*v%S#88KM~>_=5Pj)*|cvl5C-r@nNRIqRsqSxH(&N&bUb$5*KA$y~1THAyMw0 z&hCBYEj*i|l{`b$0$>?MxQjyM!zlrSbzy6XV48?tAgw^+e26v(o_d*2mr8ybZ>MRp zXi%vDQKC!J)nVcCG~v?1`j9dat>JwvTIsRfsCBNV7MCigs(Np=* zW$oe3>K(>nklLmNBCMksKLZe_)kmMv2FWZSwY4HB6B__^7C$}HT?DLLVvGI`i9P6# zvj<4O%O3oAfOXpITj&Y{HN429!&X@IQCPe{lh%k$yQ@B1QRJayIHQp>lSDJ5W-~-8 zhEzRrZbSdSo5>oqfW%b3d&U?T<{lcXGg(bQXu ziqZC^(LYo~Cb#ZoBNh)pZc0+4ZK9t!7HOJy=Z?*@)eJooLPtn88%^5DM7m?MLR-h9 zVrU1)@{vojC3jwknvI}^=2j((ffxgn%@(Q{L61*Bua#k-M=n#vHCzq=0-`s4&VFJ$ zNu{d0+3FmA(ZP8q4#6;T$wjEUBPiBH93M3TVr}DhnyPYlK4$X@otw=m!fw*Ch)TDX zoD@YkT_Aa^jVEcX4txI02&mJDV?%uPiiQZ zOY{wv7dfypoR@L+FBpGKj z*WANcjJ6DG6&6v{%aE|nWmb#Y%uqPWfXhrBV^r44OSgS-usY`QC)NG06YUze+UR|l znd`r#Fo`9p$nj$)+ga@;Brz=|D*O@*R8=m)u)i;pprK8U<-$8I&EdY|BG9KO5bhyK z-~}=nWc3X!X!%8R{ega&Ne|%@Nk<+cF6evXU_D}HCQQ;*$>E7$ybRVi<0nTbsYU5w zw-)4oTMtGN`>J}GTG$HsWx*$_NwMB1$kko z_&f%2Gea0831DG3G<%`7Aqapo?z5oATF+_!$E+nK>u4OTqipZdT-3Wy!Zwp1f8q&k z5auy0+#-tx#c7R86X}NzO&^|+t&{Ju+dG%@aD$mXNClIQE=qq$z>jMqC~bVThJT+x zNjAEfCODsQYC)z5D#lNbKND`sNX4Mj{0_7CP^_wMZeXP^o|bIPZRFMs${Pu7{ISsHCfZ4otz}{g- zE+ICbNxO8BW5xo`I6uf~U%MVX23I`#Xv5QS5ECl+mk1_^cb=xtdA`;#UJgLRyav8c!G#4TQQ2Mq*{5aqvPl4?DWv)0fm zLLY3lzUS{0{ZC7Zc8a_>NFG%+mH#H@Isz>#&^B!DP_f&83Jc8@0)*N z5ku{JmVgTASUgZe*}T!d_1$Liv6#SBYSa+lV~AFP3ax@csJl?=?}-okkTYkUvv3DT zhLft8u-KBZCl0T{3LB49xj7?*1lgNzZbvKOPaOy*-;1v*e7GP|Vgl!5xOO5LW<#m)vKx{i!#{!gkR1F~q+@t@y+qg4}r*_csvw|-gGrFm7=r7*F4 z$JJuJ=qGqBc%IMPcl11B;A(O$Kg`-SwEWx9@|w^vK+w=_YG_@O`P&_;l0#Tz|G>9- zBsJ^H{uvFH)JQ8l?b#QT{nH_PvoHI-Un9Gkxmyp|83;a>|2NMXy3hRQoTWxZGG}i( z=~UhLR-;nimR`}oHRHLWDZWi}KXN4yJ(Hd6+lPdaES=)HW6wg>j4-MXQ%=qV-|%6F z0YF8`MnTjO(HPT8k-aj6Z#NBuhpTa&%UMLg<>9^Tdul?#yjdD5ekzifWsa5>c_;H0 z2xhrgtM6{Yau|O{H;Z;E=Z>?F(8;nI0QEtql={?#`xS?ZrZCpXVmiXCN%v%W-Mn8e z5!N_ReNW28CY@lU+y(N%H2$>0pGbSHKAg`vosoPGx^lGO-Rdr4XXHdGY?-?RccEJC zV+!d(IHuP^UR>F3X`@QR45KyJu-&50akF{*6xXVN0uC9gJqoGAELEd$+cq+Yf_oGV zNtetpQ$Z4{2T>FWLE#rC!KUN$E^9BikTnzwD8h0H?bl+4-I@9GyLtZ8qoT@AlShUu z9mL2MOtHN&lJ5i%3?0X495s?`!7_kZq)YYKKgpmPP{(q>pjhHCwU=&gEfeoMW+GBh z`6642vC)9G3|>a|b?+}>9k_ae?_9XG)ShE*rQ;ul)MI%suBfWnRk+!bi|qcXV>9-r z*f+?uYLr!Q;beX-EZYpyT%jk;h*jku<4=L19+X@I{Nx)TNp3oZp$eT6skm4ZGXPO> ztqgY=r~2qjvt|6e1Z>VHFd*1`Cr_{H!H#6SMI$3ww4b}ZgnuYw2e=Pib-Z$CVZH+v z@Im9hEO4Nu9a($cJ{Gfj-kG(bH__Jx(C%0^Z~OUBhZ(kIMelMLPP%d7?aMWRZ~eDsud z+F*RCIyc!mR)k1HoYK(;)S+dJj>QemmhaA%;X6X$WN{NdF~DaFehgK-VX)&3+f5@| zetHx|r|oW|M?XL5B<&UQDBH+sy==wq>vnVL@i_0e`>wcd@RQCjGp!85 z!qK4rqmYjqpyBGfp(HlA%%+P`UA&H-Gg^DOdqU62Mh(if#yQ0Wz^WXs<{Z98;JMct z&xKpUz9(1m0;9hi@N!Jg#`Z-f&Yu6ovL00i!(P!^t&G4pVv^jJi@B*9k18Qg^Pft- zz` zAt}r-!q^t``^wFju3}r=OeuEur?P(T&-ISJ64jM;VwSA*RwX81u?$yp6DRA7Ns9zS zRZQ3%3TP$7f&v_MDRd3ah1l$dP>ugGO&Cy zM2aD@SLv}!J8&4ObHR5jJ)+G_BNKW=Y_T22iB5rA^*EA**J1KWciq|JP-@z=Z=CqF z$ebxiAscG^uf^~e(i!xE36sx0Bm_eh$(c;yY>A%Lv%Lu@C8s6m0zj~+bbIfkzQ!6G zW^o8gG(RdVuproPAW_2&U9*Fup<(_#eM*Cf{6;QhGF{ui$>MP(?gjBwW|Jh&Z-lKo zfd2JH|0=ZXP5NP4DPNVy7@|p3Xwo$h9I%4-m6XNnVY!XQrK$Xl-RVhr-K|${ikd({I{~|L#XyHu zA|_kTUR>W!#Tj4udUIxsA`gb1-fR)8=|8&-j3eIZxQ*Phoq<_ys_XjXFI!+#;Sji9bdzo=c^*T$xArtvqo@UGEH zHYXSW3w=#YB#aESZ_({pqden$4>v0A0i+~jp(fbKXx^@>weS+D!s9+J@CxQiTEahU zVanh9t0Hgc%6;XosC=@q0K54in7ymt5-`*uI3)T7)0`03n%7wwGvsJ9A;#F;0~>Cr z^Yt;Jaj5xM%DEiy9}!5%MIir&GUU#k$tGJ!l?OAs@Mzy zSr?tAA3LWvlrJmr%9g_l1p_dApO`jZYB6X4<pj~$CNjcW%R=@M|_x!EQ-Rf_M)5(UP8IB3S3jVnN~y^ zH*YsKuKCBLWx5bc1HW9G*$Fe-6S=lFWmF?jmzeXcg~gYjQ8x1UseoEK>k@wmDElQo&e!W$ z(qXKWn1|g-%p*}n=84Pq#D#u>HbM$w6)!)@`m=~;W`bXO5i*hS0T0aw#9iClxQU4W!dMQn1 zIIC}Zg8$}UrHNO9dtW;?sDD_7BN#adBvJqo!`=6GIvAvkvl)4!GC`M!nV#Cwa6)Sa zaozo`Cp;oM^vz{Qi|MIQCooJ_lkAk~by@S1>PPq%rYTGIes)>(RcHr?9_1#y4r^3LzsyE8S~2Fv#r#Cn(I(aZMs?A0VLxNcY$tg{IK6tTjJH&RscM9JICw@q8a7osqRK2# zS9{pj*>xP+fM<2I<41tMffnoe{Yp78>L}%8OS#umj;M>C!uP}eHqCi1P1M_@w^+N} z-yKuUH!1Wds)JO*_%#pMgaRp|3JTmH7dFNYF4`%0i0YzKkhL1R%=(6P4E-emscP_9#yQ*C|%4PlglZOY*j3DK@g&hR=? zY>ilu@^}5%`!9$0aa%+#1#p(^c(JOy*m4k<{n@ zAYG%rOy;+#%KRp)csO5tk(}tUoZlwQsTXwDs3F7CN>&o9xUZtjE4m}Vh7rvQOP5ye zbu?>;P$w>;6ZeFShmYC`cift*59+`+5$3w&P2TMPF!+Dc2megB=D9mis^xsI<#z!l zR&|b87H5oE^HYI<>duZOcjTz5A%dTYU0w4N8B@#1$7{rl zTe$$1l)>oPUH2{>{2tb^v(hmZX?^<#1Non}P;S_1lE{`VC3yPEhh_R;+gVsO&o_Ao z?`Ym;D#Dq)^{jQ#sMD9y&tO^mS7}x2%SzuGv$QuNIg8K+<~ph-KciR-`Ke%7LdJ{f z1;dhUW557ji>PJbR`A0*iWQJld5#WRvB5LFP(69pAT zF4-7#PkC8(b099_(^( z?*|=kr4s1qFMzHd$aUMn5>*%arHslw*jO#`255vWv=r$w zW;i273s5bDnPn@P9@qx{kGQ(6XKg5K43woyoXz3~+X9Cl87CyOfptwJksli)?*Csq^M(vD)o1Z8goldV3jZjnBnN4O@|Fv2ly0Fq?6b=t^T63H>rR z86mHgBAgA6bv&rDvsyB5Hg)3y%b2r09+oi|Y$23mh_Wi1H7pIp?D8u;21IAWZj9fk zR$8m$5{%m^N5>z3;;if4jYP>fZo%JWeU#HFZx&-lWM^uyJRdphxi) z&$YqK50_VdP~pn3w+LKw|36y|M`J9E#yaZ71knG@cm5ZMMOYARWny$T6SZYU(yHX; zIbM6K<5vSFh5#lSFXuPEE{3AduQhW7Oi?ow#PR0xTzpe}2&x%W>fD6>Q+ zn?=>zz1xq6sCl180#4g}pFa7z;+thq60pp<#DL`BI|rr5&AnDx ziEdzZ0oQPX9srymD>~l%%P#opyVlQYUXuc%J0H3IiJt-n-Im06`;94yFt?3-{pav? zy8kPzRvrdN!q={cffa2kC__e-pZr&<&OdE`|4x4aGJ%{K2U~Vh!}XS&AfvjC17DLb zcZV;<`bY;|4Cpr@PQERK(E_YDC>$KaNDF(U!axQ?Ajamjd5@^2u-me@>pp66rW5qo z?E(*wXiA$O6w-=Z;4Cbhg)#}VtG(Oava}gAxF7-k@3^;C$A78f$(dnY`>=s`Q<04r zynD8&MOTHE?*1Au$iYo7J8TDTNGtn-%8t8GybXd9Xir#7_-Xk zgbSuq+q!}MyYWuFfqqM)l%+m0b?|@R&xC_u(*rH^`^v*46+&E`v}*vrt8NDHuFY<` zteiX*?_`SKJVVW03uuXL#*8^4BQQ=gduuLgB)W_frlvW8R2AbS?8&R)O~h-3(s(Ht zC!b&2ibZ>~7-wO7@AA#iX0TaXTS%~~HzLkSWd-Ntj(Fo@gH``*pi4c*8T!=xyp=2U z##kr45#yugAzG-y3zRTByC$^|8reCtL%Qw576DFHKRGTta3wy>m z)sQhx9(D%~%3~$Z1Vh0=d92UEo^#Nm0XU(yDFvVpTA)-v@(-)T_t5y&s)TDfpNws$ zbFxi<#%JBxCJ2%|D|1f=BN6K~y@Shq-0he$u87271p=3XWJ3`2D<-_;29fr#LcWYA z^e=M{wmnV!@pz{Wa{~qiRs(wxCTnuzz@=H)W4*P&dZ7zxlEQbvfz^`+Q|u#}V#Rzy zWo2%|cEwno?N+n^b)IY=;kp?go$E3{eIJeMN_8*I=X?&XE8i{Wx|+Y;>VZkCIOn>> ztmon?&K-ym7f{M|ATIbUX0n3M!b#)6XJgl<#7X1kA<uRvLYS(aYhb+`mFqt3@HgiI={Zc0}OxOqcSJfxs%Fw~-RIMl{2 zL+r^!h(t%|k`lW@!*ZC+(05xNG#bw_@Q(shV{rXg?D0NpYhh?jYvEb#gf;Tf(r*zm z9b>QwjR6)i-=*e3esY9vai=7>k?l3d#a?q6wO&Pm+?tT91WT_J}~b zZ(r$q`?21NjHWIXFXq|%Z&~SoJno)ESkX@MD=yCMaJa=*O4SiTS7$eSciXm|+0FJ< zyYFVlH(Pj~1Ix~o-{by1wl6ZSX1>?zEbkmYAe zus2f}_Ari*)#3$RTQ9;j_DNHW6nq=@qVoY#5X>(|l@UZwKSVmU)gIPDF?$YOw}+|D){C_s8*%=6kTE-|kZw$8- zEE&XD&ziTW$L<<5EnM&8!X!nfsHGd}j1wEY6-~XDlgJ9PT@sgLvRNvG=hu+=Ld~w) zcEyXTt537)QX#6Ym8v!k&w!>A)hXY;4uFF#0QY%efR{4&;O0wTIU1;z8YrXXOCqNN z_S9EDTtc3q)tl=1;m*+?V`wC5!WyQxOv8r4Mt=S50bzR{j?!Cbm0k zNo?ezRZYTBrIN-(R?(jkAT)o+_#juF)yPe*XJ#Qzksk=eZ=)})IvwNl@u6)Gos zcyE47g_v*553F2rxrDaSnq-8RIp4V(560b?9p-IA*`8>+GC`|%subY|2az;?w_j0O z(I-W6zcy)C0fR$ax*93gtPjr#O{#S|xLY>|BMNW)IdBznwE<_Vo+;lL>TkL&Pus>Q zves9vqiy2qdVxI&&A}SZr7b?NkEp#J=s_l&sf>FBz#)5h?D-T%9528w2VbeiqSlvlCX0f*0VG=A- zG(Iv5(4N*893x}OVNa4W>n^6(8YgI67wf`$Pl6x79DF>ZHoTf;nlnS*CK(1+%n8qIQk?fx7rfkU;;`2>>$h z+g7Bm3ucA+%|n{B2*7gp=`2>iaV8KNq&~R0q7M!4p92luHca0WeuV_F7#G+bh&Rp%bWY_efwzG9iI|$0#S5;sjPS2=Js+i>e<;`U;1I_+gPC_{T+*h* z$W?8aX3G=4wi?CbU=^n8T}%Kc*6u=dDCJ%d|h!Xc~rWDu%VNuxxA&J5U+R zK2Ha6WQuCQkqP87Q@ZnmmHhr+(MXrMmC{lTv1P?-MObhGI%$%t2@AzYcm zyhVyC=#I!zDlpThjk{sgo1J=ls!5`LQpei>u+X*#=L~ZfMl0CEbPBvwa?@I``t$(r#aPtgl zZ`LNe=GmzTYKbdJAM8h|o|Y9)O2DSBANW39TI0UEEC6{~?=NfYWjgXVWDK7;O>9oS z8|{r9EXGQ*L;AL@DQ(V^(Z;j+;XtP`(}EHV6w$R-fCdWo$1W9Xx{1xAT$ z6}qxtxNA;O5VcOLNeKm^U-~C@`9l68@)11u{)WLv1#;;r>0xr^b+%1m!}mI28q|o^ zT#eF`3HWqQs`E?*)lpi=26m~VR##VJF|A{ET?JC+Z{*yvl!iWr^Kgq1A4zeaAv@H2$gJ-z9Ps_g0TUu2colA+J2GH^uJ? z@$2%?=)JkW%e}i?-^egv7Y5MBy&drbGdZ^A922v+_wEl>@^?ITG*rBQ@aubORXOj- ziKn|qCjWxC$EQnOHvY_j+6*lE&ijsvcV09H_N4s}QYHND@?y1egEQ+aJrPqK1niEs z;<{}N3o^mDgFLb+V+4Mw!qU){ds(Q>Y>3>W|Y4l^6$tD zkpq=szd4mVI>l`aDjW>b$>z_LO>^8FaT9TvL(I@b9v3rmk)|z&hAIH9;`~Zxnw>$> zOLANxnT@!R^v;=6@+M1d*D-Y+8oFrn6iGK)l1|pBE~$;%Z8;+Eo}Dlhiy0PVTE4Z{ zyHy&A<|BetzN;_?%tF6*TNj(T_9Ut3+$?Q=MYVRZQoIMQazmxZR&J=!t)M`c_=+K% zAR^^Czy&^YvVt8hx_8)I?e25WQu1zx;y=|l9}ej)u!g@G{QA2DkD*H8X~RZ&5_o_O z5leZ-nxGAu#f21_fs<+}8s(2_5x}B>U}ahr;I!#OAz7}WkPDm*Y*oEqm28xi#kRoZ z;WQKm1;@tPeyF^vIPSE_ah>LN8v>O&F(rhbewMXIF0fYNQ;bqe`oZv~ZLcDY1N)qT z*1%|4GU5?2W_VPRi>AxlxQ)tF_JVPKDfjAevbp5Y#=TbSC_%r5PNMv653T=Kyd9t-00l z?xf7PQm0SX{0yLd;)$bm>vMx&5B+`s@1p{Gk@Yh;sb>X)Rb=I?66e)3Ca*No_ zllSyN`ttBmd-~16uTR^+^k5Yy&R`qTQmW#d$t9K%o+%^@ZJH-yNapu|2ATf|AO1Jw z@7RTs!`ruE1h&21yk6{@*|TR`INrx>PyKM)-pZ65cjQC<2 zs^zUI7~F+i4+A08@~?{e4>PO#T zPenNS(KkNw6=dNBJhBh{hngJnTb3(>nLByH;#19cYqdxLq4+HG87aJ!DP4FeCmZwY zcYB+hS)nNQDMK|UT@+?9|HsP>-!^h#tfG7`=as0$HmRcghVUkx-28?UImPI@Z@abN zcQM5KJEFX{;4!)4fH4W9R6|d27%Y7^%hIQ_A_ym$sbNbvu~LXPFm1+Z@oBbbxG~4v z+RZcBkO8^8nrg4R-8=COb;5ff4>%gqig>209%JInzkelp0~fmgQ%SyGNH4g0e#>ux zCVc&e!LNI(Nqt*#g|Go_6nttlN2inwn}}{oVE^LKG_5^I*2tUXiY6a4W7y%5L3?;9 zQPlW7w6tB9TQMOqv-)PlRy7+2St`KSnWg%B?}C2KiKP1$Od%KR#0wMNN7%DsGgiWH zWIr>5~#@0#ICJkl%UZ443&p|;=$uVHNUEPsFtvWcdJF8 zun0JsINv6oSTQv|x--tdsP|&xTo-czQd(%EoHtHa!m_C_W*-`LoF6;M`(jQivT{<0 z4E=ZHG@TtskJj>tWxB4hWzwMF*%UK{$-MEHFCh>ETkhc`cEz1J1R+f~${cwe|)sHmu@tS1O+fE@qtQ`Ozmb0pyI zzVHA2yssIWuC99Osi&TL>Zz)yE*qx_LnfjLhX4lCgkCPu1XV*cVWj}02@VTb2HTnt zf1^PIlokjeRigwFk7Feh|33tU^CEaL5u*5;nHR2XMiUN+K@QM>-^4t}Bi{!>%+2E*K1!iq*#-S|QOR*ocoRF9O?X{Pmj-sgqXQK!FB5m~1n!&kmH8HOno z5n5e~oK5H)Zwl{E#GRV#QYq^tupnRvaG;nJ9MH~XOL)sZg5i}Cs)GsMH@k4M;t zQ`5q%D$o@2V#;d#0~DwYs>nBo6*rBn*%*waV2rHUXv=IHyn3Bgz5iR2$~BSvs+oqj z*hdJ-ubCnKY5sVdeelD6&~Y&j;r3o@Rk!?PN|LyM*=lq>rgTa`2&Dc>&&Bm`U#7_U;Xau*f~kr>IeadtlW z6r~AtL_eCMtyrn7H$_Kp!}{8TCL+~~58+Ge!*zs(-e(H!3=4hV6zab{1oM?*pkPs= z(9={($TWzVtm=*Q`2FOBKE^vOfS}rM>h|3==|h9ydRI<-io#fQ-7l$FXLDetshSSHtNTtGflT- z^igCO&I0}T92#n3`wE@iOegru=sT*v{1V9a^AF-S)DC>>Jv#Lr`qB#Hh0xF$0%Z-t zZLW$pKV((?ohBR#x|vwc!E^%Ujb$qSnbqLu2st8(BS3NMu~F>q1;wt1t?Kq;qxhv4 z6puZEQRA^uti7=3j9l|5mMtC|MQ^+~2o#&U{v&q&^D)>@{xcL?AGfMs95;&5P==vp zj)ITh!ddlC8#^9|CUOi5(dNxqK4jAx5Yj_5_|<<#eQKxS3{|GJY)VfclfWQYIY|sB zN`6~%G_xr43fFGsiYo@#(4FHq$;7}stwd9&6cY|;jg;tCC3XN-+d_%a`DwK7#&1)g zu&{0x-|^e{5Ee_LH4L!~T}*NxkOGy*>Kt_2W*onO*Y$WY&DbYcGse)2xnCj0CnVEt z2&Op@_#t+3Y(ocPlKN5-60(OuGAslAw!}Y01Tixga@CGDl_%Xt ziM|V?Ntnpzj3ix4gm8O!a(_0Jk0JrL)bq?L018A)aK*Oj8gms zSo#8zv*MqoJdw2;=Pzo}6grbV?tBbC9-=x*6dX4u;9=A%wp^liAsRXGn8<~BBSz`3 zPlTGpiKeH)Vc7MsLYrCRh+;^k)=z<=e5X603V+yURS(j)t|)&LB@u`GN#_wu!N7p% zPO|L6@=6lgcdW^lr;{bRtr~}!?zW;tFz0~H)ydY=u{Rr6!(hQ79RLh&Vd>T`E8!x* zWSa?;qDx6A0zPr6#Ud~2RM6G*hz}D9-NDTY10N`1^g+r5{INT+nT6E)5H$z5t$>uX zV!H-=G!*N`_*>V2-6N=F*yLaB*LD95PgvDQ>08h61<0b7Q%Y_Rn?F=UI>eTbTW4I* zO4+6%Fd#&s+W}Lj0 zG?@B`Ft!b%)2s1XhGTPwsD9|ArsSbGk9R1{Vc11CGkF-UvtqS2c{sK?41$GgD1;Mp zya*V9vx5iYL}u1)z=d-K6m-zIfkNx4;j~nYP?Ja9g}CSpis)yIz;Bc`s*iv1LXsJhTnZSeByQ2X zC^cwj{-Y~=s0d*1w9-X|A~P2<>10=S4pBzJmWN9v_)^OK5^^n&(%LU6xDZSvHHdSx zCG4%GDn!m;2umE*UR0Uetx2Pi5|~GZwV|MC7*0{%qKuA5X9t=F2@F+9rDB>GP{X#U zkV&*EmiR-I6F^5b(A{+w1-GVIl+jFDPKRsAmZUK=grrd*WvDXhF6y+Q&_*jmAVC}H zEaXu$#Mb0d${3hVkqT8W7#l!8u%jys()PkV$+D0A|D6>7F_st#lnV+^8cD}WkAx8H z#ohyT6DA}X?OWmxG6qvS*N@6H0scclc6=N62f;9^55k$sgK?ZUUEPVKEy`dT{aTel z^n#|v`g0vDSHtjwRA|JqYE_{6U-1-rA@r?Re**zBrHERqlq_jh zX6;=)5`#Sq6WtgwQ4X0A3D}t#i53%(C#{cw-WmWc?}vJVa%0OV6k!WDhS1n56bj0r z?LwmNUJO6b)reQ$rB9u>^DK1yAQD1EoFl1NJbXPW;YL!+aF+}wLx`JL5YH}q#0)(U435poBYHRhpE65pz3h&aG5Kh+K>aA+m7eh!&DviwZkCUa0=UWSXZ3yU>N1 z(b_s=m|wAOft&#*?kr%%5f=?=O#HKikk9CY#cY^K<2UFVQ9=?(6}DC*Wpx;hv}q^` z1LH7UN6b6wEKTy{-$)lWKK(mQz&*2=ap&JEj`@<(1iIYR@WP>8@M4F5=}uaxuN*)=H+h)4gn(!Ngs|p z#kDLTjui}FdSQVOU_`Cnc`jCWk**bSp{YXp^R9DYcQ;duF^G*9Ehdf4#foymYAA>l zrWe?HAV?E$zi9bBd<94pbxr6C%@EoOY)$3xNR8VkKeY07eK-Yxctf)qe&et&>y{9K z-!V|VXRS#csjt$PCh*^c2Ht#WAn?bKK2l0p1c6SlQuB1%Me3E!gn8B~HuP7BsgX-MoJQYe?1BIrb>Zz9zO97K1(3iYzrt`p(QKhf|ETG;{`sBrIxg-DriU@p! zI8YH;sED97Nt7R>0@0-P=pgkAbNPI4!DfUWT2or#MjAoIi56sD?71}^M6Ia^l}WsT zItR}TwTTbbM`DT+4c9Qn5o*GQ7YG9gI!zdX+mN{nH>C~)Ceod_kCPT;h$=3b#m8v= z0Rt&M6#g-SeI(<gQWNr=rI!HbE7n8)RcblriqalGuL{tZj-7xA~wI+-m?TwNHiMTNg2Wn}& zwi)uO_gt`uh4EV3orH0dfM%WsUnE#KE|O~ix_JylpQ~k`HBkX2pbHq!KIZy)a$4Tw z^t|KHcA8BivDN4d&HIIe)b&Am-%ekes9hBj$agpLrILI}9H{`d2^pn8Jp^>2B-C!U zNX3eZM4eb#*@@Y0^etKU1R14@PuJAw8jWi_$PqWxQoVqdXO$2|^_58*KbfE&rBA&p zi{A51V$dv$g=dtroyif=AhJdS30oj1C?4t)@+K7IP#;V$6icc=JxVA_gJ&RNr-_97 z2CBO*Gn3FwEwRS2`$GbcmpG~nL>vwXMVB;;INqC5EK`I&fb5018wRRB_ek80A%WkB z+BPQLP{HS~8LQZ+g0AT$1%^9y(WGGeH;Qm1wNs3{Y-)$E+Mz2&QP6CS4%#^ypwc85 zS@lpmN#y}TKkAQeqGM{&f=Hxf@Ij5a%9{s8F! zL&DI`NI)E^LQr++wKA~0vxVd2B1$mU)F`2A9W6LKgNR$k`b!e<3Gr`{yde;XF?b_o zLZjJZko@N$t!1ht#1agDtbB4Rz!-F1@_E@{1i~wg!J;4uRA}9cnOh%^RByb>#I2=4 zNsF2yLX9jC`cvvu78a0T#&PdR^&vA3jXNrxD2-*f#$cG5Bn_b;ze_D46$>jGG}(iJ z^#W!x)(>~L5k(xR)Y;Y4i4M4F%lUl*K+ddN+oV*F7e5GEEptd0?3D zjh|1pB7!FBDO;31$|qZyrNRK>;i9wlevIOAAQ+xx0F)2FUu->_MtaqOnSRNzNd zMQ;h!8g@W3*(dd3p|B#-saIIL)BuAZO=cy<>AVHsaHT2dJ$m%V&HKK=yvJFv!MyLQ zL}|Q_io|1_~#Cx`5jo_KUY5a$_U>Xl)KugG28L%00vTaEX$$gjM%orsOzrI*+k464S z4SIo8XjDT|KfM%SeS`ESMU@HogF!V;73MM%V1I&5ME3fjDPd=mu1}(B#t)=sbEthu zLg+R>GSBseS+g(9b97Z1##s94)3J&)Gr8|blrQdYBQq~_G41DxgSyd1WB8y%1y;g6 zqbKBHG%>Q*|AsW7;xON_EIAs5p-n>ItROTiN*~r-$B-S&V5Zu3UqGJU>!I?COdW?9}5KFZzPeLx?fzFwT>|ltBRvHd4M50$T zyXehA;g~lgpIC(enKxad8@&ObR`_5JVUop46VV%zZ5ua`O_ZjKcn|}zZsf645TPfg zo?{?JitNjrEFk+ReL|AO0!$-Wg(aI3DOm)uWK;BH(f>A*^#mnLU*=>1*?Y33EZOo% z$s&j)TdpTtXG(TyP_p!8P8N{8C%c#>TNf!=1hHi6^kf%P30rW2KI#FG@b=8Tjdwut?3gf`8xz?WV)ePjbVl5k-?G`$p>P@RNs zf7FKcOtsO8vRH#dN_+ao4N!3irR{%sVaMABdM75wZYX>Ip)+xlWgiGB@Q@8_L)kk! zGfOstsZgst`g$aawNmTL&Kp?{U<;CnBjoGL&PZ&92c`}uS>iNQwhai1U0?R(6)6ak zHYE20?l|C%Q~E)7!p?@-^*(SV!bNzk>&qUz$^%&IdPOFk8?At@@=^DL2rTN^p!D64 z919!@gST!_EbEbH>?>HW0J{w#!w^E0v(7It#*&Vfua(#}by2+6kCr|o8N*uI=7JX) za3lq1z*-(c9{oidlWnBeZS*l6_sAhsg`vBHtVaE{u3?&xN3F1B3i^ZSFi^)Wo7x-t zj>b3{`T)c);~`mE$XU#0!V||}8iOmVdOl6r6B>5h7;UIvFA9MxlN zTu;;Jm_X;O0b^)t6-x+aVLf>iv~4u+FO%$N5lg^{T%9#Y37?r7#cT%&^dtyDXM_gA z@_V91JkO?$#gGE_>fnE&4N~?Oax6HLp}d=QmZ=c@=a7lbf{v;_{ZDk^*hN15&yQUc z{>Cha=wH#ag&OBU=N(p!2mKfN1!4o#wN2e>eAyTev0EBNhOPnv>1CttIqQ3~E+kGt zONQEKfz51Xfnt4V14@H#n+H02C0mv~xKXh@v|cV3sQgrRF$Y+pT9@PCc@izE9jOr0 zRMy*9`=8A>O0oKkg_R6y8#QjJvRo9n6oM!OMgj8*&<6c10yEeW%4av?|NRx~NqxkB zNJC4;AX(n`2y**t6f}z*laZd8nVy*?;6Ob&s=Q*xqFHeElWlY6&s+f4Ksn}Ab>aLu z^T~Up996M!;ev&5Vi#)$USs8<=~JBNG&{Xbj)p0Xt|phGrOxF}Uy85-xnHBh-q_OY zJjafJW_Z1Xh3tl3gS&Pa{N5Afc*C!yN%Q@RLpql`o0|35hs=H}91P=Xk;Ue4KGzbE z0i5eaIRQ9*&PIo4soU$+G2AZ7gM$29nl#ED4~?PWe?^oB2gUF@8=MZG6N!8($^#Ho z?`*1d+8woLx469Iz2EE|fL>*h``5Ud7u47LoXtv+l1(hX+9D4l><#W_yQ2YFcQm`b z+=bAs7C8fV`UpjMit&`-nU1FvkBVmo9+a?9j;8|8OgsYCn#gIud6v7zj)L(zYMUAU zR7zwb684J0eXW=d3Jr8dy-lySh!~0KoN8!B$?`XW2;T?nba=c^lJ{Rvkc>D2| z@xBD_IK0>4-52kh@a~8At#~7Kt2~HOBg~WvrASoJ0uy;?xwGEU($K7wIXulRUZ+y- zT<)rMBJd-t+&|3o8>>7_k5Sp+SXtw!T^5M4+9t<``>waiscLhxv(eM+YFeT+yA_fg zm!rY;XQwjGrw|TjQ(by`I`X7GVUry*9j*pvT?izr4obb-tJEhqJfv!+4?Iv*Z|zc7v$K|%T|gPWAzJRIC>2e0E=N-V_(6Vm zMa$CM3OMdzfmKx%Sp|xs1wI}vTmMi|h0tvPn@_st83v}Fa+(S3b>=s}V!`}C)Q_U& z;Q@{lZ|Yn=M-7sAy(e}GOa(HOKYmIIV6bu=|O8+;68Tpa_bBYgL209B4gPlHog2-?AU6TpkH z@+iVOqouyy=~b#AsRS?yFsb9}7)^U)4g`3rytQF59`DN<(V!T<%sfPSEmBBU4np=s3Smv) zp$H-MEM#rJ0A-%qMti;2(dhI6*-iae3s>v*th76t>g*1Wr(vaixw`?Hlz9Y^#xnC# zKRKOpd3;fLZhrY~aacZY@Bf?9Vfp;$Z;Hct@4_A`t>!y_~ zb@((Y3{PqSv(@?YE9TngFPKj) zy3Co`Le9;DCj5X3eIMrw7V|gG0(H=2urx zzy0lja-1GCcP1tI=|DL__nD!Vous2bU`m(y>)6)}l1J(h0tDH45(+Th5(dDcY7hW; zVo-o`hT0(SjX?oos^*ke=)~+96kr1L*NHi33aDOC8A#*e!SYa@N(u;23IhITusl3G z(4gYc!Sb;1U_Hq<2FpXtp=PG-4T%|?yN(c=g4nuYh}=&{t1ddtPQ$CehWL?u-5=sd z06SXfS=$Myw0*n+CsIhN8!`Qm9ig6-qqjpnDMz1&dQy%KgnCkr{KJFk%%U7!73xVjx;fO7ak-1`7p_Oj*E?7_nSi<4K#LIsjxum zMywqv52|*%(Z_FEseq;?r5*z|3fVML?yD0^e(?I+NVyLIHy}^+{m@9cU!|jYDTa6O zbT=)5-*))TM<2!P_vT1Bem+KS4vbN}7%%Z0emYX_KgSp1`2*-F*MZn@j|Q8>kkyHD zwAzfJA`Lt)O_T?s4A8zI%Z}w3WYW+F0hMt1;a};Xq+oGEk45WFrv+A^0YKh zakn(%Wfa(piE`W=j5)pD77y=!zMUu!HkjJdWKLrr(lCN_j=GwZ7G@FgkCNkNV0`MR zt3&d{$;(H9lMM~dC5{Hg=X8?2=LQ1ux-nQ*JT4Cre#a;|wj5=nnSSmYCHFVV1Cy6- zDp@nnBf#^25o6>yDA3z_EmPeI4eHaNb1Axvr6dtoCQE?vuo=UH~*G2kw<8`CC-PT*rdn<&{Jwc4WRl9>2MN1w7*)aRPuAmEG zMo|x;BM$9R^5wbX$zbfdd2oGbg2NN9A^5y&{2 zB=;e~)U8(+CCmNP$~lak_3jo{|2HJdLv)emfW)SH7iplsC6g(PsQ@B1V4vQBr{zd z4Sa7&k%wewMF2+FBPsGoEo@FjMTIi6!Ho)vs#ocDvF2=NiX5XA0>JmA$iv7KN%lyx zQIc)asy)y)DROpFDnyVBlo%w;Q|)TCy<&d3GJZUoie^W{Og6GbHKZXKa$BOXq50p( z$z$}91Xt!5rqI~UJQ#j$oSX>Tyf7Qj96TrDISG&Pr|ugk=X+E#%X34}LT5d!zb#%L zS_zngLqmKp6U}MjBq48`$Ft!KGwa)Hm?a5R)JLFX$9Oq$E|Q&x2b~20COx4NkMXDO z881)rR6ozZO9+O;F8@}Ld0d><3x^C`p;hhCG~mflODX{q&6X#0;ddJlzm?-V)yPbeVv$4Utj@x3-h9>!%& zn_u7`c5c_(J4GIj!lllqU8}3Co@w(7{tP*Ov4)c4qlB)8uR~9$TXU$J;aj8o8boc) zkOxK95j!&EAxK)Y4{EhrOLsSL)rR5v4!-DEus_jAp##3?0EhTqo+-!Ihxu-TFZwMZ zu=m0j6UZUH+u-X8^L-7zXPJDd`NbalOnInlF0`Yw$>}X?aQo25Mq8JaO9SeInKI4m zp#H)1XRmj`f?Uf%U<~9@0JR}Yj>g=0b~=r$Z_JV!?4UQ5tCo$6SgR#HQs3o(6- z0$^jyRoU_+=2`7N)r*<8>ZLB<95gk2+)z}k8;{S?&>bYmTf0BUL~-pLMWf9<+w_@Se?)6NCKFA7U6V`-Uzn@O+XZ$A_c=-yd@1 zMTDKtm+5^K-VZ%NNkz*%QArI#oMu9csqtb)TyS(g=6)`hgds0II|u2!k_%h#yvl6! z7MN<)x)xM+%$F)J6)He~%ncQeMo%^qjtleT#5ym&?6r=D+7@(DsC|c+c&LX-4aw#_ zxjY)8rav~g>7mXgJ$i+MlXW^t^7T$9O}pz4I`4V1-%8+g5+OzH#G6nZ#hcI{Hhm}H z`v-h0c<;d*Mj+u$yyNlSk2h+N@G9P<+5U?62D}^bPR9EaywAq_D!gCCI~VUlB>a3= zcQ-9u*pBai;+>B7pW%No{O5x1hd~fk`0L^S2l(Fw|3>(4fd301xS*rE`(}jKAUq!a z`{Dm6{7;1c^Tm+tOA^~VYXWIP3UcLQ$<;_XJf53y8X z{K4+-&VeY7@4CAmNBC@n$0Oc;#H$3uw*J`Ny?D4FZ2qddyAJej0=@H)-a|<5)Ioyq zw{N?h5Ocjc@^Y1<)g;;Jq7f7y*Ts@K*O1$kK`$NY=puIiUh;cADxi z)|lt6YiYo|F#Innlt+}gTN>)vc#{qCTx2m~b}@wCQYiPw>J{fQED@+@iyPp1A9+%r z&FuM9p*-Y7b>V6A?DN#Qa~G7E!`?2G(`$`XY7w>BNh4TV^-w_LWRRn;cknryoHRST zsz{#LOB^<-qLD=4_w)+h!dJ9#0~mq7T_j7zSYV^R2S-^N93PNlEF8PxC?}s!$w5A! z!%;y#U&1ky9Q(*YLEpkLi+p|{2l*U;LnWU>l-eq`S zi+4HR*W+D*_l{L}c>sM{YzWHz}n|L?$;Wt}HDs)qyN6?htZoafgvxi#vkcTHHjqv$eRW zS3cx@W-}lq0)a+>8#Q+|8${fbG|>DyEC0#J*yeuwVFGcu#mmcv^T^xJTG5Tqj&5Tq0Z`oFkk~F@fMh6Y-%^gf{3+Wit` z2H#qvFWNVDnJH7S%pagf0Xmu%^p^zhrU>k(0MHGe7(m*}UB06NK-!iG06i7}s^YsU zU|@%FEC}db01e~GVM&_HUFTD1+89vd>VV^W1Se~3(Xz>=7s7IQ)u)1790F+A#cE&^ zqe+Rn$;=ps$wsonV*!JSWk~Eb;0P~deUY)Yq>il>;fQ?;`u>Lb5>1?+H5w3$fGD#;dQ1u9p0EkEg-85rOjKQRD*lMMB0aj!J zqnyE1YL-y!pm8a)|2$d23oBLFTbp_CO$0gXJ{RPvRSOo)FE_IYQ;>Wr13YfQf(N9p z(-2@fV!wpgW5QxH_a7->?og`(wu?16Nkh07?qF=#^ zDQzN#5k)-Ha5>MR#bQJh@YvG5jumjf4tLtjIddyW5z&q(C4iYn2;mpv96_Aapf~{y z#^WfEE>0f6Z`~`%i~3CYum6$7_gCPqo-&0h@qh1c$`nHV>X#ff@k8~M(P|8hAzo!U zcG@awkyz!xV$de6m-RZZ6t!MqGkqq?IOUyWMjuv(?%-TvfUGD5k?zIXX%q z2v39$j{3!~In`y@d*h{5SW0T`L?tUDGe0dWBP$#G)*7)Qu*%WY>}Yg&T@EF+RHJ-i z1e}@|M}5;ih{%6kK&JGea@-HxBf#u{TocDhU0?wt0bKSk)V{HGPD~)v22gA;Q0GE|@U`2n1^bWDE1{R!L?s;U=OsPi=4IumQqb#)xN1ofit z(E|v||GX9-l{&=<%$Y&c(}W&d?D{}&Q6jW;py^{oVcS(pP*d4xU>*dFZJxWy4fkVkM^|B$gOk3V##hulEH`uEV+TI8 zPFOW9q2$dfb?L@Y@NNVr>pbkOsqX^d1f6}HbF6s`;vDA*(BAQ5Wa!9DdkxUJIuUb> zK6S;lsB^3?kotK#(Wtk!SFY$0V}G zf^^osXz?IXJ}P(v5n_CQro~Vhi2oiwhhlZkpPgQ}o$m<24s5o$AEDnPbcAQN)8U!x zSV`3>bfM!VKcU*0MTKcsVvFsS~@Rj_31K>cfSg2HOilX6of-iJ`yQ63Z;w&oIRX|SME); z0{z>CWffRQFkhWjvCv+L|Lx^!wQ8TSXy#0K%wJGmp@8E=3N=yNeinLJ3dk!BiW6&B zDQ|Y3A&3|?GE`xHM*LwOoB_aA^@efwieCgd$3qI4?fwa3ywcjL7(u6oMct05LwiKL z3!$dv^Q@vX9UjEzUjbzr_?w}?R--ts`}N;p0$<5YOxTI|$05mB_u-5r$!pu81W*ye zWIt5uv8UTfqW>Twj1QAnM5iV5;4ws^YEfBPMO77mcLDe~h@(~Gk%+tcFx1;|5yyqX z-bBZ75H_U!0wU)wf{zC~Sun(5x>KtZYzGJ(te~t|ip@YJ&L&5zg;~b z=6y#;Ui*0CEG>$W&`F5~NKxe4NS2<#oW2l}^N+ax8wZx?p8XHf-B>hu}G^hK6!j)xs4!sL(oK(xl2x0JyD1fox1Mal6qt;}`J98(WL)5f0x zx@TDpO^nqpwtkSUqr9#QV+EpO4i7*v!*K%x@9%-&%{# zcfkbj4S1mYxX55^WjQs-*n502+49QZnAiD5b|?b1*!<+9@SeiMfQdd;t-?MmWcf*a z#qnL5RoaHE7vU9ks;g-pb)H_whg?PjbhgC>KD#K`hl6pb5Bmu|Vp;DiHHXYZU*p@l zfT^`_DQ0C$gU_kQ`~^NXb#9dkz@y|o5!>_O_OAj(st$DtzWQKSTT|8CR(77wI`TNx zSz}Oe6Tz41y_8$=Wt$HxD=^&!_gHk#T=gy-J%xd7x_0Y&?;0FL4PCdM8erQst&io1CrW}z7@Z*)RGQ64XL%!ld5e+tU94$=@LyUFOyxo8 ztW@VBWq=Wl7XSRVt}M`S?~e$^fS%=bm-VJO;Qk8-_pc(eWr4FN{#xDsmozD zaA_8Dbp8vCkD~B2()rGdLgj=Lv?zpzI2%UJ=^6m+9K}i#}nk!&2l?eW#lXHB4q`Z@itKa!9&_DqX5ku_hXI|MUsX?v~o6 zY|3uJWQBiWp*Oj4DpKvT38<;(O{5YtXPK~@i-hC^b(B|81W@I~{+U1&jb?MTq&QTi zc@QFnL7(nI;#6lf5NKqQT-pZ9ebRO9Ny;`Ph^&rIrt`8CN-88qIt>;Yom>>n)s~+q zX=WV`g7O4-7vL$w>aJxcRsdb2d%3fMj-S-`5v2w|Cz~?I6PTu1I+k6`{3A3T~~4O`)wtNCIhTyqu2##!8dvq&gg` ziP8;)2XXWRfm)?W#bFe#C3Hw;dZQCZ4VJUL?mmc%sVO9RiVT;In!3p6^vl}dqtt}-aZEW#BcWqt@j47_=c2}hRA~7Ao4h|az`}xnlj>zi z66wAcANtMMxncxqT80{J4VZ1{X2RxO$w%MBMt#Fxai9n$nYlbk0sDHyfV^P~HvSQ7 z?aoGDt=EOKSDG}%nBHreld)w#yhs9B2#d7tAr*QdZXjjZ}oP=&9pPQr&ArDhItY28E?* zK02)_CXas1RUB| z3nWuks*ZPJI_#VcsTt`RC_Ange5jRG=*?p2L1p7W*OC{jR;BpRpG%fm^;4q3aj8|- z3x?R-Gx5~tsMXF|B|I3{`P>c8^al5m)MQOl78vJ<^7R`yj|vmQwM)~LWaR{8SI6)4 zhVcgB$&>^E>dBB_x>AMAlAX}UGn}3bHbl+@sq%;ihOlzd`u`CDsOWU!&=t_6kg`cQ zxpm6eZVZ-3g2q@T5^mm1a1_;UttwNgu|rJ^q`dq>!AkVbV1ycA(kWAPj!ns#NJNLC zL1(x}W!nQ9T_{YPCd@seVU;&XP_+S1U@SY6a;()E?k)LQ>8ynC={1nXkijM1Q&l}Zk^~SYhMUF~>_@E|C&rjU3mjU59nb8L zZo6SD(T`l79Lla>vA1vyO43MoCAKL z&_=>I4oyE?jFc;~!F!Z}=8lf?GiQS}$fQ}18z=Ess|(?T{jY0ibhZN( z5y1cNYq)yXuewqEKUT2Rn++=5<88Ep3L#X0|0}&jL*)dTU%l1*4?C@a+R1yltZfX+ zP*05`?+JzLBVg#YWiB-Jym`NYXMwwq(T6Zoc8t~;bc7SvTepC`q)(T@t941yR9UcHjVIby0p=`iOoHNn#Lc& z$b+raW>Gh$5lDi$ypvYqNdU=lNNWhoP3CbeM7MOo82InhhX398do|VlH!^UH1aLae zGoqYmn(yUTM+Mqg%=rElAQSZoV;tfITPeo&G!Kb*+Ltlt0sJd~r#lExnb{Pweisnd zEpfwk5cUIr9*WbVm<^VCfkF3ptZftJaVA_QeMk$}gD`CYY!YC3DtsOuN|S84L2z#X zZa8*^V2=}*V%8#&`F9+71ti_vMaMYf5KKPn5C6-b71`23 zjRfK#t0nsIw1*pka3&dF%KALwn<%6;5^TAN3nMu%@PC4EEZt=Er>I~&(G z{6jle@;d<0?JtBvU({?^WHgvdU+fhTzZB;#0QHQB!|VVIjJ-hJqCuH&r3ojz4N&{75DM+j|BUVu1phOuthwx)-gt26mmuhV9Ii+B z=_dH;zwZ6((*!Sm;(Z4065Y*l(Em8i3h4!Z2flbXPR-jn@EJVQ=}n=O2GOJWF@F<` zPA{Xy1jGC}_MkM)>HqF#4EkThA9d>+XdXz?L+?Tg7twbBN-I*sK*O|(&kk*1$8xtO zJ_!p|ciEe$bX+THZBr5yy;S8Q@U5bCCaJGQ2bc0DPWh0(1Zs| zNd+vL#8Ga7fS!ebUX6eT3OQ^8_?}pD{>DGO8tQLzbn=Vj4{uTx$Mt81GrK9W{;j{^ zo;&D1jYj$sOlfjA!G^+{ zzjb#A9y2b6Q-{;v5#SjCzyJ3;2mYVofV%l3ZMdr)*No1xcGF&XoAo?kN0@F63~O{g z1;9i!3)<8uOiUiut<-vJhCiG1hmu{pTa^16^Qe5-aSi;kOgI7rMQB^>*z)eS!*mN| zFCrrDG}P%g4zTu7(}%7+ZPC~Zn9SdX+=X^Rz2;+Ta3kQJ)1;$*03gSY+P4&2I@tl@ zpCevY&!{7XAVZ*O<0n|akG!yK!0FPDbg3;Kl&Xs7t>P<&(^5{Rg?zr~$@f@e8GGPP2D@-Mm-C z#RVszC~k*~-CTeV{-zE3B4^&JxN$qX*Z?XuHTedI4oA2S7J}-7{8}hXCjffQDw1 zCCu}&8^Oape8Q7-N@&^tjBqky8(d<$or3irxOL4w-9V-lFP-M4MPfHIbHgtn9|z>f zfP$-bS9`G~-N6>Z@dov6K#(<+-+dI`JbZ_6YP3=7f-g0K;g_3qVVcBVE_N|I(e^KH zs0o7)?EC`M!+@F`2`kGhH+1st<9vqzqU=GGX`%b}aTC)*x4XFor77#Mv9dxp-RfoQLOpJQv_$f9gJf%nI0J zkG;Qs?gF*kyuV)GTF-X*-~X-H%jG;8b82hsFrd z^ch0_2x1+tFws_bB=i}gR0IkPi)g$q>^m{<+@_VOJTvLIAa7X{EG%LB&{=Wa`GY85 zCYIrLQZmvLS2RmK4m`u55%uf}2b=*`>%dKl3f8wNye9GB6*w^mx2HKBID{@;sSXKc z$A_T`;DQ>g@1e_Hv2n`Pz_4K6m!*gu-k_CEi@{cTM$y(ENfONWmW4^eYXFH@I_6R( z`t91(1ekUhapne?_S>aA=oAS?>GS)0DDW^cTus*!|K z>@3PJ%~D)<0OJ?TNl;vNsUTg0hYfsnbKTS>3Yyy6))VY(R~YPPfc;IZn7Oc`=L0nu zE4KX9Tdn6y7VY7+{$oU=CNFaJ)S_Xe1!k-|h+df1c2{D1`b?wa%bR*?_t~n0w36Wa z{1Eq1#HC9DdrhXLi6^uhz%;qW z&Mtt&r?R`W*u)@>)9wQ}wMhoJo2{7Z5&nI^&o{$!^mYGtT%fOK%O`lwf6!e=fL#QlYmWd$??N-Qj= zSN_U1O-N4boXwadw1WX=)U-nqD4#?e-YH=R$RNM0Y#q%M2jTA^e6&uTi85*sm%AIV zw-7)-0ceCaIY@n;Fv>1(H}Q-0(u}z}63W{VtSuk~znCSRIvq_LC-tMVpvbvb>r4hGE>_f%p+> z038DZYCl3KKYxj@;hs-TX=o)n3?N$A!5Ry#d&-Cjw?+Wv=A)ST=4XPio-Cn6=E_O! zF^@3(uObE+n;1^21c8dG)qy}{!p8Imm2M{@(peuyM3ap69Fs(5YX?{7K2L+I8RI#Q zB4U2t0Vs8Qj6}kyBbumA8j923$z?#B`erdB;=UDtY*H38zdb{3*Pv*Axo4<78WhbU z_YBnyC>r9i+2mf}Hh1wM63r<00@emFT0@}CD)$2Ug$Ak3EcXI=aW_Wtreo1iT-C^y0xsPkMk@Vb2>Mz5M?I0z_e z1I;Oi7bV6B+VLry{1#}#3U(Xg{79AQQ2m~G)4rcSrQ9q)D3 z*Qc+0bHE+%rG8}Hj#5ih7|5#r2aJk@nK{_WRn}6 zcv9|{k=s%0q89Eda@V#v3C%`w*YF1526E4xQ&kQBn;CpvGvT?7+zn_^;J%yOP#DzO zZ(;t;tnqk|+;ggCQryRwyKF%v+}oIYK0AJKJ9DcG3FZY3GmqS_a`(b=xOX!5tod{? z+q=wN$^1WL?&^gn!T(dZ$NO4pYM0`|J9fROUV6GGYa>vE0KVuVi#%H6WFtC2Oa}E@ z%P;`wHUQ<2F#>}Yy8IG7b?SG7MPmT8bPflwd3kr?eMC*t0LjZv%%`V6KB99D>Ksvy%BHjdup!|_QMabW_P&g8{2yh<*PA8G^ z3xXH{tP@~qq3i-^I&8R3HmnTqjNh|1gjAC22)JJbTvaOmc*a{$oAW14)V?%Z50Qqh zfT!7;I-a{HVt*zsTg}YRAQz+~mC&=oIzh?H$Rc*$e5nNnuaH6}Fp%vg3*c;A!wZ9N zSn=*e#33kMN;E9+D+CV4C{Q~xFlYpQ6k)h-6>82NkhoeLNDV2aWr!f^y2~u`a1Iij zIm#Epw<4S*i_*rlLf|@i-78ob?gIFzp3vD_va^8l=iXu1ik0<$vB*<2%83$oMKO*s zt#LNk-P8%gy|LldXggwsahOF~;DsFy@`3R*8HGYM>On-zjhtMA6Za%T3cb!HI13^| zqIX{&q3*Io5f$>dkVWh<={<-(B~&VC>2fubj2;NS>IxK#MzEnvbj8IMKC_k8x(a&? z;FCiW(JlnV*=Lb-$`^<-zNZwlsF)#!3q^YAl@=T;i-W7fIJ*fUnta*$mCP-fd9ZAv z@YsCnBM49Amp{9k*cH!VDBc1{f@e;7Silzu7^9KMaYHm%cixb8(6;(2i##lq9W77z zao&V7PRTNc1~(!&m_V#VG7^kpWtz?pT)%Cmg~MqCu@64A zbi=xUPC>R!6!G!}XC47aUo*?#_bmK^*$ic1V)IAg;dwcx@IwgKdRg`w-wLc$;1kSb z7`SwO0C!LrUH^^nTM@3^3LYHS?sBqoShoRSEGL*Ln}FGYE#|W~`W$r})u(_Q!2ABy zZc>2?pS9T!|I)9};WR(l7((2DN5CD)^?2z1YW9Yk{3+ZF4{f^v%w+=-0>@t)p8a@U z1L#^prS4=PaM88a^eUzQ@Rxz_VdSUo2S_PgL4SnMiYE$B44$Ase1wLBn2i>BuLakd zGI&~Chl7T3>8XIrPX%0o%I~C&$9n*tfp`Yv8HxvYKMQoX>=-=Bc*fyD3y3RLarZ2q zsd$R;%)m1T5Bh=vF4q+tc%V+$OzUdAufp>`c(&kq8qZsJh+&<0hJqW!z?1R#@LZ2) zJDwl#D9Fqyc-G^22Tvjx-+<>iJSkwpm3S;RTzHKq9t`P#~1Tba~p68I+r;yp5 z$ZR(TVvqq|26!X2Xp;n5`I9~pfmRS-U%EC{E=dTwSu6-|xG)3V4E!`}rEa{=P-PJ%(ADSw)I)$u<&T7Q_YUT0U^k>Z0Whsc7!g|| z?tEVX+V%j>Z}orU|JJ|H|1bX!{vZ9{`M>vn?*GES$N!oCEC1L2z5Xvte{TD^^ibQO z(qG$tE&ZkKm(l}m2TJ$1?JqspcChrPwx4jt?|s6p!kxkskdFt2M}^CTD=~V%Sh!KR zSy(SzE4(Yb52<-u_*nQ<_(1qbcwTr>*e*OLye_;cyezzWch}=xYrC%R+Sk?I^-|Za zuGFslu9&W2T}!*p>6+bjTG!p(k9V)_zP@{3cYF6s-MhL|yYstaP|KEfpVK|N`?T)O zNA?_1jx0X1`RJab%F)F~H@EL;SK1f1Z$7-|uyT0u;mS@=XMATy=g!XkomY2m?X2wZ zbi{XLbnNWd-*I)v)(-z*{~$kZNcIo#$NLBR6a1t6iT*ME(f;B7Vg8Z+5p8`+`?SfW za$8JkOj~SeY+Jw5er^3r`?tlF#px)8d#$$yfVFK!5p)d{0G>e67ArrMQ_cU>~cn)q*9wx?!`C_WLOMFRe7x#(R zi)+Ql#kGc55IkEPPGRk~W*FYS~vq%D}^;_$A*6*!9 zSbwzc-?6{^z>WjuKkfLb{NRp*<%f10D*t)M&*i`D_@(^U9lw^h-`>8rJ>_uS;oA@I zJ)Cl+?#S&&_8v(&T6gsJqkE60bkuch?0C52osL5tgF16Mt2>)JH+DYU`A+Ad&Ou!{ zUDaL9U6*%l>bkdUTi0t{ySu*Y>gbB=PVAoCUDQ3d`;6{}?pDaq)sUji-FJ6yg+#SM zmUcp#_CT)oL$WZ7eO~Lz)|S?@TN_(ltzS>8XkFBLa_hX-Ijt3~YHLYrQENeK zersN9PHR?cMr(TO#+ItF$m zbPRyN^)KqbtzS{UZGDUSZi_35+a?#u+xiss*%n(AyDg?DW?S?b(TUN!qc%mI5tSIV z+qTJehAq*y+q%hmhBeW;TiPTwNOPshQk?Xi-OV<1u1~te7glFMK4)Wh5iVfekLs>F~9%)&Vk=K@c$qO)UEfz z;8LGf!j6$lXaDP0%JAc|VS&d{0?l+F2i*)|cJ50W^(#+wC4gBZwA@gg>kHhtVDP#{L`> z{wa7$@xWMn9|pO>+0s+TVOT^k0OX`vSg<{0sfN!T@EJ)f7HiyYI=Gyib|3ayJG>gn zZGcD##Gw=0|BN*Xgar5Q!7>I)u~3Wnv6nzYk<~fbWC&JMEhh^a<_L+BwfCb0dct!v z1%~2b+u{+k4T1icl85(Z$F4h={g(&DoFb)9&e#zHa~A(CG3T!L$LE}Me`Zc)VR4S< zk~ukJH=mO8`1-n>MUB3kwYRLw>5wnW*?Q9mZ+E7U*&i&KeIk|<7Q*!^Y zpf0y#oGqsb9rxn)>wQJEzV%ymjizmD{FvJ^s?vSv%gHy8iAjrndWjn%Xu(%-?W+Z2sZK zg#4(VM&{QH8lQj4ry2RX&MeAbf79&zpKf22pM6Pfep974|Ly2i`OD6_G=KGJ>+>gl zbW?t8#~t}gpWm8aIAdG>#PeUu-+a-#`5!pH$lo{lr~H2%5~j^OC3afBvV>_T?-)7l zkuSzgyWsB`({3GKH0}Atv!_+nFPe5?dF`~NvEFIo=l*FaGcKL>KWXcyoxA0xX|=E3 zG3|zRTc`Dvw@s@rduf_H>)mNtW51a8{g(%(je1iku%*WqWDH9v_}jH33kE+luHdm1 z83nCB78djwKfBQc?-p_rEn*2cVBaLb<03!-m1P;kcIguY?)#C~~%Q6a=JYHDn z_;yy|ynj^}p7~5o;ihxXF1+Acf8i4c))pRqe_i3Mg*O$dXWdaaVba#Z&o@0;nDEAn zg+pI?r%<{1^TOQI4iw&bp-^YY&apAb4>iCQz$Ew1jm$uF-`tqLY zqJ6D3MepRCUG%2MUv%xuYl{lDtSf3uxvA*+X?GM|^vnH4Upk*GTD{@LqJRA5ouY?N z|Ga4BfCEKG&lHL;eI%y%)9VHlTl$SGz9MN{@jrG?DQ-Nmu()*jtm1VI)x{ST)D$QG z;3=MTlE3(ZzpgD_yLw&m>|bvzJ}vf+;-8+qzqmd9$ztgbFBUh>d#Ct};hz`3^~(O@ z)ANOr6<5TRWH$~dxq8otk_iV=O49!}rR0)Fo-+l=uYOJfJ<13t=Y`Y7lkPNmSm(&wNsnIaC1zPKH>}CYfH$85V`!Ow~uLXza zJ@Aa;Di^&|d<+d!jFd(OKwm^?0xb${!Ndh=HypxIM{4r}1jM1)I(^xhP^_%W`z5@h zNjD zZwHX^TC6!GNs9*JeQv zWnXPVypmB$&Z{?XZQHpA9S9`wxERI$V*14OW3k7l=M(j8D%inK?J5CurVn&&z8wygBgb@#*>H z)%7F5psi0^< z5^NS*7#>MvzusdDVzQ`+Iu0H~lm=LWfAO$Cn}1OEK|jJFbwAtn*RFM4|1KTbQkFE< zGS)IslGo(e93QINUs)C&vR7pfrsbpmoWl94< zl_VuY8t6y-mb!22s_9a@G8xyCxxU5-riLuNu@a0GT2gv zUk-jYsZ^R_NwH*uH!3XOR5}^RpsjmH=h)6?JO0|SuH)Y+AF=B|=VzVGwpli(?G&5O zHq};Vd#f|g=CyjQ6Y!g9^Vp)T(bn%E%Dz9ak;oeY!Oct>%~PV z$)VCvsn%L!RXb0%4z^}?IwXfQ1ivW!D#77};yAGk*89&o-s%8nHLhkzGholp7E47c zZL=)fx({~V)>+jlb#Cu?up@!Vv(j4~4k_yuw&k`Zwo`5OHp-*e#d2x&S*PMxhhMd= z0=deyc_sdvAo1T!>rAT$zZT?bsAZ_-Y$;l*mGY2_2Rh5eg`%VLWNEx*yro83EIBL= z%Q&%89AX(_87!4SvIlgMJm(-slt(5zmMqlRv6f8KSyo#iJJxO=>ekzx>pOj&nVm_U z37x#w>T*r_L|4(;ll-jeT4HUno@%YPHd|*|Pq8{Br{u$Ls&$c-azkY^L8_BxqO68W znO#J`M~oJ$r3$HB`mD3YQiB|fw=C9ZcOZ8piA)Na?CEkxl9z(osamo%*|U<)f&4{v zKmTj)FF8NocBtl%dMNV{lR;~|)u?-7?^;#t+F_@fKX`cE z;njz04$nB8bU5Mgf%ebapKZUjeN@z{_Osg^?I*WC7xiq^WC_WOsNwx~*N-PE6o+U>fhJ^%+d(y>3-I-jLpqKF06lj!!M0h@Xf*if@WX#GAzf zN57SxmJUm|NcTw}Nl!`li@U{k>s8j*td67mtS2A6K)OKMg5QVMSFPKuZtE}7FVZ*S zzrv{`O+)WlhPq+fwcX|bm^ewpkrTXVp(@&zvV0O zWpR`ArSyd53CsJ^dD33XUd!cDqx6O43(HOT{X@D(Iv|b_`{Va_%bzUsEiYN#vy@oU z#s81D_W;kT$o|LY-uK>@B(Ej*x+~aS74w#~wFF4Swe9NKw#SeJ$QqKEqO#vD0UIhP zU;z;jupu@;?2V3Hv0?|Ypdf;H4k+_`sdd6VGpdH$Q{uDmnn%$zxM=FFLyGiQ1l zUz$tJWyY_KJJ;hEdii>mdA% zv~%ri?BChP*u6IlwT4>9;%^B4CK=b^l=wE|R^wXZPmo`!Sz3)Vj9TMjqZp@ueT^2o z*}mMm+&Tb%7mB>qzMT z-q81j(EC1}&vTG}j*aiE-TMCK_cmoV&DxmWxO~H{8!p(e_lBR=FJ3=){p9tB+hl3@ z^c0N={HZzC-2UaZx!a~}8?x>4ZB^UO-`0Cua$64^p&HxPZe6zZovqKu8{;#!PTpD> z|2F>L_^a`US$ssiA^ubRr1+4nYvYH-U%`3m*YRiL55@lx|1kca z_*e1Y$6t;Qk1vmZ5FZpjE&fdWuK1VnY4M)%W$|CfFW>rp{O|Fd<__~mbGy0PSZ#b^ zZZqF9e=t8cx0){*FBz-MH_gu=>5myJjTa%?Zy1}6yNySUPmC9EW`7G#V!y*E*l7IE z_}F;Fc+J>=zwdGSzQVZKSZ{n}Ou*^>H;~Dt#vVr1mh-oqYxmxg+|pyqsrHHXURxI1 zPuc%x|H?MD{LP+f-)PUb&#|AhFSFNfo@bw8KVbjM{-?cc^9j}o)?E7udy(;P<2`r? z++;jxj58J*B)9KCDi=U5?}QxgW=uE!YR|F9+Be`Nd6s>)eZT#@=uldXfT^EX{*4YY2v z&a`f|N-elcTYrK~=0Ubc8l$Z%tO3?>)l*8KtbebzN>~REjSY<*i@zcG zBMCf%<*yc+ndX}s=;UKq7heQzymmu1>*AsqY2$veqcKlT-f%(eQX|guNFg-zAI(3S zN8#^${E;ni9%dG44@gU3U+CiAW-r)kM;N4!lLpN$WD{JoZNtX->({Mofky7J>pGcj zg2mgnz~-B=eUrV>{-3?UZnSsC*BmWQoT+rG9wfhJvL8ry#`elXrN zK7)KsG#)i4K<~Z?`FnvS?OWqjW4!U9@sqX2S{qv%I}CsJHf!sJTi)H=viXS3%P~u| zY)WtX4o(@b+0WZ6?3?Y6?El)&*-PvZ_BVEe)nL7Xzh~`-?0?w*vA=>F$M5Zz?cvsN zxO6PHKEU4~`x$%4mS0=vT9T~ zJ~V!;eXQLYKO;WG9%3Jeza0Fv$7|y)Y$q1m7sqSj&Ctci;ID7|qIeT@G3jOc`!nnD zE1}8Tj03FR>yztytUsFd@LuZ+En_`tU|I{D4;#FjQEe3QI-s9H@=tcRw8uT2yf4{N zSa_z`3O~YK7qBg^t$kuU=k2(9N1q*s?}+W#Y3;P$-&VWzqAf>mzHQUKn_5^?kKWL- zA-Uo34Wyxs4X(XHx*2~vVn4>V$G(Vdi@g=w8ha`BnE9Bwh30zmZu1uWZHjG-{m=ZL zxdDHT_*-vQn(NFzVD>IEY2H2ze`{lV#^!9l6;|s$+t(N~x36a13atuTf-HwmV{gR1 zcWj5(W8cLl#y*C%@LKHo*oxTAY#n^d*1_VfbGFXh+F*~`I^O=8Wp>Ec|JW?C_T^ib z+aK72?9(8xciGeIp7t{P*Y^AN-|a>AzwP(zr|p~UhmGf;iANYq%{|Pwp)<*zcoyU5 zE8|P!T>C+LoW0Plx8Jo-wcmkeR(g2>d~!%H-|1@Rsx3-0&$Um0P9}Z3J9Mwox#w?w z-0r=3vVFF7wsk+W_ZWMyo!p$uI(V2h%<}1A(!W-nbr$|ecP9+et|N`fo366%(RA^_ z7U|(DT}^y1EDX}cN(Yk_;n%-pLkwX{_&{saM$)>MTSGP$$BJVuw3dPHZHMm}*}r5F zlMW_(*weoILno8vMMt zTRb_riQTa;1F-qL8I676mkv0+$LwcYZ=AjUq}OKu;q{z3w_M(H&d9Qh=OAy+A@gsa z^X^|Bp7ZV#^XBY)`I9+6-mq@Y8yn+uthm_at*}Z)8;v>szCmdIP z^W{CuFZzADd|bMuyibo)%L@+ZQ-0=tXOuS|a!&c^k<(D8x)YR&>@>3rDS2@~O-t_R$^4h;$TmHeG!^)pscw>3akP+oioi?(3_Ri7e zXnXlfH;pa7@8Y}47aTdU{D2LU%I|pfp7PQu_m^+^_k-o&OZjsrKUV(8VKd9`jXzO7 zX3bOOLqB`A{2y<;P=3_x+2!C_`K6C8EPwgISIXm4UoYS1!MDo4fB2p9VUNFG{`K=q z%E8a_H$VKm{Jig$mH%)1SLGM)yQ2J^6IYi1aOUdrDFfG*gV*J6J+iU9h&o zoLTnhfagv-?wrGMmnL4dJOI7d)NB4)w&a#v%09ks?P+Gqq|;i@`0Z)Gnm*^$>s~wN)O{xpJSFvi z%_oD3AI!u^W73@em0k4Kf68uHJ-F<(qg%`Vadmy!k^5Aa4OwwXS>~X#%L-pSrRiY6*qNAabY(B9F+VB8hBl*Zzoo zSt^Q(AXGvjPyzuLkbP<2yd!#FdyFU>F;SHD+5a!SZt8E8T{YJ(du(Q`*I(Dg%F2$| ztL%`?FO&`Zsax5v?l`KfaQf|KC1ZClYoC8+*~we3D*Nrp`<0zJ|N63tUtC<)@VCRt zjvoAJ+3Gt_D?4@e31#C?xu+MXSc83i99>b^IjzxHfmpijbTRDa)5RT|`-&aMEE4lZIrWbP{*k~x4Y<|#T0wtuzBmu~vzJ$h zkpqDL#sV?j>I)Bl(6F+v*zcr8?MEv7VZhG-zZkeR_)Z6YpZQ|Cak{wlqYBYNQrm|YA00e0z2sQ+m2|Az%)*4}+Z zuj?zss@Z+TN9Bv!d*AHfp9lPb!0!RvOYw~a{+07Zcl6!t>FB?`P8S6m!N2{`{^5PZ z;g9zfBhFgXzHYdKUjY1n1OH&){vBU_A0e)tFM6%75MmO_Ksgm+q4?8*eMS4=`Qpa= z`iftlzexP|CI`Pe@P`3^AK+esPxKPqZ=Nrf{#YR{9Z@0L->nc2TMNaZ2c!Mg0&&9F zzT(D97Ktxz0DdpDKOgv`fu8^_$>54PqSu)DV)l2yZN~RVg?K$@p*ZCbwEy=D#2z>G z6|eq%QTqYI9DD)%iNLpj`#XF!bH$~T(0=rNdtdNyScMq7+d}a)@TZPgAnO0!SA15z zNc`qH;J2gxrM-lh2K+63gg6!W_sb~N| zx<&2#U!&na3HYt7J=K>%7E{*{Hj=7@ObHINc_@($gvRusH5A+`d`Lh>_ZK=NE)7C{I?|)~&T-j(Q z{wDT{Ny8v7u^Uc*^2J_z$M*43)NlGPeOlHYdj??l5U@1Z$WUeVet46ah@E3~7rh_D zzj9BptP^70PB3xA^fZ3s5Hpr<<#dnjcC3kW?)gZHpI~7Tln3JQV~O$5v}u{&w_Trk zEq+Pns5AG@yj8R!z47-?r*9ZGEIs|XKcyS(6Vf?7tn^neEKYrK)%~d+IYU!-)%`y8 z&-ac4D>C zr9b`iEooe3-$FMU&pj_4x^?&*a`vrh9z-4{6udyY?*A6Da3zqk)Wv-7uJqT)ETj_E zoj?C&Ks_UL4RG96U%}d?JIvA3k%{YVRBO;nTRI-T3V=go%~>J}d<}?WB?K-7aa4#F z_X*oG8$cVUDQ}h$+xXf%)#!S1wBkJ&I9bxo;@T>@b@vc}+*&WFt-UP7$%TM`f4N?a zd-JZcvR^a#${_Y?buCI;30N5gR)+0?FNdVp;T0ZeVG;p)%XYrGO2s-pjqF&-_ogcG zn2h_H4Ef(Y0pNq3mPg)$eG32wNPrsLll3l5vMb?4D#_5c~uoOOxVFU28iHFjvUF|=y}*nuleUYfs&#AmjVhp z#}Kz335|tg{uwsz>cxck#K0_wZ;23MJU)tO`WJjqRJap_J8Afi!Pgz1=sjsC7vtGh zP^Ye~_0Y86kbUL;*7M}QXH$MJ(R-;ZhKl4z9A@Lc_;3Xaix>P?`yUk#6w!{4w0=82 z=YPE?wZ{_H! zy@PKpzOV3YbpA^?^uKlZs1Ef}K9#-M`G_X z+y6e*GN`>&XSRCZLmu(!1AOX#s&CbA`Y-h>@vO7|iHTFLYZu)RM)oqyI%dw+IoGs{ zrTYkRavp*&xpCM}p%>wtUrtmI!;JSlrzhrdR&=K(C{|Nzb2UW`!9t9FURmAZ{4Co| z<~BILdnxEDc;Q0+-E8^0PcFdgS{qTK5aslPN*>fi`bGYzYHEVJCKhUY;I|&CBp-_j z470w3G>Cn6F?Z$rfhw;Q`6d<$IY{o`h=N3ZOypa_Jab>9$RH^)*i>zEb3>zH9^Lbt z7DTA89@vv(;`LNl3n`k42Dl+EXb_)8bzjK^!x$C$HeVh;yBpQkTnj7Zoc;07`o;kW zZE*zxm5_rg#~U%s9Ldq18B4?s^Qb_z(O5smaXV6+OQchoxR)W{z$2^EF!P)e)2Y%4 zF_Gg{Q547Bc(X^(bI6!zsIIK+i30vr+e|@+D4sZsqW)EA-^3X1>gRXEltO(*HBiAK zKS!8J8?EszR85+=tR&&(tH5q?dfb z-jpo6(M`?I^%_xV3wTT&=x>BqSvP@c_(CFp=yn1R=VR)-Xiua`I2DfgVv7GwU=+ax zp5X`);&4*rCqzExt4k<$yDTUSBmSh=L-BPnqmiHzF#Wtjj8Y12duB)xb!1xET&dqCM zG|aDFXHXGYSVvho#JWp$Hc5noqj)Wg&m}pmq8cF94YcARIoTsriIQa7NXs@^aI#L7x!=58Q1A9HXmDYh0wYHottbuH6u zn1}is>CfI>V9M@K0_&wq!VUA+*$^eb9%5gZSN^-T*fi%Fq8lBkFhIv@F zDjkS?3b#>5-0WZ5P%T?1#6O8yGC>W1%Sggxk`p`HFc0w;?#tba;(642NG?T@NKWqF zgfz&bhWl1D(8FZ>3@L?dqWEP}p~$YngI*M?F(SXI5%Kd`%*-Zw-8CBst+G{Fms8}? zY=F4yC*cs232%o{P~iwrPk@ElLeZ78!sr#ZQWV#$kg6BjI;>N&>xvFbQVqS59(io3 zZ){a6nxh`^>oCkRaTRej06;evIUq8{>k{T*((u_p>Z=ALKB_jwqzmqjiGvOE1i#dD zj6W$xv0wg0F)0IpL?z-*%Si!CWAw=X(aaeE1~Z>^p})0?r~jdNwE--iX}pP~cptH+ zVIJNg;f%5`E&Ki(L57^#|3|X`J((a`+-{J4Lcg7$TZWk!K))}(kb>*(hxi6!h(V+i z%;jyhh#-awA@qWeEMTZXla7}e=%1?%8aWZ!s&9_*w3matfLHy&g=n2^uV9`LAoGINwA3! zJeGCA9ma_r!0~o#b6XSk+i=Ufb^zUH8`E_REG~$au{^%08>Jv&7}qr-I^19k&zjn+ z40GQBFi-okkew&9aLxH(O!JfA;6^jHW4zW5YN>9nYeG~xu&3FG$eUCPOEg`6#~Z)R&ILP; zSlhD1AQd-(1(+&t?x)_8kdfOoDJUu47^5g%6Ip5;V16$EW!Auou7bsZ4J3nJI*{b3 zhuoAx^!7P1GA1!&P$6z4;$`e`eI=V>A|uSn2F;R6M55oLHmCT+jrU5~#BPx*Hu-F| z-k8jKC_%%__*JH=rQ?^z*Tuwdgt*6`i6Ou=s#%!#8Z_Gm3nLY!dI<5sSjl279n&BUzfTESerVHAsy|^R#UnE zoOF^f(#e{VO&&sPPFLrq4y8%g{h9uiI8ghU`87;*^Ffv!=S>BSrY5cm3uf$lS2ZKJ zjC|n`JEE*r145?ep@+C*0+~F+nh&#>U|et{Oih=wsWz|~PZ74YXpAc^_$(%RWYv5w zH(;x`wl#eU&8H(LKWB625hDYpduu-@rYad-XdeU=(~BdggX-$*>skMere;>W^sV`#UplqBAR<)Gpj9CUfl^&+m>DYX%r=G~t9JV#YlUZ`5 z0r3>eg<>cE>sek;8?;1HS;QNyDMdve#zZ$^KEtK!K;AIXM7iiNajf>UxVxy*ewOqQ z1GS%}hl~BapQ+@LBBuQ;I6`1Wt;S5M@EBii`Y2y+(Xqat#mD)6mi&f#!!4@xcyTyZ ze1S%L?df^d@|d`1caguJFrSr!O&VT^M%?6q3G+FftWHlG*;$a9@DNnniKj)?FSQMLSp?w@VG}aNEjs9ImM{exBuMM?;`B0X zg&F3Ne)X#`{j`3Gg%Aarq={ZZ5WUzD!bv~td6lem)I47*se(pq63u4|M8SqyBE$lp z2zxwf5#~ZRj}@+#RSB!KZICweEMmQ(AR|pvAztQD?uQE1Tj~&J0Gk+|Q6$VaStB7(!eyvg>L5?5 z(*-Ap62m;m-)CCQCt?y5Z%KOE@D|rqWbeq)u0}>W*;B;fBNd$7{40obx`0*?E>h|w zk?^D^SzP*|LHSr>`t18Np;&s;$f#h^>{(b^xIV7WgXv6?rVzK>!j$i4QQG&jI723k z3tUnt_VRwFGDi!``rgxXNne7&wIT=o{ zUOk1U_zdF=|M>%j;3Sc;4#AMuxLF4Nn_6KAd-sL-v6X@9W}6s>(1= z^h<*#_R4hD=l&mgq2unOm!#IlL}_Si%qM?qV#IbArKt3inAl&44|KDMh9i_C#fbip z#m_MtS&v{ih$YMsNF)1BaMWfYKGH{yt57~>(WIZwGDR*=KQU+vNU;y|VI8lA+%7^? zT3(~5;egFAxenAitGF!t_#tlg(oMKbNpHk#6ragVc^*^?a%=kiVRTP8A!>udL}O^3j)H zvD%eoB8>x;<0;0fW+A@T3kX%f1ss3?#d-nsiX)KX~1$_j})L;3T4({sU#4LdTN35)NsI)t=hl_I2717y}*(6lAoyE~>7mwbbHLRK8uyo<%|bZ!~E~H=4o_4)|`E zCBLXTpq?#yVsC$!>Ld013+qc|&Y}8-?^1oFmVaS=>D0MY--unQ5B>d1>jUcVslJ=L zA}!v~*;Q%rF#kZ(a*IiaFN5l?(rp5k+L0!0-4J+N3E5OMw~R7r-^xqlVLLjQNF(&t zU?L61+X9JP&+R7d@Kc#u_)@Cu4pZ#|`y!iC))==SP#}qeVL_(|=aiq(vtVaTSU7et z>5z>Ic7T}LJ42~N?zm7Y(R)`gl?fitEDI3KWlu2ayoz#s6m#B0kK|NF@$+u40-4C5 zlR~LP;^a^&kvJuo$|T+sNg|bUZx#|M?>>)2#5s4m{C=+jnaCtQ5K5&2riN09#0P_^ zOyaai5()mHEF@Ci!!C&^M3MN2TY;0vBt9BSB@!PCrBboegQ-m7j3^R0XJ#~socFj% zr`03`u%0O>p%AkeoE9-MfU$R2gpF5|4xb%RMpOIN&Y|m*CLLb;1d0k*=KfPA9eis; zN6&nkTi`r+iaNZ_re~NWCx08@GmhZoD#xkD9+iN=Vq4`@;o|)pRLzJ4WxSk4b||an`6>3 zdwo;?B(dFN$y}A5@~6+^k{CX~sQD(H0dP(Pn-(xfIM-oP{((X)G}(cTYL|>#)$nLrx`8r3&49kLs7E7{}ES+W+-2Vav2G@ghs#&vFQ1x4|w=e zc36VU4|$MMrfe|Yo^YQ#U1GAUq=Se(EtCAg2v$ka$8L&Z*C$^4bZ&jBdMAom`EW&Y zH%3Z}uCc_gLnD!D4GAR8y4PB?ks8?RkA!adBl$de6%`KcdPPvXSEC|qnYr!rb?fKc z-FT-tFyOyX>45>ilm`LB`#W4LV@`2SxVyxcETEjLIKG_a+C{*Qmj|Qz>1!5Nh6ynd zXQqKsodxa!8fM?91|?ZiU5)pxYEWoYhYODy#Mkj4UZENvHHgJ`s-B3=-D%!&p$ZF!2l$W|i2=g5u`l78OecCn$z&_mUJxcCer@ zRJg6!Bk@|~YiWCoR65Z7f-)pViw;WmwG)9cV!R3>WeK*Evc?d7J z>VW}KxrrO%{dOFw4Y<7#Y-BKGw)FT8BDGiaEFFiHbiX zV`N@CkYN^KNvpTe*Y?pYBX~yRvOv>sWf_qfftKTri*ABRm~g{yvIL%Nye&qSy@ZKq z_wC%-UN%<5F8gcn7WCI33vOG6(1(W$P?Fvj$*}Re~W$G zn8JB@=P`mC_b@lyypFlyf`z#;g1K=obHfFT;KqH-4IcyoEO4{kM8%B<{K<+NQ<)ns zbQCup^taf@jcF`2HMLNOeqH(y%c;yD%CSmknUpDts7F{PWm;6#k8%TLKAksSN$&?e zrX>~G-{%oZny zFx+(!?gMkXoVn3O*!ih&uC16fnz+%~---!1u=NGbA$_z>6B5txwi6Zi4p15T`mCv4z%J=;h zu3cslN%SwQqqQOl#R-t$9+SVuU42Dub=t88((p!lJw{sqGO?wtA6CCwLPITlo8HtC zY8o*R-r~kc6gcl-%j#_n1S#+$(Ll&+7~UYvU5V5{yGiwQ9Yws${U?*Fn;TmoEblQB zt6Cce)m1x$NtV6O(&fuQgP$V3& zQ5#<$#pr@xBxJ;B`?%wBYwDV7tI2%>_wTbqQuk_*pR#agr2xxLR;-Z#YIJ`dqYG1! zAS^bX=M5qe#KAN(vaJd3 z7TE!*To3TO>=I5Tx_4K;kI_|;$acXu&jnk_HlPmXQ(~(^vPaZ-!^8X`BzrD^TDJsD zGrg_=ES~CyX|_5fS`h>7$4J7oQL`olK6j`2l0O}Rv9 zadRDOadiMozHIW4nm6ay$H*B+FPvC_YnAf0lM-}3ZFOli%>C(Tsay`y^XjV_YB>Z= z%Q#Cc#Xai%wA>1%VOnmn#2U>{urPHo?S%zz^>x^oOW+-7ZeT&u+e0KnN>m^L6fsbk z8$)3I+Ug+OE%XpoeQhP*xfclDN@A&(Cb<&;+Z-z(FxP2GA-D`8JzCW;0GFKGRjoKjXp>iK2fK{R*+7UHlF z5K$HYy1@#LSpuqSz}sx9QLsO5w1Uc#pm0Ua4|Y?iLx`-14jFFI!cS*90ji$m&L6>i z4T3Z)A-g%mA?ASFZMQ_{yWKX@3XTPZ?~R2~(J;QTFghe!RE`v_TSL61yx>5%EhHff zrSw!53AsJ8eTswFiiphjBxnq`&GE?eoK=03+gPSQ1Vde~&2V>GWKw2_Qqx?|zz&3T z2KB0Tiz<(88!c&?-gQCmv&d)) z)lHzywU@U+lhimGT?!mWU%~E_mClA%dsP$c2QuuXiud6?VDYJXaQtE<(+YDc51@!) zO?Q2837%}RFs)ax`E#cwj)gx8PYzxQ;lVDZS+oJ+2Z3V>>ohMlJZ7-3E9{(9_Y4?y$}YmN-r;Dp@em5(u>P91lZ9wZ}HON_(EAIh?B|vKK7c z@CfIJ$BbTedJ<1Er$o2Hqaj=h0$kyaG3k@LErA)ronVrgDVSgk^WLmLhBwBiQtnK`&>J_KVJJtG<`NQlo~cEUgEJGW-5XEjb#Zxn`eW-g>BTL ze4e}uU~?=wj>!&*>z1s00ub&Hl7VjKu|by&#u>Ecd=`xWltUF2h^K~~8(5*`asbJ# zUKV|yMYrh|u)P?73=LoH9!loV;wZxmn2(*||Ap=crTj7#z=>?q{g{GuQ7W3sqwl;9 zONtVArGP6DQg5KTu_h&`1sj|XTB5IBPw_M`M^7ku2nKM-dI>Zks$xg{S`hxEe((cq z0(pb2^bt!`7-rcnH^(ite_eA+>vT&LYQ&~eGc0koo{*ktiL-u5Juch0o`(bV6go&*Q184N4wHUtfb!H2`r+9C=K-{Pv8My$D(-4Hv!QU#-q3&_TLb; z?`@0Dy|kLKD5gk>i=#{eSgBRmr+FtTkIVC9D_Kx{3*RxuPMzzX>uw)Fak1cX00g%JZPo&xAg`uHajJUgMk-rPT!U1PKV-6$B z31lY&$soKw*M@YyQY(x3f}2RNS5(#2Q&cY0OXV+>_OPDeT*6((%VeOC9N`#DyBCQA z32EhrG7;gEj@_0=XUhwWIDFuK4i(M!7{9iZdp7c=E%S|~ZZ#lD@$_46B{@?g(c$3= zZj6)WMAwnc{Epe^&vDxMJ+slt(pa{VS*E8u2&CM)CDW zUSvcAIJ{kx9YpbWEgOH4r7(|wQi~vp?5ZxcVp7saS;X%MM` z@qRi|$q9jk)IzQ<2`s^s1P zMCpBo*iA!87u;`%{q%(71O777si^^!^n?E9r!&(65QPuC(si5SfDM{+`PuXZY#Jq-L^OcKMM>KkjE?CNs+rdbEg4;S+{9Oly9o=t+YP zVZ1Vmp9(;fJZ(^T5)Y#E8Gk}y!LtUrK)Voy$>;oq7N(vzbZ6#dVfqEXXcuN)^tZOK z@Fl+l6&B6*_ibVE9Dnl*OXeEnhVRi)I?vCKqJsH;h@#{Izc>`77WyeIN-r`foQ+#( zQRZboPm2m)@sEb0qF4Q-7Ztx2sJ7&FKMRXW-|#oCxZq7c3yYI)`I%gt!t|#%{RG8jNK4X~wyGq+GV z4CF$<7TW1ql1@2P72IZ8aD5#O)?wRi+C$KZCRp^`0IYZdutRJ*s|&(<<+`!IhDHK< zg}Q)O+kEeeg3GxrrqDx;2pooj5485qds{tD7|Z3vXw5ea&oO}lq`Gia4Tl}ZCG zSoHNFcxF*n_+gQaa=ez{1suwDdZ!uj$Z$+&(>Z65IvE7)rcfTC%Dmw=M;Z+9it>1% zQoI=4vkd{M0yLnTZ8}@wAXt@-!Ps0YU8@Z9Sl;^$W$N_GePBG#0{7cnxUnH{HH=5v zv?U+Prv9K3;W=#6!Bhw!Fxd6MoBY(EI52^&hR#a(%%GF1(KcVBryxgq%OghNt=to# zQh9N9n@xM`p}e*R&b>XFBX~}Lp9#3brmf--vLhl919(h!1aH9UBYvz+JEf5|c!scA zR^4gS$+{2Nr@6=3wCwWbv+6eQ3NwgTmb4@rA7&8e$;IUao6ePeMe;<${vvW-m}t|2 z$_Jt(>Tdh6=qyH;%eF~jn1Ddxu*l{}1-d9ih`|(_7RWwAxRdX(>4d_U?sWgXVbWFC z-xuzf?A?BUG;nm6KfwCfM-G)7?(V6~nWm}%SQz`jd3;OeKggWP2BZ368V}rTP*gk4 zBCvLSs8cxX%VS&NVVe%RIw~)^>5nj|9TM&m;Dny=@MdIVvv2&(WNi{b2=$d={)V-6M0QwTf6n^)aaPC?2&!Lav5JfU z2#g?IC8xeH#BU6 zJ#EuI&=vi$UrTSah-Yltb5g(Yh>LjEW_M&jI3cf}b5V$Ka3yyEoNa~|TmWhojxpTd zt+n+S5HGpEWkA*0tW@1PNuIb%`XdmbFz0Z;M(6UT*j!fhSpd+0d93N2V0PRz)&}PM zh;+nvH5Y`^nQU`mD4m;UF5-zqFJJP(d^v=`3^QK|AxO@eud?pdOQKFeCz!8=ilQ7( z!ZPX9;}%6Jb(aFA>6=VFAyrT`$(N8xr)OEd{eaTUa8pmnq%%(dLgXJR@_!}r5i0mF zk>6e9_YnDqi~J)*KJ1Ryc~W5Jy8#0oQF?=ov4|{^syBI(4P-h3_EuDxQr6y%LUY7! zaTJ=Az;~juq%gi4l_ll!J)Tnd-9p&(D!9CV{r5hj%eM^!*FrvEYak-aJ6HRVMK=mW z8Wc-x+PPKvQZXLJiczJ7wc%6jF!K?QDFsEC+U;=jV`)qy;BgInB00CZ4Uq;1=|G=2 zVk&{?z`9jZ5V&6&UCGmY;H<v|ul&ng`mt!H4i)CtS>d=m7w(&^aNH;d zE+TNE#+9HDy=YMs@4$;6ie#5mw0ka^q;*oJV4lUn5p8m`Q3!G(hiTxSja9akV;&IB zVM=ZDd`onP_r9Z7HA+z@siE(DGS1@2vyS*aET@z~I4gaU#yzJmQdaSNrHEo4`?o=U z@Zr;J&NQp7l-0g|$UfQs7=nwQ;n#Rt3}c!G{xD_f3K}4uOu|>zKP$hF8LsZ~=#LrhL;*%wrFL@s_pxvVJmSbZS?@O{?@If%& zHuLya=_KcB=wfe=XGJ}ar!Qu>*vf*cGMQ9IP`9z5`f{Y8ZujxSm0%Lo9XxyJIM`t0 z5v9_UY1|&CwX#Z;1nDw8Bu+a!S5{q7OH%5e0f)w^m)ty}z%aY>B;_WCXQ{8)X1_X4 za_536a;}NfHiVl@dn)`!TWcGg?p+(s#rg*C`f&K3>*BPm_u;kdl7OE@H^phuFEeNWYQAj4s3fMq}rp@Z7PRd$>Qx;?%tAo*jRO*b-V?-VjWq*Uy4}^%*I1}oO+u|poE}Xl{E%`xJ4Oj&? zS2oo()siDBsPJAmlP@LW&6_ywuY_=XD&!8XGz3E|73P>YZSRCKy+;+i87!Sn-4~-1 ziNH>L2gtAR?W(cdks&aL{pOu<$9>b^ZthcO!?OX35kwAZyaJ1-adGkj4;2@Jm%B@M z#cAg#1WlHo^X?Ss)A2k|LQo{w9C?322Q)hU<>UFpIPK$y%F}6Nk*4tVcgM-8r7N(m ziih)f{M0C!*W4kUaKH2ecM+E@-~&^NmfX)Az^d z@VCgXw?jpRhzA6GA>Oyd3GhFU(@|B2IINDuv^X6xbqYw9z(bv@0Y|=?27A4jEGhif zAm`t}YfYV3Nvqct*g3=IXXivJ-S$YdPS=?wLA{|Z9__q%$=i^JZ-T!qLJM7^b zh`SpqA!=k0Ti>HR}qPs@l01Rf{PB1A<2@W?+o!r!~AV0?bV405dOU(3cM0Cg{coL zak^m!JjFx2)=Lbjgq4QC`TygcGm#j=CCMe+t~Dfpyb29LM9_FiS9t23U%OT)b`Z*U zfsNdk5vS`v7@`#0)moDaJItvH`+@WzCY}h8t3JG*_uMZ)mWy*BKOZmbjOSdl zvzq6_eL4rxo0VC@S1~$MvmwSg6aPn0vxq7ir(^d}=lgn-roVY*ZLoK8yDp{ew_(QRyNaOshI1M@nCBVHnOPMn+vLOctUM>Q|#6q0-A zO08Rq3ckPqfs=f+U8C+0utZ=fCB&i*)&p>-uC1a_;E-Q>8nh!j+kusK_K&>AeL0#2 zrdcamh*vtWD>Oi2$*Y}%Iu?$2t%JG5DK#*!;ee%coWK+!%r~O@U2i6x^_y=-_ofcV zXa8PrCQFLf7<6@{OLKK}o7VCa_g3d@gFwP6-nF^{yjVwdnQwQXoE#bnkMxn8$Q^I@ zkS|VXi0G^WOPBGb8Fy|dN`1*UNCL;l9hSljUvBBg$LYd?xiPwK-KQ%vd$2+N_b%te z=<%q<9juTX{E#`M3qi?G>~7g5^D0|;KeKuDP6v~Y){_4ROQ(}k*0YK6Zr8|&vQfHd z>1bp`m9l}!crSV)(4~xa)?6>c_dBq3oCyzqu`s4MuEqJ@F@5;dcp2lE-RvUn3ajc*3EZ3lxk}GwGF_9aBOsWOE-B} zvxWBW=$Ju>@A;&I?dAc^RZRo^rwS|i@I=d{A!wKf4#4g=wtyuD|5KVk8*!&Xh*fcN z=iy`tkB|r&JiNGg@~f0Mn;7SZIGxQglo~jz=kRg z=CHQV&nWQn88eSDYie8Z<^yj7I=2G*wYAVyxu3ie92hSjM~Ke(i`#fb>^kRk#LXZX zS1pClKcDPKnwibPA#ZN*S{2L_8+kk2ZL$9vBleCr@$!=MlIGbPC_ zQHSP?AHZ7AegK;_>S^fGYZ-3j4BWTU$}TQi=kvW>SJ8KJ{1G;=@ts4Xh-WtVub(t5jy`9q}U&lzy?ZGUX_+-`&uO=^XXPo?2 z-Rj*VwvhXQA4JOL3cve7alv<-5O}45F}*${8U7w2y><2_S6cc-u1s-i70&0PY4Ajs z*E2r^Xh^TN^vhY9;>?dQCJ}b5n~aA|JOfKSdYlLmL%PY3)=s`wivuvUn>>wl03<(1 z?uEFzn>VaZoWf5x*DI7;>kq%P1P z)%&Nzy2-Op&_u}28?-lgsf6dG-sts*3+qVwOtc=tgIq+>TJL zyjp@N=?tUWPz=ASr$V8 zN~e#Crk*(Hn#ZHN(SdEK2;CUCl}AfUQ+*xc_BBh6`8aS}H_|J90NMP5_)y)SBip`> zXU*HY$*_NV(Te&zxN*)?IAOMr=|;1wo-M09fUDHgWrf?h!m&)Mo-18oJO!03E!e@g z0K5AIK8&*ym-K|VGgP8#z&LIkz10$?{;qE15#r`a()VT3-9$-uyGbU=_-^C{;$|to zoeBPARr5rynI5$W*L*kE?B?k;yNR;qAzbq$uENbyHBa^@tD2{9&Gbq_xaNDfW;ai- z*-ex+59ONgjpt!^NY3GTv*yOOrqMRt?avMb7np{cQ4Hj66qcrL zvB~p3;4P%r;nFF|7-`eJ-MQW9=A;freT%nVwD;4*JiX0SOg+NCJ2BVW=-%dh79Xb+ z0`U38EnvCRa$S2+Eab5otR6e~+^u@L5}%h@u9yY>j(LS^31w8`1ol<#QklgZ_G7*# zXK>=G>;OHR@L$)d@kzrQ-Dq9w&`F%bmblJQwjAiLI9)-7aVdR95pKU5ImS77u;SpGvQ9D77d)PMEssbsx^Plva3>itW0=7jzI>G) zA^BNDYZ>gT^p&NGn z3!M%Zf=E@deGs}P5{7!kgIT6aldl{%1T(hPB7vwN4QP2}ZOm0KsD302732lp{hBAP zVB4u2j0`N;zlqGJGGzX@k#!Kh7XyDqBn*||!F;ESvX3)vCw$Lp-XXOKYEK6F=R033 zIZqBOR(b5SE>AsIu_($sXK?08fR0ajzF}yU{z72+-3Ws#g!J1x5a+gC1VW}EP$9pd+9&( z0M>HlrujPV5G|P-sMU&nGFJBzgnCnU4MJqF&hpZINE7h9s$y`cEix+}C0Cu$oCM$>EXN{`_ zA#yb&t=DK^OnqG>*tIzvV_wdXXudn#oMNua;U%t{@9D4W0~NRmi9Fv`F>syN3Se>@ zTk7O9DmUcNUX#Zcw*Yv{Ygt6RmUUC0JWqWM*K!ES%NdbFYkjY#h_LTBYaoOi0dh+Y z?RR*kC|0n@j?^-l-A*$(b5ss3s60$JRQzZygRtC;TeY?j*Sw(rw`nJ)4IE;X{5qx8}CODnygPF6`>S2~XmPAI*-Sc!ob^BXQ zy^t6-1m;H;=_*10Y`q}FVJ6m{vloW)nLamvQ4Sq2>6{^aw=yAK4gpXB8o(=|8mI(s zE`K$YPX&1SuW5?R5p(26Oy{qM0I8q|z&G?^?8=63_J1=3qO*lsi;CzMa*Dhe z7MI3hxm?0Br`nn+W}DyY_)<5DTmkS~6gnBp zbLg%}kU4&MKQUkBkY|1vLo+Y*3ck*v^X3l0{pEiXny~aG=eHpS6Dy)DmK8a>*EGWi z2Rf&j!lffnK+e9t6eqB=w~kMirfxJvH#qGm$o_+{vxN$jWwJ77Z&^gY!L7BpOx9T0 zmMnrpPEMXoW~;#bK~=5pubZn?fovW?<*RMT9~G#w8_YF1`^d6ziN6-UthN2C;6W?Q zwK@Ac>CVoum-SQ5eomGQC#`Y}Q&M}zMQ2u2UQ(2){NtH@`%dI->p;dOy)Qm}vTr}T zu%Kuvb|Q4<6pk>-ujC+Yug{as&R%)Ets$)D6uq*< z%C>Y0?rO9fpk3uCEJ#jb^qoQIqD&NY!QFuNYA-BEO$j6vPveBWm>5?i`<{E@Ltwrz z+jEuJ$k+uKSgIaj4$1ws-iAs<5@k;qmxp@Infr)vF*Ns(5T9B&#sIxs3rCsUqdUm= zEeo$v)qDLT9sRs6yf)VnVjLxq#*mF*$8FXXLR^>Yh&~r0_c^c6b@YjwMq8uiu-t?s ztv^TfGH>wJ&%1!G4yo*W<~gSe^Tyl*B#QLFlo3E`o0}UD4eO>{NAbDgT3T8WWKx*J z^$Z?bGDD2WmE9zlGiuxMW(BTOi~UIRmRv`~u9O6ek%}80WMEv3$~{cuzN~?sxlkOX zZO+lTj$YGBkz?c52yDvn27)ke%RMqwgC9n+PTZdB4ADR}aQmT%6jEC5$UQ!~G!Mup zGGkPK1PcYb#^&~jF6&B-esO2+;n7f9jbPHa+!H$m^Co0s>s`LiRY6(C`#M*qvM^3i zz2HiZgJMq9b69+2jy4!Gg`e6K<6L)Ek>mzS`-(Tv)oE&Bru1uD^v;H-)%6YVgt*%$ z4-WAGiJRo>5d|aVX|k_J^gOLc%qh8Q3dV#d2e<^qReq&x+(r6e*CuR5f zIx`EHPtNXFL(kb=Fdxu6#nD1E+70u7&}=3f@x85w*e}c!eQpapr=+`iIbG&xW^cY& zX_IGUc1UloSOrL2>(AXo7R86A%~g=b2bJCroTFkk5@K4m%zl`vBC74zawQ%Sk!RmH zsHh&anhDh70Xa?aL)O*S*8XTyNcZrRU+Dw=fv5b36q5r)~k zzfj|Kr!XH?ViG8qUs$Xh)KXQ0Hu+sqWqVYK?nuAcqyS@&sfi=9yt+YE-cU`J7Tsb} zq=24U54pu*-vlojDhhg5H`ey=pSqA<0a?ew(q*J1BmK-ssV>w6d$6gMk5(A*CtLLL zXf7;FuC?h&i4#Mj9ob-qfop8K+GhHjGnJJg$0`r8$8!&o1jsZG+-LD6ON&RE6e%@4 zS|ad9nG`*1R@RbffOesvezl{ypeK}S4OWF00973kU8;*hY7-x&c9HF1!e+4DF!ve& zZzZe~&&5O6S9165u<A7EJ^on=%A!3pl#)KM;8%D zYi$7n-ZWIxPXv!hk3QW&em~?tqok&-gcbrA>j)Z~>nuuIQW-b#IX4lnq$w}Un~x~vkasy!}_fg@SAJ_bP~1M@n_ zCmERUmjPhmuDHu&Xn%AfCoXgoWp{JpB9+)*b~h)!9PDmReI?Z0ocwCG?rtGUUQ^{O zY3y2e1DCt|nmCR1&byo8xx0sTvAY?Ay8HSrb~htXcVE}V?v^ykxu3fGTJG-GvvnuH zsk`6kAfLMXO@DU-3r=w^lVx{v;@c__y~JaaAQ!ud&giDZcY@u``0s|go0H#DrVhtP zb^}IhlM`tn^L@373*NWli259DnADa3F<3clI>xvmE{=jrU8hu#Y?>c-feHZbA{D^6 zk*QeHDHX&r^P?_M0l;0P0vIa_nJ!qb; zzYZm1Uk}cJp=74u+fXuBwIY<>g3mAoo9 zzooSw4xXF)VL#sqmi|NT?oL9D6XGXOZ zziG2Jci%u3_Qeo?PyCd7ke1QEz72tan(%+L1q~;=-0oVg6ZA$tW3GSuV`Ou9iO{Z;$@Bhg*PQF`x%>D_PP!;!*|4F(z#>9_$kXcXlA+#^Mf>j*+_46c-6Gp_Bes zE_xG*e78W)n1Dx@^lH63PoETA03jyjh13X1Q3Kk6cbW3^S%$HsWdPT~ENyQYh>?j6 z;=KLf+5okvW;E=mQI26A9hu(KxuOGct>T3~?0#V-X%R5|EsBQsCN^~%f^M%EQPsRn_+|;+&IxpaB#yGaPtMl?I7CVl-#w;fPVe^Sp();a-ZPuV^Ny9Qd!E1Mq)O$LY=*j^Y#+>;%rg ztY1@0&w*9-D8IG#nYj3iFdtXc^lM?K2x(H_kcx26Nz3IHOaO8o?ca#vTdMoRQM6&e zvvKjXf&Kc9AqUl6Ra^6XT+GH^YbT&A5YI_aoPIg=JG>*~1WpqaV!6d30#jEjd$YH^ z5EmC>Po{Gm)fF#dvd4ydCkVKS@Dh*DqdEbkYkh;7X2 z#Ku5k67k|UMIUaQ$jyGazYA;92Q}4ya5{z1SBcUlZl@;X|R-Sn#Sc56_jkvf} zm`^$SKykOJst%EA;LyPE%yEFD>)ymjg;&+nc}`i-bF?H^o5IiJVSP*NBC8SsP#rM- ziT`t4rOfA4dcZO2`8-D~i2>YguFup9N>e&!wsMRT=8JjG@Nkp{o9j}SQcOx^nWYK} z$FtMZuQf}>Bi5zvgSglikD@6B$>y;$^_a6=BK+?X;i9sh!xovu@#-%uE_y#6K0haB z10OH8Nk%V6q*rkp;f? zv+a$Il!bY44k3z_|NEjmN3XH)X&ZjDGhx1*Ef=dzy@4g4#Oa+H{}~fi6D$>YA7jO+ z;xM_X|dA*?Q?c*`x%(RM0N+RAY1k}>$S%1R2C#>J7rJvky& z;kxBkR`zSA6&}0|t82f&o}53bjpU-j3e@;nTz|5>u%zH~um=~X^WbVim61I~|0PxD zRVc#=nQy4(xI>6t?9{bsY#bDXGl7>fN@En3lzxS!n?K-wm#O%gt@(G9UZA<&5fj=>!qxIT z#}eVCN7Qa4kD>SS;4a4v=l7m?L=dptE(b{Pq^u*@Z*X*iOX;1~%-i)JbXYTQ)cX%; zv(^mQZ@K0VRWEAGEf(Y8K&PgQC0&K)G5%2=w!Dc1cLA8aN+x~;H-{Wd<9!eyHm#HZ7`%LZK5eE zupLQhn7>u(-6oE*vGbjm=M{{t?L01Y5Uvf#@gz5KmPw+Vfi3qlakX6%<)kt^B0H5av&L2`8_$j`rPt&fCxV%~l9a zB3u|=Ps=+rODUBlT+MnHwHoY(cEifN6_2jtLU-Q54yr!~W%q|7*_d~T${tvYz!)u6 zu)PM;rZhGM!Ou;3N4hm*;=ofx&4cmOduj-3_#Z>JYmv{aJFP{1>8p>2|dk|ElvCe*bNEQH$;HieZm#+#4%dcG{Yj& zM{9H40D8*{9PmgG;-RUt5tsu^Yi@w49j9O-|5%X^pFd^2qzX#!G4<$|sbum# z{|0fg;9fw8d^n1^SjqGQa2*u+$LndCsq9YZ0j2IYMNc8_NbKg&ODA9$b7NfT?O%_Z z5%l;Klq)a%ni|pjthC1__HwW=*`Xug59~hM9x7#Ekg^3(nmhVq1e$`;#P>36a$~uLSc?!0Txq zA*{beH^9(g;hUydgIxl}lETu0)p5FgF+~m)DoI_BcNNV&Qury4l)0OJuSYh|w!Fj< z;=aV5XQJ`F+u+4qQF}#QHO7hE`=W|7|M0dc-qsd&slxPPQyeMsPsFQbi39%7Z~;Og zNi>}3Ug#n#VpD~gcT91DM}4ZW@LiLl^m`CR@A;*;u=xD|M9BxJQ%5QN(A3vrsiJ}< zfrR8ofrQk@&#j{ExQm^DE7KBto`d<9f&1XBuvVAvqQcMo>?kVw+!RS{h$r$dr1?%m!zOrQ zuZvi0e5sEl_P(frCr4lMqltYT5@oIDsTeYkCHAC$`+%o|aKtt6rOim>pI3zl(!Ru* ziM{@a2POvjQy)+4i*{>(s`0ZD`}i}?lefyBNbD6z#|f%9rKCFvTg@g-ayPY@tRuQu0h9m)djz-O+{9XJRk+7d4Rp^+JljGexnU zQ1ZP=o^`HF7MHH%0A0@|@}zVy|HSi&-Og;`I-F`>NF-#wQ}K)V&2y^r`=vzQ=~vN= zDfyoi`6;cIl7dwxT@P`qElK|1XGlr)}$i?uco4(0tv-G2NFuw1rkcv`x8nFHu!5PO>U%V*{h{AwTal6pVrgToBdr{ zn%NRaDBNn2ld4N>Y0)-Q{7O$K*QD`|axEFc}#n129DOrPV@$;{0$ z+Bx-53U7(&LXu7vj|!AgGTPtW$Ow(hVa*kz0ZKXLu2PcgfKb> z5p`M-?(G|YGF48GT7T;rO|l+G5>_PkcMKJWR(Xg?7~gs3gOexChwnY}!AU1-RwfQp zMukk3hR+3c|EjHU?(~aQiT(XBb z2xVygl%V)=zVfQu5V{EW*aD9;M8Mn=!y$qBbD}s{1lEr7ofq|PxLmMs^Z>cu;jpVZ z)rC|2vroF{!I((u5XIAC;_T2HT|Tn9Sns`fqf0M2^FU0b;Ro84hVbTBxFLa;!#bfV zvXGhda+tZkD@3q^-2W>Pk%c_LL~KZ;cD+kAj%JFU<;mhy?T}{I3w#>Aq8D2DOpJU> zH+F@%AcqZe*JugizsM4@sVi02V>Wc&M36>;xjAthS|1Wl?!Xr5B}qF0@WdeR#$6*c zSldehrj^cSrfum8J8)Z9s^;wt zt#fvj4MF^ux$5l+iuvbL3^H^y4nV7D_XGlhm_W48=<4!J@-f(`dO~V?j24dN{(%)O zTAHTi4J!2@tvrLNc_=1IwW8A{5BqJxbm=28ftAPqQ(ex>sx!E*%&t;R0`<7xp2?(V z#q`7LbSCo@>zZD>TDWs;#m71%El=`NqO&)_b*;<(7&r)NU?0%uV*0DX=}gHBF>(Xz z5?ziK;N5$W;(H`>o_~o`n4BM@Wh6bh;~c^`&Ks3@4WJ*3QqQZF$L`sEGPeHoWAY9V zzKW5Pm@9Y1nXhAX+ni$V(uEM|UCi=>ML$lNd^OGAW1wN`7bCTbYH{8n&)}r6w|J=E z_}2r)h2O%Q@VjDY1rckU@j?!aUNI|p@k?V%aU&}zvE|`CAA*b<0CkNP5|4 za1&ybC?3KS%L9?#F$9DI&DyIxC@OMH`cd2Of*XbCFMVZ9%)}XohEjtvy4xQ0yJ;t zmt@kNbheo!vt)kn&3ioCw!2Nb?T+@6^dvK&B8cFEvWSWc$|ABU`woH#h_VQX2rhsq zf(tGnqQ1}f)IwF=Q!d@_k2?3(cRSzj_bm79=OH9>1Ln^gFz#IdGS^i(UOC3_*}yVI zS3G9*+~N%X?n2zd;GF_d`VSZ{5S8m`5Z)NB80ol*nLHRgA^>!r^FtGg%%M=@SPk;6Wf&(qn|_84g46;%ez5b7iDa1w*xV&#{pBj{{O zm+{+x`2jbKH1aHWg+m(h7ud$#Tw$FTxLKuzt{#QiJ{N<^UyNHU!%>A8ulEm%qwC@f zVLo(XuN_JAZq#+bkh@rH6s=Im*14zjwyI+ULK?NvX`+E+?ZI$)$__IAd6Z&phuu_N&Eo zOp!i+-)eP5WTekL$9hnON8O{H=EZSVxRc1_aonw=MLr9h&8|HOj|+(YmJt z;VD?_q+9Dl2dUbc5cW_0vc+$PxLwO-U)+eDM~_ELO&Df~@deCVu0`f_7^uxLQpt(RNA@o~v*w#WJeKAv=)^_xU~dknpZ z(_#PSCt-4UAkN2Dd(!yFl&(Ej_^G9zkFBg|T&Xp57mN7fm(jr-C45Uij zHvSk)qQ!4#s(xH1VV9k$229x22|?8t!-qg-yMkq83{Eo=k>^Zi*quJ<(A6xsNTmw#db0K3Hn<-bag@ zRM&xZt2MA$b?xt1t-(iChH0zdM~Gjtl)h86jA6-}OBUJgk@$Gwk`LPG3QfZ-`RToa$vcVRxRvU$vq_7Hd3dtK55N`FWKx$sF6 zDC6;B)FsfqhxpeeM(+uf`S=3l3AFzq3FM-Ii;o{Of#l3*MFM4sZ^XjYHLv71(iC+j$Vp2C}>z^e~+`= ze4Kaw&fJkpLko)GJMLLn=s!c_Q8P@du5)76`GNO5E`tubFRC$*!Fdm%6!8PxoQzG1 zqGA`N#9nO*Qb!wn#=R~!%?}PWQBTFAOaB-`!c4B~bFA~{uP`x}WoOp;3s#z_&ULzP z!Ms%_8hXzYZC&@PULUGsaNsrB7yVHZ!cDHLfvgMsSDP?(XgJ_QH;cGl(khGGBOxD7 z9${jB*p=x+{bT3Nt1_vsEAAgo8%Zb88S;fl=as6DA@U)#YlO%GA<}tQ>SKs}2yK)Q zStwd5_-HyVRFw&JJ@H8t(T7m4#UXCk)h1fAGnbmmq<+i2ygiIKn$Bl46pNm(+YO~M zxvqPxDWP01Jk`_3;21+@C=sIFt{c^p>c);9LBCFjE)^bjxxiB|m>J4ML(6`}o0pQ0 zkEU2&WGMHct8QG0?F(te9b6$x-b6FT*70SA3LiR}-j$ZVOAfrgV~kCGqLbmup;wri zAGBou9oH%%V3RlvF2FrmA0>5U|!rlO0^r1M(+_ zOD-J^Zm9Ed9Efc@ogPbmuuTEq|9T($QP8&L^y~P@(Kc0Aam;Yo$9_)M4BU~=#JDkS zz_1;A&kPMd*la7*bINeg;#mBpI1k=IdBn%+Y6z{Z4S8qb>*$$c@PW))w)icqgx0Im z=wm;8)u!_dBb|~imPUJ6;NlR={3;Vob-e77l-~3euBsNFZO6wo(6XS$L=!l!)vT)( z3m4&FD39nH#95i%IA~qIC&yvI;fyrE|B#7h*S(2Yj?q9*5w${uYrXBNrX<%K5eIS3 z#2L_NqRv>8KDW}{i}vFlurbulK-VKO=u%9b*89+%SYDY;HZxjN<18R>+{bvi20I8fTunTOXsi_KH&D)F{AGXJWr}A7b*< zXr|JtH@OZm1qRGNCNA1=9eVd`;i#E||HQ zqRq#CQ-Ym}PGWJ1-#;KvNH^P0IgpF2v}Scx8D7{hQPoL;+%&sxfnn- z2A$TjQ5-4qc{+`6E`F8}YrHs(Wk$oGSe!rMew-GVT~7|&;5D?50BX>9$*5}J^D4Ns^StgLKiML>@IDNr&g#9sM z-X@rw4i1{PT_l%ls(MNhGv>+esTyS2Db50L&2w%_JMGzp!w_854zlhQ0N4ENIL?nE z7U%z^YE)!rlnhK0C&J7Cg3>kDMf!n3!5Ls-hAyAKT(Wf0J0IHaKc$lcUB%4bC!%)M z*%7t-A%mH8fPgkNrF=90`O2fdWFXnh32U+OY39Bq$(g?pq-re7xk11VF_8S3~z_$#!o-tjNM z=(<@WATXfGeI0(Fwb@7qcsbHMATaQ#`@;OdpceOy8G*saJSgTL$4(7b84Ft7_Y?%p zYjc+oH6@PE=d8qU8#|K|2L z_a~uA+hh7E$}miM77r_BU{` zYeYdoZ@P&Je#=eN{I}iyE?7dP+#xx5-fw9+iu14k@91Oa{A+oKCLW!C1KxGRT9>+s z3Ve@!!G$>JeYd~CzjymPf0^6g1J({*b1B;GwX3A6UfVuv9kVOv)(1WacP@o{THWrCt{6|nZWqD?rV5WRaE`Iqt@8R}mI_3{YY%H_AG384R;gx3fkl2MWTAjWD5?cc#wgyOS#o45K zc@kR#B(?@fY_&?#$11VIDzU>VvBN5{!z!`E3Ol@1k#-;3PV3MaYlX27PaLd+dtdJ) ztHdFJF#bh(LNB7DW9%o1gnTIDg_FEgmTtUse%s>_Qg(kViIk@vhma1id#HUgYbluW zJuiNs*$6u8Z{hnmI0*M`yo22l0^nvPdFcC}NrLdxXB0sm{EQ;VWuHxi@cO6orfYiq zH@P?MOE?^pey$vUE$6^e4u8pVBc^=EE4`H5i+C*6cp~w%v_q!77j0oW~NZ9a0XZAxAu}6W9@3yr) zupwMm)dfoG%|J>0A1JB+17%f~r2Y?*)c-+}`acN%_4Ij=r2fY}K6*Nd9YGR1f+ThX zN$d!c*bywTBUoZbu*8mFi5(2u_IVw$9#z$^Cfo7m)J31V#j=m z9rGo2%$L|PUt-66i5>GLb}W$Cu|Q(S0*M_9Bz7#2*s(xj#{!8R3nX?dkl3*Rc6@QB z@KXPCE{0-cKv<%ugeiI;Y|#T@j2;MU^gx)S2f`jb5C-XiGK;A5p`-MdS%fq1C6qFY z{ACvT%PgYikUn;qMgB62{ACtVCqpOGBD2UMvxxd0dUlyb)cep=$}FP(hn`Yq5%oZH zl+*>$17#LbgGEm%vxvGFdPFEJwGH%?GK;8n zpr@2sMC}8&ZU9=3xLFUw5MnAHOAxSv6HQ5519dJfSHTF8PBt|u{AWIEu49_63*n?=0&1W*Z zy^QVJ7-;Vc?c|r_I%)|1jodvC-RC9xF0_VBCKGx7?>>c0o%3J$6hicSn?98;RJ??r zX;UNCjVM3+6uOWQ>9({_Els)w%B`5nQ_a4Y$&sh@xf(Un6D65lpf1Vul2NTaQ99Zs zf7W!gi}`Hn=py9*K{~oflc(cX9YtMidcf6E@4s!^Ip#<=KM8?zKbeC_p9J`bd|RG< zU8@rNb}ZX;5+Sh8g~q#Slf3ITEJr-gJCp&D`xYh##d9tct{aaWc%7!yWqet#sVo07 z+tt3xY!~^??Me>eu1M!*A{o-TEy#iVii=p6%|H(He|166?9*{zooNWKxb3!)5xDJ{ zaS*sh@3K?Ifz~?>pID3BY4*Jy;ucbI1qST^z%~HduOg|qsVA-%FZeyu?7Z#cu)l(u`#SFC6xS#ibv;4c zq#)5vHrRnH6J(S!C&&gnEHv+-bAoKJ1J@`>C}o2k7MlCe$&?LtSZMY`PbsrVHrQdI z2@pNI%p#fs(NW3FF!Y=Q)b`RmyOsAc0RGhm)1jRItimVkK@i*UNXOs2%509lJ7K-QuNkhLfRWGxDu zH!q1@HbH_D@@14Vi)1Z|09lIyN9fCBO42Am)}jcIwI~8)EeafIFNsLjq6m<+C<0_H ziU3)QB0x4l5+G}41keP@Hyv$E_vKia(x=_j;x;+QExr1DM@Ub$Db-6(AbcQNIsaueNXb>lneWjc;-wr{eej=W57S-Q#^ zTLH3Zq5xTAD?m0)6hMuwPcvNR9DwjR^H*kzEZ@tTZUM5UTY#+T7C=q6|0inOj}QK| z={a*CwOe|Ano(NeQIaQdAx)=!x(r9-=C)xWHw9ml=U!cg6$45xoLEsw8_;kUBn~+s z*)nBOcfKl@|AeJOCS3Map+@%)YGPSzvU;2v?w`&+&)o89<;>I~ zwqZ({=BS0e$e5SCaD8t{k8yEzb$|!slBY3bUBaN z^^iu11F4_)2qCn?z_ywYGkqVT(V=U1%ld@@vVLIz^$Q;!9c7*m-WD@I*rT%SkFx0S zZIKPxBI{uSTbyPi>PhFx+)U9HzZzj*o?x6`hXQA9BLG zOdv9Lu>4!#5GdxEY=>#PpY+a@06C}2J_7wY?lL9t-3WZBD7$NPhr&N9LG>>6l6J1k z@@Gy}_ddB~^9L=)ccu1Xgu|0Klge@E_rm3WT#EZr-&^|Lhxl4}*&T$9>vU_fEk{cH zM$06<&3?&FKbMI>cJ|Wza+G8HWx#KI`2IWCB8K5}ap{ud5(1e_S#MA_1`!||ZU~@7 zn1B1w+z{eLrT5XX5f?(~YYEwKMF1_?e0Ubdi51u#VEd@k(J9y#KsR4MBDdO>d)T?e z#lj9gUF}8VAb&YC>-O^>{&?;@+`K3^9}|HV+ljFDDMMteHTk)<>XsyDI(_9KpYc?w`goEidb$ zbh{38g1t16b&R@PxtwlV2zdi%#Mu^%>2s)6Hf(2=4cp;@2l)&lO?=xf+(xg!{gMZ! z{K(-G_fZ@jgBR65eBYt?XYc`vrkf8wgH9xBMknX;44DfY^Y>qMc)%rB;0D2^i+@eW zbR%1MYiZar5H+Ce`$u&7!n5ME(%9yIcf{xJar=$;$eHhpf@{yoI6H75`mXOFnh&WC z*NLQ&Q7`LxW>_5>N>VZ8U3|{z3JIBPd}n|7aCK*__bPkIQkiIcZa1YB{bBct_HFx6=6Y zzdn{~GU<*|AM){%58k$GYtOaIQSr$av5(q#FMKf4ldE?Gv~ul1>hqM-xI2Fa~7 zNdD;+ar)YuBC_Fjt8BR4Dr-?#0|N9bajXH7uqE9AucO=y?o9c`Z$*UdfwOJb$zsqQRryDe&dN4UGMF9EN=)`3vcL32@R=Ryp&9P zp0bTbxK~9F=@8ibievV0X^PEkvA@`H(1czC6iF|AI@^k8T}|udE2tZ{MDNqqlXN)} z+3VVQ9rw)82vhz)xrcN-!bz^f;kKJVB!xt_tpzuNxG&RxsC-B9);W|0UY}_FuU%n} z+bbkW(~zr|t>k_0z4B;Ob2Kum--KjUMelvkO7XT2dZpMB2-Kl!r?DaH){zWf)30(zamSxgK2KHj}A? z453R-*|0Y*4e|Qju*LqUiE}FrLVKCTw`T;pnC|rtmy555L@(KZwUq{}Wvh;!AIMfcS!s)xm*V4L!5iW#^$@7wxGs+rupRm2^~)tr&vf`;p}4D^Df8st z5l`D_kB{wW4w*5JNV`XFpo@#$&}xBfDN)?Yi4S zCd=Ef8%6;|Dm?*@b8p5I@Hn?@$auW8-d%Qb$ha)>Vm7nEL&oG~D#LBx#}n|mZ3mI@ z>2e8;jC)B7*Lyy6&EYvN{XkbjTLaO4xr%{3icDMpqTlstr8SCPTHLO&=}mN8>!L3Y zbozsr;SyJo-mXIN+WBy0mRyG-DVa1C;AK3(RT%l)`_(e`3rl3;Q9pSxR9p{Z>spBk z6W8j-(Y=&Olr^Ggi_2_Bo)=qbe*Dirc_rjGLDrC8|KvwM((l{|l&$g%q~T&OVt(_3 ze|c3V23giK9|zJBP}!O~+a4d=T(Nfx18K3S7cE}-!9V>#WnPd!`oRzXNv0x_Kz6{G zO&doCUSNF#x=;WAG>sSa`smpw`!*)=(jwnBCtk9>5< z)pp74I5N{wDLhJR*)=sXQIc*>pln5JplqiQE>w|Eb$R;RCW7u$c~TB4>#}~kYg#?}(jJNOG(;%-M#=?0{PG@|czktq-w;~A`&~!n z>oVD8k5gB8JudQ*Nkp!Z_0_#ebiaQ~q9Ixivd*7fo^30u%QZGKm5^e3%kkNfwF2Gb zIxm}XI6@`}`TUUzV$RcfS&j4zV7F-LniToISvwi#21I@6sHgPSp&-2MJzd>zOp*8P zW} zcWpD~%O9GuZj^L^vV8rX-3{*4OBU1ma#>f%MlMp?K?r$w`NB6uG`i%b0b^$| zezb(S3*T7y{s-cQYx^0^&JOZpFfV#<@tbe@e_BS1ozYqL9unh{cNflGvhD2e}1c`LAc+KSU$VH}jLZ*f9Ed2OkpL}Ud?|vw_ zzU{1sXuI5+Wa9~jAKh{+gHn_UZW$D#UUHC$V$Fo z_>r7QiciT2rRjVI8WNcM-dk^pjWo284J}Lq`-0e+y=d8@kPmF<*niPcTAVlIps6GK z$VzV-lT|Bd+WglUq0ZwZs0Ttfj>%ZyBtJQe>pf#KPPBJqA6?h`##~PDce&DzrE*$w_u4BdEa@+ty+vQZ|%xw-7_O{^Oi}#jFhUsWFPS)&n#N}Li zB_gw})Df2fqPzW~Ba_+AyLtN!#~F$t%aD^o-u?t@q~89-z?`k?89G#Fg64OxzrTF$ z+Y8^p67~;pHHdQ#(s`SlXs#^B1#XD?&G#U1`Jy*51-SGrl{uUE4<{CiKQ{HdbY-c^ zoGx+7wlAq!j%^8x-&{zJUT)V0_hNq_+>3Rm7I&A>1$nlOnR>oOc9hI&ITMZ!QD;`{ zKSDD)6aC%y8FTLVaMHhn2K4(Ozo#qs@B+^-Qkip^wUdgLYQDR0>0DG(u*S*4g<y#yG z>6zOPy^_q_fT%L(H(yA3BjlAI{!_?LeuB7`FGkY147#vI&D(EDA+t-QwA^!c`pXsvpqgX7z zuzVUO#N^U*eJtfHzwk$u@G(^(OjkbKJTg;oallr{&;5~c^;IsKRI+P9Y)LGpQD$aQ zWM2Urp<{-_Id-g%2%ox#^Sg|bcpFO~2YGhsmQfE-A00lTdLTZG&b;8#Dze$&{GQSE zup#fgNmo0gR*}e|wF&ZOJ}Kys<80`MguK2C_khvD=0&m(BrQ6S4;qpah^#elb}yS+@NvP_|?skhX8h)(6=Wb>X5#A5v!-x-a{1=~7zYIAfH3xxc*oM~d4P zXNu&S>F9{=$`kU4&XKcXpo8SFBW4Lr1uuNZR=}MVI<);@3D6%bTY}1q{@?-{mo|bM ze&HMV!r0HG^m;R@fjI{QbXT*w-0rm;rNm1UmzH3-H0YOOk^7>z=}Ys@Vmg)?w<+TU z!jG_lg4$A0eCb;T<}!@$NslS#cW_P!ZO9X+UZ7R9_zeSdS(f3+;n^^9jmY^Cn)`D% zwm-a!Wf@3!Y^J11ednovo<#30`T&>7K9US$W@xV2$ehg{k0^hF^^!mM@Qo$!y&^VQ z&JA1;XmH)z>lU?R^n}(oVk6;u?}jX1wruHp2FC6;tq5hG!>w-bEt>noe|Y6p)7k|p z1hEHZ6WjO~oaOw5k9P7eRCeJnW@(o`r?Q)$o5faq{weLi=T%ny`B|*P=Zoxu&zIO$ zpJ&u9v;K{-6NWR@@6`h_pE^e=pg<$d89?c5hscJ&Lh*p|QiGQ04XU)0thx1zVQRwD&oMRU>F1eR@buT1TJ`h`jMYEw$F4p-hfP2IB8&Xu zOG?HUzoF!R@nxmzi{DhP<9!-y|tj3N$Yt=@c)%b&FeR=e3U!E}AmzB>BVP@b>2bPJ8ZqjAcFN$BLe_u+Hbc#m+zX47>5%4_N3|=dv|l zeMa5(RgmufDoFQ#_3s!v@Krx{KxYVa>G_{9cJ+BbcK>;Qw()B}Wl3MNu!gUFi=F)157^MxAn9w*sMB8q`HB}n z9{s}48H;_vPu=|jKen^Zh_p>Ibqq zzh5%eYWBAvs`y)PF;@94Ki>Q;U*7dCU$*w!i&^%! z=kURA`|@%8?tR;rt@+Mkt^PYI>-f$rHu9af*`4pq=1G6;%gX+Gwz^{8J4}t72T`%} zu+ctoo}ZfHkG!1W570q>ny%((DDIa5#XzCwL+U+ zR?uf!KV&S=>c=aszP!=u%Z99T*iGvPYEmFX?hFLUzCeh~4fJD&0_U)`L2tA4pr5g# zpx^NeLB9MZeh-3RMDPb%L$Jy^gJ-eP;E&kd;Msipd|y^Q{}pz0{#-UTe>MwWFq>~) z;LCR`0DQsk*yMsw)ba2BJ5wjWi)dE-_dhWf`QQE6*x&q$PyLNA%lzAaV3FVZgmryy zDZBW+KdL9ckGp);E8h=ORCW6gC|v({xXo9s`62G$<>!Cs%g27`%MxB$tMJ{g_-c)> zaBch*u1>##+jG?wuOf=*S8;DHi+$CPC%@{;GhX#&9j}7AAAc_4cN2i*9|4f@BVV46 zU)7I%*(Czp#GeQFMg7>9<^LFfsvrBR-9O%hE4hc4DfW<%Gp|F9U?^M*$pYMVN<3EQ5(?8!0)QVsDvFu;WQDgs}2>1Ox1l<*{#s83^ zu%3U|qo|YrK&bRz?orsmUn0)oU()~aU+z_S?5}*)ZNEx|$lbq!$o;=c1LnZ5{M6E4 zr2|+^z$O7~{gof@`;{-h2#(lalYoq0Uo)w-^vciv+E;D(M|vClM_+#ZAAQw}|3oBv z|M?R(`pffv~s`0-eP}6Vbu&#eCHmNKBfBaPoML0|$>;E6CjBM(E%waqKXR(PD zQ7}$H=D)2nYWe@mqQ?AhVyP72RSH>42w2XA%+ZegAB(nnp+&p3(4t1Z-fTiyeI2?d zzJAn%!uq-&>wBG4SkwZ{wnf0CE+WkSMSg1jqGJG-60lAHn*cn&h-6$O;P|5BpqvEo z+8Y%AnZ*=FzKKwad}|h4{Wf&Sc)Qr7O}uSkxl0gF#BW={9rIgoC;YYz+}nTar|$i2 zJAj!4ED*pl01y4P1HeWCb_ie(faiWoY7P_dx&Tf9_~5ssX87*_T>m?g8TUIsHRc`C zWm1G0?~+Cbmd;`a--E;Myk}wQ@56mP??a>9-;+j#zXx~q?@xgH@bCT9W54eN@B{(- z1#l3+(cgCgI8MN60bH@nPmNke8f{nxVA3*T-w9y)GSVoUfW-n>xy+AWTIS0WKk(&y zKJaC&A0YRIe+ac$)`!~^*8L&=r+h^JYd+eh@b-^<)l(l)hCcfdgp7Q&*TC4dkNnih zk5Uaxy-&c%j|sT$V?Vy*V_%;6u`lcX7*dY^fuvmg1G0O;AL(`IkARkaf>$l--)FJ< ze@AY=`tLx;{RuE$^Cw@m@lTYekN*i$d;XLLsb~J=rw;!q9Z`)Da6$m@{mG9<{n?kt z{n=No{xga0{__=+dW~NBy8rOyyYb8Z4`21ce*mKH`A;Gl`%hem92TlXKh1WCusc*~ zHt?1(#h2Y%p`a>=Ua7z_2w40oNQxQrQB$Y)HtZ+rg9gOZ2W4axx+z5#&VSOVORB|y$5 z<)EV7-K5N7J2xxy)x6CL)Yc|8E1H%Trx>)pIJ{NGD;gh(SA5l*@k&1F6tBQ9s}hs~ z(jr0eQ)3g9LLd?o2(jCSNC$!)PEh7(qX~+EMI|c53QHE@-Mz{d1KXOa%w`7>@aj}} zp&0?|PF3nm+NLx`WxLX#R&korU}6nvAi9(W4U*H9enhk`$)+4eaZ`rrR;-@x_yvw z9042N2N`jh%E!w7Or=a=g_%mZ!s;`XKk%!WAi77vn*E^MxgV4T`;|Yd7xydpmX7aN zOe{PLz)e}opLt#uqASZ%s-SdD7RA?`rBuUhZCQ$+7M%?{ld@rFMYi&yax`11P}qrV zrBY$%vXy7F$Q(sun{$+BwKlwIeL0GWkK`cg+Xz@pE@H{eRsP5tbCp_!b>>37^SQvR z$^$Sp59rc7Xm%`*%sr7u(f8+(xr2E~n;RhDp$8x?8Uaf`0QwpV`VS~CvZ#Z2OFD?R zjDyNctS%paujVVCs8jh$gTj=E0_BLJ?kG^`Gkc&wX@pUg1xm2iT7cBPT%f$9-Yrm? z09{$A1hY+r0PHPPngPfHKrJs+j^e$J-cJ-NEpX7eLgg4hV+6Was2m3q;-dR`) zY~Nf0+jmotg+OgBQEnl;Z6lJnR=~k4LrOHV~Sy!s`D9V;n<&>iADOGwEC8tz5 ztth3XN}r@ag(LUS>a`fWFrE#zDx;!nz7C@M50EO zE35G*sT_aU;c^AdhW2t0oi0~mQ2m@QCpn|#N(6|;%OU3huso^)B$XA)3P6ulkerp3 z%1Zp%P>DZ$dnM3ml|n*RB}pi%R8|39Q3(l6!17KaNv~2KJcUL?6-kJ$7Js%>lZ4c2 zpmVE*gu-f)P+hHrLBio`Naz5T_ak71HOl>`*m(-ogSA3Hbu9^KuZ4iqwKgMag%Pz% zCF)lm(`1Ua?4@m9w<`}Q~XB{BZgBHTtL7g8a7M5?}{TJW?PN` zn|FkyXqS&DMm}`}s;z1iYD6_sbekKMDF{z$M0~p&mAg-&cOno6Y=~kYczq+{Yek@5 zYgBH7{9YsJvZe`;O-(}DmL`&x(xglPozVnoc}>bBq!kH7jSbNNgcjP2dSrdGGM8;b zpdD#OO)x}%cN|5fmUk3oto$e{wX_z+Uny--h7_%#1;CPHibdOa9B;ReqYB*JilDhw z30Krpt>nM6t)#+8EBWtQD{6riZ7{#Cjc`qEggenjxKnK~X-hjy+KYfyv@0VDJK2s( zAhkoetgt~5R-S{@?Dyf32|}wR>+rcrNyX z{1&~1oxxia1sP|QeTus3ocOBkJcr7*{+u$Zs3YeEWc2_bnFD|*eFMsv!Y&U`H9s++ zysAbHDpydAtQ#bkBn~Q9QIwMh;jh6#<(i^y8WOck_K>J$8ithXz;_IxW?6kf8CTS_ z3(5_!*IZC;0?~2-)z8HX$}NDd*&geMmD~82YkRZ}D-)pW8wOp9KKzjsNwi}&ymyr+&R(~z`(MAVLTBg#EsS_v~|!`!f8)?QZb1CwwW znDWblr}nboIdxfi0L%r#tQ-}XHKPKvYg7rv7dC4Yn06cHqz!XzR0#uS8W@&1rmQfi zhsKnZfE*tKWLQ9wt|+SjNxcHd$t&cRJ6Du&RBW5B3b*XI3bCbEg9k=+Zwj|e5N6vg!L$38;3>H! z+){T7CZE1VZdrX>xMkyQK(cNVh+8*b`gWU@=prOBWg#pd) zvn%kftyyU>vaXf%dT{PVEaD!2cT5T|~vekyQ3Ts_$c#ZX}HoVFw zR~vlQ6%mHD$V8D52521{VTeW^ON=o1sXHSK^w~@mh+G?@5D0cO!Z4qWMHto_)D4lO z9!riiY%uVHkp^_(5wIJPhD?RUu0fm!));(v?HT|l))-LbY>F~$LSr?`;KQn-44<&W zYYl4*?DSg0L4{pf3(Y3i8fq17Q#5#YM;l&YInjo>teoB&>8*?2&ePi!3Z|pMsMW<7 zG&UMzKvR6nI)qxwI)kRISdX9x0UKOzK+1(~!0Y-AhB@ru2E<&q!4PR+;TuV-a~lo* zY(*@|N{uy`v~C3KLagCc7PrY@QFm=J#K9G5o5)9bn+);rQPC#&sA`iT0f>5mIBr99 z0>M^oHq22sZWi7t*lf6HQsd$cRAFVt8>ptLiZ=|RU)L3H7&0*}KLMJKLK0h*Xqe4Y z65+^f1ngoW^orR+dgW|^N|&}!3QlZ+pH?LqURAdx8K_>}okWW5Pcm$ShyzK8zb?sO z;cZC}ab~Mwr-3DJqp*FOA;rKRP^j)p7RvP{8$MAt?hv^w%l1g#X~=<5dv=o0?45>O z2+iLKYs+^U@_?unh@&<{J0WUz366$c#L>3Pa1b2byMQ>eOK=Pc#8n&O79k>21jo7* z;z&#}6o4Z+1&GuX!LeT;3T=pTLKN%~9A$fmqkfN}2pr9OfausGIC=zPz=pU)h_=0g zqkAuLoZD+C0mtxOAg=Be9Jd7GfejI!3a<^P8S)M4x(va$IfM9;GYnn(hd;3>;S=!A0YVg zg9INsNbsqH1Ye&|@RJ3GW`laZNa%90h;$h*GMs=elSR-av{>k}x|k3fiUlIR7>L3W z!BJj9h{Gj@E^r(z0pdi7;5a1^gEqtnAr6)aj*>FsI82~+sKPE(89LAet1@&N*y?ISw}Hi18+r`t#cCn-N;OHHtTyyR>iud+ zU0oxjM%NG`zD6Ln)j;a1Ln!%s8VsKp>yH>N8kq53BR$xqCV*Ox2~b9>c&uy_kG^(6 z(A)un)h7k0wnsd+oDz?&UO}+E4+N=a1*r7Acw`KSN7aaUT(&)Kj?zEYbrt3A;&o95 z6UL#`{hNkigE7I#k~SI>jaqXo^yrC&9@k=x@kaI_7JB4wf*wcWNsnXk zB;jPdaXa+rkB8&~3C5j9jG-kEqBg;}3y32LMhtZ%7%|j=fK4SJmP3ig6eAlDVbvDc z$d7F?`f7WU5aEF&MA(>Q+-+nhlMvTfl8|{LiDceO5;9kAg}$jnvl_fx>J zb1(Vsz+Up}?Nrk7cp4cuoMuclvMuSxXIXrP5%YN&kXcVbD*|>p1A?{0eeg)?K6s>c zA7q`{huGQ3J{Z0>6GWYvNRib22-+wZ*iY!I*~V=~mYV~+S#++kz^LxaGZrFQa`Q;P z(mZ1kOsdX9di5TpbUb&E;Fk{?ivhoW5Q-<~6I)S%u>@=t1%z%WFqQ({QUJE`A~JWf zh~O)V$=t|d%2&lAUlkL$OMp)kxUiJK<)s8ZTuRhOOA*JJQW!K|YOFT0sB+3~Wfics zu>!W9tuR)>jtZExrxICUXAP;DT0;_YYm9Z!qp${&qiRLg*icJ|q*`MG5Ibv;t~s@E zV;KV0UW-_^9wN7wi7>H_vRhgmvfI5nM7Xvd5$>)x9x<}Kdc<|OUdTLJFRZ8+GEdh- z-v_|*b%!B12>}~DOfsVzC>(B}>~^~W;7vy;yX71qlM9ZJjH)AKa{UpgwV@H*TM@9b zMq{gy_uy4M*i6~2q?u?BH5=PtLt``I8*YZ?SDTF;Mjmz)e9;J4bqn~^p%xN=xq$#)gU$**B;q}{1DGH$%h*lc8b+L7IMbs)Rdc0gt;1-%H^a0diy zDJS5Oyc6(9?+M5nI)T{PtrIXjz7s@eJCP!JT?kH7aHWgTdELfC5Z_I9H=Hz5OZCJ_ z<0opwX-c%1)1+j=Y2!)Qwf!^_?a*mK(|Q^-o6eFUTh0x)tvg56$T{dcfPhV%gMP=(lYLi2m^(n}S~Y-ljT?j&DTA=0bkNvmWQ~JJ*Zx5v zb8wJkUKtcJZw|t12}3Y%-w*^BB4C>?kj#T3ym5ijb;U5iJBG==vSHGiPuj-l+O4s!xM7w3gcmX!-7(skJBgTtHerW_OHxaN6qhL`B zMoDtnC{fpslH}%55ciM5%=K5uihWm%XHoN90p9}(qOO8@%T+LIomXM-z*QKWdJV!^ z;We1leGT}X*O5-m6!cvu%-(S_V`^L^LBtItLG3N^e*6~Rk4;dLotPjc`X`KIPCrby$_-2sd~A}GyDR(hYL zof6@?2b4_P9}xHf*_R%wLf`CA6*7uLRp?t8s`{xb!c_V?MTQYPHcXv@zKLO~A5RNY zefdEItSL-Ib+JN)>^cz+uTasXFIuTW>%%KmUv1keRb~5Dsk2zkD)p|BwXRZUt3#`V zifb5A-q5F*p()~^Z zNm?06y03|Z?hhhG4B=}CzJ86mQpL2{8tA@f4TR?+U=3@a`^G4eS`$U_Y*-# zj0jI|Al-*I0J&-->7Klibl_kFPbsxC;zzyTOpM2Ml?8z;I-bxYtNJzs064G{ngmfQ(#}4MJRF7WBSJAF467L&}@!no6-os1q zo?0f}d&=;>v0S`Ym*aiX_MTaR_mWByUsXxs8!Jit@k;2pqDq~kHdG6qyVdF^?0T)* zXHYYni8`;DsLPs(x~3V_gGWKVrG;=iS_qfXLb#k3;A&ftZmlg4vA$J}M0RdfKhbWr z!}^sSus*3nt;Iru4p`rhKt0_VO8WLq$GcIBqJ zM`ibJs=HOS?Us5Tbltbe-gCFq0pN#k!QR7@(50V(5d>`Y9d%G;NA5ta%~L8yRql&$ z>@F#nJx!1e_bA+SpTe6Wy!3$HcZQh|Zd_p+Qd!yx(*>2?UO|xTl@#``G!3gPXO#(Z zdRGx7I-J7tZ~@c1gvBJurt>CNvcr^%S;L(~l1HJMpJqC%KBLy#9_{paO6|8j zF4MzDov=MtrQ@Gj-C%ocrw4MC?NLY%Rjm~d)|5$-H|Cj;Z4&ZKaLukf6S7TOp2?4o z<(Yi>Bm$Orz!YKPg$MBeFa>Q0SXsVlzmX5+n|#%)`6lG0Tlpm5LB1){gmLHsNQf-} z@pc5Pq`)+X)fYgFx~Gt0+gC`$`Gpi)X`#uFwG@IPyvP(~;ya7Lc7TEk1Z+)-3C-@b z65w;_m8X^hl}|wx0@hp#v06l#No8?mrde!%nQ0Bi3Cm2g`ROv?Z_0x^2X zv=NALLQEYp#R3spM;uXg0ej# zM+iJF5Ir`;8A42)GHrMoUC2|!5z%Yfh{?T}Uc|KKG!m6v6yg4}ri19uoi**ih+*P6 zlYv#9GtE&8&l5nc77y*xd6SVpIFIy=8bJDO889WAw9Wyf@4x`kcWS`2)5O*cB7HLl zO}^U1pvj`u51H^iyI@K&X}2zz0=0v~2v%M+&C)t3*nG*Psu`Ck=jB`?1xqeb&a1kF zTzc;kVu~C=OqnC5{U+W>ud6PbvP^8V2*XEBgQ^-jMwxu|7;$eHGiAde@nbNrZj6fV zx+@T}1p&*wf{a>q1(MXkD-_|#6=J!0g(94~0*;ugpty6@^a)#g%@m1IvTJx95wG#r z5fwXro$8RPn^gFxM3_HG1vTOh6=ha&hw6qi2o?3flmK0vqFSVWnm|eS1gPO2QC&x< zsCD-RXzD&uoeI@}xDcx4nb?XjdOwR$Q4g-rARWyx&6hn`Ns#n#f~W)G+CikwrEm>) z+z8k5VfvkL%})(mtrY+fv6>JYR|`bKY7MQ))ey@IR%^bz8UZ`LTH9~Z)<$S5+Y+J8 zV!07oj)_%8XtVj*2;jpawb^QWq()!mjcc?yYTFv|9ucK|!uG~$7gV(*RzN0WfxWv~ zgI~kqDB87g8vMF34(e=)(@LPu4gt@I(@LRd4k3!-v@#$n1fn5MD+i*55S?*a1rWUg zF%+j&0&$rTH{vLUI|9Bko?=)N54*xrpig3ohD7V4*D-okAEXd*_#RSc{T?EY+XLb~ zd!TCh9>UcM+);sRC)@yVe9vC^CkFvLzE`U=@iF@UfP%HD03J@&>P>7*8eGSQ(&)WA zT}w9chz!kF-I$>vHzs6IoVzl#!%#de1B%D&)2I=?X&)iB@6(!qNZF_P@%(*|TZMr2 z?bFa{*oPR^*i6zcF_VaQXOiaWnb58*6BMcYDau?CMrKiZ)npN*BwO2Q;w$o?M0B2Z z1n!H?BmQl9S|cLcod*HO^0X9C9zdu?9Ml4}E(%KWwOLwP0n&fCK&v*futIX=!9uOd zgz6vf+O8txklG@|K3GJaE=De7mX#!5e>64jYl+1UC}7AW=x~D7X{Mxr=n5A^33zL zKVyyBbvV08kZo_$HW<{XX8NP9Iw~GHw#TULvA;zC$6B=28oKzcS_B?(ty&}=+gr6Y zc3A$5@+|g2$~kZ4Vyz+O)lRgtu#{c*L}8X?Vo7 zYw37wZ`U&L*xRn{!y~I*%fzFgUE7aGMZ1=TM}51NjYmtnmV-xUyOxVbU%Qrv$56X= z0FSYD?I0ev+O>QJezWhJa`r0^-3C{uW#S+u;kqwjt0~4g(v05$0qg z;N=&g$C}HiCYvs6!?3AmRG6JPrhTHuUePWClz2r{PFJ*1n3;YBRb16oQ9LeOr@}dU zozS`_*cH=fsD<{CWbwcoUOn`6Aq)@hE6382q#20f1d|LJ$ zP2-JsVD82#P1AZQm_oo3?rI|%3!T=kXj=3G01_W)&#I-NoK(3N$}w6R#%HOA!wA5p z!}urc&lrM$F9O_(JDTN^&n6uR`GQlRmp0>wl;!)qUJ>MjQ|xy zayX|dlE-okkw$VqwIz~o0-{48`fP{+Ahcc4+^CIGusepUJU<3eRw2-$)^Q(Ry$)~D z>$#71cs-w`MQz{)?HB@fX#?NM`JD}*UbPW4=QcvZx>yA5v7osV%T+CZ6M{hmY<_0;03K?2cO06?0^Yc z!MuKf?Kiy>P+iRBmM{sk{*`px3@s-o(|BR8Fm!YpJBo zR4Q)xNJjQ2ZD$0gYakstbQLqp|M;0IocU@ zStzW1S)%mjWFyV$vpE)Tv}f~vuAa^ovd(8yB%|5<3?doNMkG_&BKFW6LPX^V#D*M1 zl9Gc+@+hc4z&di^zQG*0Z-U-7=JGj8QZ7HnmA$$AI9GCWc`H{NbA?xja^cmzdGI3Z z&w~T`%{&;o&bOYX!UwKE7Q* zY@vm`9jdP`goc|6q1+Axte_Ao9WI1&J@j@1Z_0EbKf#rVBHqcB*dpG=)yyKHTtg9* z8!6(YoNX-zmgN+aqDPCNDC;ALa$Ue56eC+`MI~@$T?v)Ao)TCwQX;IlRzm7bmGCTB z5n2jmx0Lc~uBMj?bapABi%WSow5=p`PbshBEWC_Ya5bh(5N#?WqU~k;G>B5l;EBvK z-UnOr1ftA_s3Am~jiXy2&Xw_O#5xRwHeJSzYIM1f7h6v9ww3c7V0V`TTTsreT3nvM{h?{9?6N(vegXfaLP!U~%Bd~Fb=Tsz*(Kc{Uw zito+7qlk8O3-34ah89q_BhYG&fhP1gSTc|E`TXc{AbKgdfPh7{@?p+PTk-!01t$=& z$Tm1@OB>v_pWbTP$h?j=KEnC=HV{ow5Z;b#mDDa2&+Wix>Ou!TLF-QN0j{m>#Ot0; z6k%S_39_nAei<30zLQe=cqbo4>w#2I=b*SztgQ#%zciK(L4|eu?uwSevPxjQz&Cf_bGmhE9Xz~+nj~_1xax)6^G7V zUWud!fR7S%vX>ZRP9y6m*{6xI|=?q!9r+dYS%=UKM|;uG63Gx5S_0xABMXnSdA9O;Ws@Cn?_K zNs4#RBwUm`iMYxTu>MKD#>}Vjs*X+ZH!+YgMYQ*(c$66%67GU{^IZ_{K)}lG!ud^i z!J%HgOM-9RCE^EnNpScy3`(2^MHT|}^fZq)GoJnc%!L%xAYiQzz^p}wnpKt*YM#aN zLd|QSP40FwH!Nok%l(!ur$9FS0xIcTGCpwxye2QVyh>_o4BX zZbmb$E!~V}+Szn7nrTS&hpwV>iu?EVGH_WSRfW zTe4tcca}NPjP6(#**KhK-U1(vWxW@$O* zZDv-GWBvnc$uZB>ZswRZwjtL%mnY{!Zce^A8*&TsNp4lXxfs=VeLkGml5Z}-x3fba z`fP{+LR_{Xt_#Fn8zQU#h&2U*V|@XM+EO4y?I1*2fw>f-vIL^YhNu97-6}B8X4?x9 zG!>dxac!~?x~(iSKdVL;3AJL2NY=I@^A+qG*j)r!`-;q0v1=e#AWChBY9RR0BKYAX z0(P+oe%MlM{v%H>hK0?=lsVdpNm6eyWsY;ji2GVGsMeR5cbWP260l|<&@PskxfWS! z=J@CWy|&D}+l=LP<`lDbwG5~YRn;3!iMN70%jHONf+Oa}E$0K(MA-^FOn5 z2>8`nn0OZf>po=mVSR_pEoL@)$ov$$C0;kynf{#WkDTfY{nhh`lyMCLsJ8JGUv)C4MmzkxsnEScb+X72&v{3Pg zJBFlDQ;(UuA#(pQimULL`6MKiAA`sv$4Jq^W1wGm9BISTkHeAW6dXaI9B(y$LpjxI zepwl6HGh*Ow3*QrKiGy064`D>ZhkuTBnDH$PJ7GSJ4soYh)$%%#73w<8zv1nj zNZHe!X6go<@1*EQJI&+B?c<#=b*j^R1Gzo4ix5#=0|n;O|I^31w!5|G$!E`edm-4Kx4Z7wB?1)|V~Co~tJI2m#4GBp|)V zT#ksddmx~&M+hhvh{HWXz)>LBSPwGFs#EYu>?yc683FdiAhWigqRe{k6f*0Gcn$A0 z`?H~5O1}HOW(&(c4Ike)$XUx@b&KZHYbjExL(yju*r_VsM$g>c0V=viHv! z!{%Z{5Hk$tmJOpiY#c@`ClIjei{yj{7tNnzy_d{YX0~wz0Jd|)jHYhph;U2Z2ni`0 z5pJm&fm<3!gjQ&05SIy|29=c}6xcd6* z2-V%!1!?+qB0X?jkQQG@B-Pi2(uW12^}4wpF?JE+-nigcd4o7&ZU~M|H-OlBLvZX8 zh|C-225{s7!NzZplcsK%Phu?mrr?geN!+nF1$W|2aPPb+xKjlp_olfK+=W1Bmv5qW z-Es@x5}rB%WAhNOa}(yBoZXtBY#TpmzKDXKJZZ+(ph@#3yw~HMPffxVtL}*SqV7<9 zo9~#%fK9rC_;%khkJ6?*fjIDgTY9e;XR<6!>?R|A#vk;I;G(ArdKmnuT}T*Ao9f=J z)fhkv=v^<8=0(7wyQg|)g`S;NcaNYcNI?2brq5)0&-9K=@4ffld+)t>%uIdfM!kIJ z-t!%IO$38vFsKntAf)kUBv}UNb6$|y`+}>p*%$1nk=M_7v#|9_IqzP1PTwmIm3ZIh zEr}KTNZ;z?`3HQTzteB~u)jWhSQRnnjbDIuywSc}d;6@{zrWE{&O7ys-eK4M{uy^G zr25NrRgvv4quLUG`2^K^{bd~e{_-iRZR5m%MvM_L=P%PRRyeVz5hoy|H-GsjQfvSq z9Ux`}%5?C?dieBGV5l>NwG%5q%(}gAf_F0f)+1znD-e2f&Va|AG2J zVN@u9t%s4(DfOQSg2SP#3nyg{n$je}Dk&qKq)c<7S>crNqTkMOg5xHkbOKU(AdBP( z`TrAJB4k_~_C?5_q`3$%2Lv|&y(dz}M?e6!5h>$`*-`R0;!2dfkNp=FE#s9ZG)5Nn z!!fWr2C&x{*~nsIWvjj=7P<|9Ure0*pIJ_v{6G2C#L52$>xh$a9rF~2aLxqzU-jMu z7)}A$N`j2bm5T(q>iK2C&E^c@M))qCP<_ zfTbjpvM`zY1f2kOm@MN2=u1ZCtrYoR*+mLPen~-ODJ&IM83aWDe4r_x;4(K&KK(5A zr19MmmoDQcL+SF_XXzsyo5qD(&yycOR1@)-N5c|}^EvOy zC&$Ko`3{@8Js*5O2pl}4oS4^$RS?oiK5BRXhy?}m6JnPYkZ)aq{EXNw1sL9NA&M&~ zLUFZ4u!}F|#ibOJox50mggz00*47Dwf|sJb=&-l*l3rFGG~3GOQ#UDwFYg zw_JwI`v5jvE(gfcVmb8*t^sVmf|R=zXvTWr+U${Q@EY%tk3O?gk6e!{HLra9nbmsb z_Rnm|D?ff_dtMnA#PO9_Xx3ec#bvjZwDe(Ba^GiGQ6;~8W=&P{z-P8zCHp?(r#$k| zXMI;S%1fz{{biP4Bjcs6w+4sNeGMH(A2m3P;%iY<7JyaO;*iO#lkw)AE!N2)pQXJz zOv!DXj5iR^bu=SE^)lW-IO{RDW%cl@2e9dS_(eC!$ueW^2029*CmQ5bbPlP*9vb8{ zSqg20c_Kj$fK@fh8M6MY5yibU%4X(jk~3wN*Cc-}^)-QCZIZKO=4zI+Wj5F>e=ROH zQx)sYRK;O4RdL>oWw~mX@gD!7oz(svavidUcA&bHPGrgh;8*UL-{DTA6E8a{#(gIl ze{@oekS=V2)Gk;g_7L;}7W!nI!Y}*edKt!j+_+C}K;)2qWQ^{Y8$r1GiOA~bL_QJa z{c;nCYEHEF%gylUCStf>ZUHgLiDix0B;v4NZUu49iARliBO+vg=ZGAj97zK_RK@^G z?HG`YWwtzk3MJnFMpryYGc-LUcgZYdm?pYp7$dI*u$2)xPiDoVWZX3h?GnKrfYppc z$yO$Sdgmlggr}2ofvoSDl8xftlw63aPNpdN-IQE}alA}nr`Jx)xQS(kDrlL9IV)Ho zfA5lP)cY?Z$m23`ODpmZ()b#7&f=O}f=KIY6zOn{M>=1_`0m%_QV_442wCSuUFssL?b70_bz#ee9oY>WfV-UF02|Gm$ zJm+-yIr$}=%l+_6J%``uB^@Etm!x04q$6be66MBSq1+4rtG|-J(feP^--^@M@+9qy zYaHWJ+70T@zmcafgKoY-(!m>SOnum`EQ;N?lwk0dOr~!s!Qw3vMBgDn z8h};b;bh{zmlxqYdrz@hUO5W@q!heODFF$5-eA%=H>g@=-NVJN(vVen1_u!=BvPlXvmL@_Yj@Cv`= zaPlh%2iYBN2*dN;!pZL@9DWN<_-zB&vlD(<5r!C1oQyE|8*oQ>1o>S@fQ*SW#EC2~ zlKeU&;a3#}zg7U-ih|!+lp#?R^P>$R@N12RADfPb*>*H69;3-EJjU>~SR8A>w(`Up zu;7ic25hVLSi=`7Jr2hR!vsS-!ut{o88W+a8E_A5 zWD@A4Btrt|j3kO$m}GFls5}W_o4`ta0Jf8aB5#rqTkJ`u5{8n=cqW-jSV}g0VW-K4 zZ^YU(o~SvEC%R8F;I-~G-QdKd%(4u)dHOiZ5cP@OWnny0cs7C`6Wjrqe-47{+j8*S z%aI&B_;NePkZ536IhcfmT=4E(nuN++!sTyA{s)=-? z-UfiU?7y(_##H;kvcw))ERlCcIUybDi3}W0P&I=+;f8uZV-|WzodNf z%g86c!hG^8hnltI8@`c7^D&r30J}t&MHU!-VEqMX9Tph=t-iewL)$7ux3~yIcah;6 zzq2Aku7QmdLs?j2z~e_+N({$-`m+*)o{g3nl4N#YZs-^FVIKH?cntrRReKG|_*~Iz z$k6FCD`B=(X~07Tt7vkvstlnzeSeifFD+G}ir{L)EXZ>^?wAWA=SZKW=MAkReLoruR;oObn-O*_1 zli6vb0XMhbP+Rmh8>+CC0$XT)qFM~q*h&d4hA;ZDevF`b0NL2|fT7dCZU+oKGHV|+ zbQ$z-gDBZEgxPBbF#i!lk3otZG5kbdIchMl@-fWM`k0~5z)r^u{RS2=Zs;&b(c^GP z1L$YR5xj50@V~LCNkf3l&L=U!2~%WRIz^SwPoeU?DTH~NGW?wsIt|Zc0yjW^IAi#h z)y^7H4QywYs(RuWF-Jphn=`EG**T#;f8HQU)$=%HTIUS|7-#o9jdOI~ForV8MAK;;rLbejbTnN4c@?S2B6Qr#b6h1(dxZ}(bb({8Mpl08&>pE z-aU-G0M>Jlf17M90U?v{05HAl@oAVLMDGWb{jO8i$R3#ZKdh zQHqZ+;<_H7Ka4Qy^s`Y$9e&_!95ssi{%9!P0b+5CamB5F;_h35eMk<0Nt{ z#~8ne+ZuDIF;^P%K+Lfu= z=XmrB5&$yOM)fdB^zgq`jccBxKdy+ltS9g6yvOs-J}@j zj4VBsB3`B%{}<*=BXvg_T-YMD#j|wdypidXGco47OydID#aW1zo(<>)u&^Asi`6;2 z^u`=MsIDA7sDT^|YC>b?G-h36c8NLFm}`xB(HQ?+FyXm8T1+mFmXgb(Wf4=DYh1)k zmupO2u5k$y-a<@|<};)*)0)pBF`F8*uQ3-Ia|ec%yJ@^VZsQM9VxbZDw-?gx=q#k& zF;Zy!3OC{yNAzr`&}f#fU?9B$^yx(ydp$u$F`xk;O_qS&Bsc}I;8L2Dhf?DKCTye( zR<{6FSWaqJ1y>JLKt1aL)Oi7~1TB?-Gk}y(g;+%dH2{5nHQc+ajc;~#!EvgF+NpKM zcRTB@qxN1swSyYa)|WLRPJc6e655O(cCo9?=&#^mWNpR(g}t|t`DQy|MF(MFr!i1r zb=}k+>LGOZ8-o;f!m)OM+CGj0gVc^2B3$8EFih87(*2NT*DZuh-IV3 zFa=+`jq;Uj9yNxejLuPP>4GtoxBw8t#*I$cM2~ZuEMnxcJBG;LfnvifP`x{*0&aK@;fp)*G344pB?XK=<4UGv5bY{QIs=wqgc3XJchGpnc}rBQ@r72Iwi1auG(Iv(Oha)k6abJ0xSK) z3Rd=G#TaJ7caE!kWn)&2i6+JpSFuW&tHvZSc^Xr$G1XwCj#cdWVSxT|6~{ryn(-%M z>>7`gw8rCPuNjjOr(g|nD%N%Cug0bfagO5=$9Ikm`?Tdo_Kg)tIkQhGkM_y! zgSTT3NRz{{l4B>wNsgO@;?sfA184t3GA%zO=N69sN7PQ@*m6Yd0dM;_CLDtm8;^}% zICmZsy+QxX2giw1@;W%BXi;a>&g59e zv5Dgl$IUamXda!BVemQO2FJT|3Knxgnwkq^m4f&B#%feJdr7MEOVHxmrLhL8kSnOf zu`6RO&P{t)#yW_PD`P!`=i1l+F?(%ngxI(?HbER;8=E2Su8l1aAJ@iKh>#oYXt^=A zA!OnW9W6J;cC@>0DC7DK74*p4@wX_5P2ZCKYs@idnVIWjwc*n zxjy2Brn!h?9mhV77cb-$@k%8Ry;6JQl_K2pcB&70so#eKWYWhcV&2CmV#CKLV$X+( zIP)1(QSpt&ylPCq8yM%CF&#|o8}~_l<38EM6ulX)B9%Z0W+*IGa9o5 zhCRK}Nk8nJPWsjF#uFo(dMC{#*W7*J)W~Z5O~6Bc)1^_m@i*bEF+hw9FyU5amK8=7W%D3n1PGnQ(74dkr!@8d+j6<;e>MSw+wa zU|AuiKVxMf$XFYKjQaf$lc*03HR)J&D46$9lcLWKGwJc`f4B@2%mKv1Fg}9wFd9K< zI7Lnj2k9oL0N{pso_jEya&K{q3+P#h)AVYT;+(L{0Ek|viSFmFb5f*Hr^#oOmZA5% zbDCTxzZWNsJvhRIc}opAl({F8 zB2Gci4kKa5qM``%qfEgjzpf}#h{F^U)^U!5eL&*QJMO6J54{ zM4Q6#IuH_L!iUr`CMOtI3}-T9IFmuh~-RYtSJIM{jsJme!H=h>Nu8C-NsU? zvN%dL5NC=u`8~&(VoZJ?ai&-kbH>wPyW=rf{bqs*KY&g!{h)WcOnQB`%cK))Ts%jU zi|6Qenfh_a4Z4th(q$UJR-MotKOv*f62A zoQ!$g1F*^z(murKJqyJIyfFOVTTvQdp)5znjT2>GWaQ053q= z$c9aNt|`^TnsZHQCb1>o^cVQKYd#;&aK0%6b3K`ld1x&pqPvh2BZa0+5L1O9;){q# zDdI$KktqvAQ4uDfy$AuN$s(j)1+dm)Q?7}nmYCcoF~5YIN=vv?O^GQFPE93n8YnU4 zo7i;fBj^2i2L zDe8=GK=QH%B&rACiXS<43F?~w?*tpINIB4EDuZ)#yQv%^se|_-I(hG{lLrp!;(?>O zOce;6(1pMSU5M%JMv$%^1j*<%Rm0oe%MHtVO*JsA>V@HOFDjS^;42$!#HRt8(f0vv z7dFTjE_x8_b2LQ6#SkYRhxo$14T0z$CSq`y6H~){;TDEXU-UU6*crDY82{S{&mJ_& zZK6g^byVgk?e0-il}YLtMGYeWb~TE{W@BSmh@&xTzKj#jPoT83DN`fHa5KfDyiS># z5G7z5B{-+4gxG0Lq)u}p8w9JIMxgy^+6xcU*f1=728z^K#1waCP0a|GJ;$RK%yDPW zoT&v-Yv&NPb&jHTYs82~Oo3pVa|m)dPeGa&OsxoVzrcgMF7P11i>5XNiC9FCghdLH zy2uH)Mihf!4T}iUv_zweTE&)YUd2T9uJSm;tK58M)zpqSORI>pwMuagG~!Yt?m@7S zHB*C$B@>E^TfCZ-Z5o->w~bky0 zmP^wQ%z0({My$Ew(VDJ!wC*d@7@`ecA==~>MVr@%4UO0X!IG~riBkOy7NYZpd-vaP z?};1JIK1a>U^IPe8Z@yTLecfe3*Ud_^PTsE`St?X%oEk(c}8)=&(vIfA#8X>aRWZn zqDkz2Jk1(-Pt@yrH^{H>z$=BhEGA76c1^N4PqIz7IqbUH;}~Y`tZFGaVJ1 z{$_e9Jn}a$BhrPx`HT4AZ$>1aMuY@#A~L}Ig{23WzhPy8W(0W-G}Hd=4B|ohgLsgM zAoB_hHwZ!2f+)z2Mx1KIH3;S(j3B`w2*L`(%-@I;VLZfK7!R=?W?n^z-7thW4Wkg( z8u6kL{^1Bw6K=+Qk2}ry!qmyV*PYz^z-eBC_n8w$D-q@e6FVgoZ)141-LW)s=`0ri zcJ%~cZE@y4BU^|wADE>5I4IKM%?T#`V7wW>;fy!yn2-7_Ap!aHO$lZ_>q#KRB%v7R zGSkIGvWw@=ahVU1yU=C+BGtH%p##7I6DdPxqWRb)l_x^6nMfI;laQf02^o5lDBx0( zdC;VPPeO+9WKtv%;sLTe!&)-Wu%B!`L59<0WOzzOhTs$g97>@KJ1OQflXOjr!c@vI zn~DsNsmKtXMggRl=1W}G zXV5IwXF%IaFbQBOnM9Rm((qa`p&cTa1F+02qN=i}uFfoI#|f4J%$;q1z$Yu&6tFKF z+8Kfk04vHNswIa44(C9-NU#fF<+((4=2F0kTxiz_jsUF2Z4NfE0XGGlcasCbC4e>O z5jCDi0oU@NJt24iu&#Wf=JF}vZoV16N-e=8Dd*b+BZ;m#LdyQly zt>OROgw$4Ymv-6^?*hQ0+s!d%w%cKjHH$Hw<~Z~J%hEf|@n(E72o)aCN_f~sF{66S z31(K`OYN0DYBvmMcr@3N zIm;|gE}6&ZT6u|^ZY-I{aWTBNL??qaa|gz;Mx%LKqY*5v(#P2k(-E7utiqY9H+LZw6SgTF!If8bKBKz^9XFWw=uN%9rGxd3Qcrr;#3nK zn#kSdCUsn}pgjthcVwQ1Tged*Sbb!kLBPf%jCJ4$D>e^c`^V-YvlM)SX5=YOr6K1u zoU#jAkijeStirBt2-6-&-|vmxOW@?s zURP46{)FQ*$M6o)q;M?aSkLicqj7xY_}&AJUuK`B0;|wx z@tB!skZk$~Df`VJX0>F96yqG%I6iW84wF8E;{wMcj`tkPMkv7D2-$>=QM+yo!ESi7 zc!JcO6Qn+yfI4oH6pfRlSmW(uj*(NOPv^KkMa#X*+hNnxj-DpgHN$OY2`@N?%uzdq zW8gfsTR0ALT;h1hacY6KapofB?c_MaF?I<>RV`V(X4cDbeZ^9VoxWnJ!dd@)#X=|l zuvJSn4u$Ad%NNPBietZHl@8D`jw>9GI0mj+dd#eC4f}F;&4Q1@y4NjJ_{?~n%r7{; za17lbO~nQs;YFK3v3biffm3Mb7SA}eWtqe&bYjbb$GC4%=@%URx2c`LF>VLvrq6)U%5d)C7QS?ppAlH+zTdq{b4X8Gdhe{R{w_iX31`_9kFw&2Qg0Nb)FZd-fBZJVzUYx;_I!70SW@v&)H@4qwV2|#&vECT*7T8M^aHhD9xO)+o=|SV?@qfPslCM8txwdRd?NkF z6IsqZQ~Q)-+6&(sFSOs%eVA3L-G`|h05d_BiHS^tn{Lo zlSl^TiM(^dJ9k>AG>HPtB+*cI38nWWq=-xgBm-DwvK3dmqsi82v$RBtk7TmVNul{} zOQ9l;I0mIsJDX!;sukyz<5VkNo#WCdgFB7bW{&-7G#!&1mpSfnyyE!EZCvRXx%8fa zGMt&nnvrR(!AnM_wa+X)LLmlZS^KewVOe|;}vD3r6b7 zLby=?d(Wa#m1NVX%5tD+%(2#*rExT+W$GX2Sn;pCxmKL4&T_4|#%gg}F;8ym4{XUz zLw|N#ag7y`2ivqfGAqub)vV&}4&I*0vksfZ%{(i8U$LKORoGLWb;K;Cg%m%q2&SS$!gz>Z0BI|@%Iwb8qK|nF)W24wQi5Yk; zwtgell~||HzACqVBSlugB84Ci!1^n!<7T#AL2+U{))}*u?E&W{XaTTLF9HmCDS#MQ zW1WQvuioi_unyhq3NE5YRnyg>3ux6`2E}5I*;U=g6uN=4_?5yA^KUR&r};g~t%VEP$oAW5Q3{sg9R+D8oAdE&wa*#MB>k zf-dVKy15IJde>!L$J@C0ZdhdlSX(y?wz{obSfFm}HZIC~sJ+$$^>dGP$IK#nNqy5x z>hnIr$$ru#51=jf4O(|Gqs2qkJ@fy?ZicM;cyBaJ_{cG41Z}Zl#Cm|4KBf-);OHHt zb{EGJj_({Z#>io6%zB8h7h~2V__@c)wvOW{#~qF#6Qob&SjI78k~A$G$2jgxVH$#` z0Z}v92y-*mV+2l_wVsfevz{V;**xg+c?@}lAaa39h+49q!Q^AhTfqqcHD8Bkvp;(xwk&! zwDy2VqmR}XMB06{zCz?a(b9+$PgWm#7f;qVi1=sgJ48Jf?CP0j&GkYU@=BQEqbczE ztRE<%=?#+-^+Eb>jyL``eC8QwL&Eex+c#1|kPU}KkZs2-W(3sflw@P+RkvzQA+~1tVY0Q8z5Fh+0LPFC1DbewB837(r7fS76IaGjLqMI z&)#Dp@BmU0_~Eq+6*VW>0xWEr<2J`TLNPGe7HGl0H5c1{km8C_Ol*Y>_eodSLM(o_ z6}C`|U!cbpX7P*n*upLB#ba|?^lq+OU>|IlgEOW|F}k_2GOUA8of zG|`RbOb@n7aW58GtncMh-rCCt)z@pwz@SEYF{qhdTP7xANn^G(<`4{v?n5Nj-)GCQ z=zaY*oxX4Ya7a)-h^h;R5SeWckyZRKtk}pf+T!N0Ef*2@hk34xVVfJd?uKn&^u;4K zo%k@q=hrvF>5x%d9_YwXl;Rq-<-;*;lrwo6Qv!y~k5c&OQA!v$M(wOITQ;`Z7>Y?8 zw~5R%Zu>#sHIAuR7{^p>1K8ELt-vA$PoSSlkPl!r6QmrV{w~2KDJv$SWNA|rd1H#Q zJWkmvu&6WCZk?fa+$_&Ki@Z|TEVl8;tj&XRr)GJ%%d<8w2C_Mefy~X>D#5JGab|bU zRt4sG&W3+8m`BPw09%^Jk$E;x3;RBAtF=fm3!q8}>H+uzOk1jjO)b))6S#z3QM!Z; z-MhpmZ+MAEo>{WhA@b4^rpUQ$OR-3W%kZxu=mfCcWh8lArXt4N1D!kYsg@C)r-(Nlw;mjYx8}h9vHFO47a#|51V^06SmDc1_!$12AWU z4#0{HO4zYMqng-&*&4wyfW2?PwrrDZt2W8DeUoe_H>tSIO_-e#JOfzNmd$0sM~W1t zZVTFOf(ZcI=G5~Rc{#UjKhf80<5-&C#;)Ajwwd)&I~YsKj_oVyb_Xk!a%Ahmdh{OK zx-EZ>@6~KQ7*O41ho?&tNY#Xphc`u-<2wDN+ z@QaOZ-k5yBnPC6L){8^*g%14iR~w!Q82?J`^jD-WdWChe_|G2cgL4-ap*_-um~*5^a01s}5S0K^L)k9X%oyvR2)&VHkME8i&g z;u|6zzTw4c=p7yl1Ump0`$0zCAD~AG)<3X0Za(l*G3IZ_ude;=G=cy-K3D=sSpjzJ zM*v$3up>uCpdFVEfp*NsMIf|^L3U)j4YH40*jtc&!oos=sa+CE`jJpOE)7HN^Qb-y zA>HBj1q<^!?TZ#x6KB7(und>|-om01?GMl=+8-_Kl4DO2wU1NmPdJsQ+Mf|Oldv(9 zG-JHolSS>mZ1UaBvA@ z(q1>_=n}xPdoVlR9(b%!>x5c+LulO(q2-JhE?D zSoASr*a=X|xJKNb8=AZan!Juj8bZnw;r6rrTEV8H>AZd=jlYkuFj%=&*kOorqp;*q z!m&^V`W223P6fk1icl`_nMEYwLZou12tiTGy~2c4E?9N6a;b>-G0GJ_OzDbKkSHo% z!AzIOllyc6VNW9I7ZTAHOOh0NUGyd?irAE-yjz&ipQLWHkmxek`*()-&2CDIC~~5H4^?XUI|9$ zgB%5C3in7#Q9`VEP$zj5rzl^sh7_=@KSf!=i3JMrG(`zTh9}M5Kb0~#Q^`IdRSC0- z>8VOM_~KL^uafgkobTrRc&g$AzoPLwoIfRAOwCYYtoTeRLy3hL$WY=SRx*?Xh_ejE z1rd^|BtoQR@?K@8l8gZ?WGeV`%q%4p?Za&48$6m5PzeyTYLyIV0~(i z1XL5WbSf!Uw%Cbropkbfzv@&J7T!g(8{b86d`Kmh%(?Owu~sn==6*zC04co+OK+4DYc4iqhurw zk+||>6QjzppSV1#l)-p=6vpBqw_xX^3jT8W`A55tQ6&RU!X8t~VV5vQcBx}pi0m;X zR3{ct5AS%!$g6=msbAwiu9bf$4vr}mU?#cK{Etqn+-X~LI^<5bV~PiMuiP$RT=Dl~ zLd-Y<{YuOoR|5P*v0+^C!lGxK(hrR*^#7()TnOuAc!fv6jVt)OQz2ji-6w+6LHZlTm`SA?WZEQo7LYRBEO_6N78Sj)r*(wq6)4BP z*2k{G(Y>lADqdB-#c!&Vp9sCAsrp(R`;nPhRemZiQwN)1bCp(bpL+N*e-$ezJZkoW z{~DA{U$f9PT6+zWTq$`u3;W-0W5GG z$A_4(t~A3qeVsfT*7@*yi4o@4;qipO-dx8x>o$}cKe2N|X@T+J28`L{1`f{3O{LW; zb!}o^M>k=Qxt!j_Ty9dQ>ucfcNBKmu?`y%irO7l+ia8|VRJf&l%UZS+JOZ|7OKG>_ z<9I}00Ejz3njCE@zYt%k(}e+V^EhHHN%%K!!+&;H$^Rsk>|unp0Q|MMGH7MDd&-cN z`R^;kR_5GSzLFC6VNgI&1rQhal@SbTeP0>1vdeu8Hu6Bhm;N&cikTf8D7g3O;XoOK z$@>9~JK<2lO%ZvA$~aUdhve09sNfTwn?nVkTsx28mU*Pi;|t3p#osJe9VrvAY&xPD z?mto{(HT7=xBDZd$s)EMD^pPQ9uvQOtW2Y`dCd7^6cciy3|hp|6J-Ya*%LB4JyB-S zx#gYoQ)LdFyi+ie_Y|YLCh!56^Gq4Avi>t=(aNUIF!a?kP?rR+0AcVPvxg;KI!B`F z3+3>W*ma>SA>7af!U;+{YZMZ3gEh#!;cJk0qik96>vn`JxK(g#YTK<+ zWnvSzm~q^~u54TJ0CH@J@H;+BF?VF{y@UDYoibz*FYlBcRPcC5vlMu*?4lEXPev8@ zQKcSueq?|*a zk2Y(5!mvgG!t%3nVf{1Vl!Q%qBk@^?e1X7&iC>gUc(lGKSD4!ua!COF=3=EDZuV98Bawuo?k!BbdnW5cMl5 zGX(AnAuziRQSqqlP_(W>(RvA0zY-(E)M(hd!pOcl4BTosoQ}hh_#VIloa#4XzEh=> zK&ey3W@&V)xN;bFs<=7n!>PvG#PkT2j`rLLqMIUAeC)dr0fKErsI_MCE<&ZF`i0ZZ zNb*jKRPpAmCz6b2BGm$m_!Ozqq5U37F(RYX5eut}qTrKJY62>pj{+fFM5+9ce27xt zEJ9wi)~kr7ICatLEiUPz)d;J&60N%6v=vR!E}|*rL$rzuk$@OA%PQo@XpWv3a;%S0 z^R41SjG73Sofyo7co(B4q2nJ*orG958J#TNsg6}s@Z6uqSTz-*JyuPFn2S}@VX?_A zE@IUTbe?%9GEU7zCnb*NH!n`bk?M_8{qcoKoSK5STXE`FY>Z%&-~`rIc7vwqj90VZ z7#|NuDLWp^QASV?5H8|Tey~}1B{}r95T2k7r#wN$iD)r_SGbnfU6(|3PZD`gC8<#s_R5VSl4+rbDOzbN_HT76t#b=Cr&F=b-&55b ztB{?h#Vbjp2vupc;?rrW8?&*TMpJW|##j7-cf!;8io4Q@DNg6}=}G7FS)0yRd?cN( z_&m4ROXn+o#ygMcY969~P=`fi(26H#(2Bb=XvIr2u+DWE>X=3B%TV)SIhH}Iv7CW5 z$jemmB2bp87C~Q=Nf8b+DZ))AMet=(gs?0)v&1aK$09!?MVN$S9Dz7}r#wdxSgU8l7wo||xAs}5sKueBdr%4&j7Z4oHUz3W5VKl3ApYXf(g3aeYG!q!%G3cKC@%hH}r_)XdNNxOQYOZCC$J>}ltT zhuX<{rd^#y;-z+k*=pyB4>)n95f4PXxAVlo9pn+y!95Z?Fq!TSOr{6GZaR=Dty9GV zb3L83(>l?=?WAc*>%ueycO!jPH_}&h^Yk^{6s)aVok#kfZe$th=IN(6v7!-ML>zVV z^cS3X(uj8uQf&{?cN2^QSZptHcK4};pIK->nic)DPR;%5B28_-`knrzA62*puowda zXsx3q-VgA4UI(b2kU@0`#*u?a>l##-F{^2VMC5BkDG}9!yq-o*bPuZZ@Z>=d(#jyJ za1SAM`H+eSQ%?*b$>9)^_z&|Wp~Dm_ZdhGKlH_5;${yxP3OM1_h&mAXQveKW9>6k3 z5HM^MyYFmNoyETvjH!6&X6=}Yr)vg|tMneWc3c(N;5cTRZH}vZ61x~z*KO>HqjN(2 znxz5sGZU!iXaYMhbP_u-Zju+3JV{06PO2Lys%R2Lc_-CPjJ%E$9U9RGLYjq}v;kn( zlj`+n{m>Nh?o6q8tjWr>ivLF{oIzaAj7kqBtev5_?K3Jpl(2UO+c9PqBdM9CO|d(R zW94#I{YsxXhob7|FiG8Wyq>{1@|&Jhw^7gH9O~Jeni?paB*FYfNFmoD(QJ0-a#8`G@d-_ z+@O+N8)_uzv<+l-Z>aQm=weP(YeXXvZJV@VSmYLt(UUDT+Ah{_b4~0HG)Ftou;N|9 z6^{k`{>^j_#Z$y zcAz>xNxRg%IZ*MmrI154`V&h(RPo=JK}TxFCzf!eW`1H>M`{-SR_{nX(X*Ok6%Ufx zJyzo+c6F>KO049BG)<=}p5oenN{h2{s_siH@eBt7D?C#}@b&Q-*({x_E@QS2)Hv@_6~)R+ejwIg(&#!b)gFwl{}Q`l z@lwT8CHF2>JWulZQpM9FL$6dkH_~;b`aX+!SA6YDuE?$CN*#t<(-kIV@(SZ$0kG>U z)h$b5*I2K?Yn7g|HhxXki`VKHtkP%SF?frL=5A5ZCIJ8KrGCqNcXYs}+@q|V zdvyV^3h&9K@?KqpOZ`1!wco2tAbL45t`W0Dtlq23AhtPisu9;jJm0G;AU-(ZeBhyC zA3&r$s3rJlFzbPG6l;Wsi24VW9)Z`&iGGb31;J(?)gSQZ73vz|B|ec`_LI7f(h8p7 zR`H~6fT-a_n@02yF@rYZEpcM!N!^0S5eOFYtm5Cclb$)9@k{{=pVb}E<xvUHz(_fNp#RJ;&)ijXvS@-K%;A`i1BeA9)x1xVOhg-i0(83%^a|1J z*{3FpQp_6`IRl_icvlU~^R8ao^@s1cUJCu-$9czxdShoNA6R^r5a77Awh!DpYX*$I56KNg5iozW@^k>2yRU+Hx=yN){bSyK%f&ZP7;VR2|n71ig!Q#DaOzn4kpCI1>lVT&B!5*-Qn=|vLdElP5@6xNtTnjwzM98WmDa%@kA zrG7Qpp_AHEP~cDsFK{A-7r2<>NJN3_DJXD1#gT*pPc`OFV_t{}Om!rK2~Xud@u}P= zB^5K9mPXNA(=eU4X^spSJ*RP_z;s6@0*9x=s6CU6b~9n*%5u5z1j$=tj_OHxGK~=B`(6M+$;IxDoW-?MOw?;5^Pm=W)iB zhvA&&Q4n9A;|DP=-{FQ)ay~c8$#>+zy)d7KlTX6|u;Y9zk`!5hY_0-FK8?PBo97ic zifHr&$W~S0pvQzaXiTTZ^n;OR;3%yFSZE;yDk(&uszM&9p^yjaEOZnjP=6r;jTiDj zvl_FeF*{&z111X2Ear}R#oV#H*iit->S8!H7dr}3Tc^ehY0Lx|{Zla(F0{l!Pv(g# z;f_fq4ti!!MhWP^Qta8>QU{&}(p<`oI!n3HP$@T>D8(pNN->IkfIg!PJF%<`gQzRx z)-7e+y0^^Hi&}=uU_B37+9I1L&E{RR2`hK>!6v#KY4ghwr@9>T5>?@d!e=8MM*=>N z^Ej3wXX1@bp4@XA$`!mBIzW@C{ z|MsW<^MCqZ|C4^iPgf-1-k~x9cLI3@+`UsH%-D1d!kkUlA}rW+9m0xD*CVXibOXYc zO*bO!+H@1bzD+kH9NIoLi%$ys)Ga;(hs77*wD<~K7Ja~N@eOz^z5}nt58$)tud+`8 zp8|l+Pl3SrPeH)6Pr*RF+%x%5U7Jpr_UDx5SE3xZ({B@;B>#r-b>juMgZFb#gn64dVhUq#mD`C1$OiP%q3-c1D z>$dBhxwAY}Xa!>R#-hnkt0oOh+?l$4pHtEDj+Jof(N43D|jIqy+S2Kt5>Lk==2KJ5WQZZ24c`F)IyAUg*u2y zuTT#$>lGRx7QI3v#Hv?lg4py5%@8MEp%dc5D|A8Jc!h3=2d~fr@!}PFA>O@0A4FiK z&<_z>DGWeFR0@L-F_pp)L_(!743SkSj6k?6g;9vYN?{D5v{D#{@Kg#D5Y?5!Bt(6s zFa^ zHEnyZ8j^xCyvw9@cC^?&_` z|NR&L;io_U>CgZCzyHTS{pr8`@vnaNvw!$6fBMIN`OQy%`_KRMv)}*z|JL9y;rM@k z|Jy(P`G5TR&wuyx-~Hm>|LQ;d=G$NX`)_~q>tB8Q>tB8M-FLtE)&KbG-~Hwnzx?fQ z{^NJQ`rU8;{(oRil-v5JU;p7BzW>vI{@wS#{?otw;rl-de_{QnfBDm|fAjnA|MDMx p|Ifeq_3!`q7oY$5U;g30{^j@o&!7I%@W+4r^&e2$KYjmC|3CG;4_N>J literal 0 HcmV?d00001 diff --git a/src/dark.h b/src/dark.h new file mode 100644 index 0000000..af93c2f --- /dev/null +++ b/src/dark.h @@ -0,0 +1,593 @@ +////////////////////////////////////////////////////////////////////////////////// +// // +// StyleAsCode exporter v2.0 - Style data exported as a values array // +// // +// USAGE: On init call: GuiLoadStyleDark(); // +// // +// more info and bugs-report: github.com/raysan5/raygui // +// feedback and support: ray[at]raylibtech.com // +// // +// Copyright (c) 2020-2023 raylib technologies (@raylibtech) // +// // +////////////////////////////////////////////////////////////////////////////////// + +#define DARK_STYLE_PROPS_COUNT 21 + +// Custom style name: Dark +static const GuiStyleProp darkStyleProps[DARK_STYLE_PROPS_COUNT] = { + { 0, 0, 0x878787ff }, // DEFAULT_BORDER_COLOR_NORMAL + { 0, 1, 0x2c2c2cff }, // DEFAULT_BASE_COLOR_NORMAL + { 0, 2, 0xc3c3c3ff }, // DEFAULT_TEXT_COLOR_NORMAL + { 0, 3, 0xe1e1e1ff }, // DEFAULT_BORDER_COLOR_FOCUSED + { 0, 4, 0x848484ff }, // DEFAULT_BASE_COLOR_FOCUSED + { 0, 5, 0x181818ff }, // DEFAULT_TEXT_COLOR_FOCUSED + { 0, 6, 0x000000ff }, // DEFAULT_BORDER_COLOR_PRESSED + { 0, 7, 0xefefefff }, // DEFAULT_BASE_COLOR_PRESSED + { 0, 8, 0x202020ff }, // DEFAULT_TEXT_COLOR_PRESSED + { 0, 9, 0x6a6a6aff }, // DEFAULT_BORDER_COLOR_DISABLED + { 0, 10, 0x818181ff }, // DEFAULT_BASE_COLOR_DISABLED + { 0, 11, 0x606060ff }, // DEFAULT_TEXT_COLOR_DISABLED + // { 0, 16, 0x00000010 }, // DEFAULT_TEXT_SIZE + // { 0, 17, 0x00000000 }, // DEFAULT_TEXT_SPACING + { 0, 18, 0x9d9d9dff }, // DEFAULT_LINE_COLOR + { 0, 19, 0x3c3c3cff }, // DEFAULT_BACKGROUND_COLOR + { 0, 20, 0x00000018 }, // DEFAULT_TEXT_LINE_SPACING + { 1, 5, 0xf7f7f7ff }, // LABEL_TEXT_COLOR_FOCUSED + { 1, 8, 0x898989ff }, // LABEL_TEXT_COLOR_PRESSED + { 4, 5, 0xb0b0b0ff }, // SLIDER_TEXT_COLOR_FOCUSED + { 5, 5, 0x848484ff }, // PROGRESSBAR_TEXT_COLOR_FOCUSED + { 9, 5, 0xf5f5f5ff }, // TEXTBOX_TEXT_COLOR_FOCUSED + { 10, 5, 0xf6f6f6ff }, // VALUEBOX_TEXT_COLOR_FOCUSED +}; + +// WARNING: This style uses a custom font: "SFCompactDisplay-Regular.otf" (size: 16, spacing: 0) + +#define DARK_STYLE_FONT_ATLAS_COMP_SIZE 5973 + +// Font atlas image pixels data: DEFLATE compressed +static unsigned char darkFontData[DARK_STYLE_FONT_ATLAS_COMP_SIZE] = { 0xed, + 0x9d, 0x79, 0x7c, 0x15, 0xd5, 0xd9, 0xc7, 0x6f, 0x12, 0x12, 0x16, 0x05, 0x04, 0x64, 0x53, 0x50, 0x96, 0xb0, 0xc8, 0x22, + 0x28, 0x28, 0x45, 0x40, 0x51, 0x59, 0x54, 0x70, 0x01, 0xb1, 0x5a, 0x45, 0x14, 0x41, 0x83, 0xe2, 0x5e, 0xad, 0x2f, 0x75, + 0x85, 0x54, 0x50, 0xab, 0x80, 0xda, 0x82, 0x0a, 0x02, 0x0a, 0x08, 0x55, 0x64, 0x13, 0x44, 0x6d, 0x59, 0x44, 0x40, 0x23, + 0x45, 0x40, 0x65, 0x95, 0xc4, 0x84, 0xec, 0x3b, 0x59, 0x80, 0x42, 0xc5, 0xef, 0xfb, 0xb9, 0x27, 0x93, 0x9b, 0xc0, 0x7d, + 0xce, 0xe4, 0xde, 0x24, 0x48, 0xb4, 0x0f, 0xdf, 0x3f, 0xc8, 0x67, 0xce, 0x9c, 0x59, 0xce, 0x6f, 0xe6, 0x9c, 0x99, 0x3b, + 0xbf, 0xe7, 0x39, 0x78, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x8e, 0xe3, 0x47, 0x06, 0xfb, 0x2d, 0xbb, 0x90, 0xaf, 0xa8, + 0x43, 0x96, 0xa5, 0xc6, 0x95, 0xbc, 0x81, 0x87, 0xfe, 0xbc, 0x6a, 0xdd, 0xe6, 0x3b, 0xb4, 0xb3, 0x94, 0x74, 0x22, 0xb2, + 0x82, 0xc7, 0xeb, 0x3d, 0x36, 0xff, 0xa5, 0xa1, 0x8c, 0x20, 0xcc, 0x6f, 0x69, 0x5f, 0x5a, 0x5b, 0xb6, 0x52, 0x93, 0xd3, + 0x5c, 0xf6, 0xf1, 0x37, 0xda, 0x88, 0xcb, 0xc3, 0x68, 0x43, 0x35, 0xbf, 0xa5, 0x0d, 0xe9, 0x68, 0x68, 0x26, 0xd4, 0x18, + 0x48, 0x75, 0xcb, 0x3e, 0x86, 0x70, 0xb6, 0xa5, 0xa4, 0x8e, 0xb0, 0x8f, 0x22, 0x9a, 0xb1, 0xc8, 0xaa, 0x4a, 0x43, 0xe1, + 0xfc, 0x03, 0x21, 0x5d, 0xd0, 0xff, 0x3c, 0x62, 0x08, 0x23, 0xd7, 0x52, 0x63, 0x1c, 0x0f, 0xe1, 0xe1, 0x29, 0xee, 0x15, + 0x4b, 0x07, 0xb0, 0x83, 0x9f, 0xc8, 0x63, 0x06, 0x35, 0xfc, 0xca, 0xee, 0x61, 0x27, 0xfb, 0x19, 0x68, 0xfe, 0x3e, 0x9d, + 0x2f, 0xe9, 0x2a, 0xd4, 0x0f, 0xe7, 0x1d, 0xd2, 0x89, 0x13, 0x8e, 0xaa, 0xe4, 0xd8, 0xfc, 0x97, 0x3e, 0xc8, 0x14, 0x61, + 0x69, 0x17, 0xbe, 0x16, 0x5b, 0xa5, 0x3d, 0xd7, 0x13, 0xc5, 0x79, 0xd6, 0x36, 0x59, 0x4d, 0x17, 0x71, 0xf9, 0xe5, 0xec, + 0x21, 0xd4, 0x6f, 0xe9, 0xbd, 0xec, 0x34, 0xbc, 0xe0, 0x57, 0x52, 0x8f, 0x23, 0x5c, 0x22, 0x6e, 0x29, 0x82, 0x03, 0x34, + 0x10, 0x15, 0xde, 0x48, 0x1e, 0x79, 0x3c, 0x4b, 0x88, 0x70, 0x36, 0x19, 0xbc, 0xc1, 0x4f, 0x42, 0xad, 0x6b, 0x48, 0x22, + 0x95, 0x5c, 0xc6, 0x96, 0x43, 0xff, 0x44, 0x06, 0xf8, 0x2d, 0x6b, 0xc2, 0x9b, 0x78, 0x58, 0x26, 0xac, 0x5d, 0x97, 0xc7, + 0xd8, 0xcc, 0x0c, 0x1e, 0x63, 0x0b, 0xd3, 0x19, 0x24, 0x5c, 0xbb, 0xd9, 0xf4, 0x67, 0x29, 0x7d, 0x59, 0xc3, 0x78, 0xbf, + 0xd2, 0x7f, 0x72, 0x0b, 0x4f, 0x33, 0xdd, 0xfc, 0x3d, 0x8f, 0x87, 0xc5, 0xe3, 0xb9, 0x83, 0x6f, 0xa8, 0x49, 0x7f, 0x32, + 0x85, 0x16, 0x28, 0x39, 0xb6, 0xe3, 0xa9, 0x41, 0x1a, 0xad, 0xc4, 0xb5, 0xd7, 0x30, 0x4c, 0x58, 0x1a, 0xcd, 0x97, 0xfc, + 0x9b, 0xd7, 0x85, 0x3d, 0x84, 0x12, 0x4e, 0x38, 0x6b, 0xe8, 0x46, 0xb8, 0x70, 0x17, 0xbe, 0xc8, 0x03, 0x41, 0xb6, 0x6e, + 0x4d, 0xcb, 0xf2, 0x2b, 0xc4, 0x5e, 0xcc, 0xc3, 0x3a, 0x5e, 0x25, 0x8c, 0x96, 0x24, 0x32, 0xd4, 0xaf, 0xac, 0x15, 0xad, + 0x68, 0x23, 0xe8, 0x5f, 0x9b, 0x5c, 0x73, 0x4f, 0x75, 0xe3, 0xb0, 0xb5, 0xdf, 0xb5, 0x13, 0x4b, 0xdf, 0x20, 0xd6, 0x6e, + 0xc4, 0x18, 0x72, 0xb8, 0x87, 0xbb, 0xc9, 0xe6, 0x5e, 0xe1, 0xda, 0xee, 0x4c, 0x06, 0xa1, 0x2c, 0xa1, 0x03, 0xad, 0x85, + 0xed, 0xae, 0x62, 0x04, 0xd1, 0xbc, 0x86, 0x87, 0x28, 0x16, 0x59, 0xf4, 0x1d, 0xc2, 0x5a, 0x73, 0xad, 0xa7, 0x59, 0xca, + 0x25, 0x06, 0xf3, 0x9d, 0xa5, 0xe4, 0x51, 0x16, 0x0b, 0x4b, 0x9f, 0x21, 0x86, 0x6f, 0x98, 0x2c, 0xec, 0xe1, 0x0e, 0xd2, + 0x48, 0xe3, 0x08, 0x59, 0xa4, 0x09, 0xfd, 0xcc, 0xed, 0xd4, 0xae, 0xa4, 0x51, 0xf7, 0x25, 0x9e, 0x13, 0x96, 0x46, 0x72, + 0x88, 0xba, 0xe6, 0xaf, 0x3f, 0xb1, 0x42, 0xac, 0x27, 0xe9, 0x7f, 0x36, 0x4f, 0x39, 0x7f, 0x25, 0x58, 0x7b, 0x4d, 0x3b, + 0xbb, 0x2c, 0x3d, 0x94, 0xc7, 0x3a, 0xce, 0x7c, 0x83, 0x87, 0xc6, 0x6c, 0x16, 0x4b, 0xab, 0xb3, 0x8f, 0x0f, 0xf8, 0x8a, + 0x0e, 0x16, 0x6d, 0x93, 0x49, 0xe1, 0x42, 0x2e, 0xe4, 0x3b, 0xe7, 0x3c, 0xa5, 0x9e, 0x71, 0x23, 0xb3, 0xd9, 0x49, 0x3f, + 0xaa, 0x53, 0x3f, 0xc0, 0x63, 0x8a, 0x66, 0x96, 0xa5, 0xa4, 0x0f, 0xc9, 0xe2, 0x53, 0xc8, 0x75, 0xdc, 0x4d, 0xe7, 0xa0, + 0xfb, 0xff, 0xca, 0x63, 0x3b, 0xbf, 0x13, 0x96, 0x5e, 0xcd, 0x0e, 0xdf, 0x28, 0xba, 0x3b, 0x60, 0xfd, 0x8b, 0xe9, 0x46, + 0xbe, 0x38, 0xa6, 0x94, 0x75, 0x24, 0x17, 0x05, 0xb1, 0xf6, 0x50, 0xa6, 0x10, 0x43, 0x14, 0x93, 0x89, 0x61, 0xac, 0x30, + 0x16, 0x7a, 0xc7, 0xbc, 0x68, 0xb2, 0xc9, 0x61, 0x1a, 0xf5, 0xc4, 0xf1, 0xa3, 0x26, 0x67, 0xf0, 0x1d, 0x5d, 0x68, 0xcd, + 0x00, 0xc2, 0x85, 0x35, 0x7a, 0xb0, 0x87, 0x64, 0x1e, 0xc1, 0xc3, 0x75, 0xfc, 0x33, 0xc0, 0xa3, 0x7a, 0x8b, 0xe7, 0x2d, + 0x25, 0x91, 0xfc, 0x57, 0xec, 0x47, 0x6a, 0xb9, 0xde, 0xc9, 0x27, 0x5b, 0xff, 0xb3, 0xc9, 0x12, 0x9f, 0x4b, 0x86, 0xb3, + 0xc1, 0xf9, 0xeb, 0x22, 0x32, 0x83, 0xd4, 0xbf, 0x3e, 0x7b, 0xf9, 0x7d, 0x39, 0x8e, 0x65, 0x80, 0xa8, 0x93, 0x8d, 0xbb, + 0x58, 0xc7, 0x02, 0x1e, 0xe3, 0x73, 0xe6, 0x72, 0x9f, 0x75, 0xad, 0x25, 0x0c, 0x65, 0x35, 0x0b, 0xc4, 0xb2, 0x10, 0x96, + 0x30, 0x8a, 0xf3, 0x48, 0x65, 0xb5, 0x70, 0xd7, 0xb6, 0xe5, 0x00, 0xdd, 0x69, 0xc9, 0x7e, 0xae, 0x65, 0x34, 0xef, 0x06, + 0x78, 0x54, 0x73, 0x88, 0xb6, 0x94, 0xb4, 0xe2, 0x67, 0xeb, 0xd3, 0xb4, 0x9d, 0xb7, 0xcb, 0x31, 0x8e, 0x7a, 0x82, 0x6a, + 0x45, 0xb9, 0x6d, 0x06, 0xf9, 0xc6, 0xb1, 0x7e, 0xec, 0x0d, 0x4a, 0xff, 0xea, 0x7c, 0xce, 0xc4, 0x72, 0x1d, 0x4b, 0x2f, + 0x4e, 0x0f, 0x6a, 0xfd, 0x15, 0xa6, 0xbf, 0xf8, 0xd8, 0x72, 0x87, 0x74, 0xe5, 0x3a, 0xa3, 0x7f, 0x07, 0x2e, 0xb5, 0x9c, + 0xc1, 0x63, 0xcc, 0x31, 0xcf, 0xeb, 0xf3, 0xe8, 0x48, 0x9a, 0x5f, 0xe9, 0x18, 0xe7, 0x9e, 0xef, 0x42, 0x2a, 0xdf, 0x30, + 0x32, 0xc0, 0x63, 0x9a, 0xcc, 0x7c, 0x4b, 0x49, 0x3f, 0x0e, 0x54, 0xc1, 0x77, 0xee, 0xf7, 0xb9, 0xc3, 0xf2, 0x6e, 0x53, + 0xe8, 0xbc, 0x97, 0x3e, 0xcc, 0x27, 0x41, 0xe8, 0x1f, 0xc2, 0x3c, 0x3e, 0x10, 0x7b, 0xe3, 0xb2, 0x08, 0x25, 0x87, 0x1b, + 0x83, 0xaa, 0x11, 0x6f, 0xde, 0x68, 0x13, 0xc4, 0xbe, 0xdb, 0xfb, 0x76, 0x9e, 0xc5, 0x40, 0x96, 0xd1, 0x87, 0x19, 0xe2, + 0xdd, 0xdb, 0x9b, 0x6f, 0xa8, 0x65, 0xde, 0x04, 0x97, 0xf1, 0x3b, 0xe2, 0xfc, 0xca, 0x2f, 0x25, 0x9d, 0xe6, 0x78, 0xa8, + 0xc6, 0x6c, 0xe0, 0x8a, 0x00, 0x8f, 0x69, 0xb4, 0xe5, 0x69, 0xda, 0xbb, 0x9f, 0x4d, 0x55, 0x4e, 0xfd, 0x6a, 0x64, 0xd3, + 0xd4, 0x52, 0x16, 0x63, 0x7a, 0xb2, 0x46, 0xec, 0xe3, 0xd6, 0x20, 0xf4, 0x9f, 0x40, 0x8c, 0x69, 0xd5, 0xf2, 0x50, 0xab, + 0x92, 0xcf, 0xee, 0x16, 0xbe, 0xe7, 0x27, 0xb2, 0x98, 0x23, 0x8c, 0x2b, 0x8d, 0xd8, 0xe5, 0xf4, 0xac, 0x67, 0xb2, 0x9b, + 0x54, 0xc6, 0x08, 0xf5, 0x9f, 0x22, 0x9b, 0x7f, 0x93, 0xca, 0x2c, 0xee, 0x22, 0x83, 0xf3, 0x03, 0xda, 0x67, 0x24, 0x85, + 0x9c, 0x21, 0x96, 0xcc, 0x2d, 0x67, 0xaf, 0x78, 0x32, 0xe9, 0xc5, 0x56, 0x6b, 0x59, 0x5b, 0x76, 0x92, 0x4c, 0x01, 0x53, + 0x82, 0xb8, 0x9b, 0xdb, 0xf2, 0x33, 0xc5, 0xff, 0xa2, 0xab, 0xc4, 0x19, 0x4e, 0xb3, 0xfe, 0xee, 0x56, 0xba, 0xcf, 0xb2, + 0xfd, 0x32, 0x56, 0x9d, 0x56, 0xd6, 0x32, 0x1b, 0xeb, 0x78, 0x54, 0xfc, 0xad, 0xe0, 0xb0, 0xe5, 0x97, 0xbc, 0x53, 0x49, + 0x34, 0x93, 0x5c, 0xcb, 0xcf, 0x71, 0xfd, 0x6d, 0x52, 0x91, 0xb8, 0x98, 0x1f, 0x84, 0x27, 0xea, 0x67, 0x99, 0x56, 0x05, + 0x8f, 0xf5, 0x6b, 0x2e, 0x53, 0xc5, 0x2a, 0x9d, 0x70, 0xe1, 0x3d, 0xaf, 0x5a, 0xb9, 0x9e, 0x89, 0x4e, 0xc5, 0x91, 0x2a, + 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x4a, 0xc5, 0x70, 0xf7, 0x89, + 0xd7, 0x60, 0x1b, 0xb9, 0x16, 0xd7, 0xea, 0x44, 0xf2, 0x1d, 0x46, 0xb8, 0xd4, 0x97, 0xbf, 0xdc, 0xfd, 0x81, 0x5c, 0x1f, + 0x03, 0x2d, 0x75, 0xeb, 0x09, 0x8e, 0xf1, 0x12, 0xce, 0xb0, 0xfe, 0x96, 0x1f, 0x12, 0xc4, 0xd2, 0xd2, 0x3e, 0x43, 0xff, + 0x1a, 0xbd, 0x7c, 0x9c, 0x2d, 0x78, 0xff, 0xcb, 0xf2, 0x11, 0xd5, 0xa5, 0x89, 0xcb, 0x5e, 0x5b, 0x30, 0x9c, 0x68, 0xa2, + 0xe8, 0xe6, 0xba, 0x8d, 0x0d, 0x56, 0xcf, 0x53, 0xac, 0x69, 0xbb, 0x34, 0x3e, 0x0e, 0xe0, 0xdb, 0xaa, 0x8d, 0xfe, 0x24, + 0x92, 0xc2, 0x01, 0x9e, 0xb0, 0xae, 0x31, 0x9e, 0x15, 0x60, 0xd1, 0x7f, 0x1e, 0x0f, 0x51, 0xdb, 0x20, 0x7b, 0x3f, 0x4e, + 0x63, 0x21, 0x39, 0xe4, 0x33, 0x5b, 0x28, 0x8f, 0xa0, 0x9e, 0xe1, 0x5c, 0x72, 0x69, 0x29, 0x3a, 0xf2, 0xb7, 0x90, 0xca, + 0x01, 0xe6, 0x8b, 0xd7, 0x4f, 0x1f, 0xf6, 0x90, 0x41, 0x36, 0xe3, 0x44, 0xc7, 0xf6, 0x7e, 0xae, 0x17, 0x96, 0x26, 0x70, + 0x83, 0xf5, 0x2c, 0xeb, 0x30, 0x45, 0x70, 0xa7, 0x7b, 0x7d, 0xcb, 0xc5, 0x0c, 0xf1, 0x2b, 0x3d, 0x93, 0x6d, 0xf4, 0x72, + 0xf9, 0xa6, 0xf3, 0x1e, 0x99, 0x64, 0xb1, 0x8d, 0x16, 0xa2, 0xcb, 0xe6, 0x19, 0xb6, 0xf2, 0x18, 0x83, 0x19, 0xc3, 0x0a, + 0x16, 0x5a, 0xbc, 0x0a, 0x1e, 0x3a, 0x90, 0x44, 0x2e, 0x75, 0xc4, 0xb2, 0x2c, 0xae, 0xa4, 0x1e, 0xcd, 0x58, 0xc0, 0x67, + 0xe5, 0xfe, 0xee, 0x94, 0x65, 0x1c, 0x82, 0xed, 0x28, 0x10, 0xdd, 0xa7, 0xde, 0x92, 0x14, 0xda, 0x58, 0xf5, 0xff, 0x17, + 0xd7, 0xba, 0x6e, 0x7f, 0x16, 0x0b, 0x88, 0xa0, 0x0e, 0xdf, 0x1a, 0xf7, 0xa6, 0xcc, 0x13, 0x16, 0xe7, 0xdb, 0x7a, 0xc6, + 0x13, 0xc2, 0x69, 0xac, 0xe7, 0x4f, 0x82, 0xb3, 0x31, 0x83, 0x9b, 0x8c, 0xe7, 0xf8, 0x5b, 0xae, 0x11, 0xea, 0xde, 0x48, + 0xc3, 0x80, 0x97, 0x7a, 0xef, 0xf2, 0xdb, 0x48, 0xe2, 0x6d, 0x1a, 0x07, 0xd9, 0x7a, 0xde, 0x7a, 0xfb, 0x99, 0x4d, 0x23, + 0xb1, 0xf4, 0x4e, 0xbe, 0xa2, 0x06, 0x61, 0xcc, 0x36, 0xee, 0xb6, 0x13, 0x79, 0x80, 0x0f, 0x4a, 0xf5, 0x6d, 0x8f, 0x58, + 0xdd, 0x6a, 0xcf, 0xf3, 0x12, 0xcb, 0xb8, 0xd3, 0xa2, 0xff, 0xc5, 0x8e, 0x47, 0x70, 0x7b, 0x39, 0xf5, 0xaf, 0xc9, 0x35, + 0xce, 0xfd, 0xb3, 0xcd, 0xb4, 0xa7, 0xff, 0x19, 0xae, 0x66, 0x34, 0x75, 0xad, 0xfa, 0x7f, 0xcf, 0x14, 0xbe, 0x64, 0x07, + 0xd1, 0xe2, 0x3d, 0xda, 0x90, 0x02, 0xc7, 0xd5, 0xd4, 0xc0, 0xd2, 0x46, 0xde, 0x23, 0x48, 0xe5, 0x02, 0xb1, 0x24, 0xd9, + 0x39, 0xbb, 0x09, 0x42, 0x74, 0xc7, 0x20, 0xbe, 0x75, 0xfe, 0xba, 0x9f, 0x0f, 0x2b, 0x38, 0xfa, 0x75, 0x64, 0x2d, 0x1b, + 0xe9, 0x6e, 0xf1, 0xc2, 0x7d, 0xeb, 0x63, 0xa4, 0xa5, 0x87, 0x8b, 0x26, 0x85, 0xb1, 0xc2, 0x08, 0xda, 0x83, 0x9e, 0x8e, + 0xb7, 0x63, 0xa9, 0x50, 0x6b, 0x3f, 0x0d, 0x88, 0x60, 0x22, 0xb3, 0x89, 0x62, 0x30, 0x21, 0x6c, 0xa6, 0xad, 0xd8, 0xfe, + 0x3f, 0xd2, 0x9d, 0xdb, 0x2c, 0xae, 0xe7, 0x2c, 0xae, 0xa2, 0x09, 0xdd, 0x58, 0xe5, 0xe2, 0xbb, 0x0d, 0xe4, 0x1a, 0x68, + 0xc1, 0x58, 0x62, 0x45, 0xf7, 0xfd, 0xed, 0xac, 0x27, 0xc4, 0x45, 0xff, 0x6c, 0xe6, 0xd1, 0x85, 0x2e, 0xc4, 0x98, 0x08, + 0x8e, 0x13, 0xb9, 0x8c, 0x9d, 0x0c, 0x61, 0x35, 0xab, 0xb8, 0xc5, 0xba, 0xf7, 0xb1, 0x7c, 0x6a, 0x29, 0x79, 0x92, 0x4f, + 0xe9, 0xc6, 0xd5, 0xec, 0x11, 0xfa, 0xd8, 0xfe, 0xec, 0xf3, 0xad, 0xf5, 0x4d, 0x85, 0xd4, 0x3f, 0x83, 0xa3, 0x4c, 0x70, + 0x19, 0xa3, 0x1b, 0xfa, 0xa8, 0xe5, 0xe2, 0xb6, 0x4a, 0xe3, 0x19, 0xeb, 0xf8, 0x9a, 0x21, 0x1c, 0x7f, 0x0f, 0x3e, 0xc2, + 0xc3, 0x28, 0xd6, 0xd0, 0x81, 0xaf, 0xf9, 0x3f, 0xe3, 0x57, 0xbd, 0x59, 0xf4, 0x46, 0xc6, 0x9a, 0xb1, 0xa9, 0x90, 0xb3, + 0x44, 0xfd, 0x33, 0x48, 0x22, 0x93, 0x3d, 0xe5, 0x88, 0xf1, 0x28, 0x1d, 0x29, 0x93, 0xc2, 0x61, 0x1e, 0x17, 0xda, 0xa0, + 0x3e, 0x89, 0x26, 0x6a, 0xc3, 0xae, 0xff, 0xa5, 0xce, 0xb8, 0xde, 0x93, 0x03, 0x42, 0xfd, 0xe1, 0xa4, 0xb1, 0x94, 0x5e, + 0x0c, 0x23, 0xd9, 0xd2, 0x83, 0x85, 0x13, 0xcf, 0x95, 0x96, 0xe3, 0x6a, 0xc7, 0x4e, 0xf6, 0x91, 0xce, 0x5c, 0xc1, 0x97, + 0x7f, 0x3a, 0x09, 0x4c, 0x24, 0x92, 0x61, 0xec, 0xe2, 0x47, 0xa1, 0x6e, 0x5f, 0x71, 0xc4, 0x8c, 0x14, 0x34, 0x0c, 0xe3, + 0x11, 0xd2, 0x99, 0x16, 0x74, 0xdf, 0x5f, 0x72, 0x87, 0xde, 0xcc, 0x3e, 0x96, 0x59, 0x62, 0x58, 0x2f, 0x22, 0x9d, 0x4b, + 0x85, 0xe5, 0x23, 0x78, 0x19, 0x0f, 0xaf, 0xf0, 0xa0, 0x71, 0x24, 0x79, 0xf5, 0x9f, 0xc4, 0x70, 0xd1, 0x35, 0xb7, 0x97, + 0x19, 0xcc, 0x20, 0x43, 0xf4, 0xb2, 0x15, 0xf7, 0xff, 0x3d, 0x28, 0x74, 0x89, 0x5c, 0x09, 0x84, 0x26, 0x6c, 0x13, 0x9c, + 0x97, 0xa3, 0x38, 0xcc, 0x3e, 0xf6, 0x11, 0x07, 0xc4, 0xd2, 0x49, 0xf0, 0xd2, 0x5c, 0xe6, 0x3c, 0x81, 0x77, 0xe6, 0xa0, + 0xd0, 0x03, 0x0e, 0xe3, 0x88, 0xe3, 0x24, 0xbf, 0xcb, 0x17, 0xc5, 0x70, 0x62, 0x6c, 0xd5, 0x66, 0x6b, 0xec, 0x42, 0x16, + 0x57, 0x1b, 0x7d, 0xa6, 0xb0, 0x5c, 0xbc, 0x3a, 0x3e, 0x64, 0x37, 0x1f, 0x30, 0x92, 0x2f, 0x85, 0x5e, 0x3b, 0x5b, 0x18, + 0xcd, 0x1a, 0x53, 0x60, 0x79, 0xca, 0xaa, 0xcf, 0x54, 0xb2, 0x79, 0xa6, 0x1c, 0x1e, 0xbb, 0xbe, 0x7c, 0xcd, 0x16, 0x2e, + 0xb7, 0x96, 0xbf, 0xca, 0x64, 0x4b, 0x84, 0xc5, 0x7c, 0x13, 0x73, 0xf6, 0xba, 0xf1, 0xa3, 0x4e, 0xc0, 0xc3, 0x5a, 0x21, + 0xf6, 0x34, 0x82, 0x2c, 0xee, 0x63, 0x08, 0x43, 0x78, 0x9e, 0x2d, 0x2e, 0xfa, 0x7b, 0xd8, 0x62, 0x71, 0x8f, 0x97, 0x1d, + 0x75, 0xd2, 0xcb, 0xe7, 0xb1, 0xfd, 0x40, 0x78, 0x7b, 0x69, 0x6b, 0xb8, 0x10, 0xe8, 0x2c, 0xbc, 0x89, 0x85, 0x90, 0x60, + 0x46, 0xc5, 0x08, 0xe6, 0xb3, 0x48, 0x74, 0x7e, 0xe7, 0xfa, 0xfa, 0x98, 0xed, 0xe2, 0xe8, 0xba, 0x53, 0x7c, 0xea, 0x28, + 0x8a, 0xab, 0x8d, 0xf3, 0x8d, 0xcf, 0x79, 0x42, 0x7c, 0x63, 0x47, 0x9f, 0x73, 0xf2, 0xad, 0x00, 0x63, 0x2c, 0x6f, 0x37, + 0x31, 0xea, 0x36, 0xda, 0xb0, 0x38, 0x68, 0xa7, 0x6c, 0x03, 0x12, 0xb9, 0xc3, 0xd5, 0x4f, 0xd6, 0x82, 0x26, 0xe2, 0xf2, + 0xc6, 0x26, 0x6a, 0xb8, 0x35, 0xa9, 0xc4, 0xf0, 0x3c, 0x71, 0x7c, 0xce, 0x5f, 0x84, 0xb5, 0xae, 0xe5, 0x07, 0xdf, 0xf9, + 0x1e, 0xa2, 0xbd, 0xa0, 0x7f, 0x0f, 0x33, 0x3a, 0xdf, 0x44, 0xa1, 0x25, 0xba, 0xae, 0x2c, 0xce, 0x27, 0xd7, 0xf4, 0x5c, + 0xb5, 0xd9, 0x64, 0x7a, 0x21, 0xdb, 0x5b, 0xac, 0xad, 0xff, 0xef, 0x4d, 0x02, 0xfb, 0xc8, 0x60, 0x95, 0xf8, 0x7c, 0x17, + 0xc2, 0x36, 0x46, 0x99, 0x5f, 0x00, 0x96, 0xf3, 0x8a, 0x18, 0x39, 0xf6, 0x83, 0xf5, 0x97, 0x87, 0x26, 0x14, 0x9a, 0x68, + 0xd1, 0x10, 0x26, 0x99, 0xe8, 0xcf, 0x13, 0x63, 0xa2, 0x8f, 0x98, 0xbb, 0xae, 0x2d, 0xe9, 0x5c, 0x18, 0xf0, 0x38, 0x17, + 0x59, 0xe6, 0xdb, 0x7a, 0xb0, 0x6f, 0x4f, 0x65, 0x39, 0xe5, 0xdb, 0x73, 0xae, 0xa5, 0x64, 0x81, 0x89, 0x75, 0x8e, 0x30, + 0x7d, 0x4e, 0x35, 0x4b, 0xe4, 0xd9, 0xc2, 0x52, 0x31, 0x6c, 0xd2, 0xd5, 0x99, 0x65, 0xfc, 0xdd, 0x87, 0xd9, 0x2a, 0x44, + 0x06, 0x07, 0xca, 0x13, 0xe4, 0xf3, 0x3d, 0xb9, 0xcc, 0xb4, 0xbc, 0xc1, 0x97, 0x1d, 0x2d, 0xd2, 0xd2, 0x25, 0xc2, 0xb0, + 0x13, 0xbb, 0x89, 0x23, 0x8b, 0x0f, 0x83, 0x8c, 0x28, 0x2a, 0x1a, 0x3d, 0x52, 0xf9, 0x96, 0x04, 0x36, 0x89, 0xbf, 0x0e, + 0x0c, 0x27, 0x9b, 0x58, 0xb2, 0x5d, 0x7e, 0x77, 0xaa, 0x0a, 0x2c, 0xe1, 0x6f, 0xd6, 0x5f, 0xb6, 0x36, 0x31, 0x93, 0x9e, + 0x34, 0xa4, 0xb9, 0xaf, 0x17, 0x3f, 0x35, 0xd4, 0xa2, 0x7d, 0x39, 0xd4, 0x09, 0x9c, 0xe6, 0x41, 0x45, 0x13, 0x1e, 0xff, + 0x7c, 0xd1, 0xda, 0xfa, 0xde, 0xe8, 0x2d, 0x3d, 0xb7, 0x9c, 0xf9, 0x2d, 0x7e, 0x39, 0x22, 0x5c, 0x8e, 0x30, 0x84, 0x5b, + 0x98, 0xce, 0x67, 0x2c, 0xb7, 0x64, 0xcd, 0x50, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, + 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x94, 0xf2, 0xba, 0x80, 0xeb, 0xbb, 0x3a, 0xcc, 0x77, 0x31, 0x4f, 0xfc, 0x8e, 0x1d, + 0xeb, 0xf3, 0xef, 0x8f, 0x71, 0x29, 0x1b, 0x66, 0xfd, 0x7e, 0xd7, 0xc0, 0xba, 0xd7, 0x62, 0x37, 0x66, 0x3f, 0xc1, 0xdd, + 0x17, 0x6b, 0xf1, 0x6a, 0x7a, 0xd9, 0x2a, 0xe4, 0x07, 0x2c, 0x5e, 0xff, 0x4a, 0x62, 0x85, 0xcc, 0x5f, 0x6e, 0x5b, 0xdb, + 0xc1, 0xe8, 0x52, 0x1e, 0xa1, 0x54, 0x21, 0x7b, 0x75, 0xac, 0xcf, 0x97, 0xd5, 0xc7, 0x9a, 0x6f, 0x30, 0xcc, 0xe5, 0x3c, + 0xbd, 0xed, 0x93, 0xcc, 0x22, 0xab, 0x4b, 0xc0, 0xdb, 0x4a, 0xee, 0xda, 0x24, 0xb1, 0xb4, 0x42, 0xf9, 0xcc, 0xea, 0x32, + 0x9f, 0x43, 0x14, 0x10, 0x2b, 0xfa, 0xa8, 0xbd, 0x1e, 0xac, 0x46, 0x5c, 0xc8, 0x74, 0x72, 0x84, 0x2f, 0xb1, 0xde, 0xbc, + 0x8e, 0x8d, 0x0c, 0x35, 0x2d, 0x35, 0xbd, 0xd4, 0x10, 0xbf, 0x7e, 0x7b, 0xf7, 0x9a, 0x4f, 0xa2, 0x98, 0x9f, 0x36, 0xcb, + 0xe7, 0x45, 0xbf, 0xca, 0xe7, 0xf3, 0x94, 0x4a, 0xfd, 0x89, 0x13, 0x22, 0x49, 0x8a, 0xd6, 0xbf, 0x80, 0x2c, 0xfa, 0xb9, + 0xee, 0xcb, 0x9f, 0x24, 0xbe, 0xf7, 0xb9, 0x1a, 0x1f, 0x03, 0xfa, 0x0b, 0xb5, 0x0f, 0x39, 0xad, 0x7f, 0x85, 0x2f, 0x4f, + 0xf3, 0xf1, 0x3e, 0xc5, 0x19, 0x14, 0x52, 0x40, 0x92, 0xe8, 0x80, 0xcd, 0x62, 0x00, 0x67, 0xd2, 0x82, 0x37, 0x45, 0x77, + 0x97, 0xd7, 0xf7, 0x39, 0x87, 0x83, 0x14, 0x90, 0x68, 0xa9, 0xdd, 0x9f, 0xfa, 0xb4, 0xe0, 0x2d, 0x76, 0x55, 0x20, 0xa7, + 0xd5, 0x3c, 0x56, 0x52, 0x9f, 0x10, 0x86, 0x50, 0x20, 0x38, 0x90, 0x4b, 0x5a, 0x67, 0x0d, 0x2f, 0xba, 0xf8, 0xcf, 0x82, + 0x6b, 0x57, 0x0f, 0xff, 0x60, 0x85, 0xb9, 0x2b, 0xfa, 0x93, 0x2f, 0xf8, 0x77, 0x2a, 0x5f, 0xff, 0x56, 0xa4, 0x58, 0x1c, + 0x72, 0xee, 0xfa, 0x67, 0x3b, 0xee, 0xd4, 0x30, 0x7e, 0x34, 0xed, 0xed, 0x5f, 0x7b, 0x21, 0xeb, 0xcc, 0x35, 0x22, 0xeb, + 0x3f, 0x93, 0x75, 0x26, 0x02, 0xe8, 0x2a, 0x0a, 0x84, 0x9c, 0xea, 0xc5, 0xed, 0x77, 0x06, 0x88, 0xfe, 0xde, 0x77, 0xf9, + 0x27, 0x8d, 0x08, 0x61, 0x20, 0xf9, 0x65, 0xd4, 0x6e, 0x51, 0x4e, 0xf5, 0x1b, 0xf0, 0x13, 0xe7, 0x38, 0x7f, 0xcf, 0x37, + 0x5e, 0x2d, 0x5b, 0xeb, 0x3c, 0xc4, 0xbf, 0x84, 0xd2, 0x2b, 0xa8, 0x6b, 0x08, 0x0b, 0xaa, 0x5d, 0x1b, 0x71, 0xcc, 0x77, + 0xbe, 0xd1, 0xe2, 0x5e, 0x87, 0x9a, 0x99, 0x0d, 0x5a, 0x71, 0x67, 0xa5, 0xe8, 0x7f, 0x2d, 0x7b, 0x85, 0xd8, 0x9e, 0x40, + 0xf4, 0x9f, 0xe4, 0x78, 0xf7, 0x6f, 0x60, 0x3d, 0x5f, 0x88, 0xfa, 0x77, 0x65, 0xbb, 0xf1, 0x6f, 0x48, 0xfa, 0xd7, 0xe3, + 0x98, 0xcf, 0x73, 0xf6, 0x22, 0xff, 0xb0, 0x2a, 0xd8, 0x86, 0x9f, 0x05, 0xbf, 0x72, 0x7d, 0x8e, 0xf9, 0xc6, 0x85, 0x49, + 0x2c, 0xb4, 0xd6, 0xee, 0xca, 0x7f, 0x2d, 0xf1, 0x41, 0x65, 0xd3, 0x83, 0x0c, 0xd7, 0xf2, 0x92, 0xd6, 0xb9, 0x45, 0x38, + 0xbf, 0x2c, 0xf2, 0xc9, 0x31, 0x74, 0x15, 0xca, 0x52, 0x89, 0x37, 0xf8, 0xf7, 0x4d, 0xbd, 0x48, 0x29, 0x63, 0xaf, 0x69, + 0x24, 0x18, 0xd2, 0x2b, 0x45, 0xff, 0x0c, 0xd2, 0x44, 0x97, 0x68, 0xd9, 0xfa, 0x77, 0x22, 0xd5, 0xb8, 0xcf, 0x56, 0x33, + 0xd4, 0xa2, 0x7f, 0x47, 0xba, 0x93, 0x43, 0x73, 0x51, 0xff, 0x1e, 0xa5, 0x66, 0xe6, 0x19, 0x2a, 0x38, 0x60, 0xb3, 0xf8, + 0x0b, 0xa3, 0x19, 0xc7, 0x2e, 0xde, 0x16, 0xf6, 0xde, 0xb3, 0x54, 0x2e, 0xec, 0xa1, 0x6c, 0x13, 0x6a, 0xbf, 0xc7, 0x64, + 0x66, 0x92, 0xca, 0xe3, 0xe5, 0xee, 0xfd, 0x07, 0xfa, 0x1c, 0xa6, 0x65, 0xb5, 0xce, 0x03, 0xac, 0x09, 0xb2, 0xff, 0xbf, + 0x89, 0x36, 0x06, 0xfb, 0x5e, 0x27, 0xb2, 0x80, 0x05, 0xdc, 0x73, 0xd2, 0xfb, 0xff, 0xc9, 0xb4, 0xe3, 0xa0, 0xf8, 0x7c, + 0x53, 0x96, 0xfe, 0x91, 0x4c, 0xe0, 0x65, 0x3a, 0x12, 0x4b, 0x98, 0x55, 0x7f, 0xef, 0xcc, 0x1d, 0x2b, 0x45, 0xfd, 0x07, + 0x9a, 0xe8, 0x0d, 0x8f, 0xf3, 0xf4, 0x99, 0x20, 0xd4, 0xfe, 0x88, 0xd9, 0xfc, 0x9d, 0xe1, 0xe2, 0xf8, 0x3d, 0x90, 0x3d, + 0xa5, 0x6a, 0xff, 0x28, 0xd4, 0x9e, 0xca, 0xa3, 0xac, 0x12, 0xe7, 0xe4, 0x09, 0x94, 0x4b, 0xca, 0xbc, 0x13, 0x8b, 0x5b, + 0xe7, 0x63, 0xc1, 0xc9, 0x5e, 0xde, 0xf1, 0xff, 0x12, 0x52, 0x1d, 0x17, 0xfc, 0xcd, 0x7c, 0x20, 0x5c, 0xfb, 0xc1, 0xeb, + 0x5f, 0xcb, 0x89, 0xc4, 0x4d, 0x12, 0xf2, 0xa8, 0x16, 0xad, 0xff, 0x28, 0xc9, 0xe2, 0x93, 0x74, 0x59, 0xfa, 0x37, 0x21, + 0x8d, 0x77, 0x8d, 0x57, 0xd7, 0xae, 0x7f, 0x4d, 0xf6, 0x32, 0x4b, 0xd0, 0xbf, 0xb7, 0x73, 0x9e, 0x1e, 0x33, 0x73, 0xc5, + 0xce, 0xa0, 0xda, 0xef, 0xf8, 0x5e, 0xf2, 0x7a, 0xb1, 0xf7, 0xb8, 0xd8, 0xc4, 0xb4, 0x1c, 0xa9, 0xc0, 0xfc, 0x69, 0xde, + 0x91, 0xb8, 0xb1, 0x2f, 0x92, 0xea, 0x7a, 0x61, 0x1f, 0xbd, 0x89, 0xa0, 0x25, 0x13, 0x29, 0x10, 0xe2, 0x9f, 0xb3, 0xe8, + 0x65, 0xe6, 0x46, 0x0a, 0x17, 0xae, 0x5f, 0xb7, 0x76, 0x6d, 0xcc, 0xcf, 0x3e, 0x5f, 0xfc, 0x14, 0xfe, 0x5a, 0x09, 0xfa, + 0x7f, 0xc6, 0x2b, 0x84, 0xd2, 0x85, 0xff, 0x08, 0x71, 0x3c, 0x45, 0xeb, 0x87, 0xb2, 0x41, 0x8c, 0x33, 0xcd, 0xa2, 0x0f, + 0xd5, 0x0d, 0xa1, 0xa2, 0xfe, 0xde, 0x99, 0xeb, 0xf2, 0xcc, 0xf8, 0x6a, 0xd7, 0xdf, 0x1b, 0x07, 0x75, 0x4c, 0xd0, 0xbf, + 0xf4, 0x79, 0x3e, 0x2d, 0x44, 0x01, 0xba, 0xeb, 0xdf, 0xd0, 0xa9, 0xfd, 0x2c, 0x7f, 0x60, 0xbc, 0x70, 0xec, 0xc5, 0xb5, + 0xdf, 0x67, 0x66, 0x05, 0x7a, 0x80, 0xa5, 0x2c, 0x34, 0x6f, 0x68, 0x3d, 0xc9, 0x13, 0xe2, 0xd0, 0x8b, 0x1c, 0xe6, 0xa9, + 0xac, 0x10, 0x67, 0x46, 0xcb, 0xf2, 0xe5, 0x18, 0x7f, 0x28, 0xc8, 0xe7, 0xff, 0x8f, 0x58, 0x64, 0xbc, 0xf3, 0x9d, 0x49, + 0xb7, 0xde, 0xb1, 0xc1, 0xe8, 0x7f, 0x11, 0xc9, 0xe6, 0x5d, 0xec, 0x51, 0x97, 0x3b, 0xbc, 0x2d, 0x07, 0x85, 0xb7, 0xcd, + 0x92, 0x73, 0x18, 0x66, 0xd1, 0xbf, 0xb1, 0x33, 0xaf, 0x85, 0x9b, 0xfe, 0xde, 0x48, 0xad, 0x1d, 0x62, 0xeb, 0x2e, 0x36, + 0xde, 0xea, 0x6e, 0x4e, 0x34, 0x53, 0x30, 0xfa, 0x7b, 0x58, 0xc4, 0x62, 0x6a, 0xd1, 0x85, 0x5c, 0x72, 0x84, 0x18, 0xa3, + 0xe2, 0xda, 0xdd, 0x39, 0x62, 0xe6, 0x47, 0x28, 0x1f, 0x8d, 0x59, 0xc5, 0x41, 0x12, 0xc9, 0x2c, 0x67, 0x04, 0x51, 0xf9, + 0x68, 0xca, 0x27, 0x1c, 0x66, 0xbf, 0x99, 0x37, 0xac, 0xb2, 0x7e, 0xc3, 0x6a, 0x53, 0x69, 0x33, 0x71, 0x55, 0x1e, 0x8d, + 0xf9, 0x88, 0x43, 0x24, 0x92, 0x17, 0xf4, 0x2c, 0x71, 0x45, 0x3d, 0xc0, 0x52, 0x0a, 0x88, 0x37, 0xbf, 0x1f, 0xd4, 0x3c, + 0x89, 0x47, 0x59, 0x97, 0xd6, 0xa7, 0xc0, 0x49, 0x5f, 0x87, 0xc8, 0x72, 0xcc, 0xc3, 0xf3, 0xeb, 0xa3, 0x4e, 0x85, 0x5a, + 0xb7, 0x36, 0x2d, 0x09, 0x65, 0x79, 0x95, 0xcc, 0x5a, 0xaf, 0xfc, 0x52, 0x84, 0x54, 0xc9, 0xac, 0xf5, 0x8a, 0xa2, 0x28, + 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x54, 0xdd, 0x6f, 0x0b, 0x67, 0x59, + 0xf2, 0x7f, 0x6d, 0x2d, 0x95, 0xa1, 0xff, 0x3d, 0xbf, 0xd2, 0xea, 0xe4, 0xfa, 0xdc, 0x0d, 0xb7, 0x0b, 0x39, 0x3a, 0x17, + 0xf1, 0x82, 0xef, 0xef, 0xc5, 0xa5, 0x32, 0xd9, 0x95, 0x78, 0x36, 0x1e, 0x76, 0x5c, 0x72, 0xb9, 0x8e, 0xbb, 0xe0, 0x59, + 0x21, 0x97, 0xf3, 0x6b, 0xac, 0x70, 0x3c, 0xd8, 0x03, 0x88, 0xe3, 0x4c, 0xbf, 0xf2, 0x0f, 0x7d, 0xbe, 0xe4, 0xfb, 0xd8, + 0x24, 0x7c, 0x67, 0xeb, 0x57, 0xea, 0x1c, 0xfc, 0x1d, 0x18, 0x43, 0x19, 0xc3, 0x18, 0xe1, 0xbb, 0xf1, 0x70, 0x6b, 0x3e, + 0xf6, 0x6b, 0x4d, 0x0d, 0xc9, 0x49, 0x74, 0x29, 0xb9, 0xe2, 0xf7, 0xfc, 0xba, 0xdc, 0xe8, 0xe3, 0x12, 0xa1, 0x15, 0xa3, + 0x2d, 0xf1, 0x01, 0x83, 0xd9, 0xc1, 0x01, 0x36, 0x0a, 0x99, 0x5d, 0xef, 0x71, 0xcd, 0x54, 0xd8, 0x8e, 0xd5, 0xe4, 0xb1, + 0xd5, 0x9a, 0x57, 0xf7, 0x78, 0x6e, 0x24, 0x89, 0x14, 0x0e, 0xb2, 0x4c, 0x38, 0x63, 0x6f, 0xd6, 0xee, 0x9e, 0x1c, 0x35, + 0x2e, 0x7e, 0xff, 0x3d, 0xd6, 0x28, 0xe5, 0x5a, 0x1e, 0x25, 0xb8, 0x03, 0xef, 0x20, 0xd1, 0x51, 0xae, 0x3e, 0x47, 0xb9, + 0xc8, 0xaf, 0x3c, 0x9a, 0x95, 0xe6, 0xff, 0x71, 0xe0, 0xe4, 0xaf, 0xde, 0x28, 0x38, 0x19, 0xeb, 0x93, 0x66, 0x9c, 0x09, + 0xb5, 0xd8, 0x27, 0xe6, 0x10, 0xee, 0xc4, 0x41, 0xe3, 0xd2, 0xa8, 0x27, 0xfa, 0xb3, 0xbd, 0x19, 0xd8, 0xce, 0x34, 0xb4, + 0x22, 0x4d, 0xc8, 0xfe, 0x1f, 0xc3, 0x3b, 0x3c, 0x29, 0x9c, 0xdb, 0x12, 0x6e, 0xb3, 0xb4, 0xd7, 0x70, 0x9e, 0x24, 0x4f, + 0xcc, 0xb6, 0xbb, 0x84, 0x89, 0xc2, 0x5d, 0xe2, 0xe1, 0x2c, 0xa6, 0xfa, 0x18, 0x2d, 0x94, 0x0f, 0x13, 0x73, 0xbf, 0x47, + 0x90, 0xcf, 0x50, 0xc2, 0x78, 0x4a, 0x88, 0x2b, 0x39, 0x2a, 0xe6, 0x0a, 0x2f, 0x8e, 0x36, 0xf1, 0x66, 0x63, 0xaf, 0x47, + 0x14, 0xf9, 0x01, 0xf8, 0x21, 0xce, 0xa6, 0x90, 0xde, 0x26, 0x1f, 0xf9, 0x32, 0x8b, 0x43, 0xb6, 0x1d, 0x47, 0x2d, 0x75, + 0xcb, 0xd2, 0xbf, 0x36, 0x07, 0x9d, 0xeb, 0x7d, 0x24, 0xbb, 0x85, 0xfa, 0x7d, 0xc8, 0x33, 0xf7, 0xeb, 0x67, 0x2c, 0x31, + 0xb9, 0x67, 0x6b, 0x71, 0x84, 0xf3, 0x85, 0xf5, 0x6e, 0x22, 0x8b, 0x86, 0xbc, 0xc0, 0x2a, 0xcb, 0x71, 0xbc, 0x6a, 0x7a, + 0x8d, 0x57, 0x58, 0xec, 0x7a, 0xa6, 0x33, 0x98, 0x27, 0x2c, 0x8d, 0x11, 0x5c, 0x39, 0x5e, 0xa2, 0x98, 0xeb, 0xb2, 0xad, + 0x44, 0x41, 0xff, 0x56, 0x6c, 0x21, 0x94, 0x1d, 0x82, 0x4b, 0xae, 0x6c, 0xba, 0x0a, 0x3e, 0x88, 0x30, 0x27, 0xde, 0xa6, + 0x13, 0x05, 0x41, 0xe9, 0xdf, 0x91, 0x7c, 0x67, 0x6b, 0xcd, 0x02, 0xc8, 0xe8, 0x39, 0x90, 0x74, 0xe7, 0xcb, 0x72, 0x2b, + 0x61, 0x7e, 0x8b, 0x8a, 0xe9, 0xef, 0xe1, 0x3d, 0xa6, 0x38, 0xde, 0xd1, 0xa7, 0x44, 0xc7, 0x4e, 0x1e, 0xdd, 0x89, 0x20, + 0x8f, 0x0e, 0xa4, 0x13, 0x42, 0x3f, 0x52, 0x2c, 0x79, 0xd8, 0x17, 0xb3, 0x96, 0x2c, 0xab, 0xc7, 0xe9, 0x0c, 0xd2, 0x19, + 0xc5, 0x01, 0xd7, 0x18, 0x88, 0xab, 0x2d, 0xee, 0x4f, 0x9b, 0xfe, 0xe7, 0xfa, 0xda, 0x25, 0x50, 0xfd, 0xef, 0x35, 0x31, + 0x3a, 0x77, 0x59, 0xf2, 0x9c, 0x97, 0x67, 0x54, 0x7e, 0x81, 0x38, 0x62, 0xd9, 0x4f, 0xa1, 0xa0, 0x7f, 0x14, 0x5b, 0xc9, + 0x60, 0xa6, 0x90, 0xb1, 0xba, 0x7f, 0x19, 0x8e, 0xee, 0x13, 0x1d, 0x46, 0x39, 0xbc, 0xc7, 0xef, 0x5c, 0xfc, 0x29, 0x15, + 0xd1, 0x7f, 0x10, 0x89, 0x84, 0x52, 0x8f, 0xff, 0x88, 0x19, 0x5c, 0xbd, 0xee, 0xb8, 0x3f, 0xd2, 0xdb, 0xe4, 0xef, 0xde, + 0x41, 0x27, 0xa2, 0xc5, 0x79, 0x32, 0x3c, 0x26, 0x8f, 0x34, 0xc2, 0xf3, 0x43, 0x09, 0xa3, 0x81, 0xe7, 0x5c, 0xca, 0xeb, + 0x91, 0x64, 0x99, 0xa7, 0xc4, 0xa6, 0xbf, 0x87, 0x9d, 0x2e, 0xb3, 0xf2, 0x24, 0x56, 0x30, 0xdb, 0x7a, 0x60, 0xce, 0xfc, + 0x6c, 0xd3, 0x97, 0x74, 0x12, 0xf5, 0xff, 0x9c, 0xe6, 0x34, 0x23, 0xa6, 0xd4, 0x13, 0x56, 0x31, 0xe7, 0x73, 0x20, 0x28, + 0xaf, 0x48, 0x67, 0x16, 0x99, 0x28, 0x8e, 0xbf, 0x5b, 0xb2, 0xb4, 0x56, 0x44, 0xff, 0x70, 0xd2, 0xe9, 0xc5, 0x48, 0xbe, + 0xb0, 0x6c, 0xe1, 0x3e, 0x96, 0xf3, 0xb4, 0xc9, 0x6b, 0x3c, 0x95, 0xfb, 0x59, 0xcf, 0xad, 0x96, 0xf5, 0x96, 0x10, 0x43, + 0xb2, 0xf5, 0x89, 0xcc, 0x1b, 0x23, 0x89, 0xe5, 0x0a, 0x2b, 0x8e, 0xa3, 0x7a, 0xc7, 0x52, 0x62, 0xd7, 0x7f, 0x32, 0x4f, + 0x9e, 0x52, 0xfd, 0x07, 0x93, 0x6c, 0x14, 0x79, 0x5a, 0xd4, 0xbf, 0xc8, 0x0d, 0x3a, 0x84, 0xef, 0x84, 0x36, 0x8f, 0x33, + 0x6e, 0xdc, 0x0b, 0x88, 0x75, 0xc9, 0x9d, 0x7b, 0x62, 0x9d, 0x81, 0x6c, 0xb5, 0x8c, 0x9f, 0x76, 0xfd, 0x43, 0x38, 0x40, + 0x0f, 0xe7, 0xef, 0xe7, 0x84, 0xf8, 0xa4, 0xa2, 0xa7, 0xf7, 0xa9, 0xac, 0x24, 0xca, 0xb2, 0x85, 0x48, 0x72, 0x59, 0x67, + 0xe6, 0x47, 0x18, 0xcc, 0x4a, 0x0e, 0x59, 0x66, 0xe7, 0xf9, 0x3d, 0xf1, 0x9c, 0xce, 0x72, 0x31, 0x46, 0xa6, 0x88, 0x50, + 0xd7, 0x08, 0xb8, 0x1b, 0x9c, 0x96, 0x0c, 0x4e, 0xff, 0x01, 0xd6, 0xab, 0xf6, 0x97, 0xd1, 0xbf, 0x1a, 0x8b, 0x38, 0xcc, + 0x6e, 0x5e, 0x17, 0xf5, 0x8f, 0x74, 0x5c, 0xcf, 0xd9, 0x42, 0xcd, 0x8b, 0xd9, 0x4b, 0x1e, 0x79, 0x42, 0x4c, 0xb6, 0x14, + 0x89, 0x71, 0x99, 0xef, 0xbd, 0x26, 0x25, 0x48, 0xfd, 0xbd, 0x11, 0x83, 0x9f, 0x9a, 0x67, 0xe7, 0x0e, 0xa4, 0x89, 0xb3, + 0x57, 0x78, 0xdf, 0xed, 0xd2, 0x28, 0xb0, 0x46, 0x30, 0x7b, 0x63, 0x98, 0x0b, 0xcc, 0xac, 0x6b, 0xb5, 0x39, 0xc2, 0xbf, + 0x2d, 0x11, 0x8a, 0x69, 0x26, 0x72, 0xe7, 0x1c, 0xf2, 0x19, 0x50, 0x0e, 0xfd, 0xcf, 0x24, 0x8d, 0xeb, 0xa9, 0x66, 0x08, + 0x0b, 0x42, 0xff, 0x1a, 0xe4, 0x59, 0x7b, 0x9c, 0x5f, 0x42, 0xff, 0xa2, 0x27, 0x68, 0xd9, 0x1f, 0x7b, 0xd4, 0x99, 0xb5, + 0x61, 0x10, 0xbb, 0xac, 0xcf, 0x44, 0x81, 0x39, 0x4e, 0x6f, 0x25, 0xd9, 0x44, 0x68, 0x85, 0xf3, 0xa6, 0x38, 0xcb, 0x86, + 0xbb, 0xfe, 0x0d, 0x58, 0x6a, 0x5c, 0xdc, 0x07, 0x5d, 0x46, 0xdf, 0x3d, 0xae, 0xcf, 0xe5, 0xd3, 0x9d, 0x77, 0x40, 0xef, + 0x6c, 0x5f, 0x13, 0x2d, 0x7d, 0xf7, 0x02, 0x5f, 0x04, 0x6a, 0xbc, 0xe5, 0x8d, 0xc6, 0x4d, 0xff, 0x47, 0x7c, 0xfe, 0x7e, + 0xd8, 0x1b, 0x84, 0xfe, 0xde, 0xa7, 0xd6, 0x61, 0xa7, 0x58, 0x7f, 0x1b, 0x47, 0x59, 0x62, 0x22, 0x56, 0x3e, 0xb1, 0x66, + 0x97, 0x0f, 0xfc, 0x29, 0xf3, 0x65, 0x0e, 0x13, 0x4b, 0x0e, 0x6b, 0xc4, 0x08, 0xe4, 0x40, 0xae, 0xd1, 0x36, 0xe5, 0x9c, + 0x39, 0xa0, 0x2a, 0xe0, 0xa6, 0xff, 0x83, 0xd6, 0xb8, 0x9a, 0x53, 0xaf, 0xff, 0xe3, 0x24, 0x91, 0xcf, 0xa7, 0x2e, 0x33, + 0x2f, 0x04, 0x4e, 0x04, 0x6d, 0x2b, 0x65, 0x3b, 0xbf, 0x35, 0xfd, 0xdb, 0x92, 0x58, 0x45, 0xf5, 0x2f, 0xea, 0xf3, 0x4e, + 0xd7, 0xdf, 0xae, 0x2b, 0x41, 0xff, 0x54, 0x62, 0x69, 0x66, 0x7d, 0x3a, 0xe9, 0x24, 0x3c, 0xf3, 0xc4, 0xf2, 0xdf, 0x2a, + 0xa0, 0xbf, 0x52, 0x39, 0x51, 0x63, 0x11, 0x44, 0x58, 0x67, 0xff, 0xab, 0x26, 0xbc, 0x49, 0x57, 0x73, 0xad, 0xa1, 0x28, + 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0x55, 0x8b, 0x8b, 0x84, 0xec, + 0xf6, 0x5e, 0x37, 0xe9, 0x3a, 0x72, 0xd8, 0xec, 0xf8, 0x0d, 0xfc, 0xbf, 0x1e, 0x0f, 0xe2, 0x09, 0xd1, 0x6d, 0xd6, 0x99, + 0x2f, 0xc8, 0x62, 0x19, 0xcf, 0x09, 0x0e, 0x35, 0x77, 0xf7, 0x7a, 0x1b, 0x8b, 0x73, 0x41, 0x5a, 0xee, 0xb6, 0xa5, 0x51, + 0x82, 0xe7, 0x27, 0x9e, 0x3f, 0x13, 0xcf, 0x0f, 0xdc, 0xc6, 0xfd, 0xec, 0x25, 0x83, 0x09, 0x42, 0xbd, 0x78, 0x1e, 0x60, + 0x3b, 0xd9, 0x4c, 0x17, 0xbd, 0x17, 0xad, 0x58, 0x45, 0x0e, 0x3b, 0xc4, 0x7c, 0xec, 0xfb, 0xb8, 0x9d, 0xed, 0xa4, 0x31, + 0x45, 0xfc, 0x1e, 0xde, 0x91, 0x0d, 0x64, 0xf3, 0x11, 0x4f, 0xf2, 0xb2, 0xb0, 0xcf, 0xf1, 0x24, 0x88, 0xee, 0xf5, 0xfb, + 0x88, 0x27, 0x93, 0x95, 0xbe, 0x38, 0x8b, 0xe3, 0x7d, 0x51, 0x92, 0x3f, 0xa1, 0x31, 0x09, 0x54, 0x77, 0x7c, 0xd1, 0x0f, + 0x06, 0xa1, 0x7f, 0xb4, 0xf0, 0xb5, 0x3b, 0x9c, 0xbd, 0x3c, 0x44, 0x35, 0x86, 0x92, 0x29, 0xb6, 0xf4, 0x1f, 0xc8, 0x64, + 0xbc, 0xf8, 0x8d, 0x64, 0x2f, 0xd1, 0x9c, 0x46, 0x5f, 0x0a, 0x04, 0x57, 0xb9, 0x9b, 0x7b, 0x39, 0x9c, 0x43, 0xe2, 0x75, + 0x28, 0x2f, 0x77, 0xdb, 0x52, 0x81, 0x2f, 0x33, 0x63, 0x09, 0xf0, 0x06, 0xf5, 0xb9, 0x99, 0xa3, 0x2c, 0xa5, 0x11, 0x97, + 0x71, 0x58, 0x88, 0xd7, 0x80, 0x7f, 0xd0, 0x94, 0x0b, 0x48, 0xe4, 0x6e, 0xe1, 0x9b, 0xeb, 0x36, 0x26, 0x50, 0x93, 0x4b, + 0xc8, 0x15, 0xb2, 0xd6, 0x1f, 0x65, 0x2d, 0x4d, 0x39, 0x87, 0xed, 0x3c, 0x22, 0xb8, 0xb9, 0x77, 0x31, 0x91, 0x3a, 0x26, + 0xdf, 0xfd, 0x6c, 0x61, 0x9f, 0x33, 0x69, 0x2a, 0x5c, 0x35, 0x91, 0xe4, 0x10, 0x49, 0x18, 0x73, 0xc4, 0xec, 0x6f, 0x53, + 0x79, 0x45, 0x8c, 0x36, 0xc0, 0x99, 0x71, 0x61, 0x9e, 0xe8, 0xba, 0x0e, 0x46, 0xff, 0xf3, 0xc9, 0xa6, 0x01, 0xf5, 0xa9, + 0xcf, 0x76, 0x06, 0x09, 0x75, 0x5e, 0xe1, 0x0d, 0x71, 0x5b, 0x1d, 0x28, 0x74, 0xee, 0x9e, 0xb9, 0x41, 0xea, 0xef, 0xb1, + 0x3a, 0x11, 0x1a, 0x88, 0x3e, 0x88, 0x60, 0xf5, 0x2f, 0x8a, 0x33, 0x4a, 0x76, 0xbe, 0xfa, 0x7f, 0xc1, 0x08, 0x61, 0x9d, + 0xa2, 0x18, 0x84, 0x97, 0x84, 0x23, 0x3f, 0x8f, 0x02, 0xe7, 0xbc, 0x66, 0x0a, 0x7e, 0xe4, 0x62, 0x57, 0xe6, 0x5d, 0xac, + 0x15, 0x5a, 0xe4, 0xa0, 0xa3, 0xef, 0xdb, 0xa2, 0xfe, 0x1d, 0x2d, 0xde, 0xdc, 0x42, 0xfa, 0x12, 0x46, 0x84, 0xe0, 0x7b, + 0x7a, 0x88, 0x7c, 0xf2, 0x84, 0x79, 0x23, 0x82, 0xd5, 0xbf, 0x3d, 0xeb, 0xc8, 0x62, 0x29, 0x7f, 0x17, 0xf4, 0xef, 0xcf, + 0x11, 0x76, 0x3a, 0x0c, 0xb3, 0x1c, 0x81, 0xe4, 0xda, 0xbb, 0x82, 0x38, 0xe7, 0xaf, 0x49, 0xa2, 0xfe, 0x7f, 0x64, 0x2b, + 0xd9, 0xcc, 0x10, 0xfb, 0xc9, 0xed, 0x96, 0xb6, 0x90, 0x96, 0x17, 0xe9, 0x1f, 0xc5, 0x7a, 0xa1, 0x77, 0x92, 0xf5, 0x6f, + 0xe9, 0x7c, 0xd7, 0x2f, 0xea, 0x4b, 0x56, 0x0b, 0x6e, 0xfd, 0xe2, 0x75, 0x9e, 0x11, 0x3c, 0xc3, 0xfd, 0x7c, 0xde, 0xfa, + 0xe7, 0x04, 0xaf, 0xfa, 0x51, 0x5a, 0x3b, 0xce, 0xed, 0xbd, 0x42, 0xcd, 0xe2, 0x16, 0x79, 0x5a, 0xd4, 0xbf, 0x95, 0x45, + 0x9d, 0x91, 0x7c, 0x4d, 0x36, 0x73, 0x84, 0xec, 0xbb, 0x35, 0x78, 0x93, 0xbf, 0x09, 0xe7, 0x1d, 0x9c, 0xfe, 0xde, 0x68, + 0xa1, 0x89, 0xd4, 0x66, 0x00, 0x85, 0xe2, 0xfd, 0x9f, 0xe5, 0xf2, 0xa5, 0xbb, 0x06, 0xd3, 0x99, 0x26, 0xce, 0x3c, 0xe0, + 0xcd, 0xb6, 0x5e, 0xdd, 0x71, 0x4b, 0x48, 0xfa, 0x7f, 0xc8, 0x59, 0x74, 0x21, 0xde, 0x89, 0xfa, 0x3a, 0x9e, 0x1c, 0x2e, + 0x10, 0xf7, 0x26, 0x2d, 0xf7, 0xea, 0x3f, 0x84, 0x34, 0xda, 0x07, 0x7c, 0xff, 0x57, 0x4c, 0xff, 0x12, 0x6f, 0xfd, 0x34, + 0x61, 0x36, 0x94, 0xa3, 0x26, 0x92, 0xca, 0xc3, 0x08, 0x36, 0x08, 0x77, 0x72, 0xbe, 0xf3, 0xfc, 0x32, 0x2d, 0x28, 0xfd, + 0xbd, 0x34, 0x67, 0x1a, 0x9b, 0x44, 0x6f, 0xb5, 0xd4, 0xff, 0x37, 0x05, 0xe7, 0xaa, 0xf8, 0x30, 0x00, 0xfd, 0x4b, 0xfa, + 0xa5, 0xd9, 0x82, 0xfe, 0x11, 0x24, 0x98, 0xd8, 0xbb, 0xf6, 0xec, 0x12, 0xa3, 0x6f, 0xa6, 0x3a, 0xf1, 0x3d, 0xfe, 0x57, + 0xd5, 0x77, 0x4c, 0xa1, 0x11, 0x57, 0x93, 0x2f, 0xea, 0x5f, 0x14, 0x59, 0xf1, 0xbc, 0xd0, 0x12, 0xc1, 0xea, 0x3f, 0x8a, + 0x4c, 0x4b, 0x0e, 0xe5, 0x93, 0xa1, 0x7f, 0x38, 0xb1, 0xe6, 0x9a, 0x6d, 0x45, 0x86, 0xf8, 0x34, 0xf2, 0x11, 0x35, 0x38, + 0x8d, 0x8d, 0x3c, 0x2b, 0xb4, 0xe4, 0x7e, 0xee, 0x37, 0x4f, 0xb1, 0xd9, 0x41, 0xe8, 0x7f, 0x39, 0x5f, 0x1a, 0x2d, 0x1f, + 0x66, 0x63, 0xc0, 0xfa, 0x87, 0x92, 0x67, 0xe6, 0x23, 0x69, 0x4b, 0x4e, 0x00, 0xfa, 0xf7, 0xf3, 0xcd, 0x50, 0xf0, 0x9c, + 0xe8, 0x76, 0xec, 0xc9, 0x5e, 0x92, 0xc8, 0x15, 0xef, 0x54, 0xbb, 0xfe, 0xde, 0xf3, 0xfc, 0x98, 0x78, 0xe6, 0xf2, 0xaa, + 0xcb, 0xf8, 0x3f, 0x4e, 0x8c, 0x96, 0x0c, 0x4e, 0xff, 0x42, 0xf6, 0x59, 0x3c, 0xc1, 0x27, 0x43, 0x7f, 0x6f, 0xae, 0xed, + 0x9d, 0x64, 0x92, 0x2b, 0xce, 0xb8, 0x71, 0x94, 0x17, 0x49, 0x25, 0x9f, 0x45, 0x42, 0x54, 0x96, 0x87, 0xcb, 0x48, 0x22, + 0x9d, 0xcd, 0xcc, 0x0a, 0x42, 0xff, 0x70, 0xe6, 0x71, 0x88, 0x64, 0x76, 0x0b, 0xd1, 0xb3, 0x36, 0xfd, 0xbd, 0x4f, 0xe5, + 0x79, 0xe4, 0xf2, 0x15, 0x9f, 0x04, 0xa0, 0x7f, 0x57, 0xf2, 0x7d, 0x3d, 0xda, 0x4c, 0x6b, 0xf4, 0x94, 0xcd, 0x4b, 0x6e, + 0xd3, 0x3f, 0x9c, 0xa7, 0x1c, 0x37, 0xf1, 0x22, 0xfe, 0x7c, 0x52, 0xf5, 0x1f, 0xc0, 0xc7, 0x62, 0x5c, 0xa7, 0xac, 0x7f, + 0xe5, 0x50, 0xd7, 0x12, 0x5f, 0xe5, 0x3d, 0xaf, 0x30, 0x51, 0xfb, 0x12, 0xaf, 0xb4, 0xf7, 0x3e, 0x9b, 0x1d, 0xd4, 0xde, + 0x6a, 0x58, 0x63, 0x57, 0x5e, 0x60, 0x89, 0x65, 0x74, 0x0e, 0x0b, 0x78, 0x3e, 0xa0, 0xea, 0x24, 0x33, 0xd6, 0xbc, 0x69, + 0x64, 0x96, 0x63, 0x16, 0x01, 0xfb, 0xfd, 0xff, 0x3e, 0x3b, 0x78, 0x96, 0xd9, 0x24, 0xd2, 0xf4, 0xa4, 0xea, 0xdf, 0x96, + 0x46, 0xa4, 0x08, 0x33, 0x48, 0x9d, 0x4c, 0xfd, 0xed, 0xae, 0xec, 0xb6, 0x01, 0xac, 0x15, 0xac, 0xfe, 0x6e, 0xbf, 0xd8, + 0xa4, 0x93, 0x54, 0xe1, 0xad, 0x5c, 0xce, 0x7e, 0xb2, 0xd9, 0x22, 0x3e, 0xff, 0x97, 0x5f, 0xff, 0x30, 0x6e, 0xe0, 0x49, + 0x46, 0x8b, 0xd7, 0x61, 0xe5, 0xea, 0xef, 0x7d, 0xdb, 0x90, 0xb4, 0xfe, 0xe5, 0xf5, 0x1f, 0xe8, 0x7a, 0xef, 0x97, 0xbc, + 0xd3, 0x57, 0xa6, 0x77, 0xb8, 0x66, 0x25, 0xc5, 0x19, 0x55, 0xf5, 0x5f, 0x27, 0xab, 0x07, 0x78, 0x77, 0x29, 0xbf, 0x45, + 0x3a, 0xb2, 0x9c, 0xb8, 0x5f, 0x71, 0x94, 0x91, 0x52, 0x31, 0xce, 0xe1, 0x4e, 0xf1, 0x17, 0x70, 0x45, 0x51, 0x14, 0x45, + 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x24, 0x3e, 0x71, 0xb2, 0x3e, 0xb7, 0xe7, + 0x5b, 0xe1, 0xfb, 0xca, 0x4b, 0xce, 0x7c, 0xfa, 0x6b, 0x8d, 0x47, 0xc0, 0xc3, 0x26, 0x5f, 0xbe, 0xcf, 0x12, 0xee, 0x65, + 0x8d, 0xa9, 0x79, 0x0d, 0x5f, 0x0b, 0xdf, 0x3f, 0x57, 0x3a, 0x0e, 0x9b, 0xc6, 0xc4, 0x09, 0xd9, 0x48, 0xaf, 0x22, 0xc1, + 0x61, 0xa1, 0xe5, 0xbb, 0xcf, 0x9d, 0xc2, 0xb7, 0xc9, 0x73, 0x19, 0xe8, 0xb7, 0x6c, 0x10, 0x57, 0x5b, 0x72, 0x25, 0x86, + 0x70, 0x37, 0xaf, 0x19, 0xc7, 0x59, 0x63, 0xa1, 0xde, 0xff, 0x3a, 0x4f, 0xf3, 0xbe, 0xf9, 0x7f, 0x3c, 0xb3, 0x84, 0xd2, + 0x3b, 0xf8, 0xcc, 0xb4, 0xf7, 0x21, 0x93, 0xdd, 0xb7, 0x29, 0x87, 0x1d, 0x67, 0xe9, 0xf1, 0xce, 0xb6, 0x6d, 0x8c, 0xa3, + 0x36, 0x09, 0x42, 0x76, 0x7d, 0x0f, 0x4f, 0xf0, 0x2f, 0xe7, 0x2a, 0xf9, 0x5c, 0xf4, 0xb6, 0x34, 0xa1, 0x09, 0xed, 0x48, + 0x15, 0x33, 0xff, 0x5e, 0x43, 0x3a, 0x93, 0x04, 0x87, 0xeb, 0x60, 0x21, 0xa3, 0xe4, 0x08, 0x3e, 0x77, 0xce, 0xe4, 0x44, + 0xae, 0x23, 0x96, 0x3f, 0x91, 0xc2, 0xfd, 0xcc, 0xae, 0x34, 0xe7, 0xc5, 0x6f, 0x87, 0x48, 0x0a, 0x8c, 0x87, 0x60, 0x0f, + 0x57, 0x08, 0xa5, 0xcd, 0x8c, 0x6b, 0x35, 0x8a, 0xd7, 0x48, 0xa1, 0x36, 0xc3, 0x1c, 0x2d, 0xfd, 0x3d, 0x64, 0x79, 0x2c, + 0xb6, 0xe4, 0xcb, 0x6f, 0xc6, 0x11, 0x93, 0xd5, 0x77, 0x35, 0xf7, 0x58, 0x8f, 0x61, 0x81, 0x78, 0xed, 0x79, 0x1d, 0x69, + 0xe3, 0xc4, 0xe5, 0x83, 0xc5, 0x8c, 0xa2, 0x8d, 0x38, 0x2c, 0xfa, 0xb2, 0xfa, 0xd0, 0xcf, 0xf8, 0x11, 0xe7, 0x31, 0x5f, + 0xf0, 0x22, 0x29, 0x31, 0xdc, 0x40, 0x77, 0x92, 0x2c, 0x9e, 0xb6, 0x3d, 0x5c, 0xc0, 0x52, 0xfa, 0x31, 0x97, 0x21, 0x4c, + 0x11, 0xbc, 0x7c, 0x45, 0xbc, 0xc3, 0x31, 0xeb, 0xbc, 0x07, 0x5e, 0xe5, 0x1b, 0x71, 0xd0, 0x9a, 0x03, 0x78, 0x14, 0xbb, + 0x2d, 0xbe, 0x99, 0x77, 0x2c, 0xae, 0x53, 0x59, 0x7f, 0x6f, 0x36, 0x72, 0x75, 0x08, 0x04, 0xcf, 0xc3, 0xcc, 0xe5, 0x65, + 0xfe, 0x6a, 0x29, 0x9d, 0xc6, 0xa3, 0x24, 0x13, 0xc1, 0x2d, 0xbc, 0xc5, 0x66, 0x61, 0xf4, 0xf7, 0x18, 0xa7, 0x71, 0x36, + 0x31, 0xbc, 0x6e, 0xd9, 0xc2, 0x9d, 0x7c, 0x46, 0x94, 0x30, 0xf3, 0x4e, 0x71, 0x44, 0x4d, 0x36, 0x5d, 0x2d, 0x65, 0x4b, + 0x2d, 0x7d, 0x86, 0xac, 0x7f, 0x38, 0xc7, 0xfe, 0x67, 0xb3, 0x98, 0x56, 0x84, 0xb3, 0xc8, 0x26, 0x89, 0x2e, 0x96, 0xd2, + 0x61, 0x24, 0x9a, 0xd9, 0x55, 0xea, 0x91, 0x48, 0xa6, 0xe8, 0x03, 0x0e, 0xe3, 0x4b, 0x1e, 0xa7, 0x39, 0xb9, 0x62, 0xfc, + 0xa2, 0xd7, 0x5b, 0xe6, 0x8d, 0x11, 0xba, 0xc9, 0xe2, 0x5e, 0xdb, 0xce, 0x03, 0x96, 0x3d, 0xdf, 0xca, 0x7e, 0x3a, 0x04, + 0xa1, 0xbf, 0x87, 0x55, 0xcc, 0xf9, 0x15, 0x38, 0xd9, 0xaa, 0x1e, 0xab, 0x85, 0x59, 0x04, 0x4a, 0xa2, 0xee, 0x8e, 0x31, + 0xd2, 0xfc, 0xb5, 0x8e, 0x65, 0xe2, 0x1a, 0x7f, 0x76, 0x66, 0xdd, 0x1a, 0x49, 0xa2, 0x25, 0x5f, 0xfa, 0x7b, 0xe4, 0x59, + 0x7c, 0x8a, 0x37, 0x01, 0x47, 0x0c, 0x1b, 0x84, 0xde, 0x7f, 0xa5, 0x65, 0x7b, 0x36, 0xfd, 0xa3, 0x48, 0xd2, 0x11, 0xbe, + 0x0a, 0x32, 0xdd, 0x32, 0xb3, 0x54, 0x59, 0x6c, 0x10, 0xa3, 0xac, 0x6d, 0xfa, 0x87, 0x92, 0x4f, 0x3b, 0x6d, 0xed, 0x2a, + 0x46, 0x0f, 0xde, 0x25, 0xd3, 0x89, 0x8b, 0x0c, 0x16, 0x7d, 0xfe, 0xfb, 0xf5, 0xd3, 0x86, 0x91, 0xd6, 0x79, 0xbb, 0xca, + 0xd6, 0x7f, 0x6c, 0x90, 0xfa, 0x57, 0xd3, 0x16, 0xff, 0x0d, 0xf1, 0x17, 0x66, 0x89, 0xf1, 0x4d, 0xb2, 0xfe, 0xbd, 0x2d, + 0xf3, 0xd7, 0x28, 0xbf, 0x56, 0x9a, 0xb0, 0x9e, 0x64, 0x21, 0x37, 0xbf, 0xa4, 0xff, 0x42, 0xe2, 0xad, 0xb3, 0xb5, 0x28, + 0xbf, 0x5e, 0x42, 0x85, 0x1e, 0x20, 0x54, 0x9c, 0x2d, 0x53, 0xdb, 0x4a, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, + 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, + 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, + 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, + 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, + 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, + 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, + 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, + 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, + 0x51, 0x14, 0x45, 0x51, 0x14, 0x45, 0x51, 0x14, 0xe5, 0x24, 0xf0, 0xff }; + +// Font glyphs rectangles data (on atlas) +static const Rectangle darkFontRecs[95] = { + { 4, 4, 2 , 16 }, + { 14, 4, 3 , 10 }, + { 25, 4, 5 , 3 }, + { 38, 4, 8 , 9 }, + { 54, 4, 7 , 11 }, + { 69, 4, 9 , 11 }, + { 86, 4, 9 , 11 }, + { 103, 4, 2 , 3 }, + { 113, 4, 4 , 13 }, + { 125, 4, 4 , 13 }, + { 137, 4, 5 , 6 }, + { 150, 4, 7 , 7 }, + { 165, 4, 3 , 4 }, + { 176, 4, 5 , 2 }, + { 189, 4, 3 , 3 }, + { 200, 4, 5 , 13 }, + { 213, 4, 7 , 11 }, + { 228, 4, 4 , 9 }, + { 240, 4, 7 , 10 }, + { 4, 28, 7 , 11 }, + { 19, 28, 8 , 9 }, + { 35, 28, 8 , 10 }, + { 51, 28, 7 , 11 }, + { 66, 28, 7 , 9 }, + { 81, 28, 7 , 11 }, + { 96, 28, 7 , 11 }, + { 111, 28, 3 , 8 }, + { 122, 28, 3 , 9 }, + { 133, 28, 7 , 9 }, + { 148, 28, 7 , 5 }, + { 163, 28, 7 , 9 }, + { 178, 28, 6 , 11 }, + { 192, 28, 11 , 11 }, + { 211, 28, 8 , 9 }, + { 227, 28, 7 , 9 }, + { 4, 52, 8 , 11 }, + { 20, 52, 7 , 9 }, + { 35, 52, 6 , 9 }, + { 49, 52, 6 , 9 }, + { 63, 52, 8 , 11 }, + { 79, 52, 7 , 9 }, + { 94, 52, 2 , 9 }, + { 104, 52, 6 , 10 }, + { 118, 52, 7 , 9 }, + { 133, 52, 6 , 9 }, + { 147, 52, 9 , 9 }, + { 164, 52, 7 , 9 }, + { 179, 52, 8 , 11 }, + { 195, 52, 7 , 9 }, + { 210, 52, 8 , 12 }, + { 226, 52, 7 , 9 }, + { 4, 76, 7 , 11 }, + { 19, 76, 7 , 9 }, + { 34, 76, 8 , 10 }, + { 50, 76, 8 , 9 }, + { 66, 76, 11 , 9 }, + { 85, 76, 8 , 9 }, + { 101, 76, 8 , 9 }, + { 117, 76, 7 , 9 }, + { 132, 76, 4 , 13 }, + { 144, 76, 5 , 13 }, + { 157, 76, 4 , 13 }, + { 169, 76, 5 , 4 }, + { 182, 76, 7 , 2 }, + { 197, 76, 4 , 3 }, + { 209, 76, 6 , 8 }, + { 223, 76, 6 , 11 }, + { 237, 76, 7 , 8 }, + { 4, 100, 7 , 11 }, + { 19, 100, 7 , 8 }, + { 34, 100, 5 , 10 }, + { 47, 100, 7 , 10 }, + { 62, 100, 6 , 10 }, + { 76, 100, 3 , 10 }, + { 87, 100, 4 , 13 }, + { 99, 100, 6 , 10 }, + { 113, 100, 2 , 10 }, + { 123, 100, 10 , 7 }, + { 141, 100, 6 , 7 }, + { 155, 100, 7 , 8 }, + { 170, 100, 6 , 10 }, + { 184, 100, 7 , 10 }, + { 199, 100, 4 , 7 }, + { 211, 100, 6 , 8 }, + { 225, 100, 4 , 10 }, + { 237, 100, 7 , 8 }, + { 4, 124, 7 , 7 }, + { 19, 124, 10 , 7 }, + { 37, 124, 7 , 7 }, + { 52, 124, 7 , 10 }, + { 67, 124, 6 , 7 }, + { 81, 124, 5 , 13 }, + { 94, 124, 2 , 13 }, + { 104, 124, 5 , 13 }, + { 117, 124, 7 , 3 }, +}; + +// Font glyphs info data +// NOTE: No glyphs.image data provided +static const GlyphInfo darkFontGlyphs[95] = { + { 32, 0, 12, 2, { 0 }}, + { 33, 0, 3, 3, { 0 }}, + { 34, 0, 3, 4, { 0 }}, + { 35, 0, 3, 7, { 0 }}, + { 36, 0, 2, 7, { 0 }}, + { 37, 0, 2, 9, { 0 }}, + { 38, 0, 2, 8, { 0 }}, + { 39, 0, 3, 2, { 0 }}, + { 40, 1, 2, 4, { 0 }}, + { 41, 0, 2, 4, { 0 }}, + { 42, 1, 2, 6, { 0 }}, + { 43, 0, 5, 7, { 0 }}, + { 44, 0, 10, 2, { 0 }}, + { 45, 0, 7, 5, { 0 }}, + { 46, 0, 10, 3, { 0 }}, + { 47, 0, 2, 4, { 0 }}, + { 48, 0, 2, 7, { 0 }}, + { 49, 0, 3, 5, { 0 }}, + { 50, 0, 2, 7, { 0 }}, + { 51, 0, 2, 7, { 0 }}, + { 52, 0, 3, 7, { 0 }}, + { 53, 0, 3, 7, { 0 }}, + { 54, 0, 2, 7, { 0 }}, + { 55, 0, 3, 7, { 0 }}, + { 56, 0, 2, 7, { 0 }}, + { 57, 0, 2, 7, { 0 }}, + { 58, 0, 5, 3, { 0 }}, + { 59, 0, 5, 3, { 0 }}, + { 60, 0, 4, 7, { 0 }}, + { 61, 0, 6, 7, { 0 }}, + { 62, 0, 4, 7, { 0 }}, + { 63, 0, 2, 6, { 0 }}, + { 64, 0, 3, 10, { 0 }}, + { 65, 0, 3, 7, { 0 }}, + { 66, 1, 3, 8, { 0 }}, + { 67, 0, 2, 8, { 0 }}, + { 68, 1, 3, 8, { 0 }}, + { 69, 1, 3, 7, { 0 }}, + { 70, 1, 3, 6, { 0 }}, + { 71, 0, 2, 8, { 0 }}, + { 72, 1, 3, 8, { 0 }}, + { 73, 1, 3, 3, { 0 }}, + { 74, 0, 3, 6, { 0 }}, + { 75, 1, 3, 7, { 0 }}, + { 76, 1, 3, 6, { 0 }}, + { 77, 1, 3, 10, { 0 }}, + { 78, 1, 3, 8, { 0 }}, + { 79, 0, 2, 8, { 0 }}, + { 80, 1, 3, 7, { 0 }}, + { 81, 0, 2, 8, { 0 }}, + { 82, 1, 3, 7, { 0 }}, + { 83, 0, 2, 7, { 0 }}, + { 84, 0, 3, 6, { 0 }}, + { 85, 0, 3, 8, { 0 }}, + { 86, 0, 3, 7, { 0 }}, + { 87, 0, 3, 10, { 0 }}, + { 88, 0, 3, 7, { 0 }}, + { 89, 0, 3, 7, { 0 }}, + { 90, 0, 3, 7, { 0 }}, + { 91, 1, 2, 4, { 0 }}, + { 92, 0, 2, 4, { 0 }}, + { 93, 0, 2, 4, { 0 }}, + { 94, 0, 3, 4, { 0 }}, + { 95, -1, 12, 5, { 0 }}, + { 96, 1, 2, 6, { 0 }}, + { 97, 0, 5, 6, { 0 }}, + { 98, 1, 2, 7, { 0 }}, + { 99, 0, 5, 6, { 0 }}, + { 100, 0, 2, 7, { 0 }}, + { 101, 0, 5, 7, { 0 }}, + { 102, 0, 2, 4, { 0 }}, + { 103, 0, 5, 7, { 0 }}, + { 104, 1, 2, 7, { 0 }}, + { 105, 0, 2, 3, { 0 }}, + { 106, -1, 2, 3, { 0 }}, + { 107, 1, 2, 6, { 0 }}, + { 108, 1, 2, 3, { 0 }}, + { 109, 1, 5, 11, { 0 }}, + { 110, 1, 5, 7, { 0 }}, + { 111, 0, 5, 7, { 0 }}, + { 112, 1, 5, 7, { 0 }}, + { 113, 0, 5, 7, { 0 }}, + { 114, 1, 5, 4, { 0 }}, + { 115, 0, 5, 6, { 0 }}, + { 116, 0, 3, 4, { 0 }}, + { 117, 0, 5, 7, { 0 }}, + { 118, 0, 5, 6, { 0 }}, + { 119, 0, 5, 9, { 0 }}, + { 120, 0, 5, 6, { 0 }}, + { 121, 0, 5, 6, { 0 }}, + { 122, 0, 5, 6, { 0 }}, + { 123, 0, 2, 4, { 0 }}, + { 124, 1, 2, 4, { 0 }}, + { 125, 0, 2, 4, { 0 }}, + { 126, 0, 6, 7, { 0 }}, +}; + +// Style loading function: Dark +static void GuiLoadStyleDark(void) +{ + // Load style properties provided + // NOTE: Default properties are propagated + for (int i = 0; i < DARK_STYLE_PROPS_COUNT; i++) + { + GuiSetStyle(darkStyleProps[i].controlId, darkStyleProps[i].propertyId, darkStyleProps[i].propertyValue); + } + + // Custom font loading + // NOTE: Compressed font image data (DEFLATE), it requires DecompressData() function + // int darkFontDataSize = 0; + // unsigned char *data = DecompressData(darkFontData, DARK_STYLE_FONT_ATLAS_COMP_SIZE, &darkFontDataSize); + // Image imFont = { data, 256, 256, 1, 2 }; + + // Font font = { 0 }; + // font.baseSize = 16; + // font.glyphCount = 95; + + // // Load texture from image + // font.texture = LoadTextureFromImage(imFont); + // UnloadImage(imFont); // Uncompressed image data can be unloaded from memory + + // // Copy char recs data from global fontRecs + // // NOTE: Required to avoid issues if trying to free font + // font.recs = (Rectangle *)RAYGUI_MALLOC(font.glyphCount*sizeof(Rectangle)); + // memcpy(font.recs, darkFontRecs, font.glyphCount*sizeof(Rectangle)); + + // // Copy font char info data from global fontChars + // // NOTE: Required to avoid issues if trying to free font + // font.glyphs = (GlyphInfo *)RAYGUI_MALLOC(font.glyphCount*sizeof(GlyphInfo)); + // memcpy(font.glyphs, darkFontGlyphs, font.glyphCount*sizeof(GlyphInfo)); + + // GuiSetFont(font); + + // // Setup a white rectangle on the font to be used on shapes drawing, + // // it makes possible to draw shapes and text (full UI) in a single draw call + // Rectangle fontWhiteRec = { 254, 254, 1, 1 }; + // SetShapesTexture(font.texture, fontWhiteRec); + + //----------------------------------------------------------------- + + // TODO: Custom user style setup: Set specific properties here (if required) + // i.e. Controls specific BORDER_WIDTH, TEXT_PADDING, TEXT_ALIGNMENT +} diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..307d55b --- /dev/null +++ b/src/main.c @@ -0,0 +1,1929 @@ +#include +#include +#include "stdint.h" +#include "string.h" +#include "inttypes.h" +#include +#include "shaders.h" + +#define DEMO_VIDEO_FEATURES 0 + +#ifdef PLATFORM_WEB +#include +#endif + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Weverything" + +#include "raylib.h" +#include "raymath.h" +#include "rlgl.h" + +Vector3 GetCameraRight(Camera *camera); +Vector3 GetCameraForward(Camera *camera); +void CameraMoveForward(Camera *camera, float distance, bool moveInWorldPlane); +void CameraMoveUp(Camera *camera, float distance); +void CameraMoveRight(Camera *camera, float distance, bool moveInWorldPlane); + +#define RAYGUI_IMPLEMENTATION +#include "raygui.h" +#include "dark.h" + +#pragma clang diagnostic pop + +#define print(...) TraceLog(LOG_ERROR, __VA_ARGS__) + +const int sidebar_width = 210; + +typedef enum { + CONTROL_NONE, + CONTROL_POS_X, + CONTROL_POS_Y, + CONTROL_POS_Z, + CONTROL_SCALE_X, + CONTROL_SCALE_Y, + CONTROL_SCALE_Z, + CONTROL_ANGLE_X, + CONTROL_ANGLE_Y, + CONTROL_ANGLE_Z, + CONTROL_COLOR_R, + CONTROL_COLOR_G, + CONTROL_COLOR_B, + CONTROL_TRANSLATE, + CONTROL_ROTATE, + CONTROL_SCALE, + CONTROL_CORNER_RADIUS, + CONTROL_ROTATE_CAMERA, + CONTROL_BLOB_AMOUNT, +} Control; + +Control focusedControl; +Control mouseAction; + +Vector2 scroll_offset; + +union { + struct { + bool x : 1; + bool y : 1; + bool z : 1; + }; + int mask; +} controlled_axis = {.mask = 0x7}; +double last_axis_set = 0; + +typedef struct { + Vector3 pos; + Vector3 size; + Vector3 angle; + float corner_radius; + float blob_amount; + struct { + uint8_t r,g,b; + } color; + struct { + bool x,y,z; + } mirror; + bool subtract; +} Sphere; + +bool needs_rebuild = true; + +#if DEMO_VIDEO_FEATURES +bool false_color_mode = false; +#endif + +enum { + VISUALS_NONE, + VISUALS_SDF, +} visuals_mode; + +Shader main_shader; +struct { + int viewEye; + int viewCenter; + int runTime; + int resolution; + int selectedParams; + int visualizer; +} main_locations; + +int num_spheres = 1; +#define MAX_SPHERES 100 +Sphere spheres[MAX_SPHERES]; +int selected_sphere = 0; + +Camera camera = { 0 }; + +Color last_color_set = { + (uint8_t)(0.941*255), + (uint8_t)(0.631*255), + (uint8_t)(0.361*255), + 0 +}; + +double lastSave; + +void append(char **str1, const char *str2){ + assert(str1); + assert(str2); + size_t len = (*str1 ? strlen(*str1) : 0) + strlen(str2); + + char *concatenated = (char *)malloc(len + 1); + concatenated[0] = 0; + assert(concatenated); + + if (*str1) { + strcpy(concatenated, *str1); + free(*str1); + } + strcat(concatenated, str2); + + *str1 = concatenated; +} + +int RayPlaneIntersection(const Vector3 RayOrigin, const Vector3 RayDirection, const Vector3 PlanePoint, const Vector3 PlaneNormal, Vector3 *IntersectionPoint) { + float dotProduct = (PlaneNormal.x * RayDirection.x) + (PlaneNormal.y * RayDirection.y) + (PlaneNormal.z * RayDirection.z); + + // Check if the ray is parallel to the plane + if (dotProduct == 0.0f) { + return 0; + } + + float t = ((PlanePoint.x - RayOrigin.x) * PlaneNormal.x + (PlanePoint.y - RayOrigin.y) * PlaneNormal.y + (PlanePoint.z - RayOrigin.z) * PlaneNormal.z) / dotProduct; + + IntersectionPoint->x = RayOrigin.x + t * RayDirection.x; + IntersectionPoint->y = RayOrigin.y + t * RayDirection.y; + IntersectionPoint->z = RayOrigin.z + t * RayDirection.z; + + return 1; +} + +Vector3 WorldToCamera(Vector3 worldPos, Matrix cameraMatrix) { + return Vector3Transform(worldPos, cameraMatrix); +} + +Vector3 CameraToWorld(Vector3 worldPos, Matrix cameraMatrix) { + return Vector3Transform(worldPos, MatrixInvert(cameraMatrix)); +} + +Vector3 VectorProjection(const Vector3 vectorToProject, const Vector3 targetVector) { + float dotProduct = (vectorToProject.x * targetVector.x) + + (vectorToProject.y * targetVector.y) + + (vectorToProject.z * targetVector.z); + + float targetVectorLengthSquared = (targetVector.x * targetVector.x) + + (targetVector.y * targetVector.y) + + (targetVector.z * targetVector.z); + + float scale = dotProduct / targetVectorLengthSquared; + + Vector3 projection; + projection.x = targetVector.x * scale; + projection.y = targetVector.y * scale; + projection.z = targetVector.z * scale; + + return projection; +} + +// Find the point on line p1 to p2 nearest to line p2 to p4 +Vector3 NearestPointOnLine(Vector3 p1, + Vector3 p2, + Vector3 p3, + Vector3 p4) +{ + float mua; + + Vector3 p13,p43,p21; + float d1343,d4321,d1321,d4343,d2121; + float numer,denom; + + const float EPS = 0.001; + + p13.x = p1.x - p3.x; + p13.y = p1.y - p3.y; + p13.z = p1.z - p3.z; + p43.x = p4.x - p3.x; + p43.y = p4.y - p3.y; + p43.z = p4.z - p3.z; + if (fabs(p43.x) < EPS && fabs(p43.y) < EPS && fabs(p43.z) < EPS) + return(Vector3){}; + p21.x = p2.x - p1.x; + p21.y = p2.y - p1.y; + p21.z = p2.z - p1.z; + if (fabs(p21.x) < EPS && fabs(p21.y) < EPS && fabs(p21.z) < EPS) + return(Vector3){}; + + d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z; + d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z; + d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z; + d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z; + d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z; + + denom = d2121 * d4343 - d4321 * d4321; + if (fabs(denom) < EPS) + return (Vector3){}; + numer = d1343 * d4321 - d1321 * d4343; + + mua = numer / denom; + + return (Vector3){ + p1.x + mua * p21.x, + p1.y + mua * p21.y, + p1.z + mua * p21.z}; + +} + +BoundingBox boundingBoxSized(Vector3 center, float size) { + return (BoundingBox){ + Vector3SubtractValue(center, size/2), + Vector3AddValue(center, size/2), + }; +} + +BoundingBox shapeBoundingBox(Sphere s) { + // const float radius = sqrtf(powf(s.size.x, 2) + powf(s.size.y, 2) + powf(s.size.z, 2)); + return (BoundingBox){ + Vector3Subtract(s.pos, s.size), + Vector3Add(s.pos, s.size), + }; +} + +int GuiFloatValueBox(Rectangle bounds, const char *text, float *value, float minValue, float maxValue, bool editMode) +{ + #if !defined(RAYGUI_VALUEBOX_MAX_CHARS) + #define RAYGUI_VALUEBOX_MAX_CHARS 32 + #endif + + int result = 0; + GuiState state = guiState; + + static char editingTextValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + static float original_value; + static int key_delay = 0; + snprintf(textValue, RAYGUI_VALUEBOX_MAX_CHARS, "%g", *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); + } + + char *text_to_display = textValue; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiSliderDragging) + { + Vector2 mousePoint = GetMousePosition(); + + bool valueHasChanged = false; + + if (editMode) + { + state = STATE_PRESSED; + + int keyCount = (int)strlen(editingTextValue); + + // Only allow keys in range [48..57] + if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS) + { + int key = GetCharPressed(); + if (((key >= 48) && (key <= 57)) || key == 46) + { + editingTextValue[keyCount] = (char)key; + keyCount++; + valueHasChanged = true; + } + } + + // Delete text + if (keyCount > 0) + { + if (IsKeyPressed(KEY_BACKSPACE)) + { + keyCount--; + editingTextValue[keyCount] = '\0'; + valueHasChanged = true; + } + } + + if (!valueHasChanged && IsKeyDown(KEY_UP) && key_delay <= 0) { + *value+=fabs(*value*0.1) + 0.1; + if (*value > maxValue) *value = maxValue; + key_delay=9; + sprintf(editingTextValue, "%g", *value); + }else if (!valueHasChanged && IsKeyDown(KEY_DOWN) && key_delay <= 0) { + *value-=fabs(*value*0.1) + 0.1; + if (*value < minValue) *value = minValue; + key_delay=9; + sprintf(editingTextValue, "%g", *value); + } + + if (key_delay > 0) key_delay--; + if (!IsKeyDown(KEY_UP) && !IsKeyDown(KEY_DOWN))key_delay = 0; + text_to_display = editingTextValue; + if (IsKeyPressed(KEY_ESCAPE)) { + *value = original_value; + result = 1; + } else { + if (valueHasChanged) *value = (float)strtod(editingTextValue, NULL); + if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) 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)) { + original_value = *value; + memcpy(editingTextValue, textValue, RAYGUI_VALUEBOX_MAX_CHARS + 1); + 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)); + else if (state == STATE_FOCUSED) baseColor = WHITE; + + GuiDrawRectangle(bounds, 0, GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), baseColor); + GuiDrawText(text_to_display, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(VALUEBOX, TEXT))); + + // Draw cursor + if (editMode) + { + Rectangle cursor = { bounds.x + GetTextWidth(text_to_display) + 1, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) }; + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + } + + // 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))); + //-------------------------------------------------------------------- + + return result; +} + +void append_map_function(char **result, bool use_color_as_index, int dynamic_index) { + + char *map = NULL; + + append(&map, "uniform vec3 selectionValues[5];\n\n"); + + #if DEMO_VIDEO_FEATURES + if (false_color_mode) { + append(&map, "#define FALSE_COLOR_MODE 1\n\n"); + } + #endif + + append(&map, + "vec4 signed_distance_field( in vec3 pos ){\n" + "\tvec4 distance = vec4(999999.,0,0,0);\n"); + + for (int i=0; i < num_spheres; i++) { + Sphere s = spheres[i]; + float used_radius = fmaxf(0.01,fminf(s.corner_radius, fminf(s.size.x,fminf(s.size.y, s.size.z)))); + + char *symmetry[8] = { + "", + "opSymX", + "opSymY", + "opSymXY", + "opSymZ", + "opSymXZ", + "opSymYZ", + "opSymXYZ"}; + + int mirror_index = (s.mirror.z << 2) | (s.mirror.y << 1) | s.mirror.x; + if (i == dynamic_index) { + append(&map, TextFormat("\tdistance = %s(\n" + "\t\tvec4(RoundBox(\n" + "\t\t\t\topRotateXYZ(\n" + "\t\t\t\t\t%s(pos) - selectionValues[0], // position\n" + "\t\t\t\t\tselectionValues[1]), // angle\n" + "\t\t\t\tselectionValues[2], // size\n" + "\t\t\t\tselectionValues[4].x), // corner radius\n" + "\t\t\tselectionValues[3]), // color\n" + "\t\tdistance,\n\t\tselectionValues[4].y); // blobbyness\n", + s.subtract ? "opSmoothSubtraction" : "BlobbyMin", + symmetry[mirror_index])); + } else { + + uint8_t r = use_color_as_index ? (uint8_t)(i+1) : s.color.r; + uint8_t g = use_color_as_index ? 0 : s.color.g; + uint8_t b = use_color_as_index ? 0 : s.color.b; + +# if DEMO_VIDEO_FEATURES + if (false_color_mode) { + Color c = ColorFromHSV((i*97) % 360, 1, 0.5); + r = c.r; + g = c.g; + b = c.b; + } +# endif + + + char *opName = s.subtract ? "opSmoothSubtraction" : ((use_color_as_index + #if DEMO_VIDEO_FEATURES + || false_color_mode + #endif + ) ? "opSmoothUnionSteppedColor" : (s.blob_amount > 0 ? "BlobbyMin" : "Min")); + append(&map, TextFormat("\tdistance = %s(\n\t\tvec4(RoundBox(\n", opName)); + + const bool rotated = fabsf(s.angle.x) > .01 || fabsf(s.angle.y) > 0.01 || fabsf(s.angle.z) > .01; + if (rotated) { + float cz = cos(s.angle.z); + float sz = sin(s.angle.z); + float cy = cos(s.angle.y); + float sy = sin(s.angle.y); + float cx = cos(s.angle.x); + float sx = sin(s.angle.x); + + append(&map, TextFormat("\t\t\tmat3(%g, %g, %g," + "%g, %g, %g," + "%g, %g, %g)*\n", + cz*cy, + cz*sy*sx - cx*sz, + sz*sx + cz*cx*sy, + + cy*sz, + cz*cx + sz*sy*sx, + cx*sz*sy - cz*sx, + + -sy, + cy*sx, + cy*cx + )); + } + + append(&map, TextFormat("\t\t\t\t(%s(pos) - vec3(%g,%g,%g)), // position\n", + symmetry[mirror_index], + s.pos.x, s.pos.y, s.pos.z)); + + + + append(&map, TextFormat("\t\t\tvec3(%g,%g,%g),// size\n" + "\t\t\t%g), // corner radius\n" + "\t\t\t%g,%g,%g), // color\n" + "\t\tdistance", + s.size.x-used_radius, s.size.y-used_radius, s.size.z-used_radius, + used_radius, + r/255.f, g/255.f, b/255.f)); + + if (!strcmp(opName, "Min")) { + append(&map, TextFormat(");\n")); + } else { + append(&map, TextFormat(",\n\t\t%g); // blobbyness\n", fmaxf(s.blob_amount, 0.0001))); + } + + } + + + } + + append(&map, "\treturn distance;\n}\n"); + +# if DEMO_VIDEO_FEATURES + SaveFileText("map.glsl", map); +# endif + + append(result, map); + free(map); +} + +#ifdef PLATFORM_WEB +#define SHADER_VERSION_PREFIX "#version 300 es\nprecision highp float;" +#else +#define SHADER_VERSION_PREFIX "#version 330\n" +#endif + +const char *vshader = + SHADER_VERSION_PREFIX + "in vec3 vertexPosition; \n" + "in vec2 vertexTexCoord; \n" + "out vec2 fragTexCoord; \n" + "uniform mat4 mvp; \n" + "void main() \n" + "{ \n" + " fragTexCoord = vertexTexCoord; \n" + " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" + "} \n"; + +void rebuild_shaders(void ) { + needs_rebuild = false; + UnloadShader(main_shader); + + char *map_function = NULL; + append_map_function(&map_function, false, selected_sphere); + + char *result = NULL; + append(&result, + SHADER_VERSION_PREFIX + "out vec4 finalColor; \ + uniform vec3 viewEye; \ + uniform vec3 viewCenter; \ + uniform float runTime; \ + uniform float visualizer; \ + uniform vec2 resolution;"); + append(&result, shader_prefix_fs); + append(&result, map_function); + append(&result, shader_base_fs); + main_shader = LoadShaderFromMemory(vshader, (char *)result); + free(result); + result = NULL; + + main_locations.viewEye = GetShaderLocation(main_shader, "viewEye"); + main_locations.viewCenter = GetShaderLocation(main_shader, "viewCenter"); + main_locations.runTime = GetShaderLocation(main_shader, "runTime"); + main_locations.resolution = GetShaderLocation(main_shader, "resolution"); + main_locations.selectedParams = GetShaderLocation(main_shader, "selectionValues"); + main_locations.visualizer = GetShaderLocation(main_shader, "visualizer"); + + + free(map_function); +} + +void delete_sphere(int index) { + memmove(&spheres[index], &spheres[index+1], sizeof(Sphere)*(num_spheres-index)); + num_spheres--; + + if (selected_sphere == index) { + selected_sphere = num_spheres-1; + } else if (selected_sphere > index) { + selected_sphere--; + } + + needs_rebuild = true; +} + +void add_shape(void) { + if (num_spheres >= MAX_SPHERES) return; + + spheres[num_spheres] = (Sphere){ + .size = { 1, 1, 1 }, + .color = { + last_color_set.r, + last_color_set.g, + last_color_set.b, + }, + }; + selected_sphere = num_spheres; + num_spheres++; + needs_rebuild = true; +} + +#define MIN(x,y) ({ \ + __typeof(x) xv = (x);\ + __typeof(y) yv = (y); \ + xv < yv ? xv : yv;\ + }) + +__attribute__((format(printf, 4, 5))) +void append_format(char **data, int *size, int *capacity, const char *format, ...) { + + va_list arg_ptr; + va_start(arg_ptr, format); + int added = vsnprintf(*data+*size, *capacity-*size,format, arg_ptr); + + *size+=MIN(added, *capacity - *size); + assert(*size < *capacity); + + va_end(arg_ptr); +} + +Vector3 VertexInterp(Vector4 p1,Vector4 p2, float threshold) { + + if (fabsf(threshold-p1.w) < 0.00001) + return *(Vector3 *)&p1; + if (fabsf(threshold-p2.w) < 0.00001) + return *(Vector3 *)&p2; + if (fabsf(p1.w-p2.w) < 0.00001) + return *(Vector3 *)&p1; + + float mu = (threshold - p1.w) / (p2.w - p1.w); + Vector3 r = { + p1.x + mu * (p2.x - p1.x), + p1.y + mu * (p2.y - p1.y), + p1.z + mu * (p2.z - p1.z), + }; + + return r; +} + +uint64_t FNV1a_64_hash(uint8_t *data, int len) { + uint64_t hash = 0xcbf29ce484222325; + for (int i=0; i < len; i++) { + hash = (hash ^ data[i]) * 0x00000100000001B3; + } + + return hash; +} + +void save(char *name) { + const int size = sizeof(int) + sizeof(Sphere)*num_spheres; + char *data = malloc(size); + *(int *)(void *)data = num_spheres; + memcpy(data + sizeof(int), spheres, num_spheres*sizeof(Sphere)); + + SaveFileData(TextFormat("build/%s_%"PRIu64".shapeup", name, FNV1a_64_hash(data, size)), data, size); + + free(data); + lastSave = GetTime(); +} + +void openSnapshot(char *path) { + print("opening ========= %s", path); + + unsigned int size; + unsigned char *data = LoadFileData(path, &size); + + assert(data); + + num_spheres = *(int *)(void *)data; + memcpy(spheres, data + sizeof(int), sizeof(Sphere)*num_spheres); + + UnloadFileData(data); + + selected_sphere = -1; + needs_rebuild = true; + lastSave = GetTime(); +} + +RenderTexture2D LoadFloatRenderTexture(int width, int height) +{ + RenderTexture2D target = { 0 }; + + target.id = rlLoadFramebuffer(width, height); // Load an empty framebuffer + + if (target.id > 0) + { + rlEnableFramebuffer(target.id); + + target.texture.format = PIXELFORMAT_UNCOMPRESSED_R32; + target.texture.id = rlLoadTexture(NULL, width, height, target.texture.format, 1); + target.texture.width = width; + target.texture.height = height; + target.texture.mipmaps = 1; + + // Attach color texture and depth renderbuffer/texture to FBO + rlFramebufferAttach(target.id, target.texture.id, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_TEXTURE2D, 0); + + if (rlFramebufferComplete(target.id)) { + print("FBO: [ID %i] Framebuffer object created successfully", target.id); + } + else { + print("FBO: [ID %i] Framebuffer object FAILED", target.id); + } + + rlDisableFramebuffer(); + } + else TRACELOG(LOG_WARNING, "FBO: Framebuffer object can not be created"); + + return target; +} + +// from https://paulbourke.net/geometry/polygonise/ +const int edgeTable[256]={ + 0x0 , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, + 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00, + 0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, + 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90, + 0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c, + 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30, + 0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac, + 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0, + 0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c, + 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60, + 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc, + 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0, + 0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c, + 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950, + 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc , + 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0, + 0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, + 0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0, + 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, + 0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650, + 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, + 0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0, + 0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, + 0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460, + 0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, + 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0, + 0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, + 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230, + 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, + 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190, + 0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, + 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0 }; + const int triTable[256][16] = + {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1}, + {3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1}, + {3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1}, + {3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1}, + {9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1}, + {9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1}, + {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1}, + {8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1}, + {9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1}, + {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1}, + {3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1}, + {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1}, + {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1}, + {4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1}, + {9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1}, + {5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1}, + {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1}, + {9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1}, + {0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1}, + {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1}, + {10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1}, + {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1}, + {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1}, + {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1}, + {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1}, + {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1}, + {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1}, + {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1}, + {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1}, + {2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1}, + {7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1}, + {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1}, + {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1}, + {11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1}, + {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1}, + {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1}, + {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1}, + {11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1}, + {1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1}, + {9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1}, + {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1}, + {2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1}, + {0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1}, + {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1}, + {6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1}, + {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1}, + {6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1}, + {5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1}, + {1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1}, + {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1}, + {6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1}, + {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1}, + {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1}, + {3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1}, + {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1}, + {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1}, + {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1}, + {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1}, + {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1}, + {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1}, + {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1}, + {10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1}, + {10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1}, + {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1}, + {1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1}, + {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1}, + {0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1}, + {10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1}, + {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1}, + {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1}, + {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1}, + {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1}, + {3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1}, + {6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1}, + {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1}, + {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1}, + {10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1}, + {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1}, + {7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1}, + {7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1}, + {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1}, + {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1}, + {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1}, + {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1}, + {0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1}, + {7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1}, + {10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1}, + {2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1}, + {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1}, + {7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1}, + {2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1}, + {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1}, + {10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1}, + {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1}, + {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1}, + {7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1}, + {6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1}, + {8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1}, + {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1}, + {6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1}, + {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1}, + {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1}, + {8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1}, + {0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1}, + {1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1}, + {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1}, + {10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1}, + {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1}, + {10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1}, + {5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1}, + {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1}, + {9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1}, + {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1}, + {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1}, + {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1}, + {7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1}, + {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1}, + {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1}, + {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1}, + {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1}, + {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1}, + {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1}, + {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1}, + {6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1}, + {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1}, + {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1}, + {6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1}, + {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1}, + {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1}, + {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1}, + {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1}, + {9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1}, + {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1}, + {1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1}, + {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1}, + {0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1}, + {5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1}, + {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1}, + {11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1}, + {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1}, + {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1}, + {2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1}, + {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1}, + {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1}, + {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1}, + {1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1}, + {9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1}, + {9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1}, + {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1}, + {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1}, + {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1}, + {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1}, + {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1}, + {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1}, + {9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1}, + {5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1}, + {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1}, + {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1}, + {8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1}, + {0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1}, + {9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1}, + {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1}, + {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1}, + {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1}, + {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1}, + {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1}, + {11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1}, + {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1}, + {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1}, + {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1}, + {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1}, + {1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1}, + {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1}, + {4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1}, + {0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1}, + {3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1}, + {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1}, + {0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1}, + {9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1}, + {1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, + {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}; + + + +void export(void) { + + char *shader_source = NULL; + append(&shader_source, SHADER_VERSION_PREFIX); + append(&shader_source, shader_prefix_fs); + append_map_function(&shader_source, false, -1); + append(&shader_source, slicer_body_fs); + + Shader slicer_shader = LoadShaderFromMemory(vshader, (char *)shader_source); + free(shader_source); + shader_source = NULL; + + int slicer_z_loc = GetShaderLocation(slicer_shader, "z"); + + double startTime = GetTime(); + const float cube_resolution = 0.03; + + BoundingBox bounds = { + {FLT_MAX,FLT_MAX,FLT_MAX}, + {-FLT_MAX,-FLT_MAX,-FLT_MAX} + }; + + for(int i=0; i < num_spheres; i++) { + const float radius = sqrtf(powf(spheres[i].size.x, 2) + powf(spheres[i].size.y, 2) + powf(spheres[i].size.z, 2)); + bounds.min.x = fminf(bounds.min.x, spheres[i].pos.x - radius); + bounds.min.y = fminf(bounds.min.y, spheres[i].pos.y - radius); + bounds.min.z = fminf(bounds.min.z, spheres[i].pos.z - radius); + + bounds.max.x = fmaxf(bounds.max.x, spheres[i].pos.x + radius); + bounds.max.y = fmaxf(bounds.max.y, spheres[i].pos.y + radius); + bounds.max.z = fmaxf(bounds.max.z, spheres[i].pos.z + radius); + } + + // the marching cube sampling lattace must extend beyond the objects you want it to represent + bounds.min.x -= 1; + bounds.min.y -= 1; + bounds.min.z -= 1; + + bounds.max.x += 1; + bounds.max.y += 1; + bounds.max.z += 1; + + const int slice_count_x = (int)((bounds.max.x - bounds.min.x) / cube_resolution + 1.5); + const int slice_count_y = (int)((bounds.max.y - bounds.min.y) / cube_resolution + 1.5); + const int slice_count_z = (int)((bounds.max.z - bounds.min.z) / cube_resolution + 1.5); + + const float x_step = (bounds.max.x - bounds.min.x) / (slice_count_x-1); + const float y_step = (bounds.max.y - bounds.min.y) / (slice_count_y-1); + const float z_step = (bounds.max.z - bounds.min.z) / (slice_count_z-1); + + int data_capacity = 400000000; + char *data = malloc(data_capacity); + int data_size = 0; + + RenderTexture2D sliceTexture[2]; + sliceTexture[0] = LoadFloatRenderTexture(slice_count_x, slice_count_y); + sliceTexture[1] = LoadFloatRenderTexture(slice_count_x, slice_count_y); + + for (int z_index = 0; z_index < slice_count_z-1; z_index++) { + for (int side =0; side < 2; side++) { + float z = bounds.min.z + (z_index+side)*z_step; + SetShaderValue(slicer_shader, slicer_z_loc, &z, SHADER_UNIFORM_FLOAT); + BeginTextureMode(sliceTexture[side]); { + BeginShaderMode(slicer_shader); { + rlBegin(RL_QUADS); + rlTexCoord2f(bounds.max.x, bounds.min.y); + rlVertex2f(0, 0); + + rlTexCoord2f(bounds.max.x, bounds.max.y); + rlVertex2f(0, slice_count_y); + + rlTexCoord2f(bounds.min.x, bounds.max.y); + rlVertex2f(slice_count_x, slice_count_y); + + rlTexCoord2f(bounds.min.x, bounds.min.y); + rlVertex2f(slice_count_x, 0); + rlEnd(); + } EndShaderMode(); + } EndTextureMode(); + } + + float *pixels = rlReadTexturePixels(sliceTexture[0].texture.id, sliceTexture[0].texture.width, sliceTexture[0].texture.height, sliceTexture[0].texture.format); + float *pixels2 = rlReadTexturePixels(sliceTexture[1].texture.id, sliceTexture[1].texture.width, sliceTexture[1].texture.height, sliceTexture[1].texture.format); + + #define SDF_THRESHOLD (0) + for (int y_index=0; y_index < slice_count_y-1; y_index++) { + for (int x_index=0; x_index < slice_count_x-1; x_index++) { + + float val0 = pixels [(x_index + y_index *slice_count_x)*1] ; + float val1 = pixels [(x_index+1+ y_index *slice_count_x)*1] ; + float val2 = pixels [(x_index+1 +(y_index+1)*slice_count_x)*1]; + float val3 = pixels [(x_index +(y_index+1)*slice_count_x)*1]; + float val4 = pixels2[(x_index + y_index *slice_count_x)*1] ; + float val5 = pixels2[(x_index+1+ y_index *slice_count_x)*1] ; + float val6 = pixels2[(x_index+1+(y_index+1)*slice_count_x)*1] ; + float val7 = pixels2[(x_index +(y_index+1)*slice_count_x)*1] ; + + Vector4 v0 = { + bounds.min.x + x_index*x_step, + bounds.min.y + y_index*y_step, + bounds.min.z + z_index*z_step, + val0 + }; + Vector4 v1 = {v0.x+x_step, v0.y, v0.z, val1}; + Vector4 v2 = {v0.x+x_step, v0.y+y_step, v0.z, val2}; + Vector4 v3 = {v0.x, v0.y+y_step, v0.z, val3}; + + Vector4 v4 = {v0.x, v0.y, v0.z+z_step, val4}; + Vector4 v5 = {v0.x+x_step, v0.y, v0.z+z_step, val5}; + Vector4 v6 = {v0.x+x_step, v0.y+y_step, v0.z+z_step, val6}; + Vector4 v7 = {v0.x, v0.y+y_step, v0.z+z_step, val7}; + + int cubeindex = (val0 < SDF_THRESHOLD) << 0 | + (val1 < SDF_THRESHOLD) << 1 | + (val2 < SDF_THRESHOLD) << 2 | + (val3 < SDF_THRESHOLD) << 3 | + (val4 < SDF_THRESHOLD) << 4 | + (val5 < SDF_THRESHOLD) << 5 | + (val6 < SDF_THRESHOLD) << 6 | + (val7 < SDF_THRESHOLD) << 7; + + /* Cube is entirely in/out of the surface */ + if (edgeTable[cubeindex] == 0) continue; + + Vector3 vertlist[12]; + if (edgeTable[cubeindex] & 1) vertlist[0] = VertexInterp(v0,v1, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 2) vertlist[1] = VertexInterp(v1,v2, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 4) vertlist[2] = VertexInterp(v2,v3, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 8) vertlist[3] = VertexInterp(v3,v0, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 16) vertlist[4] = VertexInterp(v4,v5, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 32) vertlist[5] = VertexInterp(v5,v6, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 64) vertlist[6] = VertexInterp(v6,v7, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 128) vertlist[7] = VertexInterp(v7,v4, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 256) vertlist[8] = VertexInterp(v0,v4, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 512) vertlist[9] = VertexInterp(v1,v5, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 1024) vertlist[10] = VertexInterp(v2,v6, SDF_THRESHOLD); + if (edgeTable[cubeindex] & 2048) vertlist[11] = VertexInterp(v3,v7, SDF_THRESHOLD); + + for (int i=0;triTable[cubeindex][i]!=-1;i+=3) { + for (int v=0; v < 3; v++) { + Vector3 pt = vertlist[triTable[cubeindex][i + v]]; + append_format(&data, &data_size, &data_capacity,"v %g %g %g\n", pt.x, -pt.y, pt.z); + } + + append_format(&data, &data_size, &data_capacity,"f -2 -1 -3\n"); + } + + } + } + + free(pixels); + free(pixels2); + } + + UnloadRenderTexture(sliceTexture[0]); + UnloadRenderTexture(sliceTexture[1]); + + + SaveFileData("build/export.obj", data, data_size); + + free(data); + + UnloadShader(slicer_shader); + + double duration = GetTime() - startTime; + print("export time %gms. size: %.2fMB", duration*1000, data_size/1000000.f); +} + +int object_at_pixel(int x, int y) { + const float start = GetTime(); + char *shader_source = NULL; + append(&shader_source, SHADER_VERSION_PREFIX); + append(&shader_source, shader_prefix_fs); + append_map_function(&shader_source, true, -1); + append(&shader_source, selection_fs); + + Shader shader = LoadShaderFromMemory(vshader, (char *)shader_source); + free(shader_source); + shader_source = NULL; + + int eye_loc = GetShaderLocation(shader, "viewEye"); + int center_loc = GetShaderLocation(shader, "viewCenter"); + int resolution_loc = GetShaderLocation(shader, "resolution"); + + SetShaderValue(shader, eye_loc, &camera.position, SHADER_UNIFORM_VEC3); + SetShaderValue(shader, center_loc, &camera.target, SHADER_UNIFORM_VEC3); + SetShaderValue(shader, resolution_loc, (float[2]){ (float)GetScreenWidth(), (float)GetScreenHeight() }, SHADER_UNIFORM_VEC2); + + RenderTexture2D target = LoadRenderTexture(GetScreenWidth(), GetScreenHeight()); + + BeginTextureMode(target); { + BeginShaderMode(shader); { + rlBegin(RL_QUADS); + rlTexCoord2f(x-1, y-1); + rlVertex2f(x-1, y-1); + + rlTexCoord2f(x-1, y+1); + rlVertex2f(x-1, y+1); + + rlTexCoord2f(x+1, y+1); + rlVertex2f(x+1, y+1); + + rlTexCoord2f(x+1, y-1); + rlVertex2f(x+1, y-1); + rlEnd(); + } EndShaderMode(); + } EndTextureMode(); + + uint8_t *pixels = rlReadTexturePixels(target.texture.id, target.texture.width, target.texture.height, target.texture.format); + + int object_index = ((int)pixels[(x + target.texture.width*(target.texture.height-y))*4]) - 1; + + free(pixels); + + UnloadRenderTexture(target); + UnloadShader(shader); + + print("picking object took %ims", (int)((-start + GetTime())*1000)); + + return object_index; +} + +int main(void){ + // SetTraceLogLevel(LOG_ERROR); + lastSave = GetTime(); + SetConfigFlags(FLAG_WINDOW_RESIZABLE); + InitWindow(1940/2, 1100/2, "ShapeUp!"); + SetExitKey(0); + + GuiLoadStyleDark(); + // Font gfont = GuiGetFont(); + // GenTextureMipmaps(&guiFont.texture); + // SetTextureFilter(guiFont.texture, TEXTURE_FILTER_POINT); + // GuiSetFont(gfont); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); + + camera.position = (Vector3){ 2.5f, 2.5f, 3.0f }; + camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; + camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; + camera.fovy = 55.0f; + camera.projection = CAMERA_PERSPECTIVE; + + spheres[0] = (Sphere){ + .size = {1,1,1}, + .color={ + last_color_set.r, + last_color_set.g, + last_color_set.b + }}; + + float runTime = 0.0f; + + SetTargetFPS(60); + +# ifndef PLATFORM_WEB + void swizzleWindow(void); + swizzleWindow(); + void makeWindowKey(void); + makeWindowKey(); +# endif + + const int gamepad = 0; + + bool ui_mode_gamepad = false; + + while (!WindowShouldClose()) { + + if (fabsf(GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_X)) > 0 || + fabsf(GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_Y)) > 0 || + fabsf(GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_X)) > 0 || + fabsf(GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y)) > 0) { + ui_mode_gamepad = true; + } + + if (Vector2Length(GetMouseDelta()) > 0) { + ui_mode_gamepad = false; + } + + #if DEMO_VIDEO_FEATURES + if (IsKeyPressed(KEY_F)) { + false_color_mode = !false_color_mode; + needs_rebuild = true; + } + #endif + + #ifdef PLATFORM_WEB + int w,h,dpi; + + EM_ASM({ + var pixelsPerPoint = 1; //window.devicePixelRatio; + var canvas = document.getElementById('canvas'); + var width = Math.floor(pixelsPerPoint*canvas.clientWidth); + var height = Math.floor(pixelsPerPoint*canvas.clientHeight); + canvas.width = width; + canvas.height = height; + setValue($0, width, "i32"); + setValue($1, height, "i32"); + setValue($2, pixelsPerPoint, "i32"); + }, &w, &h, &dpi); + + if (GetScreenWidth() != w || GetScreenHeight() != h) { + SetWindowSize(w, h); + } + #endif + + if (GetTime() - lastSave > 60) { + save("snapshot"); + } + + if (IsFileDropped()) { + FilePathList droppedFiles = LoadDroppedFiles(); + if (droppedFiles.count > 0) { + + openSnapshot(droppedFiles.paths[0]); + } + UnloadDroppedFiles(droppedFiles); + } + + + Ray ray = GetMouseRay(GetMousePosition(), camera); + + static Sphere before_edit; + if (focusedControl == CONTROL_NONE) { + if (mouseAction == CONTROL_NONE && selected_sphere >= 0 && (IsKeyPressed(KEY_DELETE) || IsKeyPressed(KEY_BACKSPACE)|| IsKeyPressed(KEY_X))) { + delete_sphere(selected_sphere); + } + + if (selected_sphere >= 0 && IsKeyPressed(KEY_D) && (IsKeyDown(KEY_RIGHT_SUPER) || IsKeyDown(KEY_LEFT_SUPER)) && num_spheres < MAX_SPHERES) { + spheres[num_spheres] = spheres[selected_sphere]; + selected_sphere = num_spheres; + num_spheres++; + needs_rebuild = true; + } + + if (IsKeyPressed(KEY_A)) { + add_shape(); + } + + + if (selected_sphere >= 0 && IsKeyPressed(KEY_G)) { + mouseAction = CONTROL_TRANSLATE; + last_axis_set = 0; + controlled_axis.mask = 0x7; + before_edit = spheres[selected_sphere]; + } + if (selected_sphere >= 0 && IsKeyPressed(KEY_R)) { + mouseAction = CONTROL_ROTATE; + last_axis_set = 0; + controlled_axis.mask = 0x7; + before_edit = spheres[selected_sphere]; + } + if (selected_sphere >= 0 && IsKeyPressed(KEY_S)) { + mouseAction = CONTROL_SCALE; + last_axis_set = 0; + controlled_axis.mask = 0x7; + before_edit = spheres[selected_sphere]; + } + } + + if (selected_sphere >= 0 && (mouseAction == CONTROL_TRANSLATE || mouseAction == CONTROL_ROTATE || mouseAction == CONTROL_SCALE)) { + bool should_set = GetTime() - last_axis_set > 1; + if (IsKeyPressed(KEY_X)) { + controlled_axis.mask = (should_set || !(controlled_axis.mask ^ 1)) ? 1 : (controlled_axis.mask ^ 1); + last_axis_set = GetTime(); + spheres[selected_sphere] = before_edit; + } + if (IsKeyPressed(KEY_Y)) { + controlled_axis.mask = (should_set || !(controlled_axis.mask ^ 2)) ? 2 : (controlled_axis.mask ^ 2); + last_axis_set = GetTime(); + spheres[selected_sphere] = before_edit; + } + if (IsKeyPressed(KEY_Z)) { + controlled_axis.mask = (should_set || !(controlled_axis.mask ^ 4)) ? 4 : (controlled_axis.mask ^ 4); + last_axis_set = GetTime(); + spheres[selected_sphere] = before_edit; + } + + if (mouseAction == CONTROL_TRANSLATE) { + + if (controlled_axis.x + controlled_axis.y + controlled_axis.z == 1) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, + (Vector3){controlled_axis.x , + controlled_axis.y , + controlled_axis.z }), + ray.position, + Vector3Add(ray.position, ray.direction)); + + spheres[selected_sphere].pos = nearest; + } else { + Vector3 plane_normal; + Vector3 intersection; + if(controlled_axis.x + controlled_axis.y + controlled_axis.z == 2) { + plane_normal = (Vector3){!controlled_axis.x, !controlled_axis.y, !controlled_axis.z}; + } else { + plane_normal = Vector3Subtract(camera.position, camera.target); + } + + if(RayPlaneIntersection(ray.position, ray.direction, spheres[selected_sphere].pos, plane_normal, &intersection)) { + spheres[selected_sphere].pos = intersection; + } + } + + } else if (mouseAction == CONTROL_ROTATE) { + if (controlled_axis.x) spheres[selected_sphere].angle.x += GetMouseDelta().x/10.f; + if (controlled_axis.y) spheres[selected_sphere].angle.y += GetMouseDelta().x/10.f; + if (controlled_axis.z) spheres[selected_sphere].angle.z += GetMouseDelta().x/10.f; + } else if (mouseAction == CONTROL_SCALE) { + if (controlled_axis.x) spheres[selected_sphere].size.x *= powf(2, GetMouseDelta().x/10.f); + if (controlled_axis.y) spheres[selected_sphere].size.y *= powf(2, GetMouseDelta().x/10.f); + if (controlled_axis.z) spheres[selected_sphere].size.z *= powf(2, GetMouseDelta().x/10.f); + } + + if (IsKeyPressed(KEY_ESCAPE)) { + mouseAction = CONTROL_NONE; + spheres[selected_sphere] = before_edit; + } + if (IsKeyPressed(KEY_ENTER)) mouseAction = CONTROL_NONE; + } + + static float drag_offset; + + if (GetMousePosition().x > sidebar_width) { + if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && mouseAction == CONTROL_NONE && selected_sphere >= 0) { + if (GetRayCollisionSphere(ray, Vector3Add(spheres[selected_sphere].pos, (Vector3){0.6,0,0}), .1).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){1,0,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = spheres[selected_sphere].pos.x - nearest.x; + mouseAction = CONTROL_POS_X; + } else if (GetRayCollisionSphere(ray, Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0.6,0}), .1).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,1,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = spheres[selected_sphere].pos.y - nearest.y; + mouseAction = CONTROL_POS_Y; + } else if (GetRayCollisionSphere(ray, Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0,0.6}), .1).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0,1}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = spheres[selected_sphere].pos.z - nearest.z; + mouseAction = CONTROL_POS_Z; + } + else if (GetRayCollisionBox(ray, boundingBoxSized(Vector3Add(spheres[selected_sphere].pos, + (Vector3){spheres[selected_sphere].size.x,0,0}), 0.2)).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){1,0,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = nearest.x - spheres[selected_sphere].size.x; + mouseAction = CONTROL_SCALE_X; + } else if (GetRayCollisionBox(ray, boundingBoxSized(Vector3Add(spheres[selected_sphere].pos, + (Vector3){0,spheres[selected_sphere].size.y,0}), 0.2)).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,1,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = nearest.y - spheres[selected_sphere].size.y; + mouseAction = CONTROL_SCALE_Y; + } else if (GetRayCollisionBox(ray, boundingBoxSized(Vector3Add(spheres[selected_sphere].pos, + (Vector3){0,0,spheres[selected_sphere].size.z}), 0.2)).hit) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0,1}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + drag_offset = nearest.z - spheres[selected_sphere].size.z; + mouseAction = CONTROL_SCALE_Z; + } + } + + if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT) && mouseAction == CONTROL_NONE) { + int new_selection = object_at_pixel((int)GetMousePosition().x, (int)GetMousePosition().y); + if (new_selection != selected_sphere) { + selected_sphere = new_selection; + needs_rebuild = true; + } + } + + static Vector2 mouseDownPosition; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) mouseDownPosition = GetMousePosition(); + + if (fabsf(GetMouseWheelMove()) > 0.01 && mouseAction == CONTROL_NONE ) { + Vector2 delta = GetMouseWheelMoveV(); + + if (IsKeyDown(KEY_LEFT_ALT)) { + CameraMoveForward(&camera, delta.y, false); + } else { + Vector3 shift = Vector3Scale(camera.up, delta.y/10); + camera.position = Vector3Add(camera.position, shift); + camera.target = Vector3Add(camera.target,shift ); + #ifdef PLATFORM_WEB + delta.x = -delta.x; + #endif + UpdateCameraPro(&camera, (Vector3){0, -delta.x/10, 0}, Vector3Zero(), 0); + } + } else if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && !guiSliderDragging && mouseAction == CONTROL_NONE && Vector2Distance(mouseDownPosition, GetMousePosition()) > 1) { + mouseAction = CONTROL_ROTATE_CAMERA; + } + + if (mouseAction == CONTROL_ROTATE_CAMERA) { + if (!IsMouseButtonDown(MOUSE_LEFT_BUTTON)) mouseAction = CONTROL_NONE; + + Vector2 delta = GetMouseDelta(); + if (IsKeyDown(KEY_LEFT_ALT)) { + UpdateCameraPro(&camera, (Vector3){0, -delta.x/80, delta.y/80}, Vector3Zero(), 0); + } else { + extern void CameraYaw(Camera *camera, float angle, bool rotateAroundTarget); + extern void CameraPitch(Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp); + CameraYaw(&camera, -delta.x*0.003f, true); + CameraPitch(&camera, -delta.y*0.003f, true, true, false); + } + } + + #ifndef PLATFORM_WEB + extern float magnification; + if (mouseAction == CONTROL_NONE ) { + CameraMoveForward(&camera, 8*magnification, false); + } + magnification = 0; + #endif + } + + + const float movement_scale = 0.1; + const float rotation_scale = 0.04; + const float rotation_radius = 4; + + + if (!IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_THUMB)) { + Vector3 offset = Vector3Scale(GetCameraForward(&camera), -rotation_radius); + offset = Vector3RotateByAxisAngle(offset, (Vector3){0,1,0}, -rotation_scale*GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_X)); + offset = Vector3RotateByAxisAngle(offset, GetCameraRight(&camera), -rotation_scale*GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_Y)); + camera.position = Vector3Add(offset, camera.target); + } + + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_TRIGGER_1)) { + Vector3 up = Vector3Normalize(Vector3CrossProduct(GetCameraForward(&camera), GetCameraRight(&camera))); + up = Vector3Scale(up, movement_scale*GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y)); + camera.position = Vector3Add(camera.position, up); + camera.target = Vector3Add(camera.target, up); + } else { + CameraMoveForward(&camera, -GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y)*movement_scale, false); + } + + CameraMoveRight(&camera, GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_X)*movement_scale, false); + + Matrix camera_matrix = GetCameraMatrix(camera); + static Vector3 camera_space_offset; + if (IsGamepadButtonPressed(gamepad, GAMEPAD_BUTTON_RIGHT_TRIGGER_1)) { + selected_sphere = object_at_pixel(sidebar_width + (GetScreenWidth()-sidebar_width)/2, GetScreenHeight()/2); + needs_rebuild = true; + if (selected_sphere>= 0){ + camera_space_offset = WorldToCamera(spheres[selected_sphere].pos, camera_matrix); + } + } + + if (selected_sphere >= 0) { + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_TRIGGER_1)) { + spheres[selected_sphere].pos = CameraToWorld(camera_space_offset, camera_matrix); + // spheres[selected_sphere].pos = Vector3Add(camera.position, Vector3Scale(GetCameraForward(&camera),distance)); + } + + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_UP)) { + spheres[selected_sphere].size = Vector3Scale(spheres[selected_sphere].size, 1.05); + spheres[selected_sphere].corner_radius *= 1.05; + } + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_DOWN)) { + spheres[selected_sphere].size = Vector3Scale(spheres[selected_sphere].size, 0.95); + spheres[selected_sphere].corner_radius *= 0.95; + } + + + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_TRIGGER_1)) { + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) { + spheres[selected_sphere].blob_amount *= 0.95; + } + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) { + spheres[selected_sphere].blob_amount = (0.01 + spheres[selected_sphere].blob_amount*1.05); + } + } else { + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) { + spheres[selected_sphere].corner_radius *= 0.95; + } + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) { + Vector3 size = spheres[selected_sphere].size; + spheres[selected_sphere].corner_radius = fminf(0.01 + spheres[selected_sphere].corner_radius*1.05, fminf(size.x, fminf(size.y,size.z))); + } + } + + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_THUMB)) { + spheres[selected_sphere].angle = Vector3Add(spheres[selected_sphere].angle, (Vector3){ + rotation_scale*GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_Y), + rotation_scale*GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_X), + 0, + }); + } + } + + if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_FACE_DOWN)) { + if (IsGamepadButtonPressed(gamepad, GAMEPAD_BUTTON_RIGHT_FACE_DOWN)) { + add_shape(); + } + + if (selected_sphere>=0) spheres[selected_sphere].pos = Vector3Add(camera.position, Vector3Scale(GetCameraForward(&camera),8)); + } + + if (mouseAction == CONTROL_POS_X) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){1,0,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + spheres[selected_sphere].pos.x = nearest.x + drag_offset; + } else if (mouseAction == CONTROL_POS_Y) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,1,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + spheres[selected_sphere].pos.y = nearest.y + drag_offset; + } else if (mouseAction == CONTROL_POS_Z) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0,1}), + ray.position, + Vector3Add(ray.position, ray.direction)); + spheres[selected_sphere].pos.z = nearest.z + drag_offset; + } else if (mouseAction == CONTROL_SCALE_X) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){1,0,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + spheres[selected_sphere].size.x = fmaxf(0,nearest.x-drag_offset); + } else if (mouseAction == CONTROL_SCALE_Y) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,1,0}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + spheres[selected_sphere].size.y = fmaxf(0,nearest.y-drag_offset); + } else if (mouseAction == CONTROL_SCALE_Z) { + Vector3 nearest = NearestPointOnLine(spheres[selected_sphere].pos, + Vector3Add(spheres[selected_sphere].pos, (Vector3){0,0,1}), + ray.position, + Vector3Add(ray.position, ray.direction)); + + spheres[selected_sphere].size.z = fmaxf(0,nearest.z-drag_offset); + } + + if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) { + mouseAction = CONTROL_NONE; + } + + // + // Mark: Drawing! + // + + float deltaTime = GetFrameTime(); + runTime += deltaTime; + + if ( needs_rebuild ) { + rebuild_shaders(); + } + SetShaderValue(main_shader, main_locations.viewEye, &camera.position, SHADER_UNIFORM_VEC3); + SetShaderValue(main_shader, main_locations.viewCenter, &camera.target, SHADER_UNIFORM_VEC3); + SetShaderValue(main_shader, main_locations.resolution, (float[2]){ (float)GetScreenWidth()*GetWindowScaleDPI().x, (float)GetScreenHeight()*GetWindowScaleDPI().y }, SHADER_UNIFORM_VEC2); + SetShaderValue(main_shader, main_locations.runTime, &runTime, SHADER_UNIFORM_FLOAT); + float mode = visuals_mode; + SetShaderValue(main_shader, main_locations.visualizer, &mode, SHADER_UNIFORM_FLOAT); + if (selected_sphere >= 0) { + Sphere *s = &spheres[selected_sphere]; + float used_radius = fmaxf(0.01,fminf(s->corner_radius, fminf(s->size.x,fminf(s->size.y, s->size.z)))); + float data[15] = { + s->pos.x, + s->pos.y, + s->pos.z, + + s->angle.x, + s->angle.y, + s->angle.z, + + s->size.x - used_radius, + s->size.y - used_radius, + s->size.z - used_radius, + + s->color.r / 255.f, + s->color.g / 255.f, + s->color.b / 255.f, + + used_radius, + fmaxf(s->blob_amount, 0.0001), + 0, + }; + + SetShaderValueV(main_shader, main_locations.selectedParams, data, SHADER_UNIFORM_VEC3, 5); + + } + + BeginDrawing(); { + + ClearBackground(RAYWHITE); + BeginShaderMode(main_shader); { + DrawRectangle(sidebar_width, 0, GetScreenWidth()-sidebar_width, GetScreenHeight(), WHITE); + } EndShaderMode(); + + BeginMode3D(camera); { + if (selected_sphere >= 0 && selected_sphere < MAX_SPHERES) { + Sphere s = spheres[selected_sphere]; + + if (mouseAction == CONTROL_TRANSLATE || mouseAction == CONTROL_ROTATE || mouseAction == CONTROL_SCALE) { + if (controlled_axis.x) DrawRay((Ray){Vector3Add(s.pos, (Vector3){.x=-1000}), (Vector3){.x=1}} , RED); + if (controlled_axis.y) DrawRay((Ray){Vector3Add(s.pos, (Vector3){.y=-1000}), (Vector3){.y=1}} , GREEN); + if (controlled_axis.z) DrawRay((Ray){Vector3Add(s.pos, (Vector3){.z=-1000}), (Vector3){.z=1}} , BLUE); + } else { + + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_X) + DrawLine3D(s.pos, Vector3Add(s.pos, (Vector3){0.5,0,0}), RED); + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_SCALE_X) + DrawCube(Vector3Add(s.pos, (Vector3){s.size.x,0,0}), .1,.1,.1, RED); + if ((mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_X) && !ui_mode_gamepad) + DrawCylinderEx(Vector3Add(s.pos, (Vector3){0.5,0,0}), + Vector3Add(s.pos, (Vector3){.7,0,0}), .1, 0, 12, RED); + + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_Y) + DrawLine3D(s.pos, Vector3Add(s.pos, (Vector3){0,0.5,0}), GREEN); + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_SCALE_Y) + DrawCube(Vector3Add(s.pos, (Vector3){0,s.size.y,0}), .1,.1,.1, GREEN); + if ((mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_Y) && !ui_mode_gamepad) + DrawCylinderEx(Vector3Add(s.pos, (Vector3){0,0.5,0}), + Vector3Add(s.pos, (Vector3){0,.7,0}), .1, 0, 12, GREEN); + + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_Z) + DrawLine3D(s.pos, Vector3Add(s.pos, (Vector3){0,0,0.5}), BLUE); + if (mouseAction == CONTROL_NONE || mouseAction == CONTROL_SCALE_Z) + DrawCube(Vector3Add(s.pos, (Vector3){0,0,s.size.z}), .1,.1,.1, BLUE); + if ((mouseAction == CONTROL_NONE || mouseAction == CONTROL_POS_Z) && !ui_mode_gamepad) + DrawCylinderEx(Vector3Add(s.pos, (Vector3){0,0,0.5}), + Vector3Add(s.pos, (Vector3){0,0,0.7}), .1, 0, 12, BLUE); + + } + } + } EndMode3D(); + + if (ui_mode_gamepad) { + DrawCircle(sidebar_width + (GetScreenWidth()-sidebar_width)/2, GetScreenHeight()/2, 5, WHITE); + } + + int default_color = GuiGetStyle(LABEL, TEXT); + DrawRectangle(0, 0, sidebar_width, GetScreenHeight(), (Color){61, 61, 61,255}); + + int y = 20; + + #ifndef PLATFORM_WEB + if (GuiButton((Rectangle){20,y,80,20}, "Save")) save("save"); + if (GuiButton((Rectangle){105,y,80,20}, "Export")) export(); + y+=30; + #endif + + GuiCheckBox((Rectangle){ 20, y+0.5, 20, 20 }, "Show Field", (bool *)&visuals_mode); + y+=30; + + if (selected_sphere >= 0 ){ + Sphere old = spheres[selected_sphere]; + + + GuiLabel((Rectangle){ 20, y, 92, 24 }, "Position"); + y+=18; + GuiSetStyle(LABEL, TEXT, 0xff0000ff); + if(GuiFloatValueBox((Rectangle){ 20, y, 50, 20 }, "X", &spheres[selected_sphere].pos.x, -50, 50, focusedControl == CONTROL_POS_X)) focusedControl = (focusedControl == CONTROL_POS_X) ? CONTROL_NONE : CONTROL_POS_X; + GuiSetStyle(LABEL, TEXT, 0x00ff00ff); + if(GuiFloatValueBox((Rectangle){ 85, y, 50, 20 }, "Y", &spheres[selected_sphere].pos.y, -50, 50, focusedControl == CONTROL_POS_Y)) focusedControl = (focusedControl == CONTROL_POS_Y) ? CONTROL_NONE : CONTROL_POS_Y; + GuiSetStyle(LABEL, TEXT, 0x0000ffff); + if(GuiFloatValueBox((Rectangle){ 150, y, 50, 20 }, "Z", &spheres[selected_sphere].pos.z, -50, 50, focusedControl == CONTROL_POS_Z)) focusedControl = (focusedControl == CONTROL_POS_Z) ? CONTROL_NONE : CONTROL_POS_Z; + GuiSetStyle(LABEL, TEXT, default_color); + + y+=23; + GuiLabel((Rectangle){ 20, y, 92, 24 }, "Scale"); + y+=18; + GuiSetStyle(LABEL, TEXT, 0xff0000ff); + if(GuiFloatValueBox((Rectangle){ 20, y, 50, 20 }, "X", &spheres[selected_sphere].size.x, 0, 50, focusedControl == CONTROL_SCALE_X)) focusedControl = (focusedControl == CONTROL_SCALE_X) ? CONTROL_NONE : CONTROL_SCALE_X; + GuiSetStyle(LABEL, TEXT, 0x00ff00ff); + if(GuiFloatValueBox((Rectangle){ 85, y, 50, 20 }, "Y", &spheres[selected_sphere].size.y, 0, 50, focusedControl == CONTROL_SCALE_Y)) focusedControl = (focusedControl == CONTROL_SCALE_Y) ? CONTROL_NONE : CONTROL_SCALE_Y; + GuiSetStyle(LABEL, TEXT, 0x0000ffff); + if(GuiFloatValueBox((Rectangle){ 150, y, 50, 20 }, "Z", &spheres[selected_sphere].size.z, 0, 50, focusedControl == CONTROL_SCALE_Z)) focusedControl = (focusedControl == CONTROL_SCALE_Z) ? CONTROL_NONE : CONTROL_SCALE_Z; + GuiSetStyle(LABEL, TEXT, default_color); + + y+=23; + GuiLabel((Rectangle){ 20, y, 92, 24 }, "Rotation"); + y+=18; + GuiSetStyle(LABEL, TEXT, 0xff0000ff); + if(GuiFloatValueBox((Rectangle){ 20, y, 50, 20 }, "X", &spheres[selected_sphere].angle.x, -360, 360, focusedControl == CONTROL_ANGLE_X)) focusedControl = (focusedControl == CONTROL_ANGLE_X) ? CONTROL_NONE : CONTROL_ANGLE_X; + GuiSetStyle(LABEL, TEXT, 0x00ff00ff); + if(GuiFloatValueBox((Rectangle){ 85, y, 50, 20 }, "Y", &spheres[selected_sphere].angle.y, -360, 360, focusedControl == CONTROL_ANGLE_Y)) focusedControl = (focusedControl == CONTROL_ANGLE_Y) ? CONTROL_NONE : CONTROL_ANGLE_Y; + GuiSetStyle(LABEL, TEXT, 0x0000ffff); + if(GuiFloatValueBox((Rectangle){ 150, y, 50, 20 }, "Z", &spheres[selected_sphere].angle.z, -360, 360, focusedControl == CONTROL_ANGLE_Z)) focusedControl = (focusedControl == CONTROL_ANGLE_Z) ? CONTROL_NONE : CONTROL_ANGLE_Z; + GuiSetStyle(LABEL, TEXT, default_color); + + Vector3 hsv = ColorToHSV((Color){spheres[selected_sphere].color.r, spheres[selected_sphere].color.g, spheres[selected_sphere].color.b, 255}); + Vector3 original_hsv = hsv; + + y+=23; + GuiLabel((Rectangle){ 20, y, 92, 24 }, "Color"); + y+=20; + GuiSetStyle(LABEL, TEXT, 0xff0000ff); + if(GuiSlider((Rectangle){ 30, y, 155, 16 }, "H", "", &hsv.x, 0, 360)) focusedControl = (focusedControl == CONTROL_COLOR_R) ? CONTROL_NONE : CONTROL_COLOR_R; + GuiSetStyle(LABEL, TEXT, 0x00ff00ff); + + y+=19; + if(GuiSlider((Rectangle){ 30, y, 155, 16 }, "S", "", &hsv.y, 0.01, 1)) focusedControl = (focusedControl == CONTROL_COLOR_G) ? CONTROL_NONE : CONTROL_COLOR_G; + GuiSetStyle(LABEL, TEXT, 0x0000ffff); + + y+=19; + if(GuiSlider((Rectangle){ 30, y, 155, 16 }, "B", "", &hsv.z, 0.01, 1)) focusedControl = (focusedControl == CONTROL_COLOR_B) ? CONTROL_NONE : CONTROL_COLOR_B; + GuiSetStyle(LABEL, TEXT, default_color); + + if (memcmp(&original_hsv, &hsv, sizeof(hsv))) { + Color new = ColorFromHSV(hsv.x,hsv.y,hsv.z); + spheres[selected_sphere].color.r = new.r; + spheres[selected_sphere].color.g = new.g; + spheres[selected_sphere].color.b = new.b; + } + + y+=23; + if (GuiFloatValueBox((Rectangle){ 40, y, 40, 20 }, "blob", &spheres[selected_sphere].blob_amount, 0, 10, focusedControl == CONTROL_BLOB_AMOUNT)) focusedControl = (focusedControl == CONTROL_BLOB_AMOUNT) ? CONTROL_NONE : CONTROL_BLOB_AMOUNT; + if (GuiFloatValueBox((Rectangle){ 140, y, 70, 20 }, "Roundness", &spheres[selected_sphere].corner_radius, 0, 9999, focusedControl == CONTROL_CORNER_RADIUS)) focusedControl = (focusedControl == CONTROL_CORNER_RADIUS) ? CONTROL_NONE : CONTROL_CORNER_RADIUS; + + GuiCheckBox((Rectangle){ 120, y+=23, 20, 20 }, "cut out", &spheres[selected_sphere].subtract); + + GuiLabel((Rectangle){ 20, y+=23, 92, 24 }, "Mirror"); + GuiSetStyle(LABEL, TEXT, 0xff0000ff); + GuiCheckBox((Rectangle){ 20, y+=23, 20, 20 }, "x", &spheres[selected_sphere].mirror.x); + GuiSetStyle(LABEL, TEXT, 0x00ff00ff); + GuiCheckBox((Rectangle){ 70, y, 20, 20 }, "y", &spheres[selected_sphere].mirror.y); + GuiSetStyle(LABEL, TEXT, 0x0000ffff); + GuiCheckBox((Rectangle){ 120, y, 20, 20 }, "z", &spheres[selected_sphere].mirror.z); + GuiSetStyle(LABEL, TEXT, default_color); + + if (memcmp(&old.mirror, &spheres[selected_sphere].mirror, sizeof(old.mirror)) || + old.subtract != spheres[selected_sphere].subtract) { + needs_rebuild = true; + + BoundingBox bb = shapeBoundingBox(spheres[selected_sphere]); + if (spheres[selected_sphere].mirror.x && bb.max.x <= 0) { + spheres[selected_sphere].pos.x *= -1; + spheres[selected_sphere].angle.y *= -1; + spheres[selected_sphere].angle.z *= -1; + } + + if (spheres[selected_sphere].mirror.y && bb.max.y <= 0) { + spheres[selected_sphere].pos.y *= -1; + spheres[selected_sphere].angle.x *= -1; + spheres[selected_sphere].angle.z *= -1; + } + + if (spheres[selected_sphere].mirror.z && bb.max.z <= 0) { + spheres[selected_sphere].pos.z *= -1; + spheres[selected_sphere].angle.y *= -1; + spheres[selected_sphere].angle.x *= -1; + } + } + + if (memcmp(&old.color, &spheres[selected_sphere].color, sizeof(old.color))) { + last_color_set = (Color){ + spheres[selected_sphere].color.r, + spheres[selected_sphere].color.g, + spheres[selected_sphere].color.b, + 0 + }; + } + + // if (memcmp(&old, &spheres[selected_sphere], sizeof(Sphere))) needs_rebuild = true; + + GuiSetState(STATE_NORMAL); + } + y+=30; + + + const int row_height = 30; + Rectangle scrollArea = (Rectangle){0, y, sidebar_width, GetScreenHeight() - y}; + + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + int border_width = GuiGetStyle(BUTTON, BORDER_WIDTH); + int text_padding = GuiGetStyle(BUTTON, BORDER_WIDTH); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 0); + GuiSetStyle(BUTTON, TEXT_PADDING, 8); + default_color = GuiGetStyle(DEFAULT, BASE_COLOR_NORMAL); + + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0); + Rectangle view_area; + GuiScrollPanel(scrollArea, NULL, (Rectangle){0,0,scrollArea.width-15, num_spheres*row_height}, &scroll_offset, &view_area); // Scroll Panel control + BeginScissorMode((int)view_area.x, (int)view_area.y, (int)view_area.width, (int)view_area.height); { + const int first_visible = (int)floorf(-scroll_offset.y / row_height); + const int last_visible = first_visible + (int)ceilf(view_area.height / row_height); + for (int i=first_visible; i < MIN(last_visible+1,num_spheres); i++) { + Sphere *s = &spheres[i]; + const char *text = TextFormat("%c Shape %i", s->subtract ? '-' : '+', i+1); + + if (selected_sphere == i) GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0x444444ff); + + if (GuiButton((Rectangle){10, scrollArea.y+i*row_height+scroll_offset.y, sidebar_width+10,row_height }, text)) { + selected_sphere = i; + needs_rebuild = true; + } + + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0); + } + } EndScissorMode(); + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, default_color); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + GuiSetStyle(DEFAULT, BORDER_WIDTH, border_width); + GuiSetStyle(BUTTON, TEXT_PADDING, text_padding); + + + if (focusedControl != CONTROL_NONE) { + DrawText("Nudge Value: Up & Down Arrows Cancel: Escape Done: Enter", sidebar_width + 8, 11, 10, WHITE); + } else if (mouseAction == CONTROL_NONE) { + DrawText("Add Shape: A Delete: X Grab: G Rotate: R Scale: S Camera: Click+Drag", sidebar_width + 8, 11, 10, WHITE); + } else if (mouseAction == CONTROL_TRANSLATE || mouseAction == CONTROL_ROTATE || mouseAction == CONTROL_SCALE) { + DrawText("Change axis: X Y Z Cancel: Escape Done: Enter", sidebar_width + 8, 11, 10, WHITE); + } else if (mouseAction == CONTROL_ROTATE_CAMERA) { + DrawText("Pan: Alt+Drag", sidebar_width + 8, 11, 10, WHITE); + } + + } EndDrawing(); + } + + return 0; +} diff --git a/src/minshell.html b/src/minshell.html new file mode 100644 index 0000000..bb81e9a --- /dev/null +++ b/src/minshell.html @@ -0,0 +1,55 @@ + + + + + + + ShapeUp + + + + + + + + + + + + + + + + + + {{{ SCRIPT }}} + + diff --git a/src/pinchSwizzle.m b/src/pinchSwizzle.m new file mode 100644 index 0000000..9fc89c7 --- /dev/null +++ b/src/pinchSwizzle.m @@ -0,0 +1,35 @@ +#import +#import +#import + +float magnification = 0; + +@implementation NSWindow (PinchGestureSwizzle) + +- (void)swizzled_sendEvent:(NSEvent *)event { + if (event.type == NSEventTypeMagnify) { + magnification += event.magnification; + } + + // Call the original implementation + [self swizzled_sendEvent:event]; +} + +@end + +void swizzleWindow(void) { + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + Class class = [NSWindow class]; + + Method originalMethod = class_getInstanceMethod(class, @selector(sendEvent:)); + Method swizzledMethod = class_getInstanceMethod(class, @selector(swizzled_sendEvent:)); + + method_exchangeImplementations(originalMethod, swizzledMethod); + }); +} + +void makeWindowKey(void) { + [[[NSApplication sharedApplication].windows firstObject] makeKeyAndOrderFront:nil]; +} + diff --git a/src/selection.fs b/src/selection.fs new file mode 100644 index 0000000..834231c --- /dev/null +++ b/src/selection.fs @@ -0,0 +1,45 @@ +out vec4 finalColor; +// int vec2 texCoord; +uniform vec3 viewEye; +uniform vec3 viewCenter; +uniform vec2 resolution; + +vec4 castRay( in vec3 ro, in vec3 rd ) +{ + float tmin = 0.1; + float tmax = 300.0; + + float t = tmin; + vec3 m = vec3(0); + for( int i=0; i<64; i++ ) + { + float precis = 0.0001*t; + vec4 res = signed_distance_field( ro+rd*t ); + if( res.xtmax ) break; + t += res.x; + m = res.gba; + } + + if( t>tmax ) m=vec3(0); + return vec4( t, m ); +} + +mat3 setCamera( in vec3 ro, in vec3 ta, float cr ) +{ + vec3 cw = normalize(ta-ro); + vec3 cp = vec3(sin(cr), cos(cr),0.0); + vec3 cu = normalize( cross(cw,cp) ); + vec3 cv = normalize( cross(cu,cw) ); + return mat3( cu, cv, cw ); +} + +void main() +{ + vec2 p = (-resolution.xy + 2.0*gl_FragCoord.xy)/resolution.y; + + mat3 camera_to_world = setCamera( viewEye, viewCenter, 0.0 ); + vec3 ray_direction = camera_to_world * normalize( vec3(p.xy,2.0) ); + + finalColor = vec4(castRay( viewEye, ray_direction ).gba, 1); +} + diff --git a/src/shader_base.fs b/src/shader_base.fs new file mode 100644 index 0000000..95fcbd1 --- /dev/null +++ b/src/shader_base.fs @@ -0,0 +1,177 @@ +vec4 castRay( in vec3 ro, in vec3 rd ) +{ + float tmin = 0.1; + float tmax = 300.0; + + float t = tmin; + vec3 m = vec3(-1); + for( int i=0; i<64; i++ ) + { + float precis = 0.0001*t; + vec4 res = signed_distance_field( ro+rd*t ); + if( res.xtmax ) break; + t += res.x; + m = res.gba; + } + + if( t>tmax ) m=vec3(-1); + return vec4( t, m ); +} + + +float calcSoftshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax ) +{ + float res = 1.0; + float t = mint; + for( int i=0; i<16; i++ ) + { + float h = signed_distance_field( ro + rd*t ).x; + res = min( res, 8.0*h/t ); + t += clamp( h, 0.02, 0.10 ); + if( h<0.001 || t>tmax ) break; + } + return clamp( res, 0.0, 1.0 ); +} + +vec3 calcNormal( in vec3 pos ) +{ + vec2 e = vec2(1.0,-1.0)*0.5773*0.0005; + return normalize( e.xyy*signed_distance_field( pos + e.xyy ).x + + e.yyx*signed_distance_field( pos + e.yyx ).x + + e.yxy*signed_distance_field( pos + e.yxy ).x + + e.xxx*signed_distance_field( pos + e.xxx ).x ); + /* + vec3 eps = vec3( 0.0005, 0.0, 0.0 ); + vec3 nor = vec3( + signed_distance_field(pos+eps.xyy).x - signed_distance_field(pos-eps.xyy).x, + signed_distance_field(pos+eps.yxy).x - signed_distance_field(pos-eps.yxy).x, + signed_distance_field(pos+eps.yyx).x - signed_distance_field(pos-eps.yyx).x ); + return normalize(nor); + */ +} + +float calcAO( in vec3 pos, in vec3 nor ) +{ + float occ = 0.0; + float sca = 1.0; + for( int i=0; i<5; i++ ) + { + float hr = 0.01 + 0.12*float(i)/4.0; + vec3 aopos = nor * hr + pos; + float dd = signed_distance_field( aopos ).x; + occ += -(dd-hr)*sca; + sca *= 0.95; + } + return clamp( 1.0 - 3.0*occ, 0.0, 1.0 ); +} + +vec3 render( in vec3 ro, in vec3 rd ) +{ + vec3 color = +#ifdef FALSE_COLOR_MODE + vec3(0.); +#else + vec3(0.4, 0.5, 0.6) +rd.y*0.4; +#endif + vec4 result = castRay(ro,rd); + float t = result.x; + vec3 m = result.yzw; + if( m.r>-0.5 ) + { + vec3 pos = ro + t*rd; + vec3 nor = calcNormal( pos ); + // vec3 ref = reflect( rd, nor ); + + // material + color = m; + + #ifndef FALSE_COLOR_MODE + + // lighting + // float occ = calcAO( pos, nor ); + vec3 light_dir = normalize( vec3(cos(-0.4), sin(0.7), -0.6) ); + vec3 hal = normalize( light_dir-rd ); + float ambient = clamp( 0.5+0.5*nor.y, 0.0, 1.0 ); + float diffuse = clamp( dot( nor, light_dir ), 0.0, 1.0 ); + float back_light = clamp( dot( nor, normalize(vec3(-light_dir.x,0.0,-light_dir.z))), 0.0, 1.0 )*clamp( 1.0-pos.y,0.0,1.0); + + // TODO: turn back on shadows + diffuse *= calcSoftshadow( pos, light_dir, 0.02, 2.5 ); + + float spe = pow( clamp( dot( nor, hal ), 0.0, 1.0 ),16.0)* + diffuse * + (0.04 + 0.96*pow( clamp(1.0+dot(hal,rd),0.0,1.0), 5.0 )); + + vec3 lin = vec3(0.0); + lin += 1.30*diffuse*vec3(1.00,0.80,0.55); + lin += 0.40*ambient*vec3(0.40,0.60,1.00);//*occ; + lin += 0.50*back_light*vec3(0.25,0.25,0.25);//*occ; + color = color*lin; + color += 10.00*spe*vec3(1.00,0.90,0.70); + #endif + } + + return vec3( clamp(color,0.0,1.0) ); +} + +mat3 setCamera( in vec3 ro, in vec3 ta, float cr ) +{ + vec3 cw = normalize(ta-ro); + vec3 cp = vec3(sin(cr), cos(cr),0.0); + vec3 cu = normalize( cross(cw,cp) ); + vec3 cv = normalize( cross(cu,cw) ); + return mat3( cu, cv, cw ); +} + +// plane.xyz must be normalized +float planeIntersect( in vec3 ro, in vec3 rd, in vec4 plane ) { + return -(dot(ro,plane.xyz)+plane.w)/dot(rd,plane.xyz); +} + +void main() +{ + vec3 tot = vec3(0.0); +// TODO: turn back on AA +#define AA 1 +#if AA>1 + for( int m=0; m 0.) { + float dist = planeIntersect(ro, ray_direction, vec4(0,0,1.,0)); + if (dist > 0.) { + vec3 t = ro + dist*ray_direction; + float sdf_value = signed_distance_field(t).x; + vec4 field_color = (sdf_value < 0. ? + vec4(1.,0.,0., sin(sdf_value*8.+runTime*2.)/4. + 0.25): + vec4(0.15, 0.15,0.8,sin(sdf_value*8.-runTime*2.)/4. + 0.25 )) ; + + col = mix(col, field_color.rgb, field_color.a); + } + } + + tot += col; +#if AA>1 + } + tot /= float(AA*AA); +#endif + + finalColor = vec4( tot, 1.0 ); +} diff --git a/src/shader_prefix.fs b/src/shader_prefix.fs new file mode 100644 index 0000000..270e706 --- /dev/null +++ b/src/shader_prefix.fs @@ -0,0 +1,119 @@ +float sdRoundBox( vec3 p, vec3 b, float r ) +{ + vec3 q = abs(p) - b; + return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - r; +} + +float RoundBox( vec3 p, vec3 b, float r ) +{ + vec3 q = abs(p) - b; + return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - r; +} + + +vec4 opSmoothUnion( vec4 a, vec4 b, float blend ) +{ + float h = max( blend-abs(a.x-b.x), 0.0 )/blend; + float m = h*h*0.5; + float s = m*blend*(1.0/2.0); + return (a.x

%V@4=hSF?N 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 z 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�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