From e7e0b39e827c5342032e4160762495c2d1472fbc Mon Sep 17 00:00:00 2001 From: "Martin Felis (berta)" Date: Mon, 5 Apr 2010 23:38:59 +0200 Subject: [PATCH] initial commit --- .hgignore | 20 + CMake/FindCEGUI.cmake | 45 + CMake/FindENET.cmake | 28 + CMake/FindFreeType2.cmake | 28 + CMake/FindUnitTest++.cmake | 28 + CMake/Findfysx.cmake | 28 + CMakeLists.txt | 43 + Doxyfile | 1563 +++++++ asteroids/AsteroidEntity.cc | 47 + asteroids/AsteroidEntity.h | 33 + asteroids/AsteroidsEnums.h | 37 + asteroids/AsteroidsEvents.h | 14 + asteroids/Controller.cc | 26 + asteroids/Controller.h | 35 + asteroids/ControllerCommands.cc | 217 + asteroids/EntityFactory.cc | 139 + asteroids/EntityFactory.h | 29 + asteroids/EnumToString.cc | 7 + asteroids/MenuOverlay.cc | 176 + asteroids/MenuOverlay.h | 41 + asteroids/Model.cc | 213 + asteroids/Model.h | 49 + asteroids/ModelCommands.cc | 48 + asteroids/Physics.cc | 58 + asteroids/Physics.h | 34 + asteroids/RocketEntity.cc | 17 + asteroids/RocketEntity.h | 39 + asteroids/ShipEntity.cc | 122 + asteroids/ShipEntity.h | 58 + asteroids/View.cc | 359 ++ asteroids/View.h | 75 + asteroids/main.cc | 44 + codingstyle.txt | 12 + data/fonts/console.ttf | Bin 0 -> 41608 bytes data/levels/default.txt | 5 + data/textures/asteroid.png | Bin 0 -> 104881 bytes data/textures/ship.png | Bin 0 -> 13086 bytes data/textures/ship_parts.png | Bin 0 -> 18235 bytes data/textures/ship_thrust.png | Bin 0 -> 21506 bytes engine/CMake/FindFreeType2.cmake | 28 + engine/CMakeLists.txt | 60 + engine/CameraBase.cc | 49 + engine/CameraBase.h | 61 + engine/Commands.cc | 245 ++ engine/Commands.h | 70 + engine/CommandsGlobal.h | 24 + engine/ControllerBase.cc | 264 ++ engine/ControllerBase.h | 92 + engine/DrawingsGL.cc | 247 ++ engine/DrawingsGL.h | 21 + engine/Engine.cc | 353 ++ engine/Engine.h | 167 + engine/EngineCommands.cc | 15 + engine/EntityBase.cc | 45 + engine/EntityBase.h | 154 + engine/EntityBaseTypes.h | 59 + engine/EntityFactoryBase.cc | 117 + engine/EntityFactoryBase.h | 35 + engine/EnumToString.h | 21 + engine/EventsBase.cc | 88 + engine/EventsBase.h | 88 + engine/EventsBaseGlobal.h | 16 + engine/GameEntityBase.cc | 7 + engine/Logging.cc | 173 + engine/Logging.h | 34 + engine/LoggingGlobal.h | 45 + engine/ModelBase.cc | 295 ++ engine/ModelBase.h | 140 + engine/ModelBaseGlobal.h | 15 + engine/Module.h | 51 + engine/OverlayBase.h | 25 + engine/PhysicsBase.cc | 604 +++ engine/PhysicsBase.h | 91 + engine/PhysicsEntityBase.cc | 149 + engine/SimpleConsoleOverlay.cc | 220 + engine/SimpleConsoleOverlay.h | 69 + engine/Sprite.cc | 237 + engine/Sprite.h | 71 + engine/Variables.cc | 159 + engine/Variables.h | 37 + engine/VariablesCommands.cc | 27 + engine/VariablesGlobal.h | 68 + engine/ViewBase.cc | 330 ++ engine/ViewBase.h | 98 + engine/ViewBaseGlobal.h | 17 + engine/VisualEntityBase.cc | 72 + engine/doc/Mainpage.h | 96 + engine/doc/Usecases.h | 114 + engine/globals.h | 16 + engine/keytable.h | 166 + engine/libraries/CMakeLists.txt | 3 + .../coll2d/CMake/FindUnitTest++.cmake | 28 + engine/libraries/coll2d/CMakeLists.txt | 21 + engine/libraries/coll2d/include/coll2d.h | 346 ++ .../libraries/coll2d/include/coll2d_errors.h | 9 + engine/libraries/coll2d/src/coll2d.cc | 572 +++ engine/libraries/coll2d/tests/CMakeLists.txt | 51 + engine/libraries/coll2d/tests/general.cc | 284 ++ engine/libraries/coll2d/tests/main.cc | 6 + .../libraries/coll2d/tests/polygon_sphere.cc | 544 +++ .../libraries/coll2d/tests/sphere_sphere.cc | 245 ++ engine/libraries/mathlib/CMakeLists.txt | 10 + engine/libraries/mathlib/mathlib.cc | 224 + engine/libraries/mathlib/mathlib.h | 179 + engine/libraries/oglft/AUTHORS | 5 + .../libraries/oglft/CMake/FindFreeType2.cmake | 28 + engine/libraries/oglft/CMakeLists.txt | 63 + engine/libraries/oglft/COPYING | 340 ++ engine/libraries/oglft/COPYING.LIB | 504 +++ engine/libraries/oglft/ChangeLog | 432 ++ engine/libraries/oglft/INSTALL | 231 + engine/libraries/oglft/NEWS | 46 + engine/libraries/oglft/OGLFT.h | 2321 ++++++++++ engine/libraries/oglft/README | 52 + .../libraries/oglft/liboglft/CMakeLists.txt | 45 + engine/libraries/oglft/liboglft/OGLFT.cpp | 3816 +++++++++++++++++ engine/libraries/oglft/liboglft/OGLFT.h.cmake | 2321 ++++++++++ engine/libraries/oglft/tests/CMakeLists.txt | 117 + .../oglft/tests/Demo3UnicodeExample.h | 211 + .../oglft/tests/Demo3UnicodeExample.sfd | 949 ++++ .../oglft/tests/Demo3UnicodeExample.ttf | Bin 0 -> 3016 bytes .../oglft/tests/Demo3UnicodeExample2.h | 470 ++ engine/libraries/oglft/tests/background.png | Bin 0 -> 475337 bytes engine/libraries/oglft/tests/background00.png | Bin 0 -> 94419 bytes .../libraries/oglft/tests/background00a.png | Bin 0 -> 94569 bytes .../libraries/oglft/tests/background00b.png | Bin 0 -> 97967 bytes engine/libraries/oglft/tests/background01.png | Bin 0 -> 141291 bytes engine/libraries/oglft/tests/background10.png | Bin 0 -> 102117 bytes .../libraries/oglft/tests/background10a.png | Bin 0 -> 102353 bytes .../libraries/oglft/tests/background10b.png | Bin 0 -> 104952 bytes engine/libraries/oglft/tests/background11.png | Bin 0 -> 121219 bytes engine/libraries/oglft/tests/demo.cpp | 378 ++ engine/libraries/oglft/tests/demo2.cpp | 183 + engine/libraries/oglft/tests/demo3.cpp | 1582 +++++++ engine/libraries/oglft/tests/speedtest.cpp | 1298 ++++++ engine/libraries/oglft/tests/speedtest.h | 89 + engine/libraries/oglft/tests/texture.png | Bin 0 -> 507 bytes engine/libraries/oglft/tests/tosrc.pl | 30 + engine/libraries/oglft/tests/tutorial1.cpp | 98 + engine/libraries/oglft/tests/tutorial2.cpp | 131 + engine/libraries/oglft/tests/tutorial3.cpp | 282 ++ engine/libraries/oglft/tests/vignette.h | 99 + engine/tests/CMake/FindUnitTest++.cmake | 28 + engine/tests/CMakeLists.txt | 51 + engine/tests/CommandsTests.cc | 138 + engine/tests/ControllerBaseTests.cc | 20 + engine/tests/EntityTests.cc | 90 + engine/tests/EventsBaseTests.cc | 130 + engine/tests/PhysicsTests.cc | 66 + engine/tests/main.cc | 8 + 150 files changed, 28636 insertions(+) create mode 100644 .hgignore create mode 100644 CMake/FindCEGUI.cmake create mode 100644 CMake/FindENET.cmake create mode 100644 CMake/FindFreeType2.cmake create mode 100644 CMake/FindUnitTest++.cmake create mode 100644 CMake/Findfysx.cmake create mode 100644 CMakeLists.txt create mode 100644 Doxyfile create mode 100644 asteroids/AsteroidEntity.cc create mode 100644 asteroids/AsteroidEntity.h create mode 100644 asteroids/AsteroidsEnums.h create mode 100644 asteroids/AsteroidsEvents.h create mode 100644 asteroids/Controller.cc create mode 100644 asteroids/Controller.h create mode 100644 asteroids/ControllerCommands.cc create mode 100644 asteroids/EntityFactory.cc create mode 100644 asteroids/EntityFactory.h create mode 100644 asteroids/EnumToString.cc create mode 100644 asteroids/MenuOverlay.cc create mode 100644 asteroids/MenuOverlay.h create mode 100644 asteroids/Model.cc create mode 100644 asteroids/Model.h create mode 100644 asteroids/ModelCommands.cc create mode 100644 asteroids/Physics.cc create mode 100644 asteroids/Physics.h create mode 100644 asteroids/RocketEntity.cc create mode 100644 asteroids/RocketEntity.h create mode 100644 asteroids/ShipEntity.cc create mode 100644 asteroids/ShipEntity.h create mode 100644 asteroids/View.cc create mode 100644 asteroids/View.h create mode 100644 asteroids/main.cc create mode 100644 codingstyle.txt create mode 100644 data/fonts/console.ttf create mode 100644 data/levels/default.txt create mode 100644 data/textures/asteroid.png create mode 100644 data/textures/ship.png create mode 100644 data/textures/ship_parts.png create mode 100644 data/textures/ship_thrust.png create mode 100644 engine/CMake/FindFreeType2.cmake create mode 100644 engine/CMakeLists.txt create mode 100644 engine/CameraBase.cc create mode 100644 engine/CameraBase.h create mode 100644 engine/Commands.cc create mode 100644 engine/Commands.h create mode 100644 engine/CommandsGlobal.h create mode 100644 engine/ControllerBase.cc create mode 100644 engine/ControllerBase.h create mode 100644 engine/DrawingsGL.cc create mode 100644 engine/DrawingsGL.h create mode 100644 engine/Engine.cc create mode 100644 engine/Engine.h create mode 100644 engine/EngineCommands.cc create mode 100644 engine/EntityBase.cc create mode 100644 engine/EntityBase.h create mode 100644 engine/EntityBaseTypes.h create mode 100644 engine/EntityFactoryBase.cc create mode 100644 engine/EntityFactoryBase.h create mode 100644 engine/EnumToString.h create mode 100644 engine/EventsBase.cc create mode 100644 engine/EventsBase.h create mode 100644 engine/EventsBaseGlobal.h create mode 100644 engine/GameEntityBase.cc create mode 100644 engine/Logging.cc create mode 100644 engine/Logging.h create mode 100644 engine/LoggingGlobal.h create mode 100644 engine/ModelBase.cc create mode 100644 engine/ModelBase.h create mode 100644 engine/ModelBaseGlobal.h create mode 100644 engine/Module.h create mode 100644 engine/OverlayBase.h create mode 100644 engine/PhysicsBase.cc create mode 100644 engine/PhysicsBase.h create mode 100644 engine/PhysicsEntityBase.cc create mode 100644 engine/SimpleConsoleOverlay.cc create mode 100644 engine/SimpleConsoleOverlay.h create mode 100644 engine/Sprite.cc create mode 100644 engine/Sprite.h create mode 100644 engine/Variables.cc create mode 100644 engine/Variables.h create mode 100644 engine/VariablesCommands.cc create mode 100644 engine/VariablesGlobal.h create mode 100644 engine/ViewBase.cc create mode 100644 engine/ViewBase.h create mode 100644 engine/ViewBaseGlobal.h create mode 100644 engine/VisualEntityBase.cc create mode 100644 engine/doc/Mainpage.h create mode 100644 engine/doc/Usecases.h create mode 100644 engine/globals.h create mode 100644 engine/keytable.h create mode 100644 engine/libraries/CMakeLists.txt create mode 100644 engine/libraries/coll2d/CMake/FindUnitTest++.cmake create mode 100644 engine/libraries/coll2d/CMakeLists.txt create mode 100644 engine/libraries/coll2d/include/coll2d.h create mode 100644 engine/libraries/coll2d/include/coll2d_errors.h create mode 100644 engine/libraries/coll2d/src/coll2d.cc create mode 100644 engine/libraries/coll2d/tests/CMakeLists.txt create mode 100644 engine/libraries/coll2d/tests/general.cc create mode 100644 engine/libraries/coll2d/tests/main.cc create mode 100644 engine/libraries/coll2d/tests/polygon_sphere.cc create mode 100644 engine/libraries/coll2d/tests/sphere_sphere.cc create mode 100644 engine/libraries/mathlib/CMakeLists.txt create mode 100644 engine/libraries/mathlib/mathlib.cc create mode 100644 engine/libraries/mathlib/mathlib.h create mode 100644 engine/libraries/oglft/AUTHORS create mode 100644 engine/libraries/oglft/CMake/FindFreeType2.cmake create mode 100644 engine/libraries/oglft/CMakeLists.txt create mode 100644 engine/libraries/oglft/COPYING create mode 100644 engine/libraries/oglft/COPYING.LIB create mode 100644 engine/libraries/oglft/ChangeLog create mode 100644 engine/libraries/oglft/INSTALL create mode 100644 engine/libraries/oglft/NEWS create mode 100644 engine/libraries/oglft/OGLFT.h create mode 100644 engine/libraries/oglft/README create mode 100644 engine/libraries/oglft/liboglft/CMakeLists.txt create mode 100644 engine/libraries/oglft/liboglft/OGLFT.cpp create mode 100644 engine/libraries/oglft/liboglft/OGLFT.h.cmake create mode 100644 engine/libraries/oglft/tests/CMakeLists.txt create mode 100644 engine/libraries/oglft/tests/Demo3UnicodeExample.h create mode 100644 engine/libraries/oglft/tests/Demo3UnicodeExample.sfd create mode 100644 engine/libraries/oglft/tests/Demo3UnicodeExample.ttf create mode 100644 engine/libraries/oglft/tests/Demo3UnicodeExample2.h create mode 100644 engine/libraries/oglft/tests/background.png create mode 100644 engine/libraries/oglft/tests/background00.png create mode 100644 engine/libraries/oglft/tests/background00a.png create mode 100644 engine/libraries/oglft/tests/background00b.png create mode 100644 engine/libraries/oglft/tests/background01.png create mode 100644 engine/libraries/oglft/tests/background10.png create mode 100644 engine/libraries/oglft/tests/background10a.png create mode 100644 engine/libraries/oglft/tests/background10b.png create mode 100644 engine/libraries/oglft/tests/background11.png create mode 100644 engine/libraries/oglft/tests/demo.cpp create mode 100644 engine/libraries/oglft/tests/demo2.cpp create mode 100644 engine/libraries/oglft/tests/demo3.cpp create mode 100644 engine/libraries/oglft/tests/speedtest.cpp create mode 100644 engine/libraries/oglft/tests/speedtest.h create mode 100644 engine/libraries/oglft/tests/texture.png create mode 100644 engine/libraries/oglft/tests/tosrc.pl create mode 100644 engine/libraries/oglft/tests/tutorial1.cpp create mode 100644 engine/libraries/oglft/tests/tutorial2.cpp create mode 100644 engine/libraries/oglft/tests/tutorial3.cpp create mode 100644 engine/libraries/oglft/tests/vignette.h create mode 100644 engine/tests/CMake/FindUnitTest++.cmake create mode 100644 engine/tests/CMakeLists.txt create mode 100644 engine/tests/CommandsTests.cc create mode 100644 engine/tests/ControllerBaseTests.cc create mode 100644 engine/tests/EntityTests.cc create mode 100644 engine/tests/EventsBaseTests.cc create mode 100644 engine/tests/PhysicsTests.cc create mode 100644 engine/tests/main.cc diff --git a/.hgignore b/.hgignore new file mode 100644 index 0000000..37e9599 --- /dev/null +++ b/.hgignore @@ -0,0 +1,20 @@ +syntax:glob +CMakeCache.txt +CMakeFiles +cmake_install.cmake +install_manifest.txt +debug +tags +Makefile + +start +runtests +hasteroids + +./doc/html/* + +*.log +*.a +*.o +*.so +*.swp diff --git a/CMake/FindCEGUI.cmake b/CMake/FindCEGUI.cmake new file mode 100644 index 0000000..1c8a0e1 --- /dev/null +++ b/CMake/FindCEGUI.cmake @@ -0,0 +1,45 @@ +# Tries to find CEGUI (http://CEGUI.bespin.org) a simple and fast +# network library by Lee Salzman +# + +SET (CEGUI_FOUND FALSE) + +FIND_PATH (CEGUI_INCLUDE_DIR CEGUI.h /usr/include/CEGUI + /usr/local/include/CEGUI $ENV{CEGUI_PATH}/include/CEGUI + $ENV{CEGUI_INCLUDE_PATH}/CEGUI) + +FIND_LIBRARY (CEGUI_BASE_LIBRARIES NAMES CEGUIBase PATHS /usr/lib /usr/local/lib $ENV{CEGUI_PATH} $ENV{CEGUI_PATH}/lib ENV{CEGUI_LIBRARY_PATH}) + +FIND_LIBRARY (CEGUI_RENDERER_LIBRARIES NAMES CEGUIOpenGLRenderer PATHS /usr/lib /usr/local/lib $ENV{CEGUI_PATH} $ENV{CEGUI_PATH}/lib ENV{CEGUI_LIBRARY_PATH}) + +SET ( CEGUI_LIBRARIES FALSE ) + +IF ( CEGUI_BASE_LIBRARIES AND CEGUI_RENDERER_LIBRARIES ) + SET ( CEGUI_LIBRARIES + ${CEGUI_BASE_LIBRARIES} + ${CEGUI_RENDERER_LIBRARIES} + ) +ENDIF ( CEGUI_BASE_LIBRARIES AND CEGUI_RENDERER_LIBRARIES ) + +MESSAGE (STATUS "CEGUI Libraries: ${CEGUI_LIBRARIES}") + +IF (CEGUI_INCLUDE_DIR AND CEGUI_LIBRARIES) + SET (CEGUI_FOUND TRUE) +ENDIF (CEGUI_INCLUDE_DIR AND CEGUI_LIBRARIES) + +IF (CEGUI_FOUND) + IF (NOT CEGUI_FIND_QUIETLY) + MESSAGE(STATUS "Found CEGUI: ${CEGUI_LIBRARIES}") + ENDIF (NOT CEGUI_FIND_QUIETLY) +ELSE (CEGUI_FOUND) + IF (CEGUI_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find CEGUI") + ENDIF (CEGUI_FIND_REQUIRED) +ENDIF (CEGUI_FOUND) + +MARK_AS_ADVANCED ( + CEGUI_INCLUDE_DIR + CEGUI_BASE_LIBRARIES + CEGUI_RENDERER_LIBRARIES + CEGUI_LIBRARIES + ) diff --git a/CMake/FindENET.cmake b/CMake/FindENET.cmake new file mode 100644 index 0000000..19a46b4 --- /dev/null +++ b/CMake/FindENET.cmake @@ -0,0 +1,28 @@ +# Tries to find ENET (http://enet.bespin.org) a simple and fast +# network library by Lee Salzman +# + +SET (ENET_FOUND FALSE) + +FIND_PATH (ENET_INCLUDE_DIR enet/enet.h /usr/include/ /usr/local/include/ $ENV{ENET_PATH}/include $ENV{ENET_INCLUDE_PATH}) + +FIND_LIBRARY (ENET_LIBRARIES NAMES enet PATHS /usr/lib /usr/local/lib $ENV{ENET_PATH} $ENV{ENET_PATH}/lib ENV{ENET_LIBRARY_PATH}) + +IF (ENET_INCLUDE_DIR AND ENET_LIBRARIES) + SET (ENET_FOUND TRUE) +ENDIF (ENET_INCLUDE_DIR AND ENET_LIBRARIES) + +IF (ENET_FOUND) + IF (NOT ENET_FIND_QUIETLY) + MESSAGE(STATUS "Found ENET: ${ENET_LIBRARIES}") + ENDIF (NOT ENET_FIND_QUIETLY) +ELSE (ENET_FOUND) + IF (ENET_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find ENET") + ENDIF (ENET_FIND_REQUIRED) +ENDIF (ENET_FOUND) + +MARK_AS_ADVANCED ( + ENET_INCLUDE_DIR + ENET_LIBRARIES + ) diff --git a/CMake/FindFreeType2.cmake b/CMake/FindFreeType2.cmake new file mode 100644 index 0000000..3abf606 --- /dev/null +++ b/CMake/FindFreeType2.cmake @@ -0,0 +1,28 @@ +# Tries to find FREETYPE2 (http://freetype2.bespin.org) a simple and fast +# network library by Lee Salzman +# + +SET (FREETYPE2_FOUND FALSE) + +FIND_PATH (FREETYPE2_INCLUDE_DIR freetype/freetype.h /usr/include/ /usr/local/include/ /usr/include/freetype2 /usr/local/include/freetype2 $ENV{FREETYPE2_PATH}/include $ENV{FREETYPE2_INCLUDE_PATH}) + +FIND_LIBRARY (FREETYPE2_LIBRARIES NAMES freetype PATHS /usr/lib /usr/local/lib $ENV{FREETYPE2_PATH} $ENV{FREETYPE2_PATH}/lib ENV{FREETYPE2_LIBRARY_PATH}) + +IF (FREETYPE2_INCLUDE_DIR AND FREETYPE2_LIBRARIES) + SET (FREETYPE2_FOUND TRUE) +ENDIF (FREETYPE2_INCLUDE_DIR AND FREETYPE2_LIBRARIES) + +IF (FREETYPE2_FOUND) + IF (NOT FREETYPE2_FIND_QUIETLY) + MESSAGE(STATUS "Found FREETYPE2: ${FREETYPE2_LIBRARIES}") + ENDIF (NOT FREETYPE2_FIND_QUIETLY) +ELSE (FREETYPE2_FOUND) + IF (FREETYPE2_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find FREETYPE2") + ENDIF (FREETYPE2_FIND_REQUIRED) +ENDIF (FREETYPE2_FOUND) + +MARK_AS_ADVANCED ( + FREETYPE2_INCLUDE_DIR + FREETYPE2_LIBRARIES + ) diff --git a/CMake/FindUnitTest++.cmake b/CMake/FindUnitTest++.cmake new file mode 100644 index 0000000..261e7a8 --- /dev/null +++ b/CMake/FindUnitTest++.cmake @@ -0,0 +1,28 @@ +# - Try to find UnitTest++ +# +# + +SET (UNITTEST++_FOUND FALSE) + +FIND_PATH (UNITTEST++_INCLUDE_DIR UnitTest++.h /usr/include/unittest++ /usr/local/include/unittest++ $ENV{UNITTESTXX_PATH}/src $ENV{UNITTESTXX_INCLUDE_PATH}) + +FIND_LIBRARY (UNITTEST++_LIBRARY NAMES UnitTest++ PATHS /usr/lib /usr/local/lib $ENV{UNITTESTXX_PATH} ENV{UNITTESTXX_LIBRARY_PATH}) + +IF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + SET (UNITTEST++_FOUND TRUE) +ENDIF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + +IF (UNITTEST++_FOUND) + IF (NOT UnitTest++_FIND_QUIETLY) + MESSAGE(STATUS "Found UnitTest++: ${UNITTEST++_LIBRARY}") + ENDIF (NOT UnitTest++_FIND_QUIETLY) +ELSE (UNITTEST++_FOUND) + IF (UnitTest++_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find UnitTest++") + ENDIF (UnitTest++_FIND_REQUIRED) +ENDIF (UNITTEST++_FOUND) + +MARK_AS_ADVANCED ( + UNITTEST++_INCLUDE_DIR + UNITTEST++_LIBRARY + ) diff --git a/CMake/Findfysx.cmake b/CMake/Findfysx.cmake new file mode 100644 index 0000000..5270fc6 --- /dev/null +++ b/CMake/Findfysx.cmake @@ -0,0 +1,28 @@ +# - Try to find FYSX +# +# + +SET (FYSX_FOUND FALSE) + +FIND_PATH (FYSX_INCLUDE_DIR fysx.h /usr/include/ /usr/local/include/ $ENV{FYSX_PATH}/include $ENV{FYSX_INCLUDE_PATH}) + +FIND_LIBRARY (FYSX_LIBRARIES NAMES fysx PATHS /usr/lib /usr/local/lib $ENV{FYSX_PATH} $ENV{FYSX_PATH}/lib ENV{FYSX_LIBRARY_PATH}) + +IF (FYSX_INCLUDE_DIR AND FYSX_LIBRARIES) + SET (FYSX_FOUND TRUE) +ENDIF (FYSX_INCLUDE_DIR AND FYSX_LIBRARIES) + +IF (FYSX_FOUND) + IF (NOT FYSX_FIND_QUIETLY) + MESSAGE(STATUS "Found FYSX: ${FYSX_LIBRARIES}") + ENDIF (NOT FYSX_FIND_QUIETLY) +ELSE (FYSX_FOUND) + IF (FYSX_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find FYSX") + ENDIF (FYSX_FIND_REQUIRED) +ENDIF (FYSX_FOUND) + +MARK_AS_ADVANCED ( + FYSX_INCLUDE_DIR + FYSX_LIBRARIES + ) diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..62b6b65 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,43 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) + +LIST( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake ) + +# FIND_PACKAGE (Cal3D REQUIRED) + +INCLUDE_DIRECTORIES ( + src/ + engine/ + include/ + engine/libraries/mathlib/ + engine/libraries/coll2d/include + engine/libraries/oglft/ + ${FREETYPE2_INCLUDE_DIR} + ) + +SET_TARGET_PROPERTIES ( ${PROJECT_EXECUTABLES} PROPERTIES + LINKER_LANGUAGE CXX + ) + +ADD_SUBDIRECTORY ( engine ) + +SET ( ASTEROIDS_SOURCES + asteroids/AsteroidEntity.cc + asteroids/Controller.cc + asteroids/ControllerCommands.cc + asteroids/EntityFactory.cc + asteroids/EnumToString.cc + asteroids/main.cc + asteroids/Model.cc + asteroids/ModelCommands.cc + asteroids/Physics.cc + asteroids/RocketEntity.cc + asteroids/ShipEntity.cc + asteroids/View.cc + asteroids/MenuOverlay.cc + ) + +ADD_EXECUTABLE ( hasteroids ${ASTEROIDS_SOURCES} ) + +TARGET_LINK_LIBRARIES ( hasteroids + Engine + ) diff --git a/Doxyfile b/Doxyfile new file mode 100644 index 0000000..ff51aa3 --- /dev/null +++ b/Doxyfile @@ -0,0 +1,1563 @@ +# Doxyfile 1.5.8 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = Engine + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = ./doc/ + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, +# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, +# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene, +# Spanish, Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it parses. +# With this tag you can assign which parser to use for a given extension. +# Doxygen has a built-in mapping, but you can override or extend it using this tag. +# The format is ext=language, where ext is a file extension, and language is one of +# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, +# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat +# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), +# use: inc=Fortran f=C + +EXTENSION_MAPPING = + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate getter +# and setter methods for a property. Setting this option to YES (the default) +# will make doxygen to replace the get and set methods by a property in the +# documentation. This will only work if the methods are indeed getting or +# setting a simple type. If this is not the case, or you want to show the +# methods anyway, you should set this option to NO. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to +# determine which symbols to keep in memory and which to flush to disk. +# When the cache is full, less often used symbols will be written to disk. +# For small to medium size projects (<1000 input files) the default value is +# probably good enough. For larger projects a too small cache size can cause +# doxygen to be busy swapping symbols to and from disk most of the time +# causing a significant performance penality. +# If the system has enough physical memory increasing the cache will improve the +# performance by keeping more symbols in memory. Note that the value works on +# a logarithmic scale so increasing the size by one will rougly double the +# memory usage. The cache size is given by this formula: +# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, +# corresponding to a cache size of 2^16 = 65536 symbols + +SYMBOL_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = YES + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 29 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. +# This will remove the Files entry from the Quick Index and from the +# Folder Tree View (if specified). The default is YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the +# Namespaces page. This will remove the Namespaces entry from the Quick Index +# and from the Folder Tree View (if specified). The default is YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by +# doxygen. The layout file controls the global structure of the generated output files +# in an output format independent way. The create the layout file that represents +# doxygen's defaults, run doxygen with the -l option. You can optionally specify a +# file name after the option, if omitted DoxygenLayout.xml will be used as the name +# of the layout file. + +LAYOUT_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = ./game/ \ + ./engine/ \ + ./engine/doc/ \ + ./libraries/coll2d/include \ + ./libraries/coll2d/src + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = *.c \ + *.cc \ + *.cxx \ + *.cpp \ + *.c++ \ + *.d \ + *.java \ + *.ii \ + *.ixx \ + *.ipp \ + *.i++ \ + *.inl \ + *.h \ + *.hh \ + *.hxx \ + *.hpp \ + *.h++ \ + *.idl \ + *.odl \ + *.cs \ + *.php \ + *.php3 \ + *.inc \ + *.m \ + *.mm \ + *.dox \ + *.py \ + *.f90 \ + *.f \ + *.vhd \ + *.vhdl \ + *.C \ + *.CC \ + *.C++ \ + *.II \ + *.I++ \ + *.H \ + *.HH \ + *.H++ \ + *.CS \ + *.PHP \ + *.PHP3 \ + *.M \ + *.MM \ + *.PY \ + *.F90 \ + *.F \ + *.VHD \ + *.VHDL + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. Otherwise they will link to the documentation. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = NO + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. +# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING +# is used to encode HtmlHelp index (hhk), content (hhc) and project file +# content. + +CHM_INDEX_ENCODING = + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER +# are set, an additional index file will be generated that can be used as input for +# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated +# HTML documentation. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can +# be used to specify the file name of the resulting .qch file. +# The path specified is relative to the HTML output folder. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#namespace + +QHP_NAMESPACE = + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#virtual-folders + +QHP_VIRTUAL_FOLDER = doc + +# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. +# For more information please see +# http://doc.trolltech.com/qthelpproject.html#custom-filters + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see +# Qt Help Project / Custom Filters. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's +# filter section matches. +# Qt Help Project / Filter Attributes. + +QHP_SECT_FILTER_ATTRS = + +# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can +# be used to specify the location of Qt's qhelpgenerator. +# If non-empty doxygen will try to run qhelpgenerator on the generated +# .qhp file. + +QHG_LOCATION = + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. +# If the tag value is set to FRAME, a side panel will be generated +# containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. Other possible values +# for this tag are: HIERARCHIES, which will generate the Groups, Directories, +# and Class Hierarchy pages using a tree view instead of an ordered list; +# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which +# disables this behavior completely. For backwards compatibility with previous +# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE +# respectively. + +GENERATE_TREEVIEW = NONE + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +# Use this tag to change the font size of Latex formulas included +# as images in the HTML documentation. The default is 10. Note that +# when you change the font size after a successful doxygen run you need +# to manually remove any form_*.png images from the HTML output directory +# to force them to be regenerated. + +FORMULA_FONTSIZE = 10 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = NO + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# By default doxygen will write a font called FreeSans.ttf to the output +# directory and reference it in all dot files that doxygen generates. This +# font does not include all possible unicode characters however, so when you need +# these (or just want a differently looking font) you can specify the font name +# using DOT_FONTNAME. You need need to make sure dot is able to find the font, +# which can be done by putting it in a standard location or by setting the +# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory +# containing the font. + +DOT_FONTNAME = FreeSans + +# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. +# The default size is 10pt. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the output directory to look for the +# FreeSans.ttf font (which doxygen will put there itself). If you specify a +# different font using DOT_FONTNAME you can set the path where dot +# can find it using this tag. + +DOT_FONTPATH = + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = YES + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 1000 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not +# seem to support this out of the box. Warning: Depending on the platform used, +# enabling this option may lead to badly anti-aliased labels on the edges of +# a graph (i.e. they become hard to read). + +DOT_TRANSPARENT = YES + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Options related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO diff --git a/asteroids/AsteroidEntity.cc b/asteroids/AsteroidEntity.cc new file mode 100644 index 0000000..d620bf5 --- /dev/null +++ b/asteroids/AsteroidEntity.cc @@ -0,0 +1,47 @@ +#include "Engine.h" + +#include "ModelBase.h" + +#include "AsteroidEntity.h" +#include "Controller.h" +#include "Model.h" +#include "EntityBase.h" + +#include "coll2d.h" + +namespace asteroids { + +bool AsteroidEntity::CollisionEvent (Engine::EntityBase* entity_state) { + GameEntityType other_type = (GameEntityType) entity_state->mType; + + Engine::LogMessage ("CONTACT OF AN ASTEROID"); + + if (other_type == GameEntityTypeRocket) { + // First remove the rocket + Engine::KillEntity (entity_state->mId); + + Engine::LogMessage ("You killed an ASTEROID!"); + + int i; + for (i = 0; i < mSubAsteroidsCount; i++) { + AsteroidEntity *asteroid = (AsteroidEntity*) Engine::CreateEntity (GameEntityTypeAsteroid); + vector3d position (rand()/float(RAND_MAX) * 1. - 0.5, 0., rand()/float(RAND_MAX) * 1. - 0.5); + asteroid->mSubAsteroidsCount = 0; + asteroid->mPhysicState->mRadius = 2. * mPhysicState->mRadius / mSubAsteroidsCount; + static_cast(asteroid->mPhysicState->mShape)->setRadius (asteroid->mPhysicState->mRadius); + asteroid->mPhysicState->mPosition = mPhysicState->mPosition + position; + asteroid->mPhysicState->mVelocity = position; + asteroid->mPhysicState->mAngleVelocity = mPhysicState->mAngleVelocity + (rand()/float(RAND_MAX) * 2. - 1) * mPhysicState->mAngleVelocity; + } + + Engine::KillEntity (mId); + + return true; + } else if (other_type == GameEntityTypeRocket) { + return false; + } + + return false; +} + +} diff --git a/asteroids/AsteroidEntity.h b/asteroids/AsteroidEntity.h new file mode 100644 index 0000000..126e6f9 --- /dev/null +++ b/asteroids/AsteroidEntity.h @@ -0,0 +1,33 @@ +#ifndef _ASTEROIDENTITY_H +#define _ASTEROIDENTITY_H + +#include "EntityBase.h" +#include "AsteroidsEnums.h" +#include "Sprite.h" + +namespace asteroids { + +struct AsteroidEntityPhysicState : public Engine::EntityPhysicState { + AsteroidEntityPhysicState () { + mBaseType = Engine::EntityBaseTypeBlock; + mType = GameEntityTypeAsteroid; + } + virtual ~AsteroidEntityPhysicState() {}; +}; + +struct AsteroidEntity: public Engine::EntityBase { + AsteroidEntity () { + mBaseType = Engine::EntityBaseTypeBlock; + mType = GameEntityTypeAsteroid; + + mSubAsteroidsCount = 4; + } + + virtual bool CollisionEvent (Engine::EntityBase *entity); + + int mSubAsteroidsCount; +}; + +} + +#endif // _ASTEROIDENTITY_H diff --git a/asteroids/AsteroidsEnums.h b/asteroids/AsteroidsEnums.h new file mode 100644 index 0000000..d9d032b --- /dev/null +++ b/asteroids/AsteroidsEnums.h @@ -0,0 +1,37 @@ +#if ( !defined(_ASTEROIDSENUMS_H) || defined(GENERATE_ENUM_STRINGS) ) + +#if ( !defined(GENERATE_ENUM_STRINGS)) + #define _ASTEROIDSENUMS_H +#endif + +#include "EnumToString.h" + +namespace asteroids { + +BEGIN_ENUM(GameEntityType) +{ + DECL_ENUM_ELEMENT(GameEntityTypeUnknown), + DECL_ENUM_ELEMENT(GameEntityTypeShip), + DECL_ENUM_ELEMENT(GameEntityTypeRocket), + DECL_ENUM_ELEMENT(GameEntityTypeAsteroid), + DECL_ENUM_ELEMENT(GameEntityTypeShipPart), + DECL_ENUM_ELEMENT(GameEntityTypeLast) +} +END_ENUM(GameEntityType) + +BEGIN_ENUM(GameState) +{ + DECL_ENUM_ELEMENT(GameStateMainMenu), + DECL_ENUM_ELEMENT(GameStateRunning), + DECL_ENUM_ELEMENT(GameStatePaused), + DECL_ENUM_ELEMENT(GameStatePlayerDied), + DECL_ENUM_ELEMENT(GameStateLevelComplete), + DECL_ENUM_ELEMENT(GameStateGameOver) +} +END_ENUM(GameState) + +#include "AsteroidsEvents.h" + +} +#endif /* _ASTEROIDSENUMS_H */ + diff --git a/asteroids/AsteroidsEvents.h b/asteroids/AsteroidsEvents.h new file mode 100644 index 0000000..e416ebe --- /dev/null +++ b/asteroids/AsteroidsEvents.h @@ -0,0 +1,14 @@ +#include "EnumToString.h" + +namespace asteroids { + +BEGIN_ENUM(Event) +{ + DECL_ENUM_ELEMENT(EventAccelerateStart), + DECL_ENUM_ELEMENT(EventAccelerateStop), + DECL_ENUM_ELEMENT(EventShipExplode) +} +END_ENUM(Event) + +} + diff --git a/asteroids/Controller.cc b/asteroids/Controller.cc new file mode 100644 index 0000000..b0ffeee --- /dev/null +++ b/asteroids/Controller.cc @@ -0,0 +1,26 @@ +#include "Controller.h" + +namespace asteroids { + +int Controller::OnInit (int argc, char *argv[]) { + Engine::ControllerBase::OnInit (argc, argv); + + mBindings[SDLK_q] = "quit"; + + mBindings[SDLK_v] = "+forward"; + mBindings[SDLK_h] = "+turnleft"; + mBindings[SDLK_g] = "+turnright"; + + mBindings[SDLK_UP] = "+forward"; + mBindings[SDLK_LEFT] = "+turnleft"; + mBindings[SDLK_RIGHT] = "+turnright"; + + mBindings[SDLK_SPACE] = "attack"; + + mBindings[SDLK_F8] = "toggleconsole"; + mBindings[SDLK_F9] = "set playerspeed 5.0"; + + return 0; +} + +} diff --git a/asteroids/Controller.h b/asteroids/Controller.h new file mode 100644 index 0000000..f81881b --- /dev/null +++ b/asteroids/Controller.h @@ -0,0 +1,35 @@ +#ifndef _CONTROLLER_H +#define _CONTROLLER_H + +#include "Engine.h" +#include "ControllerBase.h" + +namespace asteroids { + +/** \brief All possible controller states for an Entity + * + * These are used by the controller to update the current state of an Entity + * (e.g. EntityPhysicState). + */ +enum EntityControllerKeyState { + EntityKeyStateForward = 0, + EntityKeyStateBack, + EntityKeyStateLeft, + EntityKeyStateRight, + EntityKeyStateTurnLeft, + EntityKeyStateTurnRight, + EntityKeyStateLast +}; + +class Controller : public Engine::ControllerBase { + public: + Controller () {}; + protected: + /** \brief Set up basic keybindings */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Registers the commands of the cnotroller */ + virtual void OnRegisterCommands (); +}; + +} +#endif // _CONTROLLER_H diff --git a/asteroids/ControllerCommands.cc b/asteroids/ControllerCommands.cc new file mode 100644 index 0000000..01464bd --- /dev/null +++ b/asteroids/ControllerCommands.cc @@ -0,0 +1,217 @@ +// #include "Engine.h" + +#include "Controller.h" +#include "Model.h" +#include "EntityBase.h" +#include "EventsBase.h" + +#include "Controller.h" +#include "ShipEntity.h" + +#include "AsteroidsEvents.h" + +namespace asteroids { + +static Controller *ControllerInstance = NULL; + +/* +forward */ +bool Cmd_ControllerForwardDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateForward); + + Engine::EventBasePtr forward_event (new Engine::EventBase()); + forward_event->mEventType = EventAccelerateStart; + QueueEvent (forward_event); + + return true; + } + + return false; +} + +/* -forward */ +bool Cmd_ControllerForwardUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateForward); + + Engine::EventBasePtr forward_event (new Engine::EventBase()); + forward_event->mEventType = EventAccelerateStop; + QueueEvent (forward_event); + + return true; + } + + return false; +} + +/* +back */ +bool Cmd_ControllerBackDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateBack); + return true; + } + + return false; +} + +/* -back */ +bool Cmd_ControllerBackUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateBack); + return true; + } + + return false; +} + +/* +left */ +bool Cmd_ControllerLeftDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateLeft); + return true; + } + + return false; +} + +/* -left */ +bool Cmd_ControllerLeftUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateLeft); + return true; + } + + return false; +} + +/* +right */ +bool Cmd_ControllerRightDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateRight); + return true; + } + + return false; +} + +/* -right */ +bool Cmd_ControllerRightUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateRight); + return true; + } + + return false; +} + +/* +turnleft */ +bool Cmd_ControllerTurnLeftDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateTurnLeft); + return true; + } + + return false; +} + +/* -turnleft */ +bool Cmd_ControllerTurnLeftUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateTurnLeft); + return true; + } + + return false; +} + +/* +turnright */ +bool Cmd_ControllerTurnRightDown (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->SetControllerKeyState (EntityKeyStateTurnRight); + return true; + } + + return false; +} + +/* -turnright */ +bool Cmd_ControllerTurnRightUp (std::vector args) { + assert (ControllerInstance); + + Engine::EntityBase* player_entity = Engine::GetEntity (Engine::GetPlayerEntityId()); + if (player_entity) { + player_entity->UnsetControllerKeyState (EntityKeyStateTurnRight); + return true; + } + + return false; +} + +/* attack */ +bool Cmd_ControllerAttack (std::vector args) { + assert (ControllerInstance); + + ShipEntity* player_entity = (ShipEntity*) Engine::GetEntity (Engine::GetPlayerEntityId ()); + assert (player_entity); + player_entity->Attack (); + + return true; +} + +void Controller::OnRegisterCommands () { + ControllerBase::OnRegisterCommands (); + + ControllerInstance = this; + + Engine::AddCommand ("+forward", Cmd_ControllerForwardDown); + Engine::AddCommand ("-forward", Cmd_ControllerForwardUp); + Engine::AddCommand ("+back", Cmd_ControllerBackDown); + Engine::AddCommand ("-back", Cmd_ControllerBackUp); + + Engine::AddCommand ("+left", Cmd_ControllerLeftDown); + Engine::AddCommand ("-left", Cmd_ControllerLeftUp); + Engine::AddCommand ("+right", Cmd_ControllerRightDown); + Engine::AddCommand ("-right", Cmd_ControllerRightUp); + + Engine::AddCommand ("+turnleft", Cmd_ControllerTurnLeftDown); + Engine::AddCommand ("-turnleft", Cmd_ControllerTurnLeftUp); + Engine::AddCommand ("+turnright", Cmd_ControllerTurnRightDown); + Engine::AddCommand ("-turnright", Cmd_ControllerTurnRightUp); + + Engine::AddCommand ("attack", Cmd_ControllerAttack); +} + +} diff --git a/asteroids/EntityFactory.cc b/asteroids/EntityFactory.cc new file mode 100644 index 0000000..3b5e165 --- /dev/null +++ b/asteroids/EntityFactory.cc @@ -0,0 +1,139 @@ +#include + +#include "EntityBase.h" +#include "coll2d.h" + +#include "EntityFactory.h" +#include "ShipEntity.h" +#include "RocketEntity.h" +#include "AsteroidEntity.h" + +namespace asteroids { + +int EntityFactory::OnInit (int argc, char* argv[]) { + Engine::LogMessage ("Initializing EntityFactory"); + + return 0; +} + +Engine::EntityPhysicState* EntityFactory::CreateEntityPhysicState (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type > GameEntityTypeLast ) { + Engine::LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + + // Create the Entity + Engine::EntityPhysicState* entity_physics = NULL; + + // type specific initialization + if (type == GameEntityTypeShip) { + entity_physics = new ShipEntityPhysicState (); + if (!entity_physics) { + Engine::LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + entity_physics->mRadius = 0.5; + entity_physics->mShape = new coll2d::Sphere (entity_physics->mRadius); + + assert (entity_physics->mShape); + } else if (type == GameEntityTypeAsteroid) { + entity_physics = new AsteroidEntityPhysicState (); + if (!entity_physics) { + Engine::LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + + entity_physics->mRadius = 1.; + entity_physics->mShape = new coll2d::Sphere (entity_physics->mRadius); + + assert (entity_physics->mShape); + } else if (type == GameEntityTypeRocket) { + entity_physics = new RocketEntityPhysicState(); + if (!entity_physics) { + Engine::LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + entity_physics->mRadius = 0.1; + entity_physics->mShape = new coll2d::Sphere (entity_physics->mRadius); + } else if (type == GameEntityTypeShipPart) { + entity_physics = new RocketEntityPhysicState(); + entity_physics->mBaseType = Engine::EntityBaseTypeBlock; + if (!entity_physics) { + Engine::LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + entity_physics->mRadius = 0.1; + entity_physics->mShape = new coll2d::Sphere (entity_physics->mRadius); + } else { + Engine::LogError ("No EntityPhysicState defined for GameEntity type '%d'", type); + assert (0); + } + + entity_physics->mType = type; + + return entity_physics; +} + +Engine::EntityControllerState* EntityFactory::CreateEntityControllerState (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type >> Engine::EntityBaseTypeLast ) { + Engine::LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + + // Create the Entity + Engine::EntityControllerState* entity_controller = NULL; + + // specific values for each type + if (type == GameEntityTypeShip) { + entity_controller = new Engine::EntityControllerState (); + if (!entity_controller) { + Engine::LogError ("Could not allocate enough memory for EntityControllerState of type '%d'", type); + assert (0); + } + } + + return entity_controller; +} + +Engine::EntityBase* EntityFactory::CreateEntity (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type > GameEntityTypeLast ) { + Engine::LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + + // Create the Entity + Engine::EntityBase *entity; + + if (type == GameEntityTypeShip) { + entity = new ShipEntity; + } else if (type == GameEntityTypeAsteroid) { + entity = new AsteroidEntity; + } else if (type == GameEntityTypeRocket) { + entity = new RocketEntity; + } else if (type == GameEntityTypeShipPart) { + entity = new Engine::EntityBase; + entity->mBaseType = Engine::EntityBaseTypeBlock; + } + + entity->mType = type; + + if (!entity) { + Engine::LogError ("Could not allocate enough memory for EntityVisualState of type '%d'", type); + assert (0); + } + + entity->mPhysicState = CreateEntityPhysicState (type); + entity->mControllerState = CreateEntityControllerState (type); + + return entity; +} + +} + + diff --git a/asteroids/EntityFactory.h b/asteroids/EntityFactory.h new file mode 100644 index 0000000..daa5a9b --- /dev/null +++ b/asteroids/EntityFactory.h @@ -0,0 +1,29 @@ +#ifndef _ENTITYFACTORY_H +#define _ENTITYFACTORY_H + +#include "EntityFactoryBase.h" +#include "AsteroidsEnums.h" + +namespace Engine { + struct EntityBase; + struct EntityPhysicState; + struct EntityControllerState; +} + +namespace asteroids { + + class EntityFactory: public Engine::EntityFactoryBase { + public: + EntityFactory () {}; + + virtual Engine::EntityPhysicState* CreateEntityPhysicState (int type); + virtual Engine::EntityControllerState* CreateEntityControllerState (int type); + + virtual Engine::EntityBase* CreateEntity (int type); + + protected: + virtual int OnInit (int argc, char *argv[]); + }; +} + +#endif // _ENTITYFACTORY_H diff --git a/asteroids/EnumToString.cc b/asteroids/EnumToString.cc new file mode 100644 index 0000000..36d2663 --- /dev/null +++ b/asteroids/EnumToString.cc @@ -0,0 +1,7 @@ +#include "AsteroidsEnums.h" + +#define GENERATE_ENUM_STRINGS + +#include "AsteroidsEnums.h" + +#undef GENERATE_ENUM_STRINGS diff --git a/asteroids/MenuOverlay.cc b/asteroids/MenuOverlay.cc new file mode 100644 index 0000000..95bb046 --- /dev/null +++ b/asteroids/MenuOverlay.cc @@ -0,0 +1,176 @@ +#include "OGLFT.h" + +#include +#include + +#include "DrawingsGL.h" + +#include "OverlayBase.h" +#include "MenuOverlay.h" +#include "Model.h" +#include "Sprite.h" +#include "ShipEntity.h" + +#include "Engine.h" + +namespace asteroids { + +// static float left = 0; +static float right = 0; +// static float top = 0; +static float bottom = 0; + +void MenuOverlay::Init () { + if (!mShipSprite.LoadFromPNG("./data/textures/ship.png")) + Engine::LogError ("Could not load ship sprite!"); + + assert (mShipSprite.GetWidth() > 1); + mShipSprite.SetScale (0.1); +} + +bool MenuOverlay::OnKeyDown (const SDL_keysym &keysym) { + if (mModel->GetGameState() == GameStateLevelComplete) { + switch (keysym.sym) { + case SDLK_RETURN: + mModel->SetGameState(GameStateRunning); + break; + default: + break; + } + return true; + } else if (mModel->GetGameState() == GameStateRunning) { + switch (keysym.sym) { + case SDLK_ESCAPE: + mModel->SetGameState(GameStatePaused); + return true; + default: + break; + } + + return false; + } else if (mModel->GetGameState() == GameStateGameOver) { + switch (keysym.sym) { + case SDLK_ESCAPE: + mModel->SetGameState(GameStateMainMenu); + break; + case SDLK_RETURN: + mModel->SetGameState(GameStateMainMenu); + break; + default: + break; + } + + return true; + } + else if (mModel->GetGameState() == GameStateMainMenu + || mModel->GetGameState() == GameStatePaused) { + switch (keysym.sym) { + case SDLK_ESCAPE: + Engine::RunCommand ("quit"); + return true; + case SDLK_RETURN: + mModel->SetGameState(GameStateRunning); + return true; + default: + return true; + } + } else if (mModel->GetGameState() == GameStatePlayerDied) { + switch (keysym.sym) { + case SDLK_RETURN: + mModel->SetGameState(GameStateRunning); + break; + default: + break; + } + return true; + } + + return false; +} + +void MenuOverlay::Draw () { + glClearColor (0.1, 0.1, 0.1, 1.); + + right = static_cast (Engine::GetWindowWidth()); + bottom = static_cast (Engine::GetWindowHeight()); + + // we switch to orthographic projection and draw the contents of the 2d + // overlay on top of the previous drawings + glMatrixMode (GL_PROJECTION); + glPushMatrix (); + glLoadIdentity (); + + // first we have to get the size of the current viewport to set up the + // orthographic projection correctly + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + gluOrtho2D (viewport[0], viewport[2], viewport[3], viewport[1]); + + glMatrixMode (GL_MODELVIEW); + glPushMatrix (); + glLoadIdentity (); + + // then we do the drawings + if (mModel->GetGameState() == GameStateRunning) { + glClearColor (0., 0., 0., 1.); + DrawGameRunning(); + } else if (mModel->GetGameState() == GameStateGameOver) + DrawGameOverScreen (); + else if (mModel->GetGameState() == GameStateMainMenu + || mModel->GetGameState() == GameStatePaused) + DrawGameMenu (); + else if (mModel->GetGameState() == GameStateLevelComplete) + DrawGameLevelComplete (); + else if (mModel->GetGameState() == GameStatePlayerDied) + DrawPlayerDied(); + + glPopMatrix (); + + glMatrixMode (GL_PROJECTION); + glPopMatrix (); + + glMatrixMode (GL_MODELVIEW); + +}; + +void MenuOverlay::DrawGameRunning() { + right = static_cast (Engine::GetWindowWidth()); + bottom = static_cast (Engine::GetWindowHeight()); + + int i; + for (i = 0; i < mModel->GetPlayerLives(); i++) { + mShipSprite.DrawAt2D (right - 32 - i*20, bottom - 16); + } +} + +void MenuOverlay::DrawPlayerDied () { + std::ostringstream topbar_stream; + topbar_stream << "You died ..."; + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8, topbar_stream.str().c_str ()); +} + +void MenuOverlay::DrawGameOverScreen() { + std::ostringstream topbar_stream; + topbar_stream << "That was pathetic! "; + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8, topbar_stream.str().c_str ()); +} + +void MenuOverlay::DrawGameMenu() { + Engine::DrawGLString ( right * 0.5 - 100, bottom * 0.5 - 8 - 64, "A s t e r o i d s"); + Engine::DrawGLString ( right * 0.5 - 100, bottom * 0.5 - 8 - 32, "Main Menu"); + + if (mModel->GetGameState() == GameStatePaused) + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8 - 16, "[Return] - Resume Game"); + else + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8 - 16, "[Return] - Start Game"); + + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8, "[Escape] - Quit"); +} + +void MenuOverlay::DrawGameLevelComplete() { + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8 - 16, "Congratulations - You rock!"); + Engine::DrawGLString ( right * 0.5 - 80, bottom * 0.5 - 8, "[Return] - Next level ..."); +} + + +} diff --git a/asteroids/MenuOverlay.h b/asteroids/MenuOverlay.h new file mode 100644 index 0000000..2f4cd27 --- /dev/null +++ b/asteroids/MenuOverlay.h @@ -0,0 +1,41 @@ +#ifndef MENUOVERLAY +#define MENUOVERLAY + +namespace Engine { +class OverlayBase; +} + +#include "OverlayBase.h" +#include "Sprite.h" + +namespace asteroids { + +class Model; + +class MenuOverlay : public Engine::OverlayBase { + public: + MenuOverlay () { + }; + void Init (); + virtual ~MenuOverlay() {}; + + virtual bool OnKeyDown (const SDL_keysym &keysym); + virtual void Draw (); + + void DrawGameOverScreen (); + void DrawGameMenu(); + void DrawGameLevelComplete (); + void DrawGamePaused (); + void DrawGameRunning (); + void DrawPlayerDied (); + + void SetModel (Model *model) { mModel = model; }; + + private: + Model *mModel; + Engine::Sprite mShipSprite; +}; + +} + +#endif /* MENUOVERLAY */ diff --git a/asteroids/Model.cc b/asteroids/Model.cc new file mode 100644 index 0000000..e5d2765 --- /dev/null +++ b/asteroids/Model.cc @@ -0,0 +1,213 @@ +#include +#include + +#include "Model.h" +#include "Physics.h" +#include "PhysicsBase.h" + +#include "EntityFactory.h" + +#include + +namespace asteroids { + +static Model* ModelInstance = NULL; + +/* + * Inherited Module functions + */ +int Model::OnInit (int argc, char* argv[]) { + int result = Engine::ModelBase::OnInit (argc, argv); + + ModelInstance = this; + + mGameState = GameStateMainMenu; + mLastGameState = GameStateMainMenu; + + Engine::LogMessage ("Model Initialization!"); + + return result; +} + +void Model::Process () { + if (mLastGameState == mGameState) { + if (mGameState == GameStateRunning) { + Engine::ModelBase::Process(); + } + return; + } + + // when we are here we know that something has changed so we need to take + // some action. + Engine::LogDebug ("Switching from %s->%s", GetStringGameState(mLastGameState), GetStringGameState(mGameState)); + + if (mLastGameState == GameStateMainMenu && mGameState == GameStateRunning) { + mPlayerLives = 3; + mLevel = 1; + DoLoadLevel ("./data/levels/default.txt"); + } + else if (mLastGameState == GameStateRunning && mGameState == GameStatePlayerDied) { + mPlayerLives --; + + ClearEntities(); + + if (mPlayerLives == 0) + mGameState = GameStateGameOver; + } + else if (mLastGameState == GameStateLevelComplete && mGameState == GameStateRunning) + DoLoadLevel ("./data/levels/default.txt"); + else if (mLastGameState == GameStatePlayerDied && mGameState == GameStateRunning) + DoLoadLevel ("./data/levels/default.txt"); + else if (mLastGameState == GameStateRunning && mGameState == GameStateGameOver) + ClearEntities(); + + // ... and we have to set the last game state to the current gamestate + // otherwise we end up in an infinit loop of performing the switching + // action. + mLastGameState = mGameState; +} + +int Model::DoLoadLevel (const char* filename) { + Engine::LogMessage ("Loading level from %s", filename); + std::fstream level_file (filename, std::ios::in); + + if (!level_file) { + Engine::LogError ("Unable to open file %s for writing!", filename); + exit (-1); + } + + ClearEntities(); + mAsteroids.clear(); + + std::string entity_type_str; + + int entity_count = 0; + + while (level_file >> entity_type_str) { + if (entity_type_str[0] == '#') { + std::cout << "Read Comment: " << entity_type_str; + getline (level_file, entity_type_str); + std::cout << entity_type_str << std::endl; + continue; + } + + GameEntityType entity_type = GameEntityTypeUnknown; + + if (entity_type_str == "GameEntityTypeShip") + entity_type = GameEntityTypeShip; + else if (entity_type_str == "GameEntityTypeAsteroid") + entity_type = GameEntityTypeAsteroid; + else { + Engine::LogError ("Unknown Entity type: %s", entity_type_str.c_str()); + exit (-1); + } + + Engine::EntityBase* entity = CreateEntity (entity_type); + + bool is_player; + level_file >> is_player; + + if (is_player) + mPlayerEntityId = entity->mId; + + level_file >> entity->mPhysicState->mPosition[0]; + level_file >> entity->mPhysicState->mPosition[1]; + level_file >> entity->mPhysicState->mPosition[2]; + + level_file >> entity->mPhysicState->mOrientation[0]; + level_file >> entity->mPhysicState->mOrientation[1]; + level_file >> entity->mPhysicState->mOrientation[2]; + + level_file >> entity->mPhysicState->mVelocity[0]; + level_file >> entity->mPhysicState->mVelocity[1]; + level_file >> entity->mPhysicState->mVelocity[2]; + + level_file >> entity->mPhysicState->mAngleVelocity; + + entity_count ++; + } + + level_file.close(); + + Engine::LogDebug ("%d Entities loaded!", mEntities.size()); + + return 0; +} + +int Model::DoSaveLevel (const char* filename) { + Engine::LogMessage ("Saving level to %s", filename); + std::fstream level_file (filename, std::ios::out); + + if (!level_file) { + Engine::LogError ("Unable to open file %s for writing!", filename); + exit (-1); + } + + level_file << "# Format" << std::endl; + level_file << "# " << std::endl; + + std::map::iterator iter = mEntities.begin(); + unsigned int player_id = GetPlayerEntityId(); + + for (iter = mEntities.begin(); iter != mEntities.end(); iter++) { + Engine::EntityBase* game_entity = iter->second; + + level_file << GetStringGameEntityType((GameEntityType)game_entity->mType) << "\t" + // this stores the player id + << (game_entity->mId == player_id) << "\t" + << game_entity->mPhysicState->mPosition[0] << "\t" + << game_entity->mPhysicState->mPosition[1] << "\t" + << game_entity->mPhysicState->mPosition[2] << "\t" + << game_entity->mPhysicState->mOrientation[0] << "\t" + << game_entity->mPhysicState->mOrientation[1] << "\t" + << game_entity->mPhysicState->mOrientation[2] << "\t" + << game_entity->mPhysicState->mVelocity[0] << "\t" + << game_entity->mPhysicState->mVelocity[1] << "\t" + << game_entity->mPhysicState->mVelocity[2] << "\t" + << game_entity->mPhysicState->mAngleVelocity << "\t" + << std::endl; + } + + level_file.close(); + return 0; +} + +void Model::OnCreateEntity (const int type, const unsigned int id) { + GameEntityType entity_type = (GameEntityType) type; + + if (entity_type == GameEntityTypeAsteroid) { + mAsteroids.push_back (id); + } +} + +void Model::OnKillEntity (const Engine::EntityBase *entity) { + GameEntityType entity_type = (GameEntityType) entity->mType; + + if (entity_type == GameEntityTypeAsteroid) { + unsigned int i; + + for (i = 0; i < mAsteroids.size(); i++) { + if (mAsteroids.at(i) == entity->mId) { + std::vector::iterator entity_iter = mAsteroids.begin() + i; + mAsteroids.erase (entity_iter); + break; + } + } + + if (mAsteroids.size() == 0) { + SetGameState (GameStateLevelComplete); + } + } +} + +float Model::GetWorldWidth () { + return static_cast(mPhysics)->GetWorldWidth(); +} + +float Model::GetWorldHeight () { + return static_cast(mPhysics)->GetWorldHeight(); +} + +} + + diff --git a/asteroids/Model.h b/asteroids/Model.h new file mode 100644 index 0000000..45c83ce --- /dev/null +++ b/asteroids/Model.h @@ -0,0 +1,49 @@ +#ifndef _MODEL_H +#define _MODEL_H + +#include "ModelBase.h" +#include "AsteroidsEnums.h" + +namespace asteroids { + +class Model : public Engine::ModelBase { + public: + virtual void Process(); + int DoLoadLevel (const char* filename); + int DoSaveLevel (const char* filename); + + void SetGameState (const GameState &state) { + mLastGameState = mGameState; + mGameState = state; + }; + GameState GetGameState () { return mGameState; }; + + int GetPlayerLives () { return mPlayerLives; }; + + float GetWorldWidth (); + float GetWorldHeight (); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + virtual void OnRegisterCommands (); + + virtual void OnCreateEntity (const int type, const unsigned int id); + virtual void OnKillEntity (const Engine::EntityBase *entity); + + private: + /** \brief Keeps a list of all asteroids */ + std::vector mAsteroids; + + GameState mGameState; + GameState mLastGameState; + + int mPlayerLives; + int mLevel; + + friend class View; +}; + +} + +#endif // _MODEL_H diff --git a/asteroids/ModelCommands.cc b/asteroids/ModelCommands.cc new file mode 100644 index 0000000..c539e3d --- /dev/null +++ b/asteroids/ModelCommands.cc @@ -0,0 +1,48 @@ +#include "Model.h" + +namespace asteroids { + +static Model *ModelInstance = NULL; + +bool Cmd_SaveLevel (const std::vector args) { + assert (ModelInstance); + + if (args.size() != 1) { + Engine::CommandSetErrorString ("usage: savelevel "); + return false; + } + + if (ModelInstance->DoSaveLevel (args[0].c_str()) > 0) + return true; + + // ToDo: Maybe some error output? + + return false; +} + +bool Cmd_LoadLevel (const std::vector args) { + assert (ModelInstance); + + if (args.size() != 1) { + Engine::CommandSetErrorString ("usage: loadlevel "); + return false; + } + + if (ModelInstance->DoLoadLevel (args[0].c_str()) > 0) + return true; + + // ToDo: Maybe some error output? + + return false; +} + +void Model::OnRegisterCommands () { + ModelInstance = this; + + Engine::ModelBase::OnRegisterCommands (); + + Engine::AddCommand ("savelevel", Cmd_SaveLevel); + Engine::AddCommand ("loadlevel", Cmd_LoadLevel); +} + +} diff --git a/asteroids/Physics.cc b/asteroids/Physics.cc new file mode 100644 index 0000000..620edc5 --- /dev/null +++ b/asteroids/Physics.cc @@ -0,0 +1,58 @@ +#include +#include + +#include "Model.h" +#include "Physics.h" + +#include "EntityFactory.h" + +#include + +namespace asteroids { + +static Physics* PhysicsInstance = NULL; + +/* + * Inherited Module functions + */ +int Physics::OnInit (int argc, char* argv[]) { + Engine::PhysicsBase::OnInit (argc, argv); + + Engine::LogMessage ("Physics Initialization!"); + + PhysicsInstance = this; + + mWorldWidth = 16; + mWorldHeight = 16; + + return 0; +} + +int Physics::Simulate (float msec, Engine::ModelBase *model) { + int result = Engine::PhysicsBase::Simulate (msec, model); + + Engine::EntityPhysicState* entity = NULL; + std::map::iterator entity_iter; + + for (entity_iter = mEntities.begin (); + entity_iter != mEntities.end(); + entity_iter++) { + entity = entity_iter->second; + + if (entity->mPosition[0] > mWorldWidth * 0.5) + entity->mPosition[0] -= mWorldWidth; + if (entity->mPosition[0] < - mWorldWidth * 0.5) + entity->mPosition[0] += mWorldWidth; + + if (entity->mPosition[2] > mWorldHeight * 0.5) + entity->mPosition[2] -= mWorldHeight; + if (entity->mPosition[2] < - mWorldHeight * 0.5) + entity->mPosition[2] += mWorldHeight; + } + + return result; +} + +} + + diff --git a/asteroids/Physics.h b/asteroids/Physics.h new file mode 100644 index 0000000..c33fcab --- /dev/null +++ b/asteroids/Physics.h @@ -0,0 +1,34 @@ +#ifndef _PHYSICS_H +#define _PHYSICS_H + +#include "PhysicsBase.h" + +namespace Engine { + class Model; +} + +namespace asteroids { + +class Physics : public Engine::PhysicsBase { + public: + virtual int Simulate (float msec, Engine::ModelBase* model = NULL); + + void SetWorldSize (float width, float height) { + mWorldWidth = width; + mWorldHeight = height; + } + + float GetWorldWidth () { return mWorldWidth; } + float GetWorldHeight () { return mWorldHeight; } + + protected: + virtual int OnInit (int argc, char* argv[]); + + private: + float mWorldWidth; + float mWorldHeight; +}; + +} + +#endif // _PHYSICS_H diff --git a/asteroids/RocketEntity.cc b/asteroids/RocketEntity.cc new file mode 100644 index 0000000..8cd835c --- /dev/null +++ b/asteroids/RocketEntity.cc @@ -0,0 +1,17 @@ +#include "Model.h" + +#include "RocketEntity.h" +#include "Controller.h" + +#include + +namespace asteroids { + +void RocketEntity::Update (float delta_sec) { + mSecToLive -= delta_sec; + + if (mSecToLive <= 0.) + Engine::KillEntity (mId); +} + +} diff --git a/asteroids/RocketEntity.h b/asteroids/RocketEntity.h new file mode 100644 index 0000000..4adcb76 --- /dev/null +++ b/asteroids/RocketEntity.h @@ -0,0 +1,39 @@ +#ifndef _ROCKETENTITY_H +#define _ROCKETENTITY_H + +#include "EntityBase.h" +#include "AsteroidsEnums.h" + +#include "Sprite.h" + +namespace asteroids { + +struct RocketEntityPhysicState : public Engine::EntityPhysicState { + RocketEntityPhysicState () { + mBaseType = Engine::EntityBaseTypeParticle; + mType = GameEntityTypeRocket; + } + virtual ~RocketEntityPhysicState() {}; +}; + +struct RocketEntity: public Engine::EntityBase { + RocketEntity () { + mBaseType = Engine::EntityBaseTypeParticle; + mType = GameEntityTypeRocket; + + mSecToLive = 3.; + } + virtual ~RocketEntity() {}; + + virtual void Update (float delta_sec); + virtual bool CollisionEvent (Engine::EntityBase *entity) { + Engine::LogMessage ("Rocket BOOM"); + return false; + } + + float mSecToLive; +}; + +} + +#endif // _ROCKETENTITY_H diff --git a/asteroids/ShipEntity.cc b/asteroids/ShipEntity.cc new file mode 100644 index 0000000..ab63b14 --- /dev/null +++ b/asteroids/ShipEntity.cc @@ -0,0 +1,122 @@ +#include "Engine.h" + +#include "Model.h" + +#include "ShipEntity.h" +#include "RocketEntity.h" +#include "Controller.h" +#include "AsteroidsEvents.h" + +#include "coll2d.h" + +namespace asteroids { + +static Engine::Variable var_ship_acceleration ("ship_acceleration", "10"); +static Engine::Variable var_ship_maxspeed ("ship_maxspeed", "10"); +static Engine::Variable var_ship_rotationspeed ("ship_rotationspeed", "180"); + +void ShipEntity::Update (float delta_sec) { + if (!mPhysicState || !mControllerState) + return; + + // If we die, we have to decrease the fade timer + if (!mAlive) { + mFadeTimer -= delta_sec; + + if (mFadeTimer <= 0.) { + Model *model = (Model*) Engine::EngineGetModel(); + model->SetGameState (GameStatePlayerDied); + } + return; + } + + mState = Idle; + + // the local velocity + vector3d local_velocity = mPhysicState->mVelocity; + mPhysicState->LocalizeRotation (local_velocity); + + // set the local velocity as the current state of the keys are + if (mControllerState->GetKey (EntityKeyStateForward)) { + local_velocity[0] += delta_sec * var_ship_acceleration.GetFloatValue(); + mState = Accelerating; + } + + // now transform these to global velocities + mPhysicState->GlobalizeRotation (local_velocity); + + // now we can update the new global velocity + mPhysicState->SetVelocity(local_velocity); + + if (mControllerState->GetKey (EntityKeyStateTurnLeft)) { + mPhysicState->mOrientation[1] += delta_sec * var_ship_rotationspeed.GetFloatValue(); + } + if (mControllerState->GetKey (EntityKeyStateTurnRight)) { + mPhysicState->mOrientation[1] -= delta_sec * var_ship_rotationspeed.GetFloatValue(); + } + + // Check for the maximum speed + float speed = mPhysicState->mVelocity.length(); + if (speed > var_ship_maxspeed.GetFloatValue()) { + mPhysicState->mVelocity *= var_ship_maxspeed.GetFloatValue() / speed; + } +} + +bool ShipEntity::CollisionEvent (Engine::EntityBase* entity) { + GameEntityType other_type = (GameEntityType) entity->mType; + + if (other_type == GameEntityTypeAsteroid) { + Engine::LogMessage ("You died!"); + + mPhysicState->mStatic = true; + + mAlive = false; + mFadeTimer = 3.; + mState = Dying; + + Engine::EventBasePtr explode_event (new Engine::EventBase()); + explode_event->mEventType = EventShipExplode; + explode_event->mEventUnsignedInt = mId; + QueueEvent (explode_event); + + return true; + } else if (other_type == GameEntityTypeRocket) { + Engine::LogMessage ("You just killed yourself!"); + + mPhysicState->mStatic = true; + + mAlive = false; + mFadeTimer = 1.; + mState = Dying; + + return true; + } + + return false; +} + +void ShipEntity::Attack () { + if (!mAlive) + return; + + Engine::LogMessage ("ATTACK"); + + Engine::EntityPhysicState* entity_physic = Engine::GetEntityPhysicState (mId); + vector3d attack_dir (1., 0., 0.); + + entity_physic->GlobalizeRotation (attack_dir); + + RocketEntity *rocket_entity = (RocketEntity*) Engine::CreateEntity (GameEntityTypeRocket); + + rocket_entity->mSecToLive = 1.75; + + RocketEntityPhysicState *rocket_physics = (RocketEntityPhysicState*) rocket_entity->mPhysicState; + rocket_physics->mPosition = attack_dir; + rocket_physics->mPosition *= mPhysicState->mRadius; + rocket_physics->mPosition += entity_physic->mPosition; + rocket_physics->mOrientation = entity_physic->mOrientation; + rocket_physics->mVelocity = attack_dir.normalize(); + rocket_physics->mVelocity *= var_ship_maxspeed.GetFloatValue() + 0.1; +} + +} diff --git a/asteroids/ShipEntity.h b/asteroids/ShipEntity.h new file mode 100644 index 0000000..02ac7ea --- /dev/null +++ b/asteroids/ShipEntity.h @@ -0,0 +1,58 @@ +#ifndef _SHIPENTITY_H +#define _SHIPENTITY_H + +#include "EntityBase.h" +#include "AsteroidsEnums.h" +#include "Sprite.h" + +namespace asteroids { + +struct ShipEntityPhysicState : public Engine::EntityPhysicState { + ShipEntityPhysicState () { + mType = GameEntityTypeShip; + mBaseType = Engine::EntityBaseTypeActor; + + mAcceleration = 10.; + mMaxSpeed = 10.; + mRotationSpeed = 180.; + } + + virtual ~ShipEntityPhysicState() {}; + + float mAcceleration; + float mMaxSpeed; + float mRotationSpeed; +}; + +struct ShipEntity: public Engine::EntityBase { + enum State { + Idle = 0, + Accelerating, + Rotating, + Shooting, + Dying + }; + + ShipEntity () { + mType = GameEntityTypeShip; + mBaseType = Engine::EntityBaseTypeActor; + + mAlive = true; + mFadeTimer = 0.; + mState = Idle; + } + + virtual ~ShipEntity() {}; + + virtual void Attack (); + virtual void Update (float delta_sec); + virtual bool CollisionEvent (Engine::EntityBase *entity); + + bool mAlive; + float mFadeTimer; + State mState; +}; + +} + +#endif // _SHIPENTITY_H diff --git a/asteroids/View.cc b/asteroids/View.cc new file mode 100644 index 0000000..1e7cb4a --- /dev/null +++ b/asteroids/View.cc @@ -0,0 +1,359 @@ +#include "View.h" +#include "CameraBase.h" +#include "MenuOverlay.h" +#include "SimpleConsoleOverlay.h" + +#include "Engine.h" +#include "Physics.h" +#include "Model.h" +#include "EventsBase.h" + +#include "ShipEntity.h" +#include "AsteroidEntity.h" +#include "AsteroidsEvents.h" +#include "RocketEntity.h" + +#include + +// #define DRAW_BOUNDARIES + +#ifdef DRAW_BOUNDARIES + #include "coll2d.h" + #include "DrawingsGL.h" +#endif + +using namespace std; + +namespace asteroids { + +int View::OnInit (int argc, char* argv[]) { + ViewBase::OnInit (argc, argv); + + // We want menu + mMenuOverlay = new MenuOverlay; + mMenuOverlay->SetModel ((Model*) mModel); + mMenuOverlay->Init(); + AddOverlay (mMenuOverlay); + + // We want the console + Engine::SimpleConsoleOverlay *console = new Engine::SimpleConsoleOverlay; + // We also want to display the log bar + console->SetDrawLogBar (true); + AddOverlay (console); + + // This is a simple star field that makes the game so spacy + int i; + for (i = 0; i < 200; i++) { + BackgroundStar star; + star.position[0] = rand() / float(RAND_MAX); + star.position[1] = rand() / float(RAND_MAX); + star.position[2] = rand() / float(RAND_MAX); + + mBackgroundStars.push_back (star); + } + + mAsteroidSprite.LoadFromPNG ("./data/textures/asteroid.png"); + mShipSprite.LoadFromPNG ("./data/textures/ship.png"); + + mShipThrustSprite.LoadFromPNG ("./data/textures/ship_thrust.png"); + mShipThrustSprite.SetAnimation (4, 8); + + mShipPartsSprite.LoadFromPNG ("./data/textures/ship_parts.png"); + mShipPartsSprite.SetSubSpriteCount (10); + + mAccelerateEventHandler = new AccelerateEventHandler (this); + Engine::RegisterListener (mAccelerateEventHandler, EventAccelerateStart); + Engine::RegisterListener (mAccelerateEventHandler, EventAccelerateStop); + + mShipExplodeEventHandler = new ShipExplodeEventHandler (this); + Engine::RegisterListener (mShipExplodeEventHandler, EventShipExplode); + + return 0; +} + +void View::OnDestroy() { + delete mAccelerateEventHandler; +} + +/* + * Event Handlers + */ +bool View::AccelerateEventHandler::HandleEvent (const Engine::EventBasePtr &event) const { + if (event->mEventType == EventAccelerateStart) + mView->mShipThrustSprite.ResetAnimation(); + + Engine::LogMessage ("Received Acceleration Event: %d", event->mEventType); + return true; +} + +bool View::ShipExplodeEventHandler::HandleEvent (const Engine::EventBasePtr &event) const { + if (event->mEventType == EventShipExplode) { + Engine::EntityBase *ship_entity = Engine::GetEntity (event->mEventUnsignedInt); + vector3d position = ship_entity->mPhysicState->mPosition; + vector3d orientation = ship_entity->mPhysicState->mOrientation; + vector3d velocity = ship_entity->mPhysicState->mVelocity; + + unsigned int i; + mView->mShipPartsEntityIds.clear(); + + for (i = 0; i < mView->mShipPartsSprite.GetSubSpriteCount(); i++) { + Engine::EntityBase* part_sprite_particle = Engine::CreateEntity (GameEntityTypeShipPart); + part_sprite_particle->mPhysicState->mPosition = position; + part_sprite_particle->mPhysicState->mOrientation = orientation; + part_sprite_particle->mPhysicState->mVelocity = velocity; + part_sprite_particle->mPhysicState->mVelocity = vector3d (velocity[0] * (rand()/float(RAND_MAX)) * 1.7, 0., velocity[2] * (rand()/float(RAND_MAX)) * 1.5); + part_sprite_particle->mPhysicState->mAngleVelocity = (rand()/float(RAND_MAX) - 0.5 ) * 100.; + + mView->mShipPartsEntityIds.push_back(part_sprite_particle->mId); + } + } + + Engine::LogMessage ("Received Ship Explode Event: %d", event->mEventType); + return true; +} + +/* + * Module specific functions + */ +void View::UpdateCamera () { + mCamera->SetEye ( + 0., + 9.5, + 0. + ); + mCamera->SetPointOfIntrest ( + 0., + 0., + 0. + ); + mCamera->SetUp ( + 0., + 0., + -1. + ); + + mCamera->Update (); +} + +void View::DrawStars() { + unsigned int i; + + float world_width, world_height; + world_width = static_cast(mModel)->GetWorldWidth(); + world_height = static_cast(mModel)->GetWorldHeight(); + vector3d velocity (1., 0., 0.); + + glPushMatrix(); + glTranslatef(-world_width * 0.5, 0, -world_height * 0.5); + glColor3f (1., 1., 1.); + glPointSize(2.); + glBegin(GL_POINTS); + float z_value; + for (i = 0; i < mBackgroundStars.size(); i++) { +// glPointSize (2. + 300. *mBackgroundStars.at(i).position[1]); + z_value = mBackgroundStars.at(i).position[1] + 0.1; + + glColor3f (z_value, z_value, z_value); + glVertex3f (mBackgroundStars.at(i).position[0] * world_width, + -1., + mBackgroundStars.at(i).position[2] * world_height); + + mBackgroundStars.at(i).position -= vector3d(Engine::GetFrameDuration() * 0.7 * mBackgroundStars.at(i).position[1] / world_width, 0., 0.); + + if (mBackgroundStars.at(i).position[0] < 0.) + mBackgroundStars.at(i).position[0] += 1.; + if (mBackgroundStars.at(i).position[0] >= 1.) + mBackgroundStars.at(i).position[0] -= 1.; + } + + glEnd(); + glPopMatrix(); + +} + +void View::DrawWorld() { + std::map::iterator entity_iterator; + + Model *game_model = static_cast (mModel); + + DrawStars (); + + if ( game_model->GetGameState() != GameStateRunning) { + return; + } + + ViewBase::DrawWorld(); + + for (entity_iterator = game_model->mEntities.begin (); + entity_iterator != game_model->mEntities.end(); + entity_iterator++) { + Engine::EntityBase* entity = entity_iterator->second; + + // Perform multiple drawing if the entity is at the border + Physics* game_physics = (Physics*) game_model->mPhysics; + float world_width = game_physics->GetWorldWidth(); + float world_height = game_physics->GetWorldHeight(); + + // Drawing at the original position: + glPushMatrix (); + glTranslatef (entity->mPhysicState->mPosition[0], + entity->mPhysicState->mPosition[1], + entity->mPhysicState->mPosition[2]); + + glRotatef(entity->mPhysicState->mOrientation[0], 0., 0., 1.); + glRotatef(entity->mPhysicState->mOrientation[1], 0., 1., 0.); + glRotatef(entity->mPhysicState->mOrientation[2], 1., 0., 0.); + + glColor3f (1., 1., 1.); + DrawEntity (entity); + + glPopMatrix (); + + // If we move out the right side + if (entity->mPhysicState->mPosition[0] + entity->mPhysicState->mRadius * 2 + >= world_width * 0.5) { + + glPushMatrix (); + glTranslatef (entity->mPhysicState->mPosition[0] - world_width, + entity->mPhysicState->mPosition[1], + entity->mPhysicState->mPosition[2]); + + glRotatef(entity->mPhysicState->mOrientation[0], 0., 0., 1.); + glRotatef(entity->mPhysicState->mOrientation[1], 0., 1., 0.); + glRotatef(entity->mPhysicState->mOrientation[2], 1., 0., 0.); + + glColor3f (1., 1., 1.); + DrawEntity (entity); + + glPopMatrix (); + } + + // if we move out the left side + if (entity->mPhysicState->mPosition[0] - entity->mPhysicState->mRadius * 2 + < - world_width * 0.5) { + glPushMatrix (); + glTranslatef (entity->mPhysicState->mPosition[0] + world_width, + entity->mPhysicState->mPosition[1], + entity->mPhysicState->mPosition[2]); + + glRotatef(entity->mPhysicState->mOrientation[0], 0., 0., 1.); + glRotatef(entity->mPhysicState->mOrientation[1], 0., 1., 0.); + glRotatef(entity->mPhysicState->mOrientation[2], 1., 0., 0.); + + glColor3f (1., 1., 1.); + DrawEntity (entity); + + glPopMatrix (); + } + + // If we move out the bottom side + if (entity->mPhysicState->mPosition[2] + entity->mPhysicState->mRadius * 2 + >= world_height * 0.5) { + + glPushMatrix (); + glTranslatef (entity->mPhysicState->mPosition[0], + entity->mPhysicState->mPosition[1], + entity->mPhysicState->mPosition[2] - world_height); + + glRotatef(entity->mPhysicState->mOrientation[0], 0., 0., 1.); + glRotatef(entity->mPhysicState->mOrientation[1], 0., 1., 0.); + glRotatef(entity->mPhysicState->mOrientation[2], 1., 0., 0.); + + glColor3f (1., 1., 1.); + DrawEntity (entity); + + glPopMatrix (); + } + + // if we move out the left side + if (entity->mPhysicState->mPosition[2] - entity->mPhysicState->mRadius * 2 + < - world_height* 0.5) { + glPushMatrix (); + glTranslatef (entity->mPhysicState->mPosition[0], + entity->mPhysicState->mPosition[1], + entity->mPhysicState->mPosition[2] + world_height); + + glRotatef(entity->mPhysicState->mOrientation[0], 0., 0., 1.); + glRotatef(entity->mPhysicState->mOrientation[1], 0., 1., 0.); + glRotatef(entity->mPhysicState->mOrientation[2], 1., 0., 0.); + + glColor3f (1., 1., 1.); + DrawEntity (entity); + + glPopMatrix (); + } + } + +} + +void View::DrawEntity (Engine::EntityBase *entity) { + if (entity->mType == GameEntityTypeAsteroid) + DrawAsteroid ((AsteroidEntity*) entity); + else if (entity->mType == GameEntityTypeShip) + DrawShip ((ShipEntity*) entity); + else if (entity->mType == GameEntityTypeRocket) + DrawRocket ((RocketEntity*) entity); + else if (entity->mType == GameEntityTypeShipPart) + DrawShipPart (entity); + else { + Engine::LogError ("Cannot draw entity: unknown type '%d'", entity->mType); + } +} + +/// \todo: Update of the animation ?? +void View::DrawShip (ShipEntity *ship) { + if (!ship->mAlive) + return; + + mShipSprite.SetScale (2. * ship->mPhysicState->mRadius / mShipSprite.GetHeight()); + mShipThrustSprite.SetScale (2. * ship->mPhysicState->mRadius / mShipSprite.GetHeight()); + + if (ship->mState == ShipEntity::Accelerating) { + mShipThrustSprite.UpdateAnimation (Engine::GetFrameDuration()); + mShipThrustSprite.DrawAt(-0.5, 0., 0.); + } + + mShipSprite.DrawAt(0., 0., 0.); + +#ifdef DRAW_BOUNDARIES + glColor3f (1., 1., 1.); + DrawCircle (ship->mPhysicState->mRadius, 20); +#endif +} + +void View::DrawAsteroid (AsteroidEntity *asteroid) { + mAsteroidSprite.SetScale (2. * asteroid->mPhysicState->mRadius / mAsteroidSprite.GetWidth()); + mAsteroidSprite.DrawAt(0., 0., 0.); + +#ifdef DRAW_BOUNDARIES + glColor3f (1., 1., 1.); + DrawCircle (asteroid->mPhysicState->mRadius, 20); +#endif +} + +void View::DrawRocket (RocketEntity *rocket) { + glColor3f (1., 1., 1.); + glBegin (GL_QUADS); + glVertex3f (-0.25, 0., 0.05); + glVertex3f (0.05, 0., 0.05); + glVertex3f (0.05, 0., -0.05); + glVertex3f (-0.25, 0., -0.05); + glEnd (); +} + +void View::DrawShipPart (Engine::EntityBase *entity) { + unsigned int i; + mShipPartsSprite.SetScale (1. / mShipSprite.GetHeight()); + + for (i = 0; i < mShipPartsEntityIds.size(); i++) { + if (mShipPartsEntityIds.at(i) == entity->mId) { + mShipPartsSprite.DrawSubAt (i, 0., 0., 0.); + } + } +#ifdef DRAW_BOUNDARIES + glColor3f (1., 1., 1.); + DrawCircle (entity->mPhysicState->mRadius, 20); +#endif +} + +} diff --git a/asteroids/View.h b/asteroids/View.h new file mode 100644 index 0000000..485eae8 --- /dev/null +++ b/asteroids/View.h @@ -0,0 +1,75 @@ +#ifndef _VIEW_H +#define _VIEW_H + +#include "ViewBase.h" +#include "mathlib.h" +#include "Sprite.h" +#include "EntityBase.h" + +namespace asteroids { + +class MenuOverlay; +struct ShipEntity; +struct AsteroidEntity; +struct RocketEntity; + +struct BackgroundStar { + vector3d position; +}; + +/** \brief Performs the actual drawing based on Camera and Model + */ +class View : public Engine::ViewBase { + protected: + /** \brief Initializes the system */ + int OnInit (int argc, char* argv[]); + void OnDestroy (); + + /** \brief Updates the camera for further drawing */ + virtual void UpdateCamera (); + + private: + virtual void DrawWorld (); + void DrawStars (); + + void DrawEntity (Engine::EntityBase *entity); + void DrawShip (ShipEntity *ship); + void DrawAsteroid (AsteroidEntity *asteroid); + void DrawRocket (RocketEntity *asteroid); + void DrawShipPart (Engine::EntityBase *entity); + + MenuOverlay *mMenuOverlay; + std::vector mBackgroundStars; + + std::vector mShipPartsEntityIds; + + Engine::Sprite mAsteroidSprite; + Engine::Sprite mShipSprite; + Engine::Sprite mShipThrustSprite; + Engine::Sprite mShipPartsSprite; + + class AccelerateEventHandler : public Engine::EventListenerBase { + public: + explicit AccelerateEventHandler (View *view) : mView (view) {}; + virtual bool HandleEvent (const Engine::EventBasePtr &event) const; + private: + View *mView; + }; + + class ShipExplodeEventHandler : public Engine::EventListenerBase { + public: + explicit ShipExplodeEventHandler (View *view) : mView (view) {}; + virtual bool HandleEvent (const Engine::EventBasePtr &event) const; + private: + View *mView; + }; + + AccelerateEventHandler *mAccelerateEventHandler; + ShipExplodeEventHandler *mShipExplodeEventHandler; + + friend class AccelerateEventHandler; +}; + +} + +#endif // _VIEW_H diff --git a/asteroids/main.cc b/asteroids/main.cc new file mode 100644 index 0000000..e51ecb0 --- /dev/null +++ b/asteroids/main.cc @@ -0,0 +1,44 @@ +#include +#include + +#include "Engine.h" + +#include "Controller.h" +#include "View.h" +#include "Model.h" +#include "Physics.h" +#include "EntityFactory.h" + +using namespace std; + +int main (int argc, char* argv[]) { + cout << "Game Start" << endl; + + Engine::Engine engine; + + engine.SetEntityFactory (new asteroids::EntityFactory); + engine.SetController (new asteroids::Controller); + engine.SetModel (new asteroids::Model); + engine.SetPhysics (new asteroids::Physics); + engine.SetView (new asteroids::View); + + SetLogPrintLevel (Engine::LogLevelDebug); + + if (engine.Init (argc, argv) != 0) { + cout << "Could not start engine!" << endl; + exit (-1); + } + + engine.GetView()->SetGridSize (8,8); + dynamic_cast(engine.GetPhysics())->SetWorldSize (28, 20); + + SetLogPrintLevel (Engine::LogLevelDebug); + + engine.MainLoop (); + + engine.Destroy (); + + cout << "Game Quit" << endl; + + return 0; +} diff --git a/codingstyle.txt b/codingstyle.txt new file mode 100644 index 0000000..999bf02 --- /dev/null +++ b/codingstyle.txt @@ -0,0 +1,12 @@ +Indent: Tabs! + +class Uppercase { + int OnInit () + void OnDestroy (); + + void SetValue (); + int GetValue (); + + void SomeCoolFunction (); +}; + diff --git a/data/fonts/console.ttf b/data/fonts/console.ttf new file mode 100644 index 0000000000000000000000000000000000000000..bfff77e49d5b7bc059fd73ab56d9b59326e00c7d GIT binary patch literal 41608 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 literal 0 HcmV?d00001 diff --git a/data/levels/default.txt b/data/levels/default.txt new file mode 100644 index 0000000..c673d2a --- /dev/null +++ b/data/levels/default.txt @@ -0,0 +1,5 @@ +# Format +# +GameEntityTypeShip 1 0 0 0 0 90 0 0 0 0 0 +GameEntityTypeAsteroid 0 5 0 -2 0 0 0 -0.2 0 -0.1 -10 +GameEntityTypeAsteroid 0 -2 0 2 0 0 0 0.3 0 0.1 5 diff --git a/data/textures/asteroid.png b/data/textures/asteroid.png new file mode 100644 index 0000000000000000000000000000000000000000..11c9f9a5fb2986aa491c7165a851f8156ebab593 GIT binary patch literal 104881 zcmV*UKwH0wP)Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2igM; z6a*}ll{!HH03ZNKL_t(|+U&h)lVr!SC3f6BBJRDp*51|KXfzf!c5WEcv-zYC`k>#f zkJ8BWMw+*i1VIoD^iq4S_r~V>5Rq9;&5TLUjC^_|E6mzphOW-c%1rlgKj-*y!o&HK zowJhzyuG{y0DSQ5QPZ`JYg}_6hEGLg3{@9`Pn*qVv)!z3*S-JY>b74WAB=EyyLos6 zAI_irn1{FEPjj5Jczbz^r{~9`lcU-DUE3bI#-50=r^0-abDG5v9gu@Da>HU?I-Aap z=G{MC-EOXSkMsCsj8~WIhd1=$JS2cWmveqHJ?I*9*mdq~Hl3V~CzD5wYaSDu^Q`$a z#dI7~9EaddiopZ8HpcuOgkQHVAD+zHU$bB_4C(IM9~bM>qY*ByA1Z=}^T$8*@D}`W z&U@!aZPS=zCVgTJojAjfy0&>d8jT*e-RO~+<}77B8U{bxZa3X_+q+@#oN|r;)&#s2 z#&<^O8|M65&H8c(@%3^&eEa?D)%Cm2_4ssxR~M^?H~rx}B!K_F&Zu>m&pJ}Y@u+Q{ zI4398@VOCwVuYSp!{^r8v!-cISllcrP5QyNn@#Ul>osq;TaGb-iL`MhwvF91jlFS3 z-Vo#a7~}7TA^gsV_%i4GYbIJSQ`q{nIh=Hxzy0S|0DvcFQ~daL`S5`}oQDMPr@!S7 z@$&Tzjt)9I9d(ZzXCARJPlV_xGd(kgpEzqCIcrWucn;7cD|I1d+xNk2wp-qAd+G;I zAw*BITZ_lGft36XXH83jqs;1Dys59EVK2vI`_l(Qn`T;F&F z5rYU2AvMfotY~A6I%krzHaKerYo#~FY#V3R#>kCk{5S;vP2Y!q>IeVL)$Qg#|M2E+ z`0&{YzWx64;lq14|DVqT3-I4Lm)9#iKAlev=H0XDxOqD1n&(YppF8K?XXD-r5s&&X z9K{&N!!R_1A52P_6+{37!~j4!XUz%%K+JR>^Z*oqYWd5Ym7-?NsuW{F@1rr|#Ts!e zGPWYwS`(VaoLghg6*yDyfpvEB=y=+)@c;Jh_m|tRzkH6r{fF-!KEQ|bkO2O*=lEcZ ztJ^isPbTAW=bnzo>{Vo;S{ZEW#fs=xIzi%_$x9LmaPG8@F7o&33aPA0m~Tory(Y zjDZ+|FcXA9N?;Hm0%8V%pdjR&k#mM>hN_ZkMoL5}Wq1&QhzJlOQe(t9Yucub27#2%LkzF;XJee|IKrHG{wdB5@*K~ z>KgNSI&vR(t^25H%nM=pSb_Hybf%f+8PtUY=Y5dPcHr%H3-1f4r}cKX*1|apYXk%! z<%kplR1-u5)>;^2KqN?65n@D)9w9`;n2=INRv_nHl~6t?B7zv!#+ux=jh~F$<#arH zJ(-NYZQJ&@%;tA7#~*z^Tx>R*AN!%dyS`a1zx(lK`|v40oQDeFzi|%dBV1fBadJ3m z4`-uKCnNh&+t^Q?v!4<1hcV_S{ooG=A3GniNeamslyjmO6QvZ9a|V!0qyo?!flPoZ z2nyB=a7hkLBk0-&-DnIkEwT~@KVZArV6$0cvmFpqMoNmTx_d|{00JT9OgSrOMI%h? zoU@~hsWI+x({>*c)2rBpA6?VFS*?~A1YC7aUO~f~m~#5f%jM>S#}oYS)q{@U;Q;d2 z`isvdEe0Q9h2-(+?Ag)5=;yOZ`?K+=`yblI{Zfp45feS%4&ivY=|}5z@3y^{5EG}I z2^j#C00kqL&YuY)1j7U)fEB<9U<|<-M%Nfj#vNv}8D_IX%nlAQnahaeOeEOh)b}qptaA+%=!KZTq>k_9t2K*!y&_?R~pm^|ILx zJcK}+RYe4b3B*KFnsa1ks1i_vmI!b{Xe`571LrK9YtT50u61Zf6SUnFuA73TLErZf zQVc_n&1M4;0w)6PZhx(RDsliQR5L=1yxI1|vT7A@gAb#wv4=$TI7YvUF)RSRvevvc z!mm{G?@bKfgZQ9p%zs&JV|;tPeMkfk3E;2iELJ^;h0hM#BWuhT#+Vn*+Amq`XDQ=@ z_12&CK23(f+rA%o7zPS4l4@20749AirUcRqq6`s&sv;91XN3sET1MBkn9rs-I5@y` zI)!rvOavB&wJmHj0ZD_6V+>n|))K4%tPrxHcLKlQ0Xg6I1C=e%e(p!qRCE5md}WL}ZrTM_)4NKc%}-yckyZ=K=I+XtB7Ap!hl1AS$n=Im%R zH6kC2@P}f|PmHmjgZPu}5Z{Zd{&4W29YQc6BuX(-%1Nn|-Xu(b#sbn+ZjY&y<*GnT z3RMM2A!0Bdk8pZ=iu1=$Fh4kgF$S7Epb^XlY#OALK`~)vJUSaOa)5UXK#@zEfs}zn zibRT>%X8FZKnM{zWg7gTYbF*VWhQ1OVP?n7oiIqpiBOkMokA>wEV);aY4>rAj6hfHvgKt8Jlu~BZ z8sr2bC`9VruL(>Upc4Eg`hlbh%>}A!NI}dPk6IiZOmTXAi22beoNED1&>WCcLhxH` zR@abt4W|oqCScSMLJ%+kDVHRWaz>2hsgeQ_04bnZku=pLQWza7N14GW@n6^#Z z$d@AWk%)Y5jQJGIA8N)E@56x)apVVYLQGUR`Q1IPU0%At+8}zGd_~i|T#Vh#D1&}tdk}+xsF$$OnK4gTH zL5T~SkTW6?q*eeqqtJz_g@mXm!A?Cu1X9gF06t zbK=+Uoyj$kE>(548S?GL&Gx~J;2{D0d7isvk0+;-_lW5y%;trNd}%~JC8p;&=aU%Y zc<|AAA2^oar(7HF9qk521>DQ6ZYt7GC^vAZCAro_;S6Kk8XQbpoE(gBd^pA7!3@*c z1lEm^Q$X%}466&QZeL?{cZq(pMvM_mfHjQ9%08hemFE&BD7f7ESrL;Wq>LC#@F%UU z0TiqRW`!z2H6v@`4pK>OmI1MbP2)^ML^A_=l$Bo^lV1zz1+!j2^=<3YTWk2cH&>hM zhfsM)0Dl(ey~l@m`RWGGpBxxx_!AI5R^>00_zNa}q0skYhzB8tHiXDNBu*()%2^Aa zUqChj?PXF-B>;^O8p9A%%l@PwR)`@m5v&kKox$1B7*Ed+@$9{)c=Gfaj?W&W>8420 zW4*b<`tCLEu3uwuca6<*w1hp>4_0RJw}2TzajyC1Ib$%m)2*~opCRbQm6U!{yMveHK}q%$AF)cas#OdM0< z5*%4o%QdM=wfHYR_fCOlgkXgsQm8*>g0rZcfBFB`GG^lz?>#=oPd<8%4?q3{XHP!H zczS@CJeI2qEH1vo)$8Bk_UbJ*>lM5Yh%qD8+{4(%dFA~TM#}T;Bmmg}CS?c{7ywcE z$0-9KzzV|%15}b!h#4`}%0^XFO4JX5Q%Xe4k~5rwW+HS(Fg-IZte6YS@}V*28*Ace zKk#>1>E&t@zL||1EY`zA^gJYhe_!W!KV0GKFP@!`I{SqY{xs+O(;=qMy-&{v9}i;; zo%i0x5UGyis*(~DNU7eSR3~>T2~WgeLL~qdPzEv3I>xv&7_|Z`3}!-O4Ni`x`0#_L z`0&FIaQ@^O=Er9c)&dHV+I#U=c(LP`NSXAmib30VjrDuSR~+6rNU2*VgE z0bgH7jEW&7SVPzj8AfvP7Z5?~46HNA3JgQSdh4MYOAC-Q#RzB~Fc5LY5-owO7;d~V zW8aurzS^vd`JUgCu?&@y)PYY=cN7HfhsderP zRsHEO_)p=}(-`A?7>1_zfm2FcT6+RmNtBRE+#%;$X1_BbK`13P=$@0e!kCUMj%E&B z%MhZ9`geGIeu^hgpW^JSP=DQM3_!6(Kn`o}(rsU#X>%5ab{Ai{7)AyxJ# zT-pM|T=0j&5+Wso-e+w3h(2Vf0*$j6jaxL(C<6ov zL<2|ZJ=@0GrfqH4Iy)8N!whpwqH{KRJfF7XKBT`L`tYw35qx3E+=+ zKKbAjzxwWyAD_;CHl1`Yx>5I2Vfm^b{ENZIv(T_((Y`6I7W%Bt>agaPy3W zO6vjGM;LbHJ|I+jawCMUk^Sx8S_X(F1iwWZmPo?_ zF>DZGK<_hF+k_ZX5e^CVH-76FRtTvAep!nGkcCRCQH4eXpbr_w5bThk3bf8(Ja%x_ z!p96`gAfdIOz1fl_Mi%kvSz4)c7P)(D09}7h+{|yF?FFy);Ze|^9Yc!h@BWiha-~n zabxa8Xb?u)RVP&5FEv8h2t{kSHzM1cg@5zS%iH)6at{gMk8;jWCU||hg7<0mH$Q#$ zdDq&{oO3@Dv0sIdK3uK))7#}{v|Mh?;A26)|8$-S9;GHhP4IX8$yPU8Jenh05P0pbWWgDz`b5*j}x>Fp*0y+A{ZI5$%rEc z!N3iKAtd;yh%rNnDs@=i3nf6aQYO-%%2`!oOxA_O))~WO8ey4G!;eVyN5i-=hP)L- z7T&ig%*eu&gwZq8f|;+!z6a4V@VKC_-0sJe@>Cp(UFIV{J z*}=(dY`nJ-oSHw2Q^s^g}=~;UGxW@|OO-Qg=)+R1$!Z9oR>( zhT*Kh8U|4N@{~YKaF#(-t0mrE_qezlu<0Y9wD0fBKvB8tN0@Vj zV+{u*$oGkpAWWH=A~Uv3bVr0YM0oY+*#6|v(FeCF>(cwMT5X0~MgH-Jw}^lE`A%?g z{g4zM62O1wTwHJP{CxVfwemR;{ZxUU$E07R_4d8NhxuZ)am(dK1|LW@-_v5MrR>e6 z=QqM=Z24m?qcM!e30lW!oI%%>Qd$+*_5*wf&>DnR7}ih;{^=Nx&W`Zt>>P*3XK1=H zf?s2K^*t_L{tI6J@Eg2-^#)hh3tTP+TrUSKRsln(YD2znFN`pZ6yOh9Re)*7N(cz0 zB>{k#GD0jk0#U&c8q08%mSj?}7#JgPMqnhCX+i=B2?J%MocC(RoE3>s^#laXAmogw z;G7jH<<@3nxUnNrIVGY*&>}$~0LqjLt_lJr0D*|s%zVwH7Ye-9tXE8WV=doJ$IWew z>Gtc-&XzIdyO6M2Y{Hu#Uf=nr=STSA^@IH2ApyK|P7X)7yxHLCqv`XeHD4NQe#R_6 z&x+6b?eN6MG+S+YyWM&YF%ke3X4>8OSrteMVnQQ~Q7agCf>C48Izi(~dEGjL>12%A zYzk)`yzjByu8ZWB4OD>;0*Dmz$q1)sCpbAh$7ni-X2s&>M=Y*h;_`>z;Ns2qxW2i? z&D{o9ivhPwkHtD->k~rMy(QRAYFxDc3ay}CPKw&4)M}(ilyoQj*^8DcW5A_?5g{l9 zs)RNdfl^@xb>H5|kPsr5`2r|%CUDM3i9o8zyvGVuQ)vlQvxO$3YMPt`K}fkkh=n$# zlDvdPjp1w!M{D@Z2t8w_rGi%=T8PL(1UF4fR|H%t=xxgMdOFRAqpth**WbQgJ~=6|5DU zoE+oe;1D7$uCA_eb9ISfeS^E}SGc>q#A?09YVC2i_PAXJEI0A~<_ADbkShK$QUW~0 zqV$VZV!Trr?%hF9fWdt4K~iu0(mEJhJP9g?0j<9`G$U)BW8hNB456qAOPQ|-u~Y!X z-y|0(RF!fuH=zVYBqeC(Y*=@KBVebSATV?FMqsr@th3x$!xJNNOiY1^Ju~;l+O@NG zX^h;6F|P^y`#z-KfX(Fjd-?Cbd--;8I3MHY?m>{D#stIE07TeGZ2!(M@2s*FcW;th-p8xgwnki zagZ?AxKtFM!AlA=7^GbIXWM#@V14rQuU zL0SD!OEtj6BFw^MM8pwO7G`zUrlv&#Sx?4n4ZG*o+V@rRY3p?|8uj+{c=op!SBvGr zq{Z#3e~8w<#su);dx!Y;iSlhrkhw)?z*K|mCD-atr zO#^2w7Rx1me0_n}Z!WQ1tr26`m)Tlx)!t`phlJiIq@)ljH+oSJmeLujh#5$!pz*o( zMNWzk3g-_ftT5t^CahB5!Do1%keiY)LXJBgz zO&DWD%!*8teC?|`*%01{_TVM@UJideD>if-dwHui;vGfH^zRYz}H#vi=6d^ z_u*vlz8i)hAttD17-q6NP_Ke?qt>Ep8(720IU)rQ)eI5FbUMbPN00H|^N%qajj_1B zM88>L@E+?S!1MuG1;#pv7$_Lt59qgB_+gFJ@(!!j23Oa2xLa;8__#Oi$Q8f~K{3Pv z*6pMjr^O5ithDRNjZuw`-|HOi2hFD-%&Kd;s9ej#xu`^&{PnC_r~&$sK#aTHBOr zZ&!-LUmJdnbuO|!hqmCgb7E72RM8D9!}2Q1CVfgeS!66i|uxUZ6GXG0d3RZ^yCpj0)bdJ;HOk^wXAWzsv!ayOZn683FOIRate&mYfmvq|{qeDdXFGXBar_jQQrm)_@} zgb+`>53LVTvR1H9h@36`yfX$YfU|ojt*vU%?L+*k0?Dh>jjpp748-*^utg9Gn9cHGE~63A(bz8 z+$s6)gWv3gM2x*EZwKb3R2hI;p)`gu9T}V)I2_F!tYNIT3AZbcO<$fP)L|dcj-He~ zjcDrgC}qUtp((?PV$>PC{wK# zVy$*!Dh@`>ij<4y0Ck880AeomWlEV+3jj`6u0H&N(jImY~mJ-R)0h#OD z?Kcl$`xl%59vzQyeYfSur<2dEvtNmkuR;3Dl)?+|{YeO+O*sp(kf8$d83vp+XsQ># zF$Kv#m=!8-G9JNMM(`dv1z7LktYA9n;3Q#v_X@9GeuwYBe~Fi`Z?W105S0qTS%dX@ ziL1*uKn}RRyuxO^!r(n(EN;No+?VnxY30;w51)6mTlu-xl?vru9=~?X*j3x|PTB8l z@dp^Sg2o7PRxHPh zTtvQ9rLSX5zl<@w*lhZfq4#Ynr6C#OTA5}rWpM3Doi&(F8qB6+%%&4GR=||%L|=wh zRK0C1kUefMf53XR!0&$l8sERV#`Rr~m=w+wO@8z}Zm%zqhXphTtTtP0x8>%SdZU{v z8Q#fwn+CNGsIkG z1Zp4xK<5O9vof4C8yU3C?)EQWUC!k_vaBG-$eG}yVh9mKN@Zq1v8Nn&6Nn-TqkL~h zTFd-$bC<;9Oqq+YwhEV0-cKodpW&-%$?mmMH8@F9k|IYgNigLCf@VbukrZr%?ZjBa z#)>i4HaYPmgQh?_J)F1ya&y=J2mmjhACq$es<_MLZLb&CD?EQP$9F$IEKL2gNC5L` zi@Rlyv!n6n%<_eT|3k|7<+dMQ#28ODo1yg~2|#46Q!$3187X>b&d4c)h%lLqaB@7u zWZXfR5W|3N>XEF$FnFvtYlINMlyP%&h4oUgT5fQ0y})|wYY+o%D`*@c=YYlH4!-AV z4VJ;A=o*GpzI%s~84(Zz-j`b+C|Z6I!lX5rPb?;#fp7`H-X(1Mgb>qSh8tqJK|{<) z3NV*jb-9V?h2cZ_JzaGTVj@gOf`hT!2jb2zQ0uL`1L}wXfx;Sv6$PQN1~F!&I)@Od zCV;Bnh$-IZrKiuR9)iNO4^xV#BJ$|H^X7-Hv74^7Y=sNyl2dzx5*FBEr-BS_yltq3)%)d-IzleQ0Nh!7|CQ%R>Yv7s&P2)fs5r=>j!@l&MO-DF9 zoMS#eK#BqD)dDF7#4wcGzYl;a=JO6u&PI52G(t>8{L(tX;nYG5VbmJf3h1R;a!bxo zVGvbUAlVso@P0(NYm1quGrZsIv*`(g&lr40$^jrkV+D;ZLqKai*#p$nPvAz1JHM0i;|Vh6?!i4hy)a z`?3~ILhnljGinkVOCXZMB-DW`taq2cu^q{8JJ03nS*|1o}xz=_JM2=9~loiHJJu zsIdlyfgBUErW*W&gGqzaqX|xq=9tfB==%+P--1$y#WG;EP9S8=CJmmPO>llZMb{c! z-EI+MhI0gG9Ga%|^gbvCA2EayNQI&&2p7#f7<>P|#+D(X9XGD3n2yZezkkz5thWgw zgw_f$Dc7kFd9M(RN%t$mV=CjiKHgJ^x%SsSl*OU0Rvfvhdi_jL%P{XOd)u|{yR~Ih zZ`W9ZF4mGiX59}+DRT7*(EG^WKTrwm-Pp2^x>q?e1F0$OK+?STGDx{jRyqMQA*AxY z##kzvT@uLoo-W*}i>a8JYEGb_%1IKXoW|;G!=wj>HF!oMsIn1dLP%LxN%4LLoiWRF zI%&G+Pv-ySoA0k*{l9%5KYD(S-+uS{Ap!hbox5d^v*XdZ5%U?b{9MHRf|x!@DV^pV zJIzT{m6!#_2w5v-*B&QCRxlNyZqiwt92N)OgTu0KuWJO3JZ`0Y;f(2F1ekON&JcV^ z*!qO)+ch?Q0CF++Bmf~QwnM~fQ-*e!ij0=)DDeFfkPJdG^Vp&J!n|(@j1&N^A2PN+ zp>+b5^5yn1W4Q^qS$eGd1R+A(@Lo$0Qwc5~@_rn6Hy>b4ku~qeh*7l%DVN4w>bPJ| zip2T{f}NaED~`Mmy7Z1G;l9d9_d`bDG91LULZNDwm{Z2!6PBA$Sq+7iV!aU3uIkw( z0#nN}N4@iYfOlvSa*j3#SV$~kjN(fYu;*-9OLVl^U}g%5~mPQ){2 zJ8nBS8;z&O?>%|+duHA+b2Q8`Lsdjp3ic^ueYaR{|MTB{lO8I7e}l6#fjB)JO)>yy+uWeZt_&%`FwVAAH{5*1OUlDCn~f z3~LK5nR5ZZdY`Z!%H!;WJewgRE3jCV%D~55Xg*uoiClFALr946-lE(HVcZF3oxyZs z(HKT1LI@c*?_a2D^#02z1 z22m8AWt4>`Iz+5C9smmXStlWPH-5EdDQ!!wc6OBuu$xF!BFcp@4VhC;@SaeY zpxhg`8e^@srfZ$+I@h+{=%{PEXVx{B#@H1Rc@R8QSE~6kXT0`4yh-DH^EbcvWci=| z&tE+xfIs#5;q3~Kjz{gNwLde)d@f>t4x-PzkLNMQaR`xBGl)Q@&Z-xb%s@4RQA{#h z>tNYnIx1_pM&k)YfE2bc42;H8_@J1t*6242EEWMN7x$j7b4cqRJ|?V(fWhZISI;V#w6UW!rohOxe4fftYV;o z>c_0`L9rb&hM_P4MhMOkrk%mjyusnbqH7IO1~z>}PNjqwCfMEHf?5?&y1)IIv^w@w zQBwW6j9L}c+Zj~UfXGE3uwxVoJ5bG482f4^=L}!q6)@*&WOA>Ai244u&sq0nKd3ky z5q9sP)@3W$BM&=s)?#2%ZOc>vBxw1|eVQu14-t(^PF2M^YlV5{n&xTOO_pMtfmu8> z4O!D|PU**#@~^V0E!w2Ke5e5a4NliKJnrmgjkBK`V}BuHzVI%bGkH?r!r?|TrVYBJcb_SDC z3ns!a1Z?_%^`;E!7$LMxp|zM$JOXTS{OOvae9Ni`3dE=gR3`Ld%7~eu5y&|K$k+@K zHw%y3RlvGW)yqG@nlfkuEy24Pa;+xPe#oXU044ZS$}l46oZxug;Owx$s1*QZl-Dq! zv4qAMv{ukGWe$RN<$NkMTWK2#YhXCn1i<@2BqG4D>=}TZ%Tf}gw8secp+>Y%BuoUQ z(l(Xfy-0yei&Ss$y$@j(JMGyBplXn@UxuzbyEfWae|bl1R$hYlLrC|*UthB-5qTd$ z1TjWN#uz82nS*RJnUb(cAPt1HWaL*uIx-?rgcli>y(J|uuY;(2m9!H*X!JUMMY zAGPjN=iJYXbzkO`pAOznLkKp+NGWA7flvXrgi0OdBDqDwpt>q!$5+QN;QI1MkSe;- zs7%8d1LOp$8+@Ba&^W=iAFx_QT;8m(*#`Jn^z{mYO+Yp%Y=B7h4`7U1Q|P$b>!uw= zS9SeW)>;A}DVCdro0Z?s|Enr&;=;KnDJ?_g`~igwR5^7i{JJol$?zzse(Q>PiL;E9 zfx*YZP6%N>wgu&{7{yMXzcUOeD1S+&QWb`cD@m<&293>dR`nmcXHHms5?FArtgQcrnd_qT z-4>^kpmt8jAVtiHxBWmwB0j=4YY$_cQZ*`R49yxRBO{!dXkm@Hxa|Eu1Bed^;7@Rl z<|F)gvBLB7>HA${KN_{oPhHb|1%0+%ky#My>_U{#Q&J5Lr7y@zv zQY?ZN&1r9`9l`|85Htl4GWzv3khTyc41L0z?G_jKm znC`_)T>bv6*=ZTDcL3IRhM7`r74Aor_visw2)g$wDAnDLN(BJ7rzlHRU#Qj!iq_vn zwN^3Kf{9C&loC>^vlpoXrXZ^K1r0uG$Xi}-L#ZIj@2TUFlgX%|aciF$=dK#(UQb8u z6@dTr{?ilu{)fwl1n|c^*LNE{J{`@w&VJlB?u)i_Uop#vo8BL;H@)kJz&nx1j=SCs z&g^cAwkh^q&Ja?LMKQ;KYC=j8jUiYo*dXCb1Gbwx5ER>f3qNf4Bd{?kxcc}XwJk^- zLa1}_p+^V0E=^Zhwl|AYoq9El|`s}I-973VWoMntVho@&F zJUt!33UIUN_j-PbipEt6u?CDWga*9t(^FR5uEIXBn`#VNHvbeH!3ts2R(62Otr>GJ zi%sc185Ik%>Mq;}oE2>Ph%h9itd)5v3BU>iru?^UxB``R_$L9qkJt{W*s9}RPK?r} z*G)_1XTcTtQwEvp&Qu>y>xSj>yj1-bO9DvMp@^7ZjD@ug#5G8n5kkN)cz8b`gjDAg z7+Hx*E@8?Uh$$2;MM_`>#b61kYoYD&Nb`rrwO8}`^zJ|W^yBUS@ps?+-GBEYo3%(O z8tcr2iLA3MRp6BX3ad?APR338_T|lg^>6>@|LH%@tPs}ArT#Df>)$U6AU?(qZ`XM7 z?0{E&)>jt`{fkThr-z;C8v7G#&8N=VFNx&iZ6A*BmfLo{@iK%&slw09#jvBXrDWe3 zPt3*^2lE!rFt*zPA><;TWx#L*lOSnEhzWxaSgzKkP^=EOJDSc~gQjgT={ig%BXnI0 zYb|07SS(gpt(MsK9=FTBn0fROiyS}z8s{+|JItpMtNgjFkNA0 zh5_4c8RPatKmsEx*H#3zLW@W-mTDnpKr^It8Dk=PIx%kDb))UcDW$K!%I+V3{qk@7 z;lJL4n6f(O+)tS4kcj3AZtFs~EkPFtv-ZY&{WZ!?X8gxrzUWR)j-MIp#>8Tw3YupB zKmN@p>$jJ8zyHB%SZrcM`OIbUSmFXpSE4|S<|?$ z!1C#8q`gy6BKuy%cUOmWX6 zmmwX0Z`G zk~L$o4tv_IF^r?R!{OB7a5e&wfW;suMe9nyq!@607qDChyuIzQ?jx)zLqa>{;ZS-1 z;smVktR}1Pi(#});l6V&Q-o>H=W7+$xW^S8nOfNe%vLwo+dU)!hQZC9xEbKt@a@ac-*%k?s|OfaRU-I>A&IV-kkVWzM0o zf^lcjI2q6{`ROYIK z0J3HpLW1<(vB*Kw=8sz2tGm_q)%UM%Ud<-Wp$L5_%tvC(6JdGG zOeaJ%sg~0#B3y{@>!U;a;gj?Es%snSx^e5AI}l?Jm}OKixPFqtEmS|ZhBkda=nzs) zId1^mj-9z)ZT-bxL;`qwy~d0851x%W_o8jvpE8>-dLN%ImfOi{-J6n`GqUCq{B_Q} zaYgG+b;^$G!poF0LMWyD4uAttO7(C*d%rWt+>PK8Ta3po4h{}6pU>c&g%!eV+TwUV zLfcySkYHSckZ$1L-eNmM48DkQQZA)@*9xpDl;CpX(btjOaVuaUJUZ5Q)OQ)yD4Zq4 zm~gj>=zYTNDqyjWfGXONDJAtE+?)wR+>H|Jz8r2WV>Yp9t?UIm@eioA3>gwy$7rph zk?IGaK-7$ou=fyrm)%0^_F0+#stUL`6U8(KH5z z72E9wNeL+z+cVDqazu_mt~ds$z>q#<-fTnT8h_l4l}6*Pn=v0T;h8YKDeQoxVF;2{ zXUy`*h&&~xC(LvNpeu`)v1OuLW`1qNTv=mQ);hJ$jjc6@EcQTEM_Cg9+8Wy|+AiKr zQyKt@S%c4-Zc@e%YVhrN57wJ- zuv`yz@PTwERN-<zrK2txMQ4r^TBEU;RwfSk%qejo^!QrT5A&z&e}-6ss8Sbt5& z9yd#mN!P;&q2CT5D%DE}WioKJEz;Q#b5#a%u?|y|iMd#+fE_r4D-csIy>(SGW&;=^ zI3xSvpAhqXxz2TgiDe{}-4=6D)gUysR32SxF>Z@3yWQy$a#@2`KL4F(5yM)C@py#k zd%j!~zrsUadD>)2&WeY-=iRc*6V*m#!rA}3CZRdg-**eGv#AYeh^(+EaG$Euhk{`zq zY>WXp=a6&SX2sTs3D&w~6M7}SBI0kE!m2k7z{`n<o$=Oa6vG%uQ_ z`LuEFtElu*Kg8qBc4!A5IK~7bqP>%i;iCAHDy20AvT7THQER~>7`#VLii3&8@!XX! z$-=`*LNbgHGJGx*aZ*7fRYgBUtkxU28%81Qr?8^f2qXA}m=bPo7x?kjYrK7X2|xJi zDOhN^kP3I6wV?GSASwl=rSx8|BQCCcFo03Z^)@5qsumd)``cw#`6!JHt8p~@gim9xKJLEaCwy5LIB)>f>O-SU;X_@v60jg&++8Ci^53u{Xi z(ffp9hzKDe#rvs3BEX8GH4%n;L`@J;D38%t2aO$ub&If}IwY2hUxX%DNyru;Fu)cN zhm@3RK=O9G&9^r&Xegp4o^%wctTv-#&o#}mA{ zTK)MXfb+8hyncI&Cy%C|w2k?R5%X16deIN@Y_lD@eh8FOCZP7`M&PU|3N~akwz%<3 z#tquWp=%nr#$vPXF$@8%Euxs?16Qo9hlJMiK4^rfj`WttObPHgVX^9wa)KWQ^xHL- z%R5->kTPM@2iz@JSS;4?-dD}K?sWhr7Yd83p@pr~8;IZ})gd6@W;r0`jDv~Ad}`6T zA|#qk8UTde19$6$#d^Tt141a(05f30NCseEf^MhbZ>pKdq?3vjWNhn%VXXdunhWii zb9p}+8{sTr+}`gul*+9K#eM>DS3&GdK2jCw>}C%rl-fPp0y3(W#ODK0fba5H+bVb7 zc@*qiiQ783)Huet6Es%#-2eT)0!7(H#8s`h+fx8!l*&-}|EBJ}nr+L@^So!I8CKfy zqz*(QkN`nh1SLAC?DBuNZ){bG7QnK=AP@u^ole+kg&9Wl#W&{K2fnq+YTt zN+On0NQW4O_CC)(6(5tzspyoGPATb9iXvyV$e2JGYqS|CRvXji zqKY$G$$B!WlpyA;VvM8|DY@1*>ikyA+Uk|FuCdlcrOLr*4!4)9@7~@WAOBTV0N=fP zkrkuq(ja_#3Vo&ZH;S&^Kn8ipm&Cd_7R3udXe-+`BXN|nH0nxo!R69kz6++ znN%dSG}qsO3=I`cJ^Ym}loaS(!Ilw|2O8Vsx*fXNV!CT|d&M?n8s{*&$bs>A$EXV_ z8HzH52q8hyJ(w0VM@o+MWi=GE3O*|D=Mv*=V~m8DN{m^Bm`kYvDMi*DO8vi#(y^el zj%u1bxlpuL}8^jUj*eeq*!)Ssple>zR`=ci%X9Zr**Ca+_XFz!Vmro>%~H8L4quX=X7 z9oM%vTwh(&HkOBn2ec}zd&~7@&w9Ngm%`{rW-q-nTDAvWBX7LLMq7O=WIl4)#SFzW zd3l(8$kp6qtK+W@)(VT}>|7C;#)>r9)xK4WA?NWFxPO{C%mVd5DY~}h`qHpjbzE%M z*tX}|!)DduOck@_%rqqurS7^FZ80>q$bUDocaH^%m;ZP2LfBa(vrd`w3bnP;`^PK; zMWsxw0;mR{XI%gl0cNeN<8sa@Wkifs_4!LX5OtQdVwTom`TDKXtXsL+LtLDZoCk#4 zwc~Qr%Ai!sK^cOotGy})DpgEXbqEE`wr_a(;)>0xCHNC@9)v5Pq9`LTZfJL}G3_Yca-g95ct$#D|B8DP+3F(zT70 zuvHnBi#P|BR_G#gfh96)_TsHSjgixwFp4^mGFYdWXPG|7^qj#*kpWxdWFp=*n$1cO zU&k@>bPCKt@Lh)znPWjKOWRn{1T>DdwRDZ+`l2PpH6ct;5(gKUePWtZ6}YFWe3OQVWKIFfQ9hjdo{DFt2Ia(jD) zE*nnAC%m5k18ADAWwX7)t!_mV5R)(&ibs`^#wmv3M9P|?TSC(Ex`rhG?LF2g4tx3i zq8oyd8BxiJloKkc^9*J2Epm1->Z)gWc3~Qo(Im9CXEL*ZSLE-fOcjrns$^8v>nWc) zrEF4)t5VEsZS0@5PT%)hJ^bR&KYRbnzx(Q&?{x+6H^2NffBjc~vD&OR7foYsatbfi z?5|?Vtq)1ZO4oskfU00gQN9_RwY43P59b`lHKgd}mzYJP{^4;Z<&o1cky7Mx+i`Qb zqG?*DPBaPr*mJx`~= zG^g`~U8KSV)zm3^BLmJ=D}8k?<@|jvZ`e?`69WH`8+i#EUKpd8TfVeP`J5hxw&Y#+_vY~wO4i2KxjLk+f~FLS zDG9_@DSV7IAXbU$ouXn&HkZ6p@R>H|XN}b#tkn-c{*xCU{^`s2{(Id5++1I_u652D z-DOo8W1ThHYNa%l?^fS@rCL1=TAP}1!cqpzh&@>Z{OXM%R7$8lPJH=eW^Zk>6ae6ZwH&5ao8RE>-UncTW>BC5AC@x1V`)JMqcO!1YCsQHga6 zt!+rjRXkbC)qdvwY35-c*w^-C;rZz*2>(Tc1JVX^4eRc+48J*Cc;-9`H^WqYad=^AZhc-d9`LSvWIVtt0CSfiOj zCWcHsYNXYuK-9(=oDL*EP#Os&S+Ca^uPE9O=M!PLr(f+*T4RdGsetMm^zCb!)^S?j zGYkVUYhq~#SuuygGzG?Pl!~))45tI$d&X(T*@8lpgR}RTP#@AWu1uXD{-q7DrV6$y zb3q}v^}cIyu6g#f)X&*80cSPy9O@h=lXFrsqsls`+@xHtQ_5cytL}_eA8syJk6*ua zfBV_%UHQ%L@4lZ0fD@`tEJY1UnN!oav0rtuKedeyu|OcDte!RhQvS!3P$5xTUHd`< zT6WBS8X3nE!!&WI>b!z@1Nzpn+w@#r?YO*pMJO%khSO=l&oe`MhGk@1_vEe`ZBVRw z!>g-~+lvOH;V?$5T?9ljz%o^$t96apHX?&P43YgwL`cU`L_Qj^5gSv^JNDxc32Ef1 z&ItBL&!;bYt~Qp&$phC|Asbz;EmvE|?M2J`hl%g*Cms*s+=BQhIf3%MEW7g>@4e&_ zEJ-~{9`ePL;G<^MEHvZgkjT|*{|xIaMa(-UErZbNBTxlZ6wh(%^7VX>avoJR{W;+# z#n6h6qLlLd^=kW&6KG>-l@^9TZAYTY=c-LB8C8-!B^i{q7&MJBB&8^6#83BxX(tDJ zDQGf{b=b`o*R(Xpp=}dwBRZ0~HRD}dwSIBd7;1J=Gbs(fvY`E0vh?P81;MRPcg zdYXI*C90)V^*&KjLUp!+C#2W(-g7$cIqdJ5#{nw;FJ%$6NNFWQw8r&Z-n<}{mWRh9 z&RG$_oLO^H{uWmRN39i&Q(SEv*E`3$w}dF4bD`%f4`$0`zRxwS$P z0ZXF=9C{|~mO_k)hrI}VLQKTy3Aa6$TSwbyT4!mx;;)?m03ZNKL_t)Y^wVu4rl)l$ z`iBosGsi*n_QNRogKeXqAK2Oet3Xu0qnGm0LzYGTw`>SfmKCWFhQ1n)Om+3e3IZva zv%W#0&fAb@>n#*j&Iv)beh&4~AyKMpPvX%sK8hAUMtL}MDNG?T&5{>T>c&9eA-U=l zq+;>9V4P>O>R3^*)#hwWCYOjY37rEaoFMfWWzoifwJ6i!+7;GXtWr345+!8T_y}#x zRhN)y8%^K$ct0}?C!jD*W6e!m)RNETzOFEorIJ~Oq)I=hG81BPra2m|^cKpe+325^lHXaQ9^TyU{$t-a{B`$@X*BC(dAskL%I8mrEj^rlL$SDiU)F*dzesHIhqImu~= z948U`#L7}g^#BMp7eT(4j4_6F*RfiyY5Pv*L=`nI2B8k;8fhC{i)+_d*JGO&V{9$S zb6v3-thE?Z(e5S6_Nnb@x*lUJex5k&pEw-$jKf4oB6>1L%uA+zXbpCeP%p1p<7k|z z^AKriscO*HnVKTCv~n74%$c!JO8$u0TU|DXmmcTJ2q9hyVJ!cmGYQfd8fk z!0*3$%m4h}{{{d1|M|D$deuBCiiJ{g&bH*-16@qnc^`}qarr?NrAQWDV{y)6mR$QR z{hwiG)ivz4G6-5w*d>e4{`TsEmoHypo#nf4zu}*M`&-_9xF>}8Ow`TKP>KA}1e_`v zwpIWmbIcrv#C{YYs5OdBFMl@7nPEy&!Y;f$wS;6s$?9xrT~>(a7rK&dRCU0u`j(5W zn1&vYfv4jvoWhi9IVpos(D)D;#=tm5e5jNAMI2KRVD6mUD=pMA>j+V9{<%Uv!rAFp z)p@om1*>&fvIa|qo|H4H+tlxSfupQ@Qz0qlyj9S;&Q#VCfU@o^yR~DtY3LeLgGc0h zi1|5F(U@n3!7@__QNl!~y2PIwrY(z~ zKn{)NcPFY-Ycx&Q(>6W1WR8a??(W|6^z_6yPvn$Pi)hX1+6Jmx@yMZQt!BLzEd6%7 zqH#ui7+IW$LUDFtug-x|l1SgJtL=gOEIG;cAs1BL6eyI^)*9nvFg`iwPV2rO?jMi) z@6`bS@P}{2#Ps(4Q*51mP%3HfeGW0|m~t0W>b#FG#%NNKsgp6N##y>nvi-CcHoaC6 zs}g-{xY%vjU0kqUZ|M6Dr8IL8d+d6%q3;_`PY-3kC}I`x>#Ifye? z9r+R!=8Pid!Z?Zh?>Go?XWbe4&Jt5$e+rB~RbYnj*a$0ueV>ft7Hp>^k2_Y%}f zwOJPhUF*2M-0|s~SG<1pg57$B)dh+$BD&VH?qyY)q9^)EUW3MAZ7Xe1io&Ewl5|yN z=2|IKW36f0R(D;Ot+gku)zMhgj&{f#z>aE(pC~{CQqXcWo2pGo{NiX+J4PEN6_E!co-Q@BaerHKYaBq6wm#` zo`?N-7WNpUFlnLJh{EiA`)9>4EB2>wwzP&Q+JI7E-5D;o4Xs-uxnz@Itq6wt8uY0Z z=Xt>7Kg!R`nH*r&G8o*hT5c~Jw(ExN+L3eO?&-w09|mF+c<9oy%s$h#{tOKfzr73~ zQieGubd)5ZlAjUjvX3qlqp>BQZ>-iSG4s@k{gWu*Fj`{7yG9eUp$}4e``VHyCCbWm zXC#fNHMEVcvfzb&WNJvtQVvV|Bh(-{Y>ZYYr>c)Yo%0bFlF-=)an{vw_AP`M`R?7G z_3AzSs%N`tIh{@nr-M9{s}8FRUV(Kjxxb{iH6eP!c&KU1mabdXRs+2ESUcB^gXkAx zd?NXQ;EzI(&Z&Oy^164eWw&WquNrdB?2j|Y!IQI8dh5>c@@C7c*Pjr=%-e4*_B#RpG1DrguC28{)W+VWRNnV(^B(xe z@9hEb>)(6}aQxwCm;bqM9Yx8=#~7o#uF*=dOEES|m12xmT3fVf(AJW3VDe(}38_Qd zhRx**F0WrR`Km-oaE_;AV3^`L z)FWlN9WS?z%dI;n56NbruD2RpVVrUxXeGdovxfZ)!jy+$(^+mV8m_jowo5VaFwERN z4Du!_;_Y8B+lN8cM6$*!nCh3f*g6^)n0%mQVIA7~A#f6fs)N+I_R_0Pwkg&~7Q#3s zPIZ{L{C#5-t<}tRZ8rxoE*Yy?cbeVG(s$-OV{lf~iLRytFBBp9*~HL8r3UE*>n?@| zj27`%h(Z)f^D}AL)Zwg88XH9>975)Bn)&kU_c*Khr z)_b-z3fm}!ivd$oGFoetuDgF_Bt~nI@}e=Wr{BI{eenu2o#^^4P3vj^XkeUWio6W5 z>_-nqsQ;Gz^>hC&L#|9ry23?N9r_tAw~nh#L*E)<2O3T1%sC+_r9!l@st;aDGC9vR zdP^y=N~5iij9%Y#ytr&=oF>M?;WYDj@a&IO@az$?1e^6F;I^~H+5 z(MpfDgtGQ=VQhw!GK+? z-8nOH0eLJauax9rpXMYh%38t?KI0mLb#ibyXRB_Ykh7@cv=(wvwyH{uIite+M*8d4 z$<|;PBM(ml|NP}!rfHH?q+D=~1MSE;GM%0Xv0&N@+RY8t^?>5|@HOS(TU>Wdz%fpd zVHAo`@Sao@K13cL?)mQ9uQ@z@z!16GwE~fyC4R1{mSt1yL_7iLPu{G*T zqt!QWACHeWS8MJbPT$W10N}TOxIg{mi&uZU+jMQzd7Ft>4s)S#ZPI96$&;miD6Mfu z=L*mjF)HfYzOgRdpLJOF*)u<9G8$wMUoH`ZWlsHG?kHA;yhF4ke#QsSEYtkSkd zv0FK|y`%5US>d&4@^giK=DIdplub+Zsw>%d3C?Jo;^v~^PLM+uOXy{sd<_DGv3sDWEVr4Lyifk-Wsp>$P zuBTL(LOJ^m8fR#mOdk!cD_pGIS?1e1p%HbJDr}58A3{ngOceWWDgrFM-1OXB?YOwy z&^Sf#GbvA$C{bvkQbGg?rp{4lqSY|;eUEkG`228x;9)=V;qip`f!(HMyY3_l!uDj9 z2-Ar)-Glv#c74nG>Qhk&de6g$ubJaNF$K-T-pkN+^5-7Epcu!Ir~RJcbfU3_7uT0) ztvQ@#PQwHR)~lAb(ab)c2crwdOe;w+^7Dz&E5>2Kdryoq+$$y1xKyb`%P=ZYq9^7^ z3<*`T0A!M(_%jq&rCjhnGLBQzSbgQ3`9a&5A9t<&!}aCr4|flz$M0&%{R8dHmC-bL(S%pYsk0*TX}bp3uFJR zT{XOZc}de)?(d%P760Vy^FS$Q&OsRXjIR&x(!15nD|FS@cdbmjZ5?psj|Nx%bEyWQXLq2e;bgbpIKhEKJP#wyl8E~e5VRnrb1_m5uUbQEp`<{lt0IN4 z2HHkea*H12%>S#^Q*$OF1x{1s>F7C4Q4S}o+jz2&%gVc`-cPjVJ2r081?kBQbbFkd>p=LZME%NNZDa39&E? zlWCmptzErX_1zbK6Fy6+d|GmTde~3pdwT%<-EYLl@aup4{r-RWtDimC5blanN2PR( zQI#lrA(c`Dqj8O+X@vTb9wt2+O+83{+82ls(uj- zB$4ZyhPK_X-rlg@UQ=@B@!jv)?;p8;{~h-a2flf?=exU+`@I*uddO!J&$2CAv=jml z_4JM6<%=7Xe$D7TF+|xw`H9EJJ$DaB?jDci6uI2?tojzEG~+O_Kb*)h2-p^J35tF| z(-~08&~}|bX`4)l2gW%NVmgzYHKpHza>#w{g6Abr_Oo<0rd(yR`YbKAwVaNL$|m61#;cxHf5IEkXP2qcnj90} zXM9C|DIjE7Up^iK$1&6(5}AUAv^etQoj=Zrhl7_&#%h#7ranWgwu?3r}@-RK;DWYT>)OQ_y-?H88 z=vJ4cIHU5!{oMzgHC$Y5xVgS!x7*URYnpz?_VOkD`hw~B!2R8Kynp)#KHS~&_;loM zKk@E<;^F9-eXc`CSqJJ`dKsfIt;Xs?3Nyp$iE^{%_V${l+mKTrdO^pJ*DDUg%>Cnu zhsP(O8}$~~we(#hM60Us9IaxWqa1FHs}+@@Z5z5(PnTp9Aw%r&5o=*dOP2C3<)Tt9 zx}X}@blZ)wmno&)H2WLiU&jH^Hf^>lC#_YEG3H^KrB5mn;oVq8DIF;W{9Kq_!H*5m zcg(R6rW37GthzPZ?OIf3F`T2R#6nwp>QtDjQN`#*(kqX!G19NE8nFzsz$hlUMOUpk z$7huS$4NvfU9+IZr1U=y5+lA06&KBcs_|m$-kuTHi)$}@l)$UY5(}QuN)nLIntZM3 zIxC-}4!%OlXS0uJ9AvIA%`)9zdg+)7$5BYcA09oEuQQLz!v<9=90^H%JbE7XffzGg zXYi?<`GpI7L@VJ3+R6~vt}L&vIySv*D7rfT&_>jg65^q%P^Tf|nC2|WMm0XnXhp0o zkR&1Jnq2_oKo}puc3fX>`N@xd!2ad}Z7kc}6_-~xY_=EJc8zVeG^WUXH3hzI>XV^dBv}e_3UccDl=W9-<1F9s{0YXT1JEcX?W(9NJID;{URVU;tPV&8r z2us&AB*L35fjsB-E@ACKm0O;DH8m&sn9F9j7LSj({ zmSX8+!#vOEJfk~B>_jdplVWk{t=Frwi*OuAj>jXDkAlXkEcp<{mOEBkZQ~S86|Wlu zMhlOwaT@RC#)pKKXhK@6=^H_ol_~OclpE7(g>Igs#D_T%LOC1lRSmZ28qJHVmfMT= zOc083iQmpVXJCGG80e+aSa^Kuyi&}ioPF}9_K>-h`p_3nW8hSSNMn+Okv`297>gQ zQj&8rKEwH+xZD47^$j)#f;;Yf_}tmh9QGt?OH$){?5F~k~gZM0^y zcC33RVw>8}Q>4#cZg?RK302rR833kw>-q}6SR}@hWv4Lp=DylCytrstb^1KrKMax4 zM=DMLU3bknKf^Dn?!yp8Np?5|K0Hp0qj`R4l)@Tu`o$RQfKPDa%P?`A6Q?1c@nqt$ zsKT7ua_Bn9Oh!URH!CX<>b0#|EWa8>(b7WYEE@MEu6)(oGiO03k;^J=2qAFX-!UBS zX;)W(Ar~XBWs<|Ll=4hMuC0-=4r6-S^)=1vhA=)7#wT3U(`|3r+kk|Y^kOWEnzH6b(J#|EiG8zS}rzH#q3s&buVHkk?6{rsO@*GuRg**X4_j}JnEf|)7kj5Icky|;$be8)H`dn9^0GOgsdCB9G`N*>I zXxtx1gmrDbnNI;9<>zotxc$Nd)KZxs!WU;`Vy&u(DdmLHRo$ix(>QWEKC-=@Dx1wL z@QZrW)!*eLH)F}5wZ(QD+Vu_H=0*mq^HHoZ$)if7X?kq4mLaZb$T?6#0KC|OD-V5P z7A_DIN=+Ru>Wousoo2l6y<943B2{9^RuF0BY zRx?H!e1LJB(fUB&Ixe@CPCIg(P}u{8aR?j^12HABW}-1xQ&cA9bOv7JqGWYv6n$sd zts5F^cs$OP54ebU3Z@ZJO;a(}qT`kb?*15f+I7f?5nLnXg;A($iz2=H0x6X&!B~4}&VGh^|#BCA5l^s0u3;N9jhirf z0Bx$qKn9Fr^{h8r(d1gr9>-9*`aBzQGUvUzLezN+o;&7(Ml|$YwbM3M*S{x!p6c{| zAp(o&Mg%)nt17Z7IFoD1sLuWTqWm-Z*%loWvO%Z@oKV+ei%vio4CUOSEh)jmD=<|R zxR`>dQC%ZSdz2n9#9tN;pdqg zM%n#`nSw%FF@?qX#B{nNOixu!+M|uZb!(Jq&u+(5U5Gg?bZ33`bTo}1x^jWEn3bwS zwP`Hmzhq5tkL(I8dfW#0$}Sm|~p^$pJ`^Y{S_XHBOTa-tW48^{VezpZ$-&_|aef z$6x;TSAX`ym;B>Dzx#e20RQ(t{GNaF(;r;t=zp}Ih9Bo#ei~!`e4N5|nu87XDqSEI zranm0#~}`>7zp#kJj-NQoKu+)5{?!Yj3R*MkG82Z(U%d1n-klzJq2n1?AcdRd{ZI?KgM z-pK1-bop}FND!yd3f0Ttb5Y!RU!JYOS`lMrt}~5g)-1mF+Ey+7d2K($cFZ}rWcjx< zl|tnGS%QpqTs(c?^2HZyFK^lIZaF=@XP&)i7jn(=RwAjjDw5|%hQ~iZxRjZOwl(fc z+BBst%DD4ZCr6JT5AqPZKnkP$-ijh-nE|AQZ$QB+RjtjE_@q$GRWqU#)$AneH%X;W z`0_W`X6+m)s7dR!w+iei;Nt-GkQKwB=ts^H@0gfUWEkdV9H+~s>weI-{rj8i%cp<$7k}daumAGp z-~HJaFZsvcz5D(g0RQ%9pZAn-GYsjCQu-$u^+kx`#s}YqTKgKKYj4YQMASl=fvWTO zoKA(D7!9k=a&yshv1w|=m`5wP-1NM> z*%3k}#mL@>0!u4J!C>8rc6E*G*M#(hYZ`Xjf@?ZXv*!K~nfyph>G@VIOYo+yr@oPW zdK8pcOcGjIyaU14k|D^AnU^cR?R$6U(SY6b2ZBl9OC&=8Dfii%Bp_CY+Iu4UP98a5m)qlQTZHCoqJKbET_*XyA5SJrVf-qA!`xpZ6a9g#BuQW7{x}Z zp=~Uib;r%sj+Za4dG+Q~u5Lf!a5!?Y96;aN001BWNklhF2j3^}jOE`KN>*Z^Hcsg(xM*Mgp#>i^5WplN`t0V6pBaerfX%2#ps$PIi zD?_DCFYpX`kTXw1;O=qee(z-+I@HX4f9=F@{Hqwemb!Rtd(fEl0n-Br7J`u zc}j`2>ucKe710j_Kj9{b*)U9r<0v62!aCHLRPo+2T{r_tVx=U9DE?Kkji&6$Z^m*@`qR8N)D2{|~V0>TtDlv~45Xf>n>phL8*?sWUSoB$(=< z6H~_7Dj6XyEeA@N!zw*v)!hgQ~JfvRs7|z|L~hX{lQEA z>+j$F%O3#aG%1vJ&e`5Mw+S)!P)tc#DXogNMmcLLKtWDn4Cm6nb3w_G@$|$r94R@_HVUf+oBgn#@iCrX{9NF1KcW@*5I7!ZQce|j zEvva<9Qo$!Z%HYUQf9qsS#NK-xO&AH8aC_iB&*Lam~ENf_pM>GTBtadi%o-bhW#<{ zWqU$v#WW`w$~Bsp3WqU}=R~aWUe7-H1^7|Ucr#I*8MZ6oD9)7|(Aan;`KDaX`GZD3 zXAt^WszOo@*oDF?7HNHks4k^_TL*nPt7@Wprs)_Z8vv_8H5$so$OF~M>(i}vY%Xqb zt|Ntk^Sgk)8#muZfKs2Po<3AuL9dUv4hR&>LW zFdc}if#?UO<2%Cih|`Gp$?EeaX4AJ^U#@v|yXEG3!*;i#X?vJ6#s-Q~(h3!6*-odC zX%o1XN-MuadA5k47;^ue==vWkh7Y} zC(Nv%C^-P?T1kXg1y5iM~3obS-#+ow+VVEMr=y^H}j5Q59c(Du%d0A*o#t5ce6{&i? zw~RRzAClT125Zb?rxY(%eHXQ2Y#X=VZTtOauPz_Hdi!|z7d-%8UibX|+r#0{f7~9e z)1_@}5&tvify*Lr&`NIVQYYfMNKRktYEFHfHiuM*A;T1SJPbHz7)DRiJaRZ5`R?5Z zp7sY~h-gzVMJC#I?PTX3GlwzOu*@Qq-XsIA1>N-O#U+38*&Eun;ltenDcx~A4U`la z_IK!fB>9O~mzvw%B`C`j6n9Ue4bLf@6?riWPJ5c8ti61_MU_ODN!Gx^!^>wtsMgQh zizVPwDJ2O<)d^^gLRW-&sY=5+N)=;_CY8)^tTE!La2RD3xlHq^xGQU)Lr>v(VXMDk#i9|aU2?Q~A#roPQ*V3*p=~h>0+oH5X+Xn4g;ye(hC!#-zp2T}XOlJn+Gc}pBiE7zE z#0;*w^sHXk5i)&Wb(Y&*_=2sl()5X2qW^cZW|Y}dSbdBgpu4_qH7+OFm1 zYR8M43$Au6oK+0t#N&SC-TjHT9}c|#aOCN5V)pU;yJ#Hbtm|v2s_99Q3Y10@T1U!B zrBv`fs;8%;QPAhz`bFE?A1nCatoiok&HC-Cw}*fH-G_g<1K{2LSa;>kv27aVT!Rm@ z-14P7^VXab;;)}cDN#}ub)A)1>87Hr7YAL+g<%Z5zuR*Acc_Jr|(TNlX;ylw@#qOq~ z>pGlk@yYP^VdCrW43AGoLI}(u@vs-s&}QXmtU5dLbhR6oGe2-~E{gh48-+o13#(4% z1hY@fb!|9@g0u4Q#gvH=e0|X6X9uk`rNlE$SR95GR9Z1!opF`)LnROw4nyEDrn5S6 zk?D#WQ{vJERklcvrFzmvW353OClqD>#PQ+C@T4ld#pB13lBE?>_2*r6;+pKbmi6|E z%NIXnySrgJePEs@{Cq@}DCxl!9;3BJ87mn1aN_jv2U3_Qy61R!Ps-Dbm^o+i*T;b)8dOU2J&u@|HKBe8%nVE7t23?dk&C^fHSu4c+Eel!aKn_~DV9 zBgf-_(u%I@=(-kd93e#>4b2HgOed34Qp<^KjHBy%oU^EsWj|b3X-lU3V!Uac5!i=ygrqo)fx~e+^XjbvYpJ_r zbMArHz2#!t3H|jkN)MbojTOe81^TX$m?>jvyPoaEHS5imVH`x&<`Yh5iS)Kb!b@s+ zC`IxGH?87&Yav-qqp151qbD6B$1%}0R{H27`2hu0@#5kG?;DvN?AETzk);x_S}LEp zih9I`8%RmGe;*rmWO!udcCSL7lq8SQCU3(V6?`E8SgzQimX^}-FSAnX)W%;#yJYG+FWt_>QgRm|Af`< z7VR9v{vC0C!l(>!B*lr^f1C*l(T|M#w*)^@?3NGjzvKSy9ey6sMz$fPfJt&NhNNl| zQ)FKSKaF!NA$<#)eY4&0;^iA&z5blb>z6cbi*+r=wkXq}Ypc`dh|-2nK1*1gIUSGq zd19PqhADFJ5lUjeANX+h$osoJkNb&X^2Au`=7k!o&e`}STM0Q(F)b!(3Wi)1dXCIK zst^Lx95Bbx8O>JFy|#wWol&1?cnQ4y7drrc_tks;-GBF^*W2yxs%g7xKTq2jQiv+aip@UY~f>R?MTdns|7wx{dXH0_#1%hO4$va1GKCqkWtxqq7C zS#dUnjQ3uQH&sZo>ST~)oq#vGPKG;;Q_Qnu0HWlOvgTP}V~wi1`C6(bX^E_XImqp` z3E3RLC!TRbAO}nAw#A)fk<(F5Q={PoXQt5tv1Hq9mE+mzEb=VT>nQ7Ls6kqBY8v<-$9 zr82>Xic*qrOgh8GcEt}qd&BPf4R7y`><=eSr&CQ17Jl8;*0EVNbd9b|ekn~uDuhwc z%bS&@?^bNK7iiOPIE~!jKe9iZu&$H-InGRzg;0fWMa`n?wEts$OCJU*0j z`j54i+bhG>g{iypiXqpC(k&+*LOcskYO5!{@VQ2eRc%4a3Y4aAt4PGe^8<`}o~4|n z#A(SqkQOQ?O&%gXs55=1)W=wYJ&{`_)vu>=J$$Q+uC5JComZstoUedVG|tiWJ=S%s zwwJ7S*N{e8lUXBQKMUYwNf|oNf3&PVSN)dV)hBE(Kc!n;qP3%2U$ega6n}b<-FUY_ zH!F!Dt7KzPG~JGV_nPD3k%zmlc>nfGj{8SSjyR{Wb(mafyBL#EK}k+TuB}rRhp4n> zqSY9Nk#QWz)q|i-kG77IB7S}%hZ#TaNpX~)sU+6xEo`n(rs4gEw?sd2*gs;e3~a5f z7l2iGt0<+0t=RvExHsvQEJ@Sz9y2?3W}ogDV`dh!s|Pd*ih>9&Bxt9N{ieny+Lu;U)dJ+pdID4>8SMBM9c$Ikb?@AE{!?D>#7J8WV)P@*!8lO?De z7bGFHlkq8jrj7N&TAx@iDlO!ll1B2yXO8E_Uq(P|@;J!Q45xxT$;esxbf#LoV#jM2$O zrJ0p_it&ocFnoTewe-gpbeMdizY&RPoA3mY; zn%#Ddv*s&vZ`vQnjy4!$8K76H$;Ju@ruKt2EML4Ru zqHrYMQ1T+Do~0-mNL94uj>gjtu|?^pr$2nn4s@ftWFLx5T?UU$Z|R3vU@Fq-XO}9N z{D4x#%hx5$lqKZT20=(cGW|Q_hjc110a;P9yt+Z>6?wTLE#{bZ8X8W*SD^(y324uh z=!)5Ox*{vV3 zV|$sVi{BiQXC8!2;P#U`E(jfnAivLi1h?F(3=tGB_jCCaPJIO)#|+JjW?@vheZfM;=h`pyiP&M z^A{fD0%;n(f>A6IWI$vHxs+1erK!Bp+Ft`-{`Ja0LX_5wbMMBPwKj9!PdzsR!HeK6 z-dVgeC>is#&O4NXI*oA7_#Us3N;6nE9ZwA1iBx%Rml=yHrss-Gp`@DDhVfl{7#*8^ zEd9)@g4NB6KYahUy#4O)SX|v=j76xFhsS3=e12rJJ@LaY4~)jMSj_0!mO2M-Vu3yo zE|!_mc$&e{PH8hcVX$=~ao%B#C6S&)N<=Wxayv7Z+9AR=BKCXw;KW|Z1-muRHMh$cl*;uv zR5KB8i3oKKR0V{fr&owLfIasXl#H1HW8%*_Nh^x_8krP~W~6Hy`o6;&J3Z-Dym4qn zioiRA_ZA5xD#Y5WlBgs_rzJAU2q93d!qkrQ6pPoS#R8$!1cr44Z?Iz<DKu{Aj>5^h%+udYh2R|Qwgnj+6>d&72jq8kjKKR+|8ej!aWR9d6b zz|fwsrbPsUGYxo0Ap}b2cxN%DWq&xZKO7jx9)ZWZD0VSp9QvKZR}mm9rzd`lzC|&J zKnVX8oT6gmG{}@ZFBt~IXe?T5RH6_r2oC|Fw3NCQ!rdf^yeYD@1bBV7;>*+aU!x5e zX4cx7v!)u2Nt|;sT4}wAzzZ8;pCX{713!Xylv%>nGN;Pal#f>Qz2WKc38~f`4?DCp ztQHaCQ0EDGmSS9>-8**2kloz>D9w4bQ`{M9S%af_xHSdd~%s27<=wjdB6sZ z_XoP}M0tP8sVYdi1`nW%UZkV#zesT3h~tW1|zs3eQ?qO?FJ z+0@fF@e1A_V!mKJQsgPi<$~p6#&)-37)H7wt~L8<*lMOPRH`M*dCIG+g4U1$|4 z&9fwl#HHNEz4x)c z?wrH8>FI6#CG6$B$9XwLtHW2xsFas7S>zu`QXxpwge=QQharMRlZ4T`2?Y_Pl&VOi zymGi3gm{%_>Ca!Dw(c)_1Nh(mm;cBx*rh$U^6-E7In(q z^^*Jh*DSAJQB*6uGmJyaVf(~pvu1zjI5q|);*?nHD8_I`PBUA zTU{jFEOM@wIb{|>p!-8h+dI-UC6Q2?q}S;_?;Sqw>J zSjs7GEd(NXAB=GlA+kj4g;4G`PwndM{qpLEU!R`;q6a|Rw&k1GxBtOg^Ik~##)U95 z#%W`m@b2uQkNayM0;4jNnW8RIt`;?~U%le)_6j9Dc5G>yBd1dn4-4Zc3q_Wsq^Y9F z3yQJ^sc5%*wuh13$sh<*9zS7TXDk*q^=wX(76_qn!E!h>eE9gl$Is6kPCWv_d{*%4 zX2I2>KoO_T{x@0iak@%Zg{CewS(+lGyr{TSts=0*gbSb|PbEReC!w8exYh}}@oVy{ z%%kDn$w?i;SwO zNVI^lyJ)!k!Lx4+Wv&=aGF6OY!cR^{<9I8G`~Dcl`pPSCE=Go(i}{8xq36_F%56uc z$-JG&0NGYs9H zw88cVf;|yjyhRA5vEw+s3XFv5OP5Z?tWz5->ahiW68%ROxCjP({L`&bhz4 z;`N(%ES5{$c%(fT#xbENau5khjbu7DrnJ^k9i7+gP6N-op3QN<7#~Fz6SFzqgb~g5e%S8R$^R^R2R7r6OBV}nql1^*3siW?#jfCA|h7KXV_s(XN zvn%Gy>j@v`sfv`>_e(;M+}zx@3;QFxan7zATZHMHGJw zHoiifqsPev47qIH17N@I(wz$&P9{Q3Qx#*rN-`$mqC}SyD={$x)|LoWlGRt}w4|87 zrdYnCSiC{$a!T68_YfZf-bVA!^XEVF@yGv{&GQF@ZK<+ARb`a36?t_#{kfX&hFJZ}!a?*Z^X|BrvKs)Dy> zXx_-I{9Y#dd*{Q=Fxp}mtTHYL??XVG7045tB8ffx*{ou@x}u&hQA*SHJ$>Jk>Xdr6 ziVeBGLHd?F6%=_%Ue*||cv_!$Tp#H=J6-hzd8Wy;jJ&8xvWmm$#OLRKqUkK#-JT!* z{4f0a`I*r;@-)(dszTHEJ$4!_?M|`YSr>{~r6-DxB1uvP<5}-Iw)>t$1!S2_?|Xg< zl_XOZpE!`RVdBljP>&CBH59>*anR$v<8<7!dDc{AhR#yT*$p}^aW+0_y7m+!uck*P zB~?}N_RVXqudfgSZf@@>iWzOQBQI-a%a)}0jQQ~+ZPPN09;Ms`KjmDk13Ry#DRd+T z4!tWYRar2b)znoTAu}q$%N$)^vAnuP3x`$` zm1qX@h4psJ;n?DWB(I*xiLj_b#%Ir)!|=P`0A`g| zX6)vkaIaJUjT_CYw(DnY*Q^V2U6talCj zL&I*jV;BaOvkV~x%Q{0zSnu2EUgkM^yxjx%_JdDP%KN{BiIPE^?56<)+CRDid z0XsU{-o^t!pGBn}t<>c}IQIgqbsSHpc&%I3TwULh<}=F08$t*i_AfN+4Iy}HFHthy z99F9Z9!cM}^nK4b4CF<@cYpPFyblTG>`#ot$j47#kit!@Jb&T-H@#z4W>i&9nFpkB z%*v=pmqOByog&+R(FZ}$|545Kvi+N-LS~KCZ^qhJr>AIf7 zspr&2?!g)E5uJR$SqEMkkbzWds`-NJ>pSYYidL#DB~5dZtV9=Aq}2^+UV`nAGN6)_ z(FWGrBinsX(|b1i7J2CT`1y(F^?^e-P71qtql@qTQ(IDewL2AAv@b`+*jGf_Xk9Ew zX^Zy;EkWiPRs@pXT|PsCuQX|6o#=;=ZXDCpm?gpAX|1job+&wb`ENr(zsmvOycfpU zLI^RFqg{-nD^E?M`+gLovBFt5*;pbvT8OW_e(M6K*7CI8acsJXjv5Z!T~*AglAD_) zD#>Yb7#o3LB$04xdmbOxJgpBjUBrdyBtZx{g(c$CX}jC;>B}>J{_!Kvn^?k7A~35` z7PI1_@ES(P%Qo(wvqZ)pvJesIIdS6Pyd|wtKdR6RXt?QWp%}iN4t|_AR4R zJiTmbPDkq5jPL*W_gvq;jcd#P#LMFyrr*;K!-XE)_7Mq|r3pouQq2}<84#i8W}a}f zEJ?GBV`KT{(}u@QN7MU>-wN{C5+_SH-r1ZZ^@WyS=f^A@Fht~-m+HE9+94b~Y< zv!gw2**t&X^RGYf^U6| z3}X~*5GDls#5z0^pPi3b<}}Tj&u3iSyyEWFTZ%kIhM4A*NkWq5WW|gmjVnH93`%Lr zYR+;saC5VxA1zX)Xr0k^1BX+~;ndT0c8W-cNzTdy`<$AOI`%xuJfWC`D=x%>+F<+z z9-F5I=PXhNl03&rLDQOeu>2hT8LiG8)IJ8L(cE=o8ivMU%URrtJ{~(kzMOoQVKz zonv?GIGlR45~NiU!4;khoA0df>IP5SM{Z%6MLu4bGVkXSO8kXRUx+aI1Cv;F9-XK2 zfiQe+-6<8H=usqUIOPL!y<_BO4vnYl2OdBFf|P>myPU&*%jWTC_UjJ-6hZ60STnLY zTAp5ZND(Njnk+9!6yQ4Q)N{K^S+5GZE^ap5uE$Lt#X>3;vx=M5fon{25_m;75CcRg{%a{kqCi?NL z&Z+C1vdXDvbFOYyTwULCd;gBb>Kf?>%y5`qLjqmbF}N+_)DeO~cuStAD4kO;uDE~o z8bN%YpD$M&Pa{?Nh)^%nVIJ$#N={q;iPI=#obVT^nh4Ud7N1PB7GuLyjgMHf^BPwt ziWE(nCKHJEELA!CC9D`m5&C{mV`Yj|Co3uCO`_y%InTuI*!{jYfZg$=%{a6Oc}R^v z2oYKla7u}woRCaIG#@6}ga8rF*T)eKfnn$)Mj20@C+rVByZwRc`2m7QxQ1DwNb;N{ z$tX%#E)CaByfTfGW8FGO+mCqQ*tCouUbYQQA0xQAj?vG4v>Z-7#w1fi&rO+n#cHN0 zGI?q25zeHRIL%Mgxkf5!Cwq{anp|ocJPl_Zw~nTuG>L;Y!Nll0$88b#U}FdbNVTEs zE$Zn+{%KEDeZX4FIQFcru1PF6bTse~@qsTR{?&iFIb4^vxsb{meRlxK3yyfH5BOjj{n%0sgF;9@Ddiq&= z@;v2cH7C(2QcCJvP-gLl=Q%qW1odpeY;ld!Is5G+kDq_y2)?i>I|J|bRrpjtg`FL z=*$GsJ$oBQDHx5F&iPcNa;}uR)=9DikzFk+yV*Ct-vO}R9eWYnQA+jXL-k^3rK1b zo$~k~*lZ7+x{)xk>5Oq4PCdhJ;Ndx1gy&^KU8PtPS2AsHCo6HJ(xf`lda67Qi~7;h z4Hjdoou{v;tnPX2Ft}>l1P9VgIVYECwZ%FhHjQxpuAsG52-r7r| zuNz|Hk4f}#eoD^gGnQ9(RP~HhNBh$H@XW6dM;_M=2zY%{aJ?+Z(v)^EoSK0=OS!#S zvRW=Z`5&4~%c+k2)+eI6cF@92`MJ(FxG{#}u=r6LG&tEtkTk5*t&HWu!RgtD8Ix9gYR8>t`=5);()1O#e z&-m-_-_f3qjAPHIrvs;U#7!{R-zw_j?;%WZ5|7pi^E#)hXN(56`xD1wOPVDVSx%N0 zD4mkHfE0d0n#s$G*H4x5`2F(1IT9gMrBre)m0E(BZT3y`yWRjEpAU9XXCJdP+y$Tf znkex_Dg8JPjA-`s|&mDC_^!iy3zK`6!j}Ke6`y*Kb*NYq%1S_AC zmN%>xOR~Ho5f&X?hN{T9Syoh~qRLZ> zJodA-R#CQV7)zoh?J)7?m$0`ljAO;#IjT}8pvnA^1N&L@Zkgh<)8nV&tJZ< zKX%ihG_6M!EUJ_@*9Et$oJ1-1jpJ$Cb2vrh_Avcy&EztS?a}zZI~Oi1*5y3s&HajR zzWs*pzW+PstJ`=enIYc1yhY+sIz_0A_ITj=<-q5MXS%k*3>C9nvRo~2reo|?Gz4{f z@Ubj3^bKxoSuIMwd3VERvtbzH=fzr&l2a*ZQh#|LYwnTu1Tu-ai|gf#EH79sYBswa z5VvDRS%WUoHbQL!KDHvKh)RFhD@MvXO@7U{D9}_ZCu?5AtyDtn2Mh<@*6^o(;5>dEt!jTPz6;H zyZqKO?c%xAnuUyizUv*miQ%M7#~X#WBSUwf&gcB``)?Sm;&9j_yrHUUdgJ-!)1F^H zKC|ApjK)qAX-}CemNU()NHAl^^V1_;+aT-}d2&OwxZ(Y~cXZvzZg+?^?8$QEJv4)7 zcj)lmb7%~U*$xOC+mW`5Akr+2Gm=b8j>neGz9q<%=k=cTW=Gd`IOp)*Pp^lbL@8GD zl=pW9cUJ{Pmd17OZs5b015cX<>)eIqXZ=@bs#bE!iAbs<;cA|9bG_pB?hUi$EmCD1 zk53%84-o9ce^?-8JkZvg9iP5D@Uq^6H>6sy+ifWxKcaO;Ud=ImL*Hz1<0(EUykNUK zkmX|>F4r0NH#M`Wh&KQN&KlZor0K>BR=$~D9i@`=qeb9Y&P!%>&b-ptASucjd0yaE zhR&jZ)j1#AfD_#{f?m`FWR-X?WI$#CG52sCpw6>2>4(w&?n%JSzU$xK)h}6^?225s zN+otQ(F_~YO=rektk)_5c^c_I1g5}Dn1B@VOE!!#`sjS52*vnsM%NAOc6;0y1*3zB z6X$c-B2Gu+4tO<7dG~6`AHI3bySMkT(JmxKo)cV)vjaLUDC=wL)f=QP=*_Pj+n?AR z4aQisRvbHvG11C<)_5x!*En(NAFp_kwlnbqMi)an;wx0+9L0^qpLi_~XDO$hRN%3& zM?W}DUHtO9>HkM-Ns-3)WA7ZZI_K){8d7T%FC~mNb}Ez-^kaO*h_&qa zbaE~}p?ud7V;MS&WO@f%drN;nSaadH8@zByZpUk-VJaNjV$`K7D@R^Oq;~hZ8!H z6oaMfE!*vuH2cWP-bCw^9UyqpG{+2*$LAf+xmbj!fv3%p z?O~wpr^Cy|Sw=IJyl%Z?UKQjz!OIMh6a=9#h-qD(Vjc8@iGBefNfMM&lfIpZ4zo@Z zLhW6c2OsJ@mAW7J{SSc2L^Gy|>UE-x57x^m^BMt`3K{$~Ar^=U(N$zALdeK;H+~92 z#8qA*0$L|ruV%cyyW(oOBvA>6Q$ySJq&h*S6-t*R>IlN%OuTj#nPOgNeEWLA_kVcH zci(=)tS)2RGEq3wGqeGrl1m=J`M_a!;FnJi{QPml_AsDT`~W-GMZQ0QS)oZ&$fhA- zn7ngJs!NpBIZrdS2G3LR!Nm2OpI{ujlZmZ6ALypMcn}f#A*Uco*SpAvn>>bDBAHb= zi}{?Zt81>WZ^`nUW@uxZu3liQVRtxjIJOtZoS$gJ<)j`5!C*b9b(At7u(Vyrq3Liu z@bdh~)5C|@@*ARz^o*=BQ@%Z-v?Rv4i7*_;nQ5w+RXJKK`hL8$HKPq!{HE3|FNfd$ zWNlbBJ6d-b}^xW8F&wOUbRDPy-~`xNNg zmi_ZbcAE#1tm5`{Ac&NH7XSz zbp3$0{S=X&NKoV1H7U?ZLZTE7fpbm_!zjjaOq2|{51|f(GQb?@{vro}PPEfHaZ*Yz z;;df;B6tDiadtZW2(dk_66$(Jnx%-{F}_<*iYp-?&lB!$=6v`5HTQQ*(mbQ>I!?_V z5j<5@fhxGYJ90SeG1f2&PpTEmdB(f@CI9BT*SvfG4OLm;-56gtLbS=Mw2X{+({tE< zp?`kn%kznU{{MdA^Wz$VBiBi+0Z($!sz}JvxGGdq&})Yef+9J2-rkX=n%#Db#BhHVOH(n0XvrqYr*(nNVWjP2H2G>#5^T@&!$%&yXT9F= zvfeXH8x|j8g*Q<#95uSg2pC6)(F&EF*@TkitmK>bugLS1FOO@s+Z|aF^A7?jvUp9; z&ZOex>+gJCX_T69-T@Nh@j1+@3<=bEl&7>qY=Ev0Bcq8AlSQ5I`fka0-@f7fyEiPa zZje&Z9@h+Ai&B9sODFRX98WFJ&(Hkw>nA>aS+hHQ70aB(tx2MzmhN~UO;hUGk|Zmk z9q3KR%jU@EFKe_4EaxTfURPXSEm&jj@x9A^Infg5W&X7>2$ReV>R_CprX50=bk@|HbOSX_ldM zhExiO;=~A@_==hyr(lp2l0;{$uJ4#tCEkDL)U*gOW#zTvdRg+#+gskec|}!bv~9=X zc;Iw8MPOr^ke73AZw@>^eqk5}q=b20@aksH`*-)ed-tBIo=4|g-;qvG&%C-O%PX8Y zv48oDnM9_XahES^k?DBt5?}d)N=UShPyfMrx<1N5+siz?1Jd5YT9IZsuV3BsZ~y*psH&RmU;d0S1}#Qrg}MMc&i(@9 z!W4dq^PWYmNwh-gEPna0SU1fSvV_7U=p?4+3tHje)`CdKmE+}dQa0?W>rFwrRZrJa%wW5WE@6&f;5YT zwb2Zmx)Z0)MnbX~=#A!ZXfR_`lqX3v2dOEt9SP13*+bVV;qyGP&ZhxVqILW)a{wed zN2htb3QLO=@#-Q(>}px(@y_EVfFds{Ztvf)m{oM$iT!RH8&CqOGU4v3;_d5OuCDI! z!O(AZY_}WwejrWaKfI_?@-(5yH1{_(i&?>HS#f){+rQ@fzxrF!EN65H zPtR*i^Aa-=T1-Ea3GnIN1RN0;2Vn@21yGhXc06I-$Y4f>!P1YBiZnVu%^%`nn@#4S zS*a;Ai4vY9NvW^jQ?1_8Y(6q}JE~dB`sJA~&(C~(*zx)EBTtV{G;Pml9nPtXZhU`i zao)3-8?=fk#3E10iWzA!Bh5-uoiMM9SVPY<@}i79K@p|4O2){0lB861!K=G#?q9#b zTT9m-K}eKR2$^7=<8W+wT%Xt-T88e3caFg+PDca5Qsya166r$`G8>12&bq1PI7koD z7^{L0Ne~x$`|p1MD5a%Ja;cOOiMB%NG)UzL)?GOBAp~R)2&pK`ipBDp#k^*@e4?rz zv1UYwD8am1l&qFZ@@gJeE+O*UbgDrJ%s8UQf#5BRS;6ep71viY$|9wzYU+B1H7&>8 zGscX}<~P*KJLXq!$%o5MJnkz?gkPrLbu1{BlPUsC4@x2v4nRZd-{lW@{A z9JdT+&F1+;*G8hv)B42z)ZyJE$P9b3;+ZVVS=KqCc`pf3i~*kP7;Kp41z3=ac$Ed7>ADiv1fN2rkb{Avp4J; zLpS(%cnEr zb_{yMywZ4=vEOZ2tnQdqH_TVpEEbD6yeu;EETJwk(o~b+aV8#2%XvjWkY_1XnK7SL z;2o*<2odK`{a|=`+3@hR;p3Mz+kFc@{ykiXHY%-PJ}YouMCYUpINx174n{coencR! z&Px}96d}mJ*a09UiI6IliB6TA)sx{vAG>0w5jO0aR z0~BRNnx+JA7}^8J{R_L@j_tnX(2Vrvt6)M9lUGHak>yN%^Z4w_CWJW?=g>|#?Rd@i z7YN50i5=yXg6nz8ywn^!8=)1>kshMsZ!qT?ZG@U8QbeO|7A2sGlvwL%dqeKQnvvtF z<#0Sj@+_X-#G6Q5j|H~-mLGq4AQ6uDua{`8xL#ExiK6QVW_3xD#Nf{1)W>{5ny{Ev z7@yGhBhJ~VH6OxdE>UHQx3>k~zN&fmdd0i9@3{Z=@3?*c@6pvY-El*E+~A!d5N|i9 zHf|xZR860Qs7Fr}bVKwV##E(ZZXH=sQI&Ue$7eP#4{Q!c9@br?{QAK57*~^m_?o13 zyb>ETGLAjgj*&M>KYU|r#r4&ad6{r~vp``fGw`MZ<>TvHrnz3t$+BYlyIJ=815!ZWwjd>WUSf@B zcWC(X6c2&6>&bNdTp%<`d>!Cg;%B9uyqAd@F~UtmX@@jcgqRSLe^DfucWws0a@OZQ z2<3$&1Tld?!xX6v7reBOJyfzRXR%sxwOr759mWjkG>I8`?>U|JG);%j=M zbhK@Q5b@oyynW4lafKZlf(tk|;0KFymNd=C^XTi75}X|wx)U#tANc&~SAPBQiC;c% z*&PS$lvpIh3h;6<=k5K9B!QtHX_^y4MA4?0dH?{U4K!Ue`AQLOKFLJKb>Zv#d?2F5 z_b0=t|Eld8C*Pl&x(At-=msHvY;jowGxm35x& zzTt;oJY9QYH7_WulB(3C8j3QS+V^J!yRPxu~zvmm5^1R;h@zW!l-65{K z#&{LVC+gC2o-wQE%&%TEU%f@=Gxoa;AAkJM9Cqu=5b)HR_#w{YEFn!*tj*@}v(OGB zr#3<}vOK|iPogwsy&!l)|M4tH^il#!wd~VOR_X2%M@jq5rp8>Sf1B=cE_G1k&Jx{!82dXQAy73aALPV#p0F_ zWIDdu3aN1!^6#SI^V$C!a}?2sZbpT)_xl!EH|R7)Dovh)vjY-4Ww8}QcjEcsSAO{OzwqPFpZM^w zWwY+-yrlVBH>3Q47Kd%x^T_+?qN>vT_AdbKE`g>ra2?KmX(Z&C7btdVAvW={dR$3E$hR;<2L60vs7NfFjWzUq=A49nyk8^Ufxfyc_U-H ziD)s~rn0nb&_QdV=0rv_szWs#9*DfP5* z@<>K25QD=7i9}U7r*!dergR3gh#tQA-r*BHTjhQ8x;*fRDFWs&jv^{YuK)ibm`r)J>C56@U*uwIar z(ZI6XJfeh)NG76E+(m$TLZr#2xLawd{|> z#YrE%2C){J$TOBJObyAnFYZUjV4xp7LfB{lY8^;Tni;wt#&Kk`?=L&_b8jFH(!x}n z@l!Q74$X{yRIoRO+QFd6*m^CR#+!6 zP7!3mUWAAbIk=Z6nGt`BT>9ev+Zq*IYa#MwgIM_TfHma|$_l&mC-m5F-M>#zrtudyVFRuZ@6m*mR{h!XKeSFp=BJJ zDKr$=ZPx7f2l8sc>h>K%COp6FnazGAeLm3iBTZ+f-&1m-3Jaj?2KKux%l#8$vm@9p zvIl%%wz!@GJ05}~O$4Xoj$=FU@VMdg^O2{`5rV&jxnj9Y;f2Hu9jR7aujb6=HQA&L z?|O@C;%rO`4I-I76Oo;HPTGp8V)5K$xwk2JlE#33Q+$G|W+ z%3NZd<W6V#~*)Tcj)=_ z=?hh^WB5ozU8Uq{&F!*8>jaNNh{!y6dRen?99`Sd_b1HIuqXvtx*|>Un4D9Vx`-eX zfNu04ELj29b#Tlcx&f zEDsM4q&gw^fv#&9#=tNdvU0`j>McU*xaMoOtanFVwk;o@wmd!`*dKdRE$~)doP=%y z=E{jx@y|j}_W%GO07*naRO`93f zQlJnbkwR!8$kcSB{qKGN{KG%}!vFN|zP-s(^(IO5x5kEV+J3k`9h}e9g^j&N%k0*J}=k14BR14=qjaW75n=w6>Ch>#Mldy1ltZ zVrUL~hS8Adf;3A3i|LP3=_6o5!s#&bxc-^Pr#0KnGsokJ-EpMt?WFi}m+p4l1xI^v zKSYqJRsktBS*qi}NqPF=Y@7|3dT*-bgl<;U^^BsLacCTVviz1=yp`!hP?tJp076U& zCMsHCPp#$98f+J(AA@mIKRh7ifKq{~k3kSORg^=BL&+qG@`+P#83Skusn!UoD2jq_ z-oNJiZ|}HXWSF64z2C8*;JbI zK{8JhzI%T|U03|@Q^CXIGrLodb)H3)B7`E(HASi}Wh*_cU?E&$$SxdF>LX*{u-iT| zuS-O51n;8dXM$0b)sk6NqLpCZ?&#Ys3QLhovM$P11{1pu&zp`slhk?2U<1d_(+`F; z6&w!@0fn_5ozJLOZ&7K985-8($oA0l@N(p7ePXlkrYN+UIDZnIfRag^Q)L>h1k1&Y z*=)}7c(}awNu`j&;t5mqc%{Ee8(2tf!Tq!1z%Qsh#Q1jO(63Q(3sr4xB8 zq`(G~OmpSJgCvgNw6 zG`}NUUKu)`20#Il$z)a5qz66dzu%J{WL9S}si2+;eU)oJq6XVKPD`xX0i}fYH{`R-Lx;~?Cw*2MKe-t=s%z2|r zUcLPd$?SrxSn=Vs871^))Zw{RW+_$Yy`z_U@6Ne!OS1?}#yQ zvPhYi3C8A}oL!R5JP!{KJlr*uWx?xLuQ|PZ!${7}=TGdOZaLH)O6^#!&-mu6w=9<{ z{`%ebeE4oyv(YUcBj+00Ys4b`-&?Z-f3MFM=}H8ic`aa)mDu-c*Af-JKl$Qc7Z zDAFt?wV-2z?>EF@Pi`E`nPpL?&mhmP7v<)|u0v@>nGchXqhYgan3s~^v|7x>=$6i~ z*&Le`1n1}n$K&IMhsQmKLr>F<6B(GvFr`Q%Xk$py3~Q|jdZr-Rw(S{*UebiDl>paK zF3!4csOyHd>lykHA5cb~3kA_?t#hqZsf{jfA1Y3k<|{lJi>LN=WSTYVH~)c(+L|M0+Sk^qFLQu4bv_4_#i!)D*`{?nGfzTfcO#~s_ftXGyZIc<*F9guFBJl55X-AD>5E)MGqX(L$A+r$7#!#80`CNEMT}UjC;RUx zgE1c%T%>A7MlVjtJj+;=mgOvyefa2}F=fJ3lmjSBHS;3j?DT{;UwuotJm=HrTYmiU zCsb&8_v)PUiz}9Aueg5wHC9FT+k2`*MO8KU_{94ke_(m~npbar$$W9j$=L;;e*7c# z{+F&apO;sBC2?C7NPa%Z!6*Fu1Emc8!}pL(O_w(zi3RykvEH#hY*b36m|b zNzP&S$nE`x{h>yu3(l_RynI>U#-81F$K8F8HYvsy7~4tk$>bI2N8vW+#~8OL`T`k( zDj9N?8MCqw*k|z40;M@IdWQM|s{)zzTwbhsvpb!_MclLW+xbA%dO~bTt}M$FAJ!0agO6e^;Jw*r!Oy|HToI&+4l|?9sQ^|T`yS9GrDfz?r}@o zj^vp*9qZOnwWACX$3Qm$JB3hWxjZX*b-5-_Ef3p0A3h)0HIr?a$sANBoGfx)T(0^0 z>#sO}`7LjM(evir4^)ruDKk%=XC$;d-TuH~zo*{aVd$6_hC{XIkAM7EocH|p5B~=* z-u{YzS^i&KU7qprZ~w+H{*`fbWLd$`*W7&gE4|Y^JwDL)?SIlu)Sct*sUiLGmcc33 z%Nbc}c>CrxMKNQxJSQ&}m?RUON20l{YO1pW)MU;$*Q&UKY zV;D!ec4S}m?Dl({57c!kMPX!x7#Vt5#Tg8#RnLLb!|25?{v@2e zd6{s!ES_&e;m~{XEaCcc#V_7nv6^Z2n|pSf2b>efo>oT>zOV(XO(yiV;o@|T(w6O^ zXR{yZ29IhT#%NAg8D}SRE>4$RoUO={$nE_T_fNH){8Kc&5Lm^$l7)%->Lg7l9@Aa5 z==qOHK;0-BhxIyTF)K(+r0-J_BLgSr15Gc(@Md_zyNWf1+s)>~}lvo(}AG2WGj%t1sp`+p6c& z$IrBl2w;kG&h@LWdGX>khsU2VTJvmE$3NPmN3?p49(%qrkGt>_p9=@a5d_aX(zQ zS##{Go+2w*%x4s3hUy(zmXIZqG`m_9ynT7b>+2;Z_SADJUCaN8zmtM^?uFeaV z%Qj#pr>O1=(qb*^sC-13lwH-b-E6skJn-@JJ$>JE zvdCF33+iU%P><{n9bNCpi~r#K{F3Nf>g_GJpWk!;@W`jz4R;S>3Q7~hYM!xPmf$8({uxMRg+k8Gp^0+`u_ARJL?*vsHm555v8W$=QYC?BwF3x7Wyj-xJS%$8Ya(?tw z?MT&()UB+|v{Il9uU{mbp3EtWLegUf$7(L2kcUQWt3_rhb3=@t$4x~y?5LWCyT^$! z7=`y&q=w#kLXatabn*+Cl?BU%#8g*(McuSg!h1O&vP3h_jX*Va0|ChhNT)f7*j{t2 z*64J`+qdsnpPcgf^Jo6}r|;SB5BSgsWoNRfzPMWP_Umt1U3|se{R4mcU;oO`Jdvgu zX_}*yW$0_#`ZG75Kk^^{{y+KKpZ`jI*s-fS_WM>+Xq{tUcetRYbs^Mk&&|yZfBd)q zo9*4-=-ZkPA3k#TxZ!czNc`7C+!;qFlH1WU%QdM@Nm9er*^0NX&pBI4e&T%fiWgt~ zj+4u8$YyJ7S`wUN=m$<79w|O-@NDUao_%QP`hmK(w2Ks@pzcPV_5=H>dydyq3T8#h zav^r^rW>c*d*U%5JjbpV0hIHigDCQp(nFdTBnG-xZriF6hc9mz2T?t{>=UT9f!K-?*5+Jk3Ucp1#vvE+irPyd}3cU3`0bt zDKkZxYsPU(CQ3A!75@TmAl05lu1Sq#G?cl;*pzO7G|N%S5TmFRjS)AhHwqWjbKIP? z-cg8bN@ZH9+!2z9{+Y1g!%%teI%7KdEQFiB2~ku#I>OH%6I@VISx|I_!xFw(R_M(zhsk!kudP}Pop zj1y;2)PItvxR6kdeUCMsMVYXgL23s+KQ^?z3?lncq0>3@)k>0&vKhfUo(=<#j~l9X zzQK`Tj(zKR*bdxprB{nlN^}Km zc0CW9imUSlv&9KnRuEM(MMcXHFHdA*yghV`V_;j4G_Ctjd3V_)!%eK9v${?+|2ET{ zt!KP_bs?NT!70rtP`?{DJ-cK-Ul4-9K`3zvXFDQ8#jH zNUt~{!Hb;ht8=a{&Zz2^yT=Np2W(=e2{j~X!ZOO9-WbF7&=G>{ua6O6sa4NZBef7; zf0kvGt832R{DI52|HAC#6*es;0^CURTr3P%Z!F&qp2w#rntIQ}{T=nB_G>!FqLj$+ zruWZ>yPec=&I@c+YfDiSi3&kr{> z<2YiCWFKZ}2HMDrZxlvBq9gNV#>?{sFD{l`oS%{U!?)ZZIYx%Tu22 zc06u7cGVzjSrzB>8{KSt1Y=Ye@5)w3vfkk~u@u2ga(wdx?railUyi zztbw)>Mv=-N7iO=qNVwn4uD}CojZVfves1rGY~^A=+dAf0jmvY$uWyz8eT++)J_xG zc`pi!_dO3!8)mt<<}S`;?KBKM;CR|>d3ZX|4UYRq5%N@xn_dnkIA>&64Loidp0*Y1 z(*d2rp$%*g5+JFjh~=YBzU@3sDXLIQI?#Is@YPnHD z@F?swe}FhRo;C-5_~Cn+{S$d+8OK2=Jqr4+;r`)?Pj{8{z`}x*)l^hdgqLU?uFg;R z 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

nNcC8Ua>>#VXGC~I**c-zK(z9XNRDsl| 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 literal 0 HcmV?d00001 diff --git a/data/textures/ship_parts.png b/data/textures/ship_parts.png new file mode 100644 index 0000000000000000000000000000000000000000..785e3dfe53fc623edeefed6eb687f91693ffc437 GIT binary patch literal 18235 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 literal 0 HcmV?d00001 diff --git a/data/textures/ship_thrust.png b/data/textures/ship_thrust.png new file mode 100644 index 0000000000000000000000000000000000000000..cb481504ee341b28f0658a555be65fc4f3b1c225 GIT binary patch literal 21506 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

e_NCS8`&}iB*Bk{NonxFPA&wn<(yu($RBzCnY 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 +#include + +namespace Engine { + +/* + * Inherited Module functions + */ +int CameraBase::OnInit (int argc, char* argv[]) { + LogDebug ("Camera Init"); + + mEye[0] = 0.; + mEye[1] = 1.; + mEye[2] = 1.; + + mPointOfIntrest[0] = 0.; + mPointOfIntrest[1] = 0.; + mPointOfIntrest[2] = 0.; + + mUp[0] = 0.; + mUp[1] = 1.; + mUp[2] = 0.; + + mFOVY = 90.; + + return 0; +} + +void CameraBase::OnDestroy () { + LogDebug ("Camera Destroy"); +} + +/* + * Module specific functions + */ +void CameraBase::Update () { + glMatrixMode (GL_MODELVIEW); + + glLoadIdentity (); + gluLookAt(mEye[0], mEye[1], mEye[2], + mPointOfIntrest[0], mPointOfIntrest[1], mPointOfIntrest[2], + mUp[0], mUp[1], mUp[2]); + +} + +} + diff --git a/engine/CameraBase.h b/engine/CameraBase.h new file mode 100644 index 0000000..77d67bd --- /dev/null +++ b/engine/CameraBase.h @@ -0,0 +1,61 @@ +#ifndef _CAMERABASE_H +#define _CAMERABASE_H + +#include "Engine.h" + +namespace Engine { + +class Module; + +/** \brief Controls from where the View is looking to + */ +class CameraBase : public Module { + public: + /** updates the projection and modelview matrices for the camera */ + void Update (); + float GetFOVY () { + return mFOVY; + } + + /** sets the point where the camera is looking to */ + void SetPointOfIntrest (float poi_x, float poi_y, float poi_z) { + mPointOfIntrest[0] = poi_x; + mPointOfIntrest[1] = poi_y; + mPointOfIntrest[2] = poi_z; + } + /** sets the position where the camera is located */ + void SetEye (float eye_x, float eye_y, float eye_z) { + mEye[0] = eye_x; + mEye[1] = eye_y; + mEye[2] = eye_z; + } + /** returns the position of the eye */ + void GetEye (float *eye_out) { + eye_out[0] = mEye[0]; + eye_out[1] = mEye[1]; + eye_out[2] = mEye[2]; + } + + /** sets the up direction of the camera */ + void SetUp (float up_x, float up_y, float up_z) { + mUp[0] = up_x; + mUp[1] = up_y; + mUp[2] = up_z; + } + + protected: + /** \brief Initializes the system */ + int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + void OnDestroy (); + + float mPointOfIntrest[3]; + float mEye[3]; + float mUp[3]; + + float mFOVY; +}; + +} + +#endif // _CAMERABASE_H diff --git a/engine/Commands.cc b/engine/Commands.cc new file mode 100644 index 0000000..b2d2f09 --- /dev/null +++ b/engine/Commands.cc @@ -0,0 +1,245 @@ +#include "Commands.h" + +namespace Engine { + +static Commands *CommandsInstance = NULL; + +void trim_command_str (std::string &command_str) { + std::string::size_type start = command_str.find_first_not_of (" \t"); + if (start != std::string::npos) + command_str = command_str.substr (start); + + std::string::size_type end = command_str.find_first_of ("#;\n\r\0"); + + if (end != std::string::npos) + command_str = command_str.substr (0, end); +} + +/* + * Inherited Module functions + */ +int Commands::OnInit (int argc, char* argv[]) { + LogDebug ("Commands Init"); + mErrorString = ""; + if (CommandsInstance) { + LogError ("Commands module already initialized!"); + return -1; + } + + CommandsInstance = this; + + return 0; +} +void Commands::OnDestroy () { + LogDebug ("Commands Destroy"); + + if (CommandsInstance) + CommandsInstance = NULL; +} + +/* + * Module specific functions + */ +std::string Commands::GetCommandName (const std::string &command) { + return command.substr (0, command.find_first_of (" ;\n\0")); +} + +std::vector Commands::ParseArgs (std::string &argument_str) { + std::vector args; + std::string::size_type pos = argument_str.find_first_not_of (" "); + std::string::size_type next_token = 0; + + while ( argument_str.length ()> pos && argument_str.find_first_of (" \"", pos) != std::string::npos) { + next_token = argument_str.find_first_of (" \"", pos); + + if (next_token != std::string::npos && argument_str[next_token] =='"') { + pos = next_token; + next_token = argument_str.find_first_of ('"', pos + 1); + if (next_token != std::string::npos) { + args.push_back (argument_str.substr (pos + 1, next_token - pos - 1)); + } + pos = argument_str.find_first_not_of (" ", next_token + 1); + + } else { + args.push_back (argument_str.substr (pos, next_token - pos)); + pos = argument_str.find_first_not_of (" ", next_token + 1); + } + } + + if (pos != std::string::npos) + args.push_back (argument_str.substr (pos, argument_str.length ())); + + return args; +} + +void Commands::AddCommand (const std::string &name, command_cb callback){ + LogDebug ("Adding Command '%s' at %x", name.c_str(), (void *) callback); + + mCommandsCallbacks[name] = callback; + + return; +} + +bool Commands::RunCommand (const std::string &command){ + LogDebug ("Running Command: %s", command.c_str()); + + std::string cmd_name = GetCommandName (command); + std::string args; + + if (command.length () > cmd_name.length () + 1) + args = command.substr (cmd_name.length () + 1, command.length ()); + + if (mCommandsCallbacks.find (cmd_name) != mCommandsCallbacks.end()) { + std::vector argv = ParseArgs (args); + if (mCommandsCallbacks[cmd_name] (argv)) { + mErrorString = ""; + return true; + } else { + return false; + } + } else { + LogWarning ("Command '%s' not registered!", cmd_name.c_str ()); + } + + SetErrorString ("Command '" + cmd_name + "' does not exist!"); + return false; +} + +void Commands::QueueCommand (const std::string &command){ + mCommandQueue.push (command); +} + +bool Commands::QueueExecute (){ + bool result = true; + + while (mCommandQueue.size() > 0) { + result = RunCommand (mCommandQueue.front()); + if (!result) { + while (!mCommandQueue.empty()) + mCommandQueue.pop(); + + return false; + } + mCommandQueue.pop(); + } + + return true; +} + +void Commands::SetErrorString (const std::string &error_str){ + mErrorString = error_str; + LogWarning ("Command Error: %s", error_str.c_str ()); +} + +std::string Commands::GetErrorString (){ + return mErrorString; +} + + +/* + * Global functions + */ +bool CommandsInitialized () { + if (!CommandsInstance) { + LogError ("Commands System not yet initialized!"); + return false; + } + + return true; +} + +void AddCommand (const std::string &name, command_cb callback){ + if (!CommandsInitialized ()) + return; + + CommandsInstance->AddCommand (name, callback); +} + +bool RunCommand (const std::string &command){ + if (!CommandsInitialized ()) + return false; + + return CommandsInstance->RunCommand (command); +} + +void QueueCommand (const std::string &command){ + if (!CommandsInitialized ()) + return; + + CommandsInstance->QueueCommand (command); +} + +bool CommandQueueExecute (){ + if (!CommandsInitialized ()) + return false; + + return CommandsInstance->QueueExecute (); +} + +void CommandSetErrorString (const std::string &error_str){ + if (!CommandsInitialized ()) + return; + + CommandsInstance->SetErrorString (error_str); +} + +std::string CommandGetErrorString (){ + if (!CommandsInitialized ()) + return false; + + return CommandsInstance->GetErrorString(); +} + +/* + * Commands of the Command system + */ +bool Cmd_Exec (const std::vector args) { + if (!CommandsInitialized()) + return false; + + if (args.size() != 1) { + CommandsInstance->SetErrorString("usage: exec "); + return false; + } + + std::ifstream exec_file; + exec_file.open(args[0].c_str(), std::ios_base::in); + + if (!exec_file) { + std::ostringstream error_msg; + error_msg << "exec failed: could not open file '" + << args[0] << "'"; + CommandsInstance->SetErrorString(error_msg.str()); + return false; + } + + int linecounter = 0; + while (!exec_file.eof()) { + std::string line; + getline (exec_file, line); + linecounter++; + + trim_command_str (line); + + if (line.size() == 0) + continue; + + if (!CommandsInstance->RunCommand (line)) { + std::ostringstream error_msg; + error_msg << "exec failed running command '" << line + << "' in file " << args[0] << ":" << linecounter << "."; + CommandsInstance->SetErrorString (error_msg.str()); + return false; + } + } + + exec_file.close(); + return true; +} + +void Commands::OnRegisterCommands () { + AddCommand ("exec", Cmd_Exec); +} + +} + diff --git a/engine/Commands.h b/engine/Commands.h new file mode 100644 index 0000000..cff3bcc --- /dev/null +++ b/engine/Commands.h @@ -0,0 +1,70 @@ +#ifndef _COMMANDS_H +#define _COMMANDS_H + +#include "Engine.h" + +namespace Engine { + +class Module; + +/** \brief The callback signature for commands */ +typedef bool (*command_cb) (std::vector); + +/** \brief Contains all the facilities to parse/add/execute/... commands + * + * \todo make the command system case insensitive + * + * This system is mainly used for passing instructions to the Model and + * modifying it in this way. Commands can be added with a name (string) and a + * function (callback). It also contains a CommandQueue to faciliate delayed + * execution of commands and also does the parsing of functions passed to it. + * + * Functions that should be callable by the Commands module must have the + * following signature: + * \code + * bool MyFunc_cmd (std::vector args); + * \endcode + * To keep things readable one is advised to add \c _cmd at the end of the + * function so that it is clear that this function is meant to be called by + * the Commands module. + * + * Scope: Globally visible (since commands must be added) + * + */ +class Commands : public Module { + public: + /** \brief Adds the function callback as command for the given name*/ + void AddCommand (const std::string &name, command_cb callback); + /** \brief Executes the given command immediately */ + bool RunCommand (const std::string &command); + /** \brief Adds the given command to the command queue */ + void QueueCommand (const std::string &command); + /** \brief Executes the command queue */ + bool QueueExecute (); + /** \brief When a command fails it sets the error with this function */ + void SetErrorString (const std::string &error_str); + /** \brief Returns the error string */ + std::string GetErrorString (); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + virtual void OnDestroy (); + /** \brief Registers commands relevant to the Command system */ + virtual void OnRegisterCommands (); + + /** \brief All registered commands are in this map */ + std::map mCommandsCallbacks; + /** \brief Queue for the commands */ + std::queue mCommandQueue; + /** \brief Holds the error message of a failed command */ + std::string mErrorString; + + private: + std::string GetCommandName (const std::string &command); + std::vector ParseArgs (std::string &argument_str); +}; + +} +#endif // _COMMANDS_H diff --git a/engine/CommandsGlobal.h b/engine/CommandsGlobal.h new file mode 100644 index 0000000..cf7ca7f --- /dev/null +++ b/engine/CommandsGlobal.h @@ -0,0 +1,24 @@ +#ifndef _COMMANDSGLOBAL_H +#define _COMMANDSGLOBAL_H + +namespace Engine { + +typedef bool (*command_cb) (std::vector); + +/** \brief Adds the function callback as command for the given name*/ +void AddCommand (const std::string &name, command_cb callback); +/** \brief Executes the given command immediately */ +bool RunCommand (const std::string &command); +/** \brief Adds the given command to the command queue */ +void QueueCommand (const std::string &command); +/** \brief Executes the command queue */ +bool CommandQueueExecute (); +/** \brief When a command fails it sets the error with this function */ +void CommandSetErrorString (const std::string &error_str); +/** \brief Returns the error string */ +std::string CommandGetErrorString (); + +} + +#endif /* _COMMANDSGLOBAL_H */ + diff --git a/engine/ControllerBase.cc b/engine/ControllerBase.cc new file mode 100644 index 0000000..6d1533b --- /dev/null +++ b/engine/ControllerBase.cc @@ -0,0 +1,264 @@ +#include "ControllerBase.h" + +#include "ModelBase.h" +#include "ViewBase.h" +#include "CommandsGlobal.h" + +#include "keytable.h" + +namespace Engine { + +static ControllerBase *ControllerInstance = NULL; + +/* + * Helper functions + */ + +/** \brief Converts the SDL_BUTTON_* to a value we know */ +MouseButton convert_sdl_button (Uint8 button) { + MouseButton mouse_button; + switch (button) { + case SDL_BUTTON_LEFT: + mouse_button = MouseButtonLeft; + break; + case SDL_BUTTON_MIDDLE: + mouse_button = MouseButtonMiddle; + break; + case SDL_BUTTON_RIGHT: + mouse_button = MouseButtonRight; + break; + case SDL_BUTTON_WHEELUP: + mouse_button = MouseButtonWheelUp; + break; + case SDL_BUTTON_WHEELDOWN: + mouse_button = MouseButtonWheelDown; + break; + default: + mouse_button = MouseButtonUnknown; + break; + } + + return mouse_button; +} + +/* + * Inherited Module functions + */ +int ControllerBase::OnInit (int argc, char* argv[]) { + LogDebug ("Controller Init"); + + // clear all bindings + int i; + for (i = 0; i < BINDING_KEYS_LAST; i++) + mBindings[i] = ""; + + ControllerInstance = this; + + return 0; +} + +void ControllerBase::OnDestroy () { + ControllerInstance = NULL; + + LogDebug ("Controller Destroy"); +} + +/* + * Module specific functions + */ +bool ControllerBase::BindKey (int key, const char *command) { + if (key <= 0 || key >= BINDING_KEYS_LAST) { + LogError ("Could not bind to key with index '%d': invalid index!", key); + return false; + } + + mBindings[key] = command; + + return true; +} + +void ControllerBase::Process () { + ProcessEvents (); + + mView->CalcWorldCoordinates (mMouseScreenPosition[0], mMouseScreenPosition[1], + 0., mMouseWorldPosition); + + /* + LogMessage ("Screenpos = %2d,%2d Worldpos = %f,%f,%f", + mMouseScreenPosition[0], mMouseScreenPosition[1], + mMouseWorldPosition[0], mMouseWorldPosition[1], mMouseWorldPosition[2]); + */ +} + +void ControllerBase::ProcessEvents () { + SDL_Event event; + + while (SDL_PollEvent(&event)) { + /* We are only worried about SDL_KEYDOWN and SDL_KEYUP events */ + switch (event.type) { + case SDL_KEYDOWN: + OnKeyDown (event.key.keysym); + break; + + case SDL_KEYUP: + OnKeyUp (event.key.keysym); + break; + + case SDL_MOUSEMOTION: + OnMouseMotion(event.motion.x, event.motion.y); + break; + + case SDL_MOUSEBUTTONDOWN: + OnMouseButtonDown (event.button.button, event.button.x, event.button.y); + break; + + case SDL_MOUSEBUTTONUP: + OnMouseButtonUp (event.button.button, event.button.x, event.button.y); + break; + + case SDL_VIDEORESIZE: + OnVideoResize (event.resize.w, event.resize.h); + break; + + case SDL_QUIT: + EngineSetStatus (EngineStatusStopping); + break; + + default: + break; + } + } +} + +/** \brief Keyboard processing */ +bool ControllerBase::OnKeyDown (const SDL_keysym &keysym) { + if (mView->SendKeyDown (keysym)) + return true; + + if (mBindings[keysym.sym].size () != 0) { + QueueCommand (mBindings[keysym.sym]); + return true; + } + + return false; +} + +/** \brief Keyboard processing */ +bool ControllerBase::OnKeyUp (const SDL_keysym &keysym) { + if (mView->SendKeyUp (keysym)) + return true; + + if (mBindings[keysym.sym].size () != 0) { + if (mBindings[keysym.sym][0] == '+') { + std::string upcommand = mBindings[keysym.sym]; + upcommand[0] = '-'; + QueueCommand (upcommand); + return true; + } + } + + return false; +} + +/** \brief Mouse processing */ +bool ControllerBase::OnMouseButtonDown (Uint8 button, Uint16 xpos, Uint16 ypos) { + MouseButton mouse_button = convert_sdl_button (button); + + if (mView->SendMouseButtonDown (button, xpos, ypos)) + return true; + + if (mBindings[mouse_button].size () != 0) { + QueueCommand (mBindings[mouse_button]); + return true; + } + + return false; +} + +/** \brief Mouse processing */ +bool ControllerBase::OnMouseButtonUp (Uint8 button, Uint16 xpos, Uint16 ypos) { + MouseButton mouse_button = convert_sdl_button (button); + + if (mView->SendMouseButtonUp (button, xpos, ypos)) + return true; + + if (mBindings[mouse_button].size () != 0) { + if (mBindings[mouse_button][0] == '+') { + std::string upcommand = mBindings[mouse_button]; + upcommand[0] = '-'; + QueueCommand (upcommand); + return true; + } + } + + return false; +} + +/** \brief Mouse processing */ +bool ControllerBase::OnMouseMotion (const int xnew, const int ynew) { + mMouseScreenPosition[0] = xnew; + mMouseScreenPosition[1] = ynew; + return false; +} + +/** \brief Video */ +bool ControllerBase::OnVideoResize (int width, int height) { + mView->Resize (width, height); + + return true; +} + +int convert_keystring (const char *key_val) { + std::string keystr (key_val); + + // convert the keystr to lowercase + for (std::string::iterator iter = keystr.begin(); iter != keystr.end(); iter++) + (*iter) = tolower(*iter); + + // now we search through the table for he value we were given + int i = 0; + while (key_table[i].keynum != keytable_last) { + if (keystr.compare(key_table[i].keystr) == 0) + return key_table[i].keynum; + + i++; + } + + return 0; +} + +/* + * Commands for the ControllerBase + */ +bool Cmd_Bind (const std::vector args) { + if (ControllerInstance == NULL) { + CommandSetErrorString("Could not bind key: Controller not yet initialized!"); + return false; + } + + if (args.size() != 2) { + CommandSetErrorString("usage: bind "); + return false; + } + + int key = convert_keystring (args[0].c_str()); + + if (key == 0) { + std::ostringstream error_msg; + error_msg << "bind failed: invalid key '" << args[0] << '"'; + CommandSetErrorString(error_msg.str()); + return false; + } + + if (!ControllerInstance->BindKey (key, args[1].c_str())) + return false; + + return true; +} + +void ControllerBase::OnRegisterCommands () { + AddCommand ("bind", Cmd_Bind); +} + +} + diff --git a/engine/ControllerBase.h b/engine/ControllerBase.h new file mode 100644 index 0000000..483f031 --- /dev/null +++ b/engine/ControllerBase.h @@ -0,0 +1,92 @@ +#ifndef _CONTROLLERBASE_H +#define _CONTROLLERBASE_H + +#include "Engine.h" + +namespace Engine { + +class ModelBase; +class Console; +class Module; + +/** \brief Defines the number of keys (keyboard + mous) that we can bind to. + * + * As the keysym enum of SDL has about 320 keys defined and we might have some + * more we set this define to 400 which should suffice. See also the file + * keytable.h + */ +#define BINDING_KEYS_LAST 400 + +/** \brief Converts a string into the corresponding keycode */ +int convert_keystring (const char *key_val); + +/** \brief All input is sent here and distributed from here + * + * Distributes and modifies the Model and indirectly the view by modifying the + * camera. It also holds the configuration of the keybindings and sends + * commands to the CommandQueue. + */ + +class ControllerBase : public Module { + public: + /** \brief Processes all inputs and performs all the controlling for the + * current frame. */ + void Process (); + /** \brief Returns the current mouse position in screen coordinates */ + void GetMouseScreenPosition (int *pos_out) { + pos_out[0] = mMouseScreenPosition[0]; + pos_out[1] = mMouseScreenPosition[1]; + } + void GetMouseWorldPosition (float *pos_out) { + pos_out[0] = mMouseWorldPosition[0]; + pos_out[1] = mMouseWorldPosition[1]; + pos_out[2] = mMouseWorldPosition[2]; + } + bool BindKey (int key, const char *command); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + virtual void OnDestroy (); + /** \brief Registering of the commands of the ControllerBase */ + virtual void OnRegisterCommands (); + + /** \brief Processes all Events reported by SDL_PollEvent */ + virtual void ProcessEvents (); + + /** \brief Keyboard processing */ + bool OnKeyDown (const SDL_keysym &keysym); + /** \brief Keyboard processing */ + bool OnKeyUp (const SDL_keysym &keysym); + + /** \brief Mouse processing */ + bool OnMouseButtonDown (Uint8 button, Uint16 xpos, Uint16 ypos); + /** \brief Mouse processing */ + bool OnMouseButtonUp (Uint8 button, Uint16 xpos, Uint16 ypos); + /** \brief Mouse processing */ + bool OnMouseMotion (const int xnew, const int ynew); + + /** \brief Resizes the size of the View */ + bool OnVideoResize (int width, int height); + + /** \brief Needs the Model to modify it */ + ModelBase * mModel; + /** \brief Input might be sent to the Console, hence it is here */ + Console * mConsole; + /** \brief The View which can get modified by Controller */ + ViewBase *mView; + + /** \brief Stores the current mouse position in screen coordinates */ + int mMouseScreenPosition[2]; + /** \brief Stores the current mouse position on the y=0 plane in wolrd * coordinates */ + float mMouseWorldPosition[3]; + + /** \brief Contains all the bindings for the keyboard */ + std::string mBindings[BINDING_KEYS_LAST]; + + friend class Engine; +}; + +} +#endif // _CONTROLLERBASE_H diff --git a/engine/DrawingsGL.cc b/engine/DrawingsGL.cc new file mode 100644 index 0000000..567e90c --- /dev/null +++ b/engine/DrawingsGL.cc @@ -0,0 +1,247 @@ +#include + +#include "mathlib.h" +#include "DrawingsGL.h" + +#include + +static void CubeVertices () { + // front + glVertex3f (0.5, -0.5, 0.5); + glVertex3f (0.5, -0.5, -0.5); + glVertex3f (0.5, 0.5, -0.5); + glVertex3f (0.5, 0.5, 0.5); + // back + glVertex3f (-0.5, 0.5, 0.5); + glVertex3f (-0.5, 0.5, -0.5); + glVertex3f (-0.5, -0.5, -0.5); + glVertex3f (-0.5, -0.5, 0.5); + // left + glVertex3f (-0.5, -0.5, 0.5); + glVertex3f (0.5, -0.5, 0.5); + glVertex3f (0.5, 0.5, 0.5); + glVertex3f (-0.5, 0.5, 0.5); + // right + glVertex3f (-0.5, 0.5, -0.5); + glVertex3f (0.5, 0.5, -0.5); + glVertex3f (0.5, -0.5, -0.5); + glVertex3f (-0.5, -0.5, -0.5); + // bottom + glVertex3f (-0.5, -0.5, -0.5); + glVertex3f (0.5, -0.5, -0.5); + glVertex3f (0.5, -0.5, 0.5); + glVertex3f (-0.5, -0.5, 0.5); + // top + glVertex3f (-0.5, 0.5, 0.5); + glVertex3f (0.5, 0.5, 0.5); + glVertex3f (0.5, 0.5, -0.5); + glVertex3f (-0.5, 0.5, -0.5); +} + +void DrawWireCube () { + glBegin (GL_LINE_STRIP); + CubeVertices (); + glEnd (); +} + +void DrawSolidCube () { + glBegin (GL_QUADS); + CubeVertices (); + glEnd (); +} + +void DrawCircle () { + int i, segments; + segments = 20; + double x, z, rad, drad; + + drad = (M_PI * 2) / segments; + + // Top + glBegin (GL_TRIANGLE_FAN); + glVertex3f (0., 0.5, 0.); + for (i = 0; i <= segments; i++) { + rad = drad * i; + sincos (rad, &z, &x); + glVertex3f (x * 0.5, 0., -z * 0.5); + } + glEnd (); +} + +void DrawTorus () { + int i, segments; + segments = 20; + double x, z, rad, drad; + + drad = (M_PI * 2) / segments; + + // Top + glBegin (GL_TRIANGLE_FAN); + glVertex3f (0., 0.5, 0.); + for (i = 0; i <= segments; i++) { + rad = drad * i; + sincos (rad, &z, &x); + glVertex3f (x * 0.5, 0.5, -z * 0.5); + } + glEnd (); + + // Bottom + glBegin (GL_TRIANGLE_FAN); + glVertex3f (0., -0.5, 0.); + for (i = 0; i <= segments; i++) { + rad = -drad * i; + sincos (rad, &z, &x); + glVertex3f (x * 0.5, -0.5, -z * 0.5); + } + glEnd (); + + // Sides + glBegin (GL_QUAD_STRIP); + for (i = 0; i <= segments; i++) { + rad = drad * i; + sincos (rad, &z, &x); + glVertex3f (x * 0.5, 0.5, -z * 0.5); + glVertex3f (x * 0.5, -0.5, -z * 0.5); + } + glEnd (); +} + +void DrawPoint (float r, float x, float y, float z) { + glPointSize (r); + glBegin (GL_POINTS); + glVertex3f (x, y, z); + glEnd (); + glPointSize (1.); +} + +void DrawAxis() { + glColor4f(1., 1., 1., 1.); + + glBegin(GL_LINES); + glVertex3f(0., 0., 0.); + glVertex3f(1., 0., 0.); + glVertex3f(0., 0., 0.); + glVertex3f(0., 1., 0.); + glVertex3f(0., 0., 0.); + glVertex3f(0., 0., 1.); + glEnd(); + + // X + glPushMatrix(); + glTranslatef(1., 0., 0.); + glColor3f(1., 0., 0.); + glScalef(0.2, 0.1, 0.1); + DrawCone(10); + glTranslatef(0.4, 0., 0.); + // glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'x'); + glPopMatrix(); + + // Y + glPushMatrix(); + glTranslatef(0., 1., 0.); + glRotatef(90, 0., 0., 1.); + glColor3f(0., 1., 0.); + glScalef(0.2, 0.1, 0.1); + DrawCone(10); + glTranslatef(0.4, 0., 0.); + // glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'y'); + glPopMatrix(); + + // Z + glPushMatrix(); + glTranslatef(0., 0., 1.); + glRotatef(90, 0., -1., 0.); + glColor3f(0., 0., 1.); + glScalef(0.2, 0.1, 0.1); + DrawCone(10); + glPopMatrix(); +} + +void DrawDisc(float radius, int segments) { + int i; + float radiant; + glBegin(GL_TRIANGLE_FAN); + glVertex3f(0., 0., 0.); + for (i = 0; i <= segments; i++) { + radiant = (float) i * ((2 * M_PI) / (float) segments); + glVertex3f(radius * cos(radiant), 0., radius * sin(radiant)); + } + glEnd(); +} + +void DrawCircle(float radius, int segments) { + int i; + float radiant; + glBegin(GL_LINE_STRIP); + glVertex3f(0., 0., 0.); + for (i = 0; i <= segments; i++) { + radiant = (float) i * ((2 * M_PI) / (float) segments); + glVertex3f(radius * cos(radiant), 0., radius * sin(radiant)); + } + glEnd(); +} + +void DrawCone(int segments) { + int i; + float radiant; + + glBegin(GL_TRIANGLE_FAN); + glVertex3f(1., 0., 0.); + for (i = 0; i <= segments; i++) { + radiant = (float) (i * (2. * M_PI) / (float) segments); + + glVertex3f(0., cos(radiant), sin(radiant)); + } + + glEnd(); +} + +void DrawVector(vector3d start, vector3d end) { + vector3d direction (end - start); + + glColor3f(1., 1., 1.); + glLineWidth(2.); + glBegin(GL_LINES); + glVertex3f(start[0], start[1], start[2]); + glVertex3f(end[0], end[1], end[2]); + glEnd(); + glLineWidth(1.); + + vector3d right; + vector3d up; + vector3d direction_norm = direction / direction.length(); + float cone_radius = 0.15; + vector3d conebottom = end - direction_norm * 0.3; + + // Draw the tip + if (fabs(direction[0]) > fabs(direction[1]) && fabs(direction[2]) > fabs(direction[1])) { + up.setValues (0., 1., 0.); + vector3d right = direction.cross (up); + right = right / right.length(); + + int i; + int segments = 20.; + float rad_delta = 2. * M_PI / (float) segments; + double s,c; + + glColor3f(0.2, 0.2, 0.5); + glPointSize (10.); + glBegin (GL_TRIANGLE_FAN); + glVertex3f (end[0], end[1], end[2]); + + for (i = 0; i <= segments; i ++) { + sincos (i * rad_delta, &s, &c); + glVertex3f (conebottom[0] + right[0] * cone_radius * c, conebottom[1] + s * cone_radius, conebottom[2] + right[2] * cone_radius * c); + } + + glEnd (); + glBegin (GL_TRIANGLE_FAN); + glVertex3f (conebottom[0], conebottom[1], conebottom[2]); + for (i = 0; i <= segments; i ++) { + sincos (i * rad_delta, &s, &c); + glVertex3f (conebottom[0] + right[0] * cone_radius * c, conebottom[1] + s * cone_radius, conebottom[2] + right[2] * cone_radius * c); + } + + glEnd (); + } +} diff --git a/engine/DrawingsGL.h b/engine/DrawingsGL.h new file mode 100644 index 0000000..b3bc9c6 --- /dev/null +++ b/engine/DrawingsGL.h @@ -0,0 +1,21 @@ +#ifndef _DRAWINGSGL_H +#define _DRAWINGSGL_H + +#ifdef WIN32 + #include +#endif + +struct vector3d; + +void DrawWireCube (); +void DrawSolidCube (); +void DrawCircle (); +void DrawTorus (); +void DrawPoint (float r, float x, float y, float z); +void DrawAxis(); +void DrawDisc(float radius, int segments); +void DrawCircle(float radius, int segments); +void DrawCone(int segments); +void DrawVector(vector3d start, vector3d end); + +#endif /* _DRAWINGSGL_H */ diff --git a/engine/Engine.cc b/engine/Engine.cc new file mode 100644 index 0000000..660792d --- /dev/null +++ b/engine/Engine.cc @@ -0,0 +1,353 @@ +#include "Engine.h" +#include "Logging.h" +#include "Variables.h" +#include "Commands.h" + +#include "PhysicsBase.h" +#include "CameraBase.h" + +#include "ViewBase.h" +#include "ModelBase.h" +#include "ControllerBase.h" + +#include "EntityFactoryBase.h" +#include "EventsBase.h" + +#include +#include +#include +#include +#include + +int vasprintf (char **result, const char *format, va_list *string) { + return 0; +} + +namespace Engine { + +/* Globaly visible classes */ +Engine* EngineInstance = NULL; + +/* + * Inherited Module functions + */ +int Engine::OnInit (int argc, char* argv[]) { + EngineInstance = this; + mStatus = EngineStatusUndefined; + + /* Initialization of the base modules */ + if (mLogging == NULL) + mLogging = new Logging (); + + if (! mLogging ) { + SetError ("Could not allocate memory for Logging!"); + exit (-1); + } + mLogging->Init (argc, argv); + SetStatus (EngineStatusInitializing); + + if (mEventManager == NULL) + mEventManager = new EventManager(); + + mEventManager->Init (argc, argv); + + if (mVariables == NULL) + mVariables = new Variables (); + if (! mVariables ) { + SetError ("Could not allocate memory for Variables!"); + exit (-1); + } + mVariables->Init (argc, argv); + + if (mCommands == NULL) + mCommands = new Commands (); + if (! mCommands ) { + SetError ("Could not allocate memory for Commands!"); + exit (-1); + } + mCommands->Init (argc, argv); + + // Initialize the SDL + LogDebug ("Initializing SDL"); + if ( SDL_Init ( SDL_INIT_VIDEO ) < 0) { + LogError ("Error initializing SDL: %s", SDL_GetError ()); + exit (-1); + } + + + /* Model */ + if (mModel == NULL) + mModel = new ModelBase (); + + if (! mModel ) { + SetError ("Could not allocate memory for Model!"); + exit (-1); + } + + /* Initialization of the modules for the model */ + if (mEntityFactory == NULL) + mEntityFactory = new EntityFactoryBase; + + mModel->mEntityFactory = mEntityFactory; + + + /* Physics */ + if (mPhysics == NULL) { + mPhysics = new PhysicsBase (); + + if (! mPhysics ) { + SetError ("Could not allocate memory for Physics!"); + exit (-1); + } + } + + mModel->mPhysics = mPhysics; + + mEntityFactory->Init (argc, argv); + mModel->mPhysics->Init (argc, argv); + mModel->Init (argc, argv); + + /* View */ + if (mView == NULL) + mView = new ViewBase (); + + if (! mView ) { + SetError ("Could not allocate memory for View!"); + exit (-1); + } + + mView->mCamera = new CameraBase (); + mView->mCamera->Init (argc, argv); + + mView->mModel = mModel; + mView->Init (argc, argv); + + /* Controller */ + if (mController == NULL) + mController = new ControllerBase (); + + if (! mController ) { + SetError ("Could not allocate memory for Controller!"); + exit (-1); + } + + mController->mModel = mModel; + mController->mView = mView; + + mController->Init (argc, argv); + + /* Now register the commands */ + mLogging->RegisterCommands (); + mVariables->RegisterCommands (); + mCommands->RegisterCommands (); + + mModel->mPhysics->RegisterCommands (); + mModel->RegisterCommands (); + + mView->mCamera->RegisterCommands (); + mView->RegisterCommands (); + + mController->RegisterCommands (); + + RegisterCommands (); + + /* Now we are done */ + SetStatus (EngineStatusInitialized); + + return 0; +} + +void Engine::OnDestroy () { + SetStatus (EngineStatusDestroying); + + // Quit the SDL + SDL_Quit (); + + if (mController) { + mController->Destroy (); + delete mController; + mController = NULL; + } + + if (mView) { + if (mView->mCamera ) { + mView->mCamera->Destroy (); + delete mView->mCamera; + } + + mView->Destroy (); + delete mView; + mView = NULL; + } + + if (mModel) { + mModel->Destroy (); + + if (mModel->mPhysics ) { + mModel->mPhysics->Destroy (); + delete mModel->mPhysics; + } + + delete mModel; + mModel = NULL; + } + + if (mCommands) { + mCommands->Destroy (); + delete mCommands; + mCommands = NULL; + } + + if (mVariables) { + mVariables->Destroy (); + delete mVariables; + mVariables = NULL; + } + + SetStatus (EngineStatusStopped); + + if (mEventManager) { + mEventManager->Destroy(); + delete mEventManager; + mEventManager = NULL; + } + + if (mLogging) { + mLogging->Destroy (); + delete mLogging; + mLogging = NULL; + } + + mStatus = EngineStatusUndefined; + EngineInstance = NULL; +} + +/* + * Module specific functions + */ +void Engine::SetStatus (EngineStatus new_status) { + LogDebug ("EngineStatus Change: '%d' -> '%d'", mStatus, new_status); + mStatus = new_status; +} + +EngineStatus Engine::GetStatus () { + return mStatus; +} + +void Engine::OnMainLoop () { + SetStatus (EngineStatusRunning); + + while (mStatus == EngineStatusRunning) { + mController->Process (); + mCommands->QueueExecute (); + mEventManager->Process(); + mModel->UpdateTimer (); + mModel->Process (); + mView->Draw (); + } +} + +void Engine::SetError (const char* str, ...) { + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + mErrorString = msg; + + last_length = strlen (msg); +} + +const char* Engine::GetError () { + return mErrorString.c_str(); +} + +/* + * Global functions + */ +void EngineSetError (const char* str, ...) { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + EngineInstance->SetError (msg); + + last_length = strlen (msg); +} + +const char* EngineGetError () { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + return EngineInstance->GetError (); +} + +void EngineSetStatus (const EngineStatus status) { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + EngineInstance->SetStatus (status); +} + +EngineStatus EngineGetStatus () { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + return EngineInstance->GetStatus (); +} + +ModelBase* EngineGetModel () { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + return EngineInstance->GetModel(); +} + +ViewBase* EngineGetView () { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + return EngineInstance->GetView(); +} + +ControllerBase* EngineGetController () { + if (EngineInstance == NULL) { + std::cerr << "Error: Engine Instance not yet initialized!" << std::endl; + assert (0); + } + + return EngineInstance->GetController(); +} + +} + diff --git a/engine/Engine.h b/engine/Engine.h new file mode 100644 index 0000000..0be3c54 --- /dev/null +++ b/engine/Engine.h @@ -0,0 +1,167 @@ +#ifndef _ENGINE_H +#define _ENGINE_H + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Module.h" + +// Some ugly #defines + +/** \brief Defines the number of keys that can be defined for an EntityController + * + * The current state of the controls for an entity is stored in an std::bitset + * and each bit tells us whether the key is pressed or not. Unfortunately we + * have to know the number of bits that are to be reserved in advance so this + * is hard coded into the library for now. + */ +#define ENTITY_CONTROLLER_MAX_KEY_STATES 64 + +namespace Engine { + +class ModelBase; +class ViewBase; +class ControllerBase; +class PhysicsBase; +class EntityFactoryBase; +class EventManager; + +class Logging; +class Commands; +class Variables; +class Variable; + +enum EngineStatus { + EngineStatusUndefined = 0, + EngineStatusInitializing, + EngineStatusInitialized, + EngineStatusRunning, + EngineStatusStopping, + EngineStatusStopped, + EngineStatusDestroying +}; + +/** \brief The outermost class which contains just everything! + * + * Engine::Engine takes care of initializing, running and destroying the whole + * Engine. + * + * When Initialize called, the submodules are created by Engine and + * initializes them. There are two initialization phases: + * - Basemodules initialization: + * The first phase creates the base modules such as Engine::Logging, + * Engine::Variables and Engine::Commands and calls Initialize () on them. + * - ModelViewController initialization: + * In the second phase at first the Submodules for each Engine::ModelBase, Engine::ViewBase and + * Engine::ControllerBase are allocated an initialized. Then the Engine::ModelBase, + * Engine::View and Engine::ControllerBase Modules are initialized. + */ +class Engine : public Module { + public: + Engine () { + mModel = NULL; + mView = NULL; + mController = NULL; + mLogging = NULL; + mCommands = NULL; + mVariables = NULL; + mEntityFactory = NULL; + mEventManager = NULL; + } + + virtual void MainLoop () { + OnMainLoop (); + } + + void SetModel (ModelBase *model) { mModel = model; }; + ModelBase* GetModel () { return mModel; }; + void SetView (ViewBase *view) { mView = view; }; + ViewBase* GetView () { return mView; }; + void SetPhysics (PhysicsBase *physics) { mPhysics = physics; }; + PhysicsBase* GetPhysics () { return mPhysics; }; + void SetEntityFactory (EntityFactoryBase *entityfactory) { mEntityFactory = entityfactory; }; + + void SetController (ControllerBase *controller) { mController = controller; }; + ControllerBase* GetController () { return mController; }; + void SetLogging (Logging *logging) { mLogging = logging; }; + void SetCommands (Commands *commands) { mCommands = commands; }; + void SetVariables (Variables *variables) { mVariables = variables; }; + + void SetError (const char* str, ...); + const char* GetError (); + void SetStatus (const EngineStatus new_status); + EngineStatus GetStatus (); + + private: + // Engine must not be created with the standard constructor! + // It must be ensured, that the correct EntityFactory is used! + protected: + virtual int OnInit (int argc, char* argv[]); + virtual void OnDestroy (); + virtual void OnRegisterCommands (); + + void OnMainLoop (); + + ModelBase *mModel; + ViewBase *mView; + ControllerBase *mController; + PhysicsBase *mPhysics; + EntityFactoryBase *mEntityFactory; + EventManager *mEventManager; + + Logging *mLogging; + Commands *mCommands; + Variables *mVariables; + + std::string mErrorString; + EngineStatus mStatus; +}; + +} + +/* + * Global visible functions and classes + */ + +namespace Engine { +/* Globaly visible classes */ +extern Engine* EngineInstance; + +/** \brief Sets the Engine::mErrorString to the given message */ +void EngineSetError (const char* str, ...); +/** \brief Returns Engine::mErrorString */ +const char* EngineGetError (); + +/** \brief Sets the current state of the Engine */ +void EngineSetStatus (const EngineStatus status); +/** \brief Returns the current state of the Engine */ +EngineStatus EngineGetStatus (); + +/** \brief Global access functions for the Model */ +ModelBase* EngineGetModel (); +/** \brief Global access functions for the View */ +ViewBase* EngineGetView (); +/** \brief Global access functions for the Controller */ +ControllerBase* EngineGetController (); + +} + +/* Include the globally visible declarations of the other modules */ +#include "LoggingGlobal.h" +#include "VariablesGlobal.h" +#include "CommandsGlobal.h" +#include "ModelBaseGlobal.h" +#include "ViewBaseGlobal.h" +#include "EventsBaseGlobal.h" + +#endif // _ENGINE_H diff --git a/engine/EngineCommands.cc b/engine/EngineCommands.cc new file mode 100644 index 0000000..e8a7863 --- /dev/null +++ b/engine/EngineCommands.cc @@ -0,0 +1,15 @@ +#include "Engine.h" + +namespace Engine { + +bool Cmd_EngineQuit (std::vector args) { + EngineSetStatus (EngineStatusStopping); + + return true; +} + +void Engine::OnRegisterCommands () { + AddCommand ("quit", Cmd_EngineQuit); +} + +} diff --git a/engine/EntityBase.cc b/engine/EntityBase.cc new file mode 100644 index 0000000..a1fa0d0 --- /dev/null +++ b/engine/EntityBase.cc @@ -0,0 +1,45 @@ +#include "EntityBase.h" + +#include "coll2d.h" + +namespace Engine { + +bool EntityControllerState::GetKey (int state) { + assert (state < ENTITY_CONTROLLER_MAX_KEY_STATES && state >= 0); + + return mKeyState.test (state); +} + +void EntityControllerState::SetKey (int state) { + assert (state < ENTITY_CONTROLLER_MAX_KEY_STATES && state >= 0); + + LogDebug ("Setting Entity Key State %d", state); + mKeyState.set (state); +} + +void EntityControllerState::UnsetKey (int state) { + assert (state < ENTITY_CONTROLLER_MAX_KEY_STATES && state >= 0); + + LogDebug ("Unsetting Entity Key State %d", state); + mKeyState.reset (state); +} + +void EntityBase::SetControllerKeyState (int state) { + if (!mControllerState) { + LogError ("Error when trying to send a KeyState to an Entity that has no EntityControllerState!"); + assert (0); + } + + mControllerState->SetKey (state); +} + +void EntityBase::UnsetControllerKeyState (int state) { + if (!mControllerState) { + LogError ("Error when trying to send a KeyState to an Entity that has no EntityControllerState!"); + assert (0); + } + + mControllerState->UnsetKey (state); +} + +} diff --git a/engine/EntityBase.h b/engine/EntityBase.h new file mode 100644 index 0000000..0c466c8 --- /dev/null +++ b/engine/EntityBase.h @@ -0,0 +1,154 @@ +#ifndef _ENTITYBASE_H +#define _ENTITYBASE_H + +#include "Engine.h" +#include "mathlib.h" + +#include "EntityBaseTypes.h" + +namespace coll2d { + class Shape; +} + +namespace Engine { + +/** \brief Contains all the information for the physical simulation of the + * Entity + * + * Every Engine::Entity that should be simulated in the Engine::Physics module + * must have a Engine::EntityPhysicState counterpart. It represents the state + * of the Entity in the physical world of the engine. + * + * The Copy-Constructor and Assignment Operator is defined in EntityPhysics.cc + * as they require a call to coll2d::Shape::getCopy() which again requires the + * inclusion of coll2d.h which should stay out of Entity.h for faster + * compilation. + */ +struct EntityPhysicState { + /** \brief Standard constructor */ + EntityPhysicState (): + mId (0), + mBaseType (EntityBaseTypeNone), + mPosition (0., 0., 0.), + mOrientation (0., 0., 0.), + mVelocity (0., 0., 0.), + mAngleVelocity (0.), + mRadius (0.), + mShape (NULL), + mStatic (false), + mAlive (true), + mContactNormals() {}; + + virtual ~EntityPhysicState() {}; + + /** \brief Copy constructor */ + EntityPhysicState (const EntityPhysicState& state); + + /** \brief Assignment operator */ + EntityPhysicState& operator= (const EntityPhysicState& state); + + unsigned int mId; + /** \brief The type from the game's perspective */ + int mType; + /** \brief The type from the engine's perspective */ + EntityBaseType mBaseType; + + vector3d mPosition; + vector3d mOrientation; + vector3d mVelocity; + float mAngleVelocity; + float mRadius; + + coll2d::Shape* mShape; + bool mStatic; + + /** \brief If false, the entity will be removed at the end of the frame. */ + bool mAlive; + + vector3d &GetPosition (); + vector3d &GetVelocity (); + vector3d &GetOrientation (); + float &GetAngleVelocity (); + + void SetPosition (const vector3d &position); + void SetVelocity (const vector3d &velocity); + void SetOrientation (const vector3d &orientation); + void SetAngleVelocity (const float &angle_velocity); + + /** \brief Transforms the given vector in local space to world coordinates */ + void Globalize (vector3d &vec); + /** \brief Transforms the given vector from world coordinates to local + * coordinates */ + void Localize (vector3d &vec); + /** \brief Performs only the rotational part of Globalize() */ + void GlobalizeRotation (vector3d &vec); + /** \brief Performs only the rotational part of Localize() */ + void LocalizeRotation (vector3d &vec); + + /** \brief Updates the shape for collision detection */ + void UpdateShape (); + + /** \brief Contains all the normal vectors of the planes with which we are in contact. */ + std::map mContactNormals; +}; + +/** \brief Represents the current state of the Entity controller + * + * This struct stores the current state for all EntityControllerKeyStates + * (e.g. whether the keys are currently pressed or not). + * + * \todo [Low] The current design is very unflexible. Is there a better way? + */ +struct EntityControllerState { + std::bitset mKeyState; + + bool GetKey (int state); + void SetKey (int state); + void UnsetKey (int state); +}; + +/** \brief Represents the base of everything that exists in the engine + * + * An Engine::Entity has different representations in the different + * submodules. Engine::EntityPhysicState stores the physical representation of + * the entity like its position, velocity, orientation, and shape. + * Engine::EntityVisualState is used for drawing an Entity by Engine::View. + */ +struct EntityBase { + unsigned int mId; + /** \brief The type from the game's perspective */ + int mType; + /** \brief The type from the engine's perspective */ + EntityBaseType mBaseType; + + EntityPhysicState *mPhysicState; + EntityControllerState *mControllerState; + + /** \brief Applies the state of the EntityControllerState to the EntityPhysicState etc. */ + virtual void Update (float delta_sec) {}; + + /** \brief Adds the given state to the current movement state of the Entity */ + virtual void SetControllerKeyState (int state); + /** \brief Removes the given state to the current movement state of the Entity */ + virtual void UnsetControllerKeyState (int state); + + /** \brief Helper function to set the id to all substates */ + void SetId (unsigned int id) { + mId = id; + + if (mPhysicState) + mPhysicState->mId = id; + } + + /** Executes game logic for the collision event + * \returns true if it was able to react for this type of entity, false + * false otherwise + */ + virtual bool CollisionEvent (EntityBase* entity_state) { + return false; + } +}; + +} + +#endif // _ENTITYBASE_H diff --git a/engine/EntityBaseTypes.h b/engine/EntityBaseTypes.h new file mode 100644 index 0000000..e1755f6 --- /dev/null +++ b/engine/EntityBaseTypes.h @@ -0,0 +1,59 @@ +#ifndef _ENTITYBASETYPES_H +#define _ENTITYBASETYPES_H + +namespace Engine { + +struct EntityBase; +struct EntityPhysicState; +struct EntityControllerState; + +/** \brief Represents the different types of an entity from the Engines' perspective + * + * The different EntityBaseTypes define their basic behaviour when it comes to + * events such as collisions between two Entities. + * + * Here is an overview how collisions are handled: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
EntityBaseTypeParticleEntityBaseTypeBlockEntityBaseTypeActor
EntityBaseTypeParticle-CC
EntityBaseTypeBlockCCC
EntityBaseTypeActorCCC
+ * + * A 'C' means that Engine::Physics::CheckPossibleCollisionPair() will return + * true (this results that the two types cannot penetrate each other). + */ +enum EntityBaseType { + EntityBaseTypeNone = 0, /**< is the default type and does not collide with anything */ + EntityBaseTypeBlock, /**< represents walls etc. that block Particles, Actors and other Blocks */ + EntityBaseTypeParticle, /**< is used for projectiles or Entities that just move + but are "dumb" apart from that */ + EntityBaseTypeActor, /**< is the type for objects that interact with each other */ + EntityBaseTypeLast /**< marks the maximum number of EntityBaseType */ +}; + + +} + +#endif // _ENTITYBASETYPES_H diff --git a/engine/EntityFactoryBase.cc b/engine/EntityFactoryBase.cc new file mode 100644 index 0000000..4cf1c82 --- /dev/null +++ b/engine/EntityFactoryBase.cc @@ -0,0 +1,117 @@ +#include + +#include "EntityFactoryBase.h" + +#include "EntityBase.h" +#include "coll2d.h" + +namespace Engine { + +int EntityFactoryBase::OnInit (int argc, char* argv[]) { + LogMessage ("Initializing EntityFactory"); + + return 0; +} + +EntityPhysicState* EntityFactoryBase::CreateEntityPhysicState (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type >> EntityBaseTypeLast ) { + LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + EntityBaseType base_type = (EntityBaseType) type; + + // Create the Entity + EntityPhysicState* entity_physics = new EntityPhysicState (); + if (!entity_physics) { + LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + + // default values for all entities + entity_physics->mBaseType = base_type; + + // specific values for each Entity base_type + if (base_type == EntityBaseTypeNone) { + entity_physics->mShape = new coll2d::Sphere (0.01); + assert (entity_physics->mShape); + } else if (base_type == EntityBaseTypeActor) { + entity_physics->mShape = new coll2d::Sphere (0.4); + assert (entity_physics->mShape); + } else if (base_type == EntityBaseTypeBlock) { + entity_physics->mShape = new coll2d::Polygon (4); + assert (entity_physics->mShape); + + static_cast (entity_physics->mShape)->setVertice (0, vector3d (-0.5, 0., 0.5)); + static_cast (entity_physics->mShape)->setVertice (1, vector3d (0.5, 0., 0.5)); + static_cast (entity_physics->mShape)->setVertice (2, vector3d (0.5, 0., -0.5)); + static_cast (entity_physics->mShape)->setVertice (3, vector3d (-0.5, 0., -0.5)); + } else if (base_type == EntityBaseTypeParticle) { + entity_physics->mShape = new coll2d::Sphere (0.05); + assert (entity_physics->mShape); + } else { + LogError ("No EntityPhysicState defined for Entity base_type '%d'", base_type); + assert (0); + } + + return entity_physics; +} + +EntityControllerState* EntityFactoryBase::CreateEntityControllerState (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type >> EntityBaseTypeLast ) { + LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + EntityBaseType base_type = (EntityBaseType) type; + + // Create the Entity + EntityControllerState* entity_controller = NULL; + + // specific values for each Entity base_type + if (base_type == EntityBaseTypeNone) { + } else if (base_type == EntityBaseTypeActor) { + entity_controller = new EntityControllerState (); + if (!entity_controller) { + LogError ("Could not allocate enough memory for EntityControllerState of type '%d'", type); + assert (0); + } + } else if (base_type == EntityBaseTypeBlock) { + } else if (base_type == EntityBaseTypeParticle) { + } else { + LogError ("No EntityPhysicState defined for Entity base_type '%d'", base_type); + assert (0); + } + + return entity_controller; +} + +EntityBase* EntityFactoryBase::CreateEntity (int type) { + // In this simple factory the type is simply seen as the EntityBaseType. + // However to prevent errors we do a simple check vor validity. + if (type < 0 || type >> EntityBaseTypeLast ) { + LogError ("Cannot create Entity with type %d: invalid type!", type); + assert (0); + } + EntityBaseType base_type = (EntityBaseType) type; + + // Create the Entity + EntityBase *entity = new EntityBase; + entity->mBaseType = base_type; + + if (!entity) { + LogError ("Could not allocate enough memory for EntityVisualState of type '%d'", type); + assert (0); + } + + entity->mPhysicState = CreateEntityPhysicState (type); + entity->mControllerState = CreateEntityControllerState (type); + + return entity; +} + +} + + diff --git a/engine/EntityFactoryBase.h b/engine/EntityFactoryBase.h new file mode 100644 index 0000000..d82e8ec --- /dev/null +++ b/engine/EntityFactoryBase.h @@ -0,0 +1,35 @@ +#ifndef _ENTITYFACTORYBASE_H +#define _ENTITYFACTORYASE_H + +#include "Module.h" + +namespace Engine { + + struct EntityBase; + + struct EntityPhysicState; + struct EntityControllerState; + + /** \brief Takes care of the creation of user-defined Entities + * + * To be able to define custom types of Entities we use a Object Factory for + * which the actual CreateEntityXYZState () function can be overloaded with + * the creation of custom types. + * + * The method EntityFactory::CreateEntity() will be called by the + * Model::CreateEntity() function which also takes care of registering the + * Entity to required submodules. + */ + class EntityFactoryBase : public Module { + public: EntityFactoryBase () {}; + virtual EntityPhysicState* CreateEntityPhysicState (int type); + virtual EntityControllerState* CreateEntityControllerState (int type); + + virtual EntityBase* CreateEntity (int type); + + protected: + virtual int OnInit (int argc, char* argv[]); + }; +} + +#endif // _ENTITYFACTORYBASE_H diff --git a/engine/EnumToString.h b/engine/EnumToString.h new file mode 100644 index 0000000..9e728ca --- /dev/null +++ b/engine/EnumToString.h @@ -0,0 +1,21 @@ +// File name: "EnumToString.h" +// +// From: http://www.codeproject.com/KB/cpp/C___enums_to_strings.aspx +// +// Thanks to Marcos F. Cardoso + +#undef DECL_ENUM_ELEMENT +#undef BEGIN_ENUM +#undef END_ENUM + +#ifndef GENERATE_ENUM_STRINGS + #define DECL_ENUM_ELEMENT( element ) element + #define BEGIN_ENUM( ENUM_NAME ) typedef enum tag##ENUM_NAME + #define END_ENUM( ENUM_NAME ) ENUM_NAME; \ + const char* GetString##ENUM_NAME(enum tag##ENUM_NAME index); +#else + #define DECL_ENUM_ELEMENT( element ) #element + #define BEGIN_ENUM( ENUM_NAME ) const char* gs_##ENUM_NAME [] = + #define END_ENUM( ENUM_NAME ) ; const char* GetString##ENUM_NAME(enum \ + tag##ENUM_NAME index){ return gs_##ENUM_NAME [index]; } +#endif diff --git a/engine/EventsBase.cc b/engine/EventsBase.cc new file mode 100644 index 0000000..221055b --- /dev/null +++ b/engine/EventsBase.cc @@ -0,0 +1,88 @@ +#include "EventsBase.h" +#include "Logging.h" + +namespace Engine { + +EventManager* EventManagerInstance = NULL; + +int EventManager::OnInit (int argc, char* argv[]) { + EventManagerInstance = this; + + return 0; +} + +void EventManager::OnDestroy() { + EventManagerInstance = NULL; +} + +bool EventManager::RegisterListener (const EventListenerBase *listener, const int event_type) { + LogDebug ("Registering Event listener %x for event type %d", listener, event_type); + + mEventTypeListeners[event_type].push_back(listener); + return true; +} + +void EventManager::Process () { + while (mQueuedEvents.size() > 0) { + TriggerEvent (mQueuedEvents.front()); + mQueuedEvents.pop(); + } +} + +bool EventManager::QueueEvent (const EventBasePtr &event) { + if (!HasEventTypeListener(event->mEventType)) + return false; + + mQueuedEvents.push (event); + + return true; +} + +bool EventManager::TriggerEvent (const EventBasePtr &event) { + if (!HasEventTypeListener (event->mEventType)) + return false; + + std::vector::iterator listener_iter = mEventTypeListeners[event->mEventType].begin(); + for ( ; listener_iter != mEventTypeListeners[event->mEventType].end(); listener_iter++) { + if ((*listener_iter)->HandleEvent (event)) + return true; + } + + return false; +} + +/* + * Global Functions + */ +/** \brief Registers a listener to a given event type */ +bool RegisterListener (const EventListenerBase *listener, const int event_type) { + if (!EventManagerInstance) { + LogError ("Could not register EventListenerBase: EventManager not initialized!"); + return false; + } + + return EventManagerInstance->RegisterListener (listener, event_type); +} + +/** \brief Calls all event listeners to handle the events */ +bool QueueEvent (const EventBasePtr &event) { + if (!EventManagerInstance) { + LogError ("Could not queue event: EventManager not initialized!"); + return false; + } + + return EventManagerInstance->QueueEvent (event); +} + +/** \brief Calls the listener handlers immediately */ +bool TriggerEvent (const EventBasePtr &event) { + if (!EventManagerInstance) { + LogError ("Could not trigger event: EventManager not initialized!"); + return false; + } + + return EventManagerInstance->TriggerEvent (event); +} + +}; + diff --git a/engine/EventsBase.h b/engine/EventsBase.h new file mode 100644 index 0000000..fa3be18 --- /dev/null +++ b/engine/EventsBase.h @@ -0,0 +1,88 @@ +#ifndef EVENTSBASE_H +#define EVENTSBASE_H + +#include "Module.h" + +#include + +#include +#include +#include +#include + +namespace Engine { + +/** \brief Contains all information relevant to the Event */ +struct EventBase { + int mEventType; + + /** \brief This might later be used for de-/serializing of the event data */ + std::string mEventData; + float mEventFloat; + int mEventInt; + unsigned int mEventUnsignedInt; +}; + +typedef boost::shared_ptr EventBasePtr; + +/** \brief Takes care of the handling of the Event + * + * Processing of the Event is done in the EventListenerBase::HandleEvent() + * function. + */ +class EventListenerBase { + public: + virtual ~EventListenerBase() {}; + /** \brief Handles the Event */ + virtual bool HandleEvent (const EventBasePtr &event) const = 0; + void just_for_the_vtable() {}; + + /** \brief For debugging */ + std::string mName; +}; + +typedef boost::shared_ptr EventListenerPtr; + +/** \brief Keeps track of all the EventListenerBase objects and receives Event notifications. + */ +class EventManager : public Module { + public: + virtual ~EventManager() {}; + + /** \brief Registers a listener to a given event type */ + bool RegisterListener (const EventListenerBase *listener, const int event_type); + /** \brief Calls all event listeners to handle the events */ + void Process (); + /** \brief Queues the until Process() gets called */ + bool QueueEvent (const EventBasePtr &event); + /** \brief Calls the listener handlers immediately */ + bool TriggerEvent (const EventBasePtr &event); + + /** \brief Returns true if there is a listener for a given event type */ + bool HasEventTypeListener (const int event_type) { + return mEventTypeListeners.find(event_type) != mEventTypeListeners.end(); + } + /** \brief Returns the number of listeners for a given event type */ + unsigned int GetEventTypeListenerCount (const int event_type) { + if (!HasEventTypeListener (event_type)) + return 0; + + return (mEventTypeListeners.find(event_type))->second.size(); + } + unsigned int GetQueuedEventCount () { + return mQueuedEvents.size(); + } + + protected: + virtual int OnInit (int argc, char* argv[]); + virtual void OnDestroy(); + + private: + /** \brief Contains for each event type the list of listeners */ + std::map > mEventTypeListeners; + std::queue mQueuedEvents; +}; + +} + +#endif /* EVENTSBASE_H */ diff --git a/engine/EventsBaseGlobal.h b/engine/EventsBaseGlobal.h new file mode 100644 index 0000000..f83a8b8 --- /dev/null +++ b/engine/EventsBaseGlobal.h @@ -0,0 +1,16 @@ +#ifndef EVENTSBASEGLOBAL_H +#define EVENTSBASEGLOBAL_H + +#include "EventsBase.h" + +namespace Engine { + +/** \brief Registers a listener to a given event type */ +bool RegisterListener (const EventListenerBase *listener, const int event_type); +/** \brief Calls all event listeners to handle the events */ +bool QueueEvent (const EventBasePtr &event); +/** \brief Calls the listener handlers immediately */ +bool TriggerEvent (const EventBasePtr &event); + +} +#endif /* EVENTSBASEGLOBAL_H */ diff --git a/engine/GameEntityBase.cc b/engine/GameEntityBase.cc new file mode 100644 index 0000000..147f875 --- /dev/null +++ b/engine/GameEntityBase.cc @@ -0,0 +1,7 @@ +#include "EntityBase.h" +#include "ModelBase.h" + +namespace Engine { + +} + diff --git a/engine/Logging.cc b/engine/Logging.cc new file mode 100644 index 0000000..e9a8479 --- /dev/null +++ b/engine/Logging.cc @@ -0,0 +1,173 @@ +#include "Logging.h" + +#include +#include +#include +#include + +namespace Engine { + +static Logging *LoggingInstance = NULL; +static LogLevel requested_level = LOG_DEFAULT_LEVEL; + +/* + * Inherited Module functions + */ +int Logging::OnInit (int argc, char* argv[]) { + mPrintLevel = requested_level; + + Log (LogLevelDebug, "Logging Init"); + LoggingInstance = this; + + return 0; +} + +void Logging::OnDestroy () { + Log (LogLevelDebug, "Logging Destroy"); + + LoggingInstance = NULL; +} + +/* + * Module specific functions + */ +void Logging::Log (LogLevel level, const char *str, ...) { + if (level < mPrintLevel) + return; + + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + static int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + last_length = strlen (msg); + assert (last_length < LOG_MAX_MESSAGE_LENGTH); + + std::cout << msg << std::endl; + + LogEntry log_entry (level, msg); + mLogEntries.push_back (log_entry); +} + +void Logging::SetLogPrintLevel (LogLevel print_level) { + mPrintLevel = print_level; +} + +const LogEntry &Logging::GetLastEntry () { + static LogEntry null_message (LogLevelMessage, ""); + + if (mLogEntries.size() > 0) { + return mLogEntries[mLogEntries.size() - 1]; + } + + return null_message; +} + +/* + * Globally visible functions + */ +void SetLogPrintLevel (LogLevel print_level) { + if (!LoggingInstance) { + requested_level = print_level; + return; + } + + LoggingInstance->SetLogPrintLevel (print_level); +} + +void LogError (const char* str, ...) { + assert (LoggingInstance); + + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + static int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + last_length = strlen (msg); + assert (last_length < LOG_MAX_MESSAGE_LENGTH); + + LoggingInstance->Log (LogLevelError, msg); +} + +void LogWarning (const char* str, ...) { + assert (LoggingInstance); + + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + static int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + last_length = strlen (msg); + assert (last_length < LOG_MAX_MESSAGE_LENGTH); + + LoggingInstance->Log (LogLevelWarning, msg); +} + +void LogMessage (const char* str, ...) { + assert (LoggingInstance); + + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + static int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + last_length = strlen (msg); + assert (last_length < LOG_MAX_MESSAGE_LENGTH); + + LoggingInstance->Log (LogLevelMessage, msg); +} + +void LogDebug (const char* str, ...) { + assert (LoggingInstance); + static char msg[LOG_MAX_MESSAGE_LENGTH]; + static int last_length = LOG_MAX_MESSAGE_LENGTH; + static int i; + + for (i = 0; i < last_length; i++) + msg[i] = 0; + + va_list ap; + va_start(ap, str); + vsprintf(msg, str, ap); + va_end(ap); + + last_length = strlen (msg); + assert (last_length < LOG_MAX_MESSAGE_LENGTH); + + LoggingInstance->Log (LogLevelDebug, msg); +} + +const LogEntry& GetLastLogEntry () { + assert (LoggingInstance); + return LoggingInstance->GetLastEntry (); +} + +} diff --git a/engine/Logging.h b/engine/Logging.h new file mode 100644 index 0000000..6bb401a --- /dev/null +++ b/engine/Logging.h @@ -0,0 +1,34 @@ +#ifndef _LOGGING_H +#define _LOGGING_H + +#include "Engine.h" + +namespace Engine { +class Module; + +/** \brief All logging goes through this class + */ +class Logging : public Module { + public: + void Log (LogLevel level, const char *str, ...); + void SetLogPrintLevel (LogLevel print_level); + /** \brief Returns the last LogEntry that was sent to the Logging module + */ + const LogEntry& GetLastEntry (); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + virtual void OnDestroy (); + + private: + LogLevel mPrintLevel; + /** \brief Stores all log messages that were sent to the Logging module + * \todo Restrict the number of entries to be stored! + */ + std::vector mLogEntries; +}; + +} +#endif // _LOGGING_H diff --git a/engine/LoggingGlobal.h b/engine/LoggingGlobal.h new file mode 100644 index 0000000..ffe5322 --- /dev/null +++ b/engine/LoggingGlobal.h @@ -0,0 +1,45 @@ +#ifndef _LOGGINGLOBAL_H +#define _LOGGINGLOBAL_H + +namespace Engine { + +enum LogLevel { + LogLevelDebug = 0, + LogLevelWarning, + LogLevelMessage, + LogLevelError +}; + +/** \brief Represents a log message along with its level + */ +struct LogEntry { + LogEntry (LogLevel level, const char* message) { + mLevel = level; + mMessage = message; + } + + /** \brief the level of the message */ + LogLevel mLevel; + /** \brief the message itself */ + const char *mMessage; +}; + +/* Global visible functions */ + +/** \brief Sets the level for which messages should be printed out */ +void SetLogPrintLevel (LogLevel print_level); + +/** \brief Sends the Message to the Logging system */ +void LogError (const char* str, ...); +/** \brief Sends the Message to the Logging system */ +void LogWarning (const char* str, ...); +/** \brief Sends the Message to the Logging system */ +void LogMessage (const char* str, ...); +/** \brief Sends the Message to the Logging system */ +void LogDebug (const char* str, ...); +/** \brief Returns the last LogEntry sent to the Logging system */ +const LogEntry &GetLastLogEntry (); + +} + +#endif // _LOGGINGLOBAL_H diff --git a/engine/ModelBase.cc b/engine/ModelBase.cc new file mode 100644 index 0000000..62cc529 --- /dev/null +++ b/engine/ModelBase.cc @@ -0,0 +1,295 @@ +#include "ModelBase.h" + +#include "PhysicsBase.h" +#include "EntityBase.h" +#include "EntityFactoryBase.h" + +#include + +#include + +namespace Engine { + +static ModelBase* ModelInstance = NULL; + +/* + * Inherited Module functions + */ +int ModelBase::OnInit (int argc, char* argv[]) { + LogDebug ("Model Init"); + + ModelInstance = this; + mKilledEntities.clear (); + mEntityIdCounter = 0; + mDeltaSec = 0.; + + return 0; +} + +void ModelBase::OnDestroy () { + LogDebug ("Model Destroy"); + + std::map::iterator iter = mEntities.begin (); + std::map::iterator next = iter; + + // Since DestroyEntity () also erases the entry in mEntities iter gets + // invalid. Therefore we have to store the iterator that follows iter + while (iter != mEntities.end ()) { + next = iter; + next ++; + DestroyEntity (iter->first); + iter = next; + } + + ModelInstance = NULL; +} + +/* + * Model specific functions + */ +void ModelBase::Process () { + // Process the controllers and state of all entities + std::map::iterator entity_iter = mEntities.begin(); + do { + if (entity_iter->second == NULL) { + LogError ("Entity with id %d does not exist!", entity_iter->first); + assert (0); + } + entity_iter->second->Update(mDeltaSec); + entity_iter++; + } while (entity_iter != mEntities.end()); + + // simulate the world + mPhysics->Simulate (mDeltaSec, this); + + // remove killed entities + unsigned int i; + for (i = 0; i < mKilledEntities.size(); i++) + UnregisterEntity (mKilledEntities[i]); + + mKilledEntities.clear(); +} + +EntityBase* ModelBase::CreateEntity (int type) { + // Create a new entity id + unsigned int entity_id = CreateEntityId(); + + // Call the event + OnCreateEntity (type, entity_id); + + // Create the entity + EntityBase* result = mEntityFactory->CreateEntity (type); + result->SetId (entity_id); + + // And register it + RegisterEntity (result); + + return result; +} + +void ModelBase::RegisterEntity (EntityBase* entity) { + unsigned int id = entity->mId; + LogDebug ("Registering Entity with id '%d'", id); + + if (mEntities.find(id) != mEntities.end ()) { + LogError ("Replacing Entity with id '%d'", id); + assert (0); + } + + if (entity->mPhysicState) + mPhysics->RegisterEntity (entity->mPhysicState); + + mEntities[id] = entity; +} + +void ModelBase::KillEntity (const unsigned int id) { + std::map::iterator iter = mEntities.find (id); + + if (iter == mEntities.end ()) { + LogError ("Could not kill Entity with id '%d': Entity not found!", id); + assert (0); + return; + } else { + EntityBase *entity = iter->second; + + // call the event handler + OnKillEntity (entity); + + if (entity->mPhysicState) { + entity->mPhysicState->mAlive = false; + } + + mKilledEntities.push_back (iter->first); + } +} + +void ModelBase::UnregisterEntity (const unsigned int id) { + std::map::iterator iter = mEntities.find (id); + + if (iter == mEntities.end ()) { + LogError ("Could not unregister Entity with id '%d': Entity not found!", id); + assert (0); + return; + } else { + EntityBase *entity = iter->second; + if (entity->mPhysicState) { + mPhysics->UnregisterEntity (id); + entity->mPhysicState = NULL; + } + + delete entity; + + mEntities.erase (iter); + } +} + +EntityBase* ModelBase::GetEntity (const unsigned int id) { + std::map::iterator iter = mEntities.find (id); + + if (iter != mEntities.end ()) { + return iter->second; + } + + return NULL; +} + +unsigned int ModelBase::CreateEntityId () { + return ++mEntityIdCounter; +} + +void ModelBase::ClearEntities () { + LogDebug ("Clearing all %d entities.", mEntities.size()); + + std::map::iterator iter = mEntities.begin (); + std::map::iterator next = iter; + + // Since DestroyEntity () also erases the entry in mEntities iter gets + // invalid. Therefore we have to store the iterator that follows iter + while (iter != mEntities.end ()) { + next = iter; + next ++; + DestroyEntity (iter->first); + iter = next; + } + + mEntityIdCounter = 0; +} + +unsigned int ModelBase::GetPlayerEntityId () { + return mPlayerEntityId; +} + +/** + * \param collision_time The time when the collision occured relative to the start of the simulation frame + */ +void ModelBase::SendEntityCollisionEvent (const unsigned int reference_entity_id, + const unsigned int incidence_entity_id, float collision_time, vector3d normal) { + // Check whether we report the same contact over and over + static unsigned int last_reference_entity_id = 0; + static unsigned int last_incidence_entity_id = 0; + static float last_collision_time = -1.; + + if (!reference_entity_id || !incidence_entity_id) + return; + + if (last_reference_entity_id != 0) { + if (last_reference_entity_id == reference_entity_id + && last_incidence_entity_id == incidence_entity_id + && last_collision_time == collision_time) { + return; + } + } + + // update the last_* entries + last_reference_entity_id = reference_entity_id; + last_incidence_entity_id = incidence_entity_id; + last_collision_time = collision_time; + + // now we need to get the Entities and check whether we should + // call EntityBase::CollisionEvent() + EntityBase* reference_entity = GetEntity (reference_entity_id); + EntityBase* incidence_entity = GetEntity (incidence_entity_id); + + LogDebug ("Received collision type ref = %d type inc = %d", + reference_entity->mType, + incidence_entity->mType); + + // If the incidence entity accepted the collision we can return, otherwise + // we perform the symmetric collision event. + if (incidence_entity->CollisionEvent (reference_entity)) + return; + + reference_entity->CollisionEvent (incidence_entity); +} + +/* + * Global functions + */ +unsigned int GetPlayerEntityId () { + if (!ModelInstance) { + LogError ("Couldn't create Entity: Model not initialized!"); + assert (0); + } + + return ModelInstance->GetPlayerEntityId (); +} + +float GetFrameDuration () { + if (!ModelInstance) { + LogError ("Couldn't create Entity: Model not initialized!"); + assert (0); + } + + return ModelInstance->GetFrameDuration (); +} + +EntityBase * CreateEntity (int type) { + if (!ModelInstance) { + LogError ("Couldn't create Entity: Model not initialized!"); + assert (0); + } + + EntityBase *result = ModelInstance->CreateEntity (type); + + return result; +} + +void DestroyEntity (unsigned int id) { + if (!ModelInstance) { + LogError ("Couldn't destroy Entity: Model not initialized!"); + assert (0); + } + + ModelInstance->UnregisterEntity (id); +} + +void KillEntity (unsigned int id) { + if (!ModelInstance) { + LogError ("Couldn't kill Entity: Model not initialized!"); + assert (0); + } + + ModelInstance->KillEntity (id); +} + +EntityBase * GetEntity (unsigned int id) { + if (!ModelInstance) { + LogError ("Couldn't execute GetEntity(): Model not initialized!"); + assert (0); + } + + return ModelInstance->GetEntity (id); +} + +EntityPhysicState * GetEntityPhysicState (unsigned int id) { + EntityBase *entity = GetEntity (id); + + if (entity) + return entity->mPhysicState; + + return NULL; +} + +} + + diff --git a/engine/ModelBase.h b/engine/ModelBase.h new file mode 100644 index 0000000..6b86498 --- /dev/null +++ b/engine/ModelBase.h @@ -0,0 +1,140 @@ +#ifndef _MODELBASE_H +#define _MODELBASE_H + +#include "Engine.h" +#include "EntityBase.h" + +namespace Engine { + +class Module; +class PhysicsBase; +class Events; +class EntityFactoryBase; + +struct EntityBase; + +/** \brief Represents the current state of the Engine + * + * Represents the State of the Engine and is unaware of anything except itself. + * It manages all Entities, Physics, etc. + * + * It has the following subsystems: + * - Events + * - Physics + * - Variables + * + * \note + * To create an Entity one must call Engine::CreateEntity() which will + * allocate the Entity and performs all the required registrations by calling + * Model::RegisterEntity(). + */ +class ModelBase : public Module { + public: + /** Performs simulation, gamelogic, etc */ + virtual void Process (); + /** Updates the timer */ + void UpdateTimer () { + static float last_frame = 0; + float current_frame = static_cast (SDL_GetTicks ()) * 1.0e-3; + mDeltaSec = current_frame - last_frame; + last_frame = current_frame; + } + float GetFrameDuration () { + return mDeltaSec; + } + + /** Adds the given Entity to the Model */ + void RegisterEntity (EntityBase *entity); + /** Removes the Entity with the given id */ + void UnregisterEntity (const unsigned int id); + /** Marks an Engine::Entity as killed so that it gets removed after the + * simulation */ + void KillEntity (const unsigned int id); + + /** Creates an Entity of the given type + * + * This calls the CreateEntity() function on the Model::mEntityFactory to + * create the proper Entity and registers it to the required submodules + * (so far only Model::mPhysics). + */ + EntityBase* CreateEntity (int type); + /** Returns the Entity with the given id */ + EntityBase* GetEntity (const unsigned int id); + /** Returns a unused id for an Entity */ + unsigned int CreateEntityId (); + /** Removes all Entities */ + void ClearEntities (); + + /** Returns the id of the entity the player is currently controlling */ + unsigned int GetPlayerEntityId (); + + /** Notifies the gamelogic of a collision event */ + void SendEntityCollisionEvent (const unsigned int reference_entity_id, + const unsigned int incidence_entity_id, float collision_time, vector3d normal); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + virtual void OnDestroy (); + + /** \brief Gets called when an entity of the given type is being created */ + virtual void OnCreateEntity (const int type, const unsigned int id) {}; + /** \brief Gets called when an entity is marked to be killed */ + virtual void OnKillEntity (const EntityBase *entity) {}; + + + PhysicsBase *mPhysics; + Events *mEvents; + + /** \brief Creates Entities */ + EntityFactoryBase *mEntityFactory; + + /** \brief contains all Engine::Entities */ + std::map mEntities; + /** \brief contains all Engine::Entities that ceased to exist */ + std::vector mKilledEntities; + + unsigned int mEntityIdCounter; + unsigned int mPlayerEntityId; + + float mDeltaSec; + + friend class ViewBase; + friend class Engine; + friend class Controller; +}; + +/** \brief Creates an Entity of the given type and registers at the required modules * + * + * It allocates the memory needed to represent that specific type of Entity. + * At also performs the required registrations at the various Modules. + * + * All Entities that are created with this function get also destroyed in + * Model::Destroy () by calling DestroyEntity () for this Entity. + * + * \note All Entities must be created with this function if you intend to keep + * the different Modules in sync! + */ +EntityBase * CreateEntity (int type); + +/** \brief Frees the Memory required by the Entity and unregisters it + * + * This function also frees the memory the Entity is using in its + * different representitions such as EntityVisualState and EntityPhysicState. + * + * It also unregisters the Entity from the different Modules where it was + * registered by CreateEntity. + */ +void DestroyEntity (unsigned int id); +/** \brief Tells the model that the entity is no more existant in the game + * world */ +void KillEntity (unsigned int id); +/** \brief Returns the Entity with the given id, NULL otherwise */ +EntityBase * GetEntity (unsigned int id); +/** \brief Returns the physical state of the Entity with the given id, NULL otherwise */ +EntityPhysicState * GetEntityPhysicState (unsigned int id); + +} + +#endif // _MODEL_H diff --git a/engine/ModelBaseGlobal.h b/engine/ModelBaseGlobal.h new file mode 100644 index 0000000..c17ff8b --- /dev/null +++ b/engine/ModelBaseGlobal.h @@ -0,0 +1,15 @@ +#ifndef _MODELGLOBAL_H +#define _MODELGLOBAL_H + +namespace Engine { + +/** \brief Adds the function callback as command for the given name*/ +unsigned int GetPlayerEntityId (); + +/** \brief Returns the duration of the frame in seconds */ +float GetFrameDuration (); + +} + +#endif /* _MODELGLOBAL_H */ + diff --git a/engine/Module.h b/engine/Module.h new file mode 100644 index 0000000..d7ac06a --- /dev/null +++ b/engine/Module.h @@ -0,0 +1,51 @@ +#ifndef MODULE_H +#define MODULE_H + +namespace Engine { + +/** \brief Base class for the separate modules + * + * All Modules that are managed by the Engine::Engine base Module. Everything + * else is a Submodule of that or a Submodule of a Submodule. + */ +class Module { + public: + /** \brief Initializes the Module + * + * \note This function must only return if it was able to initialize + * successfully, otherwise it should log an error with LogError and exit + * the program itself! + * + * In general at first the Submodules get initialized and then the Module + * that has pointers to the Submodules. Exception: The main Module + * Engine::Engine. + * + * \note + * The function Engine::OnInit () performs the allocation + * and Initialization of all its Submodules. + */ + virtual int Init (int argc, char* argv[]) { return OnInit (argc, argv); } + /** \brief Frees the used memory of the Module + * + * The Destroy function is always called at first for the Module itself + * and then for its submodules so that a Module is still completely + * working. Again for the main Module Engine::Engine the reverse is the + * case (such as in Module::Init). + */ + virtual void Destroy () { OnDestroy (); } + /** \brief Calls the function that registers its commands to the + * Commandsystem */ + virtual void RegisterCommands () { OnRegisterCommands (); } + + protected: + /** \brief The actual function being called when Init () is called */ + virtual int OnInit (int argc, char* argv[]) = 0; + /** \brief Frees the memory */ + virtual void OnDestroy () { }; + /** \brief Registers the commands of the Module */ + virtual void OnRegisterCommands () { }; +}; + +} + +#endif /* MODULE_H */ diff --git a/engine/OverlayBase.h b/engine/OverlayBase.h new file mode 100644 index 0000000..b2644e5 --- /dev/null +++ b/engine/OverlayBase.h @@ -0,0 +1,25 @@ +#ifndef OVERLAY +#define OVERLAY + +#include + +namespace Engine { + +class OverlayBase { + public: + OverlayBase () {}; + virtual ~OverlayBase() {}; + + virtual bool OnKeyDown (const SDL_keysym &keysym) { return false; }; + virtual bool OnKeyUp (const SDL_keysym &keysym) { return false; }; + virtual bool OnMouseButtonUp (Uint8 button, Uint16 xpos, Uint16 ypos) { return false; }; + virtual bool OnMouseButtonDown (Uint8 button, Uint16 xpos, Uint16 ypos) { return false; }; + + virtual void Draw () = 0; + + void _strange_function_for_vtable () {}; +}; + +} + +#endif /* OVERLAY */ diff --git a/engine/PhysicsBase.cc b/engine/PhysicsBase.cc new file mode 100644 index 0000000..6a4a64f --- /dev/null +++ b/engine/PhysicsBase.cc @@ -0,0 +1,604 @@ +#include "PhysicsBase.h" +#include "EntityBase.h" + +// needed for GetEntityGameState() in ProcessCollisionEvent() +#include "ModelBase.h" + +#include "coll2d.h" + +#define EPSILON 1.0e-4 + +namespace Engine { + +/* + * Inherited Module functions + */ +int PhysicsBase::OnInit (int argc, char* argv[]) { + LogDebug ("Physics Init"); + mEntities.clear (); + + return 0; +} + +void PhysicsBase::OnDestroy () { + LogDebug ("Physics Destroy"); +} + +/* + * Module specific functions + */ + +void PhysicsBase::Move (float delta_msec) { + EntityPhysicState* entity = NULL; + std::map::iterator entity_iter; + std::map::iterator collision_iter; + vector3d velocity, orientation; + + for (entity_iter = mEntities.begin (); entity_iter != mEntities.end(); entity_iter++){ + entity = entity_iter->second; + velocity = entity->GetVelocity (); + + if (velocity.length2() == 0.) + continue; + + CheckContactCache (entity); + + entity->SetPosition (entity->GetPosition () + velocity * delta_msec); + entity->SetOrientation (vector3d(0., entity->GetOrientation()[1] + entity->GetAngleVelocity() * delta_msec, 0.)); + } +} + +int PhysicsBase::Simulate (float msec, ModelBase* model) { + vector3d velocity, orientation; + + unsigned int entity_a_id, entity_b_id; + int resolve_steps = 0;; + float current_time = 0, stepsize = msec / (float) 10; + + while (current_time < msec) { + if (msec - current_time < stepsize) + stepsize = msec - current_time; + + coll2d::CollisionInfo info; + bool collision_result = false; + + collision_result = CalcNextCollision (stepsize, entity_a_id, entity_b_id, info); + + if (collision_result == 0) { + // there is no collision, so we integrate to the end of + // the timestep + current_time += stepsize; + Move (stepsize); + } else { + LogDebug ("Collision between %u and %u", entity_a_id, entity_b_id); + float collision_remaining_step = stepsize; + resolve_steps = 0; + + // This is the collision loop. It loops until there is no collision any + // more within the stepsize. + while (collision_remaining_step > 0.) { + // with this we count how often we iterate through and can + // detect certain false behaviour + resolve_steps ++; + + // info.time tells us in what time the contact will happen and + // theoretically we can move to that point, however due to round-off + // errors we might end up in a situation where the Entities overlap + // which we must prevent to keep the collision detection working. + // + // Therefore we only move to a portion of the time and resolve the + // collision then. This alpha variable controls how much of the time + // we skip. + float alpha = 0.001; + + // If the timestep is already very small, we try to resolve it + // immediately. + if (info.time < EPSILON ) { + // if the timestep is too small we simply resolve the collision and + // do not move beforehang + LogDebug ("Time step too small ==> Resolving Step immediately"); + ResolveCollision (0., entity_a_id, entity_b_id, info); + // Send the collision event to the Model (if we have one) + if (model) { + model->SendEntityCollisionEvent (entity_a_id, entity_b_id, info.time, info.normal); + } + // collision_remaining_step -= 1.0e-4; + } else { + Move (info.time * (1 - alpha)); + LogDebug ("Resolving Step between %u and %u t = %f alpha = %f", entity_a_id, entity_b_id, info.time, alpha); + ResolveCollision (info.time * (1 - alpha), entity_a_id, entity_b_id, info); + // Send the collision event to the Model (if we have one) + if (model) { + model->SendEntityCollisionEvent (entity_a_id, entity_b_id, info.time, info.normal); + } + collision_remaining_step -= info.time * (1 - alpha); + } + + // At this point we resolved the collision we had found. Now we need + // to check whether there is a new one + collision_result = CalcNextCollision (collision_remaining_step, entity_a_id, entity_b_id, info); + + // If there was none, we happily move on to the end of the frame and + // set collision_remaining_step to 0 so that we jump out of the + // collision loop. + if (!collision_result) { + Move (collision_remaining_step); + collision_remaining_step = 0.; + break; + } + + assert (resolve_steps <= 50); + } + } + } + /* Postcondition: we simulated exactly msec milliseconds, no less, no more! */ + assert (current_time == msec); + + return 0; +} + +void PhysicsBase::RegisterEntity (EntityPhysicState* entity) { + unsigned int id = entity->mId; + LogDebug ("Registering EntityPhysicState with id '%d'", id); + if (mEntities.find (id) == mEntities.end ()) + mEntities[id] = entity; + else { + LogError ("Physics already has registered an Entity with id '%d'", id); + assert (0); + } +} + +void PhysicsBase::UnregisterEntity (const unsigned int id) { + std::map::iterator iter = mEntities.find(id); + LogDebug ("Unegistering EntityPhysicState with id '%d'", id); + + if (iter != mEntities.end ()) { + // Remove all the references of existing contacts to the Entity that is + // going to be deleted. + std::map::iterator temp_iter, contact_iter = iter->second->mContactNormals.begin(); + + while (contact_iter != iter->second->mContactNormals.end()) { + temp_iter = contact_iter; + contact_iter ++; + + ContactCacheRemove (id, temp_iter->first); + } + + // Remove the Entity from mEntities and erase the Entity + EntityPhysicState* entity_physic_state = iter->second; + mEntities.erase (iter); + + // We also have to delete the state! + if (entity_physic_state->mShape) + delete entity_physic_state->mShape; + + delete entity_physic_state; + } else { + LogError ("Could not unegister EntityPhysicState with id '%d': Entity not found!", id); + assert (0); + } +} + +/** + * This function also sorts out collisions that might be invalid such as + * Particle-Particle collision and the like. + */ +inline bool PhysicsBase::CheckPossibleCollisionPair (EntityPhysicState* entity_a, EntityPhysicState* entity_b) { + // no collision checks against itself + if (entity_a == entity_b) + return false; + + // no checks if both are static + if (entity_a->mStatic && entity_a->mStatic) + return false; + + // no checks if both are particles + if (entity_a->mBaseType == EntityBaseTypeParticle + && entity_b->mBaseType == EntityBaseTypeParticle) + return false; + + // no checks if both are particles + if (entity_a->mBaseType == EntityBaseTypeBlock + && entity_b->mBaseType == EntityBaseTypeBlock) + return false; + + return true; +} + +/** + * \param stepsize The timestep for which we want to check whether a + * collision occurs. + * \param reference_entity_id If a collision occurs the Id of the entity that + * is the reference entity is stored in this variable. + * \param incidence_entity_id If a collision occurs the Id of the entity that + * crashes into the reference entity is stored in this variable. + * \param info Contains information about the collision (normal, time, point) + * + * This function calls PhysicsBase::CheckPossibleCollisionPair() to sort out + * invalid collision pairs. + */ +bool PhysicsBase::CalcNextCollision ( + float stepsize, + unsigned int &reference_entity_id, + unsigned int &incidence_entity_id, + coll2d::CollisionInfo &info) { + std::map::iterator collision_iter; + std::map::iterator collision_ref; + + // We have to find the next collision, so we check everything and + // take the first one that will happen. + coll2d::CollisionInfo temp_info; + info.time = 2.; + + for (collision_ref = mEntities.begin (); collision_ref != mEntities.end (); collision_ref ++) { + if (collision_ref->second->mId != 0) { + collision_ref->second->UpdateShape(); + } + } + + for (collision_ref = mEntities.begin (); collision_ref != mEntities.end (); collision_ref ++) { + if (collision_ref->second->mAlive == false) + continue; + for (collision_iter = collision_ref; collision_iter != mEntities.end (); collision_iter ++) { + if (collision_iter->second->mAlive == false) + continue; + + if (!CheckPossibleCollisionPair(collision_ref->second, collision_iter->second)) + continue; + + EntityPhysicState *entity_a, *entity_b; + entity_a = collision_ref->second; + entity_b = collision_iter->second; + + int coll2d_result = coll2d::check_collision (stepsize, entity_a->mShape, entity_b->mShape, &temp_info); + + if (!HandleColl2dError (coll2d_result, stepsize, entity_a, entity_b, temp_info)) { + LogError ("Could not handle coll2d error: %d\n", coll2d_result); + assert (0); + } + + if (coll2d_result > 0 && temp_info.time < info.time ) { + info = temp_info; + + assert (info.reference_shape >= 0); + if (info.reference_shape == 0) { + reference_entity_id = collision_ref->first; + incidence_entity_id = collision_iter->first; + } else { + reference_entity_id = collision_iter->first; + incidence_entity_id = collision_ref->first; + //assert (0); + } + } + } + } + if (info.time != 2.) + return true; + + return false; +} + +/** + * This function updates the velocity of the Entity with id of + * incidence_entity_id so that it no more is in collision with with Entity + * with id reference_entity_id. Additionally to that we also cache the + * contact normals and check against them so that the new velocity does not + * violate previous contacts. + * + * We store the cached contact normals both in the incidence and the reference + * entity and we have to make sure that these references get cleared once one + * of the two get deleted! This is done in PhysicsBase::UnregisterEntity(). + */ +void PhysicsBase::ResolveCollision (float stepsize, unsigned int reference_entity_id, unsigned int incidence_entity_id, coll2d::CollisionInfo &info) { + EntityPhysicState* reference_entity = mEntities[reference_entity_id]; + EntityPhysicState* incidence_entity = mEntities[incidence_entity_id]; + + if (!reference_entity || !incidence_entity) { + LogError ("Invalid entity IDs passed to %s: %u and %u", __FUNCTION__, reference_entity_id, incidence_entity_id); + } + assert (reference_entity && incidence_entity); + + // So far only resolving of collision of sphere collisions is + // allowed + assert (dynamic_cast (incidence_entity->mShape)); + + // First we calculate the velocity along the normal and then we calculate + // the velocity that is tangential to the plane and set the new velocity to + // it. + vector3d new_velocity = incidence_entity->mVelocity; + new_velocity -= reference_entity->mVelocity; + + // It should be greater zero otherwise there was an error in the collision + // detection. + assert (new_velocity.length2 ()); + + // The scalar proj tells us how far we went along the normal + float proj = new_velocity * info.normal; + // As there is a collision, and the incidence_entity is moving towards the + // plane, this value must be strictly smaller than zero, otherwise we would + // not penetrate the plane. + if (proj > 0.) { + LogError ("Projection invalid: %e", proj); + info.doPrint ("Collision Info:\n"); + } + assert (proj < 0.); + + // Collision handling start: + // This is the code that tells us how we deal with collisions and how to + // prevent them. To get real dynamics one has to adjust this section: + vector3d old_velocity = incidence_entity->mVelocity; + new_velocity = old_velocity + info.normal * proj * (-1.0); + incidence_entity->SetVelocity (new_velocity); + // Collision handling end + + // And we also add the normal to the cached contacts for both incidence + // and reference entity + ContactCacheAdd (incidence_entity, reference_entity, info.normal); + + // Now we check whether we are violating any of the cached contacts. For + // this we loop through all contacts and try to adjust the velocity of + // incidence_entity until we no more violate the cached contacts. + std::map::iterator iter = incidence_entity->mContactNormals.begin(); + int readjust = 0; + while (iter != incidence_entity->mContactNormals.end()) { + vector3d contact_normal = iter->second; + float contact_velocity = new_velocity * contact_normal; + + if (contact_velocity < 0.) { + if (reference_entity_id == iter->first) { + // In this case, the projection was not good enough. We simultaneously + // damp the velocity and push a little harder. If it was damped too + // much or we had to readjust too often, we set the velocity to zero. + LogDebug ("Resolved collision needs to be readjusted"); + new_velocity = incidence_entity->GetVelocity(); + new_velocity *= 0.5; + if (new_velocity.length2() < EPSILON) + new_velocity.setValues (0., 0., 0.); + else + new_velocity += info.normal * 0.001; + incidence_entity->SetVelocity (new_velocity); + readjust++; + + // More than 10 readjusts? -> set velocity to zero + if (readjust > 10) + new_velocity.setValues (0., 0., 0.); + + // and we redo all the checking: + iter = incidence_entity->mContactNormals.begin(); + continue; + } + + // In this case the proposed velocity is violating another contact + // and we set the velocity to zero. + LogDebug ("Cached collision: %e -> resetting velocity", contact_velocity); +// contact_normal.print ("contact normal: "); + new_velocity.setValues (0., 0., 0.); + incidence_entity->mVelocity = new_velocity; + } else if (contact_velocity > 0.01) { + // If we move sufficiently fast away from a contact we remove the + // contact from the cache. + + // * Attention! * As the function ContactCacheRemove() deletes an entry + // of mContactNormals we have to increase the iterator *before* we + // remove the cache. Otherwise the iterator might become invalid! + unsigned int contact_id = iter->first; + iter++; + + ContactCacheRemove (contact_id, incidence_entity_id); + + continue; + } + iter++; + } +} + +/* + * Contact Cache Functions + */ +void PhysicsBase::ContactCacheAdd (EntityPhysicState* incidence_entity, EntityPhysicState* reference_entity, vector3d normal) { + incidence_entity->mContactNormals[reference_entity->mId] = normal; + reference_entity->mContactNormals[incidence_entity->mId] = normal * -1.; + + LogDebug ("Adding normal (%f,%f,%f) id=%d to entity %d", + normal[0], normal[1], normal[2], + reference_entity->mId, incidence_entity->mId); + LogDebug ("Adding normal (%f,%f,%f) id=%d to entity %d", + normal[0] * -1., normal[1] * -1., normal[2] * -1., + incidence_entity->mId, reference_entity->mId); +} + +void PhysicsBase::ContactCacheRemove (unsigned int entity_a_id, unsigned int entity_b_id) { + assert (entity_a_id != entity_b_id); + +// LogDebug ("Removing start %d and %d", entity_a_id, entity_b_id); + + EntityPhysicState *entity_a, *entity_b; + +#ifdef WIN32 + entity_a = mEntities[entity_a_id]; + entity_b = mEntities[entity_b_id]; +#else + entity_a = mEntities.at(entity_a_id); + entity_b = mEntities.at(entity_b_id); +#endif + + // Check the entries exist + assert (entity_a->mContactNormals.find (entity_b_id) != entity_a->mContactNormals.end()); + assert (entity_b->mContactNormals.find (entity_a_id) != entity_b->mContactNormals.end()); + +#ifdef WIN32 + vector3d contact_normal = entity_a->mContactNormals[entity_b_id]; +#else + vector3d contact_normal = entity_a->mContactNormals.at(entity_b_id); +#endif + + LogDebug ("Removing normal (%f,%f,%f) id=%d from entity %d", + contact_normal[0], contact_normal[1], contact_normal[2], + entity_a_id, entity_b_id); + entity_a->mContactNormals.erase (entity_a->mContactNormals.find(entity_b_id)); + +#ifdef WIN32 + contact_normal = entity_b->mContactNormals[entity_a_id]; +#else + contact_normal = entity_b->mContactNormals.at(entity_a_id); +#endif + + LogDebug ("Removing normal (%f,%f,%f) id=%d from entity %d", + contact_normal[0], contact_normal[1], contact_normal[2], + entity_b_id, entity_a_id); + entity_b->mContactNormals.erase (entity_b->mContactNormals.find(entity_a_id)); + +// LogDebug ("Removing done!"); +} + +/** \brief Checks whether we are still in contact with the entities stored in mContactNormals + * + * To check whether we still are in contact, we modify temporarily the + * velocity of the given Entity that it moves towards the contact point (i.e. + * we add the negative normal to the velocity) and re-check for a collision. + * If the collision has a time value of 0.0 and the reported normal stays the + * same, we know, that the two Entities are still in contact. If not, we lost + * contact. + * + * We can skip the test, if the scalar product of the normal and velocity are + * positive (in this case we move away from the plane) + */ +void PhysicsBase::CheckContactCache (EntityPhysicState* entity) { + std::map::iterator contacts_iter, current_iter; + + contacts_iter = entity->mContactNormals.begin(); + while (contacts_iter != entity->mContactNormals.end()) { + // * Attention! * + // current_iter can be used throughout this environment and contacts_iter + // can already now be increased as it *must not* be used! This is due to + // the nature of ContactCachRemove() which might make contacts_iter + // invalid if we were using that. + current_iter = contacts_iter; + contacts_iter ++; + + unsigned int contact_entity_id = contacts_iter->first; + +#ifdef WIN32 + EntityPhysicState* contact_entity = mEntities[contact_entity_id]; +#else + EntityPhysicState* contact_entity = mEntities.at (contact_entity_id); +#endif + + vector3d normal = contacts_iter->second; + vector3d old_velocity = entity->GetVelocity(); + + // If we already move away from the normal, we delete the contact. + if (normal * old_velocity > 0.01) { + LogDebug ("Lost Contact with entity %d!", current_iter->first); + ContactCacheRemove (entity->mId, current_iter->first); + continue; + } else { + vector3d new_velocity (old_velocity); + new_velocity -= normal; + entity->SetVelocity (new_velocity); + + entity->UpdateShape(); + contact_entity->UpdateShape(); + + coll2d::CollisionInfo info; + int coll2d_result; + + coll2d_result = coll2d::check_collision (1.0, entity->mShape, contact_entity->mShape, &info); + + if (!HandleColl2dError (coll2d_result, 1.0, entity, contact_entity, info)) { + // error + LogError ("Error when performing collision check: %s\n", __FUNCTION__); + assert (0); + } + + if (coll2d_result == 0) { + // no contact, so delete it: + LogDebug ("Lost Contact with entity %d!", current_iter->first); + ContactCacheRemove (entity->mId, current_iter->first); + + entity->SetVelocity (old_velocity); + continue; + } else if ( coll2d_result > 0){ + // contact + if (info.time != 0. || normal != info.normal) { + LogError ("Something strange happened when checking for contacts in %s\n", __FUNCTION__); + assert (0); + } + } + + entity->SetVelocity (old_velocity); + } + } +} + +/** + * So far we ignore overlapping if one entity is an EntityBaseTypeActor and + * the other a EntityBaseTypeParticle. + * + * If this function returns true everything is ok and we can safely continue + * otherwise it is recommended to quit the application. + * + * \returns true if there was no error at all or we were able to deal with it + */ +bool PhysicsBase::HandleColl2dError (int coll2d_result, float stepsize, + EntityPhysicState* entity_a, EntityPhysicState* entity_b, coll2d::CollisionInfo &info) +{ + if (coll2d_result < 0) { + if (coll2d_result == CHECK_ERROR_OVERLAP) { + // this can happen if an Actor is faster than its thrown Particle, + // we ignore this for now + /// \todo Handle overlaps of Actors and Particles better or define clear guidelines. Note this also in Entity.h + if ( (entity_a->mBaseType == EntityBaseTypeParticle && entity_b->mBaseType == EntityBaseTypeActor) + || (entity_b->mBaseType == EntityBaseTypeParticle && entity_a->mBaseType == EntityBaseTypeActor) ) + LogDebug ("Ignoring CHECK_ERROR_OVERLAP"); + return true; + } else { + LogError ("coll2d Error: %d (stepsize = %f, id_a = %d, id_b = %d)", coll2d_result, stepsize, entity_a->mId, entity_b->mId); + entity_a->mShape->doPrint ("Debug: entity_a"); + entity_b->mShape->doPrint ("Debug: entity_b"); + return false; + } + } + + return true; +} + +EntityPhysicState* CreateEntityPhysicState (EntityBaseType type, unsigned int id) { + EntityPhysicState* entity_physics = new EntityPhysicState (); + if (!entity_physics) { + LogError ("Could not allocate enough memory for EntityPhysicState of type '%d'", type); + assert (0); + } + // default values for all Entities + entity_physics->mId = id; + entity_physics->mBaseType = type; + + // specific values for each Entity type + if (type == EntityBaseTypeNone) { + entity_physics->mShape = new coll2d::Sphere (0.01); + assert (entity_physics->mShape); + } else if (type == EntityBaseTypeActor) { + entity_physics->mShape = new coll2d::Sphere (0.4); + assert (entity_physics->mShape); + } else if (type == EntityBaseTypeBlock) { + entity_physics->mShape = new coll2d::Polygon (4); + assert (entity_physics->mShape); + + static_cast (entity_physics->mShape)->setVertice (0, vector3d (-0.5, 0., 0.5)); + static_cast (entity_physics->mShape)->setVertice (1, vector3d (0.5, 0., 0.5)); + static_cast (entity_physics->mShape)->setVertice (2, vector3d (0.5, 0., -0.5)); + static_cast (entity_physics->mShape)->setVertice (3, vector3d (-0.5, 0., -0.5)); + } else if (type == EntityBaseTypeParticle) { + entity_physics->mShape = new coll2d::Sphere (0.05); + assert (entity_physics->mShape); + } else { + LogError ("No EntityPhysicState defined for Entity type '%d'", type); + assert (0); + } + + return entity_physics; +} + +} + + diff --git a/engine/PhysicsBase.h b/engine/PhysicsBase.h new file mode 100644 index 0000000..9e651c1 --- /dev/null +++ b/engine/PhysicsBase.h @@ -0,0 +1,91 @@ +#ifndef _PHYSICSBASE_H +#define _PHYSICSBASE_H + +#include "Engine.h" +#include "EntityBase.h" + +namespace coll2d { + struct CollisionInfo; +} + +/// \todo get rid of this forward declaration somehow +struct vector3d; + +namespace Engine { + +class Module; +class Events; + +class EntityPhysicState; + +/** \brief Performs the physical simulation of all Entities + * + * This class defines how the physical simulation is performed. Especially how + * collisions are treated is defined in the function + * Physics::ResolveCollision() . This function can be modified to simulate + * dynamics effects such as friction, bouncing, stacking etc.. + * + * \todo When running along multiple boxes that are perfectly aligned one hangs from time to time at the last box + */ +class PhysicsBase : public Module { + public: + /** \brief Performs the simulation for the next msec milliseconds + * \param msec The amount of time that is to be simulated + * \param model A pointer to the model that will be used to pass on collision events.*/ + virtual int Simulate (float msec, ModelBase* model = NULL); + /** \brief Registers the physical state of an Entity */ + virtual void RegisterEntity (EntityPhysicState* entity); + /** \brief Unregisters the physical state of an Entity */ + virtual void UnregisterEntity (const unsigned int id); + + protected: + /** \brief Initializes the system */ + virtual int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + virtual void OnDestroy (); + + /** \brief Moves all Entities for delta_msec milliseconds (can be + * negative!) */ + void Move (float delta_msec); + + /** \brief Checks whether two given Entities can collide */ + bool CheckPossibleCollisionPair (EntityPhysicState* entity_a, EntityPhysicState* entity_b); + /** \brief Calculates the next pair of Entities that will collide */ + bool CalcNextCollision (float stepsize, + unsigned int &reference_entity_id, + unsigned int &incidence_entity_id, + coll2d::CollisionInfo &info); + /** \brief Resolves the collision that CalcNextCollision has found + * It resolves a found collision and prevents interpenetration of cached contacts. + */ + void ResolveCollision (float stepsize, + unsigned int reference_entity_id, + unsigned int incidence_entity_id, + coll2d::CollisionInfo &info); + + /** \brief Contains all Entities with a physical state */ + std::map mEntities; + + private: + /** \brief Caches the contact information between two entities + */ + void ContactCacheAdd (EntityPhysicState* incidence_entity, EntityPhysicState* reference_entity, vector3d normal); + /** \brief Removes the contact cache information of two entities in contact + */ + void ContactCacheRemove (unsigned int entity_a_id, unsigned int entity_b_id); + /** \brief Checks whether the entries in the contact cache are still valid + */ + void CheckContactCache (EntityPhysicState* entity); + + /** \brief Allows to ignore certain kinds of errors reported by coll2d + */ + bool HandleColl2dError (int coll2d_result, float stepsize, + EntityPhysicState* entity_a, EntityPhysicState* entity_b, coll2d::CollisionInfo &info); +}; + +/** \brief Creates an EntityPhysicState with all the required information */ +EntityPhysicState* CreateEntityPhysicState (EntityBaseType type, unsigned int id); + +} + +#endif // _PHYSICSBASE_H diff --git a/engine/PhysicsEntityBase.cc b/engine/PhysicsEntityBase.cc new file mode 100644 index 0000000..043f836 --- /dev/null +++ b/engine/PhysicsEntityBase.cc @@ -0,0 +1,149 @@ +#include "EntityBase.h" + +#include "coll2d.h" + +namespace Engine { + +/** \brief Copy constructor */ +inline EntityPhysicState::EntityPhysicState (const EntityPhysicState& state): + mId (state.mId), + mBaseType (state.mBaseType), + mPosition (state.mPosition), + mOrientation (state.mOrientation), + mVelocity (state.mVelocity), + mAngleVelocity (state.mAngleVelocity), + mStatic (state.mStatic), + mAlive (state.mAlive), + mContactNormals(state.mContactNormals) +{ + mShape = state.mShape->getCopy(); +}; + +/** \brief Assignment operator */ +inline EntityPhysicState& EntityPhysicState::operator= (const EntityPhysicState& state) { + if (this != &state) { + mId = state.mId; + mBaseType = state.mBaseType; + mPosition = state.mPosition; + mOrientation = state.mOrientation; + mVelocity = state.mVelocity; + mAngleVelocity = state.mAngleVelocity; + mShape = state.mShape->getCopy(); + mStatic = state.mStatic; + mAlive = state.mAlive; + mContactNormals = state.mContactNormals; + } + + return *this; +} + +vector3d& EntityPhysicState::GetPosition () { + return mPosition; +} + +vector3d& EntityPhysicState::GetVelocity () { + return mVelocity; +} + +vector3d& EntityPhysicState::GetOrientation () { + return mOrientation; +} + +float& EntityPhysicState::GetAngleVelocity () { + return mAngleVelocity; +} + +void EntityPhysicState::SetPosition (const vector3d &position) { + mPosition = position; +} + +void EntityPhysicState::SetVelocity (const vector3d &velocity) { + mVelocity = velocity; +} + +void EntityPhysicState::SetOrientation (const vector3d &orientation) { + mOrientation = orientation; +} + +void EntityPhysicState::SetAngleVelocity (const float &angle_velocity) { + mAngleVelocity = angle_velocity; +} + +void EntityPhysicState::Globalize (vector3d &vec) { + // make a copy of the local coordinates + vector3d local (vec); + + // calculate sin and cos for the current rotation + float sintheta, costheta; + sintheta = sin (- mOrientation[1] * M_PI / 180); + costheta = cos (- mOrientation[1] * M_PI / 180); + + // rotation + vec[0] = - sintheta * local[2] + costheta * local[0]; + vec[1] = local[1]; + vec[2] = costheta * local[2] + sintheta * local[0] ; + + // and translation + vec += mPosition; +} + +void EntityPhysicState::Localize (vector3d &vec) { + // translation + vec -= mPosition; + + vector3d global (vec); + + // calculate sin and cos for the current rotation + float sintheta, costheta; + sintheta = sin (mOrientation[1] * M_PI / 180); + costheta = cos (mOrientation[1] * M_PI / 180); + + // rotation + vec[0] = - sintheta * global[2] + costheta * global[0]; + vec[1] = global[1]; + vec[2] = costheta * global[2] + sintheta * global[0] ; +} + +void EntityPhysicState::GlobalizeRotation (vector3d &vec) { + // make a copy of the local coordinates + vector3d local (vec); + + // calculate sin and cos for the current rotation + float sintheta, costheta; + sintheta = sin (- mOrientation[1] * M_PI / 180); + costheta = cos (- mOrientation[1] * M_PI / 180); + + // rotation + vec[0] = - sintheta * local[2] + costheta * local[0]; + vec[1] = local[1]; + vec[2] = costheta * local[2] + sintheta * local[0] ; +} + +void EntityPhysicState::LocalizeRotation (vector3d &vec) { + vector3d global (vec); + + // calculate sin and cos for the current rotation + float sintheta, costheta; + sintheta = sin (mOrientation[1] * M_PI / 180); + costheta = cos (mOrientation[1] * M_PI / 180); + + // rotation + vec[0] = - sintheta * global[2] + costheta * global[0]; + vec[1] = global[1]; + vec[2] = costheta * global[2] + sintheta * global[0] ; +} + + +void EntityPhysicState::UpdateShape () { + assert (mShape); + + mShape->setPosition (mPosition); + mShape->setAngle (mOrientation[1] * M_PI / 180); + + mShape->setVelocity (mVelocity); + mShape->setAngleVelocity (mAngleVelocity); +} + + +} + diff --git a/engine/SimpleConsoleOverlay.cc b/engine/SimpleConsoleOverlay.cc new file mode 100644 index 0000000..f4bef21 --- /dev/null +++ b/engine/SimpleConsoleOverlay.cc @@ -0,0 +1,220 @@ +#include "DrawingsGL.h" +#include "OverlayBase.h" +#include "SimpleConsoleOverlay.h" + +#include "OGLFT.h" + +#include +#include + +namespace Engine { + +static Variable Var_ConsoleTransparency ("consoletransparency", "0.2"); + +bool SimpleConsoleOverlay::OnKeyDown (const SDL_keysym &keysym) { + if (keysym.sym == SDLK_F8) { + if (mActive) { + // We have to call SetActive() to actually + // activate the unicode processing of SDL + SetActive (false); + } + else { + SetActive (true); + } + + return true; + } + + if (!mActive) + return false; + + // check for input that requires actions + switch (keysym.sym) { + case SDLK_ESCAPE: + SetActive (false); + return true; + break; + case SDLK_BACKSPACE: + if (mCurrentInput.size() > 0) + mCurrentInput = mCurrentInput.substr (0, mCurrentInput.size() - 1 ); + return true; + break; + case SDLK_RETURN: + if (mCurrentInput.size() == 0) { + mLastLines.push_back (""); + return true; + } + + mLastLines.push_back (mCurrentInput); + + // run the command and print out the error if there was one + if (!RunCommand (mCurrentInput)) { + mLastLines.push_back ("Error: " + CommandGetErrorString()); + } + mCurrentInput = ""; + return true; + + break; + default: + break; + } + + // if we got input of a character that we can write add it to the current + // input + if (keysym.unicode) { + if ((keysym.unicode & 0xFF80) == 0) { + mCurrentInput += keysym.unicode & 0x7F; + return true; + } else { + LogWarning ("Input key not supported!"); + return false; + } + } + + return true; +} + +void SimpleConsoleOverlay::Draw () { + // we switch to orthographic projection and draw the contents of the 2d + // overlay on top of the previous drawings + glMatrixMode (GL_PROJECTION); + glPushMatrix (); + glLoadIdentity (); + + // first we have to get the size of the current viewport to set up the + // orthographic projection correctly + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + gluOrtho2D (viewport[0], viewport[2], viewport[3], viewport[1]); + + glMatrixMode (GL_MODELVIEW); + glPushMatrix (); + glLoadIdentity (); + + // then we do the drawings + if (mDrawLogBar) + DrawLogBar (); + if (mActive) + DrawConsole (); + + glPopMatrix (); + + glMatrixMode (GL_PROJECTION); + glPopMatrix (); + + glMatrixMode (GL_MODELVIEW); + +}; + +void SimpleConsoleOverlay::DrawLogBar () { + // first we have to get the size of the current viewport to set up the + // orthographic projection correctly + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + + // we want to enable transparency + glDisable(GL_DEPTH_TEST); + glEnable (GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA); + + float left = 0; + float right = static_cast (GetWindowWidth()); + float top = 0; +// float bottom = static_cast (GetWindowHeight()); + + // draw the background + glColor4f (0.2, 0.2, 0.2, 0.3); + glBegin (GL_QUADS); + glVertex2f (left, top); + glVertex2f (left, top + 16); + glVertex2f (right, top + 16); + glVertex2f (right, top); + glEnd (); + + glDisable (GL_BLEND); + + // draw the log + std::ostringstream topbar_stream; + topbar_stream << "Log: " << GetLastLogEntry().mMessage; + DrawGLString ( 10, 10, topbar_stream.str().c_str ()); + + // draw the FPS counter + topbar_stream.str (""); + topbar_stream << "FPS: " << GetFrameRate(); + DrawGLString (right - 64 , 10, topbar_stream.str().c_str ()); + + glEnable (GL_DEPTH_TEST); +} + +void SimpleConsoleOverlay::DrawConsole () { + // first we have to get the size of the current viewport to set up the + // orthographic projection correctly + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + + // we want to enable transparency + glDisable(GL_DEPTH_TEST); +// glEnable (GL_BLEND); +// glBlendFunc(GL_SRC_ALPHA, GL_ONE); +// glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA); + + // calculate the screen coordinates which defines the size of the + // console + mLeft = (viewport[2] - viewport[0]) * 0.5 - (viewport[2] - viewport[0]) * 0.45 ; + mRight = (viewport[2] - viewport[0]) * 0.5 + (viewport[2] - viewport[0]) * 0.45; + mTop = -1; // Do not draw the mTop line + mBottom = (viewport[3] - viewport[1]) * 0.7; + + // draw the background + glColor4f (0.2, 0.2, 0.2, Var_ConsoleTransparency.GetFloatValue()); + glBegin (GL_QUADS); + glVertex2f (mLeft, mTop); + glVertex2f (mLeft, mBottom); + glVertex2f (mRight, mBottom); + glVertex2f (mRight, mTop); + glEnd (); + + // draw borders + glColor3f (0.9, 0.9, 0.9); + glBegin (GL_LINE_STRIP); + glVertex2f (mLeft, mTop); + glVertex2f (mLeft, mBottom); + glVertex2f (mRight, mBottom); + glVertex2f (mRight, mTop); + glVertex2f (mLeft, mTop); + glEnd (); + + glDisable (GL_BLEND); + + // now draw the contents + DrawLastLines (); + DrawCurrentInput (); + + glEnable (GL_DEPTH_TEST); +} + +const std::vector SimpleConsoleOverlay::GetLastLines (const unsigned int n) { + assert (0); + std::vector result; + return result; +} + +void SimpleConsoleOverlay::DrawLastLines () { + unsigned int i; + for (i = 0; i < mLastLines.size(); i++) + DrawGLString (mLeft + 8, mTop + 12 + 12 *i, mLastLines[i].c_str()); +} + +void SimpleConsoleOverlay::DrawCurrentInput () { + // We add a '_' to the current input as a simple cursor + static std::string current_input; + current_input = mCurrentInput + "_"; + + // We add a '>' at the beginning of the input line to highlight it + DrawGLString (mLeft, mTop + 12 + 12 * (mLastLines.size()), ">"); + DrawGLString (mLeft + 8, mTop + 12 + 12 * (mLastLines.size()), current_input.c_str()); +} + + + +} diff --git a/engine/SimpleConsoleOverlay.h b/engine/SimpleConsoleOverlay.h new file mode 100644 index 0000000..64064fe --- /dev/null +++ b/engine/SimpleConsoleOverlay.h @@ -0,0 +1,69 @@ +#ifndef SIMPLECONSOLEOVERLAY +#define SIMPLECONSOLEOVERLAY + +#include "Variables.h" + +#include +#include + +namespace Engine { + +class OverlayBase; + +class SimpleConsoleOverlay : public OverlayBase { + public: + SimpleConsoleOverlay () { + mActive = false; + mDrawLogBar = false; + }; + virtual ~SimpleConsoleOverlay() {}; + + virtual bool OnKeyDown (const SDL_keysym &keysym); + virtual bool OnKeyUp (const SDL_keysym &keysym) { + if(mActive) + return true; + return false; + }; + + virtual void Draw (); + + void DrawLogBar (); + void DrawConsole (); + + /** \brief Returns the last n lines */ + const std::vector GetLastLines (const unsigned int n); + /** \brief Returns true if the Console is active */ + bool GetActive () { return mActive; }; + /** \brief Activates or deactivates the the Console */ + void SetActive (bool active) { + if (active) { + SDL_EnableUNICODE (1); + SDL_EnableKeyRepeat (500, 50); + } + else { + SDL_EnableUNICODE (-1); + SDL_EnableKeyRepeat (0, 100); + } + mActive = active; + }; + void SetDrawLogBar (bool value) { mDrawLogBar = value; }; + + /** \brief Draws the console with the current content */ + void DrawLastLines (); + void DrawCurrentInput (); + + private: + std::vector mLastLines; + std::string mCurrentInput; + bool mActive; + bool mDrawLogBar; + + float mLeft; + float mTop; + float mRight; + float mBottom; +}; + +} + +#endif /* SIMPLECONSOLEOVERLAY */ diff --git a/engine/Sprite.cc b/engine/Sprite.cc new file mode 100644 index 0000000..caf9dd3 --- /dev/null +++ b/engine/Sprite.cc @@ -0,0 +1,237 @@ +#include "Engine.h" +#include "Sprite.h" + +#include +#include +#include + +#include + +namespace Engine { + +/* + * Code is taken from http://en.wikibooks.org/wiki/OpenGL_Programming/Intermediate/Textures on + * Sunday, March 14 2010. + */ +bool Sprite::LoadFromPNG (const char *filename) { + LogDebug ("Loading png from %s", filename); + + //header for testing if it is a png + png_byte header[8]; + + //open file as binary + FILE *fp = fopen(filename, "rb"); + if (!fp) { + LogError ("Could not open file: %s", filename); + return false; + } + + //read the header + fread(header, 1, 8, fp); + + //test if png + int is_png = !png_sig_cmp(header, 0, 8); + if (!is_png) { + LogError ("Error opening png file %s: file is not a png file!", filename); + fclose(fp); + return false; + } + + //create png struct + png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, + NULL, NULL); + if (!png_ptr) { + LogError ("Error opening png file %s: unable to read png header", filename); + fclose(fp); + return (false); + } + + //create png info struct + png_infop info_ptr = png_create_info_struct(png_ptr); + if (!info_ptr) { + LogError ("Error opening png file %s: unable to read png header", filename); + png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL); + fclose(fp); + return (false); + } + + //create png info struct + png_infop end_info = png_create_info_struct(png_ptr); + if (!end_info) { + LogError ("Error opening png file %s: unable to read png header", filename); + png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL); + fclose(fp); + return (false); + } + + //png error stuff, not sure libpng man suggests this. + if (setjmp(png_jmpbuf(png_ptr))) { + LogError ("Error opening png file %s: unable to read png header", filename); + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); + fclose(fp); + return (false); + } + + //init png reading + png_init_io(png_ptr, fp); + + //let libpng know you already read the first 8 bytes + png_set_sig_bytes(png_ptr, 8); + + // read all the info up to the image data + png_read_info(png_ptr, info_ptr); + + //variables to pass to get info + int bit_depth, color_type; + png_uint_32 tmWidth, tmHeight; + + // get info about png + png_get_IHDR(png_ptr, info_ptr, &tmWidth, &tmHeight, &bit_depth, &color_type, + NULL, NULL, NULL); + + //update mWidth and mHeight based on png info + mWidth = tmWidth; + mHeight = tmHeight; + + // Update the png info struct. + png_read_update_info(png_ptr, info_ptr); + + // Row size in bytes. + int rowbytes = png_get_rowbytes(png_ptr, info_ptr); + + // Allocate the image_data as a big block, to be given to opengl + png_byte *image_data = new png_byte[rowbytes * mHeight]; + if (!image_data) { + //clean up memory and close stuff + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); + fclose(fp); + return false; + } + + //row_pointers is for pointing to image_data for reading the png with libpng + png_bytep *row_pointers = new png_bytep[mHeight]; + if (!row_pointers) { + //clean up memory and close stuff + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); + delete[] image_data; + fclose(fp); + return false; + } + // set the individual row_pointers to point at the correct offsets of image_data + for (unsigned int i = 0; i < mHeight; ++i) + row_pointers[mHeight - 1 - i] = image_data + i * rowbytes; + + //read the png into image_data through row_pointers + png_read_image(png_ptr, row_pointers); + + //Now generate the OpenGL texture object + glGenTextures(1, &mGlTextureName); + glBindTexture(GL_TEXTURE_2D, mGlTextureName); + glTexImage2D(GL_TEXTURE_2D,0, GL_RGBA, mWidth, mHeight, 0, + GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*) image_data); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + + //clean up memory and close stuff + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); + delete[] row_pointers; + delete[] image_data; + + fclose(fp); + + return true; +} + +void Sprite::DrawAt (float xpos, float ypos, float zpos) { + float u_start = 0., u_end = 1.; + if (mAnimation) { + int frame_index = floor ( (mAnimationFrameRate) * mAnimationTimer); + u_start = static_cast(frame_index) / mAnimationFrameCount; + u_end = (frame_index + 1.) / mAnimationFrameCount; + } + + glPushMatrix(); + glTranslatef (xpos -mScale * mWidth * 0.5, ypos, zpos -mScale * mHeight * 0.5); + glScalef (mScale, mScale, mScale); + glDisable(GL_DEPTH_TEST); + glEnable(GL_TEXTURE_2D); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glBindTexture (GL_TEXTURE_2D, mGlTextureName); + + glBegin(GL_QUADS); + glTexCoord2f (u_start, 0.); glVertex3f (0., 0., 0.); + glTexCoord2f (u_end, 0.); glVertex3f (0., 0., mHeight); + glTexCoord2f (u_end, 1.); glVertex3f (mWidth, 0., mHeight); + glTexCoord2f (u_start, 1.); glVertex3f (mWidth, 0.,0.); + glEnd(); + + glPopMatrix(); + + glDisable(GL_TEXTURE_2D); + glEnable(GL_DEPTH_TEST); +} + +void Sprite::DrawAt2D (float xpos, float ypos) { + float u_start = 0., u_end = 1.; + if (mAnimation) { + int frame_index = floor ( (mAnimationFrameRate) * mAnimationTimer); + u_start = static_cast(frame_index) / mAnimationFrameCount; + u_end = (frame_index + 1.) / mAnimationFrameCount; + } + + glPushMatrix(); + glTranslatef (xpos -mScale * mWidth * 0.5, ypos, 0.); + glScalef (mScale, mScale, mScale); + // \TODO Make 2d drawing of sprites a bit nicer, seems a bit overkill for such a simple function + glRotatef (-90, 0., 0., 1.); + glDisable(GL_DEPTH_TEST); + glEnable(GL_TEXTURE_2D); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glBindTexture (GL_TEXTURE_2D, mGlTextureName); + + glBegin(GL_QUADS); + glTexCoord2f (u_start, 0.); glVertex2f (0., 0.); + glTexCoord2f (u_end, 0.); glVertex2f (0., mHeight); + glTexCoord2f (u_end, 1.); glVertex2f (mWidth, mHeight); + glTexCoord2f (u_start, 1.); glVertex2f (mWidth,0.); + glEnd(); + + glPopMatrix(); + + glDisable(GL_TEXTURE_2D); + glEnable(GL_DEPTH_TEST); +} + +void Sprite::DrawSubAt (unsigned int index, float xpos, float ypos, float zpos) { + assert (index < mSubSpriteCount); + + float u_start = static_cast(index) / mSubSpriteCount; + float u_end = (index + 1.) / mSubSpriteCount; + + glPushMatrix(); + glTranslatef (xpos -mScale * mWidth * 0.5, ypos, zpos -mScale * mHeight * 0.5); + glScalef (mScale, mScale, mScale); + glDisable(GL_DEPTH_TEST); + glEnable(GL_TEXTURE_2D); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glBindTexture (GL_TEXTURE_2D, mGlTextureName); + + glBegin(GL_QUADS); + glTexCoord2f (u_start, 0.); glVertex3f (0., 0., 0.); + glTexCoord2f (u_end, 0.); glVertex3f (0., 0., mHeight); + glTexCoord2f (u_end, 1.); glVertex3f (mWidth, 0., mHeight); + glTexCoord2f (u_start, 1.); glVertex3f (mWidth, 0.,0.); + glEnd(); + + glPopMatrix(); + + glDisable(GL_TEXTURE_2D); + glEnable(GL_DEPTH_TEST); +} + +} diff --git a/engine/Sprite.h b/engine/Sprite.h new file mode 100644 index 0000000..411856a --- /dev/null +++ b/engine/Sprite.h @@ -0,0 +1,71 @@ +#ifndef SPRITE_H +#define SPRITE_H + +#include + +namespace Engine { + +class Sprite { + public: + Sprite() { + mScale = 1.; + mWidth = 0; + mHeight = 0; + mGlTextureName = 0; + + mAnimation = false; + mSubSpriteCount = 1; + } + + bool LoadFromPNG (const char *filename); + void DrawAt (float xpos, float ypos, float zpos); + void DrawAt2D (float xpos, float ypos); + unsigned int GetWidth() { return mWidth; }; + unsigned int GetHeight() { return mHeight; }; + + void SetScale (float scale) { mScale = scale; }; + + void SetAnimation (int frame_count, float frame_rate) { + mAnimation = true; + mAnimationFrameCount = frame_count; + mAnimationFrameRate = frame_rate; + mAnimationTimer = 0.; + mWidth = static_cast(ceil (static_cast (mWidth / mAnimationFrameCount))); + } + void ResetAnimation () { + mAnimationTimer = 0.; + } + void UpdateAnimation (float seconds) { + mAnimationTimer += seconds; + while (mAnimationTimer >= mAnimationFrameCount / mAnimationFrameRate) { + mAnimationTimer -= mAnimationFrameCount / mAnimationFrameRate; + } + } + + void SetSubSpriteCount (const unsigned int count) { + mSubSpriteCount = count; + mWidth = static_cast(ceil (static_cast (mWidth / mSubSpriteCount))); + } + unsigned int GetSubSpriteCount () const { + return mSubSpriteCount; + } + void DrawSubAt (unsigned int index, float xpos, float ypos, float zpos); + + private: + float mScale; + + unsigned int mWidth; + unsigned int mHeight; + unsigned int mGlTextureName; + + unsigned int mSubSpriteCount; + + bool mAnimation; + int mAnimationFrameCount; + float mAnimationTimer; + float mAnimationFrameRate; +}; + +} + +#endif /* SPRITE_H */ diff --git a/engine/Variables.cc b/engine/Variables.cc new file mode 100644 index 0000000..6017385 --- /dev/null +++ b/engine/Variables.cc @@ -0,0 +1,159 @@ +#include "Variables.h" + +#include +#include + +namespace Engine { + +Variables* VariablesInstance = NULL; + +/* + * Inherited Module functions + */ +int Variables::OnInit (int argc, char* argv[]) { + LogDebug ("Variables Init"); + + VariablesInstance = this; + + /* This definition of a variable causes the delayed variables to be loaded, + * please keep it here! */ + static Variable VariableSystemUp_var ("variablesystemup", "true"); + + return 0; +} + +void Variables::OnDestroy () { + LogDebug ("Variables Destroy"); + + VariablesInstance = NULL; +} + +/* + * Module specific functions + */ +void Variables::RegisterVariable (const std::string &name, Variable *var) { + LogDebug ("Registering Variable '%s'", name.c_str ()); + if (mVariablesData.find (name) != mVariablesData.end()) { + // Variable already existing! + mVariablesData[name] = var; + + return; + } + + mVariablesData[name] = var; + + return; +} + +/* + * Variable class + */ +Variable* Variables::GetVariable (const std::string &name) { + if (mVariablesData.find (name) == mVariablesData.end()) { + // Variable not existing! + return NULL; + } + + return mVariablesData[name]; +} + +Variable::Variable (const std::string &name, const std::string &value) { + static std::vector delayed_variables; + + mName = name; + mStringValue = value; + mFloatValue = atof (value.c_str()); + + if (VariablesInstance == NULL) { + delayed_variables.push_back (this); + } else if (delayed_variables.size() > 0) { + LogDebug ("Loading delayed Variables"); + unsigned int i; + for (i = 0; i < delayed_variables.size(); i ++) + VariablesInstance->RegisterVariable (delayed_variables[i]->mName, delayed_variables[i]); + + delayed_variables.clear (); + + RegisterVariable (name); + } else { + RegisterVariable (name); + } +} + +void Variable::RegisterVariable (const std::string &name) { + if (! VariablesInstance ) { + LogError ("Unable to register Variable '%s': Variables System not initialized!", name.c_str()); + return; + } + + VariablesInstance->RegisterVariable (name, this); +} + +/* + * Global functions + */ +Variable* GetVariable (const std::string &name) { + if (! VariablesInstance ) { + LogError ("Unable to register Variable '%s': Variables System not initialized!", name.c_str()); + return NULL; + } + + return VariablesInstance->GetVariable (name); +} + +bool SetVariableValue (const std::string &name, const std::string value) { + if (! VariablesInstance ) { + LogError ("Unable to set Variable '%s': Variables System not initialized!", name.c_str()); + return false; + } + + Variable *var = VariablesInstance->GetVariable (name); + if (!var) { + return false; + } + + var->SetStringValue (value); + var->SetFloatValue (atof (value.c_str())); + + return true; +} + +std::string& GetVariableString (const std::string &name, std::string def) { + /* We use a static result variable for the case that def was not passed to + * is function */ + static std::string def_result = def; + + if (! VariablesInstance ) { + LogError ("Unable to register Variable '%s': Variables System not initialized!", name.c_str()); + return def_result; + } + + Variable *var = VariablesInstance->GetVariable (name); + if (!var) { + return def_result; + } + + return var->GetStringValue (); +} + +float &GetVariableFloat (const std::string &name, float def) { + /* We use a static result variable for the case that def was not passed to + * is function */ + static float def_result = def; + + if (! VariablesInstance ) { + LogError ("Unable to register Variable '%s': Variables System not initialized!", name.c_str()); + return def_result; + } + + Variable *var = VariablesInstance->GetVariable (name); + if (!var) { + return def_result; + } + + return var->GetFloatValue (); +} + + +} + diff --git a/engine/Variables.h b/engine/Variables.h new file mode 100644 index 0000000..daf6461 --- /dev/null +++ b/engine/Variables.h @@ -0,0 +1,37 @@ +#ifndef _VARIABLES_H +#define _VARIABLES_H + +#include "Engine.h" + +#include +#include +#include + +namespace Engine { + +class Module; +class Variable; + +/** \brief Manages all variables that can be changed by the Model itself + * + * \todo make the variable names case insensitive + * \todo only allow certain characters in variable names + */ +class Variables : public Module{ + public: + void RegisterVariable (const std::string &name, Variable *var); + Variable *GetVariable (const std::string &name); + + protected: + /** \brief Initializes the system */ + int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + void OnDestroy (); + void OnRegisterCommands (); + + std::map mVariablesData; +}; + +} + +#endif // _VARIABLES_H diff --git a/engine/VariablesCommands.cc b/engine/VariablesCommands.cc new file mode 100644 index 0000000..a3ed9d9 --- /dev/null +++ b/engine/VariablesCommands.cc @@ -0,0 +1,27 @@ +#include "Variables.h" + +namespace Engine { + +bool Cmd_Set (const std::vector args) { + if (args.size() != 2) { + CommandSetErrorString ("Usage: set \nSets variables to value ."); + return false; + } + + Variable *test = GetVariable (args[0]); + if (test) { + test->SetStringValue (args[1]); + test->SetFloatValue (atof (args[1].c_str())); + return true; + } + + CommandSetErrorString ("Variable '" + args[0] +"' not found!"); + return false; +} + +void Variables::OnRegisterCommands () { + AddCommand ("set", Cmd_Set); +} + +} + diff --git a/engine/VariablesGlobal.h b/engine/VariablesGlobal.h new file mode 100644 index 0000000..1739cb5 --- /dev/null +++ b/engine/VariablesGlobal.h @@ -0,0 +1,68 @@ +#ifndef _VARIABLESGLOBAL_H +#define _VARIABLESGLOBAL_H + +namespace Engine { +/** \brief Represents a variable that can be modified and read within the game + * + * \note Variables \b MUST be declared as static variables, otherwise the memory that + * hold their values get invalidated and the system gets unstable! + */ +class Variable { + public: + /** \brief The constructor to be used when initializing a Variable + * + * \param name The name under which the variable is engine wide + * accessible + * \param value The value it is assigned to. + * + * The value string gets automatically converted to a float with atof (). + * Modification of a Variable must always be made with the Get*, Set* + * functions. + */ + Variable (const std::string &name, const std::string &value); + + /** \brief Returns the string value of the Variable */ + std::string& GetStringValue () { + return mStringValue; + } + /** \brief Returns the float value of the Variable */ + float& GetFloatValue () { + return mFloatValue; + } + void SetStringValue (const std::string &value) { + mStringValue = value; + } + void SetFloatValue (float value) { + mFloatValue = value; + } + + private: + /** \brief The default constructor must not be used. + * + * Use \code + * Variable (const std::string &name, const std::string &value) + * \endcode + * instead. + * */ + Variable () { assert (0); } + /** \brief Registeres this Variable with the Variables System */ + void RegisterVariable (const std::string &name); + + std::string mName; + std::string mStringValue; + float mFloatValue; + + friend class Variables; +}; + +/** \brief Provides access to a Variable stored under the given name */ +Variable* GetVariable (const std::string &name); +/** \brief Sets the vaule of the Variable */ +bool SetVariableValue (const std::string &name, const std::string &value); +/** \brief Returns the string value of the Variable with the given name */ +std::string& GetVariableString (const std::string &name, std::string def = ""); +/** \brief Returns the float value of the Variable with the given name */ +float& GetVariableFloat (const std::string &name, float def = 0.); + +} +#endif // _VARIABLESGLOBAL_H diff --git a/engine/ViewBase.cc b/engine/ViewBase.cc new file mode 100644 index 0000000..0f83f00 --- /dev/null +++ b/engine/ViewBase.cc @@ -0,0 +1,330 @@ +#include "ViewBase.h" + +#include "ModelBase.h" +#include "ControllerBase.h" +#include "CameraBase.h" +#include "OverlayBase.h" + +#include "SimpleConsoleOverlay.h" +#include "OGLFT.h" + +#include +#include + +#include "DrawingsGL.h" + +using namespace std; + +namespace Engine { + +static ViewBase* ViewInstance = NULL; + +void InitGL () { + glClearColor(0.3f, 0.3f, 0.3f, 1.0f); + glClearDepth(1.0); + glDepthFunc(GL_LESS); + glEnable(GL_DEPTH_TEST); + glShadeModel(GL_SMOOTH); + glEnable (GL_CULL_FACE); + glDisable (GL_FOG); + + glMatrixMode (GL_PROJECTION); + glLoadIdentity (); + glMatrixMode (GL_MODELVIEW); + glLoadIdentity (); +} + +/* + * Inherited Module functions + */ +int ViewBase::OnInit (int argc, char* argv[]) { + LogMessage ("View Init"); + + mWindowHeight = VIEW_DEFAULT_HEIGHT; + mWindowWidth = VIEW_DEFAULT_WIDTH; + + SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); + + if( SDL_SetVideoMode( mWindowWidth, mWindowHeight, 16, SDL_OPENGL | SDL_RESIZABLE ) == 0 ) { + LogError ("Video mode set failed: %s", SDL_GetError ()); + exit (-1); + } + + InitGL (); + Resize (mWindowWidth, mWindowHeight); + + mConsoleFont = new OGLFT::Monochrome ("./data/fonts/console.ttf", 12); + + if ( mConsoleFont == 0 || !mConsoleFont->isValid() ) { + LogError ("Could not load font %s!", "./data/fonts/console.ttf"); + exit (-1); + } + + SimpleConsoleOverlay* console_overlay = new SimpleConsoleOverlay; + AddOverlay (console_overlay); + + mConsoleFont->setForegroundColor (1., 1., 1.); + + mDrawAxis = false; + + mDrawGrid = false; + mGridSizeX = 8; + mGridSizeZ = 8; + + ViewInstance = this; + + return 0; +} + +void ViewBase::OnDestroy () { + if (mConsoleFont ) + delete mConsoleFont; + mConsoleFont = NULL; + + std::vector::iterator overlay_iter = mOverlays.begin(), overlay_temp; + while (overlay_iter != mOverlays.end()) { + overlay_temp = overlay_iter; + delete *overlay_temp; + + overlay_iter++; + } + + ViewInstance = NULL; + + LogDebug ("View Destroy"); +} + +void ViewBase::CalcWorldCoordinates (int screen_x, int screen_y, float world_y, float *pos_out) { + GLdouble modelMatrix[16], projMatrix[16]; + GLint viewport[4]; + GLdouble wx, wy, wz; + + glGetIntegerv (GL_VIEWPORT, viewport); + glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); + glGetDoublev(GL_PROJECTION_MATRIX, projMatrix); + + int realy = viewport[3] - screen_y - 1; + + gluUnProject ((GLdouble) screen_x, (GLdouble) realy, 1., + modelMatrix, projMatrix, viewport, &wx, &wy, &wz); + + GLdouble t; + GLdouble d[3]; + float eye[3]; + + mCamera->GetEye (&eye[0]); + + d[0] = wx - eye[0]; + d[1] = wy - eye[1]; + d[2] = wz - eye[2]; + + assert (fabs (d[1]) >= 1.0e-3); + t = -eye[1]/d[1] + world_y; + + pos_out[0] = eye[0] + t * d[0]; + pos_out[1] = eye[1] + t * d[1]; + pos_out[2] = eye[2] + t * d[2]; +} + +/* + * Module specific functions + */ +void ViewBase::UpdateCamera () { + EntityPhysicState* player_ent = GetEntityPhysicState (GetPlayerEntityId()); + + if (!player_ent) { + LogError ("Could not call Model::PositionCamera(): player entity not found!"); + exit (-1); + } + vector3d entity_camera_distance (-2, 3, 0); + vector3d entity_position = player_ent->GetPosition(); + player_ent->Globalize (entity_camera_distance); + + mCamera->SetEye ( + entity_camera_distance[0], + entity_camera_distance[1], + entity_camera_distance[2] + ); + mCamera->SetPointOfIntrest ( + entity_position[0], + entity_position[1], + entity_position[2] + ); + + mCamera->Update (); +} + +void ViewBase::Draw () { + // Clear the screen + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + // update the frame rate counter + static Uint32 this_frame_ticks; + static Uint32 last_frame_ticks = 0; + static Uint32 last_fps_update = 0; + static int frame_counter = 0; + + this_frame_ticks = SDL_GetTicks (); + last_fps_update += this_frame_ticks - last_frame_ticks; + last_frame_ticks = this_frame_ticks; + frame_counter++; + + if (last_fps_update > 1000) { + mFrameRate = frame_counter; + last_fps_update = 0; + frame_counter = 0; + } + + UpdateCamera (); + + if (mDrawGrid) + DrawGrid (); + + if (mDrawAxis) + DrawAxis (); + + DrawWorld (); + + std::vector::iterator overlay_iter; + for (overlay_iter = mOverlays.begin(); overlay_iter != mOverlays.end(); overlay_iter++) { + (*overlay_iter)->Draw(); + } + + // and update the screen + SDL_GL_SwapBuffers (); +} + +void ViewBase::DrawGLString (float x, float y, const char* str) { + glPixelStorei (GL_UNPACK_ALIGNMENT, 1); + mConsoleFont->draw (x, y, str); +} + +void ViewBase::GetCamereEye (float *eye_out) { + assert (mCamera); + mCamera->GetEye (eye_out); +} + +void ViewBase::DrawGrid () { + float xmin, xmax, xstep, zmin, zmax, zstep; + int i, count_x, count_z; + + xmin = -mGridSizeX; + xmax = mGridSizeX; + zmin = -mGridSizeZ; + zmax = mGridSizeZ; + + count_x = mGridSizeX * 2; + count_z = mGridSizeZ * 2; + + xstep = 1.; + zstep = 1.; + + glColor3f (1., 1., 1.); + glBegin (GL_LINES); + for (i = 0; i <= count_x; i++) { + glVertex3f (i * xstep + xmin, 0., zmin); + glVertex3f (i * xstep + xmin, 0., zmax); + } + for (i = 0; i <= count_z; i++) { + glVertex3f (xmin, 0, i * zstep + zmin); + glVertex3f (xmax, 0, i * zstep + zmin); + } + glEnd (); + +} + +void ViewBase::DrawWorld () { +} + +void ViewBase::Resize (int width, int height) { + if (height == 0) + height = 1; + + mWindowWidth = static_cast (width); + mWindowHeight = static_cast (height); + + glViewport(0, 0, width, height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(mCamera->GetFOVY (), float (width) / float (height), 0.1, 100); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity (); + + LogDebug ("Resize to: %d x %d", mWindowWidth,mWindowHeight); + + /** \warning + * This call has to be made for SDL 1.2 for 1.3 there seems to be a + * workaround, however since I do not yet run SDL 1.3 I hold on to this. + * See http://lists.libsdl.org/pipermail/sdl-libsdl.org/2008-November/067306.html + */ + if( SDL_SetVideoMode( mWindowWidth, mWindowHeight, 16, SDL_OPENGL | SDL_RESIZABLE ) == 0 ) { + LogError ("Video mode set failed: %s", SDL_GetError ()); + exit (-1); + } +} + +bool ViewBase::SendKeyDown (const SDL_keysym &keysym) { + std::vector::iterator overlay_iter; + for (overlay_iter = mOverlays.begin(); overlay_iter != mOverlays.end(); overlay_iter++) { + if ( (*overlay_iter)->OnKeyDown (keysym)) + return true; + } + + return false; +} + +bool ViewBase::SendKeyUp (const SDL_keysym &keysym) { + std::vector::iterator overlay_iter; + for (overlay_iter = mOverlays.begin(); overlay_iter != mOverlays.end(); overlay_iter++) { + if ( (*overlay_iter)->OnKeyUp (keysym)) + return true; + } + + return false; +} + +bool ViewBase::SendMouseButtonUp (Uint8 button, Uint16 xpos, Uint16 ypos) { + std::vector::iterator overlay_iter; + for (overlay_iter = mOverlays.begin(); overlay_iter != mOverlays.end(); overlay_iter++) { + if ( (*overlay_iter)->OnMouseButtonUp (button, xpos, ypos)) + return true; + } + + return false; +} + +bool ViewBase::SendMouseButtonDown (Uint8 button, Uint16 xpos, Uint16 ypos) { + std::vector::iterator overlay_iter; + for (overlay_iter = mOverlays.begin(); overlay_iter != mOverlays.end(); overlay_iter++) { + if ( (*overlay_iter)->OnMouseButtonDown (button, xpos, ypos)) + return true; + } + + return false; +} + +/* + * Global functions + */ +void DrawGLString (float x, float y, const char* str) { + if (!ViewInstance) { + LogError ("Cannot Draw GL String: View not yet initialized!"); + return; + } + ViewInstance->DrawGLString (x, y, str); +} + +unsigned int GetWindowWidth() { + return ViewInstance->GetWindowWidth (); +} + +unsigned int GetWindowHeight() { + return ViewInstance->GetWindowHeight (); +} + +int GetFrameRate () { + return ViewInstance->GetFrameRate (); +} + +} diff --git a/engine/ViewBase.h b/engine/ViewBase.h new file mode 100644 index 0000000..a6a2bf1 --- /dev/null +++ b/engine/ViewBase.h @@ -0,0 +1,98 @@ +#ifndef _VIEWBASE_H +#define _VIEWBASE_H + +#include "Engine.h" + +// forward declarations for the OGLFT fonts +namespace OGLFT { + class Monochrome; +} + +namespace Engine { + +class Module; +class ModelBase; +class CameraBase; +class OverlayBase; + +/** \brief Performs the actual drawing based on Camera and Model + */ + +class ViewBase : public Module{ + public: + /** \brief Resizes the View */ + void Resize (int width, int height); + + /** \brief Performs all drawing */ + virtual void Draw (); + + /** \brief Draws a string at the given position using current projection + * and modelview matrices */ + void DrawGLString (float x, float y, const char* str); + /** \brief Stores the eye poisition in eye_out */ + void GetCamereEye (float *eye_out); + + /** \brief Calculates the world coordinates to given screen coordinates */ + void CalcWorldCoordinates (int screen_x, int screen_y, float world_y, float *pos_out); + + unsigned int GetWindowWidth () { return mWindowWidth; }; + unsigned int GetWindowHeight () { return mWindowHeight; }; + int GetFrameRate() { return mFrameRate; }; + + void SetDrawAxis (bool draw_axis) { mDrawGrid = draw_axis; }; + bool GetDrawAxis () { return mDrawGrid; }; + void SetDrawGrid (bool draw_grid) { mDrawGrid = draw_grid; }; + bool GetDrawGrid () { return mDrawGrid; }; + void SetGridSize (int x, int z) { mGridSizeX = x; mGridSizeZ = z; } + + void AddOverlay (OverlayBase *overlay) { mOverlays.push_back (overlay); }; + + /* Input forwarding for the overlays */ + bool SendKeyDown (const SDL_keysym &keysym); + bool SendKeyUp (const SDL_keysym &keysym); + bool SendMouseButtonUp (Uint8 button, Uint16 xpos, Uint16 ypos); + bool SendMouseButtonDown (Uint8 button, Uint16 xpos, Uint16 ypos); + + protected: + /** \brief Initializes the system */ + int OnInit (int argc, char* argv[]); + /** \brief Destroys the system (must be called!) */ + void OnDestroy (); + + /** \brief Updates the camera for further drawing */ + virtual void UpdateCamera (); + /** \brief Draws a grid of 16 x 16 tiles */ + void DrawGrid (); + /** \brief Draws the level and all the visible Entities */ + virtual void DrawWorld (); + /** \brief Draws orthographic overlay*/ + void DrawOverlay2D (); + + ModelBase *mModel; + CameraBase *mCamera; + + std::vector mOverlays; + + /** \brief The height of the canvas we're drawing on */ + unsigned int mWindowHeight; + /** \brief The width of the canvas we're drawing on */ + unsigned int mWindowWidth; + /** \brief Stores the current frame rate */ + int mFrameRate; + + bool mDrawAxis; + bool mDrawGrid; + int mGridSizeX; + int mGridSizeZ; + + /** \brief Font that is used in the console */ + OGLFT::Monochrome* mConsoleFont; + + friend class Engine; +}; + +} + +#include "ViewBaseGlobal.h" + +#endif // _VIEWBase_H diff --git a/engine/ViewBaseGlobal.h b/engine/ViewBaseGlobal.h new file mode 100644 index 0000000..6bc5295 --- /dev/null +++ b/engine/ViewBaseGlobal.h @@ -0,0 +1,17 @@ +#ifndef _VIEWGLOBAL_H +#define _VIEWGLOBAL_H + +namespace Engine { + +/** \brief Draws the given string at the given position using the current + * OpenGL transformations */ +void DrawGLString (float x, float y, const char* str); + +unsigned int GetWindowWidth(); +unsigned int GetWindowHeight(); + +int GetFrameRate (); + +} + +#endif /* _VIEWGLOBAL_H */ diff --git a/engine/VisualEntityBase.cc b/engine/VisualEntityBase.cc new file mode 100644 index 0000000..3d344e7 --- /dev/null +++ b/engine/VisualEntityBase.cc @@ -0,0 +1,72 @@ +#include "EntityBase.h" + +#include + +namespace Engine { + +void EntityVisualState::Draw () { + if (mBaseType == EntityBaseTypeActor) { + int i, segments; + segments = 20; + double x, z, rad, drad; + + drad = (M_PI * 2) / segments; + + glBegin (GL_TRIANGLE_FAN); + glVertex3f (0., 0., 0.); + for (i = 0; i <= segments; i++) { + rad = drad * i; + sincos (rad, &z, &x); + glVertex3f (x * mRadius, 0., -z * mRadius); + } + glEnd (); + + glDisable (GL_DEPTH_TEST); + glColor3f (0.8, 0., 0.2); + glBegin (GL_TRIANGLES); + glVertex3f (mRadius, 0., 0.); + glVertex3f (0., 0., -mRadius * 0.3); + glVertex3f (0., 0., mRadius * 0.3); + glEnd (); + glEnable (GL_DEPTH_TEST); + + return; + } else if (mBaseType == EntityBaseTypeBlock) { + glBegin (GL_QUADS); + glVertex3f (-0.5, 0., 0.5); + glVertex3f (0.5, 0., 0.5); + glVertex3f (0.5, 0., -0.5); + glVertex3f (-0.5, 0., -0.5); + glEnd (); + } else if (mBaseType == EntityBaseTypeParticle) { + int i, segments; + segments = 20; + double x, z, rad, drad; + + drad = (M_PI * 2) / segments; + + glDisable (GL_DEPTH_TEST); + glColor3f (0., 0.8, 0.1); + glBegin (GL_TRIANGLE_FAN); + glVertex3f (0., 0., 0.); + for (i = 0; i <= segments; i++) { + rad = drad * i; + sincos (rad, &z, &x); + glVertex3f (x * mRadius, 0., -z * mRadius); + } + glEnd (); + + glColor3f (0.8, 0., 0.2); + glBegin (GL_TRIANGLES); + glVertex3f (mRadius, 0., 0.); + glVertex3f (0., 0., -mRadius * 0.3); + glVertex3f (0., 0., mRadius * 0.3); + glEnd (); + glEnable (GL_DEPTH_TEST); + + return; + } +} + +} + diff --git a/engine/doc/Mainpage.h b/engine/doc/Mainpage.h new file mode 100644 index 0000000..4520861 --- /dev/null +++ b/engine/doc/Mainpage.h @@ -0,0 +1,96 @@ +/** \file documentation.h \mainpage Main Page + * + * This is the documentation of Engine -- a game engine without a name. + * + * \section General Information + * + * To get an overview over the most important functions and classes have a + * look at Engine. For the structure of the Engine look at Engine::Engine. In + * \ref usecases you find documentation on how things are supposed to work and + * what the ideas behind certain designs is. + * + * \section Physics + * + * So far we only use a very simple physics system which is mostly defined by + * the Engine::Physics class. It uses the coll2d collision library. Collision + * response so far only tries to prevent interpenetration. + * + * \section Networking + * + * For easier networking it is assumed that everything runs over a network. + * The game itself is rather a smart client to a simple synchronization + * protocol. What is being synchronized is the game state and the client + * simply displays the current state it knows. The client is "smart" as it + * tries to guess what the next state will be. + * + * For networking we want to use Enet http://enet.bespin.org/. + * + * Notes for networking: At + * http://www.gamedev.net/community/forums/topic.asp?topic_id=550962 is an + * interesting thread about modeling the updates. Especially the answer of + * Antheus at http://www.gamedev.net/community/forums/viewreply.asp?ID=3546077 + * describes two fundamental models: + * + * Level Triggering (GoF Observer Pattern): Entity A sends its changes to the + * Observer pattern and all objects that are interested in the state of Entity + * A get notfied by the observer. + * + * Edge Triggering: For each Entity A the Observer B is interested, it stores + * a flag for a value it is interested in (e.g. one for position, one for + * velocity, etc.). When Entity A modifies one of the values it notifies the + * observer that its current state has changed and the Observer sets the flag + * to "dirty". Anyone interested in events polls at the Observer and decides + * what to do with it. When the value is queried, the Observer reads the value + * from the Entity and clears the flag. + * + * For networking a combination can be used: During the simulation loop only + * Edge Triggering is performed and at the end of it, all dirty States get + * sent over the network. + * + * When notifying events such as "Add new Entity X" the user tomv describes at + * http://www.gamedev.net/community/forums/viewreply.asp?ID=3545586 a method + * to circumvent these messages. Instead, the server simply sends out updates + * about the Entities around a player where close Entities are updated more + * frequently than ones that are further away. It simply sends "Entity X + * changed by D". If a client does not know what the Entity X is, it queries + * the type and current state of the Entity X and therefore reconstructs the + * surroundings step-by-step. It is also robust against dropped messages of + * the form "Add new Entity X". + * + * At tomvas model there are some problems: How are events "Delete Entity X" + * handled? How to handle malicious clients that request the state of all + * Entities? (Solution for the last question: Request Queues). + * + * Kylotan cals tomvas model as a unreliable system for generic state + * [synchronization?] (http://www.gamedev.net/community/forums/viewreply.asp?ID=3548662). + * Additionally he mentions that it can increase occurences of short term + * unsynchronous states and reccomends using some reliable message passing. + * + * \section ToDos + * + * This is a loose list of items that are to be implemented. For a list of all + * todos within the code have a look at the \ref todo. + * + * \todo [high] Create a simple racing or asteroids game + * \todo [med] Clear all references of EntityVisualState and EntityGameState + * \todo [med] Clarify functionalities of CreateEntity, KillEntity, RegisterEntity, UnregisterEntity (which frees memory, which does only change the state of the Model?) + * \todo [med] Add basic networking + * \todo [med] Add serialization + * \todo [med] Add cal3d support + * \todo [med] Smooth Physics at convex collisions (somehow there is jitter) + * \todo [med] Create better collsion response + * \todo [med] In rare cases two Actors can penetrate each other (probably at slow velocities) + * \todo [low] Add a timer object to keep track of what is sucking performance. + * \todo [low] Add a inspector widget that shows information about a selected Entity + * \todo [low] Use a std::map as initialization parameters for + * Engine::Module::Init() + * + * Done: + * - [high] In Physics remove dependancy on the Model to pass on collision + * events + * - [high] Fix Physics bug when two actors collide actively (i.e. velocity + * towards each other) + * - [med] Better Game Input so that each Entity has its own ControllerState + * that can be modified + * - [med] (31-01-2009) Add support for loading levels (and saving!) + */ diff --git a/engine/doc/Usecases.h b/engine/doc/Usecases.h new file mode 100644 index 0000000..e0482fb --- /dev/null +++ b/engine/doc/Usecases.h @@ -0,0 +1,114 @@ +/** \page usecases Usecases + * + * This page contains some information on how various tasks are supposed to be + * performed with this engine. It should help understand how the internals + * work and how to avoid certain pitfalls. + * + * \section entity_management Entity Management + * + * Entities have to be created with Engine::CreateEntity() Factory Method. + * This will also cause the correct registration in all modules (especially in + * the Engine::Physics module). And create the registrations for it. + * + * Once an Entity is no more used, one has to call Engine::DestroyEntity(). + * + * \section entitiy_drawing Drawing of an Entity + * + * Aim: The visual state must always represent the visual state of the game + * state. + * + * To do this we always have to update the visual entity from the game state + * entity. + * + * \code + * View::DrawEntity (Entity* entity) { + * // if this entity has no visual part we don't need to draw + * if (! entity->mPhysicState) return; + * + * // update entity->mVisualState based on entity->mGameState + * + * // perform positioning based on entity->mPhysicState + * + * // perform drawing based on entity->mVisualState + * } + * \endcode + * + * \section game_input Game Input + * + * Each Entity has a ControllerState which keeps track on how the Entity is + * currently steered. This is then processed by the model each frame for each + * entity and updates the velocities / orientations etc. before the physical + * simulation is started. The player input simply forwards its input to the + * Entity with the Player Id and updates the ControllerState of the Entity + * with the Id. + * + * To add a new key state one has to follow these steps: + * - add a new EntityControllerKeyState e.g. EntityKeyStateCrouch (must be added + * above EntityKeyStateLast) + * - define the behaviour of the control in Entity::ProcessController() which + * updates the EntityPhysicalState of the Entity + * - add a command to be able to bind a key to the EntityControllerKeyState + * + * \section console_input Console Input + * + * Since it could be that the key being pressed has to be forwarded to another + * system such as the Menu or the Engine::Console system, we have to query the + * Engine::Model whether it is active and forward the input if it is the case. + * Otherwise we just execute the binding for the key (if it exists). + * + * \code + * Controller::OnKeyDown (SDLKey key) { + * if (mConsole->GetActive ()) + * mConsole->OnKeyDown (key); + * + * if (mBinding[key].size()) + * mCommands->QueueCommand (mBinding[key]); + * } + * \endcode + * + * \section addcommand Adding a Command to the Command System + * + * For the various Modules such as Engine::Controller, Engine::View, etc. + * separate files exist in which commands are defined. The filename pattern is + * usually [ModuleName]Commands.cc and contains the function + * \code void ModuleName::OnRegisterCommands () \endcode which is run during the + * initialization phase of the Engine in Engine::OnInit. + * + * Commands themselves have the signature: + * \code bool Cmd_CrazyCommand (std::vector args) \endcode + * and return true on success and error if some error has happened. The + * prefix \e Cmd_ is not mandatory but keeps things clear. + * + * Please make sure to call Engine::CommandSetErrorString in such a case. The + * message itself will be automatically reported to the Engine::Logging system + * as a warning since Command errors are hopefully not that important that + * they can crash the whole Engine. + * + * To register a Command to the Engine::Commands system you have to call \code + * AddCommand ("crazycommand", Cmd_CrazyCommand); \endcode in + * ModuleName::OnRegisterCommands. With this the Command is accessible through + * the Command system. + * + * \section addvariable Adding a Variable to the Engine::Variable System + * + * To register a variable to the Engine::Variables Module one \e must use a + * static variable of type Engine::Variable and use a special constructor: + * \code + * static Var_Variable PlayerSpeed ("playerspeed", "1.25"); + * \endcode + * This constructor takes care of registering the Variable PlayerSpeedVariable + * and its value to the Engine::Variables Module. The first argument is the + * name of the variable which can be used to retrieve a pointer to the + * Variable with Engine::GetVariable, Engine::GetVariableString, etc. The + * second argument is the value which the system will automatically try to + * convert to a float. This float is then returned if Engine::GetVariableFloat + * is called. + * + * The prefix \e Var_ is for readability in the code. + * + * The keyword \e static ensures that the lifespan of the variable is not only + * in a local function environment and thus mandatory. However it is + * registered at that time the program executes the first time the line in + * which the definition was made. To be safe define all your variables in the + * global scope of te source file of your Engine::Module. + */ diff --git a/engine/globals.h b/engine/globals.h new file mode 100644 index 0000000..3a14fd6 --- /dev/null +++ b/engine/globals.h @@ -0,0 +1,16 @@ +#ifndef _GLOBALS_H +#define _GLOBALS_H + +#define LOG_DEFAULT_LEVEL LogLevelMessage +#define LOG_MAX_MESSAGE_LENGTH 1024 + +#define VIEW_DEFAULT_HEIGHT 600 +#define VIEW_DEFAULT_WIDTH 800 + +#ifdef WIN32 + #include +#endif + +#include + +#endif // _GLOBALS_H diff --git a/engine/keytable.h b/engine/keytable.h new file mode 100644 index 0000000..142223f --- /dev/null +++ b/engine/keytable.h @@ -0,0 +1,166 @@ +#ifndef KEYTABLE_H +#define KEYTABLE_H + +#include + +/** \brief Defines the key codes for mouse buttons + * + * With this enum we can treat mouse button events the same way as we treat + * keyboard events. To do so we define the left button as the last keyboard + * button. + */ +enum MouseButton { + MouseButtonUnknown = SDLK_LAST, + MouseButtonLeft, + MouseButtonMiddle, + MouseButtonRight, + MouseButtonWheelUp, + MouseButtonWheelDown, + MouseButtonLast +}; + +struct key_definition { + int keynum; + const char *keystr; +}; + +const int keytable_last = MouseButtonLast; + +static const key_definition key_table[] = { + {SDLK_BACKSPACE, "backspace"}, + {SDLK_TAB, "tab"}, +// {SDLK_CLEAR, "12"}, + {SDLK_RETURN, "return"}, + {SDLK_PAUSE, "pause"}, + {SDLK_ESCAPE, "escape"}, + {SDLK_SPACE, "space"}, + {SDLK_EXCLAIM, "exclaim"}, +// {SDLK_QUOTEDBL, ""}, + {SDLK_HASH, "#"}, + {SDLK_DOLLAR, "$"}, + {SDLK_AMPERSAND, "&"}, +// {SDLK_QUOTE, "39"}, +// {SDLK_LEFTPAREN, "("}, +// {SDLK_RIGHTPAREN, ")"}, +// {SDLK_ASTERISK, "*"}, + {SDLK_PLUS, "+"}, + {SDLK_COMMA, ","}, + {SDLK_MINUS, "-"}, + {SDLK_PERIOD, "."}, + {SDLK_SLASH, "/"}, + {SDLK_0, "0"}, + {SDLK_1, "1"}, + {SDLK_2, "2"}, + {SDLK_3, "3"}, + {SDLK_4, "4"}, + {SDLK_5, "5"}, + {SDLK_6, "6"}, + {SDLK_7, "7"}, + {SDLK_8, "8"}, + {SDLK_9, "9"}, + {SDLK_COLON, ":"}, + {SDLK_SEMICOLON, ";"}, + {SDLK_LESS, "<"}, + {SDLK_EQUALS, "="}, + {SDLK_GREATER, ">"}, + {SDLK_QUESTION, "?"}, + {SDLK_AT, "@"}, + {SDLK_LEFTBRACKET, "["}, + {SDLK_BACKSLASH, "\\"}, + {SDLK_RIGHTBRACKET, "]"}, + {SDLK_CARET, "^"}, + {SDLK_UNDERSCORE, "_"}, + {SDLK_BACKQUOTE, "`"}, + {SDLK_a, "a"}, + {SDLK_b, "b"}, + {SDLK_c, "c"}, + {SDLK_d, "d"}, + {SDLK_e, "e"}, + {SDLK_f, "f"}, + {SDLK_g, "g"}, + {SDLK_h, "h"}, + {SDLK_i, "i"}, + {SDLK_j, "j"}, + {SDLK_k, "k"}, + {SDLK_l, "l"}, + {SDLK_m, "m"}, + {SDLK_n, "n"}, + {SDLK_o, "o"}, + {SDLK_p, "p"}, + {SDLK_q, "q"}, + {SDLK_r, "r"}, + {SDLK_s, "s"}, + {SDLK_t, "t"}, + {SDLK_u, "u"}, + {SDLK_v, "v"}, + {SDLK_w, "w"}, + {SDLK_x, "x"}, + {SDLK_y, "y"}, + {SDLK_z, "z"}, + {SDLK_KP0, "keypad_0"}, + {SDLK_KP1, "keypad_1"}, + {SDLK_KP2, "keypad_2"}, + {SDLK_KP3, "keypad_3"}, + {SDLK_KP4, "keypad_4"}, + {SDLK_KP5, "keypad_5"}, + {SDLK_KP6, "keypad_6"}, + {SDLK_KP7, "keypad_7"}, + {SDLK_KP8, "keypad_8"}, + {SDLK_KP9, "keypad_9"}, + {SDLK_KP_PERIOD, "keypad_period"}, + {SDLK_KP_DIVIDE, "keypad_devide"}, + {SDLK_KP_MULTIPLY, "keypad_multiply"}, + {SDLK_KP_MINUS, "keypad_minus"}, + {SDLK_KP_PLUS, "keypad_plus"}, + {SDLK_KP_ENTER, "keypad_enter"}, + {SDLK_KP_EQUALS, "keypad_equals"}, + {SDLK_UP, "up"}, + {SDLK_DOWN, "down"}, + {SDLK_RIGHT, "right"}, + {SDLK_LEFT, "left"}, + {SDLK_INSERT, "insert"}, + {SDLK_HOME, "home"}, + {SDLK_END, "end"}, + {SDLK_PAGEUP, "pageup"}, + {SDLK_PAGEDOWN, "pagedown"}, + {SDLK_F1, "f1"}, + {SDLK_F2, "f2"}, + {SDLK_F3, "f3"}, + {SDLK_F4, "f4"}, + {SDLK_F5, "f5"}, + {SDLK_F6, "f6"}, + {SDLK_F7, "f7"}, + {SDLK_F8, "f8"}, + {SDLK_F9, "f9"}, + {SDLK_F10, "f10"}, + {SDLK_F11, "f11"}, + {SDLK_F12, "f12"}, + {SDLK_F13, "f13"}, + {SDLK_F14, "f14"}, + {SDLK_F15, "f15"}, + {SDLK_NUMLOCK, "numlock"}, + {SDLK_CAPSLOCK, "capslock"}, + {SDLK_SCROLLOCK, "scrollock"}, + {SDLK_RSHIFT, "right_shift"}, + {SDLK_LSHIFT, "left_shift"}, + {SDLK_RCTRL, "right_ctrl"}, + {SDLK_LCTRL, "left_ctrl"}, + {SDLK_RALT, "right_alt"}, + {SDLK_LALT, "left_alt"}, + {SDLK_RMETA, "right_meta"}, + {SDLK_LMETA, "left_meta"}, + {SDLK_LSUPER, "left_super"}, /* Left "Windows" key */ + {SDLK_RSUPER, "right_super"}, /* Right "Windows" key */ + {SDLK_MODE, "altgr"}, /* "Alt Gr" key */ + {SDLK_COMPOSE, "compose"}, /* Multi-key compose key */ + {SDLK_DELETE, "delete"}, + {MouseButtonLeft, "mouse_left"}, + {MouseButtonMiddle, "mouse_middle"}, + {MouseButtonRight, "mouse_right"}, + {MouseButtonWheelUp, "mouse_wheelup"}, + {MouseButtonWheelDown, "mouse_wheeldown"}, + {keytable_last, NULL} +}; + +#endif /* KEYTABLE_H */ + diff --git a/engine/libraries/CMakeLists.txt b/engine/libraries/CMakeLists.txt new file mode 100644 index 0000000..d613c45 --- /dev/null +++ b/engine/libraries/CMakeLists.txt @@ -0,0 +1,3 @@ +ADD_SUBDIRECTORY ( mathlib ) +ADD_SUBDIRECTORY ( coll2d ) +ADD_SUBDIRECTORY ( oglft ) diff --git a/engine/libraries/coll2d/CMake/FindUnitTest++.cmake b/engine/libraries/coll2d/CMake/FindUnitTest++.cmake new file mode 100644 index 0000000..261e7a8 --- /dev/null +++ b/engine/libraries/coll2d/CMake/FindUnitTest++.cmake @@ -0,0 +1,28 @@ +# - Try to find UnitTest++ +# +# + +SET (UNITTEST++_FOUND FALSE) + +FIND_PATH (UNITTEST++_INCLUDE_DIR UnitTest++.h /usr/include/unittest++ /usr/local/include/unittest++ $ENV{UNITTESTXX_PATH}/src $ENV{UNITTESTXX_INCLUDE_PATH}) + +FIND_LIBRARY (UNITTEST++_LIBRARY NAMES UnitTest++ PATHS /usr/lib /usr/local/lib $ENV{UNITTESTXX_PATH} ENV{UNITTESTXX_LIBRARY_PATH}) + +IF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + SET (UNITTEST++_FOUND TRUE) +ENDIF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + +IF (UNITTEST++_FOUND) + IF (NOT UnitTest++_FIND_QUIETLY) + MESSAGE(STATUS "Found UnitTest++: ${UNITTEST++_LIBRARY}") + ENDIF (NOT UnitTest++_FIND_QUIETLY) +ELSE (UNITTEST++_FOUND) + IF (UnitTest++_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find UnitTest++") + ENDIF (UnitTest++_FIND_REQUIRED) +ENDIF (UNITTEST++_FOUND) + +MARK_AS_ADVANCED ( + UNITTEST++_INCLUDE_DIR + UNITTEST++_LIBRARY + ) diff --git a/engine/libraries/coll2d/CMakeLists.txt b/engine/libraries/coll2d/CMakeLists.txt new file mode 100644 index 0000000..f4d35d7 --- /dev/null +++ b/engine/libraries/coll2d/CMakeLists.txt @@ -0,0 +1,21 @@ +PROJECT (COLL2D) + +CMAKE_MINIMUM_REQUIRED (VERSION 2.6) + +# Needed for UnitTest++ +LIST( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake ) + +SET ( COLL2D_SRCS + src/coll2d.cc + ) + +INCLUDE_DIRECTORIES ( include ../mathlib/ ) + +SET_TARGET_PROPERTIES ( ${PROJECT_EXECUTABLES} PROPERTIES + LINKER_LANGUAGE CXX +) + +SUBDIRS (tests) + +ADD_LIBRARY ( coll2d ${COLL2D_SRCS} ) + diff --git a/engine/libraries/coll2d/include/coll2d.h b/engine/libraries/coll2d/include/coll2d.h new file mode 100644 index 0000000..2693a40 --- /dev/null +++ b/engine/libraries/coll2d/include/coll2d.h @@ -0,0 +1,346 @@ +#ifndef _COLL2D_H +#define _COLL2D_H + +/** \brief Coll2d - A 2d collision detection library + * \author Martin Felis + * + * This library provides functions to detect collisions between polygons and + * spheres. + * + * Notes: + * - vertices of polygons are described in local coordinates + * - return values of check_collision are in global coordinates + * - all Shapes get copied to a temporary instance which will then get + * transferred into global coordinates + * - Polygons are assumed to be convex and the vertices are stored + * counter clockwise. + * - The transformation of the global position and velocities towards + * relative position and velocities happens in the + * int check_collision__ functions! + */ + +#include +#include +#include + +#include + +namespace coll2d { + +/** \brief Contains the information of a collision + * + * \param normal The normal of the reference plane + * \param point The actual point where the collision happens in global + * cooldinates + * \param time If both objects move for this amount of time the contact + * will occur. + * \param reference_shape + * If 0, the first shape passed to he check_collision function + * is the reference shape, otherwise the second. +*/ +struct CollisionInfo { + vector3d normal; + vector3d point; + float time; + int reference_shape; + + CollisionInfo () : normal (0., 0., 0.), point (0., 0., 0.), time (-1.), reference_shape (-1) { + } + + CollisionInfo& operator= (const CollisionInfo& info) { + if (this != &info) { + normal = info.normal; + point = info.point; + time = info.time; + reference_shape = info.reference_shape; + } + + return *this; + } + + void doPrint (const char* msg) { + std::cout << msg; + std::cout << "Time = " << time << std::endl; + normal.print ("Normal = "); + point.print ( "Point = "); + std::cout << "Reference = " << reference_shape << std::endl; + } +}; + +/** \brief Base class for all shapes + * + */ +class Shape { +protected: + vector3d mPosition; + vector3d mVelocity; + float mAngle; + float mAngleVelocity; + + virtual void dummy() { + } +public: + Shape(): + mPosition (0., 0., 0.), + mVelocity (0., 0., 0.), + mAngle (0.), + mAngleVelocity (0.) { + } + Shape (const Shape &shape): + mPosition (shape.mPosition), + mVelocity (shape.mVelocity), + mAngle (shape.mAngle), + mAngleVelocity (shape.mAngleVelocity) + { } + + virtual ~Shape () {}; + + /** \brief Creates and returns a copy of itself */ + virtual Shape* getCopy () = 0; + + void setPosition(vector3d position) { + mPosition = position; + } + vector3d getPosition() { + return mPosition; + } + void setVelocity(vector3d velocity) { + mVelocity = velocity; + } + vector3d getVelocity() { + return mVelocity; + } + + void setAngle (const float &angle) { + mAngle = angle; + } + float getAngle () { + return mAngle; + } + void setAngleVelocity (float angle_velocity) { + mAngleVelocity = angle_velocity; + } + float getAngleVelocity () { + return mAngleVelocity; + } + + virtual void doPrintType() { + std::cout << "Shape" << std::endl; + } + virtual void doPrint (const char* name) { + std::cout << name << "" << std::endl; + } + friend int check_collision_rel(Shape *shape_a, Shape *shape_b, + vector3d *velocity_b, CollisionInfo* info); +}; + +class Polygon: public Shape { +private: + unsigned int mVerticeCount; + vector3d *mVertices; + bool mFreeVertices; +public: + Polygon() { + mVerticeCount = 0; + mVertices = NULL; + mFreeVertices = false; + } + Polygon(unsigned int n) { + mVerticeCount = n; + mVertices = new vector3d[n]; + mFreeVertices = true; + } + Polygon(unsigned int n, vector3d *vertices) { + mVerticeCount = n; + mFreeVertices = false; + + if (vertices == NULL && n > 0) { + mVertices = new vector3d [n]; + mFreeVertices = true; + } + + mVertices = vertices; + } + Polygon (const Polygon &polygon) : Shape (polygon) { + mVerticeCount = polygon.mVerticeCount; + mFreeVertices = true; + + mVertices = new vector3d[mVerticeCount]; + memcpy (mVertices, polygon.mVertices, sizeof (vector3d) * mVerticeCount); + } + virtual ~Polygon () { + if (mFreeVertices == true && mVertices) + delete[] mVertices; + } + + virtual Polygon* getCopy () { + Polygon *copy = new Polygon (*this); + + assert (copy); + + return copy; + } + + virtual void doPrintType() { + std::cout << "Polygon" << std::endl; + } + + virtual void doPrint (const char* name) { + std::cout << name << " (Polygon)" << std::endl; + + std::cout << "mVerticeCount = " << mVerticeCount << std::endl; + unsigned int i; + for (i = 0; i < mVerticeCount; i ++) { + std::cout << i << " = " << mVertices[i][0] << ", " << + mVertices[i][1] << ", " << + mVertices[i][2] << std::endl; + } + std::cout << "mPosition = " << mPosition[0] <<", " << + mPosition[1] << ", " << + mPosition[2] << std::endl; + + std::cout << "mVelocity = " << mVelocity[0] <<", " << + mVelocity[1] << ", " << + mVelocity[2] << std::endl; + + std::cout << "mAngle = " << mAngle << std::endl; + std::cout << "mAngleVelocity = " << mAngleVelocity << std::endl; + } + + unsigned int getVerticeCount () { + return mVerticeCount; + } + + vector3d& getVertice (unsigned int i) { + assert (i >= 0 && i < mVerticeCount); + return mVertices [i]; + } + + void setVertice (unsigned int i, const vector3d &vertice) { + assert (i >= 0 && i < mVerticeCount); + mVertices[i] = vertice; + } + + friend int check_collision_polygon_sphere(Shape *polygon_a, + Shape *sphere_b, CollisionInfo* info); +}; + +class Sphere: public Shape { +private: + float mRadius; +public: + Sphere (float radius) { + mRadius = radius; + Shape::setPosition (vector3d (0., 0., 0.)); + } + + Sphere(float radius, const vector3d &position) { + mRadius = radius; + Shape::setPosition(position); + } + + Sphere (const Sphere &sphere): + Shape (sphere), + mRadius (sphere.mRadius) { } + + virtual Sphere* getCopy() { + Sphere* copy = new Sphere (*this); + + return copy; + } + + virtual void doPrintType() { + std::cout << "Sphere" << std::endl; + } + + virtual void doPrint (const char* name) { + std::cout << name << " (Sphere)" << std::endl; + + std::cout << "mRadius = " << mRadius << std::endl; + std::cout << "mPosition = " << mPosition[0] <<", " << + mPosition[1] << ", " << + mPosition[2] << std::endl; + + std::cout << "mVelocity = " << mVelocity[0] <<", " << + mVelocity[1] << ", " << + mVelocity[2] << std::endl; + + std::cout << "mAngle = " << mAngle << std::endl; + std::cout << "mAngleVelocity = " << mAngleVelocity << std::endl; + } + + + void setRadius (float radius) { + mRadius = radius; + } + + float getRadius () { + return mRadius; + } + + friend int check_collision_polygon_sphere(Shape *polygon_a, + Shape *sphere_b, CollisionInfo* info); +}; + +/** \brief The higher level function to call for collision detection + * + * \param stepsize the timestep within we want to check for the collision + * \param shape_a first shape + * \param shape_b second shape + * \param info information about the collision will be to info + * + * \returns 0 - no collision, negative on error, positive on collision + */ +int check_collision(float timestep, Shape *shape_a, Shape *shape_b, CollisionInfo* info); + +/** \brief The higher level function to call for collision detection + * + * \param shape_a first shape + * \param shape_b second shape + * \param velocity_b relative velocity of b to a + * \param info information about the collision will be to info + * + * \returns 0 - no collision, negative on error, positive on collision + */ +int check_collision_rel(float timestep, Shape *shape_a, Shape *shape_b, vector3d *velocity_b, + CollisionInfo* info); + +/** \brief Callback signature for the check functions */ +typedef int (*check_cb)(float timestep, Shape *shape_a, Shape *shape_b, CollisionInfo* info); + +/** \brief Returns the check functions which performs the checks depending + * on their types. */ +check_cb get_check(Shape *shape_a, Shape *shape_b); + +/** \brief Performs a check between a polygon and a sphere + */ +int check_collision_polygon_sphere(float timestep, Shape *shape_a, Shape *shape_b, + CollisionInfo* info); + +/** \brief Performs a check between a sphere and a sphere + */ +int check_collision_sphere_sphere(float timestep, Shape *shape_a, Shape *shape_b, + CollisionInfo* info); + + +/** \brief Calculates the time it takes for a point to touch a plane + * + * \param normal normal vector of the plane + * \param plane_point point on the vector + * \param point point that is moving + * \param velocity velocity of the point + * + * \returns -1 if point is moving away from the plane (or is below and + * moves even further below + * >= 0 if point is moving along the plane or towards the plane + * + * This function depends on the scale of velocity. It is assumed + * that velocity represents the displacement in one frame. In this + * case a return value > 1 means there will not be a contact + * within this frame. + */ +float calculate_contact_plane_point(vector3d &normal, vector3d &plane_point, vector3d &point, vector3d &velocity); + +} + +#endif /* _COLL2D_H */ diff --git a/engine/libraries/coll2d/include/coll2d_errors.h b/engine/libraries/coll2d/include/coll2d_errors.h new file mode 100644 index 0000000..5ac1a25 --- /dev/null +++ b/engine/libraries/coll2d/include/coll2d_errors.h @@ -0,0 +1,9 @@ +#ifndef _COLL2D_ERRORS +#define _COLL2D_ERRORS + +#define CHECK_ERROR_UNKNOWN -9999 +#define CHECK_ERROR_NOT_IMPLEMENTED -1 +#define CHECK_ERROR_INVALID_TYPES -2 +#define CHECK_ERROR_OVERLAP -3 + +#endif /* _COLL2D_ERRORS */ diff --git a/engine/libraries/coll2d/src/coll2d.cc b/engine/libraries/coll2d/src/coll2d.cc new file mode 100644 index 0000000..aeaabcd --- /dev/null +++ b/engine/libraries/coll2d/src/coll2d.cc @@ -0,0 +1,572 @@ +#include +#include + +#include + +using namespace std; + +namespace coll2d { + +int check_collision (float timestep, Shape *shape_a, Shape *shape_b, CollisionInfo *info) { + check_cb check = NULL; + + check = get_check (shape_a, shape_b); + + if ( check == NULL ) { + return CHECK_ERROR_NOT_IMPLEMENTED; + } + + return check (timestep, shape_a, shape_b, info); +}; + +check_cb get_check (Shape *shape_a, Shape *shape_b) { + if ( (dynamic_cast (shape_a) != NULL) + && (dynamic_cast (shape_b) != NULL) ) { + return check_collision_polygon_sphere; + } + else if ( (dynamic_cast (shape_b) != NULL) + && (dynamic_cast (shape_a) != NULL) ) { + return check_collision_polygon_sphere; + } else if ( (dynamic_cast (shape_b) != NULL) + && (dynamic_cast (shape_a) != NULL) ) { + return check_collision_sphere_sphere; + } + + return NULL; +} + +int check_collision_rel (float timestep, Shape *shape_a, Shape *shape_b, vector3d *velocity_b, CollisionInfo *info) { + check_cb check = NULL; + + shape_b->setVelocity (*velocity_b); + check = get_check (shape_a, shape_b); + + if ( check == NULL ) { + return CHECK_ERROR_NOT_IMPLEMENTED; + } + + return check (timestep, shape_a, shape_b, info); +}; + +/** \brief calculates the time for a moving point to touch a plane + * + * \param normal The normal of the plane + * \param plane_point a point on the plane + * \param point the moving point + * \param velocity the velocity of the point + * + * \returns If the return value is negative, the point is moving away from the + * plane or is below the plane and thus does not touch it. Otherwise + * point + (return value) * velocity + * is on the plane. + */ +float calculate_contact_plane_point (vector3d &normal, vector3d &plane_point, vector3d &point, vector3d &velocity) { + vector3d temp_vector (point); + temp_vector -= plane_point; + + // If the following is < 0 then the point is "below" the plane + if (normal * temp_vector < 0) { + // If the following is < 0 then we move even deeper + if ( normal * velocity < 0 ) + return -999; + // Or towards the upper side of the plane. + else + return -111; + } + + int i,imax = -1; + float vmax = 0.; + for (i = 0; i < 3; i++) { + if ( normal[i] * velocity[i] < vmax) { + vmax = normal[i] * velocity[i]; + imax = i; + } + } + + if (imax == -1) { + return -1.; + } + + return (normal[imax] * plane_point[imax] - normal[imax] * point[imax]) / vmax; +} + +// #define VERBOSE_PHASE + +/** \brief Checks whether a sphere penetrates one of the polygones edges + * + * This check only finds intersections of the sphere with one of the sides in + * other words it will not find intersections with the vertices. As for convex + * polygons a sphere will either touch one of the edges or one of the + * vertices. + * + * First thing we do is calculate the normals pointing out of the polygon. + * Then for each edge e of the polygon (is being done by the function + * calculate_contatc_plane_point (...): + * - Calculate the point that would be the first to touch edge e if a contact + * occurs + * - Calculate the time it would take for this point to touch the edge with + * the relative velocity of the sphere + * + * Next we calculatefor each edge the point on the sphere which would be the first to touch + * the polygon, if it was moving towards the current edge. + */ +int check_collision_polygon_sphere_sides (Shape *shape_a, Shape *shape_b, CollisionInfo *info) { + Polygon* polygon = dynamic_cast (shape_a); + Sphere* sphere = dynamic_cast (shape_b); + + if ( polygon == NULL && sphere == NULL) { + polygon = dynamic_cast (shape_b); + sphere = dynamic_cast (shape_a); + } + + if (!polygon || !sphere) { + return CHECK_ERROR_INVALID_TYPES; + } + + vector3d velocity_sphere = sphere->getVelocity(); + + vector3d temp_vector (velocity_sphere); + if (temp_vector.length2() == 0.) + return 0; + + // Calculate the normals pointing OUT of the polygon + float *t = NULL, t_min = 10000.; + unsigned int i,j,vertices,count = 0; + vertices = polygon->getVerticeCount(); + vector3d *normals = NULL; + vector3d side (0., 0., 0.); + vector3d up (0., 1., 0.); +/* + if (polygon->getPosition().length() > 0.) { + for (i = 0; i < vertices; i++) { + polygon->getVertice(i) += polygon->getPosition(); + } + } +*/ + // normals contains all the normal vectors out of + // the polygon + normals = new vector3d[vertices]; + // The array t contains the time it takes until the sphere + // would touch the plane with the given velocity + t = new float[vertices]; + + for (i = 0; i < vertices; i++) { + j = (i + 1) % vertices; + side = polygon->getVertice(j); + side -= polygon->getVertice(i); + normals[i] = cross_product (side, up); + normals[i] /= normals[i].length (); + + // temp_vector is the point on the sphere that would touch the plane first + // if it was directly moving towards it + temp_vector = normals[i]; + temp_vector *= - sphere->getRadius(); + temp_vector += sphere->getPosition(); + + t[i] = calculate_contact_plane_point (normals[i], polygon->getVertice(i), temp_vector, velocity_sphere); + +#ifdef VERBOSE_PHASE + cout << "= next =" << endl; + cout << "t[" << i << "] = " << t[i] << " normal = "; normals[i].print (); + cout << "point = "; temp_vector.print(); + cout << "plane point = "; polygon->getVertice(i).print(); +#endif + if (t[i] < 0) + normals[i].setValues (0., 0., 0.); + else { + if (t[i] < t_min) + t_min = t[i]; + count ++; + } + } + + if (count == 0) { + delete[] t; + delete[] normals; + return 0; + } + + vector3d contact_point, cp_near; + + /// \ToDo: Instead of checking all planes, remember which ones to check + for (i = 0; i < vertices; i++) { + if ( t[i] >= 0) { + // So there seems to occur an collision. Now we have to check, + // whether this is actually between the points that define the + // plane. + unsigned int min_distance_vertex_index = i, other_vertice = (i + 1) % vertices; + float min_distance; + j = (i + 1) % vertices; + // First we calculate the actual contact point: + temp_vector = normals[i]; + temp_vector *= - sphere->getRadius(); + temp_vector *= t[i]; + temp_vector += sphere->getPosition(); + + contact_point = normals[i]; + contact_point *= -sphere->getRadius(); + contact_point += temp_vector; + + // Now we calculate to which vertice this point is closer: + temp_vector = contact_point; + temp_vector -= polygon->getVertice(i); + min_distance = temp_vector.length2 (); + + temp_vector = contact_point; + temp_vector -= polygon->getVertice(j); + + if (min_distance > temp_vector.length2 ()) { + min_distance_vertex_index = j; + other_vertice = i; + } + + // Then we want to see, whether the contact point actually lies + // on the vector that goes from one vertice to the other. For + // this we calculate (cp - near) * (far - near). The value + // cannot be greater than 1. (otherwise we would have picked + // the other vector as near. If it is < 0 then it is outside + // of the polygon. + temp_vector = polygon->getVertice(other_vertice); + temp_vector -= polygon->getVertice(min_distance_vertex_index); + + temp_vector /= temp_vector.length(); + + cp_near = contact_point; + cp_near -= polygon->getVertice(min_distance_vertex_index); + + float val = cp_near * temp_vector; + if ( (val >= 0 && val <= 1) && (t[i] <= 1.)) { + info->time = t[i]; + info->normal = normals[i]; + + info->point = sphere->getPosition(); + info->point += sphere->getVelocity() * t[i]; + info->point -= normals[i] * sphere->getRadius (); + + delete[] t; + delete[] normals; + return 1; + } + } + } + + /* + if ( (t_min <= 1.) && (t_min >= 0.)) { + return 1; + } + */ + + delete[] t; + delete[] normals; + + if (t_min > 1.) + return 0; + + return 0; +// return CHECK_ERROR_UNKNOWN; +}; + +int check_collision_polygon_sphere_vertices (Shape *shape_a, Shape *shape_b, CollisionInfo *info) { + Polygon* polygon = dynamic_cast (shape_a); + Sphere* sphere = dynamic_cast (shape_b); + + if ( polygon == NULL && sphere == NULL) { + polygon = dynamic_cast (shape_b); + sphere = dynamic_cast (shape_a); + } + + if (!polygon || !sphere) { + return CHECK_ERROR_INVALID_TYPES; + } + + // Transform global velocities to relative velocities: + /* + sphere->setVelocity (sphere->getVelocity() - polygon->getVelocity()); +*/ + vector3d velocity_sphere = sphere->getVelocity(); + + vector3d temp_vector (velocity_sphere); + if (temp_vector.length2() == 0.) { +#ifdef VERBOSE_PHASE + cout << "sphere has no velocity!" << endl; +#endif + return 0; + } + + vector3d contact_point, cp_near; + + // Okay if we happen to be here, there still might be one of + // the corners colliding with the sphere. + float a, b, c, t1, t2, t_min = 10000; + unsigned int i, j, vertices; + vector3d position (sphere->getPosition()); + vector3d velocity (sphere->getVelocity()); + float radius = sphere->getRadius(); + vertices = polygon->getVerticeCount(); + + for (i = 0; i < vertices; i++) { + vector3d vertice (polygon->getVertice(i)); + a = b = c = 0; + + // We must ensure that all happens in the x-z-plane (so y == 0.) + vertice[1] = 0.; + position[1] = 0.; + + vector3d distance_sphere_vertice; + for (j = 0; j < 3; j++) { + distance_sphere_vertice[j] = position[j] - vertice[j]; + } +#ifdef VERBOSE_PHASE + cout << " ===== " << endl; + cout << "vertice = "; + vertice.print (); + velocity.print (); + position.print (); + cout << "radius = " << radius << endl; + cout << "distance = " << distance_sphere_vertice.length () << endl;; +#endif + for (j = 0; j < 3; j++) { + a += velocity[j]*velocity[j]; + b += 2 * velocity[j] * (position[j] - vertice[j]); + c += position[j] * position[j] - 2 * position[j] * vertice[j] + vertice[j] * vertice[j]; + } + c -= radius * radius; + + if (solve_quadratic (a, b, c, &t1, &t2)) { +// cout << "solve_quadratic = " << t1 << "\t" << t2 << endl; + float t_temp_min = t2; + if (t1 < t2) + t_temp_min = t1; + + if (t_temp_min < t_min) { + if ((t_temp_min <= 1.) && (t_temp_min >= 0.)) { + t_min = t_temp_min; + temp_vector = position; + temp_vector -= vertice; + temp_vector /= temp_vector.length (); +#ifdef VERBOSE_PHASE + cout << "new closest point t = " << t_min << endl; +#endif + info->time = t_min; + info->normal = temp_vector; + info->point = vertice; + } + } + } + } + + if ( (t_min <= 1.) && (t_min >= 0.)) { + return 1; + } + + if (t_min > 1.) + return 0; + + return CHECK_ERROR_UNKNOWN; +}; + +int check_collision_polygon_sphere (float timestep, Shape *shape_a, Shape *shape_b, CollisionInfo *info) { + /* If the first shape given is a sphere and the second one a shape, we have + * to remember it to set the right value to *info. + */ + bool swapped = false; + Polygon* polygon_cast_test = dynamic_cast (shape_a); + Sphere* sphere_cast_test = dynamic_cast (shape_b); + + if ( polygon_cast_test == NULL && sphere_cast_test == NULL) { + polygon_cast_test = dynamic_cast (shape_b); + sphere_cast_test = dynamic_cast (shape_a); + + swapped = true; + } + + if (!polygon_cast_test || !sphere_cast_test) { + return CHECK_ERROR_INVALID_TYPES; + } + + Polygon polygon_copy (*polygon_cast_test); + Sphere sphere_copy (*sphere_cast_test); + + unsigned int vertices; + vertices = polygon_copy.getVerticeCount(); + +#ifdef VERBOSE_PHASE + cout << "======== New Polygon Sphere Test: Phase 1" << endl; + if (swapped) + cout << "Swapped!" << endl; + cout << "Polygon position: "; + polygon_copy.getPosition().print (); + cout << "Polygon velocity: "; + polygon_copy.getVelocity().print (); + cout << "Sphere position: "; + sphere_copy.getPosition().print (); + cout << "Sphere velocity: "; + sphere_copy.getVelocity().print (); + cout << "Timestep : " << timestep << endl; + + cout << "Vertices before transformation = " << endl; + int i; + for (i = 0; i < vertices; i++) { + polygon_copy.getVertice(i).print(); + } +#endif + + // Here we translate the polygon and its velocity into the reference frame + // of the polygon. + sphere_copy.setPosition (sphere_copy.getPosition() - polygon_copy.getPosition()); + sphere_copy.setPosition (sphere_copy.getPosition().rotate_y (-polygon_copy.getAngle())); + // Here scale the velocity so that our time horizon lies in [0., 1.] + sphere_copy.setVelocity ((sphere_copy.getVelocity() - polygon_copy.getVelocity() ) * timestep ); + sphere_copy.setVelocity (sphere_copy.getVelocity().rotate_y (-polygon_copy.getAngle())); + +#ifdef VERBOSE_PHASE + cout << "Vertices after transformation = " << endl; + for (i = 0; i < vertices; i++) { + polygon_copy.getVertice(i).print(); + } +#endif + +#ifdef VERBOSE_PHASE + cout << "After transformation:" << endl; + cout << "Polygon position: "; + polygon_copy.getPosition().print (); + cout << "Polygon velocity: "; + polygon_copy.getVelocity().print (); + cout << "Sphere position: "; + sphere_copy.getPosition().print (); + cout << "Sphere velocity: "; + sphere_copy.getVelocity().print (); +#endif + + CollisionInfo sides_info; + CollisionInfo vertices_info; + int sides_result = 0, vertices_result = 0; + + /* Tricky part: Since polygons are assumed to be convex and we calculated + * with both methods a collision, we take the sides result. Since they are + * convex the first event to happen is the collision with the side. + * Otherwise it would first touch the vertice and then the side, which is + * not possible. (\Todo true?) + */ + + sides_result = check_collision_polygon_sphere_sides (&polygon_copy, &sphere_copy, &sides_info); + // We have to transform the time back to [0., timestep] + sides_info.time *= timestep; +#ifdef VERBOSE_PHASE + cout << "sides_result = " << sides_result << " t = " << sides_info.time << endl; +#endif + if (sides_result > 0) { + sides_info.point.rotate_y (polygon_copy.getAngle()); + sides_info.normal.rotate_y (polygon_copy.getAngle()); + sides_info.point += polygon_copy.getPosition(); + memcpy (info, &sides_info, sizeof (CollisionInfo)); + sides_info.time *= timestep; + if (swapped == true) { + info->reference_shape = 1; + } else { + info->reference_shape = 0; + } + return sides_result; + } + + vertices_result = check_collision_polygon_sphere_vertices (&polygon_copy, &sphere_copy, &vertices_info); + // We have to transform the time back to [0., timestep] + vertices_info.time *= timestep; +#ifdef VERBOSE_PHASE + cout << "vertices_res = " << vertices_result << " t = " << vertices_info.time << endl; + cout << "vertices_point = "; + vertices_info.point.print(); +#endif + if (vertices_result > 0) { + vertices_info.point.rotate_y (polygon_copy.getAngle()); + vertices_info.normal.rotate_y (polygon_copy.getAngle()); + vertices_info.point += polygon_copy.getPosition(); + memcpy (info, &vertices_info, sizeof (CollisionInfo)); + if (swapped == true) { + info->reference_shape = 1; + } else { + info->reference_shape = 0; + } + return vertices_result; + } + + if ((sides_result == 0) && (vertices_result == 0)) + return 0; + + return CHECK_ERROR_UNKNOWN; +}; + +int check_collision_sphere_sphere (float timestep, Shape *shape_a, Shape *shape_b, CollisionInfo *info) { + /* If the first shape given is a sphere and the second one a shape, we have + * to remember it to set the right value to *info. + */ + Sphere* sphere_test_a = dynamic_cast (shape_a); + Sphere* sphere_test_b = dynamic_cast (shape_b); + + if (!sphere_test_a || !sphere_test_b) { + return CHECK_ERROR_INVALID_TYPES; + } + + Sphere sphere_a (*sphere_test_a); + Sphere sphere_b (*sphere_test_b); + + // First we check whether there is actually a relative velocity towards each + // other: + vector3d rel_velocity = sphere_b.getVelocity (); + rel_velocity -= sphere_a.getVelocity (); + rel_velocity *= timestep; + if (rel_velocity.length2() == 0.) + return 0; + + vector3d rel_position = sphere_b.getPosition (); + rel_position -= sphere_a.getPosition (); + + // We need to ignore height differences + rel_position[1] = 0.; + rel_velocity[1] = 0.; + + vector3d rel_position_norm = rel_position; + rel_position_norm.normalize (); + + float velocity_projection = rel_position_norm * rel_velocity; + float distance = rel_position.length(); + + if (velocity_projection >= 0.) + return 0; + + float t = (- distance + sphere_a.getRadius () + sphere_b.getRadius ()) / velocity_projection; + +#ifdef VERBOSE_PHASE + cout << "==== New Sphere Sphere Test ====" << endl; + cout << "Relative Position = "; + rel_position.print (); + cout << "Relative Velocity = "; + rel_velocity.print (); + cout << "velocity_projection = " << velocity_projection << endl; + cout << "distance = " << distance << endl; + cout << "- distance + Ra + Rb = " << - distance + sphere_a.getRadius () + sphere_b.getRadius () << endl; + cout << "t = " << t << endl; +#endif + + // if t < 0 this means we would have to move back in time + // to get to the point where the two spheres touched. In other words: they + // are overlapping, hence it is an invalid state! + if (t < 0) + return CHECK_ERROR_OVERLAP; + if (t > 1) + return 0; + + info->point = sphere_a.getPosition() + rel_position_norm * t; + info->time = t * timestep; + + if (sphere_a.getVelocity().length2() == 0.) { + info->normal = rel_position_norm; + info->reference_shape = 0; + } else { + info->normal = rel_position_norm * -1.; + info->reference_shape = 1; + } + return 1; +}; + +} diff --git a/engine/libraries/coll2d/tests/CMakeLists.txt b/engine/libraries/coll2d/tests/CMakeLists.txt new file mode 100644 index 0000000..da7a20b --- /dev/null +++ b/engine/libraries/coll2d/tests/CMakeLists.txt @@ -0,0 +1,51 @@ +PROJECT (ENGINETESTS) + +CMAKE_MINIMUM_REQUIRED (VERSION 2.6) + +# Needed for UnitTest++ +LIST( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../CMake ) + +SET ( TESTS_SRCS + main.cc + general.cc + polygon_sphere.cc + sphere_sphere.cc + ) + +FIND_PACKAGE (UnitTest++) + +INCLUDE_DIRECTORIES ( ../mathlib/ ) + +SET_TARGET_PROPERTIES ( ${PROJECT_EXECUTABLES} PROPERTIES + LINKER_LANGUAGE CXX +) + +IF ( UNITTEST++_FOUND ) + + ADD_EXECUTABLE ( coll2dtests ${TESTS_SRCS} ) + + INCLUDE_DIRECTORIES ( ${UNITTEST++_INCLUDE_DIR} ) + + SET_TARGET_PROPERTIES ( coll2dtests PROPERTIES + LINKER_LANGUAGE CXX + OUTPUT_NAME runtests + ) + + TARGET_LINK_LIBRARIES ( coll2dtests + ${UNITTEST++_LIBRARY} + mathlib + coll2d + ) + + OPTION (RUN_AUTOMATIC_TESTS "Perform automatic tests after compilation?" OFF) + + IF (RUN_AUTOMATIC_TESTS) + ADD_CUSTOM_COMMAND (TARGET coll2dtests + POST_BUILD + COMMAND coll2dtests + COMMENT "Running automated tests..." + ) + ENDIF (RUN_AUTOMATIC_TESTS) + +ENDIF ( UNITTEST++_FOUND ) + diff --git a/engine/libraries/coll2d/tests/general.cc b/engine/libraries/coll2d/tests/general.cc new file mode 100644 index 0000000..f68289a --- /dev/null +++ b/engine/libraries/coll2d/tests/general.cc @@ -0,0 +1,284 @@ +#include + +#include + +using namespace coll2d; +using namespace std; + +TEST ( SphereCopyConstructer ) { + Sphere sphere_a (123.); + sphere_a.setVelocity (vector3d(1., 2., 3.)); + + Sphere sphere_b (sphere_a); + CHECK_EQUAL (sphere_a.getRadius (), sphere_b.getRadius ()); + + vector3d velocity_a = sphere_a.getVelocity (); + vector3d velocity_b = sphere_b.getVelocity (); + + CHECK (velocity_a == velocity_b ); + + sphere_b.setVelocity (vector3d (0., 0., 0.)); + + velocity_a = sphere_a.getVelocity (); + velocity_b = sphere_b.getVelocity (); + + CHECK (velocity_a != velocity_b ); +} + +TEST ( PolygonCopyConstructer ) { + Polygon polygon_a (3); + + vector3d vertice0 (-1., 0., -1.); + vector3d vertice1 (1., 0., -1.); + vector3d vertice2 (0., 0., 1.); + + polygon_a.setVertice (0, vertice0); + polygon_a.setVertice (1, vertice1); + polygon_a.setVertice (2, vertice2); + + polygon_a.setVelocity (vector3d(1., 2., 3.)); + + Polygon polygon_b (polygon_a); + + vector3d velocity_a = polygon_a.getVelocity (); + vector3d velocity_b = polygon_b.getVelocity (); + + CHECK (vertice0 == polygon_b.getVertice (0)); + CHECK (vertice1 == polygon_b.getVertice (1)); + CHECK (vertice2 == polygon_b.getVertice (2)); + + polygon_b.setVelocity (vector3d (0., 0., 0.)); + velocity_a = polygon_a.getVelocity (); + velocity_b = polygon_b.getVelocity (); + + CHECK (velocity_a != velocity_b ); +} + +/** Checks whether we identify the different shapes + * correctly. + */ +TEST ( CheckShapeType ) { + vector3d sphere_position (0., 0., 0.); + + Shape* polygon = new Polygon (0, NULL); + Shape* sphere = new Sphere (0, sphere_position); + + Shape* cast_test = NULL; + + cast_test = dynamic_cast ( sphere ); + CHECK_EQUAL (cast_test, sphere); + cast_test = dynamic_cast ( polygon ); + CHECK (cast_test == NULL ); + cast_test = dynamic_cast (polygon); + CHECK_EQUAL (cast_test, polygon); + cast_test = dynamic_cast (sphere); + CHECK (cast_test == NULL ); + + delete polygon; + delete sphere; +} + +/** Checks whether the right check function is chosen + */ +TEST ( CheckGetCheck ) { + vector3d sphere_position (0., 0., 0.); + + Shape* polygon = new Polygon (0, NULL); + Shape* sphere = new Sphere (0, sphere_position); + + check_cb check = NULL; + + // polygon - sphere -> polygon_sphere + check = get_check (polygon, sphere); + CHECK (static_cast (check) == static_cast (check_collision_polygon_sphere)); + + // sphere - polygon -> polygon_sphere + check = get_check (sphere, polygon); + CHECK (static_cast (check) == static_cast (check_collision_polygon_sphere)); + + // and we do not want that the pointers have changed! + // (as it used to be in previous versions) + CHECK (dynamic_cast (sphere) == NULL); + CHECK (dynamic_cast (polygon) == NULL); + + check = get_check (sphere, sphere); + CHECK (check == check_collision_sphere_sphere); + + delete polygon; + delete sphere; +} + +TEST ( CheckErrorNotImplemented ) { + Shape* polygon = new Polygon (0, NULL); + vector3d velocity (0., 0., 0.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, polygon, &velocity, &info); + + CHECK (result == CHECK_ERROR_NOT_IMPLEMENTED); + + delete polygon; +} + +TEST ( CheckCalculateContactPlanePoint ) { + vector3d normal (1., 0., 0.); + vector3d plane_point (0., 0., 0.); + vector3d point (1., 0., 0.); + vector3d velocity (-1., 0., 0); + + float result; + + // Directly moving towards the plane + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (1, result); + + // Moving with a slight angle onto the plane + velocity.setValues (-1., 0., 0.2); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (1, result); + + velocity.setValues (-1., 0., 0.); + + // Point is "below" the plane and moves even deeper + plane_point.setValues (2., 0., 0); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (-999, result); + + // Point is "below" but moves towards the plane + velocity.setValues (1., 0., 0); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (-111, result); +} + +TEST ( CheckCollisionStepsize ) { + vector3d normal (1., 0., 0.); + vector3d plane_point (0., 0., 0.); + vector3d point (1., 0., 0.); + vector3d velocity (-1., 0., 0); + + float result; + + // Directly moving towards the plane + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (1, result); + + // Moving with a slight angle onto the plane + velocity.setValues (-1., 0., 0.2); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (1, result); + + velocity.setValues (-1., 0., 0.); + + // Point is "below" the plane and moves even deeper + plane_point.setValues (2., 0., 0); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (-999, result); + + // Point is "below" but moves towards the plane + velocity.setValues (1., 0., 0); + result = calculate_contact_plane_point (normal, plane_point, point, velocity); + CHECK_EQUAL (-111, result); +} + +/* Here we test, whether the value of info.reference_shape is correct. + * If we swap the shapes passed to check_collision, then the value must swap, + * too. + */ +TEST ( CheckReferenceShapeValue ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + // first part of the test, the collision occurs + // on an edge + vector3d sphere_position (2.3, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d (-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0, info.reference_shape); + + result = check_collision (1., sphere, polygon, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (1, info.reference_shape); + + // here the collision occurs on a vertice + sphere->setPosition (vector3d (1.5, 0., -2.5)); + sphere->setVelocity (vector3d (0., 0., 1.)); + + result = check_collision (1., sphere, polygon, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (1, info.reference_shape); + + result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0, info.reference_shape); + + delete sphere; + delete polygon; +} + +/* Test whether Polygon::getCopy() does what it should */ +TEST ( CheckPolygonGetCopy ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Polygon* polygon = new Polygon (4, vertices); + Polygon* polygon_copy = polygon->getCopy(); + + CHECK (polygon != polygon_copy); + CHECK_EQUAL (polygon->getVerticeCount(), polygon_copy->getVerticeCount()); + + unsigned int i, count; + count = polygon->getVerticeCount (); + + for (i = 0; i < count; i ++) { + vector3d vertice = polygon->getVertice (i); + vector3d vertice_copy = polygon_copy->getVertice (i); + + int j; + for (j = 0; j < 3; j++) { + CHECK_EQUAL (vertice[j], vertice_copy[j]); + } + } + + delete polygon; + delete polygon_copy; +} + +/* Test whether Sphere::getCopy() does what it should */ +TEST ( CheckSphereGetCopy ) { + Sphere* sphere = new Sphere (1.23); + Sphere* sphere_copy = sphere->getCopy(); + + CHECK_EQUAL (sphere->getRadius(), sphere_copy->getRadius()); + CHECK (sphere != sphere_copy); + + delete sphere; + delete sphere_copy; +} + +TEST ( SphereSetGetRadius ) { + Sphere sphere (123.); + CHECK_EQUAL (123, sphere.getRadius()); + + sphere.setRadius (456.); + CHECK_EQUAL (456, sphere.getRadius()); +} + + diff --git a/engine/libraries/coll2d/tests/main.cc b/engine/libraries/coll2d/tests/main.cc new file mode 100644 index 0000000..d37abc3 --- /dev/null +++ b/engine/libraries/coll2d/tests/main.cc @@ -0,0 +1,6 @@ +#include + +int main (int argc, char *argv[]) +{ + return UnitTest::RunAllTests (); +} diff --git a/engine/libraries/coll2d/tests/polygon_sphere.cc b/engine/libraries/coll2d/tests/polygon_sphere.cc new file mode 100644 index 0000000..cb79a5c --- /dev/null +++ b/engine/libraries/coll2d/tests/polygon_sphere.cc @@ -0,0 +1,544 @@ +#include + +#include + +using namespace coll2d; +using namespace std; + +TEST ( CheckErrorInvalidTypes ) { + Shape* polygon = new Polygon (0, NULL); + vector3d velocity (0., 0., 0.); + vector3d sphere_position (2.1, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d(0., 0., 0.)); + + CollisionInfo info; + int result = check_collision_polygon_sphere (1., sphere, sphere, &info); + CHECK (result == CHECK_ERROR_INVALID_TYPES); + + result = check_collision_polygon_sphere (1., polygon, polygon, &info); + CHECK (result == CHECK_ERROR_INVALID_TYPES); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereNoVelocity ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., -1.); + vertices[1].setValues (1., 0., -1.); + vertices[2].setValues (1., 0., 1.); + vertices[3].setValues (-1., 0., 1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.1, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0., 0., 0.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK (result >= 0); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereDiverging ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.1, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (1., 0., 0.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK (result >= 0); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereContact ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2., 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d (-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK (result > 0); + CHECK_EQUAL (0.0, info.time); + CHECK_EQUAL (1., info.normal[0]); + CHECK_EQUAL (0., info.normal[1]); + CHECK_EQUAL (0., info.normal[2]); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereColliding ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.5, 0., 0.1); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (-1., 0., 0.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereCollidingTop ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (0., 0., 2.5); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0., 0., -1.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereCollidingNonPerpendicular ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (0., 0., 2.5); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0.01, 0., -1.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereCollidingCorner) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position ( 1.5, 0., 2.5); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0.0, 0., -1.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (1, result); + + delete polygon; + delete sphere; +} + +// In this test we make sure, that the z value of both the polygon and the +// sphere get ignored: +TEST ( CheckCollisionPolygonSphereCollidingCornerIgnoreHeight) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position ( 1.5, 10., 2.5); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d (0., 0., -1.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + + vertices[0].setValues (-1., -10., 1.); + vertices[1].setValues (1., -10., 1.); + vertices[2].setValues (1., -10., -1.); + vertices[3].setValues (-1., -10., -1.); + + sphere->setPosition (vector3d (1.5, 0., 2.5)); + result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereCollidingCornerTop) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (1.5, 0., - 2.5); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0., 0., 1.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (1, result); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereCollidingCornerNeighbour) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., -0.99); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (1.5 , 0., - 2.5); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (0., 0., 1.); + + CollisionInfo info; + check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK (info.point == vertices[2]); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereNonCollidingSetPosition ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.5, 0., 0.1); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setPosition (vector3d (35, 0, 0)); + vector3d velocity (-1., 0., 0.); + + CollisionInfo info; + int result = check_collision_rel (1., polygon, sphere, &velocity, &info); + + CHECK_EQUAL (0, result); + + delete polygon; + delete sphere; +} + +// In this test we set the velocity of the polygon instead of the +// sphere. +TEST ( CheckCollisionPolygonSphereCollidingPolygonSetVelocity ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.5, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (1., 0., 0.); + polygon->setVelocity (velocity); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete polygon; + delete sphere; +} + +TEST ( CheckSetGetAngle ) { + Shape* polygon = new Polygon (0, NULL); + + polygon->setAngle (0.1234567); + + CHECK (fabs (0.1234567 - polygon->getAngle ()) < 1.0e-7); + + delete polygon; +} + +TEST ( CheckCollisionPolygonSphereDiamond ) { + vector3d vertices[4]; + float sqrt2 = sqrt (2); + + vertices[0].setValues (-sqrt2, 0., 0.); + vertices[1].setValues (0., 0., sqrt2); + vertices[2].setValues (sqrt2, 0., 0.); + vertices[3].setValues (0., 0., -sqrt2); + + Shape* polygon = new Polygon (4, vertices); + + Shape* sphere = new Sphere (1., vector3d (sqrt2 + 1.5, 0., 0.)); + sphere->setVelocity (vector3d (-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK (fabs (0.5 - info.time) <= 1.0e-6); + CHECK_EQUAL (0, info.reference_shape); + + delete polygon; + delete sphere; +} + +TEST ( CheckPolygonSpherePassingBy ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (1., 0., 2.5); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d (-2., 0., 0.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (0, result); + + delete sphere; + delete polygon; +} + +TEST ( CheckCollisionPolygonSphereReturnValuePoint ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + polygon->setPosition (vector3d (sqrt (2), 0., - sqrt (2))); + polygon->setAngle (M_PI * 0.25); + + Shape* sphere = new Sphere (1, vector3d (-sqrt(2) * 0.5, 0., sqrt (2) * 0.5)); + sphere->setVelocity (vector3d (sqrt (2), 0., -sqrt(2))); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK ( fabs (0.5 - info.time) < 1.0e-6); + CHECK ( (info.point - vector3d (sqrt (2) * 0.5, 0., -sqrt(2) * 0.5)).length() < 1.0e-6 ); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereReturnValuePointTranslated ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + polygon->setPosition (vector3d (sqrt (2) + 1., 0., - sqrt (2) - 1.)); + polygon->setAngle (M_PI * 0.25); + + Shape* sphere = new Sphere (1, vector3d (-sqrt(2) * 0.5 + 1., 0., sqrt (2) * 0.5 -1.)); + sphere->setVelocity (vector3d (sqrt (2), 0., -sqrt(2))); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK ( fabs (0.5 - info.time) < 1.0e-6); + CHECK ( (info.point - vector3d (sqrt (2) * 0.5 + 1, 0., -sqrt(2) * 0.5 - 1.)).length() < 1.0e-6 ); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereReturnValuePointVerticeTranslated ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + polygon->setPosition (vector3d (0. + 2., 0., - sqrt (2) - 1.5)); + polygon->setAngle (M_PI * 0.25); + + Shape* sphere = new Sphere (1, vector3d (0. + 2., 0., 0.)); + sphere->setVelocity (vector3d (0. , 0., -1.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK ( fabs (0.5 - info.time) < 1.0e-6); + CHECK ( (info.point - vector3d (0. + 2., 0., -1.5)).length() < 1.0e-6 ); + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereReferenceShapePolygon ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + polygon->setPosition (vector3d (0., 0., 0.)); + polygon->setVelocity (vector3d (1., 0., 0.)); + + Shape* sphere = new Sphere (1, vector3d (2.5, 0., 0.)); + sphere->setVelocity (vector3d (0., 0., 0.)); + + CollisionInfo info; + int result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK ( fabs (0.5 - info.time) < 1.0e-6); + CHECK_EQUAL ( 0, info.reference_shape ); + + polygon->setPosition (vector3d (0., 0., 0.)); + polygon->setVelocity (vector3d (1., 0., 0.)); + sphere->setPosition (vector3d (2.5, 0., 0.)); + sphere->setVelocity (vector3d (0., 0., 0.)); + + result = check_collision (1., sphere, polygon, &info); + + CHECK_EQUAL (1, result); + CHECK ( fabs (0.5 - info.time) < 1.0e-6); + CHECK_EQUAL ( 1, info.reference_shape ); + + + delete polygon; + delete sphere; +} + +TEST ( CheckCollisionPolygonSphereTimestep ) { + vector3d vertices[4]; + + vertices[0].setValues (-1., 0., 1.); + vertices[1].setValues (1., 0., 1.); + vertices[2].setValues (1., 0., -1.); + vertices[3].setValues (-1., 0., -1.); + + Shape* polygon = new Polygon (4, vertices); + + vector3d sphere_position (2.5, 0., 0.1); + Shape* sphere = new Sphere (1, sphere_position); + + vector3d velocity (-1., 0., 0.); + sphere->setVelocity (velocity); + + CollisionInfo info; + int result; + result = check_collision (1., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + result = check_collision (2., polygon, sphere, &info); + + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + result = check_collision (0.499, polygon, sphere, &info); + CHECK_EQUAL (0, result); + + delete polygon; + delete sphere; +} + + diff --git a/engine/libraries/coll2d/tests/sphere_sphere.cc b/engine/libraries/coll2d/tests/sphere_sphere.cc new file mode 100644 index 0000000..2698661 --- /dev/null +++ b/engine/libraries/coll2d/tests/sphere_sphere.cc @@ -0,0 +1,245 @@ +#include + +#include + +using namespace coll2d; +using namespace std; + +TEST ( CheckSphereSphereInvalidTypes ) { + Shape* polygon = new Polygon (0, NULL); + vector3d velocity (0., 0., 0.); + vector3d sphere_position (2.1, 0., 0.); + Shape* sphere = new Sphere (1, sphere_position); + sphere->setVelocity (vector3d(0., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., polygon, sphere, &info); + CHECK (result == CHECK_ERROR_INVALID_TYPES); + + delete polygon; + delete sphere; +} + +TEST ( CheckSphereSphereNoVelocity ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (4., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (0, result); + + delete sphere_a; + delete sphere_b; +} + +/* This tests whether we report a collision time of 0.0 when two spheres are + * in contact with each other + */ +TEST ( CheckCollisionSphereSphereContact ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (2., 0., 0.)); + + sphere_b->setVelocity (vector3d(-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + + CHECK (result >= 0); + CHECK_EQUAL (0.0, info.time); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereDiverging ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (4., 0., 0.)); + + sphere_b->setVelocity (vector3d (1., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (0, result); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereCollision ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (3., 0., 0.)); + + sphere_b->setVelocity (vector3d (-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereCollisionCheckOrder ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (3., 0., 0.)); + + sphere_a->setVelocity (vector3d (1., 0., 0.)); + sphere_b->setVelocity (vector3d (-1.5, 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + + vector3d normal = info.normal; + result = check_collision_sphere_sphere (1., sphere_b, sphere_a, &info); + CHECK_EQUAL (1, result); + + CHECK ( normal[0] == -info.normal[0]); + CHECK ( normal[1] == -info.normal[1]); + CHECK ( normal[2] == -info.normal[2]); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereNoCollision ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (3., 0., 0.)); + + sphere_b->setVelocity (vector3d (-0.9, 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (0, result); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereCollisionResult ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (2.5, 0., 0.)); + + sphere_b->setVelocity (vector3d (-1, 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereMovingNonHorizontal ) { + Shape* sphere_a = new Sphere (3., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1.5, vector3d (3., 0., 4.)); + + sphere_a->setVelocity (vector3d (3./5., 0., 4./5.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + + vector3d result_normal = vector3d (-3., 0., -4.).normalize(); + vector3d collision_point = result_normal * -0.5; + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + CHECK_EQUAL (1, info.reference_shape); + CHECK (result_normal == info.normal); + CHECK (collision_point == info.point); + + sphere_a->setVelocity (vector3d (0., 0., 0.)); + + sphere_b->setVelocity (vector3d (-3./5., 0., -4./5.)); + result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + + delete sphere_a; + delete sphere_b; +} + +/* If there is one of the sphere non moving we must ensure that we + * set the moving one as the incidence shape. + */ +TEST ( CheckSphereSphereReferenceShape ) { + Shape* sphere_a = new Sphere (3., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1.5, vector3d (3., 0., 4.)); + + sphere_a->setVelocity (vector3d (3./5., 0., 4./5.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + + vector3d result_normal = vector3d (-3., 0., -4.).normalize(); + vector3d collision_point = result_normal * 0.5; + CHECK_EQUAL (1, result); + CHECK_EQUAL (0.5, info.time); + CHECK (result_normal == info.normal); + CHECK_EQUAL (1, info.reference_shape); + + sphere_a->setVelocity (vector3d (0., 0., 0.)); + + sphere_b->setVelocity (vector3d (-3./5., 0., -4./5.)); + result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + CHECK (result_normal * -1. == info.normal); + CHECK_EQUAL (0.5, info.time); + CHECK_EQUAL (0, info.reference_shape); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereIgnoreHeight ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (3., 0., 0.)); + + sphere_b->setVelocity (vector3d (-2., 0., 0.)); + + sphere_a->setPosition (vector3d (0., 10., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckSphereSphereCollisionTimestep ) { + Shape* sphere_a = new Sphere (1., vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (1, vector3d (3., 0., 0.)); + + sphere_b->setVelocity (vector3d (-1., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (1, result); + CHECK_EQUAL (1, info.time); + + result = check_collision_sphere_sphere (2., sphere_a, sphere_b, &info); + CHECK_EQUAL (1., result); + CHECK_EQUAL (1., info.time); + + result = check_collision_sphere_sphere (0.5, sphere_a, sphere_b, &info); + CHECK_EQUAL (0, result); + + delete sphere_a; + delete sphere_b; +} + +TEST ( CheckPerpendicularMovement ) { + Shape* sphere_a = new Sphere (0.4, vector3d (0., 0., 0.)); + Shape* sphere_b = new Sphere (0.4, vector3d (0., 0., -1.)); + + sphere_a->setVelocity (vector3d (0., 0., 0.)); + sphere_b->setVelocity (vector3d (5., 0., 0.)); + + CollisionInfo info; + int result = check_collision_sphere_sphere (1., sphere_a, sphere_b, &info); + CHECK_EQUAL (0, result); + + delete sphere_a; + delete sphere_b; +} diff --git a/engine/libraries/mathlib/CMakeLists.txt b/engine/libraries/mathlib/CMakeLists.txt new file mode 100644 index 0000000..96ae294 --- /dev/null +++ b/engine/libraries/mathlib/CMakeLists.txt @@ -0,0 +1,10 @@ +PROJECT (MATHLIB CXX) + +LIST ( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/ ) + +SET ( SRCS + mathlib.cc + main.cc + ) + +ADD_LIBRARY ( mathlib mathlib.cc mathlib.h) diff --git a/engine/libraries/mathlib/mathlib.cc b/engine/libraries/mathlib/mathlib.cc new file mode 100644 index 0000000..0365fd6 --- /dev/null +++ b/engine/libraries/mathlib/mathlib.cc @@ -0,0 +1,224 @@ +#include +#include +#include +#include + +#include "mathlib.h" + +using namespace std; + +#ifdef WIN32 + +void sincos (float rad, double *s, double *c){ + *s = sin (rad); + *c = cos (rad); +} + +#endif + +vector3d::vector3d () +{ + values[0] = 0.; + values[1] = 0.; + values[2] = 0.; +} + +vector3d::vector3d (float u, float v, float w) +{ + values[0] = u; + values[1] = v; + values[2] = w; +} + +vector3d::vector3d (const vector3d &vec) +{ + values[0] = vec.values[0]; + values[1] = vec.values[1]; + values[2] = vec.values[2]; +} + +vector3d vector3d::operator=(const vector3d &vec) { + if (this != &vec) { + values[0] = vec.values[0]; + values[1] = vec.values[1]; + values[2] = vec.values[2]; + } + return *this; +} + +vector3d::~vector3d () +{ +} + +#ifndef MATHLIB_INLINE +vector3d vector3d::operator* (const float &f) +{ + return vector3d (values[0] * f, values[1] * f, values[2] * f); +} + +vector3d vector3d::operator/ (const float &f) +{ + return vector3d (values[0] / f, values[1] / f, values[2] / f); +} + +void vector3d::operator*= (const float &f) +{ + values[0] *= f; + values[1] *= f; + values[2] *= f; +} + +void vector3d::operator/= (const float &f) +{ + values[0] /= f; + values[1] /= f; + values[2] /= f; +} + +float vector3d::operator* (const vector3d &vec) +{ + return values[0] * vec.values[0] + values[1] * vec.values[1] + values[2] * vec.values[2]; +} + +vector3d vector3d::operator+ (const vector3d &vec) +{ + return vector3d (values[0] + vec.values[0], values[1] + vec.values[1], values[2] + vec.values[2]); +} + +vector3d vector3d::operator- (const vector3d &vec) +{ + return vector3d (values[0] - vec.values[0], values[1] - vec.values[1], values[2] - vec.values[2]); +} + +void vector3d::operator+= (const vector3d &vec) +{ + values[0] += vec.values[0]; + values[1] += vec.values[1]; + values[2] += vec.values[2]; +} + +void vector3d::operator-= (const vector3d &vec) +{ + values[0] -= vec.values[0]; + values[1] -= vec.values[1]; + values[2] -= vec.values[2]; +} + +bool vector3d::operator== (const vector3d &vec) +{ + if ( (values[0]==vec.values[0]) && (values[1]==vec.values[1]) && (values[2]==vec.values[2]) ) + return true; + return false; +} + +bool vector3d::operator!= (const vector3d &vec) +{ + return ! (operator==(vec)); +} + +vector3d vector3d::cross (const vector3d &vec) +{ + return vector3d (values[1] * vec.values[2] - values[2] * vec.values[1], + values[2] * vec.values[0] - values[0] * vec.values[2], + values[0] * vec.values[1] - values[1] * vec.values[0]); +} + +float vector3d::length2 () +{ + return values[0]*values[0] + values[1]*values[1] + values[2]*values[2]; +} + +float vector3d::length () +{ + return sqrt (values[0]*values[0] + values[1]*values[1] + values[2]*values[2]); +} +#endif + +vector3d& vector3d::rotate_x (float angle) +{ + vector3d old (*this); + double s,c; + sincos (angle, &s, &c); + + values[0] = old[0]; + values[1] = c * old[1] - s * old[2]; + values[2] = s * old[1] + c * old[2]; + + return *this; +} + +vector3d& vector3d::rotate_y (float angle) +{ + vector3d old (*this); + double s,c; + sincos (angle, &s, &c); + + values[0] = c * old[0] + s * old[2]; + values[1] = old[1]; + values[2] = - s * old[0] + c * old[2]; + + return *this; +} + +vector3d& vector3d::rotate_z (float angle) +{ + vector3d old (*this); + double s,c; + sincos (angle, &s, &c); + + values[0] = c * old[0] + -s * old[1]; + values[1] = s * old[0] + c * old[1]; + values[2] = old[2]; + + return *this; +} + +vector3d& vector3d::normalize () { + float norm = length (); + values [0] /= norm; + values [1] /= norm; + values [2] /= norm; + + return *this; +} + +void vector3d::print () +{ + std::cout << values[0] << " " << values[1] << " " << values[2] << std::endl; +} + +void vector3d::print (const char *str) +{ + std::cout << str << values[0] << " " << values[1] << " " << values[2] << std::endl; +} + +vector3d cross_product (vector3d &a, vector3d &b) { + return a.cross (b); +} + +inline bool point_within (vector3d *a, vector3d *b, vector3d *point); + +vector3d integrate_rk45 (float t, vector3d& ydot, vector3d& y) +{ + vector3d k1 = ydot * t; + vector3d k2 = (ydot + k1 / 2) * t; + vector3d k3 = (ydot + k2 / 2 ) * t; + vector3d k4 = (ydot + k3) * t; + + return y + (k1 + k2 * 2 + k3 * 2 + k4) / 6; +} + +vector3d integrate (float t, vector3d& ydot, vector3d& y) +{ + return integrate_rk45 (t, ydot, y); +} + +int solve_quadratic (float a, float b, float c, float *x1, float *x2) { + if (b*b - 4 * a * c < 0) + return 0; + *x1 = static_cast ((-b + sqrt (b*b - 4 * a * c)) / (2 * a)); + *x2 = static_cast ((-b - sqrt (b*b - 4 * a * c)) / (2 * a)); + + return 1; +} + diff --git a/engine/libraries/mathlib/mathlib.h b/engine/libraries/mathlib/mathlib.h new file mode 100644 index 0000000..fd30375 --- /dev/null +++ b/engine/libraries/mathlib/mathlib.h @@ -0,0 +1,179 @@ +#ifndef __MATHLIB_H +#define __MATHLIB_H + +#include +#include +#include + +#ifdef WIN32 + +#define M_PI 3.14159265 +void sincos (float rad, double *s, double *c); + +#endif + +#define MATHLIB_INLINE + +struct vector3d +{ + float values[3]; + + vector3d (); + vector3d (float u, float v, float w); + vector3d (const vector3d &vec); + vector3d operator= (const vector3d &vec); + ~vector3d (); + + // Setter and getter + inline void setValues (float u, float v, float w) { + values[0] = u; + values[1] = v; + values[2] = w; + } + + inline float& operator[] (const int index) { + assert (index >= 0); + assert (index <= 3); + + return values[index]; + } + + vector3d operator* (const float &f); + vector3d operator/ (const float &f); + void operator*= (const float &f); + void operator/= (const float &f); + + float operator* (const vector3d &vec); + vector3d operator+ (const vector3d &vec); + vector3d operator- (const vector3d &vec); + void operator+= (const vector3d &vec); + void operator-= (const vector3d &vec); + bool operator== (const vector3d &vec); + bool operator!= (const vector3d &vec); + vector3d cross (const vector3d &vec); + + float length2 (); + float length (); + float get_angle () { + return atan2 (values[1], values[0]); + } + + vector3d &rotate_x (float angle); + vector3d &rotate_y (float angle); + vector3d &rotate_z (float angle); + vector3d &normalize (); + + void print (); + void print (const char* str); +}; + +#ifdef MATHLIB_INLINE + +inline +vector3d vector3d::operator* (const float &f) +{ + return vector3d (values[0] * f, values[1] * f, values[2] * f); +} + +inline +vector3d vector3d::operator/ (const float &f) +{ + return vector3d (values[0] / f, values[1] / f, values[2] / f); +} + +inline +void vector3d::operator*= (const float &f) +{ + values[0] *= f; + values[1] *= f; + values[2] *= f; +} + +inline +void vector3d::operator/= (const float &f) +{ + values[0] /= f; + values[1] /= f; + values[2] /= f; +} + +inline +float vector3d::operator* (const vector3d &vec) +{ + return values[0] * vec.values[0] + values[1] * vec.values[1] + values[2] * vec.values[2]; +} + +inline +vector3d vector3d::operator+ (const vector3d &vec) +{ + return vector3d (values[0] + vec.values[0], values[1] + vec.values[1], values[2] + vec.values[2]); +} + +inline +vector3d vector3d::operator- (const vector3d &vec) +{ + return vector3d (values[0] - vec.values[0], values[1] - vec.values[1], values[2] - vec.values[2]); +} + +inline +void vector3d::operator+= (const vector3d &vec) +{ + values[0] += vec.values[0]; + values[1] += vec.values[1]; + values[2] += vec.values[2]; +} + +inline +void vector3d::operator-= (const vector3d &vec) +{ + values[0] -= vec.values[0]; + values[1] -= vec.values[1]; + values[2] -= vec.values[2]; +} + +inline +bool vector3d::operator== (const vector3d &vec) +{ + if ( (values[0]==vec.values[0]) && (values[1]==vec.values[1]) && (values[2]==vec.values[2]) ) + return true; + return false; +} + +inline +bool vector3d::operator!= (const vector3d &vec) +{ + return ! (operator==(vec)); +} + +inline +vector3d vector3d::cross (const vector3d &vec) +{ + return vector3d (values[1] * vec.values[2] - values[2] * vec.values[1], + values[2] * vec.values[0] - values[0] * vec.values[2], + values[0] * vec.values[1] - values[1] * vec.values[0]); +} + +inline +float vector3d::length2 () +{ + return values[0]*values[0] + values[1]*values[1] + values[2]*values[2]; +} + +inline +float vector3d::length () +{ + return sqrt (values[0]*values[0] + values[1]*values[1] + values[2]*values[2]); +} +#endif + +vector3d cross_product (vector3d &a, vector3d &b); + +inline bool point_within (vector3d *a, vector3d *b, vector3d *point); + +vector3d integrate_rk45 (float t,vector3d& ydot, vector3d& y); + +vector3d integrate (float t, vector3d& ydot, vector3d& y); + +int solve_quadratic (float a, float b, float c, float *x1, float *x2); + +#endif /* __MATHLIB_H */ diff --git a/engine/libraries/oglft/AUTHORS b/engine/libraries/oglft/AUTHORS new file mode 100644 index 0000000..2a22791 --- /dev/null +++ b/engine/libraries/oglft/AUTHORS @@ -0,0 +1,5 @@ +Authors of OGLFT + +Allen Barnett +Oliver Bock +Nigel Stewart diff --git a/engine/libraries/oglft/CMake/FindFreeType2.cmake b/engine/libraries/oglft/CMake/FindFreeType2.cmake new file mode 100644 index 0000000..3abf606 --- /dev/null +++ b/engine/libraries/oglft/CMake/FindFreeType2.cmake @@ -0,0 +1,28 @@ +# Tries to find FREETYPE2 (http://freetype2.bespin.org) a simple and fast +# network library by Lee Salzman +# + +SET (FREETYPE2_FOUND FALSE) + +FIND_PATH (FREETYPE2_INCLUDE_DIR freetype/freetype.h /usr/include/ /usr/local/include/ /usr/include/freetype2 /usr/local/include/freetype2 $ENV{FREETYPE2_PATH}/include $ENV{FREETYPE2_INCLUDE_PATH}) + +FIND_LIBRARY (FREETYPE2_LIBRARIES NAMES freetype PATHS /usr/lib /usr/local/lib $ENV{FREETYPE2_PATH} $ENV{FREETYPE2_PATH}/lib ENV{FREETYPE2_LIBRARY_PATH}) + +IF (FREETYPE2_INCLUDE_DIR AND FREETYPE2_LIBRARIES) + SET (FREETYPE2_FOUND TRUE) +ENDIF (FREETYPE2_INCLUDE_DIR AND FREETYPE2_LIBRARIES) + +IF (FREETYPE2_FOUND) + IF (NOT FREETYPE2_FIND_QUIETLY) + MESSAGE(STATUS "Found FREETYPE2: ${FREETYPE2_LIBRARIES}") + ENDIF (NOT FREETYPE2_FIND_QUIETLY) +ELSE (FREETYPE2_FOUND) + IF (FREETYPE2_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find FREETYPE2") + ENDIF (FREETYPE2_FIND_REQUIRED) +ENDIF (FREETYPE2_FOUND) + +MARK_AS_ADVANCED ( + FREETYPE2_INCLUDE_DIR + FREETYPE2_LIBRARIES + ) diff --git a/engine/libraries/oglft/CMakeLists.txt b/engine/libraries/oglft/CMakeLists.txt new file mode 100644 index 0000000..70dc430 --- /dev/null +++ b/engine/libraries/oglft/CMakeLists.txt @@ -0,0 +1,63 @@ +project( OGLFT ) + +CMAKE_MINIMUM_REQUIRED (VERSION 2.6) + +Set( CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake ) + +FIND_PACKAGE( OpenGL REQUIRED ) +FIND_PACKAGE( FreeType2 REQUIRED ) + +if( ENABLE_QT ) + find_package( Qt REQUIRED ) + if( DESIRED_QT_VERSION EQUAL 3 ) + find_package( KDE3 REQUIRED ) + endif( DESIRED_QT_VERSION EQUAL 3 ) +endif( ENABLE_QT ) + +if( ENABLE_GLE ) + find_package( GLE ) +endif( ENABLE_GLE ) + +# +# Test to determine if we want the "tripledot" (variable) form of the GLU tesselator callback. +# +if(NOT GLU_TESS_CALLBACK_TRIPLEDOT) + if(WIN32 OR CMAKE_SYSTEM_NAME MATCHES "Linux") + # Skip the compile check for platforms that never need the variable form + set(DEFAULT_GLU_TESS_CALLBACK_TRIPLEDOT false) + else(WIN32 OR CMAKE_SYSTEM_NAME MATCHES "Linux") + # For other platforms perform the check + include(CheckCXXSourceCompiles) + include(CheckIncludeFiles) + set(CMAKE_REQUIRED_INCLUDES ${OPENGL_INCLUDE_DIR}) + set(CMAKE_REQUIRED_LIBRARIES ${OPENGL_LIBRARY}) + check_include_files(OpenGL/gl.h HAVE_OPENGL_DIR) + if(HAVE_OPENGL_DIR) + set(OPENGL_DIR_PREFIX "OpenGL") + else(HAVE_OPENGL_DIR) + set(OPENGL_DIR_PREFIX "GL") + endif(HAVE_OPENGL_DIR) + set(GLUTESS_TEST_SOURCE " + #include <${OPENGL_DIR_PREFIX}/gl.h> + #include <${OPENGL_DIR_PREFIX}/glu.h> + typedef GLvoid (*GLUTessCallback)(...); + static void testcb(GLvoid *, void*) { } + int main() { + GLUtesselator *t = gluNewTess(); + gluTessCallback(t, GLU_TESS_VERTEX_DATA, GLUTessCallback(testcb)); + return 0; + } + ") + check_cxx_source_compiles("${GLUTESS_TEST_SOURCE}" GLU_Tesselator_Needs_Variable_Parameter_Callback_Convention_Failure_Means_No) + set(GLU_TESS_CALLBACK_TRIPLEDOT ${GLU_Tesselator_Needs_Variable_Parameter_Callback_Convention_Failure_Means_No}) + endif(WIN32 OR CMAKE_SYSTEM_NAME MATCHES "Linux") +endif(NOT GLU_TESS_CALLBACK_TRIPLEDOT) + +add_subdirectory( liboglft ) + +set( BUILD_OGLFT_TESTS OFF CACHE BOOL "Build oglft tests." ) + +if( BUILD_OGLFT_TESTS ) + enable_testing() + add_subdirectory( tests ) +endif( BUILD_OGLFT_TESTS ) diff --git a/engine/libraries/oglft/COPYING b/engine/libraries/oglft/COPYING new file mode 100644 index 0000000..d60c31a --- /dev/null +++ b/engine/libraries/oglft/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/engine/libraries/oglft/COPYING.LIB b/engine/libraries/oglft/COPYING.LIB new file mode 100644 index 0000000..b1e3f5a --- /dev/null +++ b/engine/libraries/oglft/COPYING.LIB @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/engine/libraries/oglft/ChangeLog b/engine/libraries/oglft/ChangeLog new file mode 100644 index 0000000..c193c52 --- /dev/null +++ b/engine/libraries/oglft/ChangeLog @@ -0,0 +1,432 @@ +2002-07-12 Allen Barnett + + * doc/Doxyfile, configure.ac: Updated to version 0.8. + + * liboglft/OGLFT.cpp: + Removed unnecessary default arguments from constructors. + + * tests/Makefile.am: Added extra demo3 header. + + * liboglft/OGLFT.h: Improved the Doxygen comments. + +2002-07-11 Allen Barnett + + * doc/documentation.dox: Updated to version 0.8 information. + + * NEWS: Added FreeType version warning. + + * liboglft/OGLFT.cpp: Updated to be compilable by G++ 3. + + Minor improvement of Doxygen comments. + + Added height() method. Returns the "line spacing" of the font. + + Added drawing of formatted numbers. + + Made a couple of changes to support newer versions of FreeType: + * A default charmap is not activated if there is no UNICODE map. + * Adjust creation of monochrome bitmap to account for even + number of bytes now in FreeType bitmaps. + + Correctly compute the vector size for each auxiliary face: + Type1 and TrueType fonts typically have different EM sizes. + + Reverted to tesselating straight lines with one step. + + * liboglft/OGLFT.h: Updated to be compilable by G++ 3. + + Minor improvement of Doxygen comments. + + Added height() method. Returns the "line spacing" of the font. + + Added drawing of formatted numbers. + + * tests/tutorial3.cpp: Updated to be compilable by G++ 3. + + * tests/tutorial2.cpp: Updated to be compilable by G++ 3. + + Also, minor modification to optionally (at compile time) use a + scalable representation. And, made it double buffered since that's the + only available visual with the Mach64 driver. + + * tests/tutorial1.cpp, tests/speedtest.cpp, tests/demo.cpp: + Updated to be compilable by G++ 3. + + * tests/demo3.cpp: Updated to be compilable by G++ 3. + + Added example of number formatting. + + * tests/demo2.cpp: Updated to be compilable by G++ 3. + + * tests/Demo3UnicodeExample.h: Added GPL header. + + * tests/Demo3UnicodeExample2.h: Initial checkin. + + * README: Improved Qt project instructions. + + * configure.ac: Updated version number. + + * tests/tests.pro, OGLFT.pro, liboglft/liboglft.pro: Initial checkin. + + * README, NEWS: Added new features for version 0.8. + +2002-07-11 Allen Barnett + + * doc/documentation.dox: Updated to version 0.8 information. + + * NEWS: Added FreeType version warning. + + * liboglft/OGLFT.cpp: Updated to be compilable by G++ 3. + + Minor improvement of Doxygen comments. + + Added height() method. Returns the "line spacing" of the font. + + Added drawing of formatted numbers. + + Made a couple of changes to support newer versions of FreeType: + * A default charmap is not activated if there is no UNICODE map. + * Adjust creation of monochrome bitmap to account for even + number of bytes now in FreeType bitmaps. + + Correctly compute the vector size for each auxiliary face: + Type1 and TrueType fonts typically have different EM sizes. + + Reverted to tesselating straight lines with one step. + + * liboglft/OGLFT.h: Updated to be compilable by G++ 3. + + Minor improvement of Doxygen comments. + + Added height() method. Returns the "line spacing" of the font. + + Added drawing of formatted numbers. + + * tests/tutorial3.cpp: Updated to be compilable by G++ 3. + + * tests/tutorial2.cpp: Updated to be compilable by G++ 3. + + Also, minor modification to optionally (at compile time) use a + scalable representation. And, made it double buffered since that's the + only available visual with the Mach64 driver. + + * tests/tutorial1.cpp, tests/speedtest.cpp, tests/demo.cpp: + Updated to be compilable by G++ 3. + + * tests/demo3.cpp: Updated to be compilable by G++ 3. + + Added example of number formatting. + + * tests/demo2.cpp: Updated to be compilable by G++ 3. + + * tests/Demo3UnicodeExample.h: Added GPL header. + + * tests/Demo3UnicodeExample2.h: Initial checkin. + + * README: Improved Qt project instructions. + + * configure.ac: Updated version number. + + * tests/tests.pro, OGLFT.pro, liboglft/liboglft.pro: Initial checkin. + + * README, NEWS: Added new features for version 0.8. + +2002-03-26 Allen Barnett + + * tests/tutorial2.cpp, tests/tutorial1.cpp: Added . + + * tests/demo3.cpp: + Without GL_RASTER_POSITION_UNCLIPPED_IBM, need to adjust some of the + text items so that they are not clipped. + + * tests/demo.cpp: + Reduced the size of the font since nVidia's OpenGL version does not + support the GL_RASTER_POSITION_UNCLIPPED_IBM. + + * configure.ac: + Note that disabling Qt support also removes UNICODE support. + +2002-03-26 allen@llama.lignumcomputing.org + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/tutorial2.cpp, /home/allen/cvsroot/lignumCAD/OGLFT/tests/tutorial1.cpp: + Added . + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo3.cpp: + Without GL_RASTER_POSITION_UNCLIPPED_IBM, need to adjust some of the + text items so that they are not clipped. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo.cpp: + Reduced the size of the font since nVidia's OpenGL version does not + support the GL_RASTER_POSITION_UNCLIPPED_IBM. + + * /home/allen/cvsroot/lignumCAD/OGLFT/configure.ac: + Note that disabling Qt support also removes UNICODE support. + +2002-03-25 allen@llama.lignumcomputing.org + + * /home/allen/cvsroot/lignumCAD/OGLFT/configure.ac: + Update the version number to 0.7. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/Makefile.am: + Use the correct name for the embedded font file. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.cpp: + Updated Doxygen comments. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo3.cpp: + Use .h for embedded font file to make automake happier. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo3.cpp, /home/allen/cvsroot/lignumCAD/OGLFT/tests/Demo3UnicodeExample.c, /home/allen/cvsroot/lignumCAD/OGLFT/tests/Demo3UnicodeExample.sfd, /home/allen/cvsroot/lignumCAD/OGLFT/tests/Demo3UnicodeExample.ttf, /home/allen/cvsroot/lignumCAD/OGLFT/tests/tosrc.pl: + Add demo files for UNICODE and multiple fonts. + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/documentation.dox: + Updated to 0.7. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Updated the Doxygen comments. + + * /home/allen/cvsroot/lignumCAD/OGLFT/NEWS: Addes the latest news. + + * /home/allen/cvsroot/lignumCAD/OGLFT/README: + Mention UNICODE rendering dependence on Qt and how to build the test programs. + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/Doxyfile: + Updated version number. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Fix typos in description of vertical justification enum documentation. + + * /home/allen/cvsroot/lignumCAD/OGLFT/configure.ac: + Now, if you have Qt and don't disable it, the library will compile + with UNICODE support, in the form of Qt's QString. Thus, the FLAGS + necessary to compile with Qt are propagated through to all the + Makefiles. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + * Added the ability to draw glyphs based on UNICODE characters. Here, + we use the Qt UNICODE representation: QString. Additionally, there + are methods to set the foreground and background colors using + QColor. + + * Made the definition of measure(const char*) explicit in each of + Face's immediate subclasses in order to avoid a complaint from + gcc 2.95 about "using measure" from Face. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.cpp: + * Added the ability to draw glyphs based on UNICODE characters. Here, + we use the Qt UNICODE representation: QString. Additionally, there + are methods to set the foreground and background colors using + QColor. + + * Removed redundant insertion of display list index in the glyph display + list cache. + + * Removed memory leak on deletion of face. Was not freeing the glyph + display lists. + + * Added check for validity of FT_Face in OGLFT::Face subclasses before + proceeding with subclass initiliation. + + * For now at least, tessellation of straight lines is also broken into + segments so that the triangles produced by gluTess* are (slightly) + more regular. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Fix issue with compiling under older version (2.95) of GCC g++. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.cpp: + Add extra case statements to silence compiler warning. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Fix bug in BoundingBox auto-increment operator. + +2002-02-05 allen@llama.lignumcomputing.org + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/documentation.dox: + Update copyright date and SourceForge logo reference. + +2002-02-04 allen@llama.lignumcomputing.org + + * /home/allen/cvsroot/lignumCAD/OGLFT/NEWS, /home/allen/cvsroot/lignumCAD/OGLFT/configure.ac, /home/allen/cvsroot/lignumCAD/OGLFT/doc/Doxyfile: + Update to 0.6. + + * /home/allen/cvsroot/lignumCAD/OGLFT/NEWS: + Comment on "Changes to improve compilation on SGI." + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h, /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.cpp: + Changes to improve compilation on SGI. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Don't try to include mpatrol header if built without mpatrol. + + * /home/allen/cvsroot/lignumCAD/OGLFT/configure.ac: + * Make sure to check for libm first. + + * Do not continue build if proper freetype headers are not found. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo2.cpp: + stdio.h not included if mpatrol is undefined. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/Makefile.am: + Don't include moc_*.cpp files in distribution. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/vignette.h, /home/allen/cvsroot/lignumCAD/OGLFT/tests/speedtest.h: + Missing definition of exit() when built in "dist" mode (?) + + * /home/allen/cvsroot/lignumCAD/OGLFT/ChangeLog: + Reran EMACS regeneration command. + + * /home/allen/cvsroot/lignumCAD/OGLFT/NEWS: + Add note about already open FT_Face. + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/html/classOGLFT_1_1ColorTess.html, /home/allen/cvsroot/lignumCAD/OGLFT/doc/html/classOGLFT_1_1ColorTess-members.html, /home/allen/cvsroot/lignumCAD/OGLFT/doc/html/classOGLFT_1_1TextureTess.html, /home/allen/cvsroot/lignumCAD/OGLFT/doc/html/classOGLFT_1_1TextureTess-members.html: + New structures. + + * /home/allen/cvsroot/lignumCAD/OGLFT/ChangeLog, /home/allen/cvsroot/lignumCAD/OGLFT/Makefile.in, /home/allen/cvsroot/lignumCAD/OGLFT/NEWS: + Updates for version 0.5. + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/Doxyfile: + Updated version number. + + * /home/allen/cvsroot/lignumCAD/OGLFT/doc/documentation.dox: + Updates for version 0.5. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo2.cpp: + Demo of using an already open FT_Face. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo3.cpp: The spiffy demo. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/Makefile.am: + Renamed demo2 and demo3. + + * /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.cpp, /home/allen/cvsroot/lignumCAD/OGLFT/liboglft/OGLFT.h: + Add a constructor where the FT_Face is already open. + + * /home/allen/cvsroot/lignumCAD/OGLFT/README: + Updated compilation instructions to better describe configure options. + + * /home/allen/cvsroot/lignumCAD/OGLFT/Makefile.am: + Add target for the bzip distribution. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/Makefile.am: + Added demo2 texture.png to distribution. + + * /home/allen/cvsroot/lignumCAD/OGLFT/tests/demo2.cpp: + Run the per glyph display text in the other direction. + +2002-02-04 Allen Barnett + + * NEWS: Comment on "Changes to improve compilation on SGI." + + * liboglft/OGLFT.h, liboglft/OGLFT.cpp: + Changes to improve compilation on SGI. + + * liboglft/OGLFT.h: + Don't try to include mpatrol header if built without mpatrol. + + * configure.ac: * Make sure to check for libm first. + + * Do not continue build if proper freetype headers are not found. + + * tests/demo2.cpp: stdio.h not included if mpatrol is undefined. + + * tests/Makefile.am: Don't include moc_*.cpp files in distribution. + + * tests/vignette.h, tests/speedtest.h: + Missing definition of exit() when built in "dist" mode (?) + + * ChangeLog: Reran EMACS regeneration command. + + * NEWS: Add note about already open FT_Face. + + * doc/Doxyfile: Updated version number. + + * doc/documentation.dox: Updates for version 0.5. + + * tests/demo2.cpp: Demo of using an already open FT_Face. + + * tests/demo3.cpp: The spiffy demo. + + * tests/Makefile.am: Renamed demo2 and demo3. + + * liboglft/OGLFT.cpp, liboglft/OGLFT.h: + Add a constructor where the FT_Face is already open. + + * README: + Updated compilation instructions to better describe configure options. + + * Makefile.am: Add target for the bzip distribution. + + * tests/Makefile.am: Added demo2 texture.png to distribution. + + * tests/demo2.cpp: + Run the per glyph display text in the other direction. + +2002-02-01 Allen Barnett + + * tests/background00a.png, tests/background00b.png, tests/background00.png, tests/background01.png, tests/background10a.png, tests/background10b.png, tests/background10.png, tests/background11.png, tests/background.png: + Background images for demo2. + + * tests/tutorial3.cpp, tests/speedtest.cpp: + Accounted for absence of Solid face. + + * configure.ac: Improved GLE checking. + + * tests/demo2.cpp, tests/demo.cpp: Accounted for absence of Solid face. + + * configure.ac: Added an mpatrol configuration option. + + * liboglft/OGLFT.h: + Added definitions for Color and Texture callbacks during tessellation. + + * liboglft/OGLFT.cpp: * Added color callback for Face::Outline. + + * Added color and texture callbacks for Face::Filled. + + * Properly set the character rotation reference for all face types. + + * Cleaned up memory leak during GLU tesselation. + + * tests/vignette.h, tests/demo2.cpp: Initial checkin + +2002-02-01 Allen Barnett + + * tests/background00a.png, tests/background00b.png, tests/background00.png, tests/background01.png, tests/background10a.png, tests/background10b.png, tests/background10.png, tests/background11.png, tests/background.png: + Background images for demo2. + + * tests/tutorial3.cpp, tests/speedtest.cpp: + Accounted for absence of Solid face. + + * configure.ac: Improved GLE checking. + + * tests/demo2.cpp, tests/demo.cpp: Accounted for absence of Solid face. + + * configure.ac: Added an mpatrol configuration option. + + * liboglft/OGLFT.h: + Added definitions for Color and Texture callbacks during tessellation. + + * liboglft/OGLFT.cpp: * Added color callback for Face::Outline. + + * Added color and texture callbacks for Face::Filled. + + * Properly set the character rotation reference for all face types. + + * Cleaned up memory leak during GLU tesselation. + + * tests/vignette.h, tests/demo2.cpp: Initial checkin + +2002-01-29 Allen Barnett + + * liboglft/OGLFT.cpp: Moved config.h to the main library source . + + * liboglft/Makefile.am: Be sure to install the library header file. + + * liboglft/OGLFT.h: Moved config.h to the main library source. + + * tests/tutorial3.cpp, tests/tutorial2.cpp, tests/tutorial1.cpp, tests/speedtest.cpp: + Added revsion control keyword (Id). + + * tests/speedtest.cpp, tests/speedtest.h: + Reorganized a little to help automake deal with .moc files. + diff --git a/engine/libraries/oglft/INSTALL b/engine/libraries/oglft/INSTALL new file mode 100644 index 0000000..62ea076 --- /dev/null +++ b/engine/libraries/oglft/INSTALL @@ -0,0 +1,231 @@ +Copyright 1994, 1995, 1996, 1999, 2000, 2001 Free Software Foundation, +Inc. + + This file is free documentation; the Free Software Foundation gives +unlimited permission to copy, distribute and modify it. + +Basic Installation +================== + + These are generic installation instructions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +debugging `configure'). + + It can also use an optional file (typically called `config.cache' +and enabled with `--cache-file=config.cache' or simply `-C') that saves +the results of its tests to speed up reconfiguring. (Caching is +disabled by default to prevent problems with accidental use of stale +cache files.) + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +some point `config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file `configure.ac' (or `configure.in') is used to create +`configure' by a program called `autoconf'. You only need +`configure.ac' if you want to change it or regenerate `configure' using +a newer version of `autoconf'. + +The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. If you're + using `csh' on an old version of System V, you might need to type + `sh ./configure' instead to prevent `csh' from trying to execute + `configure' itself. + + Running `configure' takes awhile. While running, it prints some + messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. Run `./configure --help' +for details on some of the pertinent environment variables. + + You can give `configure' initial values for variables by setting +them in the environment. You can do that on the command line like this: + + ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you must use a version of `make' that +supports the `VPATH' variable, such as GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. + + If you have to use a `make' that does not support the `VPATH' +variable, you have to compile the package for one architecture at a +time in the source code directory. After you have installed the +package for one architecture, use `make distclean' before reconfiguring +for another architecture. + +Installation Names +================== + + By default, `make install' will install the package's files in +`/usr/local/bin', `/usr/local/man', etc. You can specify an +installation prefix other than `/usr/local' by giving `configure' the +option `--prefix=PATH'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +give `configure' the option `--exec-prefix=PATH', the package will use +PATH as the prefix for installing programs and libraries. +Documentation and other data files will still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=PATH' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + +Optional Features +================= + + Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + +Specifying the System Type +========================== + + There may be some features `configure' cannot figure out +automatically, but needs to determine by the type of host the package +will run on. Usually `configure' can figure that out, but if it prints +a message saying it cannot guess the host type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS KERNEL-OS + + See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the host type. + + If you are _building_ compiler tools for cross-compiling, you should +use the `--target=TYPE' option to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the host +platform (i.e., that on which the generated programs will eventually be +run) with `--host=TYPE'. In this case, you should also specify the +build platform with `--build=TYPE', because, in this case, it may not +be possible to guess the build platform (it sometimes involves +compiling and running simple test programs, and this can't be done if +the compiler is a cross compiler). + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + + Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the `configure' command line, using `VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +will cause the specified gcc to be used as the C compiler (unless it is +overridden in the site shell script). + +`configure' Invocation +====================== + + `configure' recognizes the following options to control how it +operates. + +`--help' +`-h' + Print a summary of the options to `configure', and exit. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff --git a/engine/libraries/oglft/NEWS b/engine/libraries/oglft/NEWS new file mode 100644 index 0000000..bc5efa7 --- /dev/null +++ b/engine/libraries/oglft/NEWS @@ -0,0 +1,46 @@ +New in OGLFT version 0.8 + + * Added the ability to draw numbers with a format à la printf. + There is also a format, %p, which will draw the number as + a fraction. + + * Updated the source to be compilable with G++ 3. + + * Added an (untested) Qt project for OSs which don't support + autoconf. + + * Note: FreeType versions 2.0.9 through 2.1.2 contain a bug which + prevents rotated text from being rendered correctly. + +New in OGLFT version 0.7 + + * Fixed another memory leak when deleting a Face which had compiled + its glyphs into display lists (the default behavior). + + * Added the ability to render UNICODE glyphs using Qt QStrings. + + * Added the ability to use mulitple FT_Faces in a single OGLFT::Face + so that you can cover more UNICODE points by combining fonts. + +New in OGLFT version 0.6 + + Updates include: + + * Fixed a pervasive memory leak (must call FT_Done_Glyph after each + call to FT_Get_Glyph). + + * measure() now queries the OpenGL view and calls gluUnProject to + compute accurate glyph sizes. + + * Autoconf-enabled. + + * There is a user color callback for drawing the Outline face and + color and texture coordinate callbacks for the Filled face. + + * Can pass an already open FreeType FT_Face to a rendering style. + + * Changes to improve compilation on the SGI. + +;;;Local variables: *** +;;;mode: text *** +;;;End: *** diff --git a/engine/libraries/oglft/OGLFT.h b/engine/libraries/oglft/OGLFT.h new file mode 100644 index 0000000..a8bf6ed --- /dev/null +++ b/engine/libraries/oglft/OGLFT.h @@ -0,0 +1,2321 @@ +// -*- c++ -*- +/* + * OGLFT: A library for drawing text with OpenGL using the FreeType library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id: OGLFT.h.cmake 107 2008-04-25 09:29:24Z brevilo $ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +#ifndef OGLFT_H +#define OGLFT_H + +// CMake activates these definitions. +/* #undef ENABLE_QT */ +/* #undef ENABLE_GLE */ +/* #undef GLU_TESS_CALLBACK_TRIPLEDOT */ +/* #undef HAVE_OPENGL_DIR */ +// Convert to our old options. +#if !defined(ENABLE_QT) +#define OGLFT_NO_QT +#endif +#if !defined(ENABLE_GLE) +#define OGLFT_NO_SOLID +#endif + +#include +#include +#include +#include + +#ifdef WIN32 +#include +#endif + +#ifdef HAVE_OPENGL_DIR +#include +#include +#else +#include +#include +#endif + +#ifndef OGLFT_NO_SOLID +#ifdef HAVE_OPENGL_DIR +#include +#else +#include +#endif +#endif + +#ifndef OGLFT_NO_QT +#define OGLFT_QT_VERSION +#if OGLFT_QT_VERSION == 3 +#include +#include +#elif OGLFT_QT_VERSION == 4 +#include +#include +#endif +#endif + +#include +#include FT_FREETYPE_H +#include FT_GLYPH_H +#include FT_OUTLINE_H +#include FT_TRIGONOMETRY_H + +#ifdef _MSC_VER +#ifdef OGLFT_BUILD +#define OGLFT_API __declspec(dllexport) +#else +#define OGLFT_API __declspec(dllimport) +#endif +#else +#define OGLFT_API +#endif + +//! All of OGLFT C++ objects are in this namespace. + +namespace OGLFT { + + //! Thanks to DesCartes, I'd consider these manifest constants. + enum Coordinates { + X, //!< The X component of space + Y, //!< The Y component of space + Z, //!< The Z component of space + W //!< The projection component of space + }; + + //! Who to credit? Newton? I'd consider these manifest constants. + enum ColorSpace { + R, //!< The Red component of a color + G, //!< The Green component of a color + B, //!< The Blue component of a color + A, //!< The Alpha (or transparency) of a color + }; + + //! Callback from GLU tessellation routines. +#ifdef GLU_TESS_CALLBACK_TRIPLEDOT + typedef GLvoid (*GLUTessCallback)(...); +#else + typedef GLvoid (*GLUTessCallback)(); +#endif + + //! The FreeType library instance. + /*! + * The FreeType library has a single, global instance of a library + * handle. This reference is used to load font faces. This detail + * is generally hidden from the user of OGLFT, however, it + * can be useful to get the FT_Library instance if you want to open + * a font file yourself, either from disk or embedded in the program. + */ + class Library { + public: + /*! + * The FreeType library's library handle is only available through this + * accessor method. + * \return the global OGLFT FreeType library handle. + */ + static OGLFT_API FT_Library& instance ( void ); + + protected: + /*! + * The constructor for this class is automatically called when + * this library is loaded. Access the instance through the instance() + * method. + */ + OGLFT_API Library ( void ); + /*! + * This destructor is automatically called when the program exits. + */ + OGLFT_API ~Library( void ); + + private: + static Library library; + static FT_Library library_; + }; + + //! Advance describes the "advance" of a glyph, namely the distance in + //! model space at which the NEXT glyph should be drawn. This class exists + //! to assist the computation of string metrics. + struct OGLFT_API Advance { + float dx_; //!< Advance increment in the X direction. + float dy_; //!< Advance increment in the Y direction. + + //! Default constructor. An otherwise uninitialized Advance contains zeros. + Advance ( float dx = 0, float dy = 0 ) : dx_( dx ), dy_( dy ) + {} + + //! Initialize an advance from a FreeType advance member. + Advance ( FT_Vector v ) + { + dx_ = v.x / 64.f; + dy_ = v.y / 64.f; + } + + //! Increment Advance with a FreeType advance member. + //! \return a reference to oneself. + Advance& operator+= ( const FT_Vector v ) + { + dx_ += v.x / 64.f; + dy_ += v.y / 64.f; + return *this; + } + }; + + //! Describe the metrics of a glyph or string relative to the origin + //! of the first character + struct OGLFT_API BBox { + float x_min_; //!< The left-most position at which "ink" appears. + float y_min_; //!< the bottom-most position at which "ink" appears. + float x_max_; //!< The right-most position at which "ink" appears. + float y_max_; //!< The top-most position at which "ink" appears. + Advance advance_; //!< The (total) advancement + + //! Default constructor is all zeros. + BBox () : x_min_( 0 ), y_min_( 0 ), x_max_( 0 ), y_max_( 0 ) + {} + + /*! + *(Partially) initialize a BBox from a FreeType bounding box member. + *(The advancement is initialized to zero by its default constructor). + * \param ft_bbox a FreeType bounding box as retrieved from + * \c FT_Glyph_Get_CBox. + */ + BBox ( FT_BBox ft_bbox ) + { + x_min_ = ft_bbox.xMin / 64.f; + y_min_ = ft_bbox.yMin / 64.f; + x_max_ = ft_bbox.xMax / 64.f; + y_max_ = ft_bbox.yMax / 64.f; + } + + //! Scale the bounding box by a constant. + //! \param k a constant to scale the bounding box by. + //! \return a reference to oneself. + BBox& operator*= ( float k ) + { + x_min_ *= k; + y_min_ *= k; + x_max_ *= k; + y_max_ *= k; + advance_.dx_ *= k; + advance_.dy_ *= k; + + return *this; + } + + /*! + * Merge a bounding box into the current one (not really addition). + * Each time a BBox is "added", the current BBox is expanded to include + * the metrics of the new BBox. May only work for horizontal fonts, though. + * \param b the bounding box to merge. + * \return a reference to oneself. + */ + BBox& operator+= ( const BBox& b ) + { + float new_value; + + new_value = b.x_min_ + advance_.dx_; + if ( new_value < x_min_ ) x_min_ = new_value; + + new_value = b.y_min_ + advance_.dy_; + if ( new_value < y_min_ ) y_min_ = new_value; + + new_value = b.x_max_ + advance_.dx_; + if ( new_value > x_max_ ) x_max_ = new_value; + + new_value = b.y_max_ + advance_.dy_; + if ( new_value > y_max_ ) y_max_ = new_value; + + advance_.dx_ += b.advance_.dx_; + advance_.dy_ += b.advance_.dy_; + + return *this; + } + }; + + //! During tesselation of a polygonal Face (outline, filled or solid), + //! an object which implements this interface can be used to compute a + //! different color for each vertex. + class OGLFT_API ColorTess { + public: + virtual ~ColorTess ( void ) {} + //! Compute a color for this position. Note that the position is + //! in the glyph's local coordinate system. + //! \param p vertex position in glyph's local coordinate system. Argument is + //! a GLdouble[3]. + //! \return GLfloat[4] (RGBA) color specification. + virtual GLfloat* color ( GLdouble* p ) = 0; + }; + + //! During tesselation of a polygonal Face (outline, filled or solid), + //! an object which implements this interface can be used to compute a + //! different texture coordinate for each vertex. + class OGLFT_API TextureTess { + public: + virtual ~TextureTess ( void ) {} + //! Compute a texture coordinate for this position. Note that the + //! position is in the glyph's local coordinate system. + //! \param p vertex position in glyph's local coordinate system. Argument is + //! a GLdouble[3]. + //! \return GLfloat[2] (s,t) texture coordinates. + virtual GLfloat* texCoord ( GLdouble* p ) = 0; + }; + + //! The argument to setCharacterDisplayLists is an STL vector of + //! OpenGL display list names (GLuints). + typedef std::vector DisplayLists; + + //! A convenience definition of an iterator for display list vectors. + typedef DisplayLists::const_iterator DLCI; + + //! A convenience definition of an iterator for display list vectors. + typedef DisplayLists::iterator DLI; + + //! A face (aka font) used to render text with OpenGL. + /*! + * This is an abstract class, but it does define most the functions that + * you are likely to call to manipulate the rendering of the text. + */ + class Face { + public: + //! Thanks to the standard formerly known as PHIGS. Horizontal text + //! justification constants. + enum OGLFT_API HorizontalJustification { + LEFT, //!< Left justified justification of text + ORIGIN, //!< Natural origin alignment of text (default) + CENTER, //!< Center justified alignment of text + RIGHT //!< Right justified alignment of text + }; + + //! Thanks to the standard formerly known as PHIGS. Vertical text + //! justification constants. + enum OGLFT_API VerticalJustification { + BOTTOM, //!< Descender alignment of text + BASELINE, //!< Baseline alignment of text (default) + MIDDLE, //!< Centered alignment of text + TOP //!< Ascender justification of text + }; + + //! Control how OpenGL display lists are created for individual glyphs. + //! The default mode is to create display lists for each glyph as it + //! is requested. Therefore, the Face drawing routines cannot themselves + //! be called from within an open display list. In IMMEDIATE mode, + //! cached glyphs will be drawn if available, otherwise the FreeType + //! data for a glyph is re-rendered each time. + enum OGLFT_API GlyphCompileMode { + COMPILE, //!< Compile new glyphs when seen for the first time. + IMMEDIATE //!< Do not \em create display lists for glyphs. + }; + + private: + //! We allow a Face to be constructed either from a file name + //! or passed in as an already opened FreeType FT_Face. In the case + //! of the later (already opened), we don't close the FT_Face on + //! destruction. This way you can share FT_Faces between related + //! OGLFT faces. Also, we're experimenting with being able to use + //! multiple FT_Faces in a single OGLFT Face, so this is represented + //! as a data structure. + struct FaceData { + FT_Face face_; + bool free_on_exit_; + FaceData ( FT_Face face, bool free_on_exit = true ) + : face_( face ), free_on_exit_( free_on_exit ) + {} + }; + protected: + //! The FreeType face - experimentally, this is now an array of + //! faces so that we can handle a wider range of UNICODE points + //! in case a face doesn't cover the points of interest. + std::vector< FaceData > faces_; + + //! Did a font load OK? + bool valid_; + + //! Glyph display list creation mode. + enum GlyphCompileMode compile_mode_; + + //! Nominal point size. + float point_size_; + + //! Display resolution in pixels per inch. + FT_UInt resolution_; + + //! Does rendering text affect the MODELVIEW matrix? + bool advance_; + + //! Foreground color (I really wanted to avoid this, but not really + //! possible without state queries, which you can't put into + //! display lists. Anyway, you'll be able to get even more fancy + //! by passing in a function to map the color with, so why balk at + //! this?) + GLfloat foreground_color_[4]; + + //! Background color (what modes would use this?) + GLfloat background_color_[4]; + + //! PHIGS-like horizontal positioning of text. + enum HorizontalJustification horizontal_justification_; + + //! PHIGS-like vertical positioning of text. + enum VerticalJustification vertical_justification_; + + //! Rotate an entire string in the Z plane + GLfloat string_rotation_; + + //! Let the user decide which character to use as the rotation reference. + //! Use "o" by default, I suppose. + FT_UInt rotation_reference_glyph_; + + //! The rotation reference character could be in any face. + FT_Face rotation_reference_face_; + + //! These are the translation offsets provided by the rotation reference + //! character; for whom, we've discovered, only the Y position is relevant. + GLfloat rotation_offset_y_; + + //! Type of the cache of defined glyph to display list mapping. + typedef std::map< FT_UInt, GLuint > GlyphDLists; + + //! A convenience definition of the iterator over the glyph to display + //! list map. + typedef GlyphDLists::const_iterator GDLCI; + + //! A convenience definition of the iterator over the glyph to display + //! list map. + typedef GlyphDLists::iterator GDLI; + + //! Cache of defined glyph display lists + GlyphDLists glyph_dlists_; + + //! The user can supply an array of display list which are invoked + //! before each glyph is rendered. + DisplayLists character_display_lists_; + + public: + /*! + * Construct a Face by loading a font from the given file. + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Construct a Face by loading a font from the given memory location. + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Alternatively, the user may have already opened a face and just + * wants to draw with it. This is useful for Multiple Master fonts or + * combining multiple files to increase UNICODE point coverage. + * \param face open Freetype FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Deleting a Face frees its FreeType face (and anything else it's + * styles have allocated). + */ + virtual ~Face ( void ); + + /*! + * Let the user test to see if the font was loaded OK. + * \return true if the FT_Face was successfully created. + */ + bool isValid ( void ) const { return valid_; } + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes a filename and takes ownership of the FT_Face. + * \param filename name of file containing font face data. + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( const char* filename ); + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes a memory location and takes ownership of the FT_Face. + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( const FT_Byte* data_base, const FT_Long data_size ); + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes an already open FT_Face. The user is responsible + * for clean up. + * \param face open FreeType FT_Face + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( FT_Face face ); + + /*! + * By default, each time a new character is seen, its glyph is rendered + * into a display list. This means that a display list cannot already + * be open (since OpenGL doesn't allow nested display list creation). + * Rendering can be set into immediate mode in which case glyphs are + * rendered from display lists if available, but are otherwise generated + * anew each time. + * \param compile_mode the new compile mode. + */ + void setCompileMode ( enum GlyphCompileMode compile_mode ) + { + compile_mode_ = compile_mode; + } + + /*! + * \return the current glyph compile mode. + */ + enum GlyphCompileMode compileMode ( void ) const { return compile_mode_; } + + /*! + * For the rasterized styles (Monochrome, Grayscale, Translucent, Texture), + * glyphs are rendered at the pixel size given by: + * + * point_size [pts] * / 72 [pts/in] * resolution [dots/in] = [dots]. + * + * For the polygon styles (Outline, Filled, Solid), the "nominal" size of + * the glyphs is: + * + * point_size[pts] / 72 [pts/in] * resolution [dots/in] + * / units_per_EM [font unit/EM] = [dots * EM]. + * + * If the MODELVIEW and PROJECTION matrices are such that one screen pixel + * corresponds to one modeling unit, then polygonal Faces will + * be the same size as raster Faces. + * + * Note that changing the point size after Face creation will invalidate + * the cache of OpenGL display lists and any other information which + * the individual styles have cached. + * \param point_size the new point size in points (1/72-th inch). + */ + void setPointSize ( float point_size ); + + /*! + * \return the current point size. + */ + float pointSize ( void ) { return point_size_; } + + /*! + * For the rasterized styles (Monochrome, Grayscale, + * Translucent, Texture), the exact rendered size of the glyphs depends on + * the resolution of the display (as opposed to the polygon styles + * whose size is controlled by the viewing matrices). The Texture + * style is slightly different because the glyphs are texture-mapped + * onto an arbitrary rectangle; here, the resolution only controls + * how accurately the glyph is rendered. + * \param resolution the resolution in DPI (dots per inch). + */ + void setResolution ( FT_UInt resolution ); + + /*! + * \return the current raster resolution. + */ + FT_UInt resolution ( void ) { return resolution_; } + + /*! + * If advance is true, then the changes made to the MODELVIEW matrix + * to render a string are allowed to remain. Otherwise, the library + * pushes the current MODELVIEW matrix onto the matrix stack, renders + * the string and then pops it off again. Rendering a character always + * modifies the MODELVIEW matrix. + * \param advance whether or not the MODELVIEW matrix should be left + * translated by the advancement of a rendered string. + */ + void setAdvance ( bool advance ) { advance_ = advance; } + + /*! + * \return the advance value. + */ + bool advance ( void ) const { return advance_; } + + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param red the red component of the foreground color. + * \param green the green component of the foreground color. + * \param blue the blue component of the foreground color. + * \param alpha the alpha component of the foreground color. + */ + void setForegroundColor ( GLfloat red = 0.0, + GLfloat green = 0.0, + GLfloat blue = 0.0, + GLfloat alpha = 1.0 ); + + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param foreground_color an array of 4 values corresponding to the + * red, green, blue and alpha components of the foreground color. + */ + void setForegroundColor ( const GLfloat foreground_color[4] ); +#ifndef OGLFT_NO_QT + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param foreground_color the foreground color as an unsigned int. + */ + void setForegroundColor ( const QRgb foreground_color ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the red component of the foreground color + */ + GLfloat foregroundRed ( void ) const { return foreground_color_[R]; } + /*! + * \return the green component of the foreground color + */ + GLfloat foregroundGreen ( void ) const { return foreground_color_[G]; } + /*! + * \return the blue component of the foreground color + */ + GLfloat foregroundBlue ( void ) const { return foreground_color_[B]; } + /*! + * \return the alpha component of the foreground color + */ + GLfloat foregroundAlpha ( void ) const { return foreground_color_[A]; } + + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param red the red component of the background color. + * \param green the green component of the background color. + * \param blue the blue component of the background color. + * \param alpha the alpha component of the background color. + */ + void setBackgroundColor ( GLfloat red = 1.0, + GLfloat green = 1.0, + GLfloat blue = 1.0, + GLfloat alpha = 0.0 ); + + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param background_color an array of 4 values corresponding to the + * red, green, blue and alpha components of the background color. + */ + void setBackgroundColor ( const GLfloat background_color[4] ); +#ifndef OGLFT_NO_QT + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param background_color the background color as an unsigned int. + */ + void setBackgroundColor ( const QRgb background_color ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the red component of the background color + */ + GLfloat backgroundRed ( void ) const { return background_color_[R]; } + /*! + * \return the green component of the background color + */ + GLfloat backgroundGreen ( void ) const { return background_color_[G]; } + /*! + * \return the blue component of the background color + */ + GLfloat backgroundBlue ( void ) const { return background_color_[B]; } + /*! + * \return the alpha component of the background color + */ + GLfloat backgroundAlpha ( void ) const { return background_color_[A]; } + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of z rotation. + */ + virtual void setCharacterRotationZ ( GLfloat character_rotation_z ) = 0; + + /*! + * \return the character rotation in the Z direction. + */ + virtual GLfloat characterRotationZ ( void ) const = 0; + + /*! + * The z rotation angle needs a center. Nominate a character whose + * center is to be the center of rotation. By default, use "o". + * \param c rotation reference character. + */ + void setCharacterRotationReference ( unsigned char c ); + + /*! + * Rotate an entire string through the given angle (in the Z plane only). + * (Somewhat pointless for the vector styles since you can do mostly + * the same thing with the MODELVIEW transform, however, for what its + * worth, this routine uses the FreeType rotation function to compute + * the "proper" metrics for glyph advance.) + * \param string_rotation angle in degrees of z rotation. + */ + void setStringRotation ( GLfloat string_rotation ); + + /*! + * \return the (Z plane) string rotation angle. + */ + GLfloat stringRotation ( void ) const { return string_rotation_; } + + /*! + * Set the horizontal justification. + * \param horizontal_justification the new horizontal justification. + */ + void setHorizontalJustification ( enum HorizontalJustification + horizontal_justification ) + { + horizontal_justification_ = horizontal_justification; + } + + /*! + * \return the horizontal justification. + */ + enum HorizontalJustification horizontalJustification ( void ) const + { return horizontal_justification_; } + + /*! + * Set the vertical justification. + * \param vertical_justification the new vertical justification + */ + void setVerticalJustification ( enum VerticalJustification + vertical_justification ) + { + vertical_justification_ = vertical_justification; + } + + /*! + * \return the vertical justification. + */ + enum VerticalJustification verticaljustification ( void ) + const { return vertical_justification_; } + + /*! + * Specify an OpenGL display list to be invoked before + * each character in a string. Face makes a copy of the argument. Pass + * an empty DisplayLists to disable this feature. + * \param character_display_lists STL vector containing a display + * list to invoke before each glyph in a string is drawn. + */ + void setCharacterDisplayLists ( const DisplayLists& character_display_lists ) + { + character_display_lists_ = character_display_lists; + } + + /*! + * \return a reference to the array of character display lists. This is + * the live list as stored in the Face. + */ + DisplayLists& characterDisplayLists ( void ) + { return character_display_lists_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + virtual double height ( void ) const = 0; + + /*! + * Compute the bounding box info for a character. + * \param c the (latin1) character to measure. + * \return the bounding box of c. + */ + virtual BBox measure ( unsigned char c ) = 0; +#ifndef OGLFT_NO_QT + /*! + * Compute the bounding box info for a character. + * \param c the (UNICODE) character to measure. + * \return the bounding box of c. + */ + virtual BBox measure ( const QChar c ) = 0; +#endif /* OGLFT_NO_QT */ + /*! + * Compute the bounding box info for a string. + * \param s the (latin1) string to measure. + * \return the bounding box of s. + */ + virtual BBox measure ( const char* s ); + /*! + * Compute the bounding box info for a string without conversion + * to modeling coordinates. + * \param s the (latin1) string to measure. + * \return the bounding box of s. + */ + virtual BBox measureRaw ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Compute the bounding box info for a string. + * \param s the (UNICODE) string to measure. + * \return the bounding box of s. + */ + virtual BBox measure ( const QString& s ); + /*! + * Compute the bounding box info for a real number formatted as specified. + * \param format (see draw for valid formats) + * \param number real number. + * \return the bounding box of the formatted number. + */ + virtual BBox measure ( const QString& format, double number ); + /*! + * Compute the bounding box info for a string without conversion + * to modeling coordinates. + * \param s the (UNICODE) string to measure. + * \return the bounding box of s. + */ + virtual BBox measureRaw ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Compile a string into an OpenGL display list for later + * rendering. Essentially, the string is rendered at the origin + * of the current MODELVIEW. Note: no other display lists should + * be open when this routine is called. Also, the Face does not + * keep track of these lists, so you must delete them in order + * to recover the memory. + * \param s the (latin1) string to compile. + * \return the display list name for the string. + */ + GLuint compile ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Compile a string into an OpenGL display list for later + * rendering. Essentially, the string is rendered at the origin + * of the current MODELVIEW. Note: no other display lists should + * be open when this routine is called. Also, the Face does not + * keep track of these lists, so you must delete them in order + * to recover the memory. + * \param s the (UNICODE) string to compile. + * \return the display list name for the string. + */ + GLuint compile ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Compile a single character (glyph) into an OpenGL display list + * for later rendering. The Face \em does keep track of these + * display lists, so do not delete them. + * \param c the (latin1) character to compile. + * \return the display list name for the character. + */ + GLuint compile ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Compile a single character (glyph) into an OpenGL display list + * for later rendering. The Face \em does keep track of these + * display lists, so do not delete them. + * \param c the (UNICODE) character to compile. + * \return the display list name for the character. + */ + GLuint compile ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw a (latin1) string using the current MODELVIEW matrix. If + * advance is true, then the final glyph advance changes to the + * MODELVIEW matrix are left in place. + * \param s the (latin1) string to draw. + */ + void draw ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Draw a (UNICODE) string using the current MODELVIEW + * matrix. If advance is true, then the final glyph advance + * changes to the MODELVIEW matrix are left in place. + * \param s the (UNICODE) string to draw. + */ + void draw ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw the character using the current MODELVIEW matrix. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw a + * string if you don't want the MODELVIEW matrix changed. + * \param c the (latin1) character to draw. + */ + void draw ( unsigned char c ); + +#ifndef OGLFT_NO_QT + /*! + * Draw the character using the current MODELVIEW matrix. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw a + * string if you don't want the MODELVIEW matrix changed. + * \param c the (UNICODE) character to draw. + */ + void draw ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw the (latin1) character at the given 2D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param c the (latin1) character to draw. + */ + void draw ( GLfloat x, GLfloat y, unsigned char c ); + /*! + * Draw the (latin1) character at the given 3D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param c the (latin1) character to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Draw the (UNICODE) character at the given 2D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param c the (UNICODE) character to draw. + */ + void draw ( GLfloat x, GLfloat y, QChar c ); + /*! + * Draw the (UNICODE) character at the given 3D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param c the (UNICODE) character to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw a string at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param s the (latin1) string to draw. + */ + void draw ( GLfloat x, GLfloat y, const char* s ); + /*! + * Draw a string at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param s the (latin1) string to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Draw a string at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param s the (UNICODE) string to draw. + */ + void draw ( GLfloat x, GLfloat y, const QString& s ); + /*! + * Draw a string at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param s the (UNICODE) string to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const QString& s ); + /*! + * Draw a real number per the given format at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param format Like a typical printf format. Regular text is printed + * while a '%' introduces the real number's format. Includes the + * following format flags: + * \li %%x.yf - floating point in field width x and precision y + * \li %%x.ye - scientific notation in field width x and precision y + * \li %%x.yg - pick best floating or scientific in field width x and + * precision y + * \li %%p - draw as a proper fraction, e.g. 1 1/2. Note: this currently + * requires a special font which encodes glyphs to be drawn for the + * numerator and demoninator in the UNICODE Private Area (0xE000). + * + * \param number the numeric value. + */ + void draw ( GLfloat x, GLfloat y, const QString& format, double number ); + /*! + * Draw a real number per the given format at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param format Like a typical printf format. Regular text is printed + * while a '%' introduces the real number's format. Includes the + * following format flags: + * \li %%x.yf - floating point in field width x and precision y + * \li %%x.ye - scientific notation in field width x and precision y + * \li %%x.yg - pick best floating or scientific in field width x and + * precision y + * \li %%p - draw as a proper fraction, e.g. 1 1/2. Note: this currently + * requires a special font which encodes glyphs to be drawn for the + * numerator and demoninator in the UNICODE Private Area (0xE000). + * + * \param number the numeric value. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const QString& format, + double number ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the face ascender, in point units. + */ + int ascender ( void ); + + /*! + * \return the face descender, in point units. + */ + int descender ( void ); + + protected: + // The various styles override these routines + + //! Some styles, in particular the Texture, need specialized steps + //! to compile a glyph into an OpenGL display list. + //! \param face the FT_Face containing the glyph. + //! \param glyph_index the index of the glyph in face. + //! \return the display list of the compiled glyph. + virtual GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ) = 0; + + //! Each style implements its own glyph rendering routine. + //! \param face the FT_Face containing the glyph. + //! \param glyph_index the index of the glyph in face. + virtual void renderGlyph ( FT_Face face, FT_UInt glyph_index ) = 0; + + //! There is a slight different between the way in which the polygonal + //! and raster styles select the character size for FreeType to generate. + virtual void setCharSize ( void ) = 0; + + //! The different styles have different caching needs (well, really only + //! the texture style currently has more than the display list cache). + virtual void clearCaches ( void ) = 0; + + //! The polygonal and raster styles compute different values for the + //! Z rotation offset. (It's in integer pixels for the raster styles and + //! in floating point pixels for the polygonal styles.) + virtual void setRotationOffset ( void ) = 0; + + private: + void init ( void ); + BBox measure_nominal ( const char* s ); +#ifndef OGLFT_NO_QT + BBox measure_nominal ( const QString& s ); + QString format_number ( const QString& format, double number ); +#endif /* OGLFT_NO_QT */ + }; + + //! This is the base class of the polygonal styles: outline, filled and solid. + /*! + * In the polygonal styles, the detailed geometric outlines of the glyphs + * are extracted from the font file and rendered as polygons. + */ + class Polygonal : public Face { + protected: + //! Angle of rotation of characters relative to text orientation. + struct { + bool active_; + GLfloat x_, y_, z_; + } character_rotation_; + + //! The tessellation of curves is pretty crude; regardless of length, + //! use the same number of increments (and as near as I can tell, this + //! is more than sufficient unless the glyph takes up the whole screen). + unsigned int tessellation_steps_; + + //! When curves are tessellated, we use the forward difference algorithm + //! from Foley and van Dam for parametric curves (pg. 511 of 2nd Ed. in C). + //! So, the step size, delta, is in the parametric variable which is always + //! on the interval [0,1]. Therefore, delta = 1/tessellation_steps + double delta_, delta2_, delta3_; + + //! For vector rendition modes, FreeType is allowed to generate the + //! lines and arcs at the original face definition resolution. To + //! get to the proper glyph size, the vertices are scaled before + //! they're passed to the GLU tessellation routines. + float vector_scale_; + + //! Callbacks for FreeType glyph decomposition into outlines + FT_Outline_Funcs interface_; + + //! Default number of steps to break TrueType and Type1 arcs into. + //! (Note: this looks good to me, anyway) + static const unsigned int DEFAULT_TESSELLATION_STEPS = 4; + + /*! + * VertexInfo is a private class which is used by the decomposition and + * tessellation routines to store the vertices and other data of the glyph's + * outline. Because of the "impedance mismatch" between the crazy + * 26.6 fixed point format of the FreeType library (well, don't + * blame them; look at what they have to work with) and OpenGL's preference + * for double precision, this simple vector has two constructors: one + * for 26.6 format and one for direct floating point. + * + * VertexInfo also contains (optional) pointers to objects which + * implement the ColorTess and TextureTess interfaces. + */ + struct VertexInfo { + double v_[3]; //!< Why is this double precision? Because the second + //!< argument to the routine gluTessVertex is a pointer + //!< to an array of doubles. Otherwise, we could use + //!< single precision everywhere. + + //! The user can provide a ColorTess object which computes a color + //! for each tesselated vertex. + ColorTess* color_tess_; + + //! The user can provide a TextureTess object which computes texture + //! coordinates for each tesselated vertex. + TextureTess* texture_tess_; + + //! Default constructor just initializes Vertex to zero. + //! \param color_tess optional color tesselation object. + //! \param texture_tess optional texture tesselation object. + VertexInfo ( ColorTess* color_tess = 0, TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = v_[Y] = v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a point in a FreeType contour. + * \param ft_v a FreeType FT_Vector, normally passed into the + * the decomposition callbacks. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( FT_Vector* ft_v, ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = (double)( ft_v->x / 64 ) + (double)( ft_v->x % 64 ) / 64.; + v_[Y] = (double)( ft_v->y / 64 ) + (double)( ft_v->y % 64 ) / 64.; + v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a 2D point. + * \param p 2D array of doubles. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( double p[2], ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = p[X]; + v_[Y] = p[Y]; + v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a 2D point. + * \param x the X coordinate. + * \param y the Y coordinate. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( double x, double y, ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = x; + v_[Y] = y; + v_[Z] = 0.; + } + + //! Treat the Vertex like a vector: Normalize its length in the + //! usual way. + void normalize ( void ) + { + double length = sqrt( v_[X] * v_[X] + v_[Y] * v_[Y] + v_[Z] * v_[Z] ); + v_[X] /= length; + v_[Y] /= length; + v_[Z] /= length; + } + }; + + /*! + * Buffers the last control point as the outline of a glyph is + * decomposed. + */ + VertexInfo last_vertex_; + + //! Normally, we will consider a list of vertices. + typedef std::list< VertexInfo* > VertexInfoList; + + //! A convenience definition of the iterator over the list of vertices. + typedef VertexInfoList::const_iterator VILCI; + + //! A convenience definition of the iterator over the list of vertices. + typedef VertexInfoList::iterator VILI; + + /*! + * As curves are decomposed out of the glyph, their vertices are passed + * along to the GLU tessellation functions. These vertices have to + * hang around until gluTessContourEnd is called. + */ + VertexInfoList vertices_; + + //! As GLU tessellation proceeds, new contours open with every call + //! to moveTo. + bool contour_open_; + + //! The user can provide a ColorTess object which computes a color + //! for each tesselated vertex. + ColorTess* color_tess_; + + //! The user can provide a TextureTess object which computes texture + //! coordinates for each tesselated vertex. + TextureTess* texture_tess_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100); + + /*! + * \param face open Freetype FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The Polygonal destructor doesn't do anything in particular. + */ + OGLFT_API virtual ~Polygonal ( void ); + + /*! + * TrueType and Type1 files describe the boundaries of glyphs with + * quadratic and cubic curves, respectively. Since OpenGL can only really + * draw straight lines, these curves have to be tessellated. The + * number of steps used is fixed for all glyphs in the face, + * but can be changed through this method. Other notes: This value is + * only applicable for Outline, Filled and Solid styles. Changing this value + * invalidates any cached display lists for glyphs in this face. + * + * \param tessellation_steps the number of steps to tessellate each curved + * segment of a glyph outline. + */ + OGLFT_API void setTessellationSteps ( unsigned int tessellation_steps ); + + /*! + * \return the number of steps used to tessellate curves in the + * polygonal font types. + */ + OGLFT_API unsigned int tessellationSteps ( void ) const { return tessellation_steps_; } + + /*! + * Set the individual character rotation in the X direction. + * \param character_rotation_x angle in degrees of the X rotation. + */ + OGLFT_API void setCharacterRotationX ( GLfloat character_rotation_x ); + + /*! + * Set the individual character rotation in the Y direction. + * \param character_rotation_y angle in degrees of the Y rotation. + */ + OGLFT_API void setCharacterRotationY ( GLfloat character_rotation_y ); + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of the Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + + /*! + * \return the character rotation in the X direction. + */ + OGLFT_API GLfloat characterRotationX ( void ) const { return character_rotation_.x_; } + + /*! + * \return the character rotation in the Y direction. + */ + OGLFT_API GLfloat characterRotationY ( void ) const { return character_rotation_.y_; } + + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_.z_; } + + /*! + * Set an optional color tesselation object. Each tesselated vertex + * is passed to this object, which returns a color for that position + * in space. + * \param color_tess the color tesselation object. + */ + OGLFT_API void setColorTess ( ColorTess* color_tess ); + /*! + * \return the color tesselation object. + */ + OGLFT_API ColorTess* colorTess ( void ) const { return color_tess_; } + /*! + * Set an optional texture coordinate tesselation object. Each + * tessellated vertex is passed to this object, which returns + * texture coordinates for that position in space. + * \param texture_tess the texture coordinate tesselation object. + */ + OGLFT_API void setTextureTess ( TextureTess* texture_tess ); + /*! + * \return the texture coordinate tesselation object. + */ + OGLFT_API TextureTess* textureTess ( void ) const { return texture_tess_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a polygonal face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a polygonal face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ) + { return Face::measure( format, number ); } +#endif /* OGLFT_NO_QT */ + + private: + void init ( void ); + void setCharSize ( void ); + void setRotationOffset ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + protected: + void clearCaches ( void ); + }; + + //! Render text as a polygon outline. + /*! + * \image html outline_class.png + * Text is drawn as an outline of each glyph. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to a given size. Usually the outline is drawn in the foreground + * color, however, you can specify a ColorTess object to provide a color + * for each vertex individually. You can also use + * the per-glyph display list functionality to alter the attributes + * of each glyph. + * + * The only complexity to this style is selecting the point size. Since + * the outlines are drawn as a polygon, they are subject to the MODELVIEW + * transformation. The point size is nominally chosen to be the same as a + * raster image generated at the given resolution. Some experimentation + * with point size and resolution may be necessary to achieve the desired + * results. + */ + class Outline : public Polygonal { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + ~Outline ( void ); + private: + void init ( void ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + static int moveToCallback ( FT_Vector* to, Outline* outline ); + static int lineToCallback ( FT_Vector* to, Outline* outline ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Outline* outline ); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Outline* outline ); + }; + + //! Render text as a filled polygons. + /*! + * \image html filled_class.png + * Each glyph is drawn as a filled polygon. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to the given size. Then the GLU tessellation routines are used + * to tessellate the contours into polygons (well, triangles). By default, + * these are drawn in GL_FILL polygon mode, but any other polygon mode + * can be specified. + * + * Usually, the polygons are drawn only in the + * foreground color, however, you may supply ColorTess and TextureTess + * objects which can alter the color or texture coordinates of each + * vertex individually. You can also use + * the per-glyph display list functionality to alter the attributes + * of each glyph. + * + * The only complexity to this style is selecting the point size. Since + * the glyphs are drawn as polygons, they are subject to the viewing and + * modeling transformations. The point size is nominally chosen to be the same + * as a raster image generated at the given resolution. Some experimentation + * with point size and resolution may be necessary to achieve the desired + * results. + */ + class Filled : public Polygonal { + //! 3D tessellation of glyphs is accomplished through the standard GLU + //! routines + GLUtesselator* tess_obj_; + + //! A place to store any extra vertices generated by the Combine callback + VertexInfoList extra_vertices_; + + protected: + //! Offset the glyph in the Z direction. Solely for the Solid subclass. + //! Until I can figure out how to shift the glyph outside the context + //! of this class, I guess this has got to stay (but it is redundant + //! to extrusion_.depth_) + GLfloat depth_offset_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor deletes the GLU tessellation object allocated in + * in the constructor. + */ + OGLFT_API virtual ~Filled ( void ); + + /*! + * \return the list of extra vertices created by the GLU tessellation + * combine callback. + */ + OGLFT_API VertexInfoList& extraVertices ( void ) { return extra_vertices_; } + + protected: + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + private: + void init ( void ); + static int moveToCallback ( FT_Vector* to, Filled* filled ); + static int lineToCallback ( FT_Vector* to, Filled* filled ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Filled* filled); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Filled* filled ); + static void vertexCallback ( VertexInfo* vertex ); + static void beginCallback ( GLenum which ); + static void endCallback ( void ); + static void combineCallback ( GLdouble coords[3], void* vertex_data[4], + GLfloat weight[4], void** out_data, + Filled* filled ); + static void errorCallback ( GLenum error_code ); + }; + +#ifndef OGLFT_NO_SOLID + //! Render text as solid letters. + /*! + * \image html solid_class.png + * Each glyph is drawn as a closed solid. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to the given size. The contours are passed to the GLE + * tubing and extrusion library to create the sides of the solid. + * Then the GLU tessellation routines are used + * to tessellate the contours into polygons which are used to cap the sides. + * + * Currently, the solids are drawn only in the foreground color. However, + * proper surface normals are computed so that the solids may be lighted. + * Eventually, you'll be able to supply a color/texture + * coordinate function to make glyphs more interesting. Note that you can use + * the per-glyph display list functionality to alter each glyph individually. + * + * Another TODO item is to improve the interaction with GLE. Currently, + * you can only create block solids. Eventually, we'll have the capability + * add bevels and rounds to the edges of the solids and maybe even more + * general extrusions (like, for example, the swooshing letters in the title + * sequence of the Salkind's 1978 "Superman" movie). + * + * The only complexity to this style is selecting the point size. Since + * the glyphs are drawn as a collection of polygons, they are subject to the + * viewing and modeling transformations. The point size is nominally chosen + * to be the same as a raster image generated at the given resolution. + * Some experimentation with point size and resolution may be necessary to + * achieve the desired results. + */ + class Solid : public Filled { + private: + + //! Callbacks for FreeType glyph decomposition into outlines (note: this + //! has the same name as the variable in Polygonal, but it is distinct since + //! the routines for the GLE contouring are different from the Filled + //! GLU tessellation routines. This may be too confusing?) + FT_Outline_Funcs interface_; + + //! For now, you can only get block extruded solids + static const unsigned int N_POLYLINE_PTS = 4; + + //! Data for the gleExtrusion routine + struct glePoint2D { + double p_[2]; + glePoint2D ( double p[2] ) { p_[X] = p[X]; p_[Y] = p[Y]; } + glePoint2D ( double x, double y ) { p_[X] = x; p_[Y] = y; } + glePoint2D ( const VertexInfo& v ) { p_[X] = v.v_[X]; p_[Y] = v.v_[Y]; } + }; + + //! Collect all the output from GLE in one of these structures. + struct { + double depth_; + struct { + int x_, y_; + } normal_sign_; + std::vector< glePoint2D > contour_; + std::vector< glePoint2D > contour_normals_; + gleDouble up_[3]; + int n_polyline_pts_; + gleDouble point_array_[N_POLYLINE_PTS][3]; + } extrusion_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Solid ( void ); + /*! + * Set the thickness of the solid + * \param depth thickness of the solid in model units. + */ + OGLFT_API void setDepth ( double depth ); + + /*! + * \return the solid extrusion depth. + */ + OGLFT_API double depth ( void ) const { return extrusion_.depth_; } + + private: + // It would be nice if C/C++ had real matrix notation (like Perl!) + void assign ( gleDouble a[3], double x, double y, double z ) + { + a[X] = x; + a[Y] = y; + a[Z] = z; + } + + void init ( void ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + static int moveToCallback ( FT_Vector* to, Solid* solid ); + static int lineToCallback ( FT_Vector* to, Solid* solid ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Solid* solid ); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Solid* solid ); + }; +#endif /* OGLFT_NO_SOLID */ + //! This is the base class of the raster styles: bitmap, grayscale and + //! translucent. + /*! + * In the raster styles, FreeType's rasterizer is used to generate raster + * images of each glyph. + */ + class Raster : public Face { + protected: + //! Raster glyph can be rotated in the Z plane (in addition to the string + //! rotation). + GLfloat character_rotation_z_; + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API virtual ~Raster ( void ); + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_z_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a raster face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a raster face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ); +#endif /* OGLFT_NO_QT */ + + private: + void init ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + void setCharSize ( void ); + void setRotationOffset ( void ); + void clearCaches ( void ); + }; + + //! Render text as a monochrome raster image. + /*! + * \image html monochrome_class.png + * This is more or less the standard way in which text is intended to + * be rendered in OpenGL. It uses the \c glBitmap call to draw a sequence + * of monochrome bitmaps. Since FreeType is capable of rotating glyphs + * created from faces based on vector outlines, you can rotate (in the Z plane) + * both the text string as well as the individual characters in the string. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for monochrome glyphs to be rendered properly. + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Monochrome : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param font open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Monochrome ( void ); + private: + GLubyte* invertBitmap ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as a grayscale raster image. + /*! + * \image html grayscale_class.png + * The Grayscale style is similar to the Monochrome style. FreeType is used + * to rasterize a glyph and this is then drawn on the screen using + * \c glDrawPixels. The FreeType rasterization is done in anti-aliased mode. + * When Grayscale draws the glyph image, the resulting text is blended + * smoothly from the foreground color to the background color. The background + * of the glyph is opaque, so this style works best over a solid background. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for grayscale glyphs to be rendered properly. + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Grayscale : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Grayscale ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as a translucent raster image. + /*! + * \image html translucent_class.png + * The Translucent style is similar to the Grayscale style. FreeType is used + * to rasterize a glyph and this is then drawn on the screen using + * \c glDrawPixels. The FreeType rasterization is done in anti-aliased mode. + * When Translucent draws the glyph image, the grayscale levels provided + * by FreeType are used as Alpha values in the raster image. This allows + * the glyphs to be smoothly blended into complicated backgrounds. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for translucent glyphs to be rendered properly. + * Additionally, you need to activate blending in order to achieve the + * translucent effect: + * \code + * glEnable( GL_BLEND ); + * glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + * \endcode + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Translucent : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Translucent ( void ); + + private: + GLubyte* invertPixmapWithAlpha ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! This is the base class of the texture style. + class Texture : public Face { + protected: + //! Angle of rotation of characters relative to text orientation. + struct { + bool active_; //!< Is character rotation non-zero? (faster than checking all + //!< the other values.) + GLfloat x_, //!< Angle of rotation in the X direction. + y_, //!< Angle of rotation in the Y direction. + z_; //!< Angle of rotation in the Z direction. + } character_rotation_; + + /*! + * The textured glyphs need a little bit more infrastructure to draw + * since we have to remember the size of the texture object itself + * (at least implicitly). Also, we don't want to create any more + * texture objects than we have to, so they are always cached. + */ + struct TextureInfo { + GLuint texture_name_; //!< A bound texture name is an integer in OpenGL. + FT_Int left_bearing_, //!< The left bearing of the transformed glyph. + bottom_bearing_; //!< The bottom bearing of the transformed glyph. + int width_, //!< The 2**l width of the texture. + height_; //!< The 2**m height of the texture. + GLfloat texture_s_, //!< The fraction of the texture width occupied + //!< by the glyph. + texture_t_; //!< The fraction of the texture height occupied + //!< by the glyph. + FT_Vector advance_; //!< The advance vector of the transformed glyph. + }; + + //! Type of the cache of defined glyph to texture objects mapping. + typedef std::map< FT_UInt, TextureInfo > GlyphTexObjs; + + //! A convenience definition of the iterator over the glyph to texture + //! object map. + typedef GlyphTexObjs::const_iterator GTOCI; + + //! A convenience definition of the iterator over the glyph to texture + //! object map. + typedef GlyphTexObjs::iterator GTOI; + + //! Cache of defined glyph texture objects. + GlyphTexObjs glyph_texobjs_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The texture destructor doesn't really do anything. + */ + OGLFT_API virtual ~Texture ( void ); + /*! + * Set the individual character rotation in the X direction. + * \param character_rotation_x angle in degrees of X rotation. + */ + OGLFT_API void setCharacterRotationX ( GLfloat character_rotation_x ); + + /*! + * Set the individual character rotation in the Y direction. + * \param character_rotation_y angle in degrees of Y rotation. + */ + OGLFT_API void setCharacterRotationY ( GLfloat character_rotation_y ); + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + + /*! + * \return the character rotation in the X direction. + */ + OGLFT_API GLfloat characterRotationX ( void ) const { return character_rotation_.x_; } + + /*! + * \return the character rotation in the Y direction. + */ + OGLFT_API GLfloat characterRotationY ( void ) const { return character_rotation_.y_; } + + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_.z_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a texture face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a texture face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + OGLFT_API BBox measure ( const QString& s ) + { return Face::measure( s ); } + + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ) + { return Face::measure( format, number ); } +#endif /* OGLFT_NO_QT */ + + protected: + /*! + * OpenGL texture maps have to be a power of 2 in width and height (including + * apparently 1 = 2**0 ). This function returns the next higher power of + * 2 of the argument. If the argument is already a power of 2, you just + * get that back. + * \param a width or height of an image. + * \return value of a rounded to nearest, higher power of 2. + */ + unsigned int nearestPowerCeil ( unsigned int a ); + /*! + * This is all that distinguishes the various texture styles. Each subclass + * defines this method as appropriate. Once the texture is bound, it + * is rendered the same in all cases. + * \param face FT_Face containing the glyph to render. + * \param glyph_index index of glyph in face. + */ + virtual void bindTexture ( FT_Face face, FT_UInt glyph_index ) = 0; + + private: + void init ( void ); + void setCharSize ( void ); + void setRotationOffset ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + void clearCaches ( void ); + }; + + //! Render text as texture mapped monochrome quads. + /*! + * \image html texture_monochrome_class.png + * This style is similar to the Monochrome raster style, except instead + * of using \c glBitmap to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Monochrome. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do take up more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + */ + class MonochromeTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The monochrome texture destructor doesn't really do anything. + */ + OGLFT_API ~MonochromeTexture ( void ); + private: + GLubyte* invertBitmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as texture mapped grayscale quads. + /*! + * \image html texture_grayscale_class.png + * This style is similar to the Grayscale raster style, except instead + * of using \c glDrawPixels to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Grayscale. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do consume more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + */ + class GrayscaleTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The grayscale texture destructor doesn't really do anything. + */ + OGLFT_API ~GrayscaleTexture ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as texture mapped translucent quads. + /*! + * \image html texture_translucent_class.png + * This style is similar to the Translucent raster style, except instead + * of using \c glDrawPixels to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Translucent. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do consume more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + * Additionally, you need to activate blending in order to achieve the + * translucent effect: + * \code + * glEnable( GL_BLEND ); + * glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + * \endcode + */ + class TranslucentTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The translucent texture destructor doesn't really do anything. + */ + OGLFT_API ~TranslucentTexture ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; +} // Close OGLFT namespace +#endif /* OGLFT_H */ diff --git a/engine/libraries/oglft/README b/engine/libraries/oglft/README new file mode 100644 index 0000000..6089682 --- /dev/null +++ b/engine/libraries/oglft/README @@ -0,0 +1,52 @@ +OGLFT Version 0.8 + +OGLFT is a library for drawing text in OpenGL. It usees the FreeType 2 +library to extract information from font files on your system. OGLFT +can handle any of the files which FreeType can read, both vector and +bitmapped (although currently the bitmap routines are not implemented). + +The software is available from www.sf.net/project/oglft. + +The documentation is in ./doc/html/index.html. + +The mailing list is oglft-devel@lists.sourceforge.net. + +A couple of installation notes: + +OGLFT depends on the GLE Tubing and Extrusion library to create solid +characters. If you don't have this library (or don't want solid +glyphs), you can disable this feature with: + +./configure --disable-solid + +If the configure script can't find the GLE library and header files, +it is disabled automatically. + +UNICODE character rendering, Demo3 and the performance test code +depend on the Qt library. You can disable them with: + +./configure --disable-qt + +Note that the configure script depends on finding the environment +variable QTDIR in order to locate the headers and library for Qt (if +not disabled). If the configure script can't successfully build a +simple Qt app, Qt is disabled automatically. + +'make check' builds the test programs in the tests/ directory. + +There is also a (mostly untested) Qt project file from which it may be +possible to generate a Makefile for operating systems for which +autoconf is not supported. Edit the files ./OGLFT/OGLFT.pro and +./tests/tests.pro to change the values to those appropriate for your +operating system. Generate the library and the test program by doing a +"make install" (this will actually only copy the library to the ./lib +directory). + +--------------------------------------------------------------------- +lignum Computing, Inc., July, 2002 +oglft@lignumcomputing.com + + +;;;Local variables: *** +;;;mode: text *** +;;;End: *** diff --git a/engine/libraries/oglft/liboglft/CMakeLists.txt b/engine/libraries/oglft/liboglft/CMakeLists.txt new file mode 100644 index 0000000..fb6d0ad --- /dev/null +++ b/engine/libraries/oglft/liboglft/CMakeLists.txt @@ -0,0 +1,45 @@ +CMAKE_MINIMUM_REQUIRED (VERSION 2.6) + +FIND_PACKAGE ( FreeType2 REQUIRED ) + +FILE( GLOB sources *.cpp ) +IF( DESIRED_QT_VERSION EQUAL 3) + INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ) +ELSEIF( DESIRED_QT_VERSION EQUAL 4 ) + INCLUDE_DIRECTORIES( ${QT_QTCORE_INCLUDE_DIR} ) + INCLUDE_DIRECTORIES( ${QT_QTGUI_INCLUDE_DIR} ) +ENDIF( DESIRED_QT_VERSION EQUAL 3) + +INCLUDE_DIRECTORIES( + ${FREETYPE2_INCLUDE_DIR} + ) +INCLUDE_DIRECTORIES( ${PROJECT_BINARY_DIR} ) +CONFIGURE_FILE( + "${CMAKE_CURRENT_SOURCE_DIR}/OGLFT.h.cmake" + "${PROJECT_BINARY_DIR}/OGLFT.h" +) + +IF( WIN32 ) + ADD_DEFINITIONS( -DOGLFT_BUILD ) +ENDIF( WIN32 ) + +ADD_LIBRARY( oglft STATIC ${sources} ) +TARGET_LINK_LIBRARIES( + oglft + ${FREETYPE2_LIBRARIES} + ${OPENGL_LIBRARIES} + ) + +INSTALL( + TARGETS oglft + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib + COMPONENT libraries +) + +INSTALL( + FILES "${PROJECT_BINARY_DIR}/OGLFT.h" + DESTINATION include/OGLFT + PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ + COMPONENT headers +) diff --git a/engine/libraries/oglft/liboglft/OGLFT.cpp b/engine/libraries/oglft/liboglft/OGLFT.cpp new file mode 100644 index 0000000..db61802 --- /dev/null +++ b/engine/libraries/oglft/liboglft/OGLFT.cpp @@ -0,0 +1,3816 @@ +/* + * OGLFT: A library for drawing text with OpenGL using the FreeType library + * Copyright (C) 2002 lignum Computing, Inc. + * Copyright (C) 2008 Allen Barnett + * $Id:$ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include + +#include "OGLFT.h" + +#ifndef OGLFT_NO_QT +#include +#endif + +namespace OGLFT { + + // This is the static instance of the FreeType library wrapper ... + + Library Library::library; + + // ... and this is the FreeType library handle itself. + + FT_Library Library::library_; + + // The static instance above causes this constructor to be called + // when the object module is loaded. + + Library::Library ( void ) + { + + FT_Error error = FT_Init_FreeType( &library_ ); + + if ( error != 0 ) { + std::cerr << "Could not initialize the FreeType library. Exiting." << std::endl; + exit( 1 ); + } + } + + Library::~Library ( void ) + { + FT_Error error = FT_Done_FreeType( library_ ); + + if ( error != 0 ) { + std::cerr << "Could not terminate the FreeType library." << std::endl; + } + } + + // Return the only instance in the process + + FT_Library& Library::instance ( void ) + { + return library_; + } + + // Load a new face from file + + Face::Face ( const char* filename, float point_size, FT_UInt resolution ) + : point_size_( point_size ), resolution_( resolution ) + { + valid_ = true; // Assume the best :-) + + FT_Face ft_face; + + FT_Error error = FT_New_Face( Library::instance(), filename, 0, &ft_face ); + + if ( error != 0 ) { + valid_ = false; + return; + } + + // As of FreeType 2.1: only a UNICODE charmap is automatically activated. + // If no charmap is activated automatically, just use the first one. + if ( ft_face->charmap == 0 && ft_face->num_charmaps > 0 ) + FT_Select_Charmap( ft_face, ft_face->charmaps[0]->encoding ); + + faces_.push_back( FaceData( ft_face ) ); + + init(); + } + + // Load a new face from memory + + Face::Face ( const FT_Byte* data_base, const FT_Long data_size, float point_size, FT_UInt resolution ) + : point_size_( point_size ), resolution_( resolution ) + { + valid_ = true; // Assume the best :-) + + FT_Face ft_face; + + FT_Error error = FT_New_Memory_Face( Library::instance(), data_base, data_size, 0, &ft_face ); + + if ( error != 0 ) { + valid_ = false; + return; + } + + // As of FreeType 2.1: only a UNICODE charmap is automatically activated. + // If no charmap is activated automatically, just use the first one. + if ( ft_face->charmap == 0 && ft_face->num_charmaps > 0 ) + FT_Select_Charmap( ft_face, ft_face->charmaps[0]->encoding ); + + faces_.push_back( FaceData( ft_face ) ); + + init(); + } + + // Go with a face that the user has already opened. + + Face::Face ( FT_Face face, float point_size, FT_UInt resolution ) + : point_size_( point_size ), resolution_( resolution ) + { + valid_ = true; + + // As of FreeType 2.1: only a UNICODE charmap is automatically activated. + // If no charmap is activated automatically, just use the first one. + if ( face->charmap == 0 && face->num_charmaps > 0 ) + FT_Select_Charmap( face, face->charmaps[0]->encoding ); + + faces_.push_back( FaceData( face, false ) ); + + init(); + } + + // Standard initialization behavior once the font file is opened. + + void Face::init ( void ) + { + // By default, each glyph is compiled into a display list the first + // time it is encountered + + compile_mode_ = COMPILE; + + // By default, all drawing is wrapped with push/pop matrix so that the + // MODELVIEW matrix is not modified. If advance_ is set, then subsequent + // drawings follow from the advance of the last glyph rendered. + + advance_ = false; + + // Initialize the default colors + + foreground_color_[R] = 0.; + foreground_color_[G] = 0.; + foreground_color_[B] = 0.; + foreground_color_[A] = 1.; + + background_color_[R] = 1.; + background_color_[G] = 1.; + background_color_[B] = 1.; + background_color_[A] = 0.; + + // The default positioning of the text is at the origin of the first glyph + horizontal_justification_ = ORIGIN; + vertical_justification_ = BASELINE; + + // By default, strings are rendered in their nominal direction + string_rotation_ = 0; + + // setCharacterRotationReference calls the virtual function clearCaches() + // so it is up to a subclass to set the real default + rotation_reference_glyph_ = 0; + rotation_reference_face_ = 0; + rotation_offset_y_ = 0.; + } + + Face::~Face ( void ) + { + for ( unsigned int i = 0; i < faces_.size(); i++ ) + if ( faces_[i].free_on_exit_ ) + FT_Done_Face( faces_[i].face_ ); + } + + // Add another Face to select characters from file. + + bool Face::addAuxiliaryFace ( const char* filename ) + { + FT_Face ft_face; + + FT_Error error = FT_New_Face( Library::instance(), filename, 0, &ft_face ); + + if ( error != 0 ) + return false; + + faces_.push_back( FaceData( ft_face ) ); + + setCharSize(); + + return true; + } + + // Add another Face to select characters from memory. + + bool Face::addAuxiliaryFace ( const FT_Byte* data_base, const FT_Long data_size ) + { + FT_Face ft_face; + + FT_Error error = FT_New_Memory_Face( Library::instance(), data_base, data_size, 0, &ft_face ); + + if ( error != 0 ) + return false; + + faces_.push_back( FaceData( ft_face ) ); + + setCharSize(); + + return true; + } + + // Add another Face to select characters from (face) + + bool Face::addAuxiliaryFace ( FT_Face face ) + { + faces_.push_back( FaceData( face, false ) ); + + setCharSize(); + + return true; + } + + // Note: Changing the point size also clears the display list cache + + void Face::setPointSize ( float point_size ) + { + if ( point_size != point_size_ ) { + + point_size_ = point_size; + + clearCaches(); + + setCharSize(); + } + } + + // Note: Changing the resolution also clears the display list cache + + void Face::setResolution ( FT_UInt resolution ) + { + if ( resolution != resolution_ ) { + + resolution_ = resolution; + + clearCaches(); + + setCharSize(); + } + } + + // Note: Changing the background color also clears the display list cache. + + void Face::setBackgroundColor ( GLfloat red, GLfloat green, GLfloat blue, + GLfloat alpha ) + { + if ( background_color_[R] != red || + background_color_[G] != green || + background_color_[B] != blue || + background_color_[A] != alpha ) { + + background_color_[R] = red; + background_color_[G] = green; + background_color_[B] = blue; + background_color_[A] = alpha; + + clearCaches(); + } + } + + // Note: Changing the foreground color also clears the display list cache. + + void Face::setForegroundColor ( GLfloat red, GLfloat green, GLfloat blue, + GLfloat alpha ) + { + if ( foreground_color_[R] != red || + foreground_color_[G] != green || + foreground_color_[B] != blue || + foreground_color_[A] != alpha ) { + + foreground_color_[R] = red; + foreground_color_[G] = green; + foreground_color_[B] = blue; + foreground_color_[A] = alpha; + + clearCaches(); + } + } + + // Note: Changing the foreground color also clears the display list cache. + + void Face::setForegroundColor ( const GLfloat foreground_color[4] ) + { + if ( foreground_color_[R] != foreground_color[R] || + foreground_color_[G] != foreground_color[G] || + foreground_color_[B] != foreground_color[B] || + foreground_color_[A] != foreground_color[A] ) { + + foreground_color_[R] = foreground_color[R]; + foreground_color_[G] = foreground_color[G]; + foreground_color_[B] = foreground_color[B]; + foreground_color_[A] = foreground_color[A]; + + clearCaches(); + } + } + + // Note: Changing the background color also clears the display list cache. + + void Face::setBackgroundColor ( const GLfloat background_color[4] ) + { + if ( background_color_[R] != background_color[R] || + background_color_[G] != background_color[G] || + background_color_[B] != background_color[B] || + background_color_[A] != background_color[A] ) { + + background_color_[R] = background_color[R]; + background_color_[G] = background_color[G]; + background_color_[B] = background_color[B]; + background_color_[A] = background_color[A]; + + clearCaches(); + } + } +#ifndef OGLFT_NO_QT + // Note: Changing the foreground color also clears the display list cache. + + void Face::setForegroundColor ( const QRgb foreground_rgba ) + { + GLfloat foreground_color[4]; + foreground_color[R] = qRed( foreground_rgba ) / 255.; + foreground_color[G] = qGreen( foreground_rgba ) / 255.; + foreground_color[B] = qBlue( foreground_rgba ) / 255.; + foreground_color[A] = qAlpha( foreground_rgba ) / 255.; + + if ( foreground_color_[R] != foreground_color[R] || + foreground_color_[G] != foreground_color[G] || + foreground_color_[B] != foreground_color[B] || + foreground_color_[A] != foreground_color[A] ) { + + foreground_color_[R] = foreground_color[R]; + foreground_color_[G] = foreground_color[G]; + foreground_color_[B] = foreground_color[B]; + foreground_color_[A] = foreground_color[A]; + + clearCaches(); + } + } + + // Note: Changing the background color also clears the display list cache. + + void Face::setBackgroundColor ( const QRgb background_rgba ) + { + GLfloat background_color[4]; + background_color[R] = qRed( background_rgba ) / 255.; + background_color[G] = qGreen( background_rgba ) / 255.; + background_color[B] = qBlue( background_rgba ) / 255.; + background_color[A] = qAlpha( background_rgba ) / 255.; + + if ( background_color_[R] != background_color[R] || + background_color_[G] != background_color[G] || + background_color_[B] != background_color[B] || + background_color_[A] != background_color[A] ) { + + background_color_[R] = background_color[R]; + background_color_[G] = background_color[G]; + background_color_[B] = background_color[B]; + background_color_[A] = background_color[A]; + + clearCaches(); + } + } +#endif /* OGLFT_NO_QT */ + // Note: Changing the string rotation angle clears the display list cache + + void Face::setStringRotation ( GLfloat string_rotation ) + { + if ( string_rotation != string_rotation_ ) { + string_rotation_ = string_rotation; + + clearCaches(); + + // Note that this affects ALL glyphs accessed through + // the Face, both the vector and the raster glyphs. Very nice! + + if ( string_rotation_ != 0. ) { + float angle; + if ( string_rotation_ < 0. ) { + angle = 360.f - fmod( fabs( string_rotation_ ), 360.f ); + } + else { + angle = fmod( string_rotation_, 360.f ); + } + + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(angle * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + for ( unsigned int i = 0; i < faces_.size(); i++ ) + FT_Set_Transform( faces_[i].face_, &rotation_matrix, 0 ); + } + else + for ( unsigned int i = 0; i < faces_.size(); i++ ) + FT_Set_Transform( faces_[i].face_, 0, 0 ); + } + } + + // Note: Changing the rotation reference character clears the display list cache. + + void Face::setCharacterRotationReference ( unsigned char c ) + { + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( f < faces_.size() && glyph_index != rotation_reference_glyph_ ) { + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + + if ( error != 0 ) return; + + rotation_reference_glyph_ = glyph_index; + + rotation_reference_face_ = faces_[f].face_; + + setRotationOffset(); + + clearCaches(); + } + } + + BBox Face::measure ( const char* s ) + { + BBox bbox; + char c; + + if ( ( c = *s++ ) != 0 ) { + + bbox = measure( c ); + + for ( c = *s; c != 0; c = *++s ) { + + BBox char_bbox = measure( c ); + + bbox += char_bbox; + } + } + + return bbox; + } + + BBox Face::measureRaw ( const char* s ) + { + BBox bbox; + + for ( char c = *s; c != 0; c = *++s ) { + BBox char_bbox; + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) continue; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) continue; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) continue; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + char_bbox = ft_bbox; + char_bbox.advance_ = faces_[f].face_->glyph->advance; + + bbox += char_bbox; + } + + return bbox; + } + +#ifndef OGLFT_NO_QT + BBox Face::measure ( const QString& s ) + { + BBox bbox; + + if ( s.length() > 0 ) { + + bbox = measure( s.at( 0 ) ); + + for ( unsigned int i = 1; i < s.length(); i++ ) { + + BBox char_bbox = measure( s.at( i ) ); + + bbox += char_bbox; + } + } + + return bbox; + } + + BBox Face::measure ( const QString& format, double number ) + { + return measure( format_number( format, number ) ); + } + + BBox Face::measureRaw ( const QString& s ) + { + BBox bbox; + + for ( unsigned int i = 0; i < s.length(); i++ ) { + BBox char_bbox; + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, s.at( i ).unicode() ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) { + continue; + } + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) continue; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) continue; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + char_bbox = ft_bbox; + char_bbox.advance_ = faces_[f].face_->glyph->advance; + + bbox += char_bbox; + } + + return bbox; + } +#endif /* OGLFT_NO_QT */ + + // Measure the bounding box as if the (latin1) string were not rotated + + BBox Face::measure_nominal ( const char* s ) + { + if ( string_rotation_ == 0. ) + return measure( s ); + + for ( unsigned int f = 0; f < faces_.size(); f++ ) + FT_Set_Transform( faces_[f].face_, 0, 0 ); + + BBox bbox = measure( s ); + + float angle; + if ( string_rotation_ < 0. ) { + angle = 360.f - fmod( fabs( string_rotation_ ), 360.f ); + } + else { + angle = fmod( string_rotation_, 360.f ); + } + + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(angle * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + for ( unsigned int f = 0; f < faces_.size(); f++ ) + FT_Set_Transform( faces_[f].face_, &rotation_matrix, 0 ); + + return bbox; + } + +#ifndef OGLFT_NO_QT + // Measure the bounding box as if the (UNICODE) string were not rotated + + BBox Face::measure_nominal ( const QString& s ) + { + if ( string_rotation_ == 0. ) + return measure( s ); + + for ( unsigned int f = 0; f < faces_.size(); f++ ) + FT_Set_Transform( faces_[f].face_, 0, 0 ); + + BBox bbox = measure( s ); + + float angle; + if ( string_rotation_ < 0. ) { + angle = 360. - fmod( fabs( string_rotation_ ), 360.f ); + } + else { + angle = fmod( string_rotation_, 360.f ); + } + + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(angle * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + for ( unsigned int f = 0; f < faces_.size(); f++ ) + FT_Set_Transform( faces_[f].face_, &rotation_matrix, 0 ); + + return bbox; + } + + // Format the number per the given format. Mostly pointless + // for the standard formats, e.g. %12e. You can use the regular + // Qt functions to format such a string and avoid the parsing + // which is done here. + + QString Face::format_number ( const QString& format, double number ) + { + // This regexp says: + // 1. optionally match any thing up to a format, + // 2. the optional format (%...), and + // 3. optionally anything after it. + // Note that since everything is optional, the match always succeeds. + QRegExp format_regexp("((?:[^%]|%%)*)(%[0-9]*\\.?[0-9]*[efgp])?((?:[^%]|%%)*)"); +#if OGLFT_QT_VERSION == 3 + /*int pos = */ format_regexp.search( format ); +#elif OGLFT_QT_VERSION == 4 + /*int pos = */ format_regexp.exactMatch( format ); +#endif + + QStringList list = format_regexp.capturedTexts(); + + QStringList::Iterator it = list.begin(); + +#if OGLFT_QT_VERSION == 3 + it = list.remove( it ); // Remove the "matched" string, leaving the pieces +#elif OGLFT_QT_VERSION == 4 + it = list.erase( it ); // Remove the "matched" string, leaving the pieces +#endif + + if ( it == list.end() ) return QString::null; // Probably an error + + // Extract each piece from the list + + QString prefix, value_format, postfix; + char type = '\0'; + + if ( !(*it).isEmpty() ) + prefix = *it; + + ++it; + + if ( it != list.end() ) { + if ( !(*it).isEmpty() ) { + // Reparse this to extract the details of the format + QRegExp specifier_regexp( "([0-9]*)\\.?([0-9]*)([efgp])" ); +#if OGLFT_QT_VERSION == 3 + (void)specifier_regexp.search( *it ); +#elif OGLFT_QT_VERSION == 4 + (void)specifier_regexp.exactMatch( *it ); +#endif + QStringList specifier_list = specifier_regexp.capturedTexts(); + + QStringList::Iterator sit = specifier_list.begin(); +#if OGLFT_QT_VERSION == 3 + sit = specifier_list.remove( sit ); +#elif OGLFT_QT_VERSION == 4 + sit = specifier_list.erase( sit ); +#endif + int width = (*sit).toInt(); + ++sit; + int precision = (*sit).toInt(); + ++sit; +#if OGLFT_QT_VERSION == 3 + type = (*sit).at(0).latin1(); +#elif OGLFT_QT_VERSION == 4 + type = (*sit).at(0).toLatin1(); +#endif + // The regular formats just use Qt's number formatting capability + if ( type == 'e' || type == 'f' || type == 'g' ) + value_format = QString( "%1" ).arg( number, width, type, precision ); + + // For the fraction, though, we have to convert it the special + // UNICODE encoding + else if ( type == 'p' ) { + // Fixed for now... + if ( fabs( number ) < 1./256. ) + value_format = "0"; + else { + // Extract the integral part + int a = (int)number; + + if ( a != 0 ) + value_format = QString::number( a ); + + // Extract the fractional part: NOTE: THIS IS LIMITED TO + // REPRESENTING ALL FRACTIONS AS n/256 + int b = (int)rint( 256. * fabs( number - a ) ); + + // If b is exactly 256, then the original number was + // essentially an integer (to within 1/256-th) + if ( b == 256 ) + value_format = QString::number( rint( number ) ); + + else if ( b != 0 ) { + int c = 256; + // Remove common factors of two from the numerator and denominator + for ( ; ( b & 0x1 ) == 0; b >>= 1, c >>= 1 ); + + // Format the numerator and shift to 0xE000 sequence + QString numerator = QString::number( b ); + for ( uint i = 0; i < numerator.length(); i++ ) { + numerator[i] = QChar( numerator.at(i).unicode() - + QChar('0').unicode() + + 0xE000 ); + } + value_format += numerator; + value_format += QChar( 0xE00a ); // The '/' + // Format the denominator and shift to 0xE010 sequence + QString denominator = QString::number( c ); + for ( uint i = 0; i < denominator.length(); i++ ) { + denominator[i] = QChar( denominator.at(i).unicode() - + QChar('0').unicode() + + 0xE010 ); + } + value_format += denominator; + } + } + } + } + + ++it; + + if ( it != list.end() && !(*it).isEmpty() ) + postfix = *it; + } + + return prefix + value_format + postfix; + } +#endif /* OGLFT_NO_QT */ + + // Compile a (latin1) string into a display list + + GLuint Face::compile ( const char* s ) + { + // First, make sure all the characters in the string are themselves + // in display lists + const char* s_tmp = s; + + for ( char c = *s_tmp; c != 0; c = *++s_tmp ) { + compile( c ); + } + + GLuint dlist = glGenLists( 1 ); + glNewList( dlist, GL_COMPILE ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + if ( !advance_ ) + glPushMatrix(); + + draw( s ); + + if ( !advance_ ) + glPopMatrix(); + + glEndList(); + + return dlist; + } +#ifndef OGLFT_NO_QT + // Compile a (UNICODE) string into a display list + + GLuint Face::compile ( const QString& s ) + { + // First, make sure all the characters in the string are themselves + // in display lists + for ( unsigned int i = 0; i < s.length(); i++ ) { + compile( s.at( i ) ); + } + + GLuint dlist = glGenLists( 1 ); + glNewList( dlist, GL_COMPILE ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + if ( !advance_ ) + glPushMatrix(); + + draw( s ); + + if ( !advance_ ) + glPopMatrix(); + + glEndList(); + + return dlist; + } +#endif /* OGLFT_NO_QT */ + // Compile a (latin1) character glyph into a display list and cache + // it for later + + GLuint Face::compile ( unsigned char c ) + { + // See if we've done it already + + GDLCI fgi = glyph_dlists_.find( c ); + + if ( fgi != glyph_dlists_.end() ) + return fgi->second; + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return 0; + + GLuint dlist = compileGlyph( faces_[f].face_, glyph_index ); + + glyph_dlists_[ c ] = dlist; + + return dlist; + } + +#ifndef OGLFT_NO_QT + // Compile a (UNICODE) character glyph into a display list and cache + // it for later + + GLuint Face::compile ( const QChar c ) + { + // See if we've done it already + + GDLCI fgi = glyph_dlists_.find( c.unicode() ); + + if ( fgi != glyph_dlists_.end() ) + return fgi->second; + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c.unicode() ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return 0; + + GLuint dlist = compileGlyph( faces_[f].face_, glyph_index ); + + glyph_dlists_[ c.unicode() ] = dlist; + + return dlist; + } +#endif /* OGLFT_NO_QT */ + // Assume the MODELVIEW matrix is already set and draw the (latin1) + // string. Note: this routine now ignores almost all settings: + // including the position (both modelview and raster), color, + // justification and advance settings. Consider this to be the raw + // drawing routine for which you are responsible for most of the + // setup. + + void Face::draw ( const char* s ) + { + DLCI character_display_list = character_display_lists_.begin(); + + for ( char c = *s; c != 0; c = *++s ) { + + if ( character_display_list != character_display_lists_.end() ) { + glCallList( *character_display_list ); + character_display_list++; + } + + draw( c ); + } + } +#ifndef OGLFT_NO_QT + // Assume the MODELVIEW matrix is already set and draw the (UNICODE) + // string. Note: this routine now ignores almost all settings: + // including the position (both modelview and raster), color, + // justification and advance settings. Consider this to be the raw + // drawing routine for which you are responsible for most of the + // setup. + + void Face::draw ( const QString& s ) + { + DLCI character_display_list = character_display_lists_.begin(); + + for ( unsigned int i = 0; i < s.length(); i++ ) { + + if ( character_display_list != character_display_lists_.end() ) { + glCallList( *character_display_list ); + character_display_list++; + } + + draw( s.at( i ) ); + } + } +#endif /* OGLFT_NO_QT */ + + // Assume the MODELVIEW matrix is already setup and draw the + // (latin1) character. + + void Face::draw ( unsigned char c ) + { + // See if we've done it already + + GDLCI fgi = glyph_dlists_.find( c ); + + if ( fgi != glyph_dlists_.end( ) ) { + glCallList( fgi->second ); + return; + } + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return; + + // Otherwise, either compile it (and call it) or ... + + else if ( compile_mode_ == COMPILE ) { + GLuint dlist = compile( c ); + glCallList( dlist ); + } + + // ... render it immediately + + else { + renderGlyph( faces_[f].face_, glyph_index ); + } + } +#ifndef OGLFT_NO_QT + // Assume the MODELVIEW matrix is already setup and draw the + // (UNICODE) character. + + void Face::draw ( const QChar c ) + { + // See if we've done it already + + GDLCI fgi = glyph_dlists_.find( c.unicode() ); + + if ( fgi != glyph_dlists_.end( ) ) { + glCallList( fgi->second ); + return; + } + + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c.unicode() ); + if ( glyph_index != 0 ) { + break; + } + } + + if ( glyph_index == 0 ) + return; + + // Otherwise, either compile it (and call it) or ... + + if ( compile_mode_ == COMPILE ) { + GLuint dlist = compile( c ); + glCallList( dlist ); + } + + // ... render it immediately + + else { + renderGlyph( faces_[f].face_, glyph_index ); + } + } +#endif /* OGLFT_NO_QT */ + // Draw the (latin1) character at the given position. The MODELVIEW + // matrix is modified by the glyph advance. + + void Face::draw ( GLfloat x, GLfloat y, unsigned char c ) + { + glTranslatef( x, y, 0. ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + + glRasterPos2i( 0, 0 ); + + draw( c ); + } +#ifndef OGLFT_NO_QT + // Draw the (UNICODE) character at the given position. The MODELVIEW + // matrix is modified by the glyph advance. + + void Face::draw ( GLfloat x, GLfloat y, QChar c ) + { + glTranslatef( x, y, 0. ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + + glRasterPos2i( 0, 0 ); + + draw( c ); + } +#endif /* OGLFT_NO_QT */ + // Draw the (latin1) string at the given position. + + void Face::draw ( GLfloat x, GLfloat y, const char* s ) + { + if ( !advance_ ) + glPushMatrix(); + + if ( horizontal_justification_ != ORIGIN || + vertical_justification_ != BASELINE ) { + glPushMatrix(); + + BBox bbox = measure_nominal( s ); + + GLfloat dx = 0, dy = 0; + + switch ( horizontal_justification_ ) { + case LEFT: + dx = -bbox.x_min_; break; + case CENTER: + dx = -( bbox.x_min_ + bbox.x_max_ ) / 2.f; break; + case RIGHT: + dx = -bbox.x_max_; break; + default: + break; + } + switch ( vertical_justification_ ) { + case BOTTOM: + dy = -bbox.y_min_; break; + case MIDDLE: + dy = -( bbox.y_min_ + bbox.y_max_ ) / 2.f; break; + case TOP: + dy = -bbox.y_max_; break; + default: + break; + } + + // There is probably a less expensive way to compute this + + glRotatef( string_rotation_, 0., 0., 1. ); + glTranslatef( dx, dy, 0 ); + glRotatef( -string_rotation_, 0., 0., 1. ); + } + + glTranslatef( x, y, 0. ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + + glRasterPos2i( 0, 0 ); + + draw( s ); + + if ( horizontal_justification_ != ORIGIN || + vertical_justification_ != BASELINE ) + glPopMatrix(); + + if ( !advance_ ) + glPopMatrix(); + } + +#ifndef OGLFT_NO_QT + // Draw the (UNICODE) string at the given position. + + void Face::draw ( GLfloat x, GLfloat y, const QString& s ) + { + if ( !advance_ ) + glPushMatrix(); + + if ( horizontal_justification_ != ORIGIN || + vertical_justification_ != BASELINE ) { + glPushMatrix(); + + BBox bbox = measure_nominal( s ); + + GLfloat dx = 0, dy = 0; + + switch ( horizontal_justification_ ) { + case LEFT: + dx = -bbox.x_min_; break; + case CENTER: + dx = -( bbox.x_min_ + bbox.x_max_ ) / 2.; break; + case RIGHT: + dx = -bbox.x_max_; break; + case ORIGIN: + break; + } + switch ( vertical_justification_ ) { + case BOTTOM: + dy = -bbox.y_min_; break; + case MIDDLE: + dy = -( bbox.y_min_ + bbox.y_max_ ) / 2.; break; + case TOP: + dy = -bbox.y_max_; break; + case BASELINE: + break; + } + + // There is probably a less expensive way to compute this + + glRotatef( string_rotation_, 0., 0., 1. ); + glTranslatef( dx, dy, 0 ); + glRotatef( -string_rotation_, 0., 0., 1. ); + } + + glTranslatef( x, y, 0. ); + + glColor4f( foreground_color_[R], foreground_color_[G], foreground_color_[B], + foreground_color_[A] ); + + glRasterPos2i( 0, 0 ); + + draw( s ); + + if ( horizontal_justification_ != ORIGIN || + vertical_justification_ != BASELINE ) + glPopMatrix(); + + if ( !advance_ ) + glPopMatrix(); + } + + // Draw the number at the given position per the given format. + + void Face::draw ( GLfloat x, GLfloat y, const QString& format, double number ) + { + draw( x, y, format_number( format, number ) ); + } +#endif /* OGLFT_NO_QT */ + + Raster::Raster ( const char* filename, float point_size, FT_UInt resolution ) + : Face( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Raster::Raster ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Face( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Raster::Raster ( FT_Face face, float point_size, FT_UInt resolution ) + : Face( face, point_size, resolution ) + { + init(); + } + + void Raster::init ( void ) + { + character_rotation_z_ = 0; + + setCharSize(); + + setCharacterRotationReference( 'o' ); + } + + Raster::~Raster ( void ) + { + clearCaches(); + } + + void Raster::setCharacterRotationZ ( GLfloat character_rotation_z ) + { + if ( character_rotation_z != character_rotation_z_ ) { + character_rotation_z_ = character_rotation_z; + + clearCaches(); + } + } + + double Raster::height ( void ) const + { + if ( faces_[0].face_->height > 0 ) + return faces_[0].face_->height / 64.; + else + return faces_[0].face_->size->metrics.y_ppem; + } + + BBox Raster::measure ( unsigned char c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + // In order to be accurate regarding the placement of text not + // aligned at the glyph's origin (CENTER/MIDDLE), the bounding box + // of the raster format has to be projected back into the + // view's coordinates + + GLint viewport[4]; + GLdouble modelview[16], projection[16]; + + glGetIntegerv( GL_VIEWPORT, viewport ); + glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); + glGetDoublev( GL_PROJECTION_MATRIX, projection ); + + // Well, first we have to get the Origin, since that is the basis + // of the bounding box + GLdouble x0, y0, z0; + gluUnProject( 0., 0., 0., modelview, projection, viewport, &x0, &y0, &z0 ); + + GLdouble x, y, z; + gluUnProject( bbox.x_min_, bbox.y_min_, 0., modelview, projection, viewport, + &x, &y, &z ); + bbox.x_min_ = (float)( x - x0 ); + bbox.y_min_ = (float)( y - y0 ); + + gluUnProject( bbox.x_max_, bbox.y_max_, 0., modelview, projection, viewport, + &x, &y, &z ); + bbox.x_max_ = (float)( x - x0 ); + bbox.y_max_ = (float)( y - y0 ); + + gluUnProject( bbox.advance_.dx_, bbox.advance_.dy_, 0., modelview, projection, + viewport, + &x, &y, &z ); + bbox.advance_.dx_ = (float)( x - x0 ); + bbox.advance_.dy_ = (float)( y - y0 ); + + return bbox; + } + +#ifndef OGLFT_NO_QT + BBox Raster::measure ( const QChar c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c.unicode() ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + // In order to be accurate regarding the placement of text not + // aligned at the glyph's origin (CENTER/MIDDLE), the bounding box + // of the raster format has to be projected back into the + // view's coordinates + + GLint viewport[4]; + GLdouble modelview[16], projection[16]; + + glGetIntegerv( GL_VIEWPORT, viewport ); + glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); + glGetDoublev( GL_PROJECTION_MATRIX, projection ); + + // Well, first we have to get the Origin, since that is the basis + // of the bounding box + GLdouble x0, y0, z0; + gluUnProject( 0., 0., 0., modelview, projection, viewport, &x0, &y0, &z0 ); + + GLdouble x, y, z; + gluUnProject( bbox.x_min_, bbox.y_min_, 0., modelview, projection, viewport, + &x, &y, &z ); + bbox.x_min_ = x - x0; + bbox.y_min_ = y - y0; + + gluUnProject( bbox.x_max_, bbox.y_max_, 0., modelview, projection, viewport, + &x, &y, &z ); + bbox.x_max_ = x - x0; + bbox.y_max_ = y - y0; + + gluUnProject( bbox.advance_.dx_, bbox.advance_.dy_, 0., modelview, projection, + viewport, + &x, &y, &z ); + bbox.advance_.dx_ = x - x0; + bbox.advance_.dy_ = y - y0; + + return bbox; + } + + BBox Raster::measure ( const QString& format, double number ) + { + return Face::measure( format, number ); + } +#endif /* OGLFT_NO_QT */ + + GLuint Raster::compileGlyph ( FT_Face face, FT_UInt glyph_index ) + { + GLuint dlist = glGenLists( 1 ); + glNewList( dlist, GL_COMPILE ); + + renderGlyph( face, glyph_index ); + + glEndList( ); + + return dlist; + } + + void Raster::setCharSize ( void ) + { + FT_Error error; + for ( unsigned int i = 0; i < faces_.size(); i++ ) { + error = FT_Set_Char_Size( faces_[i].face_, + (FT_F26Dot6)( point_size_ * 64 ), + (FT_F26Dot6)( point_size_ * 64 ), + resolution_, + resolution_ ); + if ( error != 0 ) return; + } + + if ( rotation_reference_glyph_ != 0 ) + setRotationOffset(); + } + + void Raster::setRotationOffset ( void ) + { + FT_Error error = FT_Load_Glyph( rotation_reference_face_, + rotation_reference_glyph_, + FT_LOAD_RENDER ); + + if ( error != 0 ) + return; + + rotation_offset_y_ = rotation_reference_face_->glyph->bitmap.rows / 2.f; + } + + void Raster::clearCaches ( void ) + { + GDLI fgi = glyph_dlists_.begin(); + + for ( ; fgi != glyph_dlists_.end(); ++fgi ) { + glDeleteLists( fgi->second, 1 ); + } + + glyph_dlists_.clear(); + } + + Monochrome::Monochrome ( const char* filename, float point_size, + FT_UInt resolution ) + : Raster( filename, point_size, resolution ) + {} + + Monochrome::Monochrome ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Raster( data_base, data_size, point_size, resolution ) + {} + + Monochrome::Monochrome ( FT_Face face, float point_size, FT_UInt resolution ) + : Raster( face, point_size, resolution ) + {} + + Monochrome::~Monochrome ( void ) + {} + + GLubyte* Monochrome::invertBitmap ( const FT_Bitmap& bitmap ) + { + // In FreeType 2.0.9, the pitch of bitmaps was rounded up to an + // even number. In general, this disagrees with what we had been + // using for OpenGL. + + int width = bitmap.width / 8 + ( ( bitmap.width & 7 ) > 0 ? 1 : 0 ); + + GLubyte* inverse = new GLubyte[ bitmap.rows * width ]; + GLubyte* inverse_ptr = inverse; + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < width; p++ ) + *inverse_ptr++ = *bitmap_ptr++; + } + + return inverse; + } + + void Monochrome::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + // Start by retrieving the glyph's data. + + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_Glyph original_glyph; + FT_Glyph glyph; + + error = FT_Get_Glyph( face->glyph, &original_glyph ); + + if ( error != 0 ) + return; + + error = FT_Glyph_Copy( original_glyph, &glyph ); + + FT_Done_Glyph( original_glyph ); + + if ( error != 0 ) + return; + + // If the individual characters are rotated (as distinct from string + // rotation), then apply that extra rotation here. This is equivalent + // to the sequence + // glTranslate(x_center,y_center); + // glRotate(angle); + // glTranslate(-x_center,-y_center); + // which is used for the polygonal styles. The deal with the raster + // styles is that you must retain the advance from the string rotation + // so that the glyphs are laid out properly. So, we make a copy of + // the string rotated glyph, and then rotate that and add back an + // additional offset to (in effect) restore the proper origin and + // advance of the glyph. + + if ( character_rotation_z_ != 0. ) { + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + FT_Vector original_offset, rotation_offset; + + original_offset.x = ( face->glyph->metrics.width / 2 + + face->glyph->metrics.horiBearingX ) / 64 * 0x10000L; + original_offset.y = (FT_Pos)(rotation_offset_y_ * 0x10000L); + + rotation_offset = original_offset; + + FT_Vector_Rotate( &rotation_offset, + (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_offset.x = original_offset.x - rotation_offset.x; + rotation_offset.y = original_offset.y - rotation_offset.y; + + rotation_offset.x /= 1024; + rotation_offset.y /= 1024; + + error = FT_Glyph_Transform( glyph, &rotation_matrix, &rotation_offset ); + } + + error = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_mono, 0, 1 ); + + if ( error != 0 ) { + FT_Done_Glyph( glyph ); + return; + } + + FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph; + + // Evidently, in FreeType2, you can only get "upside-down" bitmaps and + // OpenGL won't invert a bitmap with PixelZoom, so we have to invert the + // glyph's bitmap ourselves. + + GLubyte* inverted_bitmap = invertBitmap( bitmap_glyph->bitmap ); + + glBitmap( bitmap_glyph->bitmap.width, bitmap_glyph->bitmap.rows, + (GLfloat)-bitmap_glyph->left, + (GLfloat)( bitmap_glyph->bitmap.rows - bitmap_glyph->top ), + face->glyph->advance.x / 64.f, + face->glyph->advance.y / 64.f, + inverted_bitmap ); + + FT_Done_Glyph( glyph ); + + delete[] inverted_bitmap; + } + + Grayscale::Grayscale ( const char* filename, float point_size, + FT_UInt resolution ) + : Raster( filename, point_size, resolution ) + {} + + Grayscale::Grayscale ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Raster( data_base, data_size, point_size, resolution ) + {} + + Grayscale::Grayscale ( FT_Face face, float point_size, FT_UInt resolution ) + : Raster( face, point_size, resolution ) + {} + + Grayscale::~Grayscale ( void ) + {} + + GLubyte* Grayscale::invertPixmap ( const FT_Bitmap& bitmap ) + { + GLubyte* inverse = new GLubyte[ bitmap.rows * bitmap.pitch ]; + GLubyte* inverse_ptr = inverse; + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < bitmap.pitch; p++ ) { + *inverse_ptr++ = *bitmap_ptr++; + } + } + + return inverse; + } + + void Grayscale::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_Glyph original_glyph; + FT_Glyph glyph; + + error = FT_Get_Glyph( face->glyph, &original_glyph ); + + if ( error != 0 ) return; + + error = FT_Glyph_Copy( original_glyph, &glyph ); + + FT_Done_Glyph( original_glyph ); + + if ( error != 0 ) return; + + if ( character_rotation_z_ != 0. ) { + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + FT_Vector original_offset, rotation_offset; + + original_offset.x = ( face->glyph->metrics.width / 2 + + face->glyph->metrics.horiBearingX ) / 64 * 0x10000L; + original_offset.y = (FT_Pos)(rotation_offset_y_ * 0x10000L); + + rotation_offset = original_offset; + + FT_Vector_Rotate( &rotation_offset, + (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_offset.x = original_offset.x - rotation_offset.x; + rotation_offset.y = original_offset.y - rotation_offset.y; + + rotation_offset.x /= 1024; + rotation_offset.y /= 1024; + + error = FT_Glyph_Transform( glyph, &rotation_matrix, &rotation_offset ); + } + + error = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 ); + + if ( error != 0 ) { + FT_Done_Glyph( glyph ); + return; + } + + FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph; + + // Evidently, in FreeType2, you can only get "upside-down" bitmaps + // (this could be cured with PixelZoom, but that an additional function) + + GLubyte* inverted_pixmap = invertPixmap( bitmap_glyph->bitmap ); + + // :-( If this is compiled in a display list, it may or not be in effect + // later when the list is actually called. So, the client should be alerted + // to this fact: unpack alignment must be 1 + + glPushAttrib( GL_PIXEL_MODE_BIT ); + glPixelTransferf( GL_RED_SCALE, foreground_color_[R] - background_color_[R] ); + glPixelTransferf( GL_GREEN_SCALE, foreground_color_[G] - background_color_[G] ); + glPixelTransferf( GL_BLUE_SCALE, foreground_color_[B] - background_color_[B] ); + glPixelTransferf( GL_ALPHA_SCALE, foreground_color_[A] ); + glPixelTransferf( GL_RED_BIAS, background_color_[R] ); + glPixelTransferf( GL_GREEN_BIAS, background_color_[G] ); + glPixelTransferf( GL_BLUE_BIAS, background_color_[B] ); + glPixelTransferf( GL_ALPHA_BIAS, background_color_[A] ); + + glBitmap( 0, 0, 0, 0, + (GLfloat)bitmap_glyph->left, + (GLfloat)( bitmap_glyph->top - bitmap_glyph->bitmap.rows ), + 0 ); + + glDrawPixels( bitmap_glyph->bitmap.width, bitmap_glyph->bitmap.rows, + GL_LUMINANCE, GL_UNSIGNED_BYTE, + inverted_pixmap ); + + // This is how you advance the raster position when drawing PIXMAPS + // (without querying the state) + + glBitmap( 0, 0, 0, 0, + (GLfloat)( -bitmap_glyph->left + face->glyph->advance.x / 64.f ), + (GLfloat)( bitmap_glyph->bitmap.rows - bitmap_glyph->top + + face->glyph->advance.y / 64. ), + 0 ); + + FT_Done_Glyph( glyph ); + + glPopAttrib(); + + delete[] inverted_pixmap; + } + + Translucent::Translucent ( const char* filename, float point_size, + FT_UInt resolution ) + : Raster( filename, point_size, resolution ) + {} + + Translucent::Translucent ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Raster( data_base, data_size, point_size, resolution ) + {} + + Translucent::Translucent ( FT_Face face, float point_size, FT_UInt resolution ) + : Raster( face, point_size, resolution ) + {} + + Translucent::~Translucent ( void ) + {} + + // The simplest format which glDrawPixels can render with (varying) transparency + // is GL_LUMINANCE_ALPHA; so, we take the grayscale bitmap from FreeType + // and treat all non-zero values as full luminance (basically the mask for + // rendering) and duplicate the grayscale values as alpha values + // (as well as turn it upside-down). + + GLubyte* Translucent::invertPixmapWithAlpha ( const FT_Bitmap& bitmap ) + { + GLubyte* inverse = new GLubyte[ 2 * bitmap.rows * bitmap.pitch ]; + GLubyte* inverse_ptr = inverse; + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < bitmap.pitch; p++ ) { + *inverse_ptr++ = *bitmap_ptr ? 255 : 0; + *inverse_ptr++ = *bitmap_ptr++; + } + } + + return inverse; + } + + void Translucent::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_Glyph original_glyph; + FT_Glyph glyph; + + error = FT_Get_Glyph( face->glyph, &original_glyph ); + + if ( error != 0 ) return; + + error = FT_Glyph_Copy( original_glyph, &glyph ); + + FT_Done_Glyph( original_glyph ); + + if ( error != 0 ) return; + + if ( character_rotation_z_ != 0. ) { + FT_Matrix rotation_matrix; + FT_Vector sinus; + + FT_Vector_Unit( &sinus, (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_matrix.xx = sinus.x; + rotation_matrix.xy = -sinus.y; + rotation_matrix.yx = sinus.y; + rotation_matrix.yy = sinus.x; + + FT_Vector original_offset, rotation_offset; + + original_offset.x = ( face->glyph->metrics.width / 2 + + face->glyph->metrics.horiBearingX ) / 64 * 0x10000L; + original_offset.y = (FT_Pos)(rotation_offset_y_ * 0x10000L); + + rotation_offset = original_offset; + + FT_Vector_Rotate( &rotation_offset, + (FT_Angle)(character_rotation_z_ * 0x10000L) ); + + rotation_offset.x = original_offset.x - rotation_offset.x; + rotation_offset.y = original_offset.y - rotation_offset.y; + + rotation_offset.x /= 1024; + rotation_offset.y /= 1024; + + error = FT_Glyph_Transform( glyph, &rotation_matrix, &rotation_offset ); + } + + error = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 ); + + if ( error != 0 ) { + FT_Done_Glyph( glyph ); + return; + } + + FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph; + + // Evidently, in FreeType2, you can only get "upside-down" bitmaps. For + // translucency, the grayscale bitmap generated by FreeType is expanded + // to include an alpha value (and the non-zero values of the + // grayscale bitmap are saturated to provide a "mask" of the glyph). + + GLubyte* inverted_pixmap = invertPixmapWithAlpha( bitmap_glyph->bitmap ); + + glPushAttrib( GL_PIXEL_MODE_BIT ); + glPixelTransferf( GL_RED_SCALE, foreground_color_[R] - background_color_[R] ); + glPixelTransferf( GL_GREEN_SCALE, foreground_color_[G] -background_color_[G] ); + glPixelTransferf( GL_BLUE_SCALE, foreground_color_[B] - background_color_[B] ); + glPixelTransferf( GL_ALPHA_SCALE, foreground_color_[A] ); + glPixelTransferf( GL_RED_BIAS, background_color_[R] ); + glPixelTransferf( GL_GREEN_BIAS, background_color_[G] ); + glPixelTransferf( GL_BLUE_BIAS, background_color_[B] ); + glPixelTransferf( GL_ALPHA_BIAS, background_color_[A] ); + + // Set the proper raster position for rendering this glyph (why doesn't + // OpenGL have a similar function for pixmaps?) + + glBitmap( 0, 0, 0, 0, + (GLfloat)bitmap_glyph->left, + (GLfloat)( bitmap_glyph->top - bitmap_glyph->bitmap.rows ), + 0 ); + + glDrawPixels( bitmap_glyph->bitmap.width, bitmap_glyph->bitmap.rows, + GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, + inverted_pixmap ); + + // This is how you advance the raster position when drawing PIXMAPS + // (without querying the state) + + glBitmap( 0, 0, 0, 0, + -bitmap_glyph->left + face->glyph->advance.x / 64.f, + bitmap_glyph->bitmap.rows - bitmap_glyph->top + + face->glyph->advance.y / 64.f, + 0 ); + + FT_Done_Glyph( glyph ); + + glPopAttrib(); + + delete[] inverted_pixmap; + } + + Polygonal::Polygonal ( const char* filename, float point_size, FT_UInt resolution ) + : Face( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Polygonal::Polygonal ( const FT_Byte* data_base, const FT_Long data_size, float point_size, FT_UInt resolution) + : Face( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Polygonal::Polygonal ( FT_Face face, float point_size, FT_UInt resolution ) + : Face( face, point_size, resolution ) + { + init(); + } + + void Polygonal::init ( void ) + { + character_rotation_.active_ = false; + character_rotation_.x_ = 0; + character_rotation_.y_ = 0; + character_rotation_.z_ = 0; + + tessellation_steps_ = DEFAULT_TESSELLATION_STEPS; + + delta_ = 1. / (double)tessellation_steps_; + delta2_ = delta_ * delta_; + delta3_ = delta2_ * delta_; + + // For vector rendition modes, FreeType is allowed to generate the + // lines and arcs at the original face definition resolution. To + // get to the proper glyph size, the vertices are scaled before + // they're passed to the GLU tessellation routines. + + if ( resolution_ != 0 ) + vector_scale_ = ( point_size_ * resolution_ ) / + (float)( faces_.front().face_->units_per_EM * 72 ); + else // According to the FreeType documentation, resolution == 0 -> 72 DPI + vector_scale_ = ( point_size_ ) / + (float)( faces_.front().face_->units_per_EM ); + + color_tess_ = 0; + texture_tess_ = 0; + + setCharSize(); + + // Can't call this until a valid character size is set! + + setCharacterRotationReference( 'o' ); + } + + Polygonal::~Polygonal ( void ) + { + clearCaches(); + } + + // Note: Changing the color tessellation object also clears the + // display list cache + + void Polygonal::setColorTess ( ColorTess* color_tess ) + { + color_tess_ = color_tess; + + clearCaches(); + } + + // Note: Changing the texture coordinate tessellation object also + // clears the display list cache + + void Polygonal::setTextureTess ( TextureTess* texture_tess ) + { + texture_tess_ = texture_tess; + + clearCaches(); + } + + // Note: Changing the appoximation steps also clears the display list cache + + void Polygonal::setTessellationSteps ( unsigned int tessellation_steps ) + { + if ( tessellation_steps != tessellation_steps_ ) { + + tessellation_steps_ = tessellation_steps; + + delta_ = 1. / (double)tessellation_steps_; + delta2_ = delta_ * delta_; + delta3_ = delta2_ * delta_; + + clearCaches(); + } + } + + // Note: Changing the character rotation also clears the display list cache. + + void Polygonal::setCharacterRotationX ( GLfloat character_rotation_x ) + { + if ( character_rotation_x != character_rotation_.x_ ) { + character_rotation_.x_ = character_rotation_x; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Polygonal::setCharacterRotationY ( GLfloat character_rotation_y ) + { + if ( character_rotation_y != character_rotation_.y_ ) { + character_rotation_.y_ = character_rotation_y; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Polygonal::setCharacterRotationZ ( GLfloat character_rotation_z ) + { + if ( character_rotation_z != character_rotation_.z_ ) { + character_rotation_.z_ = character_rotation_z; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Polygonal::setCharSize ( void ) + { + for ( unsigned int i = 0; i < faces_.size(); i++ ) { + FT_Error error = FT_Set_Char_Size( faces_[i].face_, + 0, + faces_[i].face_->units_per_EM * 64, + 0, + 0 ); + if ( error != 0 ) return; + } + + if ( rotation_reference_glyph_ != 0 ) + setRotationOffset(); + } + + void Polygonal::setRotationOffset ( void ) + { + FT_Error error = FT_Load_Glyph( rotation_reference_face_, + rotation_reference_glyph_, + FT_LOAD_RENDER ); + + if ( error != 0 ) + return; + + vector_scale_ = ( point_size_ * resolution_ ) / + ( 72.f * rotation_reference_face_->units_per_EM ); + + rotation_offset_y_ = + ( rotation_reference_face_->glyph->metrics.horiBearingY / 2.f ) / 64.f + * vector_scale_; + } + + double Polygonal::height ( void ) const + { + if ( faces_[0].face_->height > 0 ) + return ( faces_[0].face_->height * point_size_ * resolution_ ) / + ( 72. * faces_[0].face_->units_per_EM ); + else + return ( faces_[0].face_->size->metrics.y_ppem * point_size_ * resolution_ ) / + ( 72. * faces_[0].face_->units_per_EM ); + } + + BBox Polygonal::measure ( unsigned char c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + bbox *= + ( point_size_ * resolution_ ) / ( 72.f * faces_[f].face_->units_per_EM ); + + return bbox; + } +#ifndef OGLFT_NO_QT + BBox Polygonal::measure ( const QChar c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c.unicode() ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + bbox *= ( point_size_ * resolution_ ) / ( 72. * faces_[f].face_->units_per_EM ); + + return bbox; + } +#endif /* OGLFT_NO_QT */ + + GLuint Polygonal::compileGlyph ( FT_Face face, FT_UInt glyph_index ) + { + GLuint dlist = glGenLists( 1 ); + + glNewList( dlist, GL_COMPILE ); + + renderGlyph( face, glyph_index ); + + glEndList( ); + + return dlist; + } + + void Polygonal::clearCaches ( void ) + { + GDLI fgi = glyph_dlists_.begin(); + + for ( ; fgi != glyph_dlists_.end(); ++fgi ) { + glDeleteLists( fgi->second, 1 ); + } + + glyph_dlists_.clear(); + } + + Outline::Outline ( const char* filename, float point_size, FT_UInt resolution ) + : Polygonal( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Outline::Outline ( const FT_Byte* data_base, const FT_Long data_size, float point_size, FT_UInt resolution) + : Polygonal( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Outline::Outline ( FT_Face face, float point_size, FT_UInt resolution ) + : Polygonal( face, point_size, resolution ) + { + init(); + } + + void Outline::init ( void ) + { + interface_.move_to = (FT_Outline_MoveTo_Func)moveToCallback; + interface_.line_to = (FT_Outline_LineTo_Func)lineToCallback; + interface_.conic_to = (FT_Outline_ConicTo_Func)conicToCallback; + interface_.cubic_to = (FT_Outline_CubicTo_Func)cubicToCallback; + interface_.shift = 0; + interface_.delta = 0; + } + + Outline::~Outline ( void ) + {} + + void Outline::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_Glyph g; + + error = FT_Get_Glyph( face->glyph, &g ); + + if ( error != 0 || g->format != FT_GLYPH_FORMAT_OUTLINE ) + return; + + vector_scale_ = ( point_size_ * resolution_ ) / + ( 72.f * face->units_per_EM ); + + if ( character_rotation_.active_ ) { + glPushMatrix(); + glTranslatef( ( face->glyph->metrics.width / 2.f + + face->glyph->metrics.horiBearingX ) / 64.f + * vector_scale_, + rotation_offset_y_, + 0.f ); + + if ( character_rotation_.x_ != 0. ) + glRotatef( character_rotation_.x_, 1., 0., 0. ); + + if ( character_rotation_.y_ != 0. ) + glRotatef( character_rotation_.y_, 0., 1., 0. ); + + if ( character_rotation_.z_ != 0. ) + glRotatef( character_rotation_.z_, 0., 0., 1. ); + + glTranslatef( -( face->glyph->metrics.width / 2.f + + face->glyph->metrics.horiBearingX ) / 64.f + * vector_scale_, + -rotation_offset_y_, + 0.f ); + } + + contour_open_ = false; + + // The Big Kahuna: the FreeType glyph decomposition routine traverses + // the outlines of the font by calling the various routines stored in + // outline_interface_. These routines in turn call the GL vertex routines. + + error = FT_Outline_Decompose( &((FT_OutlineGlyph)g)->outline, + &interface_, this ); + + FT_Done_Glyph( (FT_Glyph)g ); + + // Some glyphs may be empty (the 'blank' for instance!) + + if ( contour_open_ ) + glEnd( ); + + + if ( character_rotation_.active_ ) { + glPopMatrix(); + } + + // Drawing a character always advances the MODELVIEW. + + glTranslatef( face->glyph->advance.x / 64.f * vector_scale_, + face->glyph->advance.y / 64.f * vector_scale_, + 0.f ); + + for ( VILI vili = vertices_.begin(); vili != vertices_.end(); vili++ ) + delete *vili; + + vertices_.clear(); + } + + int Outline::moveToCallback ( FT_Vector* to, Outline* outline ) + { + if ( outline->contour_open_ ) { + glEnd(); + } + + outline->last_vertex_ = VertexInfo( to, + outline->colorTess(), + outline->textureTess() ); + + glBegin( GL_LINE_LOOP ); + + outline->contour_open_ = true; + + return 0; + } + + int Outline::lineToCallback ( FT_Vector* to, Outline* outline ) + { + outline->last_vertex_ = VertexInfo( to, + outline->colorTess(), + outline->textureTess() ); + GLdouble g[2]; + + g[X] = outline->last_vertex_.v_[X] * outline->vector_scale_; + g[Y] = outline->last_vertex_.v_[Y] * outline->vector_scale_; + + glVertex2dv( g ); + + return 0; + } + + int Outline::conicToCallback ( FT_Vector* control, FT_Vector* to, Outline* outline ) + { + // This is crude: Step off conics with a fixed number of increments + + VertexInfo to_vertex( to, outline->colorTess(), outline->textureTess() ); + VertexInfo control_vertex( control, outline->colorTess(), outline->textureTess() ); + + double b[2], c[2], d[2], f[2], df[2], d2f[2]; + GLdouble g[3]; + + g[Z] = 0.; + + b[X] = outline->last_vertex_.v_[X] - 2 * control_vertex.v_[X] + + to_vertex.v_[X]; + b[Y] = outline->last_vertex_.v_[Y] - 2 * control_vertex.v_[Y] + + to_vertex.v_[Y]; + + c[X] = -2 * outline->last_vertex_.v_[X] + 2 * control_vertex.v_[X]; + c[Y] = -2 * outline->last_vertex_.v_[Y] + 2 * control_vertex.v_[Y]; + + d[X] = outline->last_vertex_.v_[X]; + d[Y] = outline->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * outline->delta_ + b[X] * outline->delta2_; + df[Y] = c[Y] * outline->delta_ + b[Y] * outline->delta2_; + d2f[X] = 2 * b[X] * outline->delta2_; + d2f[Y] = 2 * b[Y] * outline->delta2_; + + for ( unsigned int i = 0; i < outline->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + g[X] = f[X] * outline->vector_scale_; + g[Y] = f[Y] * outline->vector_scale_; + + if ( outline->colorTess() ) + glColor4fv( outline->colorTess()->color( g ) ); + + glVertex2dv( g ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + } + + g[X] = to_vertex.v_[X] * outline->vector_scale_; + g[Y] = to_vertex.v_[Y] * outline->vector_scale_; + + if ( outline->colorTess() ) + glColor4fv( outline->colorTess()->color( g ) ); + + glVertex2dv( g ); + + outline->last_vertex_ = to_vertex; + + return 0; + } + + int Outline::cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Outline* outline ) + { + // This is crude: Step off cubics with a fixed number of increments + + VertexInfo to_vertex( to, outline->colorTess(), outline->textureTess() ); + VertexInfo control1_vertex( control1, outline->colorTess(), outline->textureTess() ); + VertexInfo control2_vertex( control2, outline->colorTess(), outline->textureTess() ); + + double a[2], b[2], c[2], d[2], f[2], df[2], d2f[2], d3f[2]; + GLdouble g[3]; + + g[Z] = 0.; + + a[X] = -outline->last_vertex_.v_[X] + 3 * control1_vertex.v_[X] + -3 * control2_vertex.v_[X] + to_vertex.v_[X]; + a[Y] = -outline->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y] + -3 * control2_vertex.v_[Y] + to_vertex.v_[Y]; + + b[X] = 3 * outline->last_vertex_.v_[X] - 6 * control1_vertex.v_[X] + + 3 * control2_vertex.v_[X]; + b[Y] = 3 * outline->last_vertex_.v_[Y] - 6 * control1_vertex.v_[Y] + + 3 * control2_vertex.v_[Y]; + + c[X] = -3 * outline->last_vertex_.v_[X] + 3 * control1_vertex.v_[X]; + c[Y] = -3 * outline->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y]; + + d[X] = outline->last_vertex_.v_[X]; + d[Y] = outline->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * outline->delta_ + b[X] * outline->delta2_ + + a[X] * outline->delta3_; + df[Y] = c[Y] * outline->delta_ + b[Y] * outline->delta2_ + + a[Y] * outline->delta3_; + d2f[X] = 2 * b[X] * outline->delta2_ + 6 * a[X] * outline->delta3_; + d2f[Y] = 2 * b[Y] * outline->delta2_ + 6 * a[Y] * outline->delta3_; + d3f[X] = 6 * a[X] * outline->delta3_; + d3f[Y] = 6 * a[Y] * outline->delta3_; + + for ( unsigned int i = 0; i < outline->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + g[X] = f[X] * outline->vector_scale_; + g[Y] = f[Y] * outline->vector_scale_; + + if ( outline->colorTess() ) + glColor4fv( outline->colorTess()->color( g ) ); + + glVertex2dv( g ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + d2f[X] += d3f[X]; + d2f[Y] += d3f[Y]; + } + + g[X] = to_vertex.v_[X] * outline->vector_scale_; + g[Y] = to_vertex.v_[Y] * outline->vector_scale_; + + if ( outline->colorTess() ) + glColor4fv( outline->colorTess()->color( g ) ); + + glVertex2dv( g ); + + outline->last_vertex_ = to_vertex; + + return 0; + } + + Filled::Filled ( const char* filename, float point_size, FT_UInt resolution ) + : Polygonal( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Filled::Filled ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Polygonal( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Filled::Filled ( FT_Face face, float point_size, FT_UInt resolution ) + : Polygonal( face, point_size, resolution ) + { + init(); + } + + void Filled::init ( void ) + { + depth_offset_ = 0; + + interface_.move_to = (FT_Outline_MoveTo_Func)moveToCallback; + interface_.line_to = (FT_Outline_LineTo_Func)lineToCallback; + interface_.conic_to = (FT_Outline_ConicTo_Func)conicToCallback; + interface_.cubic_to = (FT_Outline_CubicTo_Func)cubicToCallback; + interface_.shift = 0; + interface_.delta = 0; + + tess_obj_ = gluNewTess(); + +#if defined(WIN32) + typedef void (CALLBACK*(CB))(); +#else + typedef GLUTessCallback CB; +#endif + gluTessCallback( tess_obj_, GLU_TESS_VERTEX, CB(vertexCallback) ); + gluTessCallback( tess_obj_, GLU_TESS_BEGIN, CB(beginCallback) ); + gluTessCallback( tess_obj_, GLU_TESS_END, CB(endCallback) ); + gluTessCallback( tess_obj_, GLU_TESS_COMBINE_DATA, CB(combineCallback) ); + gluTessCallback( tess_obj_, GLU_TESS_ERROR, CB(errorCallback) ); + } + + Filled::~Filled ( void ) + { + gluDeleteTess( tess_obj_ ); + } + + void Filled::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_Glyph g; + + error = FT_Get_Glyph( face->glyph, &g ); + + if ( error != 0 || g->format != FT_GLYPH_FORMAT_OUTLINE ) + return; + + vector_scale_ = ( point_size_ * resolution_ ) / + ( 72.f * face->units_per_EM ); + + if ( character_rotation_.active_ ) { + glPushMatrix(); + glTranslatef( ( face->glyph->metrics.width / 2.f + + face->glyph->metrics.horiBearingX ) / 64.f + * vector_scale_, + rotation_offset_y_, + 0. ); + + if ( character_rotation_.x_ != 0. ) + glRotatef( character_rotation_.x_, 1., 0., 0. ); + + if ( character_rotation_.y_ != 0. ) + glRotatef( character_rotation_.y_, 0., 1., 0. ); + + if ( character_rotation_.z_ != 0. ) + glRotatef( character_rotation_.z_, 0., 0., 1. ); + + glTranslatef( -( face->glyph->metrics.width / 2.f + + face->glyph->metrics.horiBearingX ) / 64.f + * vector_scale_, + -rotation_offset_y_, + 0.f ); + } + + if ( depth_offset_ != 0. ) { + glPushMatrix(); + glTranslatef( 0., 0., depth_offset_ ); + glNormal3f( 0., 0., 1. ); + } + else { + glNormal3f( 0., 0., -1. ); + } + + glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); + + contour_open_ = false; + + gluTessBeginPolygon( tess_obj_, this ); + + // The Big Kahuna: the FreeType glyph decomposition routine traverses + // the outlines of the font by calling the various routines stored in + // interface_. These routines in turn call the GLU tessellation routines + // to create OGL polygons. + + error = FT_Outline_Decompose( &((FT_OutlineGlyph)g)->outline, + &interface_, this ); + + FT_Done_Glyph( (FT_Glyph)g ); + + // Some glyphs may be empty (the 'blank' for instance!) + + if ( contour_open_ ) + gluTessEndContour( tess_obj_ ); + + gluTessEndPolygon( tess_obj_ ); + + if ( depth_offset_ != 0. ) { + glPopMatrix(); + } + if ( character_rotation_.active_ ) { + glPopMatrix(); + } + + // Drawing a character always advances the MODELVIEW. + + glTranslatef( face->glyph->advance.x / 64 * vector_scale_, + face->glyph->advance.y / 64 * vector_scale_, + 0. ); + + for ( VILI vili = extra_vertices_.begin(); vili != extra_vertices_.end(); vili++ ) + delete *vili; + + extra_vertices_.clear(); + + for ( VILI vili = vertices_.begin(); vili != vertices_.end(); vili++ ) + delete *vili; + + vertices_.clear(); + } + + int Filled::moveToCallback ( FT_Vector* to, Filled* filled ) + { + if ( filled->contour_open_ ) { + gluTessEndContour( filled->tess_obj_ ); + } + + filled->last_vertex_ = VertexInfo( to, filled->colorTess(), filled->textureTess() ); + + gluTessBeginContour( filled->tess_obj_ ); + + filled->contour_open_ = true; + + return 0; + } + + int Filled::lineToCallback ( FT_Vector* to, Filled* filled ) + { + filled->last_vertex_ = VertexInfo( to, filled->colorTess(), filled->textureTess() ); + + VertexInfo* vertex = new VertexInfo( to, filled->colorTess(), filled->textureTess() ); + + vertex->v_[X] *= filled->vector_scale_; + vertex->v_[Y] *= filled->vector_scale_; + + gluTessVertex( filled->tess_obj_, vertex->v_, vertex ); + + filled->vertices_.push_back( vertex ); + + return 0; + } + + int Filled::conicToCallback ( FT_Vector* control, FT_Vector* to, Filled* filled ) + { + // This is crude: Step off conics with a fixed number of increments + + VertexInfo to_vertex( to, filled->colorTess(), filled->textureTess() ); + VertexInfo control_vertex( control, filled->colorTess(), filled->textureTess() ); + + double b[2], c[2], d[2], f[2], df[2], d2f[2]; + + b[X] = filled->last_vertex_.v_[X] - 2 * control_vertex.v_[X] + + to_vertex.v_[X]; + b[Y] = filled->last_vertex_.v_[Y] - 2 * control_vertex.v_[Y] + + to_vertex.v_[Y]; + + c[X] = -2 * filled->last_vertex_.v_[X] + 2 * control_vertex.v_[X]; + c[Y] = -2 * filled->last_vertex_.v_[Y] + 2 * control_vertex.v_[Y]; + + d[X] = filled->last_vertex_.v_[X]; + d[Y] = filled->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * filled->delta_ + b[X] * filled->delta2_; + df[Y] = c[Y] * filled->delta_ + b[Y] * filled->delta2_; + d2f[X] = 2 * b[X] * filled->delta2_; + d2f[Y] = 2 * b[Y] * filled->delta2_; + + for ( unsigned int i = 0; i < filled->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + VertexInfo* vertex = new VertexInfo( f, filled->colorTess(), filled->textureTess() ); + + vertex->v_[X] *= filled->vector_scale_; + vertex->v_[Y] *= filled->vector_scale_; + + filled->vertices_.push_back( vertex ); + + gluTessVertex( filled->tess_obj_, vertex->v_, vertex ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + } + + VertexInfo* vertex = new VertexInfo( to, filled->colorTess(), filled->textureTess() ); + + vertex->v_[X] *= filled->vector_scale_; + vertex->v_[Y] *= filled->vector_scale_; + + filled->vertices_.push_back( vertex ); + + gluTessVertex( filled->tess_obj_, vertex->v_, vertex ); + + filled->last_vertex_ = to_vertex; + + return 0; + } + + int Filled::cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Filled* filled ) + { + // This is crude: Step off cubics with a fixed number of increments + + VertexInfo to_vertex( to, filled->colorTess(), filled->textureTess() ); + VertexInfo control1_vertex( control1, filled->colorTess(), filled->textureTess() ); + VertexInfo control2_vertex( control2, filled->colorTess(), filled->textureTess() ); + + double a[2], b[2], c[2], d[2], f[2], df[2], d2f[2], d3f[2]; + + a[X] = -filled->last_vertex_.v_[X] + 3 * control1_vertex.v_[X] + -3 * control2_vertex.v_[X] + to_vertex.v_[X]; + a[Y] = -filled->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y] + -3 * control2_vertex.v_[Y] + to_vertex.v_[Y]; + + b[X] = 3 * filled->last_vertex_.v_[X] - 6 * control1_vertex.v_[X] + + 3 * control2_vertex.v_[X]; + b[Y] = 3 * filled->last_vertex_.v_[Y] - 6 * control1_vertex.v_[Y] + + 3 * control2_vertex.v_[Y]; + + c[X] = -3 * filled->last_vertex_.v_[X] + 3 * control1_vertex.v_[X]; + c[Y] = -3 * filled->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y]; + + d[X] = filled->last_vertex_.v_[X]; + d[Y] = filled->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * filled->delta_ + b[X] * filled->delta2_ + + a[X] * filled->delta3_; + df[Y] = c[Y] * filled->delta_ + b[Y] * filled->delta2_ + + a[Y] * filled->delta3_; + d2f[X] = 2 * b[X] * filled->delta2_ + 6 * a[X] * filled->delta3_; + d2f[Y] = 2 * b[Y] * filled->delta2_ + 6 * a[Y] * filled->delta3_; + d3f[X] = 6 * a[X] * filled->delta3_; + d3f[Y] = 6 * a[Y] * filled->delta3_; + + for ( unsigned int i = 0; i < filled->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + VertexInfo* vertex = new VertexInfo( f, filled->colorTess(), filled->textureTess() ); + + vertex->v_[X] *= filled->vector_scale_; + vertex->v_[Y] *= filled->vector_scale_; + + filled->vertices_.push_back( vertex ); + + gluTessVertex( filled->tess_obj_, vertex->v_, vertex ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + d2f[X] += d3f[X]; + d2f[Y] += d3f[Y]; + } + + VertexInfo* vertex = new VertexInfo( to, filled->colorTess(), filled->textureTess() ); + + vertex->v_[X] *= filled->vector_scale_; + vertex->v_[Y] *= filled->vector_scale_; + + filled->vertices_.push_back( vertex ); + + gluTessVertex( filled->tess_obj_, vertex->v_, vertex ); + + filled->last_vertex_ = to_vertex; + + return 0; + } + + void Filled::vertexCallback ( VertexInfo* vertex ) + { + if ( vertex->color_tess_ != 0 ) + glColor4fv( vertex->color_tess_->color( vertex->v_ ) ); + + if ( vertex->texture_tess_ != 0 ) + glTexCoord2fv( vertex->texture_tess_->texCoord( vertex->v_ ) ); + + glVertex3dv( vertex->v_ ); + } + + void Filled::beginCallback ( GLenum which ) + { + glBegin( which ); + } + + void Filled::endCallback ( void ) + { + glEnd(); + } + + void Filled::combineCallback ( GLdouble coords[3], void* vertex_data[4], + GLfloat weight[4], void** out_data, + Filled* filled ) + { + (void)vertex_data; + (void)weight; + // std::cerr << "called combine" << std::endl; + VertexInfo* vertex = new VertexInfo( coords ); + *out_data = vertex; + filled->extraVertices().push_back( vertex ); + } + + void Filled::errorCallback ( GLenum error_code ) + { + std::cerr << "hmm. error during tessellation?:" << gluErrorString( error_code ) << std::endl; + } + +#ifndef OGLFT_NO_SOLID + Solid::Solid ( const char* filename, float point_size, FT_UInt resolution ) + : Filled( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Solid::Solid ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Filled( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Solid::Solid ( FT_Face face, float point_size, FT_UInt resolution ) + : Filled( face, point_size, resolution ) + { + init(); + } + + void Solid::init ( void ) + { + interface_.move_to = (FT_Outline_MoveTo_Func)moveToCallback; + interface_.line_to = (FT_Outline_LineTo_Func)lineToCallback; + interface_.conic_to = (FT_Outline_ConicTo_Func)conicToCallback; + interface_.cubic_to = (FT_Outline_CubicTo_Func)cubicToCallback; + interface_.shift = 0; + interface_.delta = 0; + + // Set up for extrusion. Default depth is 1 (units of what?) + extrusion_.depth_ = 1.; + extrusion_.up_[X] = 0.; + extrusion_.up_[Y] = 1.; + extrusion_.up_[Z] = 0.; + extrusion_.n_polyline_pts_ = N_POLYLINE_PTS; + + assign( extrusion_.point_array_[0], 0., 0., extrusion_.depth_ + 1. ); + assign( extrusion_.point_array_[1], 0., 0., extrusion_.depth_ ); + assign( extrusion_.point_array_[2], 0., 0., 0. ); + assign( extrusion_.point_array_[3], 0., 0., -1. ); + + // Turn on closed contours and smooth vertices; turn off end capping + + gleSetJoinStyle( TUBE_JN_RAW | TUBE_CONTOUR_CLOSED | TUBE_NORM_EDGE ); + } + + Solid::~Solid ( void ) + {} + + // Note: as usual, setting this clears the caches + + void Solid::setDepth ( double depth ) + { + if ( depth > 0. && depth != extrusion_.depth_ ) { + extrusion_.depth_ = depth; + + assign( extrusion_.point_array_[0], 0., 0., extrusion_.depth_ + 1. ); + assign( extrusion_.point_array_[1], 0., 0., extrusion_.depth_ ); + + clearCaches(); + } + } + + void Solid::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + FT_OutlineGlyph g; + + error = FT_Get_Glyph( face->glyph, (FT_Glyph*)&g ); + + if ( error != 0 ) + return; + + vector_scale_ = ( point_size_ * resolution_ ) / ( 72. * face->units_per_EM ); + + if ( character_rotation_.active_ ) { + glPushMatrix(); + + glTranslatef( ( face->glyph->metrics.width / 2. + + face->glyph->metrics.horiBearingX ) / 64. + * vector_scale_, + rotation_offset_y_, + 0. ); + + if ( character_rotation_.x_ != 0. ) + glRotatef( character_rotation_.x_, 1., 0., 0. ); + + if ( character_rotation_.y_ != 0. ) + glRotatef( character_rotation_.y_, 0., 1., 0. ); + + if ( character_rotation_.z_ != 0. ) + glRotatef( character_rotation_.z_, 0., 0., 1. ); + + glTranslatef( -( face->glyph->metrics.width / 2. + + face->glyph->metrics.horiBearingX ) / 64. + * vector_scale_, + -rotation_offset_y_, + 0. ); + } + + contour_open_ = false; + + // In theory, TrueType contours are defined clockwise and Type1 contours + // are defined counter-clockwise. Trust the flag set by FreeType to + // indicate this since it is critical to getting the orientation of the + // surface normals correct. + if ( g->outline.flags & ft_outline_reverse_fill ) { + extrusion_.normal_sign_.x_ = -1; + extrusion_.normal_sign_.y_ = 1; + } + else { + extrusion_.normal_sign_.x_ = 1; + extrusion_.normal_sign_.y_ = -1; + } + // The Big Kahuna: the FreeType glyph decomposition routine traverses + // the outlines of the font by calling the various routines stored in + // extrude_interface_. These in turn call the gleExtrusion routine. + + error = FT_Outline_Decompose( &g->outline, &interface_, this ); + + FT_Done_Glyph( (FT_Glyph)g ); + + // Some glyphs may be empty (the 'blank' for instance!) + + if ( contour_open_ ) { + extrusion_.contour_normals_.push_back( extrusion_.contour_normals_.front() ); + + gleExtrusion( extrusion_.contour_.size(), + &extrusion_.contour_.begin()->p_, + &extrusion_.contour_normals_[1].p_, + extrusion_.up_, + extrusion_.n_polyline_pts_, + extrusion_.point_array_, + 0 ); + + extrusion_.contour_.clear(); + extrusion_.contour_normals_.clear(); + } + + if ( character_rotation_.active_ ) { + glPopMatrix(); + } + + // Apply the front and back faces of the solid character (recall that + // drawing a character advances the MODELVIEW, so defend against that + // with the stack operations) + + glPushMatrix(); + depth_offset_ = 0.; + Filled::renderGlyph( face, glyph_index ); + glPopMatrix(); + + glPushMatrix(); + depth_offset_ = extrusion_.depth_; + Filled::renderGlyph( face, glyph_index ); + glPopMatrix(); + + // Drawing a character always advances the MODELVIEW. + + glTranslatef( face->glyph->advance.x / 64. * vector_scale_, + face->glyph->advance.y / 64. * vector_scale_, + 0. ); + + for ( VILI vili = vertices_.begin(); vili != vertices_.end(); vili++ ) + delete *vili; + + vertices_.clear(); + } + + int Solid::moveToCallback ( FT_Vector* to, Solid* solid ) + { + if ( solid->contour_open_ ) { + + // A word of explanation: since you can't predict when the + // contour is going to end (its end is signaled by calling this + // routine, i.e., the contour ends when another is started + // abruptly), only the lineTo and arcTo functions generate contour + // points. The upshot is that the normals, which are computed for the + // current segment, are one behind the segment described in the + // the contour array. To make things match up at the end, the first + // normal is copied to the end of the normal array and the extrusion + // routine is passed the list of normals starting at the second entry. + + solid->extrusion_.contour_normals_. + push_back( solid->extrusion_.contour_normals_.front() ); +#if 1 + gleExtrusion( solid->extrusion_.contour_.size(), + &solid->extrusion_.contour_.begin()->p_, + &solid->extrusion_.contour_normals_[1].p_, + solid->extrusion_.up_, + solid->extrusion_.n_polyline_pts_, + solid->extrusion_.point_array_, + 0 ); +#endif + solid->extrusion_.contour_.clear(); + solid->extrusion_.contour_normals_.clear(); + } + + solid->last_vertex_ = VertexInfo( to, solid->colorTess(), solid->textureTess() ); + + solid->contour_open_ = true; + + return 0; + } + + int Solid::lineToCallback ( FT_Vector* to, Solid* solid ) + { + VertexInfo vertex( to, solid->colorTess(), solid->textureTess() ); + + VertexInfo normal( solid->extrusion_.normal_sign_.y_ * + ( vertex.v_[Y] - solid->last_vertex_.v_[Y] ), + solid->extrusion_.normal_sign_.x_ * + ( vertex.v_[X] - solid->last_vertex_.v_[X] ) ); + + solid->last_vertex_ = vertex; + + vertex.v_[X] *= solid->vector_scale_; + vertex.v_[Y] *= solid->vector_scale_; + + normal.normalize(); + + solid->extrusion_.contour_.push_back( vertex ); + solid->extrusion_.contour_normals_.push_back( normal ); + + return 0; + } + + int Solid::conicToCallback ( FT_Vector* control, FT_Vector* to, Solid* solid ) + { + // This is crude: Step off conics with a fixed number of increments + + VertexInfo to_vertex( to, solid->colorTess(), solid->textureTess() ); + VertexInfo control_vertex( control, solid->colorTess(), solid->textureTess() ); + + double b[2], c[2], d[2], f[2], df[2], d2f[2]; + + b[X] = solid->last_vertex_.v_[X] - 2 * control_vertex.v_[X] + + to_vertex.v_[X]; + b[Y] = solid->last_vertex_.v_[Y] - 2 * control_vertex.v_[Y] + + to_vertex.v_[Y]; + + c[X] = -2 * solid->last_vertex_.v_[X] + 2 * control_vertex.v_[X]; + c[Y] = -2 * solid->last_vertex_.v_[Y] + 2 * control_vertex.v_[Y]; + + d[X] = solid->last_vertex_.v_[X]; + d[Y] = solid->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * solid->delta_ + b[X] * solid->delta2_; + df[Y] = c[Y] * solid->delta_ + b[Y] * solid->delta2_; + d2f[X] = 2 * b[X] * solid->delta2_; + d2f[Y] = 2 * b[Y] * solid->delta2_; + + for ( unsigned int i = 0; i < solid->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + VertexInfo vertex( f, solid->colorTess(), solid->textureTess() ); + + VertexInfo normal( solid->extrusion_.normal_sign_.y_ * df[Y], + solid->extrusion_.normal_sign_.x_ * df[X] ); + + vertex.v_[X] *= solid->vector_scale_; + vertex.v_[Y] *= solid->vector_scale_; + + normal.normalize(); + + solid->extrusion_.contour_.push_back( vertex ); + solid->extrusion_.contour_normals_.push_back( normal ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + } + + VertexInfo vertex( to, solid->colorTess(), solid->textureTess() ); + + VertexInfo normal( solid->extrusion_.normal_sign_.y_ * df[Y], + solid->extrusion_.normal_sign_.x_ * df[X] ); + + vertex.v_[X] *= solid->vector_scale_; + vertex.v_[Y] *= solid->vector_scale_; + + normal.normalize(); + + solid->extrusion_.contour_.push_back( vertex ); + solid->extrusion_.contour_normals_.push_back( normal ); + + solid->last_vertex_ = to_vertex; + + return 0; + } + + int Solid::cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Solid* solid ) + { + // This is crude: Step off cubics with a fixed number of increments + + VertexInfo to_vertex( to, solid->colorTess(), solid->textureTess() ); + VertexInfo control1_vertex( control1, solid->colorTess(), solid->textureTess() ); + VertexInfo control2_vertex( control2, solid->colorTess(), solid->textureTess() ); + + double a[2], b[2], c[2], d[2], f[2], df[2], d2f[2], d3f[2]; + + a[X] = -solid->last_vertex_.v_[X] + 3 * control1_vertex.v_[X] + -3 * control2_vertex.v_[X] + to_vertex.v_[X]; + a[Y] = -solid->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y] + -3 * control2_vertex.v_[Y] + to_vertex.v_[Y]; + + b[X] = 3 * solid->last_vertex_.v_[X] - 6 * control1_vertex.v_[X] + + 3 * control2_vertex.v_[X]; + b[Y] = 3 * solid->last_vertex_.v_[Y] - 6 * control1_vertex.v_[Y] + + 3 * control2_vertex.v_[Y]; + + c[X] = -3 * solid->last_vertex_.v_[X] + 3 * control1_vertex.v_[X]; + c[Y] = -3 * solid->last_vertex_.v_[Y] + 3 * control1_vertex.v_[Y]; + + d[X] = solid->last_vertex_.v_[X]; + d[Y] = solid->last_vertex_.v_[Y]; + + f[X] = d[X]; + f[Y] = d[Y]; + df[X] = c[X] * solid->delta_ + b[X] * solid->delta2_ + + a[X] * solid->delta3_; + df[Y] = c[Y] * solid->delta_ + b[Y] * solid->delta2_ + + a[Y] * solid->delta3_; + d2f[X] = 2 * b[X] * solid->delta2_ + 6 * a[X] * solid->delta3_; + d2f[Y] = 2 * b[Y] * solid->delta2_ + 6 * a[Y] * solid->delta3_; + d3f[X] = 6 * a[X] * solid->delta3_; + d3f[Y] = 6 * a[Y] * solid->delta3_; + + for ( unsigned int i = 0; i < solid->tessellation_steps_-1; i++ ) { + + f[X] += df[X]; + f[Y] += df[Y]; + + VertexInfo vertex( f, solid->colorTess(), solid->textureTess() ); + + VertexInfo normal( solid->extrusion_.normal_sign_.y_ * df[Y], + solid->extrusion_.normal_sign_.x_ * df[X] ); + + vertex.v_[X] *= solid->vector_scale_; + vertex.v_[Y] *= solid->vector_scale_; + + normal.normalize(); + + solid->extrusion_.contour_.push_back( vertex ); + solid->extrusion_.contour_normals_.push_back( normal ); + + df[X] += d2f[X]; + df[Y] += d2f[Y]; + d2f[X] += d3f[X]; + d2f[Y] += d3f[Y]; + } + + VertexInfo vertex( to, solid->colorTess(), solid->textureTess() ); + + VertexInfo normal( solid->extrusion_.normal_sign_.y_ * df[Y], + solid->extrusion_.normal_sign_.x_ * df[X] ); + + vertex.v_[X] *= solid->vector_scale_; + vertex.v_[Y] *= solid->vector_scale_; + + normal.normalize(); + + solid->extrusion_.contour_.push_back( vertex ); + solid->extrusion_.contour_normals_.push_back( normal ); + + solid->last_vertex_ = to_vertex; + + return 0; + } +#endif // OGLFT_NO_SOLID + + Texture::Texture ( const char* filename, float point_size, FT_UInt resolution ) + : Face( filename, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Texture::Texture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Face( data_base, data_size, point_size, resolution ) + { + if ( !isValid() ) return; + + init(); + } + + Texture::Texture ( FT_Face face, float point_size, FT_UInt resolution ) + : Face( face, point_size, resolution ) + { + init(); + } + + void Texture::init ( void ) + { + character_rotation_.active_ = false; + character_rotation_.x_ = 0; + character_rotation_.y_ = 0; + character_rotation_.z_ = 0; + + setCharSize(); + + setCharacterRotationReference( 'o' ); + } + + Texture::~Texture ( void ) + { + clearCaches(); + } + + // Note: Changing the character rotation also clears the display list cache. + + void Texture::setCharacterRotationX ( GLfloat character_rotation_x ) + { + if ( character_rotation_x != character_rotation_.x_ ) { + character_rotation_.x_ = character_rotation_x; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Texture::setCharacterRotationY ( GLfloat character_rotation_y ) + { + if ( character_rotation_y != character_rotation_.y_ ) { + character_rotation_.y_ = character_rotation_y; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Texture::setCharacterRotationZ ( GLfloat character_rotation_z ) + { + if ( character_rotation_z != character_rotation_.z_ ) { + character_rotation_.z_ = character_rotation_z; + + if ( character_rotation_.x_ != 0. || character_rotation_.y_ != 0. || + character_rotation_.z_ != 0. ) + character_rotation_.active_ = true; + else + character_rotation_.active_ = false; + + clearCaches(); + } + } + + void Texture::setCharSize ( void ) + { + for ( unsigned int f = 0; f < faces_.size(); f++ ) { + FT_Error error = FT_Set_Char_Size( faces_[f].face_, + (FT_F26Dot6)( point_size_ * 64 ), + (FT_F26Dot6)( point_size_ * 64 ), + resolution_, + resolution_ ); + if ( error != 0 ) + return; + } + + if ( rotation_reference_glyph_ != 0 ) + setRotationOffset(); + } + + void Texture::setRotationOffset ( void ) + { + FT_Error error = FT_Load_Glyph( rotation_reference_face_, + rotation_reference_glyph_, + FT_LOAD_RENDER ); + + if ( error != 0 ) + return; + + rotation_offset_y_ = rotation_reference_face_->glyph->bitmap.rows / 2.f; + } + + BBox Texture::measure ( unsigned char c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + return bbox; + } + + double Texture::height ( void ) const + { + if ( faces_[0].face_->height > 0 ) + return faces_[0].face_->height / 64.; + else + return faces_[0].face_->size->metrics.y_ppem; + } + +#ifndef OGLFT_NO_QT + + BBox Texture::measure ( const QChar c ) + { + BBox bbox; + // For starters, just get the unscaled glyph bounding box + unsigned int f; + FT_UInt glyph_index = 0; + + for ( f = 0; f < faces_.size(); f++ ) { + glyph_index = FT_Get_Char_Index( faces_[f].face_, c.unicode() ); + if ( glyph_index != 0 ) break; + } + + if ( glyph_index == 0 ) + return bbox; + + FT_Error error = FT_Load_Glyph( faces_[f].face_, glyph_index, + FT_LOAD_DEFAULT ); + if ( error != 0 ) + return bbox; + + FT_Glyph glyph; + error = FT_Get_Glyph( faces_[f].face_->glyph, &glyph ); + if ( error != 0 ) + return bbox; + + FT_BBox ft_bbox; + FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_unscaled, &ft_bbox ); + + FT_Done_Glyph( glyph ); + + bbox = ft_bbox; + bbox.advance_ = faces_[f].face_->glyph->advance; + + return bbox; + } +#endif /* OGLFT_NO_QT */ + GLuint Texture::compileGlyph ( FT_Face face, FT_UInt glyph_index ) + { + bindTexture( face, glyph_index ); + + GLuint dlist = glGenLists( 1 ); + glNewList( dlist, GL_COMPILE ); + + renderGlyph( face, glyph_index ); + + glEndList( ); + + return dlist; + } + + void Texture::renderGlyph ( FT_Face face, FT_UInt glyph_index ) + { + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + TextureInfo texture_info; + + GTOCI texture_object = glyph_texobjs_.find( glyph_index ); + + if ( texture_object == glyph_texobjs_.end() ) { + + bindTexture( face, glyph_index ); + + texture_object = glyph_texobjs_.find( glyph_index ); + + if ( texture_object == glyph_texobjs_.end() ) + return; + } + + texture_info = texture_object->second; + + glBindTexture( GL_TEXTURE_2D, texture_info.texture_name_ ); + + if ( character_rotation_.active_ ) { + glPushMatrix(); + glTranslatef( ( texture_info.width_ / 2.f + + texture_info.left_bearing_ ), + rotation_offset_y_, 0.f ); + + if ( character_rotation_.x_ != 0. ) + glRotatef( character_rotation_.x_, 1.f, 0.f, 0.f ); + + if ( character_rotation_.y_ != 0. ) + glRotatef( character_rotation_.y_, 0.f, 1.f, 0.f ); + + if ( character_rotation_.z_ != 0. ) + glRotatef( character_rotation_.z_, 0.f, 0.f, 1.f ); + + glTranslatef( -( texture_info.width_ / 2.f + + texture_info.left_bearing_ ), + -rotation_offset_y_, 0.f ); + } + + glBegin( GL_QUADS ); + + glTexCoord2i( 0, 0 ); + glVertex2i( texture_info.left_bearing_, texture_info.bottom_bearing_ ); + + glTexCoord2f( texture_info.texture_s_, 0.f ); + glVertex2i( texture_info.left_bearing_ + texture_info.width_, + texture_info.bottom_bearing_ ); + + glTexCoord2f( texture_info.texture_s_, texture_info.texture_t_ ); + glVertex2i( texture_info.left_bearing_ + texture_info.width_, + texture_info.bottom_bearing_ + texture_info.height_ ); + + glTexCoord2f( 0.f, texture_info.texture_t_ ); + glVertex2i( texture_info.left_bearing_, + texture_info.bottom_bearing_ + texture_info.height_ ); + + glEnd(); + + if ( character_rotation_.active_ ) { + glPopMatrix(); + } + + // Drawing a character always advances the MODELVIEW. + glTranslatef( texture_info.advance_.x / 64.f, + texture_info.advance_.y / 64.f, + 0. ); + } + + void Texture::clearCaches ( void ) + { + GDLI fgi = glyph_dlists_.begin(); + + for ( ; fgi != glyph_dlists_.end(); ++fgi ) { + glDeleteLists( fgi->second, 1 ); + } + + glyph_dlists_.clear(); + + GTOI fti = glyph_texobjs_.begin(); + + for ( ; fti != glyph_texobjs_.end(); ++fti ) { + glDeleteTextures( 1, &fti->second.texture_name_ ); + } + + glyph_texobjs_.clear(); + } + + unsigned int Texture::nearestPowerCeil ( unsigned int a ) + { + unsigned int b = a; + unsigned int c = 1; + + if ( a == 0 ) return 1; + + // Take the log-2 of a + for ( ; ; ) { + if ( b == 1 ) + break; + + else if ( b == 3 ) { + c *= 4; + break; + } + + b >>= 1; + c *= 2; + } + // If it's too small, raise it another power + if ( c < a ) c *= 2; + + return c; + } + + MonochromeTexture::MonochromeTexture ( const char* filename, float point_size, + FT_UInt resolution ) + : Texture( filename, point_size, resolution ) + {} + + MonochromeTexture::MonochromeTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Texture( data_base, data_size, point_size, resolution ) + {} + + MonochromeTexture::MonochromeTexture ( FT_Face face, float point_size, + FT_UInt resolution ) + : Texture( face, point_size, resolution ) + {} + + MonochromeTexture::~MonochromeTexture ( void ) + {} + + // Round up the size of the image to a power of two, but otherwise + // use the bitmap as is (i.e., don't expand it into separate + // luminance and alpha components) + + GLubyte* MonochromeTexture::invertBitmap ( const FT_Bitmap& bitmap, + int* width, int* height ) + { + *width = nearestPowerCeil( bitmap.width ); + *height = nearestPowerCeil( bitmap.rows ); + + GLubyte* inverse = new GLubyte[ ( *width + 7) / 8 * *height ]; + GLubyte* inverse_ptr = inverse; + + memset( inverse, 0, sizeof( GLubyte )*( *width + 7 ) / 8 * *height ); + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < bitmap.pitch; p++ ) { + + *inverse_ptr++ = *bitmap_ptr++; + } + + inverse_ptr += ( ( *width + 7 ) / 8 - bitmap.pitch ); + } + + return inverse; + } + + // Hmm. This is the only routine which is different between the different + // styles. + + void MonochromeTexture::bindTexture ( FT_Face face, FT_UInt glyph_index ) + { + GTOCI texobj = glyph_texobjs_.find( glyph_index ); + + if ( texobj != glyph_texobjs_.end() ) + return; + + // Retrieve the glyph's data. + + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + error = FT_Render_Glyph( face->glyph, ft_render_mode_mono ); + + if ( error != 0 ) + return; + + TextureInfo texture_info; + + glGenTextures( 1, &texture_info.texture_name_ ); + glBindTexture( GL_TEXTURE_2D, texture_info.texture_name_ ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + // Texture maps have be a power of 2 in size (is 1 a power of 2?), so + // pad it out while flipping it over + int width, height; + GLubyte* inverted_pixmap = + invertBitmap( face->glyph->bitmap, &width, &height ); + + GLfloat red_map[2] = { background_color_[R], foreground_color_[R] }; + GLfloat green_map[2] = { background_color_[G], foreground_color_[G] }; + GLfloat blue_map[2] = { background_color_[B], foreground_color_[B] }; + GLfloat alpha_map[2] = { background_color_[A], foreground_color_[A] }; + + glPixelMapfv( GL_PIXEL_MAP_I_TO_R, 2, red_map ); + glPixelMapfv( GL_PIXEL_MAP_I_TO_G, 2, green_map ); + glPixelMapfv( GL_PIXEL_MAP_I_TO_B, 2, blue_map ); + glPixelMapfv( GL_PIXEL_MAP_I_TO_A, 2, alpha_map ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, + 0, GL_COLOR_INDEX, GL_BITMAP, inverted_pixmap ); + + // Save a good bit of the data about this glyph + texture_info.left_bearing_ = face->glyph->bitmap_left; + texture_info.bottom_bearing_ = -( face->glyph->bitmap.rows + - face->glyph->bitmap_top ); + texture_info.width_ = face->glyph->bitmap.width; + texture_info.height_ = face->glyph->bitmap.rows; + texture_info.texture_s_ = (GLfloat)texture_info.width_ / width; + texture_info.texture_t_ = (GLfloat)texture_info.height_ / height; + texture_info.advance_ = face->glyph->advance; + + glyph_texobjs_[ glyph_index ] = texture_info; + + delete[] inverted_pixmap; + } + + GrayscaleTexture::GrayscaleTexture ( const char* filename, float point_size, + FT_UInt resolution ) + : Texture( filename, point_size, resolution ) + {} + + GrayscaleTexture::GrayscaleTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Texture( data_base, data_size, point_size, resolution ) + {} + + GrayscaleTexture::GrayscaleTexture ( FT_Face face, float point_size, + FT_UInt resolution ) + : Texture( face, point_size, resolution ) + {} + + GrayscaleTexture::~GrayscaleTexture ( void ) + {} + + // For the grayscale style, the luminance is the grayscale FreeType value, + // so this just rounds up to a power of two and inverts the pixmap + + GLubyte* GrayscaleTexture::invertPixmap ( const FT_Bitmap& bitmap, + int* width, int* height ) + { + *width = nearestPowerCeil( bitmap.width ); + *height = nearestPowerCeil( bitmap.rows ); + + GLubyte* inverse = new GLubyte[ *width * *height ]; + GLubyte* inverse_ptr = inverse; + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < bitmap.width; p++ ) { + *inverse_ptr++ = *bitmap_ptr++; + } + + inverse_ptr += ( *width - bitmap.pitch ); + } + return inverse; + } + + // Hmm. This is the only routine which is different between the different + // styles. + + void GrayscaleTexture::bindTexture ( FT_Face face, FT_UInt glyph_index ) + { + GTOCI texobj = glyph_texobjs_.find( glyph_index ); + + if ( texobj != glyph_texobjs_.end() ) + return; + + // Retrieve the glyph's data. + + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + error = FT_Render_Glyph( face->glyph, ft_render_mode_normal ); + + if ( error != 0 ) + return; + + TextureInfo texture_info; + + glGenTextures( 1, &texture_info.texture_name_ ); + glBindTexture( GL_TEXTURE_2D, texture_info.texture_name_ ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + // Texture maps have be a power of 2 in size (is 1 a power of 2?), so + // pad it out while flipping it over + int width, height; + GLubyte* inverted_pixmap = + invertPixmap( face->glyph->bitmap, &width, &height ); + + glPushAttrib( GL_PIXEL_MODE_BIT ); + glPixelTransferf( GL_RED_SCALE, foreground_color_[R] - background_color_[R] ); + glPixelTransferf( GL_GREEN_SCALE, foreground_color_[G]-background_color_[G] ); + glPixelTransferf( GL_BLUE_SCALE, foreground_color_[B]-background_color_[B] ); + glPixelTransferf( GL_ALPHA_SCALE, foreground_color_[A]-background_color_[A] ); + glPixelTransferf( GL_RED_BIAS, background_color_[R] ); + glPixelTransferf( GL_GREEN_BIAS, background_color_[G] ); + glPixelTransferf( GL_BLUE_BIAS, background_color_[B] ); + glPixelTransferf( GL_ALPHA_BIAS, background_color_[A] ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, + 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, inverted_pixmap ); + + glPopAttrib(); + // Save a good bit of the data about this glyph + texture_info.left_bearing_ = face->glyph->bitmap_left; + texture_info.bottom_bearing_ = -( face->glyph->bitmap.rows + - face->glyph->bitmap_top ); + texture_info.width_ = face->glyph->bitmap.width; + texture_info.height_ = face->glyph->bitmap.rows; + texture_info.texture_s_ = (GLfloat)texture_info.width_ / width; + texture_info.texture_t_ = (GLfloat)texture_info.height_ / height; + texture_info.advance_ = face->glyph->advance; + + glyph_texobjs_[ glyph_index ] = texture_info; + + delete[] inverted_pixmap; + } + + TranslucentTexture::TranslucentTexture ( const char* filename, float point_size, + FT_UInt resolution ) + : Texture( filename, point_size, resolution ) + {} + + TranslucentTexture::TranslucentTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size, FT_UInt resolution ) + : Texture( data_base, data_size, point_size, resolution ) + {} + + TranslucentTexture::TranslucentTexture ( FT_Face face, float point_size, + FT_UInt resolution ) + : Texture( face, point_size, resolution ) + {} + + TranslucentTexture::~TranslucentTexture ( void ) + {} + + // For the translucent style, the luminance is saturated and alpha value + // is the translucent FreeType value + + GLubyte* TranslucentTexture::invertPixmap ( const FT_Bitmap& bitmap, + int* width, int* height ) + { + *width = nearestPowerCeil( bitmap.width ); + *height = nearestPowerCeil( bitmap.rows ); + + GLubyte* inverse = new GLubyte[ 2 * *width * *height ]; + GLubyte* inverse_ptr = inverse; + + for ( int r = 0; r < bitmap.rows; r++ ) { + + GLubyte* bitmap_ptr = &bitmap.buffer[bitmap.pitch * ( bitmap.rows - r - 1 )]; + + for ( int p = 0; p < bitmap.width; p++ ) { + *inverse_ptr++ = 0xff; + *inverse_ptr++ = *bitmap_ptr++; + } + + inverse_ptr += 2 * ( *width - bitmap.pitch ); + } + return inverse; + } + + // Hmm. This is the only routine which is different between the different + // styles. + + void TranslucentTexture::bindTexture ( FT_Face face, FT_UInt glyph_index ) + { + GTOCI texobj = glyph_texobjs_.find( glyph_index ); + + if ( texobj != glyph_texobjs_.end() ) + return; + + // Retrieve the glyph's data. + + FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT ); + + if ( error != 0 ) + return; + + error = FT_Render_Glyph( face->glyph, ft_render_mode_normal ); + + if ( error != 0 ) + return; + + TextureInfo texture_info; + + glGenTextures( 1, &texture_info.texture_name_ ); + glBindTexture( GL_TEXTURE_2D, texture_info.texture_name_ ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + // Texture maps have be a power of 2 in size (is 1 a power of 2?), so + // pad it out while flipping it over + int width, height; + GLubyte* inverted_pixmap = + invertPixmap( face->glyph->bitmap, &width, &height ); + + glPushAttrib( GL_PIXEL_MODE_BIT ); + glPixelTransferf( GL_RED_SCALE, foreground_color_[R] - background_color_[R] ); + glPixelTransferf( GL_GREEN_SCALE, foreground_color_[G]-background_color_[G] ); + glPixelTransferf( GL_BLUE_SCALE, foreground_color_[B]-background_color_[B] ); + glPixelTransferf( GL_ALPHA_SCALE, foreground_color_[A]-background_color_[A] ); + glPixelTransferf( GL_RED_BIAS, background_color_[R] ); + glPixelTransferf( GL_GREEN_BIAS, background_color_[G] ); + glPixelTransferf( GL_BLUE_BIAS, background_color_[B] ); + glPixelTransferf( GL_ALPHA_BIAS, background_color_[A] ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, + 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, inverted_pixmap ); + + glPopAttrib(); + + // Save a good bit of the data about this glyph + texture_info.left_bearing_ = face->glyph->bitmap_left; + texture_info.bottom_bearing_ = -( face->glyph->bitmap.rows + - face->glyph->bitmap_top ); + texture_info.width_ = face->glyph->bitmap.width; + texture_info.height_ = face->glyph->bitmap.rows; + texture_info.texture_s_ = (GLfloat)texture_info.width_ / width; + texture_info.texture_t_ = (GLfloat)texture_info.height_ / height; + texture_info.advance_ = face->glyph->advance; + + glyph_texobjs_[ glyph_index ] = texture_info; + + delete[] inverted_pixmap; + } + +} // close OGLFT namespace diff --git a/engine/libraries/oglft/liboglft/OGLFT.h.cmake b/engine/libraries/oglft/liboglft/OGLFT.h.cmake new file mode 100644 index 0000000..ab686d6 --- /dev/null +++ b/engine/libraries/oglft/liboglft/OGLFT.h.cmake @@ -0,0 +1,2321 @@ +// -*- c++ -*- +/* + * OGLFT: A library for drawing text with OpenGL using the FreeType library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id: OGLFT.h.cmake 107 2008-04-25 09:29:24Z brevilo $ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +#ifndef OGLFT_H +#define OGLFT_H + +// CMake activates these definitions. +#cmakedefine ENABLE_QT +#cmakedefine ENABLE_GLE +#cmakedefine GLU_TESS_CALLBACK_TRIPLEDOT +#cmakedefine HAVE_OPENGL_DIR +// Convert to our old options. +#if !defined(ENABLE_QT) +#define OGLFT_NO_QT +#endif +#if !defined(ENABLE_GLE) +#define OGLFT_NO_SOLID +#endif + +#include +#include +#include +#include + +#ifdef WIN32 +#include +#endif + +#ifdef HAVE_OPENGL_DIR +#include +#include +#else +#include +#include +#endif + +#ifndef OGLFT_NO_SOLID +#ifdef HAVE_OPENGL_DIR +#include +#else +#include +#endif +#endif + +#ifndef OGLFT_NO_QT +#define OGLFT_QT_VERSION @DESIRED_QT_VERSION@ +#if OGLFT_QT_VERSION == 3 +#include +#include +#elif OGLFT_QT_VERSION == 4 +#include +#include +#endif +#endif + +#include +#include FT_FREETYPE_H +#include FT_GLYPH_H +#include FT_OUTLINE_H +#include FT_TRIGONOMETRY_H + +#ifdef _MSC_VER +#ifdef OGLFT_BUILD +#define OGLFT_API __declspec(dllexport) +#else +#define OGLFT_API __declspec(dllimport) +#endif +#else +#define OGLFT_API +#endif + +//! All of OGLFT C++ objects are in this namespace. + +namespace OGLFT { + + //! Thanks to DesCartes, I'd consider these manifest constants. + enum Coordinates { + X, //!< The X component of space + Y, //!< The Y component of space + Z, //!< The Z component of space + W //!< The projection component of space + }; + + //! Who to credit? Newton? I'd consider these manifest constants. + enum ColorSpace { + R, //!< The Red component of a color + G, //!< The Green component of a color + B, //!< The Blue component of a color + A, //!< The Alpha (or transparency) of a color + }; + + //! Callback from GLU tessellation routines. +#ifdef GLU_TESS_CALLBACK_TRIPLEDOT + typedef GLvoid (*GLUTessCallback)(...); +#else + typedef GLvoid (*GLUTessCallback)(); +#endif + + //! The FreeType library instance. + /*! + * The FreeType library has a single, global instance of a library + * handle. This reference is used to load font faces. This detail + * is generally hidden from the user of OGLFT, however, it + * can be useful to get the FT_Library instance if you want to open + * a font file yourself, either from disk or embedded in the program. + */ + class Library { + public: + /*! + * The FreeType library's library handle is only available through this + * accessor method. + * \return the global OGLFT FreeType library handle. + */ + static OGLFT_API FT_Library& instance ( void ); + + protected: + /*! + * The constructor for this class is automatically called when + * this library is loaded. Access the instance through the instance() + * method. + */ + OGLFT_API Library ( void ); + /*! + * This destructor is automatically called when the program exits. + */ + OGLFT_API ~Library( void ); + + private: + static Library library; + static FT_Library library_; + }; + + //! Advance describes the "advance" of a glyph, namely the distance in + //! model space at which the NEXT glyph should be drawn. This class exists + //! to assist the computation of string metrics. + struct OGLFT_API Advance { + float dx_; //!< Advance increment in the X direction. + float dy_; //!< Advance increment in the Y direction. + + //! Default constructor. An otherwise uninitialized Advance contains zeros. + Advance ( float dx = 0, float dy = 0 ) : dx_( dx ), dy_( dy ) + {} + + //! Initialize an advance from a FreeType advance member. + Advance ( FT_Vector v ) + { + dx_ = v.x / 64.f; + dy_ = v.y / 64.f; + } + + //! Increment Advance with a FreeType advance member. + //! \return a reference to oneself. + Advance& operator+= ( const FT_Vector v ) + { + dx_ += v.x / 64.f; + dy_ += v.y / 64.f; + return *this; + } + }; + + //! Describe the metrics of a glyph or string relative to the origin + //! of the first character + struct OGLFT_API BBox { + float x_min_; //!< The left-most position at which "ink" appears. + float y_min_; //!< the bottom-most position at which "ink" appears. + float x_max_; //!< The right-most position at which "ink" appears. + float y_max_; //!< The top-most position at which "ink" appears. + Advance advance_; //!< The (total) advancement + + //! Default constructor is all zeros. + BBox () : x_min_( 0 ), y_min_( 0 ), x_max_( 0 ), y_max_( 0 ) + {} + + /*! + *(Partially) initialize a BBox from a FreeType bounding box member. + *(The advancement is initialized to zero by its default constructor). + * \param ft_bbox a FreeType bounding box as retrieved from + * \c FT_Glyph_Get_CBox. + */ + BBox ( FT_BBox ft_bbox ) + { + x_min_ = ft_bbox.xMin / 64.f; + y_min_ = ft_bbox.yMin / 64.f; + x_max_ = ft_bbox.xMax / 64.f; + y_max_ = ft_bbox.yMax / 64.f; + } + + //! Scale the bounding box by a constant. + //! \param k a constant to scale the bounding box by. + //! \return a reference to oneself. + BBox& operator*= ( float k ) + { + x_min_ *= k; + y_min_ *= k; + x_max_ *= k; + y_max_ *= k; + advance_.dx_ *= k; + advance_.dy_ *= k; + + return *this; + } + + /*! + * Merge a bounding box into the current one (not really addition). + * Each time a BBox is "added", the current BBox is expanded to include + * the metrics of the new BBox. May only work for horizontal fonts, though. + * \param b the bounding box to merge. + * \return a reference to oneself. + */ + BBox& operator+= ( const BBox& b ) + { + float new_value; + + new_value = b.x_min_ + advance_.dx_; + if ( new_value < x_min_ ) x_min_ = new_value; + + new_value = b.y_min_ + advance_.dy_; + if ( new_value < y_min_ ) y_min_ = new_value; + + new_value = b.x_max_ + advance_.dx_; + if ( new_value > x_max_ ) x_max_ = new_value; + + new_value = b.y_max_ + advance_.dy_; + if ( new_value > y_max_ ) y_max_ = new_value; + + advance_.dx_ += b.advance_.dx_; + advance_.dy_ += b.advance_.dy_; + + return *this; + } + }; + + //! During tesselation of a polygonal Face (outline, filled or solid), + //! an object which implements this interface can be used to compute a + //! different color for each vertex. + class OGLFT_API ColorTess { + public: + virtual ~ColorTess ( void ) {} + //! Compute a color for this position. Note that the position is + //! in the glyph's local coordinate system. + //! \param p vertex position in glyph's local coordinate system. Argument is + //! a GLdouble[3]. + //! \return GLfloat[4] (RGBA) color specification. + virtual GLfloat* color ( GLdouble* p ) = 0; + }; + + //! During tesselation of a polygonal Face (outline, filled or solid), + //! an object which implements this interface can be used to compute a + //! different texture coordinate for each vertex. + class OGLFT_API TextureTess { + public: + virtual ~TextureTess ( void ) {} + //! Compute a texture coordinate for this position. Note that the + //! position is in the glyph's local coordinate system. + //! \param p vertex position in glyph's local coordinate system. Argument is + //! a GLdouble[3]. + //! \return GLfloat[2] (s,t) texture coordinates. + virtual GLfloat* texCoord ( GLdouble* p ) = 0; + }; + + //! The argument to setCharacterDisplayLists is an STL vector of + //! OpenGL display list names (GLuints). + typedef std::vector DisplayLists; + + //! A convenience definition of an iterator for display list vectors. + typedef DisplayLists::const_iterator DLCI; + + //! A convenience definition of an iterator for display list vectors. + typedef DisplayLists::iterator DLI; + + //! A face (aka font) used to render text with OpenGL. + /*! + * This is an abstract class, but it does define most the functions that + * you are likely to call to manipulate the rendering of the text. + */ + class Face { + public: + //! Thanks to the standard formerly known as PHIGS. Horizontal text + //! justification constants. + enum OGLFT_API HorizontalJustification { + LEFT, //!< Left justified justification of text + ORIGIN, //!< Natural origin alignment of text (default) + CENTER, //!< Center justified alignment of text + RIGHT //!< Right justified alignment of text + }; + + //! Thanks to the standard formerly known as PHIGS. Vertical text + //! justification constants. + enum OGLFT_API VerticalJustification { + BOTTOM, //!< Descender alignment of text + BASELINE, //!< Baseline alignment of text (default) + MIDDLE, //!< Centered alignment of text + TOP //!< Ascender justification of text + }; + + //! Control how OpenGL display lists are created for individual glyphs. + //! The default mode is to create display lists for each glyph as it + //! is requested. Therefore, the Face drawing routines cannot themselves + //! be called from within an open display list. In IMMEDIATE mode, + //! cached glyphs will be drawn if available, otherwise the FreeType + //! data for a glyph is re-rendered each time. + enum OGLFT_API GlyphCompileMode { + COMPILE, //!< Compile new glyphs when seen for the first time. + IMMEDIATE //!< Do not \em create display lists for glyphs. + }; + + private: + //! We allow a Face to be constructed either from a file name + //! or passed in as an already opened FreeType FT_Face. In the case + //! of the later (already opened), we don't close the FT_Face on + //! destruction. This way you can share FT_Faces between related + //! OGLFT faces. Also, we're experimenting with being able to use + //! multiple FT_Faces in a single OGLFT Face, so this is represented + //! as a data structure. + struct FaceData { + FT_Face face_; + bool free_on_exit_; + FaceData ( FT_Face face, bool free_on_exit = true ) + : face_( face ), free_on_exit_( free_on_exit ) + {} + }; + protected: + //! The FreeType face - experimentally, this is now an array of + //! faces so that we can handle a wider range of UNICODE points + //! in case a face doesn't cover the points of interest. + std::vector< FaceData > faces_; + + //! Did a font load OK? + bool valid_; + + //! Glyph display list creation mode. + enum GlyphCompileMode compile_mode_; + + //! Nominal point size. + float point_size_; + + //! Display resolution in pixels per inch. + FT_UInt resolution_; + + //! Does rendering text affect the MODELVIEW matrix? + bool advance_; + + //! Foreground color (I really wanted to avoid this, but not really + //! possible without state queries, which you can't put into + //! display lists. Anyway, you'll be able to get even more fancy + //! by passing in a function to map the color with, so why balk at + //! this?) + GLfloat foreground_color_[4]; + + //! Background color (what modes would use this?) + GLfloat background_color_[4]; + + //! PHIGS-like horizontal positioning of text. + enum HorizontalJustification horizontal_justification_; + + //! PHIGS-like vertical positioning of text. + enum VerticalJustification vertical_justification_; + + //! Rotate an entire string in the Z plane + GLfloat string_rotation_; + + //! Let the user decide which character to use as the rotation reference. + //! Use "o" by default, I suppose. + FT_UInt rotation_reference_glyph_; + + //! The rotation reference character could be in any face. + FT_Face rotation_reference_face_; + + //! These are the translation offsets provided by the rotation reference + //! character; for whom, we've discovered, only the Y position is relevant. + GLfloat rotation_offset_y_; + + //! Type of the cache of defined glyph to display list mapping. + typedef std::map< FT_UInt, GLuint > GlyphDLists; + + //! A convenience definition of the iterator over the glyph to display + //! list map. + typedef GlyphDLists::const_iterator GDLCI; + + //! A convenience definition of the iterator over the glyph to display + //! list map. + typedef GlyphDLists::iterator GDLI; + + //! Cache of defined glyph display lists + GlyphDLists glyph_dlists_; + + //! The user can supply an array of display list which are invoked + //! before each glyph is rendered. + DisplayLists character_display_lists_; + + public: + /*! + * Construct a Face by loading a font from the given file. + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Construct a Face by loading a font from the given memory location. + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Alternatively, the user may have already opened a face and just + * wants to draw with it. This is useful for Multiple Master fonts or + * combining multiple files to increase UNICODE point coverage. + * \param face open Freetype FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + Face ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * Deleting a Face frees its FreeType face (and anything else it's + * styles have allocated). + */ + virtual ~Face ( void ); + + /*! + * Let the user test to see if the font was loaded OK. + * \return true if the FT_Face was successfully created. + */ + bool isValid ( void ) const { return valid_; } + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes a filename and takes ownership of the FT_Face. + * \param filename name of file containing font face data. + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( const char* filename ); + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes a memory location and takes ownership of the FT_Face. + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( const FT_Byte* data_base, const FT_Long data_size ); + + /*! + * Add another FT_Face to the OGLFT Face. Generally used to add more + * coverage of UNICODE points (at least that's the plan). This + * routine takes an already open FT_Face. The user is responsible + * for clean up. + * \param face open FreeType FT_Face + * \return true if face was successfully added. + */ + bool addAuxiliaryFace ( FT_Face face ); + + /*! + * By default, each time a new character is seen, its glyph is rendered + * into a display list. This means that a display list cannot already + * be open (since OpenGL doesn't allow nested display list creation). + * Rendering can be set into immediate mode in which case glyphs are + * rendered from display lists if available, but are otherwise generated + * anew each time. + * \param compile_mode the new compile mode. + */ + void setCompileMode ( enum GlyphCompileMode compile_mode ) + { + compile_mode_ = compile_mode; + } + + /*! + * \return the current glyph compile mode. + */ + enum GlyphCompileMode compileMode ( void ) const { return compile_mode_; } + + /*! + * For the rasterized styles (Monochrome, Grayscale, Translucent, Texture), + * glyphs are rendered at the pixel size given by: + * + * point_size [pts] * / 72 [pts/in] * resolution [dots/in] = [dots]. + * + * For the polygon styles (Outline, Filled, Solid), the "nominal" size of + * the glyphs is: + * + * point_size[pts] / 72 [pts/in] * resolution [dots/in] + * / units_per_EM [font unit/EM] = [dots * EM]. + * + * If the MODELVIEW and PROJECTION matrices are such that one screen pixel + * corresponds to one modeling unit, then polygonal Faces will + * be the same size as raster Faces. + * + * Note that changing the point size after Face creation will invalidate + * the cache of OpenGL display lists and any other information which + * the individual styles have cached. + * \param point_size the new point size in points (1/72-th inch). + */ + void setPointSize ( float point_size ); + + /*! + * \return the current point size. + */ + float pointSize ( void ) { return point_size_; } + + /*! + * For the rasterized styles (Monochrome, Grayscale, + * Translucent, Texture), the exact rendered size of the glyphs depends on + * the resolution of the display (as opposed to the polygon styles + * whose size is controlled by the viewing matrices). The Texture + * style is slightly different because the glyphs are texture-mapped + * onto an arbitrary rectangle; here, the resolution only controls + * how accurately the glyph is rendered. + * \param resolution the resolution in DPI (dots per inch). + */ + void setResolution ( FT_UInt resolution ); + + /*! + * \return the current raster resolution. + */ + FT_UInt resolution ( void ) { return resolution_; } + + /*! + * If advance is true, then the changes made to the MODELVIEW matrix + * to render a string are allowed to remain. Otherwise, the library + * pushes the current MODELVIEW matrix onto the matrix stack, renders + * the string and then pops it off again. Rendering a character always + * modifies the MODELVIEW matrix. + * \param advance whether or not the MODELVIEW matrix should be left + * translated by the advancement of a rendered string. + */ + void setAdvance ( bool advance ) { advance_ = advance; } + + /*! + * \return the advance value. + */ + bool advance ( void ) const { return advance_; } + + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param red the red component of the foreground color. + * \param green the green component of the foreground color. + * \param blue the blue component of the foreground color. + * \param alpha the alpha component of the foreground color. + */ + void setForegroundColor ( GLfloat red = 0.0, + GLfloat green = 0.0, + GLfloat blue = 0.0, + GLfloat alpha = 1.0 ); + + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param foreground_color an array of 4 values corresponding to the + * red, green, blue and alpha components of the foreground color. + */ + void setForegroundColor ( const GLfloat foreground_color[4] ); +#ifndef OGLFT_NO_QT + /*! + * This is the nominal color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the foreground + * color invalidates the glyph cache. + * \param foreground_color the foreground color as an unsigned int. + */ + void setForegroundColor ( const QRgb foreground_color ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the red component of the foreground color + */ + GLfloat foregroundRed ( void ) const { return foreground_color_[R]; } + /*! + * \return the green component of the foreground color + */ + GLfloat foregroundGreen ( void ) const { return foreground_color_[G]; } + /*! + * \return the blue component of the foreground color + */ + GLfloat foregroundBlue ( void ) const { return foreground_color_[B]; } + /*! + * \return the alpha component of the foreground color + */ + GLfloat foregroundAlpha ( void ) const { return foreground_color_[A]; } + + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param red the red component of the background color. + * \param green the green component of the background color. + * \param blue the blue component of the background color. + * \param alpha the alpha component of the background color. + */ + void setBackgroundColor ( GLfloat red = 1.0, + GLfloat green = 1.0, + GLfloat blue = 1.0, + GLfloat alpha = 0.0 ); + + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param background_color an array of 4 values corresponding to the + * red, green, blue and alpha components of the background color. + */ + void setBackgroundColor ( const GLfloat background_color[4] ); +#ifndef OGLFT_NO_QT + /*! + * This is the nominal background color of the glyphs. A lot of other things + * can alter what you actually see! Note that changing the background + * color invalidates the glyph cache. + * \param background_color the background color as an unsigned int. + */ + void setBackgroundColor ( const QRgb background_color ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the red component of the background color + */ + GLfloat backgroundRed ( void ) const { return background_color_[R]; } + /*! + * \return the green component of the background color + */ + GLfloat backgroundGreen ( void ) const { return background_color_[G]; } + /*! + * \return the blue component of the background color + */ + GLfloat backgroundBlue ( void ) const { return background_color_[B]; } + /*! + * \return the alpha component of the background color + */ + GLfloat backgroundAlpha ( void ) const { return background_color_[A]; } + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of z rotation. + */ + virtual void setCharacterRotationZ ( GLfloat character_rotation_z ) = 0; + + /*! + * \return the character rotation in the Z direction. + */ + virtual GLfloat characterRotationZ ( void ) const = 0; + + /*! + * The z rotation angle needs a center. Nominate a character whose + * center is to be the center of rotation. By default, use "o". + * \param c rotation reference character. + */ + void setCharacterRotationReference ( unsigned char c ); + + /*! + * Rotate an entire string through the given angle (in the Z plane only). + * (Somewhat pointless for the vector styles since you can do mostly + * the same thing with the MODELVIEW transform, however, for what its + * worth, this routine uses the FreeType rotation function to compute + * the "proper" metrics for glyph advance.) + * \param string_rotation angle in degrees of z rotation. + */ + void setStringRotation ( GLfloat string_rotation ); + + /*! + * \return the (Z plane) string rotation angle. + */ + GLfloat stringRotation ( void ) const { return string_rotation_; } + + /*! + * Set the horizontal justification. + * \param horizontal_justification the new horizontal justification. + */ + void setHorizontalJustification ( enum HorizontalJustification + horizontal_justification ) + { + horizontal_justification_ = horizontal_justification; + } + + /*! + * \return the horizontal justification. + */ + enum HorizontalJustification horizontalJustification ( void ) const + { return horizontal_justification_; } + + /*! + * Set the vertical justification. + * \param vertical_justification the new vertical justification + */ + void setVerticalJustification ( enum VerticalJustification + vertical_justification ) + { + vertical_justification_ = vertical_justification; + } + + /*! + * \return the vertical justification. + */ + enum VerticalJustification verticaljustification ( void ) + const { return vertical_justification_; } + + /*! + * Specify an OpenGL display list to be invoked before + * each character in a string. Face makes a copy of the argument. Pass + * an empty DisplayLists to disable this feature. + * \param character_display_lists STL vector containing a display + * list to invoke before each glyph in a string is drawn. + */ + void setCharacterDisplayLists ( const DisplayLists& character_display_lists ) + { + character_display_lists_ = character_display_lists; + } + + /*! + * \return a reference to the array of character display lists. This is + * the live list as stored in the Face. + */ + DisplayLists& characterDisplayLists ( void ) + { return character_display_lists_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + virtual double height ( void ) const = 0; + + /*! + * Compute the bounding box info for a character. + * \param c the (latin1) character to measure. + * \return the bounding box of c. + */ + virtual BBox measure ( unsigned char c ) = 0; +#ifndef OGLFT_NO_QT + /*! + * Compute the bounding box info for a character. + * \param c the (UNICODE) character to measure. + * \return the bounding box of c. + */ + virtual BBox measure ( const QChar c ) = 0; +#endif /* OGLFT_NO_QT */ + /*! + * Compute the bounding box info for a string. + * \param s the (latin1) string to measure. + * \return the bounding box of s. + */ + virtual BBox measure ( const char* s ); + /*! + * Compute the bounding box info for a string without conversion + * to modeling coordinates. + * \param s the (latin1) string to measure. + * \return the bounding box of s. + */ + virtual BBox measureRaw ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Compute the bounding box info for a string. + * \param s the (UNICODE) string to measure. + * \return the bounding box of s. + */ + virtual BBox measure ( const QString& s ); + /*! + * Compute the bounding box info for a real number formatted as specified. + * \param format (see draw for valid formats) + * \param number real number. + * \return the bounding box of the formatted number. + */ + virtual BBox measure ( const QString& format, double number ); + /*! + * Compute the bounding box info for a string without conversion + * to modeling coordinates. + * \param s the (UNICODE) string to measure. + * \return the bounding box of s. + */ + virtual BBox measureRaw ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Compile a string into an OpenGL display list for later + * rendering. Essentially, the string is rendered at the origin + * of the current MODELVIEW. Note: no other display lists should + * be open when this routine is called. Also, the Face does not + * keep track of these lists, so you must delete them in order + * to recover the memory. + * \param s the (latin1) string to compile. + * \return the display list name for the string. + */ + GLuint compile ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Compile a string into an OpenGL display list for later + * rendering. Essentially, the string is rendered at the origin + * of the current MODELVIEW. Note: no other display lists should + * be open when this routine is called. Also, the Face does not + * keep track of these lists, so you must delete them in order + * to recover the memory. + * \param s the (UNICODE) string to compile. + * \return the display list name for the string. + */ + GLuint compile ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Compile a single character (glyph) into an OpenGL display list + * for later rendering. The Face \em does keep track of these + * display lists, so do not delete them. + * \param c the (latin1) character to compile. + * \return the display list name for the character. + */ + GLuint compile ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Compile a single character (glyph) into an OpenGL display list + * for later rendering. The Face \em does keep track of these + * display lists, so do not delete them. + * \param c the (UNICODE) character to compile. + * \return the display list name for the character. + */ + GLuint compile ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw a (latin1) string using the current MODELVIEW matrix. If + * advance is true, then the final glyph advance changes to the + * MODELVIEW matrix are left in place. + * \param s the (latin1) string to draw. + */ + void draw ( const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Draw a (UNICODE) string using the current MODELVIEW + * matrix. If advance is true, then the final glyph advance + * changes to the MODELVIEW matrix are left in place. + * \param s the (UNICODE) string to draw. + */ + void draw ( const QString& s ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw the character using the current MODELVIEW matrix. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw a + * string if you don't want the MODELVIEW matrix changed. + * \param c the (latin1) character to draw. + */ + void draw ( unsigned char c ); + +#ifndef OGLFT_NO_QT + /*! + * Draw the character using the current MODELVIEW matrix. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw a + * string if you don't want the MODELVIEW matrix changed. + * \param c the (UNICODE) character to draw. + */ + void draw ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw the (latin1) character at the given 2D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param c the (latin1) character to draw. + */ + void draw ( GLfloat x, GLfloat y, unsigned char c ); + /*! + * Draw the (latin1) character at the given 3D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param c the (latin1) character to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Draw the (UNICODE) character at the given 2D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param c the (UNICODE) character to draw. + */ + void draw ( GLfloat x, GLfloat y, QChar c ); + /*! + * Draw the (UNICODE) character at the given 3D point. Note that + * the MODELVIEW matrix is modified by the glyph advance. Draw + * a string if you don't want the MODELVIEW matrix changed. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param c the (UNICODE) character to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Draw a string at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param s the (latin1) string to draw. + */ + void draw ( GLfloat x, GLfloat y, const char* s ); + /*! + * Draw a string at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param s the (latin1) string to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const char* s ); +#ifndef OGLFT_NO_QT + /*! + * Draw a string at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param s the (UNICODE) string to draw. + */ + void draw ( GLfloat x, GLfloat y, const QString& s ); + /*! + * Draw a string at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param s the (UNICODE) string to draw. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const QString& s ); + /*! + * Draw a real number per the given format at the given 2D point. + * \param x the X position. + * \param y the Y position. + * \param format Like a typical printf format. Regular text is printed + * while a '%' introduces the real number's format. Includes the + * following format flags: + * \li %%x.yf - floating point in field width x and precision y + * \li %%x.ye - scientific notation in field width x and precision y + * \li %%x.yg - pick best floating or scientific in field width x and + * precision y + * \li %%p - draw as a proper fraction, e.g. 1 1/2. Note: this currently + * requires a special font which encodes glyphs to be drawn for the + * numerator and demoninator in the UNICODE Private Area (0xE000). + * + * \param number the numeric value. + */ + void draw ( GLfloat x, GLfloat y, const QString& format, double number ); + /*! + * Draw a real number per the given format at the given 3D point. + * \param x the X position. + * \param y the Y position. + * \param z the Z position. + * \param format Like a typical printf format. Regular text is printed + * while a '%' introduces the real number's format. Includes the + * following format flags: + * \li %%x.yf - floating point in field width x and precision y + * \li %%x.ye - scientific notation in field width x and precision y + * \li %%x.yg - pick best floating or scientific in field width x and + * precision y + * \li %%p - draw as a proper fraction, e.g. 1 1/2. Note: this currently + * requires a special font which encodes glyphs to be drawn for the + * numerator and demoninator in the UNICODE Private Area (0xE000). + * + * \param number the numeric value. + */ + void draw ( GLfloat x, GLfloat y, GLfloat z, const QString& format, + double number ); +#endif /* OGLFT_NO_QT */ + /*! + * \return the face ascender, in point units. + */ + int ascender ( void ); + + /*! + * \return the face descender, in point units. + */ + int descender ( void ); + + protected: + // The various styles override these routines + + //! Some styles, in particular the Texture, need specialized steps + //! to compile a glyph into an OpenGL display list. + //! \param face the FT_Face containing the glyph. + //! \param glyph_index the index of the glyph in face. + //! \return the display list of the compiled glyph. + virtual GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ) = 0; + + //! Each style implements its own glyph rendering routine. + //! \param face the FT_Face containing the glyph. + //! \param glyph_index the index of the glyph in face. + virtual void renderGlyph ( FT_Face face, FT_UInt glyph_index ) = 0; + + //! There is a slight different between the way in which the polygonal + //! and raster styles select the character size for FreeType to generate. + virtual void setCharSize ( void ) = 0; + + //! The different styles have different caching needs (well, really only + //! the texture style currently has more than the display list cache). + virtual void clearCaches ( void ) = 0; + + //! The polygonal and raster styles compute different values for the + //! Z rotation offset. (It's in integer pixels for the raster styles and + //! in floating point pixels for the polygonal styles.) + virtual void setRotationOffset ( void ) = 0; + + private: + void init ( void ); + BBox measure_nominal ( const char* s ); +#ifndef OGLFT_NO_QT + BBox measure_nominal ( const QString& s ); + QString format_number ( const QString& format, double number ); +#endif /* OGLFT_NO_QT */ + }; + + //! This is the base class of the polygonal styles: outline, filled and solid. + /*! + * In the polygonal styles, the detailed geometric outlines of the glyphs + * are extracted from the font file and rendered as polygons. + */ + class Polygonal : public Face { + protected: + //! Angle of rotation of characters relative to text orientation. + struct { + bool active_; + GLfloat x_, y_, z_; + } character_rotation_; + + //! The tessellation of curves is pretty crude; regardless of length, + //! use the same number of increments (and as near as I can tell, this + //! is more than sufficient unless the glyph takes up the whole screen). + unsigned int tessellation_steps_; + + //! When curves are tessellated, we use the forward difference algorithm + //! from Foley and van Dam for parametric curves (pg. 511 of 2nd Ed. in C). + //! So, the step size, delta, is in the parametric variable which is always + //! on the interval [0,1]. Therefore, delta = 1/tessellation_steps + double delta_, delta2_, delta3_; + + //! For vector rendition modes, FreeType is allowed to generate the + //! lines and arcs at the original face definition resolution. To + //! get to the proper glyph size, the vertices are scaled before + //! they're passed to the GLU tessellation routines. + float vector_scale_; + + //! Callbacks for FreeType glyph decomposition into outlines + FT_Outline_Funcs interface_; + + //! Default number of steps to break TrueType and Type1 arcs into. + //! (Note: this looks good to me, anyway) + static const unsigned int DEFAULT_TESSELLATION_STEPS = 4; + + /*! + * VertexInfo is a private class which is used by the decomposition and + * tessellation routines to store the vertices and other data of the glyph's + * outline. Because of the "impedance mismatch" between the crazy + * 26.6 fixed point format of the FreeType library (well, don't + * blame them; look at what they have to work with) and OpenGL's preference + * for double precision, this simple vector has two constructors: one + * for 26.6 format and one for direct floating point. + * + * VertexInfo also contains (optional) pointers to objects which + * implement the ColorTess and TextureTess interfaces. + */ + struct VertexInfo { + double v_[3]; //!< Why is this double precision? Because the second + //!< argument to the routine gluTessVertex is a pointer + //!< to an array of doubles. Otherwise, we could use + //!< single precision everywhere. + + //! The user can provide a ColorTess object which computes a color + //! for each tesselated vertex. + ColorTess* color_tess_; + + //! The user can provide a TextureTess object which computes texture + //! coordinates for each tesselated vertex. + TextureTess* texture_tess_; + + //! Default constructor just initializes Vertex to zero. + //! \param color_tess optional color tesselation object. + //! \param texture_tess optional texture tesselation object. + VertexInfo ( ColorTess* color_tess = 0, TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = v_[Y] = v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a point in a FreeType contour. + * \param ft_v a FreeType FT_Vector, normally passed into the + * the decomposition callbacks. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( FT_Vector* ft_v, ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = (double)( ft_v->x / 64 ) + (double)( ft_v->x % 64 ) / 64.; + v_[Y] = (double)( ft_v->y / 64 ) + (double)( ft_v->y % 64 ) / 64.; + v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a 2D point. + * \param p 2D array of doubles. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( double p[2], ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = p[X]; + v_[Y] = p[Y]; + v_[Z] = 0.; + } + + /*! + * Construct a Vertex from a 2D point. + * \param x the X coordinate. + * \param y the Y coordinate. + * \param color_tess optional color tesselation object. + * \param texture_tess optional texture tesselation object. + */ + VertexInfo ( double x, double y, ColorTess* color_tess = 0, + TextureTess* texture_tess = 0 ) + : color_tess_( color_tess ), texture_tess_( texture_tess ) + { + v_[X] = x; + v_[Y] = y; + v_[Z] = 0.; + } + + //! Treat the Vertex like a vector: Normalize its length in the + //! usual way. + void normalize ( void ) + { + double length = sqrt( v_[X] * v_[X] + v_[Y] * v_[Y] + v_[Z] * v_[Z] ); + v_[X] /= length; + v_[Y] /= length; + v_[Z] /= length; + } + }; + + /*! + * Buffers the last control point as the outline of a glyph is + * decomposed. + */ + VertexInfo last_vertex_; + + //! Normally, we will consider a list of vertices. + typedef std::list< VertexInfo* > VertexInfoList; + + //! A convenience definition of the iterator over the list of vertices. + typedef VertexInfoList::const_iterator VILCI; + + //! A convenience definition of the iterator over the list of vertices. + typedef VertexInfoList::iterator VILI; + + /*! + * As curves are decomposed out of the glyph, their vertices are passed + * along to the GLU tessellation functions. These vertices have to + * hang around until gluTessContourEnd is called. + */ + VertexInfoList vertices_; + + //! As GLU tessellation proceeds, new contours open with every call + //! to moveTo. + bool contour_open_; + + //! The user can provide a ColorTess object which computes a color + //! for each tesselated vertex. + ColorTess* color_tess_; + + //! The user can provide a TextureTess object which computes texture + //! coordinates for each tesselated vertex. + TextureTess* texture_tess_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100); + + /*! + * \param face open Freetype FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Polygonal ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The Polygonal destructor doesn't do anything in particular. + */ + OGLFT_API virtual ~Polygonal ( void ); + + /*! + * TrueType and Type1 files describe the boundaries of glyphs with + * quadratic and cubic curves, respectively. Since OpenGL can only really + * draw straight lines, these curves have to be tessellated. The + * number of steps used is fixed for all glyphs in the face, + * but can be changed through this method. Other notes: This value is + * only applicable for Outline, Filled and Solid styles. Changing this value + * invalidates any cached display lists for glyphs in this face. + * + * \param tessellation_steps the number of steps to tessellate each curved + * segment of a glyph outline. + */ + OGLFT_API void setTessellationSteps ( unsigned int tessellation_steps ); + + /*! + * \return the number of steps used to tessellate curves in the + * polygonal font types. + */ + OGLFT_API unsigned int tessellationSteps ( void ) const { return tessellation_steps_; } + + /*! + * Set the individual character rotation in the X direction. + * \param character_rotation_x angle in degrees of the X rotation. + */ + OGLFT_API void setCharacterRotationX ( GLfloat character_rotation_x ); + + /*! + * Set the individual character rotation in the Y direction. + * \param character_rotation_y angle in degrees of the Y rotation. + */ + OGLFT_API void setCharacterRotationY ( GLfloat character_rotation_y ); + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of the Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + + /*! + * \return the character rotation in the X direction. + */ + OGLFT_API GLfloat characterRotationX ( void ) const { return character_rotation_.x_; } + + /*! + * \return the character rotation in the Y direction. + */ + OGLFT_API GLfloat characterRotationY ( void ) const { return character_rotation_.y_; } + + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_.z_; } + + /*! + * Set an optional color tesselation object. Each tesselated vertex + * is passed to this object, which returns a color for that position + * in space. + * \param color_tess the color tesselation object. + */ + OGLFT_API void setColorTess ( ColorTess* color_tess ); + /*! + * \return the color tesselation object. + */ + OGLFT_API ColorTess* colorTess ( void ) const { return color_tess_; } + /*! + * Set an optional texture coordinate tesselation object. Each + * tessellated vertex is passed to this object, which returns + * texture coordinates for that position in space. + * \param texture_tess the texture coordinate tesselation object. + */ + OGLFT_API void setTextureTess ( TextureTess* texture_tess ); + /*! + * \return the texture coordinate tesselation object. + */ + OGLFT_API TextureTess* textureTess ( void ) const { return texture_tess_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a polygonal face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a polygonal face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ) + { return Face::measure( format, number ); } +#endif /* OGLFT_NO_QT */ + + private: + void init ( void ); + void setCharSize ( void ); + void setRotationOffset ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + protected: + void clearCaches ( void ); + }; + + //! Render text as a polygon outline. + /*! + * \image html outline_class.png + * Text is drawn as an outline of each glyph. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to a given size. Usually the outline is drawn in the foreground + * color, however, you can specify a ColorTess object to provide a color + * for each vertex individually. You can also use + * the per-glyph display list functionality to alter the attributes + * of each glyph. + * + * The only complexity to this style is selecting the point size. Since + * the outlines are drawn as a polygon, they are subject to the MODELVIEW + * transformation. The point size is nominally chosen to be the same as a + * raster image generated at the given resolution. Some experimentation + * with point size and resolution may be necessary to achieve the desired + * results. + */ + class Outline : public Polygonal { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Outline ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + ~Outline ( void ); + private: + void init ( void ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + static int moveToCallback ( FT_Vector* to, Outline* outline ); + static int lineToCallback ( FT_Vector* to, Outline* outline ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Outline* outline ); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Outline* outline ); + }; + + //! Render text as a filled polygons. + /*! + * \image html filled_class.png + * Each glyph is drawn as a filled polygon. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to the given size. Then the GLU tessellation routines are used + * to tessellate the contours into polygons (well, triangles). By default, + * these are drawn in GL_FILL polygon mode, but any other polygon mode + * can be specified. + * + * Usually, the polygons are drawn only in the + * foreground color, however, you may supply ColorTess and TextureTess + * objects which can alter the color or texture coordinates of each + * vertex individually. You can also use + * the per-glyph display list functionality to alter the attributes + * of each glyph. + * + * The only complexity to this style is selecting the point size. Since + * the glyphs are drawn as polygons, they are subject to the viewing and + * modeling transformations. The point size is nominally chosen to be the same + * as a raster image generated at the given resolution. Some experimentation + * with point size and resolution may be necessary to achieve the desired + * results. + */ + class Filled : public Polygonal { + //! 3D tessellation of glyphs is accomplished through the standard GLU + //! routines + GLUtesselator* tess_obj_; + + //! A place to store any extra vertices generated by the Combine callback + VertexInfoList extra_vertices_; + + protected: + //! Offset the glyph in the Z direction. Solely for the Solid subclass. + //! Until I can figure out how to shift the glyph outside the context + //! of this class, I guess this has got to stay (but it is redundant + //! to extrusion_.depth_) + GLfloat depth_offset_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Filled ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor deletes the GLU tessellation object allocated in + * in the constructor. + */ + OGLFT_API virtual ~Filled ( void ); + + /*! + * \return the list of extra vertices created by the GLU tessellation + * combine callback. + */ + OGLFT_API VertexInfoList& extraVertices ( void ) { return extra_vertices_; } + + protected: + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + private: + void init ( void ); + static int moveToCallback ( FT_Vector* to, Filled* filled ); + static int lineToCallback ( FT_Vector* to, Filled* filled ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Filled* filled); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Filled* filled ); + static void vertexCallback ( VertexInfo* vertex ); + static void beginCallback ( GLenum which ); + static void endCallback ( void ); + static void combineCallback ( GLdouble coords[3], void* vertex_data[4], + GLfloat weight[4], void** out_data, + Filled* filled ); + static void errorCallback ( GLenum error_code ); + }; + +#ifndef OGLFT_NO_SOLID + //! Render text as solid letters. + /*! + * \image html solid_class.png + * Each glyph is drawn as a closed solid. The contours are extracted + * from the font file through FreeType. FreeType is used to scale the + * contours to the given size. The contours are passed to the GLE + * tubing and extrusion library to create the sides of the solid. + * Then the GLU tessellation routines are used + * to tessellate the contours into polygons which are used to cap the sides. + * + * Currently, the solids are drawn only in the foreground color. However, + * proper surface normals are computed so that the solids may be lighted. + * Eventually, you'll be able to supply a color/texture + * coordinate function to make glyphs more interesting. Note that you can use + * the per-glyph display list functionality to alter each glyph individually. + * + * Another TODO item is to improve the interaction with GLE. Currently, + * you can only create block solids. Eventually, we'll have the capability + * add bevels and rounds to the edges of the solids and maybe even more + * general extrusions (like, for example, the swooshing letters in the title + * sequence of the Salkind's 1978 "Superman" movie). + * + * The only complexity to this style is selecting the point size. Since + * the glyphs are drawn as a collection of polygons, they are subject to the + * viewing and modeling transformations. The point size is nominally chosen + * to be the same as a raster image generated at the given resolution. + * Some experimentation with point size and resolution may be necessary to + * achieve the desired results. + */ + class Solid : public Filled { + private: + + //! Callbacks for FreeType glyph decomposition into outlines (note: this + //! has the same name as the variable in Polygonal, but it is distinct since + //! the routines for the GLE contouring are different from the Filled + //! GLU tessellation routines. This may be too confusing?) + FT_Outline_Funcs interface_; + + //! For now, you can only get block extruded solids + static const unsigned int N_POLYLINE_PTS = 4; + + //! Data for the gleExtrusion routine + struct glePoint2D { + double p_[2]; + glePoint2D ( double p[2] ) { p_[X] = p[X]; p_[Y] = p[Y]; } + glePoint2D ( double x, double y ) { p_[X] = x; p_[Y] = y; } + glePoint2D ( const VertexInfo& v ) { p_[X] = v.v_[X]; p_[Y] = v.v_[Y]; } + }; + + //! Collect all the output from GLE in one of these structures. + struct { + double depth_; + struct { + int x_, y_; + } normal_sign_; + std::vector< glePoint2D > contour_; + std::vector< glePoint2D > contour_normals_; + gleDouble up_[3]; + int n_polyline_pts_; + gleDouble point_array_[N_POLYLINE_PTS][3]; + } extrusion_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Solid ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Solid ( void ); + /*! + * Set the thickness of the solid + * \param depth thickness of the solid in model units. + */ + OGLFT_API void setDepth ( double depth ); + + /*! + * \return the solid extrusion depth. + */ + OGLFT_API double depth ( void ) const { return extrusion_.depth_; } + + private: + // It would be nice if C/C++ had real matrix notation (like Perl!) + void assign ( gleDouble a[3], double x, double y, double z ) + { + a[X] = x; + a[Y] = y; + a[Z] = z; + } + + void init ( void ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + static int moveToCallback ( FT_Vector* to, Solid* solid ); + static int lineToCallback ( FT_Vector* to, Solid* solid ); + static int conicToCallback ( FT_Vector* control, FT_Vector* to, Solid* solid ); + static int cubicToCallback ( FT_Vector* control1, FT_Vector* control2, + FT_Vector* to, Solid* solid ); + }; +#endif /* OGLFT_NO_SOLID */ + //! This is the base class of the raster styles: bitmap, grayscale and + //! translucent. + /*! + * In the raster styles, FreeType's rasterizer is used to generate raster + * images of each glyph. + */ + class Raster : public Face { + protected: + //! Raster glyph can be rotated in the Z plane (in addition to the string + //! rotation). + GLfloat character_rotation_z_; + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( const char* filename, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Raster ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API virtual ~Raster ( void ); + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_z_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a raster face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a raster face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ); +#endif /* OGLFT_NO_QT */ + + private: + void init ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + void setCharSize ( void ); + void setRotationOffset ( void ); + void clearCaches ( void ); + }; + + //! Render text as a monochrome raster image. + /*! + * \image html monochrome_class.png + * This is more or less the standard way in which text is intended to + * be rendered in OpenGL. It uses the \c glBitmap call to draw a sequence + * of monochrome bitmaps. Since FreeType is capable of rotating glyphs + * created from faces based on vector outlines, you can rotate (in the Z plane) + * both the text string as well as the individual characters in the string. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for monochrome glyphs to be rendered properly. + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Monochrome : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param font open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Monochrome ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Monochrome ( void ); + private: + GLubyte* invertBitmap ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as a grayscale raster image. + /*! + * \image html grayscale_class.png + * The Grayscale style is similar to the Monochrome style. FreeType is used + * to rasterize a glyph and this is then drawn on the screen using + * \c glDrawPixels. The FreeType rasterization is done in anti-aliased mode. + * When Grayscale draws the glyph image, the resulting text is blended + * smoothly from the foreground color to the background color. The background + * of the glyph is opaque, so this style works best over a solid background. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for grayscale glyphs to be rendered properly. + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Grayscale : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Grayscale ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Grayscale ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as a translucent raster image. + /*! + * \image html translucent_class.png + * The Translucent style is similar to the Grayscale style. FreeType is used + * to rasterize a glyph and this is then drawn on the screen using + * \c glDrawPixels. The FreeType rasterization is done in anti-aliased mode. + * When Translucent draws the glyph image, the grayscale levels provided + * by FreeType are used as Alpha values in the raster image. This allows + * the glyphs to be smoothly blended into complicated backgrounds. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for translucent glyphs to be rendered properly. + * Additionally, you need to activate blending in order to achieve the + * translucent effect: + * \code + * glEnable( GL_BLEND ); + * glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + * \endcode + * + * Another note: It is helpful to have the option + * \c GL_RASTER_POSITION_UNCLIPPED_IBM available if you intend to draw text + * at MODELVIEW based positions, otherwise if the initial text position is off + * the screen, the entire image is clipped. + */ + class Translucent : public Raster { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Translucent ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The destructor doesn't do anything in particular. + */ + OGLFT_API ~Translucent ( void ); + + private: + GLubyte* invertPixmapWithAlpha ( const FT_Bitmap& bitmap ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + }; + + //! This is the base class of the texture style. + class Texture : public Face { + protected: + //! Angle of rotation of characters relative to text orientation. + struct { + bool active_; //!< Is character rotation non-zero? (faster than checking all + //!< the other values.) + GLfloat x_, //!< Angle of rotation in the X direction. + y_, //!< Angle of rotation in the Y direction. + z_; //!< Angle of rotation in the Z direction. + } character_rotation_; + + /*! + * The textured glyphs need a little bit more infrastructure to draw + * since we have to remember the size of the texture object itself + * (at least implicitly). Also, we don't want to create any more + * texture objects than we have to, so they are always cached. + */ + struct TextureInfo { + GLuint texture_name_; //!< A bound texture name is an integer in OpenGL. + FT_Int left_bearing_, //!< The left bearing of the transformed glyph. + bottom_bearing_; //!< The bottom bearing of the transformed glyph. + int width_, //!< The 2**l width of the texture. + height_; //!< The 2**m height of the texture. + GLfloat texture_s_, //!< The fraction of the texture width occupied + //!< by the glyph. + texture_t_; //!< The fraction of the texture height occupied + //!< by the glyph. + FT_Vector advance_; //!< The advance vector of the transformed glyph. + }; + + //! Type of the cache of defined glyph to texture objects mapping. + typedef std::map< FT_UInt, TextureInfo > GlyphTexObjs; + + //! A convenience definition of the iterator over the glyph to texture + //! object map. + typedef GlyphTexObjs::const_iterator GTOCI; + + //! A convenience definition of the iterator over the glyph to texture + //! object map. + typedef GlyphTexObjs::iterator GTOI; + + //! Cache of defined glyph texture objects. + GlyphTexObjs glyph_texobjs_; + + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API Texture ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * The texture destructor doesn't really do anything. + */ + OGLFT_API virtual ~Texture ( void ); + /*! + * Set the individual character rotation in the X direction. + * \param character_rotation_x angle in degrees of X rotation. + */ + OGLFT_API void setCharacterRotationX ( GLfloat character_rotation_x ); + + /*! + * Set the individual character rotation in the Y direction. + * \param character_rotation_y angle in degrees of Y rotation. + */ + OGLFT_API void setCharacterRotationY ( GLfloat character_rotation_y ); + + /*! + * Set the individual character rotation in the Z direction. + * \param character_rotation_z angle in degrees of Z rotation. + */ + OGLFT_API void setCharacterRotationZ ( GLfloat character_rotation_z ); + + /*! + * \return the character rotation in the X direction. + */ + OGLFT_API GLfloat characterRotationX ( void ) const { return character_rotation_.x_; } + + /*! + * \return the character rotation in the Y direction. + */ + OGLFT_API GLfloat characterRotationY ( void ) const { return character_rotation_.y_; } + + /*! + * \return the character rotation in the Z direction. + */ + OGLFT_API GLfloat characterRotationZ ( void ) const { return character_rotation_.z_; } + + /*! + * \return the height (i.e., line spacing) at the current character size. + */ + OGLFT_API double height ( void ) const; + + /*! + * Implement measuring a character in a texture face. + * \param c the (latin1) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( unsigned char c ); +#ifndef OGLFT_NO_QT + /*! + * Implement measuring a character in a texture face. + * \param c the (UNICODE) character to measure + * \return the bounding box of c. + */ + OGLFT_API BBox measure ( const QChar c ); +#endif /* OGLFT_NO_QT */ + /*! + * Measure a string of characters. Note: currently, this merely + * calls Face's measure routine. + * \param s string of (latin1) characters to measure + * \return the bounding box of s. + */ + OGLFT_API BBox measure ( const char* s ) { return Face::measure( s ); } +#ifndef OGLFT_NO_QT + OGLFT_API BBox measure ( const QString& s ) + { return Face::measure( s ); } + + /*! + * Implement measuring a formatted number + * \param format the format string + * \param number to value to format + * \return the bounding box of the formatted number + */ + OGLFT_API BBox measure ( const QString& format, double number ) + { return Face::measure( format, number ); } +#endif /* OGLFT_NO_QT */ + + protected: + /*! + * OpenGL texture maps have to be a power of 2 in width and height (including + * apparently 1 = 2**0 ). This function returns the next higher power of + * 2 of the argument. If the argument is already a power of 2, you just + * get that back. + * \param a width or height of an image. + * \return value of a rounded to nearest, higher power of 2. + */ + unsigned int nearestPowerCeil ( unsigned int a ); + /*! + * This is all that distinguishes the various texture styles. Each subclass + * defines this method as appropriate. Once the texture is bound, it + * is rendered the same in all cases. + * \param face FT_Face containing the glyph to render. + * \param glyph_index index of glyph in face. + */ + virtual void bindTexture ( FT_Face face, FT_UInt glyph_index ) = 0; + + private: + void init ( void ); + void setCharSize ( void ); + void setRotationOffset ( void ); + GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ); + void renderGlyph ( FT_Face face, FT_UInt glyph_index ); + void clearCaches ( void ); + }; + + //! Render text as texture mapped monochrome quads. + /*! + * \image html texture_monochrome_class.png + * This style is similar to the Monochrome raster style, except instead + * of using \c glBitmap to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Monochrome. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do take up more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + */ + class MonochromeTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API MonochromeTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The monochrome texture destructor doesn't really do anything. + */ + OGLFT_API ~MonochromeTexture ( void ); + private: + GLubyte* invertBitmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as texture mapped grayscale quads. + /*! + * \image html texture_grayscale_class.png + * This style is similar to the Grayscale raster style, except instead + * of using \c glDrawPixels to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Grayscale. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do consume more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + */ + class GrayscaleTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API GrayscaleTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The grayscale texture destructor doesn't really do anything. + */ + OGLFT_API ~GrayscaleTexture ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; + + //! Render text as texture mapped translucent quads. + /*! + * \image html texture_translucent_class.png + * This style is similar to the Translucent raster style, except instead + * of using \c glDrawPixels to draw the raster image, the image is used + * as a texture map on a quad. If drawing is confined to the Z plane, + * then you will see no difference between this style and Translucent. + * However, because the quad is a 3D object, it can be transformed + * by the usual modeling operations; so, texture mapped glyphs can be + * rotated in the X and Y directions as well as Z direction. Also, + * if the viewing (or modeling) transformation has a non-unity scale or + * shear, the glyphs will also be scaled or sheared (unlike the raster + * styles). Also, there is no problem with clipping glyphs which lie + * off the screen; texture mapped quads are properly clipped to the + * screen boundary. + * + * If this is not convincing enough, the performance of texture mapped + * glyphs is generally as good as or better than the equivalent + * raster style (especially with hardware texture acceleration). However, + * they do consume more memory space. + * + * Note: you \em must call + * \code + * glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + * \endcode + * before drawing in order for textured glyphs to be rendered properly. + * Additionally, you need to activate blending in order to achieve the + * translucent effect: + * \code + * glEnable( GL_BLEND ); + * glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + * \endcode + */ + class TranslucentTexture : public Texture { + public: + /*! + * \param filename the filename which contains the font face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( const char* filename, float point_size = 12, + FT_UInt resolution = 100 ); + + /*! + * \param data_base the memory location (base pointer) which contains the font face. + * \param data_size the size (in bytes) of the font data found at \ref data_base. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( const FT_Byte* data_base, const FT_Long data_size, + float point_size = 12, FT_UInt resolution = 100 ); + + /*! + * \param face open FreeType FT_Face. + * \param point_size the initial point size of the font to generate. A point + * is essentially 1/72th of an inch. Defaults to 12. + * \param resolution the pixel density of the display in dots per inch (DPI). + * Defaults to 100 DPI. + */ + OGLFT_API TranslucentTexture ( FT_Face face, float point_size = 12, + FT_UInt resolution = 100 ); + /*! + * The translucent texture destructor doesn't really do anything. + */ + OGLFT_API ~TranslucentTexture ( void ); + private: + GLubyte* invertPixmap ( const FT_Bitmap& bitmap, int* width, int* height ); + void bindTexture ( FT_Face face, FT_UInt glyph_index ); + }; +} // Close OGLFT namespace +#endif /* OGLFT_H */ diff --git a/engine/libraries/oglft/tests/CMakeLists.txt b/engine/libraries/oglft/tests/CMakeLists.txt new file mode 100644 index 0000000..cc85304 --- /dev/null +++ b/engine/libraries/oglft/tests/CMakeLists.txt @@ -0,0 +1,117 @@ +FIND_PACKAGE( GLUT ) + +LINK_LIBRARIES( oglft ${FREETYPE2_LIBRARIES}) + +INCLUDE_DIRECTORIES( ${PROJECT_BINARY_DIR} ) +INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR} ) +INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR} ) +INCLUDE_DIRECTORIES( ${FREETYPE2_INCLUDE_DIR} + ${FREETYPE2_INCLUDE_DIR}/freetype2 + ) +INCLUDE_DIRECTORIES( ${GLUT_INCLUDE_DIR} ) +IF( ENABLE_QT ) +IF( DESIRED_QT_VERSION EQUAL 3) + INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ) + LINK_LIBRARIES( oglft ${FREETYPE2_LIBRARIES} ${QT_LIBRARIES} ) +ELSEIF( DESIRED_QT_VERSION EQUAL 4 ) + INCLUDE_DIRECTORIES( ${QT_QTCORE_INCLUDE_DIR} ) + INCLUDE_DIRECTORIES( ${QT_QTGUI_INCLUDE_DIR} ) + INCLUDE_DIRECTORIES( ${QT_QTOPENGL_INCLUDE_DIR} ) + LINK_LIBRARIES( oglft ${FREETYPE2_LIBRARIES} ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ) +ENDIF( DESIRED_QT_VERSION EQUAL 3) +ENDIF( ENABLE_QT ) + +ADD_EXECUTABLE( + tutorial1 + tutorial1.cpp +) + +TARGET_LINK_LIBRARIES( + tutorial1 + ${GLUT_LIBRARIES} +) + +ADD_EXECUTABLE( + tutorial2 + tutorial2.cpp +) + +TARGET_LINK_LIBRARIES( + tutorial2 + ${GLUT_LIBRARIES} +) + +ADD_EXECUTABLE( + tutorial3 + tutorial3.cpp +) + +TARGET_LINK_LIBRARIES( + tutorial3 + ${GLUT_LIBRARIES} +) + +ADD_EXECUTABLE( + tutorial3 + tutorial3.cpp +) + +TARGET_LINK_LIBRARIES( + tutorial3 + ${GLUT_LIBRARIES} +) + +ADD_EXECUTABLE( + demo + demo.cpp +) + +TARGET_LINK_LIBRARIES( + demo + ${GLUT_LIBRARIES} +) + +ADD_EXECUTABLE( + demo2 + demo2.cpp +) + +TARGET_LINK_LIBRARIES( + demo2 + ${GLUT_LIBRARIES} +) + +IF( ENABLE_QT ) +IF( DESIRED_QT_VERSION EQUAL 3 ) +KDE3_AUTOMOC( demo3.cpp speedtest.cpp ) +ELSEIF( DESIRED_QT_VERSION EQUAL 4 ) +QT4_AUTOMOC( demo3.cpp speedtest.cpp ) +ENDIF( DESIRED_QT_VERSION EQUAL 3 ) +ADD_EXECUTABLE( + demo3 + demo3.cpp +) + +TARGET_LINK_LIBRARIES( + demo3 + ${OPENGL_LIBRARIES} +) + +ADD_EXECUTABLE( + speedtest + speedtest.cpp +) + +TARGET_LINK_LIBRARIES( + speedtest + ${OPENGL_LIBRARIES} +) +ENDIF( ENABLE_QT ) + +# Copy some files needed by demo3 into the tests directory. +FILE( GLOB images *.png ) +FOREACH( test_png ${images} ) + GET_FILENAME_COMPONENT( png_file ${test_png} NAME ) + CONFIGURE_FILE( ${test_png} + "${CMAKE_CURRENT_BINARY_DIR}/${png_file}" COPYONLY ) +ENDFOREACH( test_png ${images} ) diff --git a/engine/libraries/oglft/tests/Demo3UnicodeExample.h b/engine/libraries/oglft/tests/Demo3UnicodeExample.h new file mode 100644 index 0000000..a4277ea --- /dev/null +++ b/engine/libraries/oglft/tests/Demo3UnicodeExample.h @@ -0,0 +1,211 @@ +/* + * Demo3UnicodeExample.h: Sample font for demo3 example. + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +FT_Byte Demo3UnicodeExample_ttf[] = { +0,1,0,0,0,11,0,128,0,3,0,48,79,83,47,50, +83,120,128,90,0,0,0,188,0,0,0,86,99,109,97,112, +135,81,49,45,0,0,1,20,0,0,1,114,99,118,116,32, +5,238,9,153,0,0,2,136,0,0,0,36,103,108,121,102, +105,160,31,169,0,0,2,172,0,0,4,178,104,101,97,100, +212,135,107,129,0,0,7,96,0,0,0,54,104,104,101,97, +6,249,3,88,0,0,7,152,0,0,0,36,104,109,116,120, +20,76,1,64,0,0,7,188,0,0,0,40,108,111,99,97, +6,150,5,39,0,0,7,228,0,0,0,22,109,97,120,112, +0,78,0,250,0,0,7,252,0,0,0,32,110,97,109,101, +88,93,109,50,0,0,8,28,0,0,3,72,112,111,115,116, +11,139,233,133,0,0,11,100,0,0,0,100,0,1,3,232, +1,144,0,5,0,12,0,200,0,200,0,0,0,200,0,200, +0,200,0,0,0,200,0,49,1,2,0,0,2,0,5,3, +0,0,0,0,0,0,0,0,1,131,0,0,0,96,0,0, +0,0,0,0,0,0,80,102,69,100,0,64,0,0,34,43, +3,164,255,52,0,0,3,164,0,204,0,0,0,1,0,0, +0,0,0,0,0,0,0,2,0,3,0,1,0,0,0,20, +0,1,0,0,0,0,0,108,0,4,0,88,0,0,0,18, +0,16,0,3,0,2,3,169,3,195,3,200,33,38,33,146, +34,7,34,25,34,43,255,255,0,0,3,169,3,195,3,200, +33,38,33,146,34,7,34,25,34,43,255,255,252,90,252,65, +252,61,222,221,222,116,222,0,221,239,221,222,0,1,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,1,6,0,0,1,0,0,0,0,0,0,0,1,3, +0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,33,2,121,0,0,0,86, +0,83,1,30,0,100,0,12,0,74,2,25,0,92,2,222, +0,90,0,50,3,176,0,41,0,102,0,78,0,2,0,33, +0,0,1,110,2,154,0,3,0,7,0,46,177,1,0,47, +60,178,7,4,0,237,50,177,6,5,220,60,178,3,2,0, +237,50,0,177,3,0,47,60,178,5,4,0,237,50,178,7, +6,1,252,60,178,1,2,0,237,50,51,17,33,17,37,33, +17,33,33,1,77,254,212,1,11,254,245,2,154,253,102,33, +2,88,0,1,0,48,0,0,2,206,2,234,0,38,0,137, +0,177,20,2,63,176,21,47,176,37,51,176,38,51,177,0, +3,237,177,1,3,237,177,18,3,237,177,19,3,237,176,6, +47,176,28,51,176,29,51,176,30,51,177,10,4,237,1,176, +0,47,176,38,51,177,36,5,237,177,37,5,237,176,2,47, +176,3,51,176,4,51,176,5,51,177,6,6,237,177,33,6, +237,177,34,6,237,177,35,6,237,176,21,176,36,16,222,176, +22,50,177,19,5,237,177,20,5,237,176,23,176,34,16,222, +176,24,50,176,25,50,177,15,6,237,177,16,6,237,177,17, +6,237,177,40,16,16,204,48,49,55,51,38,53,39,54,55, +54,55,54,23,22,23,22,23,22,21,20,7,51,21,33,53, +54,61,1,54,39,38,7,38,7,49,6,23,20,23,21,33, +48,160,151,1,1,101,24,28,74,120,92,58,104,36,16,152, +160,254,226,178,3,71,63,95,110,66,53,2,177,254,226,86, +127,182,1,165,99,23,17,50,5,4,37,65,127,55,61,182, +128,86,81,83,216,2,127,82,72,1,2,96,78,104,220,85, +81,0,0,2,0,34,255,243,2,98,2,32,0,19,0,35, +0,98,0,177,8,7,63,176,9,47,176,10,51,177,27,8, +237,177,28,8,237,177,29,8,237,177,0,9,63,176,19,47, +177,1,8,237,177,2,8,237,1,176,13,47,176,14,51,176, +15,51,176,16,51,177,23,10,237,177,24,10,237,177,25,10, +237,176,31,176,24,16,222,176,32,50,176,33,50,177,3,10, +237,177,4,10,237,177,5,10,237,177,6,10,237,177,37,5, +16,204,48,49,1,21,35,22,21,23,20,7,6,35,34,47, +1,38,61,1,52,55,54,23,7,6,7,6,23,6,23,22, +23,54,55,54,39,52,39,38,2,98,145,66,1,73,68,108, +108,66,5,70,73,106,154,87,94,40,22,2,2,81,33,44, +102,38,19,1,75,35,2,19,73,62,130,1,143,67,67,65, +5,70,136,2,141,68,96,40,63,2,87,49,65,134,48,20, +1,1,95,47,61,130,50,23,0,1,0,61,255,52,2,157, +2,19,0,34,0,118,0,176,26,47,176,27,51,177,0,11, +237,177,1,11,237,177,9,11,237,177,10,11,237,177,17,11, +237,177,18,11,237,1,176,0,47,176,33,51,176,34,51,177, +1,12,237,177,2,12,237,177,3,12,237,176,8,176,1,16, +222,176,9,50,176,27,50,176,28,50,177,10,12,237,177,11, +12,237,177,25,12,237,177,26,12,237,176,14,176,10,16,222, +176,15,50,176,16,50,176,17,50,177,18,12,237,177,19,12, +237,177,20,12,237,177,36,18,16,204,48,49,19,51,17,22, +23,22,23,22,23,17,51,17,54,55,54,61,1,17,51,17, +6,7,6,7,6,7,21,35,53,38,39,38,39,38,39,61, +89,2,19,13,29,39,68,90,124,32,13,89,1,24,20,51, +59,103,90,138,63,43,9,5,1,2,19,254,250,97,34,25, +20,26,3,1,211,254,45,4,86,38,76,1,1,6,254,253, +122,47,39,35,38,3,192,192,5,68,48,55,32,76,0,1, +0,39,0,78,3,216,1,182,0,18,0,37,0,176,11,47, +176,12,51,177,13,13,237,177,14,13,237,1,176,12,47,176, +13,51,177,3,14,237,177,4,14,237,177,20,3,16,204,48, +49,1,22,31,1,21,6,7,6,7,35,54,55,33,53,33, +38,39,53,39,3,10,91,64,51,86,76,19,26,39,47,52, +252,227,3,29,51,20,26,1,182,98,41,27,23,44,78,20, +29,101,54,51,66,36,1,51,0,2,0,14,0,0,2,103, +2,182,0,2,0,5,0,23,0,176,3,47,176,5,51,177, +0,15,237,177,1,15,237,1,177,7,1,47,204,48,49,19, +33,1,3,27,1,14,2,88,254,198,168,200,220,2,182,253, +74,2,140,254,29,1,227,0,0,1,0,92,1,53,0,195, +1,156,0,3,0,37,0,176,0,47,176,3,51,177,1,16, +237,177,2,16,237,1,176,0,47,176,1,51,177,2,16,237, +177,3,16,237,177,5,2,16,204,48,49,19,53,51,21,92, +103,1,54,102,102,0,0,1,255,255,255,145,1,25,3,164, +0,46,0,29,176,0,47,176,26,51,176,38,51,176,45,51, +176,46,51,177,16,17,237,177,21,17,237,177,22,17,237,48, +49,27,1,54,55,54,55,54,23,22,21,22,7,6,35,34, +39,38,7,6,31,1,22,7,3,6,7,6,39,38,39,38, +55,54,55,54,23,22,23,22,63,1,54,39,38,39,38,17, +100,9,9,70,14,16,31,22,9,1,28,9,10,17,21,18, +15,8,1,4,20,1,8,4,41,25,43,25,17,21,6,3, +9,20,29,11,7,22,15,1,8,5,1,1,18,1,218,1, +10,155,29,6,2,1,28,13,14,35,13,4,18,19,15,9, +17,72,251,86,254,222,147,52,35,1,1,16,20,35,15,9, +22,11,5,8,24,14,1,15,48,12,8,158,1,1,0,0, +0,1,0,0,0,0,0,0,248,61,157,109,95,15,60,245, +0,19,3,232,0,0,0,0,184,197,19,226,0,0,0,0, +184,197,19,226,255,255,255,52,3,216,3,164,0,0,0,8, +0,2,0,0,0,0,0,0,0,1,0,0,3,32,255,56, +0,0,4,11,255,255,0,10,3,216,0,1,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,10,1,176,0,33, +0,0,0,0,1,77,0,0,2,248,0,48,2,142,0,34, +2,236,0,61,4,11,0,39,2,136,0,14,1,38,0,92, +1,35,255,255,0,0,0,43,0,43,0,43,0,171,1,22, +1,137,1,190,1,222,1,253,2,89,0,0,0,1,0,0, +0,10,0,47,0,2,0,0,0,0,0,2,0,0,0,64, +0,1,0,0,0,64,0,137,0,0,0,0,0,0,0,21, +1,2,0,1,0,0,0,0,0,0,0,65,0,0,0,1, +0,0,0,0,0,1,0,21,0,66,0,1,0,0,0,0, +0,2,0,7,0,88,0,1,0,0,0,0,0,3,0,47, +0,96,0,1,0,0,0,0,0,4,0,21,0,144,0,1, +0,0,0,0,0,5,0,7,0,166,0,1,0,0,0,0, +0,6,0,19,0,174,0,0,0,3,0,0,0,0,0,130, +0,194,0,0,0,3,0,0,0,1,0,42,1,70,0,0, +0,3,0,0,0,2,0,14,1,114,0,0,0,3,0,0, +0,3,0,94,1,130,0,0,0,3,0,0,0,4,0,42, +1,226,0,0,0,3,0,0,0,5,0,14,2,14,0,0, +0,3,0,0,0,6,0,38,2,30,0,3,0,1,4,9, +0,0,0,130,0,194,0,3,0,1,4,9,0,1,0,42, +1,70,0,3,0,1,4,9,0,2,0,14,1,114,0,3, +0,1,4,9,0,3,0,94,1,130,0,3,0,1,4,9, +0,4,0,42,1,226,0,3,0,1,4,9,0,5,0,14, +2,14,0,3,0,1,4,9,0,6,0,38,2,30,67,114, +101,97,116,101,100,32,98,121,32,65,108,108,101,110,32,66, +97,114,110,101,116,116,32,119,105,116,104,32,80,102,97,69, +100,105,116,32,49,46,48,32,40,104,116,116,112,58,47,47, +112,102,97,101,100,105,116,46,115,102,46,110,101,116,41,0, +68,101,109,111,51,32,85,110,105,99,111,100,101,32,69,120, +97,109,112,108,101,0,82,101,103,117,108,97,114,0,80,102, +97,69,100,105,116,32,49,46,48,32,58,32,68,101,109,111, +51,32,85,110,105,99,111,100,101,32,69,120,97,109,112,108, +101,32,58,32,50,53,45,50,45,50,48,55,50,0,68,101, +109,111,51,32,85,110,105,99,111,100,101,32,69,120,97,109, +112,108,101,0,48,48,49,46,48,48,48,0,68,101,109,111, +51,85,110,105,99,111,100,101,69,120,97,109,112,108,101,0, +0,67,0,114,0,101,0,97,0,116,0,101,0,100,0,32, +0,98,0,121,0,32,0,65,0,108,0,108,0,101,0,110, +0,32,0,66,0,97,0,114,0,110,0,101,0,116,0,116, +0,32,0,119,0,105,0,116,0,104,0,32,0,80,0,102, +0,97,0,69,0,100,0,105,0,116,0,32,0,49,0,46, +0,48,0,32,0,40,0,104,0,116,0,116,0,112,0,58, +0,47,0,47,0,112,0,102,0,97,0,101,0,100,0,105, +0,116,0,46,0,115,0,102,0,46,0,110,0,101,0,116, +0,41,0,0,0,68,0,101,0,109,0,111,0,51,0,32, +0,85,0,110,0,105,0,99,0,111,0,100,0,101,0,32, +0,69,0,120,0,97,0,109,0,112,0,108,0,101,0,0, +0,82,0,101,0,103,0,117,0,108,0,97,0,114,0,0, +0,80,0,102,0,97,0,69,0,100,0,105,0,116,0,32, +0,49,0,46,0,48,0,32,0,58,0,32,0,68,0,101, +0,109,0,111,0,51,0,32,0,85,0,110,0,105,0,99, +0,111,0,100,0,101,0,32,0,69,0,120,0,97,0,109, +0,112,0,108,0,101,0,32,0,58,0,32,0,50,0,53, +0,45,0,50,0,45,0,50,0,48,0,55,0,50,0,0, +0,68,0,101,0,109,0,111,0,51,0,32,0,85,0,110, +0,105,0,99,0,111,0,100,0,101,0,32,0,69,0,120, +0,97,0,109,0,112,0,108,0,101,0,0,0,48,0,48, +0,49,0,46,0,48,0,48,0,48,0,0,0,68,0,101, +0,109,0,111,0,51,0,85,0,110,0,105,0,99,0,111, +0,100,0,101,0,69,0,120,0,97,0,109,0,112,0,108, +0,101,0,0,0,2,0,0,0,0,0,0,255,156,0,50, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,10,0,0,0,1,0,2,1,2,1,3, +1,4,1,5,1,6,1,7,0,156,7,117,110,105,48,51, +65,57,5,115,105,103,109,97,3,112,115,105,10,97,114,114, +111,119,114,105,103,104,116,8,103,114,97,100,105,101,110,116, +7,117,110,105,50,50,49,57, +}; +const int Demo3UnicodeExample_ttf_size = sizeof( Demo3UnicodeExample_ttf ); diff --git a/engine/libraries/oglft/tests/Demo3UnicodeExample.sfd b/engine/libraries/oglft/tests/Demo3UnicodeExample.sfd new file mode 100644 index 0000000..57415c0 --- /dev/null +++ b/engine/libraries/oglft/tests/Demo3UnicodeExample.sfd @@ -0,0 +1,949 @@ +SplineFontDB: 1.0 +FontName: Demo3UnicodeExample +FullName: Demo3 Unicode Example +FamilyName: Demo3 Unicode Example +Weight: Medium +Copyright: Created by Allen Barnett with PfaEdit 1.0 (http://pfaedit.sf.net) +Version: 001.000 +ItalicAngle: 0 +UnderlinePosition: -100 +UnderlineWidth: 50 +Ascent: 800 +Descent: 200 +FSType: 12 +PfmFamily: 17 +TTFWeight: 400 +TTFWidth: 5 +Panose: 2 0 5 3 0 0 0 0 0 0 +Encoding: 26 +DisplaySize: -24 +AntiAlias: 1 +BeginChars: 65536 263 +StartChar: space +Encoding: 32 32 +Width: 1000 +EndChar +StartChar: exclam +Encoding: 33 33 +Width: 1000 +EndChar +StartChar: quotedbl +Encoding: 34 34 +Width: 1000 +EndChar +StartChar: numbersign +Encoding: 35 35 +Width: 1000 +EndChar +StartChar: dollar +Encoding: 36 36 +Width: 1000 +EndChar +StartChar: percent +Encoding: 37 37 +Width: 1000 +EndChar +StartChar: ampersand +Encoding: 38 38 +Width: 1000 +EndChar +StartChar: quotesingle +Encoding: 39 39 +Width: 1000 +EndChar +StartChar: parenleft +Encoding: 40 40 +Width: 1000 +EndChar +StartChar: parenright +Encoding: 41 41 +Width: 1000 +EndChar +StartChar: asterisk +Encoding: 42 42 +Width: 1000 +EndChar +StartChar: plus +Encoding: 43 43 +Width: 1000 +EndChar +StartChar: comma +Encoding: 44 44 +Width: 1000 +EndChar +StartChar: hyphen +Encoding: 45 45 +Width: 1000 +EndChar +StartChar: period +Encoding: 46 46 +Width: 1000 +EndChar +StartChar: slash +Encoding: 47 47 +Width: 1000 +EndChar +StartChar: zero +Encoding: 48 48 +Width: 1000 +EndChar +StartChar: one +Encoding: 49 49 +Width: 1000 +EndChar +StartChar: two +Encoding: 50 50 +Width: 1000 +EndChar +StartChar: three +Encoding: 51 51 +Width: 1000 +EndChar +StartChar: four +Encoding: 52 52 +Width: 1000 +EndChar +StartChar: five +Encoding: 53 53 +Width: 1000 +EndChar +StartChar: six +Encoding: 54 54 +Width: 1000 +EndChar +StartChar: seven +Encoding: 55 55 +Width: 1000 +EndChar +StartChar: eight +Encoding: 56 56 +Width: 1000 +EndChar +StartChar: nine +Encoding: 57 57 +Width: 1000 +EndChar +StartChar: colon +Encoding: 58 58 +Width: 1000 +EndChar +StartChar: semicolon +Encoding: 59 59 +Width: 1000 +EndChar +StartChar: less +Encoding: 60 60 +Width: 1000 +EndChar +StartChar: equal +Encoding: 61 61 +Width: 1000 +EndChar +StartChar: greater +Encoding: 62 62 +Width: 1000 +EndChar +StartChar: question +Encoding: 63 63 +Width: 1000 +EndChar +StartChar: at +Encoding: 64 64 +Width: 1000 +EndChar +StartChar: A +Encoding: 65 65 +Width: 1000 +EndChar +StartChar: B +Encoding: 66 66 +Width: 1000 +EndChar +StartChar: C +Encoding: 67 67 +Width: 1000 +EndChar +StartChar: D +Encoding: 68 68 +Width: 1000 +EndChar +StartChar: E +Encoding: 69 69 +Width: 1000 +EndChar +StartChar: F +Encoding: 70 70 +Width: 1000 +EndChar +StartChar: G +Encoding: 71 71 +Width: 1000 +EndChar +StartChar: H +Encoding: 72 72 +Width: 1000 +EndChar +StartChar: I +Encoding: 73 73 +Width: 1000 +EndChar +StartChar: J +Encoding: 74 74 +Width: 1000 +EndChar +StartChar: K +Encoding: 75 75 +Width: 1000 +EndChar +StartChar: L +Encoding: 76 76 +Width: 1000 +EndChar +StartChar: M +Encoding: 77 77 +Width: 1000 +EndChar +StartChar: N +Encoding: 78 78 +Width: 1000 +EndChar +StartChar: O +Encoding: 79 79 +Width: 1000 +EndChar +StartChar: P +Encoding: 80 80 +Width: 1000 +EndChar +StartChar: Q +Encoding: 81 81 +Width: 1000 +EndChar +StartChar: R +Encoding: 82 82 +Width: 1000 +EndChar +StartChar: S +Encoding: 83 83 +Width: 1000 +EndChar +StartChar: T +Encoding: 84 84 +Width: 1000 +EndChar +StartChar: U +Encoding: 85 85 +Width: 1000 +EndChar +StartChar: V +Encoding: 86 86 +Width: 1000 +EndChar +StartChar: W +Encoding: 87 87 +Width: 1000 +EndChar +StartChar: X +Encoding: 88 88 +Width: 1000 +EndChar +StartChar: Y +Encoding: 89 89 +Width: 1000 +EndChar +StartChar: Z +Encoding: 90 90 +Width: 1000 +EndChar +StartChar: bracketleft +Encoding: 91 91 +Width: 1000 +EndChar +StartChar: backslash +Encoding: 92 92 +Width: 1000 +EndChar +StartChar: bracketright +Encoding: 93 93 +Width: 1000 +EndChar +StartChar: asciicircum +Encoding: 94 94 +Width: 1000 +EndChar +StartChar: underscore +Encoding: 95 95 +Width: 1000 +EndChar +StartChar: grave +Encoding: 96 96 +Width: 1000 +EndChar +StartChar: a +Encoding: 97 97 +Width: 1000 +EndChar +StartChar: b +Encoding: 98 98 +Width: 1000 +EndChar +StartChar: c +Encoding: 99 99 +Width: 1000 +EndChar +StartChar: d +Encoding: 100 100 +Width: 1000 +EndChar +StartChar: e +Encoding: 101 101 +Width: 1000 +EndChar +StartChar: f +Encoding: 102 102 +Width: 1000 +EndChar +StartChar: g +Encoding: 103 103 +Width: 1000 +EndChar +StartChar: h +Encoding: 104 104 +Width: 1000 +EndChar +StartChar: i +Encoding: 105 105 +Width: 1000 +EndChar +StartChar: j +Encoding: 106 106 +Width: 1000 +EndChar +StartChar: k +Encoding: 107 107 +Width: 1000 +EndChar +StartChar: l +Encoding: 108 108 +Width: 1000 +EndChar +StartChar: m +Encoding: 109 109 +Width: 1000 +EndChar +StartChar: n +Encoding: 110 110 +Width: 1000 +EndChar +StartChar: o +Encoding: 111 111 +Width: 1000 +EndChar +StartChar: p +Encoding: 112 112 +Width: 1000 +EndChar +StartChar: q +Encoding: 113 113 +Width: 1000 +EndChar +StartChar: r +Encoding: 114 114 +Width: 1000 +EndChar +StartChar: s +Encoding: 115 115 +Width: 1000 +EndChar +StartChar: t +Encoding: 116 116 +Width: 1000 +EndChar +StartChar: u +Encoding: 117 117 +Width: 1000 +EndChar +StartChar: v +Encoding: 118 118 +Width: 1000 +EndChar +StartChar: w +Encoding: 119 119 +Width: 1000 +EndChar +StartChar: x +Encoding: 120 120 +Width: 1000 +EndChar +StartChar: y +Encoding: 121 121 +Width: 1000 +EndChar +StartChar: z +Encoding: 122 122 +Width: 1000 +EndChar +StartChar: braceleft +Encoding: 123 123 +Width: 1000 +EndChar +StartChar: bar +Encoding: 124 124 +Width: 1000 +EndChar +StartChar: braceright +Encoding: 125 125 +Width: 1000 +EndChar +StartChar: asciitilde +Encoding: 126 126 +Width: 1000 +EndChar +StartChar: nonbreakingspace +Encoding: 160 160 +Width: 1000 +EndChar +StartChar: exclamdown +Encoding: 161 161 +Width: 1000 +EndChar +StartChar: cent +Encoding: 162 162 +Width: 1000 +EndChar +StartChar: sterling +Encoding: 163 163 +Width: 1000 +EndChar +StartChar: currency +Encoding: 164 164 +Width: 1000 +EndChar +StartChar: yen +Encoding: 165 165 +Width: 1000 +EndChar +StartChar: brokenbar +Encoding: 166 166 +Width: 1000 +EndChar +StartChar: section +Encoding: 167 167 +Width: 1000 +EndChar +StartChar: dieresis +Encoding: 168 168 +Width: 1000 +EndChar +StartChar: copyright +Encoding: 169 169 +Width: 1000 +EndChar +StartChar: ordfeminine +Encoding: 170 170 +Width: 1000 +EndChar +StartChar: guillemotleft +Encoding: 171 171 +Width: 1000 +EndChar +StartChar: logicalnot +Encoding: 172 172 +Width: 1000 +EndChar +StartChar: softhyphen +Encoding: 173 173 +Width: 1000 +EndChar +StartChar: registered +Encoding: 174 174 +Width: 1000 +EndChar +StartChar: macron +Encoding: 175 175 +Width: 1000 +EndChar +StartChar: degree +Encoding: 176 176 +Width: 1000 +EndChar +StartChar: plusminus +Encoding: 177 177 +Width: 1000 +EndChar +StartChar: twosuperior +Encoding: 178 178 +Width: 1000 +EndChar +StartChar: threesuperior +Encoding: 179 179 +Width: 1000 +EndChar +StartChar: acute +Encoding: 180 180 +Width: 1000 +EndChar +StartChar: mu +Encoding: 181 181 +Width: 1000 +EndChar +StartChar: paragraph +Encoding: 182 182 +Width: 1000 +EndChar +StartChar: periodcentered +Encoding: 183 183 +Width: 1000 +EndChar +StartChar: cedilla +Encoding: 184 184 +Width: 1000 +EndChar +StartChar: onesuperior +Encoding: 185 185 +Width: 1000 +EndChar +StartChar: ordmasculine +Encoding: 186 186 +Width: 1000 +EndChar +StartChar: guillemotright +Encoding: 187 187 +Width: 1000 +EndChar +StartChar: onequarter +Encoding: 188 188 +Width: 1000 +EndChar +StartChar: onehalf +Encoding: 189 189 +Width: 1000 +EndChar +StartChar: threequarters +Encoding: 190 190 +Width: 1000 +EndChar +StartChar: questiondown +Encoding: 191 191 +Width: 1000 +EndChar +StartChar: Agrave +Encoding: 192 192 +Width: 1000 +EndChar +StartChar: Aacute +Encoding: 193 193 +Width: 1000 +EndChar +StartChar: Acircumflex +Encoding: 194 194 +Width: 1000 +EndChar +StartChar: Atilde +Encoding: 195 195 +Width: 1000 +EndChar +StartChar: Adieresis +Encoding: 196 196 +Width: 1000 +EndChar +StartChar: Aring +Encoding: 197 197 +Width: 1000 +EndChar +StartChar: AE +Encoding: 198 198 +Width: 1000 +EndChar +StartChar: Ccedilla +Encoding: 199 199 +Width: 1000 +EndChar +StartChar: Egrave +Encoding: 200 200 +Width: 1000 +EndChar +StartChar: Eacute +Encoding: 201 201 +Width: 1000 +EndChar +StartChar: Ecircumflex +Encoding: 202 202 +Width: 1000 +EndChar +StartChar: Edieresis +Encoding: 203 203 +Width: 1000 +EndChar +StartChar: Igrave +Encoding: 204 204 +Width: 1000 +EndChar +StartChar: Iacute +Encoding: 205 205 +Width: 1000 +EndChar +StartChar: Icircumflex +Encoding: 206 206 +Width: 1000 +EndChar +StartChar: Idieresis +Encoding: 207 207 +Width: 1000 +EndChar +StartChar: Eth +Encoding: 208 208 +Width: 1000 +EndChar +StartChar: Ntilde +Encoding: 209 209 +Width: 1000 +EndChar +StartChar: Ograve +Encoding: 210 210 +Width: 1000 +EndChar +StartChar: Oacute +Encoding: 211 211 +Width: 1000 +EndChar +StartChar: Ocircumflex +Encoding: 212 212 +Width: 1000 +EndChar +StartChar: Otilde +Encoding: 213 213 +Width: 1000 +EndChar +StartChar: Odieresis +Encoding: 214 214 +Width: 1000 +EndChar +StartChar: multiply +Encoding: 215 215 +Width: 1000 +EndChar +StartChar: Oslash +Encoding: 216 216 +Width: 1000 +EndChar +StartChar: Ugrave +Encoding: 217 217 +Width: 1000 +EndChar +StartChar: Uacute +Encoding: 218 218 +Width: 1000 +EndChar +StartChar: Ucircumflex +Encoding: 219 219 +Width: 1000 +EndChar +StartChar: Udieresis +Encoding: 220 220 +Width: 1000 +EndChar +StartChar: Yacute +Encoding: 221 221 +Width: 1000 +EndChar +StartChar: Thorn +Encoding: 222 222 +Width: 1000 +EndChar +StartChar: germandbls +Encoding: 223 223 +Width: 1000 +EndChar +StartChar: agrave +Encoding: 224 224 +Width: 1000 +EndChar +StartChar: aacute +Encoding: 225 225 +Width: 1000 +EndChar +StartChar: acircumflex +Encoding: 226 226 +Width: 1000 +EndChar +StartChar: atilde +Encoding: 227 227 +Width: 1000 +EndChar +StartChar: adieresis +Encoding: 228 228 +Width: 1000 +EndChar +StartChar: aring +Encoding: 229 229 +Width: 1000 +EndChar +StartChar: ae +Encoding: 230 230 +Width: 1000 +EndChar +StartChar: ccedilla +Encoding: 231 231 +Width: 1000 +EndChar +StartChar: egrave +Encoding: 232 232 +Width: 1000 +EndChar +StartChar: eacute +Encoding: 233 233 +Width: 1000 +EndChar +StartChar: ecircumflex +Encoding: 234 234 +Width: 1000 +EndChar +StartChar: edieresis +Encoding: 235 235 +Width: 1000 +EndChar +StartChar: igrave +Encoding: 236 236 +Width: 1000 +EndChar +StartChar: iacute +Encoding: 237 237 +Width: 1000 +EndChar +StartChar: icircumflex +Encoding: 238 238 +Width: 1000 +EndChar +StartChar: idieresis +Encoding: 239 239 +Width: 1000 +EndChar +StartChar: eth +Encoding: 240 240 +Width: 1000 +EndChar +StartChar: ntilde +Encoding: 241 241 +Width: 1000 +EndChar +StartChar: ograve +Encoding: 242 242 +Width: 1000 +EndChar +StartChar: oacute +Encoding: 243 243 +Width: 1000 +EndChar +StartChar: ocircumflex +Encoding: 244 244 +Width: 1000 +EndChar +StartChar: otilde +Encoding: 245 245 +Width: 1000 +EndChar +StartChar: odieresis +Encoding: 246 246 +Width: 1000 +EndChar +StartChar: divide +Encoding: 247 247 +Width: 1000 +EndChar +StartChar: oslash +Encoding: 248 248 +Width: 1000 +EndChar +StartChar: ugrave +Encoding: 249 249 +Width: 1000 +EndChar +StartChar: uacute +Encoding: 250 250 +Width: 1000 +EndChar +StartChar: ucircumflex +Encoding: 251 251 +Width: 1000 +EndChar +StartChar: udieresis +Encoding: 252 252 +Width: 1000 +EndChar +StartChar: yacute +Encoding: 253 253 +Width: 1000 +EndChar +StartChar: thorn +Encoding: 254 254 +Width: 1000 +EndChar +StartChar: ydieresis +Encoding: 255 255 +Width: 1000 +EndChar +StartChar: uni03A9 +Encoding: 937 937 +Width: 760 +Flags: W +HStem: 0 86.5<55 192 560 711> 662.5 82.6191<368 400> +VStem: 48.5 285.5<1 81> 56.5 100.5<368 416> 432.5 285<1 81> 610.5 99<368 416> +Fore +48.5 86.5 m 1 + 208.5 86.5 l 1 + 107.167 171.167 56.5 274.5 56.5 396.5 c 1 + 56.7101 536.75 118.58 644.249 209.5 699.75 c 1 + 297.509 759.342 465.523 760.85 554.25 703.5 c 1 + 642.338 648.475 711.166 540.692 709.5 396.5 c 1 + 709.5 274.5 658.833 171.167 557.5 86.5 c 1 + 717.5 86.5 l 1 + 717.5 0 l 1 + 432.5 0 l 1 + 432.5 81 l 1 + 551.167 136.333 610.5 236.5 610.5 381.5 c 1 + 613.683 531.395 525.526 663.23 384.5 662.5 c 1 + 242.961 665.005 154.417 531.689 157 386.5 c 1 + 157 239.5 216 137.667 334 81 c 1 + 334 0 l 1 + 48.5 0 l 1 + 48.5 86.5 l 1 +EndSplineSet +MinimumDistance: x5,-1 +EndChar +StartChar: sigma +Encoding: 963 963 +Width: 654 +Flags: W +HStem: -11.9998 73.9998<282 299.31> 458 73<466 594> 468.5 74.5483<280.625 302.587> +VStem: 34 92.5<243 265 265.575 298.829> 440 91.5<243 291> +Fore +609.5 531 m 1 + 609.5 458 l 1 + 465 458 l 1 + 509.333 416.667 531.5 352.333 531.5 265 c 0 + 531.5 170 507.25 100.083 458.75 55.25 c 1 + 367.585 -35.1072 191 -34.6289 104 58 c 1 + 57.333 104.667 34 173.833 34 265.5 c 0 + 34 359.833 58.25 429.667 106.75 475 c 1 + 176.138 537.884 259.745 558.789 367 531 c 1 + 609.5 531 l 1 +280.5 468.5 m 1 + 180.415 465.592 122.839 382.568 126.5 265 c 1 + 124.033 145.734 177.982 64.8142 282 62 c 1 + 387.637 63.1845 442.118 149.124 440 265.5 c 1 + 439.941 377.605 391.876 470.041 280.5 468.5 c 1 +EndSplineSet +MinimumDistance: x3,-1 +EndChar +StartChar: psi +Encoding: 968 968 +Width: 748 +Flags: W +HStem: -203.5 734.5<320 410> +VStem: 61 89.5<244 530> 320 90<-188 -12 65 530> 579 89.5<244 530> +Fore +61 531 m 1 + 150.5 531 l 1 + 150.5 269 l 1 + 151.992 173.54 157.865 130.981 213.25 92.75 c 1 + 239.083 75.583 274.667 65.833 320 63.5 c 1 + 320 531 l 1 + 410 531 l 1 + 410 63.5 l 1 + 489.519 66.7047 544.824 98.0574 565.75 154.25 c 1 + 574.583 179.75 579 218 579 269 c 2 + 579 531 l 1 + 668.5 531 l 1 + 668.5 272 l 1 + 666.618 133.548 653.5 84.7044 571.5 29.25 c 1 + 532.5 4.08301 478.667 -9.66699 410 -12 c 1 + 410 -203.5 l 1 + 320 -203.5 l 1 + 320 -12 l 1 + 229.595 -8.79161 164.247 11.9517 118.75 61.25 c 1 + 67.0712 119.571 62.4383 155.542 61 272 c 1 + 61 531 l 1 +EndSplineSet +MinimumDistance: x11,-1 +EndChar +StartChar: arrowright +Encoding: 8594 8594 +Width: 1035 +Flags: W +HStem: 233 50.5<55 836> +VStem: 39.5 944.5<249 271> +Fore +777.5 438 m 1 + 848.958 360.788 901.645 310.333 984 271.5 c 1 + 984 249 l 1 + 897.46 204.953 850.008 159.158 777 78.5 c 1 + 738.5 78.5 l 1 + 769.833 145.5 802.667 197 837 233 c 1 + 39.5 233 l 1 + 39.5 283.5 l 1 + 837 283.5 l 1 + 782.642 353.947 781.915 354.515 739.5 438 c 1 + 777.5 438 l 1 +EndSplineSet +MinimumDistance: x1,-1 +EndChar +StartChar: gradient +Encoding: 8711 8711 +Width: 648 +Flags: W +HStem: 652.5 41<134 551> +DStem: 14.5 693.5 132.5 652.5 300.5 0 332 169 552 652.5 614.5 693.5 332 169 300.5 0 +Fore +14.5 693.5 m 1 + 614.5 693.5 l 1 + 300.5 0 l 1 + 14.5 693.5 l 1 +132.5 652.5 m 1 + 332 169 l 1 + 552 652.5 l 1 + 132.5 652.5 l 1 +EndSplineSet +MinimumDistance: x1,-1 +EndChar +StartChar: uni2219 +Encoding: 8729 8729 +Width: 294 +Flags: W +HStem: 309.5 102.5<108 194> +VStem: 92.5 102.5<325 411> +Fore +92.5 309.5 m 1 + 92.5 412 l 1 + 195 412 l 1 + 195 309.5 l 1 + 92.5 309.5 l 1 +EndSplineSet +MinimumDistance: x2,-1 +EndChar +StartChar: integral +Encoding: 8747 8747 +Width: 291 +Flags: W +VStem: 100.5 77.8252<327.709 474> +Fore +100.5 474 m 1 + 109 739.5 l 1 + 114.542 833.138 134.534 923.622 217.5 931.5 c 1 + 247.522 933.096 280.447 905.565 280 878 c 1 + 280.849 848.918 261.127 825.941 234 826 c 1 + 222.333 826 209.667 832 196 844 c 1 + 176.357 863.99 153.522 851.038 156 822 c 1 + 156 808 157.5 783.833 160.5 749.5 c 1 + 184.169 438.285 182.123 484.679 171 123 c 1 + 168.333 24.667 153.333 -41.833 126 -76.5 c 1 + 101.122 -110.714 47.8807 -123.362 16.5 -93 c 1 + -3.17021 -74.8996 -6.32757 -33.0899 12.75 -13.5 c 1 + 30.257 5.46361 62.8625 4.28698 79.5 -16 c 1 + 93.653 -31.3569 104.804 -38.4598 118 -25 c 1 + 129.244 -4.11259 121.392 22.5244 119 58.5 c 1 + 106.667 163.5 100.5 302 100.5 474 c 1 +EndSplineSet +EndChar +EndChars +EndSplineFont diff --git a/engine/libraries/oglft/tests/Demo3UnicodeExample.ttf b/engine/libraries/oglft/tests/Demo3UnicodeExample.ttf new file mode 100644 index 0000000000000000000000000000000000000000..e861494ea40ef7b71e39dadc3ebec17f7718f381 GIT binary patch literal 3016 zcmds3TWlOj6}`85y60uh!}Ibp>6x)-9J2O|yZvBIjAO?MNyvsg6mJs3CKJ#20Uq0$ zOg0WeN(f>fJoW(+EFp{Xu^?6;)a?(84}?~%K>1kl!+u04@kf@A1u^h}R$3Ov=G62= z2@5O1FI_rS_ujg7tM09;TTM(ve!5Bu!(r z|KnG&;3E2q#LBz;5~&lzTtz;(ot&}^}n%cRw1sne++c>>3zA?If zcfGn!cmH~K{So_(X=KCN!--k0_u(oWtq=2#^#83+ipy|mijMO(>}(Sq6s>edtkY>S z6pMDy3{HliB*L>Ou450})Mqp0cCETyR5NT%y|Zgo5g^G{q*#^WRky|)yH;@+YK9q3 zhP#vDWRjoQe4G87?}_X8XOiM1;+@A?`K|a9W$1abqhid8<*aVg%9u7OHJgEEAfnVP zEoXI@R;OugGi{%%#unwIT9;b0yVaT{a+YFRF4Iy?ThnTG5=a4Qt!BlnuF$#_H|z+M zqfky*DF|8&tJScBPznKIpeGc1E8jnCW(KoE!zhWkEU~EDj3oz$MtLZkacA89S|XZ= zCG$7G%Uo*dIJk0VWUedp%FWGttIDUw&Mr<23VZY3)Ri^<;dCNwsIKnuE5oB}SEr61 zzb&pD+t1?M;ki2}j>>D2+WMO~FLa7fn$DB$agSNvoaHm^c2CXj06GEkj#-hM%^-yb zp8IlEz_fy<6*BFFuV%LZt-hMI-D-hbx?v>^TY=04sDK7^tI{=&rQ@+g)UBmcInIpo z0DN?7ZY`m~Q8=6($Y#X(mnZnZqL=JrN8o#(_ z&$znpIq}WOb3J3?$^P+Y@=@lqxzTGz0=qi8H6UIU5lYe1WVPk2c5J5~+X;999}otb z{mwQfO)F*E+ywUkrKx6lEQTju!)iCI4#W0A><3zbHgpFpAG(8v6*8=_VK+k@0ir-x zv-C4!hU;6G2%BNJHOgq=CQ2+ln90gAdP+omo!QCLU($W2xFu?SV)pdc#&&vD7Lm;l z3aQp;o5H`_>~&3L4l!$+_rI9SrZdVLZ>W>`Vf_%i%+g`yHm@Nwb(7`KSxq>Yh;+aQ zubS$cs06SHKvby*Kfaw~at-OB;pAX4lO4<|zR&J9rw&Ehvblkcca%;u+Qw_=ceE!S zI~?sS4Ve>NY~qvza8zc+noO&dAWO-~Q%*rdG+1NX%{l3El9hH2h?ASY`SGngV(tDx z@r}(+en)1tGdxId@(tWwtQ7Y~L9|1NcF2i8o07B@Ko#}y4Vtktvph62gV9@CTQ74f z@^l|{%E4{&dRo1v)o0qFaLtYZ@o+8Q-_DIo6N}3OhP$F|=eS#e%QE5*F4UO3M%hfb z==JUkgto`M+~M_wW6ePiyQ1uI?P%TE8jfj-H`?iU$Aj!qnVb3d?E8MFCb+{FNc&vP zk)Suc{~uGE>)#$oGl!z-pf~PUJuLwa=9@e}V41la+57#`SIcLEyWXRS@~%wXKmT>) z-h&pt4Jfza8y-4D*ZD9`(YHR1ch!&A#i!hUV5!kh3QsbbvF6d0M_rw6k7*!f}3{f6427U!0Ny0UzZWbIO@_*JZnr2c0j5)Yn-1;RbZEz>LpwGdx^8n%rBtYv ziu(D>`uM^^X;GgjR2ECss(xv{I;S6*DeNuISM~nByxucctuBw`a?3M?5@dZBX8NGG zgCNN4 literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/Demo3UnicodeExample2.h b/engine/libraries/oglft/tests/Demo3UnicodeExample2.h new file mode 100644 index 0000000..384ef0c --- /dev/null +++ b/engine/libraries/oglft/tests/Demo3UnicodeExample2.h @@ -0,0 +1,470 @@ +/* + * Demo3UnicodeExample2.h: Additional symbols for demo3 example. + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +FT_Byte lCSymbols_ttf[] = { +0,1,0,0,0,12,0,128,0,3,0,64,79,83,47,50, +81,97,77,142,0,0,0,204,0,0,0,86,99,109,97,112, +224,46,4,241,0,0,1,36,0,0,1,82,99,118,116,32, +4,48,5,221,0,0,2,120,0,0,0,34,103,108,121,102, +109,46,45,11,0,0,2,156,0,0,18,254,104,101,97,100, +211,187,118,221,0,0,21,156,0,0,0,54,104,104,101,97, +6,115,1,120,0,0,21,212,0,0,0,36,104,109,116,120, +28,67,1,223,0,0,21,248,0,0,0,100,107,101,114,110, +251,84,252,187,0,0,22,92,0,0,0,162,108,111,99,97, +51,201,56,104,0,0,23,0,0,0,0,52,109,97,120,112, +0,94,1,24,0,0,23,52,0,0,0,32,110,97,109,101, +31,28,131,163,0,0,23,84,0,0,3,167,112,111,115,116, +142,120,183,88,0,0,26,252,0,0,1,4,0,1,3,232, +1,144,0,5,0,12,0,200,0,200,0,0,0,200,0,200, +0,200,0,0,0,200,0,49,1,2,0,0,2,0,5,3, +0,0,0,0,0,0,0,0,0,3,16,0,0,8,0,0, +0,0,0,0,0,0,80,102,69,100,0,64,0,32,224,25, +2,234,255,52,0,90,2,234,0,204,0,0,0,1,0,0, +0,0,0,0,0,0,0,3,0,0,0,3,0,0,0,28, +0,1,0,0,0,0,0,76,0,3,0,1,0,0,0,28, +0,4,0,48,0,0,0,8,0,8,0,2,0,0,33,4, +224,10,224,25,255,255,0,0,33,4,224,0,224,16,255,255, +222,255,32,4,31,255,0,1,0,0,0,0,0,0,0,0, +0,0,1,6,0,0,1,0,0,0,0,0,0,0,1,3, +0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,33,2,121,0,86,0,83, +0,100,0,97,1,202,0,37,0,46,1,112,0,43,0,242, +0,48,0,41,0,237,0,0,0,21,0,0,0,2,0,33, +0,0,1,110,2,154,0,3,0,7,0,46,177,1,0,47, +60,178,7,4,0,237,50,177,6,5,220,60,178,3,2,0, +237,50,0,177,3,0,47,60,178,5,4,0,237,50,178,7, +6,1,252,60,178,1,2,0,237,50,51,17,33,17,37,33, +17,33,33,1,77,254,212,1,11,254,245,2,154,253,102,33, +2,88,0,1,0,7,255,52,2,246,2,234,0,47,0,110, +0,176,11,47,176,12,51,177,9,2,237,177,10,2,237,176, +32,47,176,33,51,176,34,51,177,24,3,237,177,25,3,237, +177,26,3,237,1,176,17,47,176,18,51,176,19,51,176,20, +51,177,39,4,237,177,40,4,237,177,41,4,237,177,42,4, +237,176,12,47,176,13,51,176,45,51,176,46,51,177,0,5, +237,177,7,5,237,177,8,5,237,177,9,5,237,177,47,5, +237,176,12,16,177,10,6,237,177,11,6,237,48,49,37,54, +55,23,6,7,6,15,1,21,33,21,33,53,38,47,1,38, +61,1,52,55,54,55,54,51,50,23,22,23,7,38,47,1, +34,7,6,15,1,6,29,1,20,23,22,23,17,51,1,141, +130,31,97,46,161,24,26,1,1,105,254,54,183,70,1,39, +122,22,25,80,97,176,81,20,13,96,45,128,23,135,63,12, +8,3,23,112,39,42,97,76,31,150,24,185,47,7,3,1, +108,86,194,19,166,1,91,104,1,198,100,18,14,44,136,35, +43,22,141,11,1,100,19,22,8,68,72,1,201,67,23,7, +1,198,0,2,0,21,1,97,1,5,2,216,0,12,0,30, +0,109,0,176,7,47,176,8,51,176,9,51,177,10,7,237, +177,17,7,237,177,18,7,237,177,19,7,237,176,26,176,10, +16,222,176,27,50,176,28,50,177,1,7,237,177,2,7,237, +177,3,7,237,1,176,0,47,176,1,51,176,11,51,176,12, +51,177,13,8,237,177,14,8,237,177,30,8,237,176,21,176, +13,16,222,176,22,50,176,23,50,176,24,50,177,5,8,237, +177,6,8,237,177,7,8,237,177,32,6,16,204,48,49,19, +52,51,50,23,22,21,20,35,34,39,38,53,55,20,23,51, +22,51,50,55,54,61,1,52,39,38,35,34,7,6,21,120, +85,26,8,119,53,30,37,47,20,1,21,31,31,21,21,21, +21,32,31,18,23,2,29,187,101,32,54,187,38,45,102,2, +90,30,30,30,30,88,2,90,30,30,27,33,0,1,0,55, +1,104,0,191,2,216,0,13,0,41,0,176,0,47,176,1, +51,177,11,9,237,177,12,9,237,177,13,9,237,1,176,1, +47,176,2,51,177,0,8,237,177,13,8,237,177,15,0,16, +204,48,49,19,35,17,6,7,6,7,53,54,55,54,63,1, +51,191,45,17,26,26,21,37,29,27,12,1,29,1,104,1, +31,16,15,16,8,44,18,25,25,23,1,0,0,1,0,15, +1,104,1,2,2,216,0,37,0,96,0,176,1,47,176,2, +51,177,0,10,237,177,37,10,237,176,15,176,0,16,222,176, +16,50,176,17,50,177,23,7,237,177,24,7,237,177,25,7, +237,1,176,2,47,176,3,51,177,0,11,237,177,1,11,237, +177,28,11,237,177,29,11,237,177,30,11,237,176,29,16,177, +10,8,237,177,11,8,237,177,12,8,237,177,13,8,237,177, +25,8,237,177,39,0,16,204,48,49,1,21,35,38,55,53, +54,55,54,55,54,61,1,52,39,38,35,34,7,21,7,39, +54,63,1,50,23,22,31,1,20,15,1,6,7,6,15,1, +1,2,242,2,36,21,38,60,21,21,41,13,15,56,13,3, +46,8,82,29,70,31,10,2,1,38,1,21,48,52,13,6, +1,147,43,37,42,1,24,32,49,28,28,25,1,43,16,5, +50,1,23,5,89,15,2,50,17,20,15,44,43,1,23,41, +44,17,10,0,0,1,0,21,1,97,1,6,2,216,0,52, +0,133,0,176,48,47,176,49,51,176,50,51,177,2,7,237, +177,3,7,237,177,4,7,237,176,13,176,2,16,222,176,14, +50,176,15,50,177,17,0,237,177,18,0,237,177,19,0,237, +176,26,176,17,16,222,176,27,50,176,28,50,177,33,7,237, +177,34,7,237,177,35,7,237,1,176,21,47,176,22,51,176, +23,51,176,24,51,176,35,51,177,38,8,237,177,39,8,237, +177,40,8,237,177,41,8,237,176,8,47,176,9,51,176,10, +51,176,11,51,177,44,12,237,177,45,12,237,177,46,12,237, +177,54,45,16,204,48,49,19,55,22,51,50,55,61,1,54, +61,1,52,39,38,35,34,7,55,23,50,55,54,61,1,52, +39,38,35,34,7,39,54,55,54,51,50,23,49,22,21,23, +20,7,22,31,1,20,7,6,35,34,39,38,22,44,15,57, +47,21,8,40,15,17,13,19,5,7,55,16,4,34,12,14, +56,10,45,13,63,16,18,59,31,17,1,51,59,8,2,57, +30,37,71,32,11,1,201,6,72,41,1,1,15,17,1,47, +18,6,4,39,1,38,11,12,1,38,14,5,66,8,73,17, +5,42,23,29,1,51,24,13,60,17,65,32,17,57,20,0, +0,2,0,6,1,104,1,4,2,215,0,10,0,13,0,114, +0,176,1,47,176,2,51,176,8,51,176,9,51,177,3,13, +237,177,6,13,237,177,7,13,237,177,11,13,237,177,13,13, +237,177,4,6,16,204,177,5,6,16,204,177,10,1,16,204, +177,0,1,16,204,1,176,0,47,176,1,51,176,11,51,176, +12,51,177,5,8,237,177,6,8,237,177,9,8,237,177,10, +8,237,177,4,6,16,204,177,8,6,16,204,177,7,6,16, +204,177,3,1,16,204,177,2,1,16,204,177,15,7,16,204, +48,49,19,53,35,53,55,51,21,51,21,35,21,39,53,7, +166,160,168,36,50,50,44,115,1,104,88,41,237,237,41,88, +129,165,165,0,0,1,0,21,1,97,1,9,2,210,0,36, +0,102,0,176,32,47,176,33,51,176,34,51,177,3,7,237, +177,4,7,237,177,5,7,237,176,12,176,3,16,222,176,13, +50,176,14,50,177,22,13,237,177,23,13,237,177,24,13,237, +176,19,176,22,16,222,176,20,50,177,17,10,237,177,18,10, +237,1,176,7,47,176,8,51,176,9,51,176,10,51,176,24, +51,177,27,12,237,177,28,12,237,177,29,12,237,177,30,12, +237,177,38,29,16,204,48,49,19,55,22,31,1,50,55,54, +61,1,52,39,38,35,34,7,39,55,51,21,35,7,54,51, +50,23,21,22,29,1,20,7,6,35,34,39,38,21,47,9, +47,15,51,19,7,46,15,17,44,22,43,36,182,146,20,33, +36,66,32,16,57,30,38,76,30,9,1,200,4,58,10,1, +49,18,21,1,59,19,5,35,5,189,44,98,23,55,1,27, +35,1,75,36,19,60,19,0,0,2,0,19,1,97,1,6, +2,216,0,29,0,47,0,136,0,176,17,47,176,18,51,176, +19,51,177,33,7,237,177,34,7,237,177,35,7,237,176,42, +176,33,16,222,176,43,50,176,44,50,176,45,50,177,8,13, +237,177,9,13,237,177,10,13,237,176,2,176,8,16,222,176, +3,50,176,4,50,177,25,7,237,177,26,7,237,177,27,7, +237,177,28,7,237,1,176,21,47,176,22,51,176,23,51,176, +24,51,177,6,10,237,177,7,10,237,176,10,47,176,37,51, +176,38,51,176,39,51,176,40,51,177,12,8,237,177,13,8, +237,177,14,8,237,177,15,8,237,177,49,14,16,204,48,49, +1,7,38,35,34,7,6,21,54,51,50,23,22,29,1,20, +7,6,35,34,39,38,39,53,52,55,54,51,50,23,7,20, +23,22,51,50,55,54,61,1,52,39,38,39,35,34,7,6, +0,255,45,13,49,48,23,13,32,57,64,30,14,52,27,36, +56,35,35,1,117,7,8,73,24,177,36,18,21,46,17,6, +41,11,14,5,47,19,7,2,125,4,58,57,30,55,49,57, +28,33,1,73,34,18,41,41,94,2,184,11,1,63,186,52, +25,11,49,16,19,1,56,19,6,1,44,16,0,1,0,24, +1,104,1,6,2,210,0,16,0,43,0,176,0,47,176,16, +51,177,1,10,237,177,2,10,237,176,9,47,176,10,47,1, +176,0,47,176,1,51,177,2,14,237,177,3,14,237,177,18, +2,16,204,48,49,19,53,51,21,6,7,6,7,6,7,35, +54,55,52,55,54,55,24,238,71,42,6,4,14,3,46,5, +86,1,17,19,2,166,44,35,75,120,16,15,46,55,140,129, +2,1,25,21,0,3,0,20,1,97,1,7,2,216,0,32, +0,51,0,69,0,207,0,176,24,47,176,25,51,176,26,51, +177,55,7,237,177,56,7,237,177,57,7,237,176,17,176,55, +16,222,176,31,50,176,64,50,176,65,50,176,66,50,177,36, +7,237,177,37,7,237,177,38,7,237,176,3,176,36,16,222, +176,45,50,176,46,50,176,47,50,177,5,7,237,177,6,7, +237,177,7,7,237,1,176,28,47,176,29,51,176,30,51,176, +31,51,177,52,8,237,177,53,8,237,177,68,8,237,177,69, +8,237,176,1,47,176,2,51,176,3,51,176,27,51,177,33, +8,237,177,34,8,237,177,50,8,237,177,51,8,237,176,40, +47,176,41,51,176,42,51,176,43,51,177,12,8,237,177,13, +8,237,177,14,8,237,177,15,8,237,176,59,47,176,60,51, +176,61,51,176,62,51,177,17,8,237,177,18,8,237,177,19, +8,237,177,20,8,237,177,21,8,237,177,22,8,237,177,71, +21,16,204,48,49,19,38,53,52,55,54,51,50,31,1,21, +23,22,29,1,20,7,22,23,20,29,1,20,7,6,35,34, +39,38,61,1,52,55,39,20,23,22,51,50,55,54,61,1, +52,39,38,35,34,15,1,6,21,7,20,23,22,51,50,55, +54,61,1,52,39,38,35,34,7,6,21,90,54,54,23,28, +63,29,1,1,12,54,67,2,58,28,34,72,33,16,67,6, +37,11,12,40,14,5,35,12,13,38,16,1,4,15,40,16, +19,48,19,7,41,16,19,47,19,7,2,47,20,55,59,25, +10,46,1,1,1,21,25,1,53,20,22,69,1,1,1,67, +30,14,52,26,33,1,73,19,77,42,13,4,34,10,11,1, +39,15,5,32,1,11,11,170,48,19,8,40,15,17,1,48, +20,7,40,15,17,0,0,2,0,21,1,97,1,7,2,216, +0,35,0,58,0,133,0,176,32,47,176,33,51,176,34,51, +177,2,7,237,177,3,7,237,177,4,7,237,176,11,176,2, +16,222,176,12,50,176,13,50,177,7,13,237,177,8,13,237, +177,53,13,237,177,54,13,237,177,55,13,237,176,41,176,8, +16,222,176,42,50,176,43,50,177,21,7,237,177,22,7,237, +177,23,7,237,1,176,16,47,176,17,51,176,18,51,176,19, +51,177,13,8,237,177,49,8,237,177,50,8,237,177,51,8, +237,176,6,47,176,7,51,176,8,51,176,9,51,177,28,10, +237,177,29,10,237,177,30,10,237,48,49,19,55,22,51,50, +55,54,53,55,39,6,15,1,34,39,53,38,61,1,52,55, +54,51,50,31,1,21,23,22,21,20,7,6,35,34,39,55, +52,39,34,49,38,35,34,15,1,21,7,21,6,21,20,23, +22,51,50,55,54,53,28,43,11,50,61,19,5,1,1,27, +52,8,65,30,14,54,27,34,72,34,1,4,15,60,30,41, +76,22,179,37,1,14,18,45,20,1,1,7,39,15,19,52, +15,4,1,189,4,58,79,24,28,2,8,43,4,1,58,1, +27,33,1,73,34,17,64,1,1,8,36,67,132,43,22,67, +185,54,22,9,45,1,1,1,1,18,21,50,21,8,52,14, +15,0,0,1,0,0,255,243,1,2,2,234,0,3,0,20, +176,0,47,176,1,47,176,2,47,176,3,47,1,177,5,2, +47,204,48,49,21,19,51,3,212,46,214,12,2,246,253,10, +0,2,0,21,255,249,1,5,1,112,0,12,0,31,0,113, +0,176,7,47,176,8,51,176,9,51,177,10,7,237,177,17, +7,237,177,18,7,237,177,19,7,237,176,26,176,10,16,222, +176,27,50,176,28,50,177,1,7,237,177,2,7,237,177,3, +7,237,1,176,0,47,176,1,51,176,11,51,176,12,51,177, +13,8,237,177,14,8,237,177,30,8,237,177,31,8,237,176, +21,176,13,16,222,176,22,50,176,23,50,176,24,50,177,5, +8,237,177,6,8,237,177,7,8,237,177,33,6,16,204,48, +49,55,52,51,50,23,22,21,20,35,34,39,38,53,55,20, +23,51,22,51,50,55,54,61,1,52,39,38,35,34,7,6, +21,21,120,85,26,8,119,53,30,37,47,20,1,21,31,31, +21,21,21,21,32,31,18,23,181,187,101,32,54,187,38,45, +102,2,90,30,30,30,30,88,2,90,30,30,27,33,89,0, +0,1,0,55,0,0,0,191,1,112,0,13,0,42,0,177, +0,15,63,176,1,51,177,11,9,237,177,12,9,237,177,13, +9,237,1,176,1,47,176,2,51,177,0,8,237,177,13,8, +237,177,15,0,16,204,48,49,51,35,17,6,7,6,7,53, +54,55,54,63,1,51,191,45,17,26,26,21,37,29,27,12, +1,29,1,31,16,15,16,8,44,18,25,25,23,1,0,1, +0,15,0,0,1,2,1,112,0,38,0,101,0,177,1,15, +63,176,2,51,177,0,10,237,177,38,10,237,176,14,176,0, +16,222,176,15,50,176,16,50,177,23,7,237,177,24,7,237, +177,25,7,237,1,176,2,47,176,3,51,177,0,11,237,177, +1,11,237,177,28,11,237,177,29,11,237,177,30,11,237,177, +31,11,237,176,28,16,177,9,8,237,177,10,8,237,177,11, +8,237,177,12,8,237,177,25,8,237,177,40,0,16,204,48, +49,37,21,35,38,55,54,55,54,55,54,61,1,52,39,38, +35,34,7,29,1,7,39,54,63,1,50,23,21,22,29,1, +20,15,1,6,7,6,15,1,1,2,242,2,36,21,38,60, +21,21,41,13,15,56,13,3,46,8,82,29,70,31,13,38, +1,21,48,52,13,6,43,43,38,42,24,32,49,28,28,25, +1,43,16,5,50,1,1,22,5,89,15,2,50,1,22,28, +1,44,43,1,23,41,44,17,10,0,0,1,0,21,255,249, +1,6,1,112,0,51,0,133,0,176,47,47,176,48,51,176, +49,51,177,2,7,237,177,3,7,237,177,4,7,237,176,11, +176,2,16,222,176,12,50,176,13,50,177,15,0,237,177,16, +0,237,177,17,0,237,176,24,176,15,16,222,176,25,50,176, +26,50,177,31,7,237,177,32,7,237,177,33,7,237,1,176, +19,47,176,20,51,176,21,51,176,22,51,176,33,51,177,37, +8,237,177,38,8,237,177,39,8,237,177,40,8,237,176,6, +47,176,7,51,176,8,51,176,9,51,177,43,12,237,177,44, +12,237,177,45,12,237,177,53,44,16,204,48,49,63,1,22, +51,50,55,54,61,1,52,39,38,35,34,7,55,23,50,55, +54,61,1,52,39,38,35,34,7,39,54,55,54,51,50,31, +1,49,22,21,23,20,7,22,31,1,20,7,6,39,34,39, +38,22,44,15,57,47,21,8,40,15,17,13,19,5,7,55, +16,4,34,12,14,56,10,45,13,63,16,18,61,30,1,15, +1,51,59,8,2,57,30,37,71,32,11,97,6,72,41,16, +18,1,47,18,6,4,39,1,38,11,12,1,38,14,5,66, +8,73,17,5,43,1,22,28,1,51,24,13,60,17,65,32, +18,1,57,20,0,2,0,6,0,0,1,4,1,111,0,10, +0,13,0,111,0,177,0,15,63,176,10,51,176,1,222,176, +2,50,176,8,50,176,9,50,177,3,13,237,177,6,13,237, +177,7,13,237,177,11,13,237,177,13,13,237,177,4,6,16, +204,177,5,6,16,204,1,176,0,47,176,1,51,176,11,51, +176,12,51,177,5,8,237,177,6,8,237,177,9,8,237,177, +10,8,237,177,4,6,16,204,177,8,6,16,204,177,7,6, +16,204,177,3,1,16,204,177,2,1,16,204,177,15,7,16, +204,48,49,51,53,35,53,55,51,21,51,21,35,21,39,53, +7,166,160,168,36,50,50,44,115,88,41,237,237,41,88,129, +165,165,0,1,0,21,255,249,1,9,1,106,0,36,0,106, +0,176,32,47,176,33,51,176,34,51,177,3,7,237,177,4, +7,237,177,5,7,237,177,6,7,237,176,13,176,3,16,222, +176,14,50,176,15,50,177,23,13,237,177,24,13,237,177,25, +13,237,176,20,176,23,16,222,176,21,50,177,18,10,237,177, +19,10,237,1,176,8,47,176,9,51,176,10,51,176,11,51, +176,25,51,177,27,12,237,177,28,12,237,177,29,12,237,177, +30,12,237,177,38,29,16,204,48,49,63,1,22,23,22,51, +50,55,54,61,1,52,39,38,35,34,7,39,55,51,21,35, +7,54,51,50,23,22,29,1,20,7,6,35,34,39,38,21, +47,9,47,7,8,51,19,7,46,15,17,44,22,43,36,182, +146,20,33,36,66,32,16,57,30,38,76,30,9,96,4,58, +10,1,49,18,21,1,59,19,5,35,5,189,44,98,23,55, +28,35,1,75,36,19,60,19,0,2,0,12,255,249,0,255, +1,112,0,31,0,49,0,129,0,176,17,47,176,18,51,176, +19,51,177,35,7,237,177,36,7,237,177,37,7,237,176,44, +176,35,16,222,176,45,50,176,46,50,177,8,13,237,177,9, +13,237,177,10,13,237,176,2,176,8,16,222,176,3,50,176, +4,50,177,25,7,237,177,26,7,237,177,27,7,237,1,176, +21,47,176,22,51,176,23,51,176,24,51,177,6,10,237,177, +7,10,237,176,10,47,176,39,51,176,40,51,176,41,51,176, +42,51,177,12,8,237,177,13,8,237,177,14,8,237,177,15, +8,237,177,51,14,16,204,48,49,19,7,38,35,34,7,6, +21,54,51,50,23,22,29,1,20,7,6,35,34,39,38,39, +53,52,63,1,50,23,21,22,23,7,20,23,22,51,50,55, +54,61,1,52,39,38,35,34,7,6,21,248,45,13,49,48, +23,13,32,57,64,30,14,52,27,35,57,35,35,1,117,15, +73,24,5,2,184,36,18,21,46,17,6,41,13,17,47,19, +7,1,21,4,58,57,30,55,49,57,28,33,1,73,34,18, +41,41,94,2,184,11,1,63,1,12,14,159,52,25,11,49, +16,19,1,56,19,7,44,16,18,0,0,1,0,24,0,0, +1,6,1,106,0,14,0,44,0,177,9,15,63,176,10,51, +176,0,222,176,14,50,177,1,10,237,177,2,10,237,1,176, +0,47,176,1,51,177,2,14,237,177,3,14,237,177,16,2, +16,204,48,49,19,53,51,21,6,7,6,7,6,7,35,54, +55,54,55,24,238,71,42,6,4,14,3,46,5,86,18,19, +1,62,44,35,75,120,16,15,46,55,140,129,27,22,0,3, +0,20,255,249,1,7,1,112,0,29,0,47,0,65,0,203, +0,176,20,47,176,21,51,176,22,51,177,51,7,237,177,52, +7,237,177,53,7,237,176,14,176,51,16,222,176,27,50,176, +60,50,176,61,50,176,62,50,177,33,7,237,177,34,7,237, +177,35,7,237,176,3,176,33,16,222,176,42,50,176,43,50, +176,44,50,177,5,7,237,177,6,7,237,177,7,7,237,1, +176,24,47,176,25,51,176,26,51,176,27,51,177,48,8,237, +177,49,8,237,177,64,8,237,177,65,8,237,176,1,47,176, +2,51,176,3,51,176,23,51,177,30,8,237,177,31,8,237, +177,46,8,237,177,47,8,237,176,37,47,176,38,51,176,39, +51,176,40,51,177,9,8,237,177,10,8,237,177,11,8,237, +177,12,8,237,176,55,47,176,56,51,176,57,51,176,58,51, +177,14,8,237,177,15,8,237,177,16,8,237,177,17,8,237, +177,18,8,237,177,67,17,16,204,48,49,55,38,53,52,55, +54,51,50,23,22,29,1,20,7,22,23,20,49,20,7,6, +35,34,39,38,61,1,52,55,50,39,20,23,22,51,50,55, +54,61,1,52,39,38,35,34,7,6,21,7,20,23,22,51, +50,55,54,61,1,52,39,38,35,34,7,6,21,90,54,54, +23,28,63,29,14,54,67,2,58,28,34,72,33,16,65,2, +6,37,11,12,40,14,5,35,12,13,38,16,5,15,40,16, +19,48,19,7,41,16,19,47,19,7,199,20,55,59,25,10, +46,22,27,1,53,20,22,69,3,67,30,14,52,26,33,1, +72,20,77,42,13,4,34,10,11,1,39,15,5,32,11,12, +170,48,19,8,40,15,17,1,48,20,7,40,15,17,0,2, +0,21,255,249,1,7,1,112,0,33,0,52,0,133,0,176, +29,47,176,30,51,176,31,51,177,2,7,237,177,3,7,237, +177,4,7,237,176,11,176,2,16,222,176,12,50,176,13,50, +177,7,13,237,177,8,13,237,177,47,13,237,177,48,13,237, +177,49,13,237,176,39,176,8,16,222,176,40,50,176,41,50, +177,20,7,237,177,21,7,237,177,22,7,237,1,176,15,47, +176,16,51,176,17,51,176,18,51,177,13,8,237,177,43,8, +237,177,44,8,237,177,45,8,237,176,6,47,176,7,51,176, +8,51,176,9,51,177,25,10,237,177,26,10,237,177,27,10, +237,48,49,63,1,22,51,50,55,54,53,55,39,6,15,1, +34,39,38,61,1,52,55,54,51,50,31,1,22,21,20,7, +6,35,34,39,38,55,52,39,34,49,38,35,34,7,6,21, +20,23,22,51,50,55,54,53,28,43,11,50,40,22,23,1, +1,27,52,8,65,30,14,54,27,34,72,34,5,15,60,30, +41,76,22,3,182,37,1,14,18,46,20,8,39,15,19,52, +15,4,85,4,58,35,36,60,2,8,43,4,1,58,27,34, +1,73,34,17,64,10,36,67,132,43,22,67,11,174,54,22, +9,46,20,22,50,21,8,52,14,15,0,0,0,1,0,0, +0,0,0,0,233,217,10,104,95,15,60,245,0,19,3,232, +0,0,0,0,184,207,153,237,0,0,0,0,184,207,153,237, +0,0,255,52,2,246,2,234,0,0,0,8,0,2,0,0, +0,0,0,0,0,1,0,0,3,32,255,56,0,90,2,142, +0,0,255,152,2,246,0,1,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,25,1,176,0,33,0,0,0,0, +1,77,0,0,2,142,0,7,1,15,0,21,0,235,0,55, +1,31,0,15,1,23,0,21,1,23,0,6,1,30,0,21, +1,28,0,19,1,25,0,24,1,28,0,20,1,23,0,21, +1,27,0,0,1,15,0,21,0,235,0,55,1,31,0,15, +1,25,0,21,1,22,0,6,1,31,0,21,1,21,0,12, +1,25,0,24,1,28,0,20,1,31,0,21,0,0,0,1, +0,0,0,158,0,1,0,24,0,96,0,4,255,208,0,4, +0,4,0,0,0,4,0,14,255,122,0,5,0,5,0,0, +0,5,0,14,255,152,0,6,0,6,0,0,0,6,0,14, +255,150,0,7,0,14,255,122,0,8,0,14,255,122,0,9, +0,14,255,115,0,10,0,14,255,115,0,11,0,14,255,92, +0,12,0,14,255,115,0,13,0,14,255,115,0,14,0,14, +255,211,0,14,0,15,255,107,0,14,0,16,255,85,0,14, +0,17,255,107,0,14,0,18,255,115,0,14,0,19,255,92, +0,14,0,20,255,100,0,14,0,21,255,107,0,14,0,22, +255,130,0,14,0,23,255,100,0,14,0,24,255,107,0,0, +0,0,0,43,0,43,0,43,0,171,1,16,1,64,1,172, +2,58,2,140,2,246,3,128,3,180,4,125,5,19,5,42, +5,146,5,193,6,47,6,188,7,11,7,118,7,255,8,49, +8,241,9,127,0,1,0,0,0,25,0,70,0,3,0,0, +0,0,0,2,0,0,0,1,0,1,0,0,0,64,0,207, +0,0,0,0,0,0,0,26,1,62,0,1,0,0,0,0, +0,0,0,65,0,0,0,1,0,0,0,0,0,1,0,9, +0,66,0,1,0,0,0,0,0,2,0,7,0,76,0,1, +0,0,0,0,0,3,0,34,0,84,0,1,0,0,0,0, +0,4,0,9,0,119,0,1,0,0,0,0,0,5,0,7, +0,129,0,1,0,0,0,0,0,6,0,9,0,137,0,0, +0,3,0,0,0,0,0,130,0,147,0,0,0,3,0,0, +0,1,0,18,1,23,0,0,0,3,0,0,0,2,0,14, +1,43,0,0,0,3,0,0,0,3,0,68,1,59,0,0, +0,3,0,0,0,4,0,18,1,129,0,0,0,3,0,0, +0,5,0,14,1,149,0,0,0,3,0,0,0,6,0,18, +1,165,0,3,0,1,4,9,0,0,0,130,0,147,0,3, +0,1,4,9,0,1,0,18,1,23,0,3,0,1,4,9, +0,2,0,14,1,43,0,3,0,1,4,9,0,3,0,68, +1,59,0,3,0,1,4,9,0,4,0,18,1,129,0,3, +0,1,4,9,0,5,0,14,1,149,0,3,0,1,4,9, +0,6,0,18,1,165,0,3,0,1,0,0,0,4,0,34, +1,185,0,3,0,1,0,0,0,8,0,44,1,221,0,3, +0,1,0,0,0,11,0,46,2,11,0,3,0,1,0,0, +0,13,0,6,2,59,0,3,0,1,0,0,0,14,0,36, +2,67,67,114,101,97,116,101,100,32,98,121,32,65,108,108, +101,110,32,66,97,114,110,101,116,116,32,119,105,116,104,32, +80,102,97,69,100,105,116,32,49,46,48,32,40,104,116,116, +112,58,47,47,112,102,97,101,100,105,116,46,115,102,46,110, +101,116,41,0,108,67,83,121,109,98,111,108,115,0,82,101, +103,117,108,97,114,0,80,102,97,69,100,105,116,32,49,46, +48,32,58,32,108,67,83,121,109,98,111,108,115,32,58,32, +50,45,51,45,50,48,55,50,0,108,67,83,121,109,98,111, +108,115,0,48,48,49,46,48,48,48,0,108,67,83,121,109, +98,111,108,115,0,0,67,0,114,0,101,0,97,0,116,0, +101,0,100,0,32,0,98,0,121,0,32,0,65,0,108,0, +108,0,101,0,110,0,32,0,66,0,97,0,114,0,110,0, +101,0,116,0,116,0,32,0,119,0,105,0,116,0,104,0, +32,0,80,0,102,0,97,0,69,0,100,0,105,0,116,0, +32,0,49,0,46,0,48,0,32,0,40,0,104,0,116,0, +116,0,112,0,58,0,47,0,47,0,112,0,102,0,97,0, +101,0,100,0,105,0,116,0,46,0,115,0,102,0,46,0, +110,0,101,0,116,0,41,0,0,0,108,0,67,0,83,0, +121,0,109,0,98,0,111,0,108,0,115,0,0,0,82,0, +101,0,103,0,117,0,108,0,97,0,114,0,0,0,80,0, +102,0,97,0,69,0,100,0,105,0,116,0,32,0,49,0, +46,0,48,0,32,0,58,0,32,0,108,0,67,0,83,0, +121,0,109,0,98,0,111,0,108,0,115,0,32,0,58,0, +32,0,50,0,45,0,51,0,45,0,50,0,48,0,55,0, +50,0,0,0,108,0,67,0,83,0,121,0,109,0,98,0, +111,0,108,0,115,0,0,0,48,0,48,0,49,0,46,0, +48,0,48,0,48,0,0,0,108,0,67,0,83,0,121,0, +109,0,98,0,111,0,108,0,115,0,0,0,108,0,105,0, +103,0,110,0,117,0,109,0,67,0,65,0,68,0,32,0, +83,0,121,0,109,0,98,0,111,0,108,0,115,0,0,0, +108,0,105,0,103,0,110,0,117,0,109,0,32,0,67,0, +111,0,109,0,112,0,117,0,116,0,105,0,110,0,103,0, +44,0,32,0,73,0,110,0,99,0,46,0,0,0,119,0, +119,0,119,0,46,0,108,0,105,0,103,0,110,0,117,0, +109,0,99,0,111,0,109,0,112,0,117,0,116,0,105,0, +110,0,103,0,46,0,99,0,111,0,109,0,0,0,71,0, +80,0,76,0,0,0,104,0,116,0,116,0,112,0,58,0, +47,0,47,0,119,0,119,0,119,0,46,0,103,0,110,0, +117,0,46,0,111,0,114,0,103,0,0,0,0,2,0,0, +0,0,0,0,255,156,0,50,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,25,0,0, +0,1,0,2,1,2,1,3,1,4,1,5,1,6,1,7, +1,8,1,9,1,10,1,11,1,12,1,13,1,14,1,15, +1,16,1,17,1,18,1,19,1,20,1,21,1,22,1,23, +7,117,110,105,50,49,48,52,7,117,110,105,69,48,48,48, +7,117,110,105,69,48,48,49,7,117,110,105,69,48,48,50, +7,117,110,105,69,48,48,51,7,117,110,105,69,48,48,52, +7,117,110,105,69,48,48,53,7,117,110,105,69,48,48,54, +7,117,110,105,69,48,48,55,7,117,110,105,69,48,48,56, +7,117,110,105,69,48,48,57,7,117,110,105,69,48,48,65, +7,117,110,105,69,48,49,48,7,117,110,105,69,48,49,49, +7,117,110,105,69,48,49,50,7,117,110,105,69,48,49,51, +7,117,110,105,69,48,49,52,7,117,110,105,69,48,49,53, +7,117,110,105,69,48,49,54,7,117,110,105,69,48,49,55, +7,117,110,105,69,48,49,56,7,117,110,105,69,48,49,57, +}; +const int lCSymbols_ttf_size = sizeof( lCSymbols_ttf ); diff --git a/engine/libraries/oglft/tests/background.png b/engine/libraries/oglft/tests/background.png new file mode 100644 index 0000000000000000000000000000000000000000..3686224f78b278cad73fd15edb02d2afe2d20825 GIT binary patch literal 475337 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 rlk-I2)bgghK0pAdm!6 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�u``X`r%>0sKs4#pVYdW!0t4iqT%ZvASN8nqNPbqYko}awALb z?HokHp-v-fEK;M0w>?t&CqIsKX*j4q-lOqp0U)>DvQ<&Iu^2|3%fECt#MwgwB7D<9R=BaCp+DqV$CdqiXr;T|wfMqL?E z`+S$cJNC_pxUyg6-V^;s(B7m;eon=!8mt{tzX0q>^Bj+mgNdliOU}xLaodrOcpGEL zn~EJAq0c_){weEFW|YdzhyNO|H3c|Q{}h>D1^43jfBFJYt;&(IlYV}sA5S69I^73^j2y3lna6N+PAON9=j+$SrLok>c!E=Y{aUhwPWghRZpoD9GjbzjY-+RsE9P z#57HKSX5w#7;^j7f^vA>z;Eu~(&HPuhW?cX{Z{-amxK2???Kd4hG^>9`GnITcZ~V( z#Z1x2D|jGJqAj-Ho&J4x>HPf5R-Q+ZKnGa2O5l@ZH4BTX9AE^0cHB6=BHm>H7!%?3 zy!%PNGg-rMx6oX!?3Vr`Y_GQq^=YN-xayQ5KZj**x zJ9l>pewhD?Q+F5sf{!ZFPBef2($HAxS5r}$lB0L_F8BlY%N{yiDgH^4oh--x*pn$&Vh|ozr8k;#8LMV zWJZUou5Yw;9bJMLI$> zG(ElnLQ^?0UstM%>JVGEe0R znK%VW#bxfV2gZ;ILmk)4=t!pWMfbCv^6NWR*zCRhuNTsVUiXNWt9NGvo!q?L`+-md zpMc2L0*q*qwVF+81O@{K67z}tG1KHnDOaVB@=?@#5iMIgUaGrnpY!XqQSuX#T=LBOYw)(ecH2@xoTM+t5>t5xmW`{xxc^bSd{5(r{s{5T^_?}?|RggXpFf$mRw(}pgu>Nek(!y28xD-bxFIi zlx2t!IR*yjPuJ`Lcmnh00;NAtEMuq_+(!>x2Rz&QS|Q`M?F0r}+3(CijCwXILLk@K$3+?~ug%NxazE&03I@+U z-^s3N(XIL>yT_EtsfHkz7?^;O5( z+v1oAXkIq_g6V%!6%T^GtH!;*%xWs7V|;KqK|o2xlUJ}{`P625pABwyX*O5G|5{3Q zh`%-DNmHvoKCB?Q)YR^KpA%EBKB=Mt`{!xqFn)QlK);_&!ow(MU9Cy<&{JP!7cP=8 z=)1udrW*8<-c=?#xMysikCU3-MlET34GTLNmJlhgkoJjQhsXlM41IE>G=vH(-UMsU zQzxwibg)cV4)|sO7YQhp&VUESpkL#(!!1bN!R+jCr9eZ*IrK>L3d1wF4lD@A-Sib}GE;{*p}m#%<6 zJMVmB*tRPz+U4B#($04xIn!_Ha+*ka2I_9E{*zZ;yU@6}=Ac^^B?I+T zd<#`Tz|kIO1Xx@^7lpOp2&R4&&jsfxVw_Qa!q=_;y}oktfFdOa9A5=GNYiKPit$z()orhy zThd~DdK&Dr64?&8T!pN{?{UPD#IQAW^YC5&58??u^5C4tO09G%ic?{KS>m5w>A;qG z-;KY4p0n=Xcjydy?)(4X;nhdZI^t;~%i1|;f~{qRC%&*`8I#5o3pq`5;{2T7a7R_S zS}2qlaD*7lMRK#gU+$y@)aZpkti5OJ;jiCRQL^!@t@uUx_W*WezW=M=@yUre(loMA zAWwEec%<70GpoQZ2?C=eJpZ#$vj0fS;s(}4M55WtodmV3HV(cKk@Bnyh0~GN*=8AJ(Z*x#-4nOYFFotQ7eXq)b5q*eVAz zRaN*j-tLOp-9Nt7Wrb~sMEr;v8LbvXs9fZ87>T91$!$NYDjwyCUU7YRz~^zZcA%$K z7rWervI0YK*yHV~+v%F{uK{xCMYNobv+GmRTnx|v)H&hGQ%=YDul<>)?HYe*%7~*1 zWwfr~uP+C!c_aDzhmte)f}yFoN_RXd>D2XtDuo95I>~F{0q@I&$)uznezySI)Y{#z zgIe@1o)@}@@lG9mqR;gJB_Dcv-u2WLG`0SE=*5-IeYuO1PGDU!muK;PSV@2I<}hiL zA$k{52*WYMnqBtJ_`Qr3d+aUVJSic5HG4`bSh_6tY5tde{}oCD#h68TWmTcwPN5E+ zluim)K#7Blv69;H;m1MNbF3$B3_iNpT1)#Ft|dhqvz?6+=_#){PxDDtbBr(cP;Q{x z59{q>vt5vz;#(c^=nlumWdLqDd9m7-#Ig1-LlZZ=iM)*T=zW^Y>6(Ga-3GP;Wmt!S z;52$(CoW3SsUJ|o9s^4%qLW^zS-BXi3+pUB(rO48!rBoug%lnMEN1J{$V>UG%8SKB zYum?J?l_DoH(kCnAdrTB>%|8@H>3RgCEuIg-JbPj7ksHB_cy13PkP5%%{XTu?yGb; zx`_3 zsPm>sNgeuypv+%uLV{27hyz>WPMT;Q!q=Y;IbSv&^UrQVp?3qUBD)Ls3P2f(rQ)z? zz)MKkskVW^3>W$s>}@uGB}b*E-3PK30g?S(iwO;)k(iLb4HT77HX2xj38)1;O&@=; zF=S=Ndv`RFbBfs1@tYVj;mkrih5|v}2>GHkWTh(~{DUjq?tFsC>JK+_Cn{YPjQd@U zVZMp!P-SJV4`ZKlN)+1{K#%IydT=K+HP-Br8Iq zu>7Kh_Me`<{;H8uj;53r@IDZz9?XY7KRT)6BUlkIBIOB<{V{Ynk8D>Ij35j{S!#4D zFf2$N)*bJ9-o^~7Y&6m0bq^R51a^dcD-noZ!NK`2`LBYhoP3N(qk%|wKbpNx9X>ur zDE?ceKK49bWF!r`MAviAYCFVTWuid}b-Dua>bu(mBT>B{sPX^kwLjj$g_s{)^0 zp04sI5is0FvXA1Cdn>CL)q1_M&~`l{cHTd6A_aG%0O}mz#4p{WgodSC8CM&sRPy9YRFE0kKfq8@J?CySmG0)~@-j z`6rTGp4#$2?_xYbhYsDGu|qOW96&1u1(sReHxfjFYUBQ6}A%MMLw0IB(6k zU3u5qDFfEOr0@d^{1qG3;-rJNG;%aNsY!P=lZGVJuNqkY?*$;jmwWLw)9M^%FqIAa zG!Z=77BFS zQlUAlCWOZc@?vJDWxi+YpdAoH5?&;HaP0mAN#V*q`H+gI1H6aSIkFRz?&|Y9yu~~0 z`i)Kz8$P;B0xi3!h77XN>;X=&eC5CJw1ovivd>>OCA)`$OT;Zgx`;nZunIj3>kMM32!K*nA;n_`tzx%-#_tY+N}2+Ps!On3MO_ z1DmGgR@Cy(!9tkEbewpF0$#GLYE<~zntOMtJ?2!u;zo*N)tFqhY{Tv~rqwKiN>;%Wiu!4((u zm&LP?Q{5>!_}iLga-f}SRA=DycUd#U!aWe+wg}T#rAHk z197F@Cpo6x%~Wx`oO5!DRojX1aPjitDa0CWaP+p~NMN}PU(xmK;&Ptwq#SLgZj zTe%;DY&>5ewPt7P20=By>b}jujX7gxH!4e=5$I8tipK{IL6W_M*uv-zL-qp2;|$AX z;H50HcRz>wOL&aFq#$I+4y#+%gWD{}9HAtoUq2Qz+vv~ieV4@EB`L$pzRt?POSYw; zJ5Bi_udZbERinqh)0jPX7X3M+OKx6CLF`+lq#{+ZO@!DShFPn@;S>sh@HYy2-Hd-m zqO*BOv*n=fA2!VFTZ3#*iBMm2Td=%`+6o{#WGe3cX~%M%S`!&E3L3d|A~P$3q~wka z>nop`lxWi6=_=Ehp_2nN!?dkGs|YDljG-QCw@KOl(j5-XK9@A256Pmt$)^G7raaqQ zhar6&+t>9&Liby|#3cVD-=_0Bb_QTVHWyd}NF_?TeT^71Xe>(#Pc7+fRD7l`?U>>~=l5b-sp*ns#c}{W0SB$xzApwH}Q5x+C*M z5cEVT@^Zl9w93r40`5V2in{;*+3fXiWDjAo4btCplx|mfam-SM&Yf|bvN>)$$ zm|C_-h>w#Mrku#&MInGhG6usdMhMNa8Q8OxTK6#5QPxrZ*_Ky6Wu&I*hT%wD`$y2Y zGXYnSog-8EZ)^C7{oo^6!0_6P(l1z!7nw-OWuC3T?!ltNOkJG)H&^0E&*x9Yo9F84 zP{F2bbe+8nO?)MILeWaM`MP7Z%)ANLbO%^i8YkJ6L-Pj*XaIMpCVqy&<>?S%l0n4x zHGmXwuhx%*0c84|xny)5%b&kSyzRIT@P?}_H1QQ_@!L+MuYT#yd2G!rX0CipNy|oH zh<)~)*bp{Y+JdY=;7x@;iPkdKD?Jh@M7)1?BHSBBI_aq^m6_3%7mOn?|4RJ`gUoE7 zHkX~0;1U&!@j}?|)=esA4`}Db`eTrziO(=3$6Lu(^B!59HeAuf_X7N_D`F} z_QySTQkQ*Rzo8TK{FD8m)Y!vEE;0%JMS2smeRlS3gVLkE?-n>C*%wW6C>gkm6oorZ z&wEhey>#;FW+_klRbvO+Vn}9c!efAd-lNbKN`)E3eUpH1Gw&;X*qTP4vB>4X8l)_5 zjgA;Y9RN=taFz6Gp)UCh_sZZExySCyOrTLQ#5>L+Oxd%oAJ{_xOzh=Z%o*brTexbb zON|+o=8@Ci`%PaH*r-7K7t4o7p~b()hn{4UByG7f<8)Odm!jr2J1|9zn^yK0M)=#x zdUTk#NKaifX^N=WNf$ko4Dmr#?1RWx<~w-r*Nd=FjS?+DX1}F%MOZk0Wbla!4hSgZ zS@}O+Asft{{S!Q$_GD(w>o9JE1MeO_K|$(=ZogBJ&x`}SDtTX)NJa#zo0xSBzobz6 z7#3hrk`tz})df$hX z*|c~Zee`i8M^M9wJ@(Yv=4k1^CjYJLL`O^g{0VwK;I9mN+ef76E4wAh9zKcs#ufCT zRs66k)6J|+j)iou>v>Z~)N{EYr-;b+hCm@LhQGdp-%{800zSn?ua=67ObMZVumeEg`0>N%BvaYE2#$xbgu|M5}5(f`(rPh^kv zHR3fzj)cMD4!kA^WWP zb4`uzH8Dx90)?0)aL2LD8Ko3WEX03ZZu#+~ofCdQ*l-o`mfl`EkN@Kw{Ut1n2+>a{ z=$v^C5vG-j-)4XadeEFM8Ifl&z*)SQ{&AEGajnaV+`ih1Ufp2VQ6>}e&@1Lrtk75M z2w*(a;F`3gV;0M<99PZUcCFw2WpgICX&=>-V28ZPZs={G2a}H2!Dj zGUgUNN0$m8EWGay0lSsiXadA>> z6<(ATU(gww_Slw}z!28d^Ihl6W*)B3`D-qn7p3Rz;UXuW_vq#HKNFAJprioP8A&~D^dZq+I#l^g-nZ;wt$#y#K&fAN};fR+l~PUVsz)JjJ%<=7Vn+r{8(n~ zTac>j50dc6Ca@HLDU6%TA+|o`E01(6fA}}~ht|P;eQC?mrK7%K?iw#(v*ftS_o+TD z;X_06;dDY6#iAF9E`7Axf7FwFvPrM(x)PxQ@8f$l)m#6|Hc;8On0h?ui~rN+60_K6 zs~$QkOUVE2=jTL%3qeZu{7D4ntPx#l&9p2g0#+}`wC_~K9BSZ0j0(SSSGR6oC0$19 zF6fX*x?q~`7q>KquIml{KOdA7A8Epo@C(i*v$D?#t(oIbj+aB)#}pts2{}1FdzW|et1)y+wPp3=A8X|(0Nc! zlZw+AZEl3vj1_dVz>eaek*i;;g)q0JsTNaU4@ty69A@^DJ--xqrW6BqIejV6>9H9zB&PA zalUQ!o*Q!0OzH+|#^0BE-z~n&nCM61buWnlaMQ=><702DnCAY5Ws`}7SWN+dfB0+9 zgQ-+~)%~iLkz3>17o{>hi-Gea&cF+(=LkPF^o@0W-@V{i^#1FC(^mrTe=+nH`FI+4lXV3>1Jv;S&>op$9cuv9;YqZr++*`KG=t2?r9i7i_8)`J4iUp*r1YDn0`zT43Jg{r}Sh|kRZ!j$5 ziqupBESW}7lnKe})pa}}D^TCMu$7`>&z|_>=;i;ioBs4fkbiM}53Pjik%|WNs07`( z8FmIv2s(8s8Jv1w?C7Pq;LU+`xJ_EUy4PYU9oIXCLZRzDxG`OygYGC;A0#A~PGYk07&Gzn-e&DzM@m@m*8`+u}3jQzMf=fwB z4_djzm?OPN>+^j!4JcDJm>Y>%#+;=PJM>}q=CI2II-B$txE+QLZDTzUl1CudmNIjm zcXY>|N!tIlRa4T?)hQAqn=K5*vR-*oy$rCi<&R(l91tBgmDyw;DSkoA^QCpK5t;%= zTMOsNk1_AEPJpiaeBkP%J$W;Y3?#GuwgtzGp$FZkzXCbGJk>q? zFfov?y4k>O%H3Q_OLJ&>fgq~gY#aiD{R5EC{)+*Ml`KPoRd^dTUVE|}&!;Cg^qrwd z5DTUK36NgiG7cIE^;+A!>1eah`pBzSa1m|lly5-heRIJLFSF9}Y6$4wL8u=PAq%?o zW4gHos}*5haEy#eh*67wBb)5x7aMe$T9j+Fp;|}p6YGE{wnrdI(#|C{oi_Wp_ZMT5 zx<1}0wR#R6Uieep^B-10USsqf*ON!g+m#gFm5_wjx^;VCc3|d}d`<|(`4q3|s)xjm zP37BLZ4-7tduk5mESt#~A_AO#i3F7H(io@@zCv-$b8UvL@ZzeftQ18WeD;w|-wvJP zSekILB`-xQ^#;|9b5DPghBwi5J6AgrVk$kHMv5@Kaq7n+k~JCMQ=3Cg$4aTF#S5JL z2?CJWj4q(1Mj^L$QVvql2%5nhy@Y&jl0@E@)&CvF`{t=t9J_PwW@gSLBH`28WY$&@ zMTcBr0k-XbGL`1Y%P9)W6n&fFpK#vAe)0QbTX6>HQm79Q%}x&<;{p%pF5ecd+^|ft zo;itVNd+qHUx?f4TPul;ds%SPQhn#*B-yJpkoxX{X@#5n*N^EFvP>W7Cr z&IA0IXD8F5R^PR=HHju9zClvV3L`g$xjsX2dJ#~tGE4YqnPPrr6g2k5p=|U-uy+}M z&*IsNmBczoKKp1c!It?|QJ&vkp3q=1aWGn;W1N`bYDbzKY;@2`=JZ!i`ax-~5MoxR zkChnu4V>7p$Ups7OATf3lK*6SyDrCJRh~tj`r{=ydm^qWkv>Be$24zZlLI8xUS21Nky`W{T=9Flw(JyH z$sxz3=^N~90{0H94ny`#*2sW9g02^cRZae-O0Vel8K!739rw4ojEw*aFaF~bHy2O& zb*>~^-n2HTBd){-&`!OE!r{b|X$CQM@eademXU#aUu}}ss3_mVrUEC=Ve}603)qyX z)X&fC%+qq)zwwfz*Zpt6N}^|X=cs|tM@~MsF9tai$OcN5Oh*d{{oQ()|6E^lq2#RI z0L}i#uqCwgukJ-VF}-F~C#H2s0yWM;l(kfheG zT-f`AA*G>^m?ovj(Uxlq^#`vVkCt889KEidVVC#F?k>Izu)|)1-+I4p2KAM9J)s9( z=D!-{2?t7861U}=31oi3LugyY*yi}0nS^x|C&5U$eNl_c+-9JZrq|$lCC-5o+;3T5 z%A^qOvcKw~CY+o?FChZ%5}Y-wlHmzMGX4}|j2=0H>t_SWnE9~q`0bF&za)1>Gpn_f zj-jrypxRE3iKwtb$4-1CZWwJ7O*LkaCi_Yld3w z$ziudxU6*zdHKeMaXwzq*fgfQ2hU3Yg*t(iOJ-Q>a*MLsLi655S4*m=A?pi1wKQt0 zPN4FI{Z&A`Y8u;3Je+5EzmX}@WaI8GOdLGzD%sY)%vRO==VjzfvgFivl4a5UC~JkE z9}O%8iH^ArFRRe`M|SaWms68R=H}aC3BS>{7><@FeX)>Q_3XX)<2YO=ub2)>k!z?j zRz$7(+x~^@l3|D{B0jjK#8kKqwXdp&_jtwW_+Lr zQN4O5ulGR^gLBiR9>6~oTa-VA2b(w)Fflfy2C-IsKwgbrNId#_kF|Vs8r=AC-&O5f z%7>4a!VnEp5=HUmM+4gbKox`Bp<>?d@;Gm=Nq0LyJFa~@grMRBxN^p6_cN4qBLH)I zSplqc@Zq7!LhH72$<7^(f>#2qa4-_hMhkjnP%?_z^pobh?ELuy$8L_Km)Z=_)@)yn zi-Bo@a$VNNLJy~ElF#j?{VCRj9>7`v-ggaOGkaNhga!%aDxK5URe8;uEj?idoyq(b z4dpsJ+3zw*ih|M5OOoMNXM}JwIjz1GGJ4&za&OC;N5~l&aShf8V}nd;vR0ZGBZvNX zG$t`DY5?CF((~{}5pK}qTz;WJAj!jpT&;tEFDqqx9n+3y3D=Rq#DK3%12`awomZCzq&AQg_H%~N z#Ah@pzd@3KUkM37MJd5!9o?wku$t}k749?$%%f{0nxslpd~UO28;q>7A)Yg1V)4S$ zh$0i%tEY!Lt>G=YFC|*VK~LAr>J8)D@Z_*rKPpIs?N1s0HmoA20s0>l+!{A`uI+Nz z+XH>ZkCJf>yF^mcB-Pp<&xBu&RbH^2guTTyQn#bK0pQpuZ+!mQ)d**J0^6wb_8vCN zSjjrfy<`VLK1FDm?m@ZNRfmPQqReqxw^n=nCsZ)2)e`iUfPm3d5h#(xGTXSXFGma9 zn0Y)sKbMI|GU&U9(Mv9=;sGb5!f6iGqbAuId)%<86mhBKA~+>2A)b(v$~AIJVEBG; zc~`Q)aj;Q&&pN`e`TZQSk7{%opX@9z>)O|K^LVngr+pteRSi5JWcj(cR+%a(xr&s* z2w5HF9qrt1kOKT_3Hs;YJKuq12_|Wgl>oiZV-HE$Wk}sPta6EBo}FTCa{^s9RCRcg zS1Kt@a?+iLmeqB%$h<{=+MQ$oL})ko_cQlTXXS62I(fqkI&9oH@O83>p(qiclHgd z{J5;(6+5Jhlk;Ycl84b;t(eMt@w#vLOodBni0$xu07Sov*X$qVtQUz5S|diN3^n+E zkPpQzL)HJ=w1EDd(o@6$G^hlHU}pkxW_~v z>pUFlA4CtRyZ1QgK^bIn}TvwNLf;9!o+D)06_bS;*Tb`hT%e87ndE zChlN~Q{Ez$>RC-vHiKiu#5=uoDzlWYJ>ZOw{4p@R3OvcBVr;dX+BEVHj;k%-Cvp{G z6qNmPi3GSwO*y$nSncHwx@B`y!)bbOy%P5BTn?rsr0=D^?wLeGtwrhG;wXg6v?&b#1)9PXp4lOuHLm3 z?qBU3XPI-Oy&JT+GE6GSB~XuLlusKAAQkqd@*YuC7`?fpj_i?Lr>N1Fojltw zCk4%uiL3B5R5|n}y^q!cj$sI0eoxV@p$@Cl7^GyL8C(!&lCi148(iN~??&6|$CAVTdH2Us71UD%SB1F3@s#ws+yGBuHf~B>p$;;D0M-8P<;?Fh!n#mEVC>37bPl<^pIB_$n&kmIy*#22LbM$D@-9fGkp{F6diX|Gp*VHH`d{|gD)=|wQ?Ud34_45)_ z3fVsHa)hW|1;k9?DYaR2tPNK=AsuJE$=+X@`qr9ER5jxEU{a97yfctg5`DlS7xGx* zGLW)^=5bo;cFYl8HUx^$d}GHHEerQZSqR%e{PkDS77|*SA#_pm>KMEH|6Tx91W1x^ z{+S3<2ifoCZy}zbGXoh-OFRwwpI(gM1X~*2g@G5+WSbHDq|5!+2cxr-|B>#90D6~| z6~VYAt|mb`R~w<4*g){}E_nx;b|dp0DL!|&tRp(_p2FL#u~@9ttZFNy%`A$$5A@Z8 z;W4+^sk7b(qvrD0ukSbpK!2Z|190QmUg)RY5hQs2aV#TYf)C3)GzJ~rn@ zn6vlghc;DfGYHo5jvqrrU$1To_t#`(n{VI=i%RHodHid{_}vHF2(wntB-es&TV+x$7-jx>!BJg=D}(i%#s; zdzT11)G6Vxo;MZAfKVFJ5gPFCWPR_ZI{E9#bkC97L)mvMnb53mlgKEFu>*hBtWGxL z*wSH+2hZlRJ-+n%E~D5lNJ^?{CCc-KEMqXyN;)fbIqkK!p%*XFP0ZJk{NK8{ZZA9Z z6PC;*gIF^kKXq#Xz3xv4VZ-jav0Y!8jYx~lhmPLUX7+yaGtb_R21+S?8Lw-wTKG8op-vKLO-g5Ti5 z_55uDbvhh~8;-yb?jv{bO}-CW!#GQ^p>pyih3Q$!SD#Zs4{0_gnJQLyo#jrt4+R;l zx4ZPFm9>IhDN6YHrV~J7bD;H-T?Jq|HJABwiErq-;Gi%>UG&xZ?A# zWV>!3Aeovkaie9c=XI?VG+A-*{1Ysj<6qC~Fb_J#B0}VNJGUzW5E28=lk$QMKk!**F-Gz@;yMjbmnP2`gNi(*tV&GF+?x2D!tOKUp zIjFfQ(i8uNG*ezMQ9|QDt?Wym8mGDbMM~nC?qa>=rD9Buoa*d%3^UZ_X$9lo!{^u%r!B2Qhz>53Y*^Fs+Ng`8CNlyG zVuTE#r#lHJu4+hV#kd7ddi>5F%rjDzs>MvQBSz5V({WRFGlAS%?PGR9zHX6wfa5sm z*=FhC62cud@$i;6>G|fP0tYklb*JMWgR0?6a56D6xMF>m^A4)e$bm@B=XuK4ze_qrZ>5Jhj; zu~MI0dEw!^o8+%|T~EBfp@;&eStLM_()1#F^52ldMThV*i%#u=l&#a(xuC790Y)`m zB;|SShL7?vcL5V5(o!x-vTEGoKrG?BF?os4NV20F7ZArt4&B<8Fshv5+r*`zp?Qai zzFV^1&^9~`@m;1{N3xkpEwm1Z>blSVo1^rpyX>xq`2HphKXnF~32dB&VWkD?Ehaik(!F)E_lN98rsi$#rL3=JdF-wU1s1kE#i0o~S)8Xm}ehrcMn@b93{~)p1JQuMACu&WaX3{*TMJ!Lx)piK=!Nu8~U;VGr$8IaP3 zH}a*ML8KWak@8w?WGR6XKwi&g3tbI71a_$h@<{F}U7e~=@*}*g_S~)r^RkhggGeCi zQdJ^;&sa&&yU()&fw*xDWAZoY4!lX=iR(a-Qo0*SyFb-SJJRPf#Sz5E6G#E9JmPrS zj-Tii=KP{5tTZiwp?*2MqeECf4|!bbXX2Vxp^R>k8^w^$zZ3RsRvSWc5_vMi_q>^n z2^0b-Keo{^yN(bg(3V!-2LFeQ)5N5Z(>Oa8e#9O6pMd!_mj5RR48_72sV{OcRVXAr zDwHTx^gbHfn1^uIM~7eh{Xz5ip@oIO7Vc4N9mF8Sh-m441lFSZiLXqZ6^?=&&oTM^JU zp8aQ87Csdxp!u;t_n&~ z%KqWf>Gdj^45&m~#4yVV^Bj#necHq{7I{}(J97Et)g@Iv{C6OlIM#*VVAZsJzhWv# z;aC7Xqm3x{i&q4}H9d9%eQJ02`(1WpkDrQa%DjQh9J+m0I5`K(C*MO&_e}Dh`vL0m zeS&uH>*&@azCT8;Y`J0p1jt9)WEaud$FtY6ezQ2@)Y<1Iy6e88%TiS_BOPC4*nuaE z?m7fW&=tQ|q_89kYb2#yhRxJ4`dM=R%anB$w1&qK@j9~UjAt;Vmn7T)$;ZBtqi`rG zab3;?C_Jv(hEG^{bG4XqZ~dP1x<38sLaS>KGqEnq#DJdaw+V6V9(b89rLKfd6o|R{ zg3FRX!E8&-{oNbFZw|s`;n!wM&BaWNvWY9YIcaKAqF1xb+=S)a8j11Q{!(dR+2B9C zz)nBe>)*Nwdp7W-yXXwq*5f-pm6*1{3L3@8J+B?ZMCbrVo8{Tpu>j8#v9A)}IhJP^ z(E}3{2TrmP!!}x09PS@R=2U;Y)k?Q=cTmc-_^J`?M1+#Aimw)%sm#D}bY`G(CTsxh zvnDsyD5ZSBh*31kX;l1$JZCGhbiJiu#L^P*$a7S|jY1ybL-rFu%sq!5&FG`OJE~CN z!uikd`XcrC-M*VnjHvxfGLPK+A8|l&DKWCA$c$s2Doz#?4w&zFk1XG-g zY>#=RF-I-4s>jz1-+Jn?*-N3*`*Q9R_VUrg|9y}@b$^(qGMNpto)Kp+VUy(DAUg9n z(8Vi6B0K6g8ABV>{6hR$?LXPKs|U5MgE^eHYj!V)Wd4j^xH3pziv?~c8(&_D)^2@Z z3*1tMUo3e5V~$h;>mCBY9-BD;Enc&7@|5{|=_%Gq|(fmP-J2&0$1{Ab=x3;GH(2!8g7YU+HtF{2K>F(oY`sj&1q{e;) z-+|Mwtx;$nyETI!g2mjR5Lw0`MP)Mk!PWDM z6L>T@<3zEFwVE(Iu8M5&l(?#zry>P0-Zv(XnG=BFl=nxCo(NW*HLR{We4AjeR_NiA zI47;Z=Rdxt`%|hO2#npRHs01dqh7a-fD=Z#Nso;Ep#!RGMvJ{YkCWdcY)UphtP^}06DY(1gW(Y$*3ub z8g_J;TE>#AR~|Rh#(ox~HszF6h{_Ng&UIS$2-XqT(4RExauYnWQX2L#2qNz=D=)abJSr*piW|os&`t0!8?q261XE9X-#jDe9O(2- zYbc>~7vNOIqHlS$=9cP*1=K27ERiQqU6Z|RPV363qg#@h$7U_tchKf8oqE)U)O&P# zx_lydx46Z=jPLh!j5pdVsVzIWYJb+$+_G)*Xa8G!L1iPvoOP!t@%FeoF}{muAa3^u zJnV%5W04Dr-}*EAHp#4&XfSRLkm{sVKRjQt){F#u00_mL*9q9=rqrk<4xAnlG=@S< z-S1|P_k0_{e8Z(F^J4dcri?iSD95CZTjACz+;V)9)tCJnR*`z?4qs9dkx=|ag1@7# z!`=f;hj(Fhb&dUA&Bk_KncQ9S3{^YCHKA7BF5=xDOP9VY-84yPfl=V%y!V(04PmGLM@jeZT_KUVNdsGpo7E*i&tD(Va0yL+9@up}g@=}1{c)el_WTMva=3U{s>)l;t+tl0~2XRR? zW961aa?6*hLf?@S^)id!1VP-6?{J{L`t0?ReN zDdltPEpv+4ue@(q_B0zXGYhTLE^ zX0WhJXpMVc?jjp5T+9&|UjknyFqc{W{aNB)i|M5PVLE=>V1ZQKii@Z3_!M`^COE6& z*~Pk;Et5?bJZqu+bY{;ppyYkMaq&=@7Qa)}y8oI*6k-htVvoYNCY7a5_v7i^r(3e` z{&)EPGU~)(yx~Z!S>B5grfJ2E0mblszLneum?&^z$AW1-krC?G5>)RcAoYgfYk`Pl zJBta{$*FKxy2EBhO8wk3CWR5xQ5>#r$|2bm-V;RlbuJRVc4mYi%A`%R$~rnN{zyCe z{8q3lpibv&>j>LHFjZJc!^6`e8gftpHkmwv0Gix&f_44e#$Qf%yhf%1UU?(8(u&>q z*Hn`;F;jXUCbh^1j~i$U25nZ|+VI&h;a0}v$E6p1t^SrWuY)yD?~8rB5xxOu3s?8v z%Uz_3ovKst2%S^lJ=LU9n?~*Hq@))ezJ{%!UENSgu1x;}7K~BF4c@~7UDo;M zb41ba&YNeqQ5ZQQTZh+V0WS}YT*oL+?Yq9J5V-f<5KaUtWgn9~* zDUIIv)c%v(PNy>cN#z|Q(MJPDFh~X@6k*?0ezEWBs+KOMFDrK%*;+(3Q;wT#+#pp?!w%hIr;{yEw9xacjJ~4^+^*q)(MrM{n zlb`E=OGm6@za?QIvOJD|-rApnO?h#8Iq$e!tpW#qIU@%9X@8w2D}IpdV6DzP9RAY3 zuOd(XT+evOGS;*|9WfZW*^vccAK*$;Z4%v73zH0CUGmdOYxIq3+)4bG6@cNg}l8&N3GoqCDpWOL(2o4 zI?JP6;JSt)ni)`ro1DICZ;9O|vFH7vz7`%}D9h^^?7FysxQ7Pd>Mb-lHn*I#e!B{ zOL-$ODt>fRQUauGMJi~lu@8j>o+oa+tWj`6B8{K#I^i9LT^}kWXC(+3vVuw=A8Cgojob7#hWn1rK~l z9wpLkraf92#%FWS0-v(pF}wPmZ#}hLt>aWVIz0dqsU`=H=hv9PzU|G}2~b{brjSpH z=<96YPkxafBNwuP&x5Om>)(6>lp$&Yg`r;B%3>rYc|PxURRRF1i2Uq8ZR)sfdV19n zgMEK@_q&V?{l|_$-^tS(G=hbNwySK**0owAKFAE$O>zxv7;tK))_ocKK6G{)whEqE ztZ8rU!&R(_Nezz3+nDRIYf!h`I29Nm43*%v{PnbZmjtkx9!WoBx;~xh_t6qpO8vth zFs(kv{WZ)rkiPiDNUuqlrbUN%!aqQG?4ihkf65U?CHE)iWcU$hah>}M2>?c~tK$Sh z=fkey=#dVy(+h&R5`TKMjj9)}rxRMl2=K_qk2h0mz50vRF!QP7MinC^SAt7?J=`Z< zngJuRf(hF=zojlm4vRO?f^#PIz8lt9_k{@~ku9{Mxwl)k8z?+sgtP>lUiC}!s4 zV*Pd1)7iT1+hQ!V&9Ug3$2pXe)fNOZ@fG*1e50K?6td}$C2CRLnQY{4cplxoy%@c7 zs>ga-Y}Z>qZVxuf#yZkFD>j-r8nmsRc-?RnoyL~-9A@)q6KUP9oTWJ5oNo1d9cKdg z=Oc<0&Nh~jd>wwbVddpa$${75iJy9#*!C1h2{(K@F#_MQY$h^hcsyiv`IyoEi0jc) zCybL@#oAgQ<$HNNgXS^+598L{aVi0!QwaV+ZPN7&cs#Pxxbon0oA z2it_}mb4NBAiP=-esFZ+;iIWa_O1yl#o-uWD@XBmgk)>pN&F%K2^gPa6=FA!%d17| z7r=(DAg!aW+K6`R{wEO|eivve-DZCVk~n*8z!mgR_^SsvYi`MnO^wa%e`uI#dw>Ba zA|cj})c2C`2Wgt1K`zl?z%lfr*@E&rmTlYQFYBdh$Z_72SZ-yURPFx*S?kydW-a!U1`3bk(lBuA`J?r5C8(xK6{aAJ^)UA|F=9SoCp&G=W zrSxl<2(A!DY&;rCDl}4EhTVl-{*)rqPE=O|d$6*vDlyw8><62h-vT@Ef0!Toq|5MO zN^W32e#oS=rIDC_QZQ#cl+1kPt-SrI+rFl*$r(&h!b?(Hi%mG`Fa zjcan*&;@d)+IzZ_+JJN}+e&ueCg46R&>CWS=%XH`Im-W8^bs>d5E^jrKlLjE4R8}e zl)#Bhd_w$5n|Mk88(Ey4g>jXZga=SUYQsBPTKaq^E7G@WA%yVjql6rzijcb5RKq@j zfJ6#|gg(T`Y|I!>dry*yPm_c)lP7h&Zib^6qOVk>6dDMhS8fvP6b6zkk<;j4zOVb$ zZ|SF}$szqz)3O!n9MtUS^|Y9|V!9Vq^UClH7a{2ITDr0H2rpm%Y+mRCBTnrC+WbUb zC!?!!p?F}^ipX@@{))z9ccenMbZBOX=A!g%tl>_z}qUTz*(8mNL|8?hKI0n z`cPi*zXCZOCtX%WbOO9WPSPr!`%MI15|dfqv-E67RNArK=o{4aD?pZzd=>Ax9uUnj zNf?&w;~RY^EWHI>{j8pzeMjOyL5r&Zc)7YO@E=@KfcRhsVT8-N$U; zC3)EU$p%gw*rQvqqNE4XJ*%s$&cBTS=&YDkm#)0^Nw|@{;9+ERY~2^;G*)ykSMN~* zW8q%QAOD%UL>hW5Zw@*Kj}MWHOmfbj(1AdMnL>P2tSCn9{Kby?4gQ~v5)_4K8+r7ROKkylxYL1np=#{D|J~+8ph`K={Vz2Y39i@FV4_L!oWB zvrnMqGUq+pi+8wdaz=)tW7UK%E92|+=U2Lor*nVDYTy9m*gqi{)x`H8rnQ>~-^98f z|NEAe_0wTXc1QwZo0sdv!lV&q{QGxWT6ADHFh{vn=(L7jq=t&xwsaP!MOp|$zM*u_ zXK$nlVo2C35oGl^ft)rMRH8N8@V`08W;a%j-=+Cf+zz5FZrZcT_GWWON0F_*TKeRE z;uW2-|5awd`6{Teuz)Dot$MD)Y{jGgh2fnr6-SYjp<-z1q6va~S#gr?s%w(vTA_T? z*!PslKbhkUwGdo5hlQDX>dVt*@*k>;M#e@L{f(2}uI{4_v+PpxgZ3xMG1(oxu-9Gl zuquE=t|vc8HfZXDf!ABFGJ~R-_-Q4aA&ALa1_;!TKyJPcPu)>xubu7sOMI($m{k(O zDv1idG5f(D*4ncFxStHbfUP;p$}+PpcfBRsj%>00^h%er{{5<_rudL8)tN2S=%}vjGj#JR}i(Xx`hej)5cKc}rlpCyR_JLcMq>N)QMz|<+ zD$YQF@Bgy^o(4t+&vjkz$1}<~>(%Vf8tNTH$-a{VI?uhPjw)Sdt306z=E$z9j=kZ* zjf1lHo|{mAAn%Av0DbSN;T zEzac|l+dw2O__k3h0Ts?lXSm6>#3^+T^V)l?$T3S!>D&I_#8%sR5=v>E{VuqdsCx; z0VF5?{e z_?eN#1!hbS7w7b?IG2QPUxr+o@g1c9^|LzQcypUKCbWOinuz>SM4?yZboRSn%t&)g z=i`=uowQogBDl$X!6Q_>>>`iR=Bxo{+F^N)u?F?)`^zm5^n2QKUELC-mbp}LxME&u z?O%aa`&~7RGY=*^#E!y-L^vqUMLm3`aVUm@0~4ON&~S4~)jX$R4`}2}0jHJN)KY^W z*=<9>`?39atHXCtQWk86JYWN0$G>^%?7*kC1$#5pxUvc@Z_p0T}@6aEg2(xQi^Ku$Dlv7GD=o* zr{8DTLgPAYL8O)R%0e%MG|PlU&Bam+^|&9P^N3@Ly1d*D(P|28ozg1Cu%V>g_R&_5 zwGPrd>u6hS8oQ_hYC1&wb=(4MvxrY0dMh&!d-MRAQD+Nyt-75-MK_voocDbLp0>IGbU?#yFm2Ab6{QSTI4 zSq$%sZG?>uuL;M-o$(A_(rlqTX2r0UtQPwR-=B3hGy!L(guqb8#KrMgv4?V2vM5y0 zywjYM7Qy!MmD5fhY*Lx*u6NB$z=W?gY*j~vFuCY%;6yzAQK@IyBlfQS3)zq%Co0^U z!gn=*E3WjI@WRD3L_DiEJ~O`SOCkMD7$V$_po)w<9ciH}W4KW8-w&oDty!gj0QkDR z#4wd;ljpNDC}13EqCOb1bTi-f0Qp|mP{^^fGbx;<8=2VZ)$=p_xH11sXjyN>UclJ`OI-xortA!wm8ml{BjNx_lNQcUOyZc{~uA8c+xAdW~mKv5$(9X@f z4xH;8?d>X%p*iTkXn5xiZyDQ*6s4$2zf@4q?(yWRO2R zCMwTm*K*+Zsk}moHI;N?T;xo-H7lQph*k5K=w<%1#d&JDYj6}B3(kh;LW~qbA&#S@ z5^^Ojkkc{z#J|o^Uu$EHq!xKd&w7VXT!|Ydg(@x=2##we)%vayd%!;*k*c^#8GoGg zn)aPh<=4+A!}Ip6@kLmu%bi_Xzsm=9Ww_=h*4KJ*0TPOc=>+vv0u=U$h#?yUq=yOF z>Ff%0jQ8Y)yGyN0j;Z4o?Y}c8ZDh_rjLb#Vosa+>$o{(xepA9dYZvVn)}Tc~kCm{_ zm)4w}OCqCDl-~@B$39H05;T(zYkz(T0Sx7CpU6=QiHpmA&g5{}FFKnqU3};^@aq^h z)X@)qmnYG%4cR}&N79t2?MN#wqaiyu6*Hl^p!=W)04Gze>MYP0?`JHnh6N92=fZE= zVgVN^5(-G(<7|C2A@RRz1}*#B~$!_M?_>I7ZTVSJz!;*XOH3d zLuy7jN@@;*mEFx=scSL-Hunxo-qIXHBeO(YVs9g{>ps&yC4!*z%f7>~2G?i82e8gPNp3CM^ZHrI;BM(BJ{0nTv1 z`2_}pHQtIc(~qBN26*gjw`QLc=S=f#i689ew-e%F6UZ9vX?e~+@$1bpqoxwE%~1=C zTCOmIHq-DBw6doic~=b$<8gt=AA9-xzJy;Sh!RtT#qtSB{ESrHVCq(x^jN}n+)V|J z$pqd*1MLh4-n@9F{?v-R9k(0-(0C=1SIB>T9Mi?fIyo;ncH<&43ryn;wyN_kt~yuy z;~DMQO!Pr0M+M+$h{wt)2`mv?V1VJjhdFGREKs0RQ>f8nUOFXa_gIG9JbuIGP?CC( zb-Fq~(nw_~nVhsuU+eoC^9x&xJBTV65|x?k?-e)PTfcI8OGTFFcT=!=k!yYU^>~fU zp^gf|((PG49@bw$Ti7+-{qE}Pz?D<>1;N|H+s@?M59ww z=DTjfDkrCiP+LgJP*#sE{}*JegaY_Ux1J-~{6B0Q_1ldq@-FomMW#F%?8Xt)FFQFv z+2J7=xMmv_Ka~EHDyYVWFFmk!`@a#z#KZ)Wc-#Ht>(+q{4Yjza8|oUmW^ z5X>Piv2M7by5TTXL?GxTPZ>20OPXC{`|Z#d=?9<)C z44kjVt?Zqgnp@io)*W_zf9u(Y2$;IIE+C*ffMO#(HlLs4tCngQKJIJD>+)4i7~?#W ziN0<*T}@xIe>=yx~r=)I_$Zgvo;SjhVT zEN#SoZDen*%k#5bT5~5#eJISFQpNY*)7h!f#iu7nEV=<(V^%U0-~IWbE+dKACI`3isJV-pdLudM6>HYU&e;d)1X%fcs=ZN!}Z6CAHBtgpBvuBeM zV3}D@0WfxS8SPK_j1@Z<>mg1>Q#4B}hAcYQFpg1nh3R<>MneT!E@jbgo{e;LsVNAi z|L&}-{v-$3l-gna*jQWZx~|#~q|dA)tvC?!x&Pkw&6i9;6m?N3-_duuAv~2~G=68t zeE+Ih=_BH#nY);%*JHP51#u15I`_a93h~c1B2hY`Y zN3RE<0=t$xeTPcmWWzc+oVB+XO%Uq53F>^)fF>&f!`ifxmV8iSlu#W5_i1v{`Isb9 za20pnm$?xWtw95$)ys{*3!q;Q4_#n_&NB_hL>`a>UkKik%7Imd`LH#+eAEs&NDstb`Kp6{CaQ*l72Wd-JhH=i8dO6P+n>Z-&I z54DUjr5Bka(X<+}oFG=R5&L1bEb-;C0i!J{nKBM*?i}+(QuNb?4;bj+_=+eC0aMK` z!V6+qywc+KOzt})wZ+pjIrh9HI#lt$6#;#BXw3-b*l8iM#e=||@vqnr*BXOqE|ym1 zpAx6J*gJ$>gy=Ekzkc==JMxfRc;Aw}Tyt!!uVW3!>F_e(ItUJZWuWEAn8k>zi?%yE zerNfy#knt4iITI|)8ylhMWZluEt?4jIlqM6Z3q;;kk5V{zJ$(x^5tQb7k}>;RX_Q4 z+G?f`MET(|50lYYfzO)C$BoqcY4>}$tYT(VCV3^l&=+Sn=DyC1Ryg#ryo^uh|9>nW79z%QFdV2X+q9BlYzXYP#{@=vC06;YLijW^-Ay%T zKX9T`eRzz2LMlmdC_Bj-cmt%@JVYx)3(E9QBeXZ*-tt&WM{mn?6Zyu0c-Fw(Lpi@X3# z7ivA8Gelo$lBH#g7jV60^cVhl{P{jC!-_Bd{$%ARnP-Onu?G{C;`}#fXXT9>RR7-I zSq&eGruGE)oEq(b_1a86+$=7~*@H`sAP#*%gg`LMPfEX>|HX*a>CC3x`aK-hihI`m zQ>JETwQ?2>e zC;P){S5E&^yBx>=m@d--^zia+iR~SmT3fq;8YKKZLu>w_tWeZRv|^Q`=kxwmHGgME zzwhMMbowBy4b7{Hbwaml|6V-!KlFJ;KB4{a9KW8x$C$Tp%#ab31Sui>nM6Dxch~rv z*xS`(U#DFe>z5d#+VbKN?fBoQ zJAA5ma7VF*?KA^emN#5KmBx zKPGb6pM6bZmX6_sDz}@rmev$)0*;k_Gb++OA#3gNqnE@!Zkgjpyy#k!nlHf9(7$zo zb#kL8fX}ru{?SkKep*9QQ3hs-I4DdZ_FhS9+A;#TapDFSw4+TcNsv4k{%8;69<8-q zU~;Tu#>vfpuJfs78)(0!3H@zciYe60Da7}sXK{N4>hfoIYdGCg^ghDLDEsO`$9Nmd zWxh83J8wW=D3$~2Qr}yODuvoVfqcSnbiXcJ>AJPJdg`2{MI{k)-CZFe?=Ij(zx{Rh zb{D!!_Iy-S{hd=)89 zWpJbNsd9qRgOp^VIEKs0qTXBZfWTX}1k&wo{n#)jB)&=&~Krt7Rll!+}z#Rf$ z0WlW!?MB>qdZ(49c)<@Y{Mle*+1%1129`cUl?SO>IrS@wnEasytp}3B5Oz?bDuyEC z+I2)HUC$m)y{Qf!34J6&XNFtyDSX6B7_kl*S@`CvNci~q%@&8q{ZO-C=M<}|tAS?t zwzcRJ(MG@vn(|5l#PU4OXQ5Vv`S<+g{j|Q{ia(;u$-z@)waxKd6lSG=AB)B z7aa)*nSku{&v2uclwSWG8@%7>{cSw=<@B32N(}R8Q*-&!nt{fGJ^&%u&QoMQz^ml> zYim)rf*qfC)aozJ38iTvz_r)b_U-IQ@sgV+`0{Zia>Zt4^RjeWQ600rqiH}3fyZ@m z%@K63m{O-#X)`FcaBa{gu;X~>eUGDijtFDNS>2j$g}L6pP_SjUZ*4y)zRR^yj0zgF zC@DFN{{^3~fNEN>barlzp?51PDH_kEK^YnMo+n36TncT6VGCIvoQJhxzYxQ$Fgkw9 zq7}E*zTXb|d_N2l-QM2jZW!~vycQmLh`)(m;Hm^U5J%-}sI2=8tz8lHeHjU`Bm7Y+ zRG9r>>+&5dDjwrq0`|b}n4;pW1K6$mNFQVAFUe)Y=1%cvIlce6?Y!Ta_k_Ru{p5UN z&tr}X&$^L$VY6^PAqYGF-1(fi7!wMVFK~My&frRapGh8&IJ#$)e&6o4CVlcXL#5si3oCizQ-+CYAg|pbcK^??@I)oiqCx z6$xNJgE=gs@d{lpYwduGm|BJ+;R?{Leuaw=pODGFh7vZ+CsSf;6cn!epzmzWI(2Z0 zDk}^&&jR&lafGh53U3nws zbEDh&-qgbw~5TS$*RG2(yN@Z3=u7Dv8v48>5&?vHlM&|QE17W39NfNe#d`;{D zkvlI(pOjjX6bloP<#m8C&H$1?Ze`N5c>?|EK>bd3+vuI{(bD_;^8joz=|6}vLv*5% zLG{1a{$SY=OC?5O59OmVj<}{gW{>QTMFo4TsC|(&C2eih?|3=>xbAc3zwZAS(fPJl zttwL|zDcqC#calgW+UH3Z4b8omqkxJ&3ZQtz=tW%)_h@^;z@{9gDg_-Z1u_-Y&i0X z5@_0H>$cpYOLV0|a!(iC$m-g}nEHpOsYD;{8=EVITN?^(zXH_-qjeY~i3$`t{84tJ z(Z*0!>uQ+XZupAGo1LZ)06ZT(LEZUrI8t3v#ZB#loIg-dLB%WV29UlmPFnVJqCyhr zw0hJEz7Y?i|6oJjp2E?ir97mzJm|m^xLg_QNWtO zaZS@WY2@<9_G0Lm7J=3K1{`m;IURx%kzHkH`w0C-t+#jW&}cl^$5(^#%6ehCkXei=<=P|1rD~K(^IO~ zr?_cgfRDl)wXKB@P$f9pG&i?OAN5UNNM?%!jE$yP+dIMflKGXTVS~f!e^Kf|RFuHX zX~MqIe762R)<%ygC}u}4lUhGIZ?QKo^N$UgZgmR73BB2B@*({Eo>U={SQJWrA9hNQ z+`fyIw~Q5c?)2`wn1a0{?3;|XVRXOJr!~r`CueNr0m5QI<{=bs2yW8WH~+2&FKOM0 zU2nzoGDh0pN|8y<_8Bk!&YhP-mAwL^V@Hufzyb&WCgRmmMSeNZi`BNGVTHzUc*QtF z8%Vl_(D@pn`Mr_`8zJlon1yDUg7HM+#lDN#a zEA9zz9wyBO98hdFHlJ_aDn`k)aKx-|pX^FelsS?cVCPs38Dv=e5#{RWTMZ{oURUXF z&w)8LmAod{#W{f!0Iymj;CbisR2>|-aA?imPR?`c+jYOwA~(XQ#Cv6x=>Ego+hpJq z)rZOT(3aX);$_H+B8h)u#eeReeEq(CB=~&!_Tsu9jkjmtZ{@0pq}GRFsK~sQh$p;F zAN;rf0k6%A?)QHP3n?i8pDkWy@@6k-(JuJkeg6FRuyx+oA93rx5;HE}3*^o@KKxwH zSMMX16#I{KS&pC}Nu2Zm+cJ`4S4-X$O@K~2I^H|GZe`us*L^%=L8r~NWnWhGo@Lok zSqH|)=RLIM(L41QPCV^Xeoy3L^@(iHB72y#ge&8*Vf4>;4iz?_GEzGs-V7GQg)InX ztd;J&`FN%uIq`kdQ4%3PX>u{%)8tUSpIrQdI*#8vL`a4~P73f6XaFLyZMaldoV`j{ z&B+JIbg=kbdcj!0AjlfH5=6)wXk+?~!4gxCkc?xaC!roksO9zGj$<01t zmG4Smyid;^qy>BIaD63iPa*Rr{4$mdj4LR7qnNFY@c$Yrt~3aFKjQ~Jg5KgET>6cl z=K}L54>afemN^j(;$R=66Q!h z6kUQghlLHN+`n-p&YGx_c*yOimYM0_1gl<~=GFZ=bwX11-v(sPE|;;@9RU*=yeS6R z8>;x66Rg!!#N?Tz-zU{%+{l$_fY2VZZFqM6o_Z?D#Iz@ilKBg+MV1rFAYx>0hjp`OM0zRt&pt4S6~OCrKKbWnr1Df?KwVml;lQsKhOdk zFi8>fW9+B_+Y($F&*k~ww6B?$M|ATFHgojH8>)~+wlfF5(&(Oao+oz`*|FRmhJ#9G!4L{rzzxAD-vLJc~Ap^`AdCDK7 zsFq2yrwwmPe|H!v=x*WlY>TXa9QJy?FODoe^~X(qV2e-r;TESiYw!44U*GWw2_w+4{j55fvWs@!qy2ZeTiD-BDk}4!JBng0tZbN% zz1!?pGotJ0SOs7aCLd070(yX;iNgnqQYZxnRM-%nSe_7Pzm9ZD9!*nAT7RL>=s)nu z4KSYufj|WXUI8Bc%S;WY-{(JM>{-a5EB}jNbaCVS?O?fwCBwS5&87009pxRE?s<{Z z4XaRy9a=vwcS&>QM?a#KuNGkOr-U!-Qw0wl`aIJNZ2{4snuiVJmZp?6Ylq{(ka9OO z!JOL`hxp?_sB<#FZmX#nIbzcYO`S^1XR!LKJkBQ-G$R7w$NrpSFu@1 zFH1jl&Z8PJ;%5C=LuC6yr*^b4P4ef)QcI!-7tpJ5(GCx{@Sf-&XW3};l2`v=+1Kfh zQ7*5S3!xhA2x%#x^!d*YbwX)24aZQitmqV=tmAKN zY{bOY>t*{e5Zkokcqjw5*tM2pPO%%PqMt-Tv7`SOn-xVSrmH@(=;)i>?l*9y<75-o z<>x+B<%En?F@A2oTFv=^ZfRXlGW8d|o}H!=v$kuLAA0Vf4HgKyebK@E*Ef$&dSvn2 z46W?bobql&WZfESE0(d}Xq*3^1&Bf|%sr>}F;LXLBkl*gLi3L_J?yH# zS5Aj2_P@Eyp#TzSx;K520X1#)0mAMlD`L@WT+0DMYRj{t2wU*?lh*9kQx-tN3`wNU zUs!c?;_qzQKe67poJRcYeYXbEY|gX$imnrmN*;Bbep;1lz)VUkA<}i>pTFf8uPmG5fh=xdw)Og)+wFT1-jNczJoblzVe| zzBHPM7>_h-Yb9#bY=y@?n04QrekiQ(>k4CF%S3M4ZBKCz`eRQbp0XhsG*bKCuEvKl z49hxmw*a6{z6KVpmoGGMwNLnVaP6Q7W|EebG1cTB@<@*)+SE(Edyh);+dWrt<5=Y_ zC~%N1)1)^UP4}0BxJPte%dnM>3TTesI)`lD$h3&{VLQvZ@wiMCQR~m0o@>AsnYj>6 zfs|YjAec?8qW&=yf`~!r5`6aG1R&b^mXwbkR#&G(t22Emd5HMQxU)IP(1N8!V?|*C z%1`g{w7#|!$1w2FOG$c%DG)WIPK;IiC!W=;5$2S-PvutfFvWgLHhS|FYWk&OCN+_h9 zFggdn9s@$eqnFmz4$tVS6;7c*1(j?Mn#i($w3yOiDy&9o7^@9)c8V!)gZJO!Z7IT!b@{wmsvnkx6X1pZ2henU#~rfk1hdimniKWjAcD`x%H+w%X# zV#k50RWy@6yVBUlLS962_WD1nOI4$e-y6*Ma&7jYDG#BrdD+w8^fr^Uvgv8_)6Fq{ znN5j~-M}bQV&xYy7K>nP91T%b+&$E)DPG3|z{s6^YBdP>RoEce3)Pbh=?L@|9gkoyRr!&GN! zFl9leJk{#z{`g9ZR^Lw}ep%i#u)=69i@ZNA!M+UadY$tW<9`XxeEmkRZ?Jc;&Nq=s zqv!a&z}Rdr#TZ33)H>a9lLQ7w^XT1(;q9}xpnb5LfM6Q6FP zQU}4$S_aD~0?uBx%YREBjf_u`vY6mE=@Va73#lmu{K+5f172Zl*BhxSuXz)`UzEKY01;niFBI3n@~t5ByH(R z#LKkIZuEDv6(Rjr&4T&|bC-aj9UV!!FR9QJnfrZpBw{%kOkiI!Jz zDxb-%^ZT5#l2ss{CjpkH_M#|J2*;bn`=OyZ7wmg?wk5ecJPV6tfUqo{-TtCIwW!?l zYVL}m5!}dCr&Wfx1QT?PjwcV4l5BMIL9tmH`p3d@ko*&SUo!cyvVEnsc$!*z&X}nr zGpQSR{@w~JDQy%!0sKkLT$!aQDc?4=^{*<0v?kFZ0 z{ZJfuT_;N6 z*>FjVYt1oO4!N$P>`Gy2^dL@JwHD^U?a;O@#{!+VL@{Pu2`+eLwFQgHC9?Ho?k4Y= zNOkSYd4%A4J}~82r6sKG>QfAb@a}lIj*x&}ZV`OW%RX;?Ltecjxkgb&T%>oonpx;3 z_s;^|Svh{!Lz(y)8xS3C$@Dtqk*$E<9%rdh(Au7?`b0oyN8+_!0#f}dxYKjGfl zRkIXV2Od*ekw^G>x(s9R9{+ZcD(z4!V%H$Zf{s zybfjfK$9qA*E{`~O7U_i>$aBMksvvEbcD8)%kr%m!o0#9&|r#YRsqf88Z+!FW6tzi-5Crs7rT?No3CJ!Se{JMYJMY%t^M^|tD2t0;PKlo zf(?;_{u9?ckJMWF@f|D6_4$6Qinx6VJ5+_@3`tzQ@#DrWFX)1z{RCtUN*a8vN`Q`b zZ3v2M?}>}Nx6S*O+`@Qa+JkTQ$T6Q+zda@Ym%;18fq5kzSI97MGiwm$0_%qFc(~QS zeS#*;Y5<9fQsC?dk0NcTD8*JBfkCsdVy8Y~VCeL4eO2AG_)nZa(M2lu(`}~Xh*N!1 zZ=RQR*F;XZ_86K+Heue7I6qG9Zgr(IFJf{m_7A4CeRax0gh)dkMH!0eiClYm2(lel z`ChPA>+YcFBh@V5x7SCy7t=s^6=&)3@{|L=mm8e=@{)7}Fetqx9$DLzeIoZ~T#>vK z)8C1_pMdEyX6o`>Z1nIL{{YPbcJ24_=OU(C=Con4_t#mYV1x;!3 zBj)+B0YMHe!<_@0i$fY2Yx4Eh(b@`1`He^k@x=N1Jh!?a%}_MBAt3bpsd!SMlYU2eY%XL z^(DwKF!p2BJPI#oh3j8Z0K}SN>^D#;d)IG7(qBV{9tQStfw;8_8yIxe?#)lLPoAXn zNxMX$t{J(NXhq+-dP_mg4%0}Ml1K3}){+~?Rb{}<;`A5;o0;i$;&`KbE{^Q+3^J%# z2Nq-D9GVWjz!505rSk9zzIr_~&V18?<(kz%TvzKpb@2)K-BCdI{DAzQ()uJ>>y{_Y zPoljX>ykmA<~$=--FlX4<4*hpy|Mb}bO0@>@_FI8Qsa4R<0WRA(4!T;^ZD(SY%Q~y zKqKKk_G39P$v5-%>p5+0l}~@-WL*dSzjeuTUuTJRmbrXF34=rR%~)euay7 zNkNc)-N4Y?O|n@RW(RNDRU&;xr|QL9zB95&XM@L4<6F4)G`~ibe;J~*#=Avg1SC(JCYwf zZnEn^w86#v*r4Ur#m~F~zqQSNmsafUU~HIc>D_98!UULPK*AdgFIw9-{rn?ZnZ_`w zx~yVWj)A0J`3C3+aWFno*nAXl+?rdNxUO{xj+^r#7X)}tCd59+R^6t7{WqqYPdWso zEChY2OE7d)$#8XR(yYu{Q7@j9lrM$4f4Td*rXn4U35YlDm{$-cv{21Aj~}C~StpxX z)^Qxf=do)fBAJA(RR`3^QWqLCU%6ryT_^74g_zv6)Rvjkk4zQOap*y2-vG#=ODqz7 zWY0(qMv|%w=^pTJ4NV5DGc)-AcxaiEjl*Z&}^0vzVB0CP!O0nNv~SLk-!acvOSPjl^KtdtM@{nFQ-C2 zpz4EU3v$X(G%cT&R+y^c?Y?hyrj`Qo47G;2(diLA^LPm{O|@c2N^|u9J2tiVn@KaK zO4q3M#>L^QKYlcg8UDTcN`t0WKd#k;pYCi7yrpemc-=g)C_+5`?l7BM{Rs_JTXEZT zdp%3v-a}&YI)qX?`q;*iGQ&=LCv*g;rrmExJN0EGcE`|6*hq{NY?j)U+DynGn^e}~ zPB^oFs0cHDxkc{0y9i%3VwqxON4p#gPg^jaN1)v*`|M8{Hs<2btPx45y3RQvR(3v* z5hADfRAue%N4s(GkDap!Yxi6zD1jEIsfR60Z0@f`<&YDa8^f}+Bq!7hZ9nG~pr~as zo1^_7P3PDhXa9cvt4YJgoTxD-YHZuKZQE(Ai6^$xuyJGCN#n-0t$Tj|weB}CYaX2I zduZ>^wq+ZZl>F;Hd3}vOS#N&-B!CtD&S}VuOeEi#$@_;jixcoLcY%j<77l6n6cY8+C*suzkQm6|>! z%$fJG5TcG{hFRr0PNi~gZ7sB+{XZwX=+f*x5pEhTUx&X8i2U=T_Jg5)l6|~coPfdM znnEIdg_Vk#WPmx>6-!>t+5}^y55R{?EVy^F6C4vG`_NwfPY+RYe(_(IYYb416=m+` z;4Qn* zsWg$=Iy}Mg>3A*)5MKQ89K*Nq>siDc{_)b@$*eB*4CfZ=@Z5z$i%uKTxLd0+$O{3I zQ&y29tWM=(kVxNxUOzhahb13kIy5U}24QNh5iR0t*pDCkOtQrmZ*dz`?|Vx{Wn-Fx z`!LOs!y2G^W-^`ALuc(NQL8K+h4g@nC|`;x_GdE zy42zI9KL^zz)b+I92s&+C#%pyi#3f*bU*?zv&seCzoa`ypP>>#YC>TR#P?TPL3!im z)=^r82;s8U>9K@QBwPL{F8HOx^dcoFXQgTMO;$T46pKQzX5mssz5ZYMt==+(KJLB- z!6y`oObmd{5eu;wxx=kV#F@b|SPB&pWzJ~dIYmfWhm0FD8ag5gF`>uDZnk&fmf3I} z8yUobNT1F~6h;8aic*VK0mvVQ>?%2ns|NEk&2|aGgU%f!m+svnI(zaOb8}u)7IeVa z;{5Hyrb56NkJPFhCoHz7qgI}7v-UNY)2H+{+CToMYHjD0_`5O&exI4+G04=X?6Iun z^nRxmZiFbl%}cx{Q+kfPx!rz~4TrT{n|5{Tvh6y|UZg4j<8r7nk7eA#>TUyGW_(zavh4T%BJ@p&_a5k4; zXLK@0SpCgQcoY$}t6OG8=dvWi06Tx{m1)0sVL( zxb-}qrgz~f2UJOg;fCXOqM?Zi24EWF1IL1^dQwqL31jv#s)^p2>eq;^PH^(bnrUdV zi)fK(sWU~CEv5^9DOnkG285vA#7Q?RPND=xMAxS>W`<85;HzWhm&B=Sj|bpBUA;%} zb@*oSu^y&q093au$a6XrF;{tNYHA1X_&+^S`Ufo9P1DUcAeAiu|B%LE^n(NgjEZ?~ zLh7|aC}bTpX_j%;T5l4_#iRf&Ks7XKT9u-3*H?GRtD>P*!~&GUOl!ii#Evl+RmD9b zOwSFFbbbWHn7DdR9!n2G27T5Fi^0P@zcJkIcLomXAfOqO2FQI;N9{xZG?SP*daTZl zfSH3Ls{YA16s<07*QW)-_BIBaw{Hg54KNj0bkdcG>8DUY8%F{x)5)HUjT%;*yxpf( zDlfh7j=n%7BMEgZJ>rMPVOz#cy(HJYvmKE5x|5GzU;pbP*By~3@xT4Iw`@m&&&=WY z4M<-oxHYdRxX(oBv>@6x8Fo}&`*~J#fZkLC)gc8aZzSM5f8nnwc6HK4gD^>MKNVF1TY@*tw1U(D_cG#5?z{h z`=vd`lsbwER_{-z%JgvPYdDbTe%u|H^^tE8bXtx``WYO%j z$0aKmfnv`tzOt1)Smrl>O7td%&r`@;z845r?;NKu$l@J!Vvh=!I!yh~_YEQ|d&2B` zdKl$HPF|B-Yli1Cf3Q%)=GHMm8lbT|smBKPNKP{)BbaJfu^1z|sVWL82qlR`gMW(_ z6GN9#OV0f)MQZ;@a_oK%x12UmN<%J_9G(+$U)~1o+^N-n0{iw4GI1f7rp{BPRTnoO zxP8Ki0HbsYiDevQ?eRi}z3QlRXj(Ip^$|NqY8og_ygGHd5*nR=!@`;s$J%RcKBoHK zad=(p@j~lgW5IO<$FI5B*b_|^eZe#q$hr>M^7Bk_@3F*NJ8#kJ1(wkn0Z1J@-Fr3- zqWh8lvTv$NRvAoB)?|~mRT2gDjTA3?(%h!9+<&pfd%4^|MOS=7b;I$PB@DmlsB=ll zRfvE;F|MW^vVYTJ7WG2V&&s7yi%H-ijcPkL=S%`X38oPMwvc$n7-C_D@x08wlI(th z3A~F59EmBLj+Az;Te*g4g|05zFK>$SKC&Y&1$IVHSyRVL%syNPtRphtH4ZF(B=w_9 zt5w#W9(zE`Z~t*`EPM>=i|jsndC3$v2C9b^=3C=nK+9(&u&Q2h@&i__3Q>1f=8O*d zGD>TN35L+5(Z@<*d9R+AHm`O)FB`NP?P_YobF&AQetyx^(W4wX>AKXeUE=hMI-;hf zwhtUy#=|9a9B~YgSY^}+iVm|*-)9~F8^foW%8n4b;L<}YM8(8h;A>!+ANA0@Eu2m)KHvP|GsB*Y>eGy)z2+`uC7T`i1*@cDKH3G1y39Bin@BU0itdw|9cVPl?%<;OsvOo$HqQaR zfvnAG%}m;Sm2*3wLMNQbwX=?)J&Gd3pJ>0vF=F^a9c^DSRdhydu%rp97SzHhzj`aD zsHnNec*NB_o;`&8-aTYaU{|t&=bqDw5iU3x7<|TCYX9G0T9G7zEk3jtI%Qotnc|AF z;Bv$}wqW8g2&KuhjZ-Fe1HCqh-CO|)K)IeDuxX_LCI4hWfg7r`boJk2;xDs_bCw90 zUe#hs;>FQ)>%)q3X35rf^lE6`8_fE4QonU^t_q27g+|m(ik8!E1ikk(SWZ9fB~L4@ zCdPt1Od|)L{c1t%n#7*x0)RWl4=*SXX@TsUeZez#@N4s{Y{yUkN z&SyH_pE;Gpvw!ptY@p#9eB+BemgSi(Deu$a#m(^&2_5vAEIs{|nR!2puDP@n9E%hr z-T>j(tE5qidZHES-^lsr|FS{K35Z zKQ+Njb{5WDv5-X}Dxk!w0g|;1$H2jb{;7h8FiIN0J<-^W#+J(jHfV^g>-u_t4t9tMwE^ zarvQJk3fJ~pP4;}11VRXWm*$Lf@DgowEiNKeq&cEDvwd|nYAR(+RE9TT-IBJ z21Wp@L~IIf@2X3UF(nWiZvU&8uBKg^>_p)EW8m8%GpL-N8DrEe4&=Pk zPaH6?-cF75{(YZXBPM)3V0e82KTgBRd1~{m`!ig9zP_BGg4<;$gqoasvISKvT|afa zG*x-$C~Scb1SN9JJ60$Jw01xwjeeH3l@Of0^vx_SXiTl3HxtcuR9PJ%&HojKZKz2} z{JBm1JMfy{YVth-)rwdUt>wvc+UsSqg|Iq~X{cV%jZHpgQDyuHku^T>Akh_!5i7bh zYOfOW#nj(zptJq)%6KPPQDEDr+qB8RwX<~yum9en{}J*y98M8sN=S*vc=Xl=zH{nj z8@fC$A}n%Wbl)aazNcDWJr#Sq*O~kKeba0_L*XB_g1w|HwV?Dos^Stj?W;Fn1LSC{ z!Gz1{W2=Q>%c#p>jU^-jV3eO>bFUBH^vJk|n2^Y|`?>D8N`4_yZw3x@3;in?Ye0g88Cglp`G`!suwJ`({*eDc$vF-F+XHcngWY46>mNkn9PB zB{f-d&>nb)$ZJR2HDcuYXe03Qi(SX;WgkUAO9#2awEItEu}F`y_2`VBHn7%krfF4| zS0eHX;;P(MP}&M4e-VWxE&|JGlatU}?r|7kix?mU^?!52hOq*|06PcMq$QCo z52dzUjj5&d+VuE{w#N}Dx?0SRFG6w%_JrKRkvquNr#g(j5WmUn%?0YlF66Gm7x)pp ze-i0WZ7x}BnCA@neqRE1ehcOcl`2RS9a#Plm)0_)lv00w8xT5)<`zz{=+rlGC`A2A zd^I0Q>Uz1DIlrs=5D{0~f|+q(rx-2;c5j(nLX6*AU_u{|Af z{$1TazVb7V`2N@wWJQx`!-}4pL&fCA^H}2_(|U*?3R_T_OFl&0Psb|_TCfqeCbF?z;jY@9xBOfOn>S4> zgDV)0+lZcm=4`^H3DeYrPPuk!Tk2f+JN4eidlw`1hnld0m|(q5BmGIz zUKr)4Q{7&&qF`^tNTEIVFWJbbz}N1#Z&SH~mQ7kaWl_2%3agXl)33?9c(u_iK zN+kBZh2`}eYn~yJ<{Rq3x5uZ-?iUF8;-2#IV~bzlWi->ku95+Bn^DRdCb|(>Af_JPUwN3-4>;a3c-FSfdx4LMnmPsXsX7sKvD3RH#R63fY z)OtXhRIemKTG#;)#;!6W3??X?Ej+ZLH0!1Jb2C04e^NC6rRuIhxW71Zh~tlen6*HU z`>oX31RpMu#>IjVHoPCDj7;$JIQ~y(1!-6o3^P!&FQFdx^v}j60^aw|SCo)PNFFt0 zGIeVRU#AL3Oy@66y;WqH-o0 zVJoa`<8&^SA!tQ_0zWkUPOz3eJjN$ov`h2aSobNUkuDCqHyK^mZ8>-pN;Cz}(J|Z@ zN(H44dZL?T&SPcRu`SBLxM{N&SM4d4nzbB15;1=r6LB~<6)d#S76CH+_v437^O!Le z4t$0 z#m9{@Ln>ki7S_cio; zuT|AMdtQ@F3LOHzqKn~$RkJ!SCqn>}D^7&0Hgv8epbR$+9$lSs^>O>ixqEMWJn?9W z72$rXexvKT6IOgQ3!vmMdY+3~iGqlAVk5GY5hy#nthh%nl#kYjlz`D6YaxL(t-i!e zojMMqdIc#HDp-{A^K+=s`qY=XED~>W0UPv?&k(w+Azrv>)2esq~BFK|-pSEuLrvDA!mM@rKQGxPfGBAvtcs!q$x>T|M! zQ+{$oJVI1*$=Ot8=;~6XzL~J4TeGV!E-oS~SaJbITxZI4`9Q+=g2TWM;t%Q}v}fMH zE7unXMIN{8z|; zd*5t{X8ri4)MouLDBdEPGV4q_Ylafc8XwNPrvNcs-f=qVLOJfDB*LqcdN8!84CjKf6<43#lLED)i^)u*`Bt~nDd zP&(a<=~vsBRrl2mZJDjYm$+4X!gglLqfcvpX_l~lOT)~nfVI+d{8E*Lr_a7 zULd|pDg8Gv9bhPNE)sSK{jOGTcIn4cg9dvQ^HcfdBB1ug?Vw#d?(S# zo-G<~4Qj)(t9nd4lLTSl>qqDEDI(piMU~*-DMc*{QJG4sDWELPlepx^f3YXpn6^e& zof>5CgQy)ZU>j=t0Cc;qr&iVEd;G8&h}@=*Lyz{V&iviv825f__YSj*%oiSnLs4x? zPk`k|BDthp#fGd6Y)VouoJvYbNlAKq=06X&PhE_%iHKAgb75%k+CEeI+S6EEzja0% zk-m)X;kkj6Q$vuIY`#HuKz<^eX|&i8s!i1x| z^+3~jgj-6asPX3W7hURjY85gNF1k-e9mZb{a+5KcHTf95?7ls$HR!egz}0g+{TILS z`m_6yy1VD?h`M|sI()>*KZ+RD?KQXP9{qJP4j00adI_2@!jzKfd*H?#La5K4q86Ne zEYG@{k< zfmMnL1yht0!_Q>XoiH!^>H|(NU!VQ$Wb@6|!0(xI_&k_P0l?Orpjk{WYyFwQS#i|4 zXMLzEp|06D4wLnsTC{5#@Y0Ys%Lu{Hc=fW$L$dAAsir*|_K%ax{61C=2hi|_qbet1 ztG7;ek`x7>gMa1y2|N_gp{se&-T3T`r&)raQ6LAf=Qmluxq&JR>Y@VL!5-X>GB%A0 zMfXxB#FP?>A{w#j^EQQ{y2UL-=FB^YEFNlo1{0zmaWe0PT(ko4m-P$^n+n-dO*X7t zlbn~ZFa)GgmaIheaSFL5j>D+P34;iMl~Bii#1Pz*QInPuZoSpn3sIYsm93*vR+xKv zIupf2c2cAOhJRmMa2q6C5%-N6!Il(-KP%>2+j-NS+Tlc2!;;_qvn65mQsX$KVqW*w zo6orM&0Wzjct19P2N^RU^D5ago6leHx1gJwXgo*wg;PH9KuO2?1=k&>0EHju>;azY{LG&b6YsN&nQxoaz@ArDzO$B^%1lKMFJPIGOs9mZCt>b9#$8R-4;7R3cS z1$+yMii%`Q2m>5sDNAZ&tGQFItY?pO?RH8&{t0}Ak9;at8d9DzzyfZh!)w>+5#RQ{ z63;X<#D5pqd%ivF@OF)(lWlaSC;><^UxfmWUvi7FwDCm5dZ=#gXSJNkd{HADNQ`F| zRXA^+%Z~=jl5gbaSJ*&RII(v5KqVdSpC10x9xbMTuiy8puR+R$5i5jrK9FVRqR%$xZnw4P!{6s9#?$@Ljgvhf$>kZYFUJRdKLG zQ19lYG=ktBFNLMv9yq&m^bcLUWto*|j-M@3e;>$UMvFxT)$6bfB8}zC3oj8Bi_wiV zB&d*4$IItNJYHNu>}v*)<$0<8)P>U*XgqdK9$I+UBq=zxSrs{lQ4S0goKgnh_JK?viow@3ZKJZ>vLjBfcPQo!`TQD$IUB}n^4Ta~ zPB1+EzU5&=1Qc82vqcx2hOMgqWt$APU*0){*P6nsZzP4ej1rg_#0+u!t>2z}rfhLo?`utBjBG8Z zk<~ayRB&wYb{+EKn&J4Z!zh+@i3-6xES)pUY?@)2hR@+4Rs&@v1yQndIt#yHuD!?k z#(%$=&HDfnzo&hM_8Y!azWNU@Ji`RuE(K0Pwu1*643ql@(XWq}E{_jDPlxsWqQ~i{ zlNd)pJG6{B$1ciL?N*NGpH;oBvPfDi|D}001_N_Q#O9f#+!UA4;LoOvIW8BB7PrmE zJGh`X%@jg6lL@x4T_$A6T~P#{FfTVU6piKeJ(o>>kImRu{`{X@HfAhG;j-hSU3+5v z@8T-Jkit)tT{eQVdbB2sTixtf&mr#7QAm>g?}S7v6{SUF(lawNyf7s8sUb;qFere` z15dXq638y_g54WV%dTwyH)8w0LH z71zOL#FpebW_OsYTz1<|HD=wHBic9(EvtXo+(7|_1W4;NelBLY6bmH~vJkZ7DW!9Q z>Lc64`>5l2D+PF#HBq^-t>BbN=I;9Z;AQBjTn)BgUW|&8VuPc_XMcrDQ}bI?3^oja zT*1=zD(8R5_qz=uaO!+FD)cmLvIL5p#*6noJlm=#q& zxm-qep^-j5UTO9B+Pxg9ah(;WW29L>+uW=4m>Z~AAJH_b0ksE*GUDTBo_t!EyH-kh z)etQpJj(dSB-s5Yi&)8_#BY!@RO*eZ3`r4Qcu+P>xypp;ST;Y8Y;LPc29{CFnyjw2 z99ryFlxeYp45IC_9Vbh8OSt?JGqSIM*Ihy(ZL44N?gm!+7oR&{W9Jq+;OWup#}HR# z3RkV~<%*~8=%Hdz1 zqitQa7p8OB8-j1$ywsjd`6~d+<{fu_%xzNM!vmxjmi^$T2oK0-f+fc*!ipuvBIMF!DiT{$)Z!hf(IlbC1yGfwGRi>#fLp9EVY)M&|}C- z0%yvR8g-bYOO%p0%h!WOl{1acl%*pbX&4fJTwXI5G`v+&A)l#Oq*Kl5b(mTR2pba( zWn>6ZCr6`UFoUqq_;?2UpG?TxT5x@Ps_n9=lwMaEbw&rNuCvxG3RDwj{l~V}Gx$d5rGyqtAYtz7SEZ z1LPa*j!gy@-N!>DFHP;F)o}L7$BWv{^nX_N#Jgz{`25JJ4CC;7Sb^t)#5Uihwzo_d`?r~E|J`a!hKO1%L0{(Y9~_f39ur=QVm_QGS|HSw|; zrI_cj9xRlZ!j4Q;ue6Z$1tFpZaaGkd7~Cv62o#<5;;iO*%d%VX^@_A3V02y5Q~Uc5 zuZMNjkDIj5IL%rEWnA{K6si7mUeBip$OSAb2H9Oz87IzRvmdZM1-$Hf1(*hiFUfZQ ziN`d>3JCZ`=sv#{!61IDr7rtMGbtl_=lWq7f`MhGx&YzOnoQ`~KZL@URMNNwxkk6q z(o~b#mRG`*q+lLYE;+(8f5X(bUcB|P0!7cp{2DkEVqp>=jeo^je(2{LVg;?I7FIYx zTI{qiUJDW!JM|sYz7%$#EO-1Pru!N^nwbOB96}8$(d#;U#Co{9>JANjm*i=tMcu)| zbNK10tlJmV@Bj9A`*ktR zO7nbB;GVyCJVLlz9uWp|3I;l7FLgzXGKiE+Xw?*zIU*GMas})f)`dX{EblbvzlKs8 zV<^kz1W~MzwGsHJ;DjkrJO9q$SJLQ9x6+J`)&D-__9!1%22=71c)&HU@t=y58e!1A zR8}H_<^g%5K&L+&S1sKywgE5mc`m1&l5cO1pX48xpNDCMuRPS^__3H8o?t9FPiNsN zL|a;uiN8&EZm9hMUE7h;bfyl*&|G4DJ%nP5lhUukGB^UjR3`U> zrvxkmslvZ@qL$OZ4T%6jEXyj9f%7vlt@ezaiBM@!x_wL+CE9gNd*DIw?ER{J3kJWd zIB-ynP60a1_4C9uxlhkITq+O6=3K;yUz4$GI#w%VqLlX7U z^|DugX!drWQxPKH5lOsu&ZpO1JxD*9f_Cuk;i+lXWqj~$>pGl$*Ui?~bGcjuMi@)l z#y+KjN%y2!!li+|M=xHYCdpDlrHq8@e@7$v=#rwzyi>86C2(R=xhO;~oWr)^;)$8h zA3NHXSq3AgGen{q)>A0M=+aC1n`xC5>N;1^mD2kP&PPI2y*@i72bdB>C? z_(4A#bhzNTlZ$YzlJMZ2jhd=PeH0vG$%iJMcC?3VPLdKzkm$qVN%O0mR3t9B@1T{j z?L6VYb$0Dv8X=!`)_HDZpWQrml? zzV9#W{WXVHtpg^<9=<9VYyPU(7~AO$9`2N8MZJoDV{mW@R}rHar~sX2p7Nw;{{rrc zRYFqWCM*@<6WMIzvrZXgxU1^ES{{ezuAilXNb8AxPfEA%9vEs+eN!v3A!kfK4+#LZ z47KTYDRAWx+B!+KsUZ$fPl6@dHY@o}pDC;dz}KYhzj|gd&G@|o@Z`G6RGy&+(JA^9%gtPN4C&_{s0Pa)b{N9!*8e`=y6w}h-;+dE;JO;^wMTZ6)4D+|Cx~mojH20uGb8O zIIiomPzk}pJ|1xU*50#UzIJeokJyuX(3$P2FHjn1WB8SjNlZWAKwbJgpyK%59ofqf za`W?UU*!0jJ!enn`3*wY_QQeiaA)V!%Ys~eY_5=*P+BcIBm}yH6)kKq&-!@E4-t0s z7AY$Y_=Cp@Pv0ve`yk5davq>3#PywfrqjhLInk1`Tqw(qj(L1E8BKYoJQn^S33c6y zuDGmGPep<{DWiOW+@MOipTxN@k|jU@bJ`)-9AKMK2s)#}{f&r}iAMEs;2IZS8>2Nm zD273}?2*J+Wd@ReLxFox@6d7sQrwX6cH&hv|Jg=I>PV7=@03 z*{hV`pSA}5(a5xoGyKHhfHr<#BfN4#BoT42l+9VF z80e~|@cgNh3#yA>#j61l&+YLjLbL7+;>s*-Lb)+n7Wh;ZWR{V|zsf9K$fu->)Uk0C z%@)}j*GSOEyoGad??NokV3o-G6AFz|$fhB&WfGP+|HQKBJ$Gm7TFL>d=h&g;mpWD9 zZDU+KfBM?xj=WAbj-4!H+7Bh#j{q?`|8xZzlz581O-iuK$M3Uz8aRAdroP>{G8enwR z2F9iv;jczk*EWoT?LgJ5Vg!UEWLbk2G+&!%;o3H4ABy;TWMaJfWSNblRc;(#bJ4_R zSnuN6bY>Le?mfnjZ=i6YiU>l@u+8b3tv#Q%TKyk6bR-!S3~wQXc8M09dMg_|{pWP7 zVOUQ2P&S7J8T2GTsl$O78wcjNl=^hdO#1L}gqpeVlKo1RMu+z;A`Bsi>qFp^s6a&2kqy2>_h-U%;0N&Y%{R?7lH^CiQ54D{IoiBt-fP7aCKBMLI0ip|gWY zU|{^S-;hmbpFE~{hU$__U9&zaRX>c?E9uJ2U>my}ruzJhLQ%erJ=G6PldRUaTY#AQ zM!Y`;&T}YTlUqMn?Kc@zokWP|Su^gx4)=-2?pKC@L*7f*#|z|#2ZFd7{awG-gS0&V zvF&Tpz|ZbiI5}gJ_4{<2_`J90X>Io}a>7@_j6KXutv|E)(2aRws;&CG(YKzC!ko|b z5p~h%GMG~f%V}aTOj+DabbNnsnO3KqU4hNeX&AoNqLIBb%}~>VSyB@^j${Z7eS;%w zNi8@XweQ{7=<;)5UMW$_r~fv_Qbf-hJ%*9;=f9yY$_AG8sDS))oyBp8G4A@J2yRQF zhWH$_EK%@vH18&-<)W@d>uU6epmEcR(gJ11!rR8>JA;7NrT)Xi!?J^?7*_3OHj{jm zr%|ygJH|zCdeVF53h1Y$)PH5?7X8bQXUz=#06c2zso<=mHFn8YR-A^UGDCjzo8awx zvS2hzMYI-_k!i>efwiR<*h1kCEqS|Mx7Yr41xz&BUeA+=w>Evn9Z1z4QJeGiMhW@$ z=V+zD_}{vURm3G}W~Sa*EQ?NlU5nc)1fuVNK0KzMdPapxBbx zlG>VGE*!|DFSD0~s*mX8GORoH)i_VR{5*o&i-1d@&7V(peHg>2PCm{PvS4d%f~*9_ z#fb2(LEqivP8KE3EXMD7^zWcz0Qy+hOKh__Kg?TLY-uX9Et*N%e$J)V=gv0kTExIa z$2DL6(W%q#eCmx4kaFUub~M>x9`U^l?3rDAbavj_ zfe0M$P7gt<`RBf4t)bRPAtb~p!DK{$dA9mfUOlw0wag+tw?${a*w8TR6rgk|ByL@@ zE0e@&LnBr2v(k=v5z&aKG--Mcp0T+n!V%3+96||0{P+|$T+{Mo znWJGPh46EXq98`Rw_ffYtnyPlxL3)lDTSlg#6s{^0Sio@n+5qp@&DHX=u;mn=p-M` zk@~$Im;Gz?%qyf>ZrquGFbO+5Gab&fYM1s}JEk*c!ScwxnCa#7ST&tuI;Cc`a{;ab zmFB3~+Knl3T;XP&h`;~YQP!yMS<4A*g;1o)3kY*gI3^u8VuaN%Ywo{Zp=*Dk%KP1p zq#=`>Hm=4h7*>3X{$G53cpX74)}@YibeqWr7>QTfcx zJrMTuNF?0Ys5$WGsm{vo0SnAnG*t3o=!`NJ3`bd!;n~nK6R+Xr=V=F0%v_@%e;PfZ`wo*~x;PXZB6M?w% z^9yGUk*nV>hq?Z>&imM)MavaB6#qLttEN z=C3c#|Jjzagkmru3T zsNTJ^8{8s{_GL*60wK*a+4 z6+=R%te`O#bT^7H>VSL)o0Zy9(Mf>s{fe4;m`Y+5cnc1DV92Q2@<{xjI!!+okp>-3 z1HL&j*j*UMb<_7uu_|*Do*xM{=Y$#ER%kabL26%*u1}X1Nv?B4c+WWGrcDqt zht`NWqOlqDX%~0r*LJYVgtaGg05ke?WHq#!g$*abtJmA+q~J+-O9;v+Nvh{x{ey5{ ziQmqx~l?cz1sPEe`HELgT?&=^B6?4)~+>OWu`j3eg=5hb{ zBr-Ka%;jrI>hi$$DM}KOFKTjo(iyiT5D^lWM7r^R2>HX~=N9}a7fhp~SJQ-(#ja9y z1VSU!Am~7ci$lQJB?$H-p5OZ|mFQ+o0QMA3D5Pq@@^-)HP1TmpCPbt`Y?V@1k1kRB zwnRczpD(lN{^g7q(j;(Nt~I&o_iWFKPc5S^i-?7P?RRMv!EK`Gz=jc5-yiL^SbneodN1e0tznhhGvmejm zbWAD-802;ooO75plk8;Rau*Rh&-b7P9O}Mp4F{&+{+NE+{CE`HSr|<^zX9=Zn#s(A z)$7-7ZsZDfLfJDDz(;BGbZE*t>R>DmOCbo4)a1M*i2BtIBC;;KcPm^J}V$CHl}rAbs~1n1it`<{R2Ynde@f$H<-bT|K4XG(}@XZCve!bhn&uN zOgRgOdf0eYCQC)903j?K+MIj;A^p;+wH-Ae7R7RkZ2BY3m^TaeaBG`BcXKjn>!BaR z0^vWC(n@fmdBj!J3`96!b6)<#f_bzUEy!AKca1sx0SQ;c_xlOw*ga|ImA^sN_5;rK8w6Az}n{%bi&KrBvp+tuS&Ta z?)}vciiVO%M6x|DJguPMS@F%y%fqCK&CtY|)MliyV21OM znRNaFcFd)LEM)~E;C%J6bIRiAC9%VL1R5ofb7xTM4ewBN!Di+`%=LwT#C8lWc9k-v zqUmB~9yD|?%Mb)(HD4b9i8DpHQ_f2*_SZIK_r0OjWYrHR@^uQ+5eR%?@nN7MD9c7 z%a3EXv|mnzQgK{$@ZytuuzZF0*S&`4k~x@EEyB^urMb*@OJsfXGF}JFEO98oWIWpT z5DQEN5ff0*$h*1lz9`h{Z14Ts&`ux87Mgp87=8Kfto)NQ7d!{;U$%k}QEy3#LS$g# z_(*qy%HKQv2n1y#u~sWEJbKC@C?wfoD)van`S00oY0$Y1L%^+^hA^|prn{DH4bRiF zUGLycwlyGwD6((8wTFw#V=ZpqW%AwEahH1du=|DG_clC%jc@pu!OhKU$qG7a%Wcb?WkdF^S-D6x z%P{{mnmRcPJ(YC*$of1H+}-?mR(w7o{c>1^19YY?-B`FHzpC$*zmuatyNVbXiO z%}m;Jat37!p)JC!HMirxFVmNmBZ3r2g5jxtIDdhX_#IGW>0T#?z!5IgV+K={1}~?) zreneSOa{lPl)|o^*q~R-)yXA!81A|08(+`J9rzqPtk|_PG?`USUt};bDye^*TpVKBO4zW zx;r=vz4wq!#QjSAe3q>EywhN~`;r^d31jJ~@bnBx#^d~v>-^aZz2S3(6HhF7aJ;05 zzTYbAB;B*$Fsy5-QH9O2F< zCH)$RVFNreQ=KJ@vYBntU&ThlIeCQH3Wxs_i1eS-qFZlwh5C+wc}KMQyhZ986Yh+5 zE}eQ9`k%P6iU#{T6N?WQU)NCVny1&*)EfQ8dg&j}_*zJ(_&@8N8Ra}z-Ac``v6l*( zytdSHA8})>&+E+(-8ad=d&v&3YY?Q64&bP1{K~?KjMp178O7@;BBE}@5iW_I!Gcmm zP&N^O!Dsl&Q4-tXD3MHkh#*7RhhHy;%7mmU;uAc#W4kz-%qKtR&LJOCZ*r|1C2!p% zq06wE0iV%y(?0n1F;awE?{7+e0yb0s^j7uAb}Lr*~z`+sJA;=iK(DC1)v^&b{U<$KTW4U zyw+6A=s3JOO4nbSyC?T%j0(N?6E@)ZT7vLBb^Kd~ml}4=J2xqpf`WlC=&$%x%SK@Q z<|{#94#c`D{>BtBmi{Qz(6`f@It*i2zNXlC_^66cB1L?Nuy2a0kBG{^N4`-7;P6`*_T$+ZAxrbXCvF{Cp@bY=DI%y+Pd3 zp_ZS4fvMj{yz=gG9=B43t{X}}Fu<5<+4q(Ul}w;z|3AhYTVzI8IX~zP%#iH|!}xzrovDVpaUX zstVPu5Q{6*o2LWKMJnS|y62rzgki^MnmJLyLZ5zHtQMx;%9J)KD zySr=X?nY4BVd(CX9=aQ(n*nL*R2rn~-Oq>j2k>dwd#`m}=Xo5Xb~izvRO{;CvdiT$ zA(q<6f?VOf?oH;e=Kx8b!okDyXP!xq8@UC`>Ll+85+ZWOUR&8@v;z2@g(b-cSPHpu zDn3~9Sj5@=k6K#bb|JG~O*3a(t-!SsYd%Lz^l&#_Lxf#CM_$wp^UfiMyzj1YJbPmI zFnyU#6YvfDDwm)?RB&)wMf$tlE6Y^$1v2kG=-dS+@xO#wcCE83{{-_jTQ&znr)-R1 zKJ;1GF*qAuxfanO=48^l)`O=~P-H~A>h{m!%4w}i*)w39PA!XYrlB^aJaBxSfE{|_ zTyd^Gl_Zas^c;8CA&7iZ6}IRw#w~*NGt)9FfX=&#x#7-g#=#)sSwXi zV6m#(YCbF++H+HMmb5I_v1(lKrK6zV8qtE$;DOst_!CzuHK9&$Dk(zzGE}%B zSsPSY?W|<0zm>J~Zl6Eb%Knsriq4+&53y@7o zNRIM+N@}!S$EsPQ5~C!N=SeSsBL--Z`zNG2Pz%07NwM6)Np&mb=LwqS*l&Q_n zMs~kR1J`3+IB2B#-PSO@dV5N%1w#ssnM{9=tY2}IiG_G{WRzd=H(8H(dDSppUvU*3 zxV=CLPUbH9-h6mOWu2Nj1a70qj`;C*{abzFvtIPcoSr9Q&MXED&{@wfai}3>Ilo7$ zld}Iql~Xc7^F13;lF?3Wti-=P-8dK>*M+L)B~o-U#s9}6XLB4LdK^-kC&PKht{=+P8%QQ-KA&tK5~H|r}LQg{lgU9Mrpws#(-^W zP~h82_x6+CE1R18^M1^`&3>0UlNx>2G)w)V>s2568gj9gaG#HtJ}*~2KA8$AEG+%dR~zaN=wNoChnj9plDuWkzzj( ziAU>P5&No&VWfOjYbl&1GTaWaCZeGtK}cl~j4&@`^r)|w>xuOJ_UN|l$~$b0xB~Fd zYV|Q;sSY8D9Co=Wn~01!N&X8&7 zAZLv^738bi7|CTaG2qQklKRZI6Dv(su~<5!=p}4-yH9ErsCDU!hWyyJQBk z*mCZ6gGs^dDnCOyJ;0H;WxV3j5F?p_tjT?QZgPA;UG=nE1~Gcal2HP4PbG9vLitc{ zfb*z@Fz1`MN&O{G2jXp89I}YL$6{dk=izC5a0oCi#vg4WaP~wb$xPuxahX>VA2xg_Sizl87UM8 zq80Mh0%_3G<>sg80@46?heWj+x=NIif)v=JzjqS_Yc#X6FWP4mk;#DRYM1cW&lpC5 zSNM^#To@R)t*!hPyftk>&*^zD(!+u4uC9T-)@|T!I_H8(c31bHzN{;J+SP*kY_}GR z2Hc-ksaD+DEaE&zEaQ`z!qdw_O9v}W4wgf+apYObk#!)B_o0SLgk* zzmd-3ts;{695N^JZ{wl{H$!lF@#>R!{1)@eZ zTp*Gf6!Di`o9LzY?!YMK>`X#M5&j`3a4_J0@pn+M#BTfFKeCx)QU8&r-7rU@HLFTupUh&g5l@qYXBxOHt+T6;OPbZ+kUIv=DFF_ zZTB;_=<^-1pZ4|;a$vp(`G-J#i7 zBAyJ4$m%7Q?bhY`hYPoVI$REqwdR#%kX&`PYY}QxdBCH9f7HohafV3vjiautL7Wf! z^pwugidro~@$BJnB*kI@*H~u4v3}lg`7A zyfihCfswTHM18P%=k2;s;8S$o<>j8D^Y2!1uFApreEh5X>^VLr&-(6aJ|Q4IEv}xL z&8GWDh=9~0_n`54;EJ#Y$rdB7T3s8TuiDtg{q0({6_HFyQ2x3#)`rIZa%GsIPEpP=c1p& zwf2>irLX$Tb`0e}_OCzHMOjyCDQ_hRuor4sO_dyp`^gi<#LikySo5sMB)1LnfhyN% zzlaJ*=W<w3fd?(0!EK$C53wC_AKea4MFP>@9q6Am9~N$}xdg`njl|pIp#-7f#qU9u zCVc;<)Kio@yxHQk);zL? z!XLH7Upi>4Lw*E)soRhj)hmJDDMcez_YeAepSB&gH><`hgl1IkOLS>2*@oPo_YQ@Mt zR$<;^4AwFWc8MSr%B&c$2mNHpuXbQvAZ=b{k>(=gFof#f6h~j-0~8MAThS*uR$7{P z%0#3X%E~mO{>U?tU03+|(=u0K9>0*lUbJe^Xvf*-U3h5AU3A_vP7(I|76{s$FXBvF zr&5zjh;EgJe|nmTFT}N(;e&~t`lV`-W%eUISi2|&O7A7b#4te_1>zY*CzKxLmgmT{ zAy%-1^4taWcE}}I>EaR=EJ|~NlwzF8+=6gWR|8oGy`V%6)i@Mv0NUi;dvFXb(`Dth zGjEnU^FB;R5jF{e&qBV=Ve3AOj z_p3-f`(33&f2|l*Y3Wwt9~>M2L(!}G9XjE_b6%IOYl0JJ;P18`;2g?x=i7tj?DTlT zL6>2JeFet@IPP6wVmcr9dsOh12-&;|<6OVx{>Mf`Sm zibfiLwutPx4{pJz?Ze@1utOPDu_6h)A8yue@SW`6-(pAn7w4)Bbh5~KLkl9=a-o4| z{rHRH{IkaYp9P4!&3O1WX)m8bNJd6hYn0QVUj;Z%CWwG|=OToeOSe#3DYbhzWWpZU zQ%B@B@X^^im5oE3u~v(2bG=vHeSJrkFGD8nX{J??enkrurSYidrT~6AD#r)PR1=MG zUS%A0k|t{37#2>)gsZiU7pK2x!Gt}e9j+;c#p^*ALrmEV3w}T}h0QK|J z8b!TN?eH`Jwl?VrV(GZq6R<-0(l>(F8-v?%5>dT2%YD1K!V~cWfnsf-rspp4h|l?a zy(O45`+!jN9(Rb))MMw6$WV)0depwD&~D(U>!jtE@~ERr-{iHIw?*_q<{-GQ=k-s| z)-oTPeig5g(2^`eXq>B?_qQreYwbaB-G4>*_oY3X7lfwlN^gNG1axQQgp^O<^UBV$ zpCUXNO;RxxpA#zY#2k0sJ>2-SB{=&fDf zHY|sX0&}v6$-mHNOwrAi3#w8ZLU|+`+yQCUu~C8gda!4Li%HJ5))4zO5M~nv*5YqX zvYG836Z-r@rj~@dM-PQFMu|ghdC1<-)FQ5Q_v?jI3Y{V`CA1zUpx?dqKk(h~qRVC8Q)zJT zPEBt8kpZN=fF9-VM7_~TH8{c8fI%s#^y=+rKYuUlIZL*DTrki3$T*xMnAYWM>6sKm zcx)l6+tk+cKr#NL-@qvk(kDA2I_$`j*i2u2GO4;v-bw9Ywm@gq66L?UZ~gT9%h)sU ze5{~&+MsF4blX*vdfW=)&nkCFViO9+j7jv$V_B0{|C-X>ZJBB^7oJ?J_Il)S^c z)!j%cAD*heHllxmK=tn(OC<#bwYcI{gOQ7+JJ-Ko#a0j$3Qz_cU+ST_bX+V4k8Gyf z<-4OLDDE@+x5UQoiKw2Q+(|J~Z@@A~7~b2M%n1&Mc`O{UL_S6aUeD_?Pfzm;E|s1% zZztOdVPM4B5*+-_;laBS=q&)9D& z3-hNq873OY_GJ1BaOgP|b8OfJRM-}NS&66YiP3qtiEoOmqq4oaKkQ3VauMs7L{-?V zo|f65cdv4yop)_yx*ZL9VcZgAKYCa<5J!j8@9=Q6#dF?ZVp=VB@u?ai*nwM|PahEc%KuwY zsHAAx1~=@_FAE%Gu>_x)VNi4q=0u)tJ>=Bd_&m>tJHbNaJL@b2nM1Oo#Pk(mzxh!* z&9gt{?_GxfQ+S$TJi$P;v0;$Rl@a>c+4OKJopabu{<>}Y;t@2>cymkmyTb#uvRE_l z{!$<>=n|Q4O10JdiX?8`ZzNR6hl6COE~OXP2l-tN;#O3cX9~00V>tgdzW|yNU+$c$ zjXQ=+pZvfn--W(~oPIF?~@Ka}VO{K-aO8H!wJ^6E!`*o6iia?zR1UkH&{2`0Fn- zLpKN}QEWWME+BJYReG8bAF2d1Uz;h4Ilg7Jpvmz7bR^aRsL&9h#cE_TQ25bOGDK%T z)ei5h_!f6yJO}34CZW;*9I2~q;+q1oS zo?ekrcjWJhMs52xI}VDpv8IDc2I&dBgaYTQKDv^YWw+cSnVHWT7M3;Br?YWzWwkj_KHBo`YENA=}i$oQev?b)B_Vbmro%B-d=z^@(m`5~%sgx}PeUs#xSe9vRana9Z}8D!Yqw7q@hV-9_X%WtgoK0)meFvcg{F(%{&1UX2 zrF4qzmf^qe6S}V~!%I#+NJQa_jU(&gr>RCus|ZL(;g78W!LJqL3-Nx z4n?48VW9=qqRN=pp?B50@5-^0wc<>QqOq-Y!?M!q`f912TArbYd@F8Jh~gLfetmet zQ$m0n?44ciP~#=+NYG95(}-Q$`ert_2GzUNaUOl0c%dI{5QB;MFQSlVb9jE!{`nA( zP8Paq&jUpCg)n$xBk+u(uWEHbRn)p`O&vtwuJvuwT2jQ&=tOdF8y}*N^sPDR`55rl zCHWkCllQZ;$HoRNy&=ibhfb;+%sO&fNL>h`i{($SP#xk?*#U~gr^}r@$qJkr3e%nQ z^LW`aVatHJ?Qu5I1I(Ar+cvM;&o#N9souRw5`NrguwgU3+|H^Qoq_QgPOWFdZ*imh z`nw(j?=WAn{mSneg0F{RJ}j+b<{l;d=AA__(snnqu4OfDkg`a>HGYjrPOZtf$$_g& zUddP)Os@e0GuHRuIWpcbb1-`{EwMjnXWuJ3k3Vbju$g?J8Tj^5P-`PBfAwrT(LhkM zv|;(XG3gx{EqW+Vxi6)@{hO~2H={(Adt3n?!@RqRdSUd0N zd6W#gxG2pwh1Ke3{2IDI`Ms_6iCJ+#hiw;#1R!QHW)=5&BGla-Wfim1l#)QCAMQcqxi(7n# z(=Jo+Z~c!E7M%bFD9)js5?*78U2D*qYxl}5rg(i#4AnFzih~|onvs!_nl=b9-q2et zH^05|XJsNo#N6-$AXP2C*Z&xfj1|=~pZjUXmb343Rws@Sfl4Q9&H9r-Kl>&Ew6AUj zCVi)!s=-|xBF$>8EQcI98%_#N7AZ!(4A}RJttWBda*fT`u(W%pk-TR`2_ZD(@X`+@ zaqYvEkyYP4loCcW$z2_{(W2!PhoGipqO&2p+s2T-t(b^X0K3uAzSUpiy!-0 z%o;V5+GZ{Q`duEG)jyUN&Vx@-RqRV58#$DeVcDdGZGk96Ci!U`6^aQ>8vY>tF$Kmv zB=+aOfm_Gq&ZMl#_YPd%YrQi)WouZ-Npp1U@C^nY*mB z|A780EUQLxyLc`7JDJJSb$Zpkk-2U@eef^pbV%we?HeRKhO9&@{buctT2@RdpuOnd zKN#<6Uy#awxF=NnI9?(wzoTwo8S=(!D_kOB9>){M`A_`6m;(3?@y+^KYl+d*qJY{1 z!r|Y!o%J)5BT?b$v(XH1s=79Sle|khT+m@jBB)|2U>?lBnVIQFfUZ9A{SdcfO(pYh z*DhNae^F<+`hfS*HHj#ynxpVXJ=o%e)e86}$u#KTYap(_{-GbATfgs5WyO= z!4%z_T3h|?d##-t{30;CC3lWXE1Mhm0y2F%J{WKtvL83^IiNdx4$FJK6LALV1@CyN zxa8K)WY&BR7`Uh{wIk)t!l&bNzLOc5_B4}b*^fkG?LZ8K+ z#6gcJltN}@K6CO9a=)<0!QP{hQFZ}rpLFAecZ%qSFaWI8YCjr45jZg2;~P;yMlUUj zhGVwF%s|ujOTGYb(;j(Kp_~vA+aPPG8SKE`g&u;Xspz)J%8Wrmbj5ZK!-d|*si;aS z%#Pvm8Dj?aHXL7dAa1z;<1Yq!t!&IcxIK9iDK88|SpldFLa>PDX6BVtEUx|~3!_0Y zVPF#Nv+;~kU2%7}qbfbJ!+6oZuOz48^oV6CoBYnu&Ov~=(wo68bI1%9nz(h0D)ifc z=}zy+b&7McfL_vLOEPksIE6COyX|YDNVdmNzN^k`TNtv*XhF{I^n^V3#{whIa(+Iw zLg67TdP5FBxbVb|l%^1Y_GGGn;QJ-t*+-~iFmtEQCVODetP(|+4>~8c#{0C_ zbLk))^pG6ARI4X+p;24f0X@dU(>N|p ze!xqiAjXP_4uH!I>4l_ma~*xs?AC95N5Q{5_D_W=oELBv=vSu!gM<=0v*iUWYkJ(2 zN+pykJcjR)?GA#;(HNcZYioNQga--#sW13tqJs z%(-`o0FK=AOJY#sW;Tp`=Xg}#ame8N$<_8{NO#hqr6Ebp`18jD#)=jA?FY1sMH9aa z{x~BbyYEwW1QlgwbwNiAWvQbOR$@X(rU+a)vDv zpV^^Ywvv$Vlm5yOaFbC@8d(R^B-9mMVvGz^_HPCCBqy?}*e{G6&HQq5K}ABe^XIeR zyq1l7-V`pSqGRQBDa)pSM`N8V&5t5M)E4Zz94XL0S{PfE^xBo5@(U~Mvr~Q*24!9_ z%zC}u;h$qB9DpIo-zX$uqV;<^<+!fQ5M0R5qoD9kO~X-ycb3E6(2 zWXnuHiay7m!Y!s)rvyYr51JNDN;!BiMIX|wI?Ni3YE2p^o_lR5f+t=dg0ev@ADJ%e=8zS zV_8E1ZsZipSKfz&N$9FQZC2WM%5gOA5Byp&g2qa$@uzV2BAS7L%bFfm)RQ@?Xpfpa!e11FG= zO{k$)H3t(3W|mn0D?(aLUeZg|9;`^1>isK$qf7lCc89ig?tA+Kc6xUuGS=x)U!BUq z>yHnr!B4m^e=vix;;DNsD|?iF)t(8lMr;{;p-{6dN`I1@_yz-YTA*QDk$K4FXL}CH zhgMhjiv&WHG)E^eY8`bow$g&n?CbK&83hiT%yWeq#zwmANHV337iiwwG<8NyrNmQS zUDLOaWzFp_Q(!6u5eUiS%{woS2Fx{YE0rCkR!Z^dOC#2SDiZ6eLA(it)r$s~4W)i1 z6w>-t^|Z2KYmO`nslDk$@{Bt>M*PQy%UPvTI@CcVLm0Z$0-C8(-OUvOYdN(WXVR2S zMmQmQ)G-{krOVDOT0;Q5kRK!GX$|TrrMnXO9E7=m)37}=S2*!B~om0xaPUQ z;1Z8oaxtNZE}S^UJoEj-jv6e}T6y+g8j`XOf5u}2N9soRhMV2)-^Lp@#Z8vo&~#t+cxLVzmqd{HW0?=5Ais6nUqI!q3|~qOy|u(DjS2-E|>2z5q{V{?DhWBaJZ^Z=2`&1n@rWT#OvcIvQiw{}0h!Dg(73=g-o~HS_3O^ zc7d2;2@$`(i|^i=kKey@#h}Z6iaMkD+A=B`J(lJ5);@cWG5@A*-)5VCG))~i z&cyrb`PU1hD%Ug0mdyP`hY#45+@>P_KgkfhI)2;|0#P^j2J3XoPIh#zA4&sr%}rr3 z{KGFx7lZw5y(3d1d%f(6f(g9ujfFmn_>DD;D=w7s5r2%qLbnj*^2FuySxvkk)n{JJ zc2re2xB_$+6we)^R{Y2J`&l(tvxaBqQ#P3Q=flBcd*-Sem`Wb14NmM{gFq#5*-_Q^ zuI4p8?(<8SA)TR$>H-n93`4#0rzGN^BPSiVzGq38zL&?ugu`!L);kcJ_WpdJI6poX z7$1zV2f9;S@AO(z;Wla+$(*XD*#(VAGbKc>EATiPFPfdkK?z6srsm@QRAVP??EwZj zEUj@07<3_D@gsMQ35s`{Q294NX_|1%)0(MC?2b?xhYq6hYyvfuG<&sp3O3bZIJn0_ z3@S=)oMF1``!l*}`63W)u3eXC>cY-OVrN z%*(b~I81Z)4Isp}*3xB7Hs&RRyEmU2u@@fP0gkFtu1%_Pbh894tf`pd?Q&G7;Qqwc zlKNtb8bVSjZ~fcTND(4sLq)Pm_;gEV^ebB{}t9?-*E+P5$60k_z2y?#D89+lok33)srMXFHrqniAS$)vk@@>>*q z8ro=x2|&_;_)kVa|;h(z|A+d!~O@2({JX%Rm+TX7tU)vgKH+E}Z znIXU3-ld#fia4eV$@}4Ibj&ZZ>2PYeXkL6;vF+RG6s70w;iOye*1QA#;tx8Zu*hmhz!^%Z9B`) zwz6h|JkH-y)TZ#u>~9L(ghJOyqaDb{NFPqWQb>t)(QCFhN8M==9L{<-;YpBXbW`v{ z-y9iu5)>Rd15$;pUT|IfRF2d?Tuta<#gK`Sk(d&WrHezm^LE_p;l}I&@RYk=?JJ*( z_{x6_$)@TboiscK!dH35oYT3^AGh)amSL!eV(b5jgWj(ULi}RG@KDz0H0DuZyxdJ< z7PM?MaoJqMMaQc4En+;>o#}zQzCly&btzv89RQSGm>y^FxNqT+tcl+^-bM{*| z>01~fwm26iZ^MgZJ8vpH-6~@SZoTH9H?_8gj^#Q{-@KbF;nnH;Z=67HY;&!F;6SWL z?4&>PCupiEaD|9usrWlSuDD-U+v=puO1!8%m#+yXL99q{mobbUBTfm+5ShdkuuhHU zQE(U~0$sDK$6@mX)M(kia@bKF2e*%k9aOHiuAzoIntgg0?-T9OQ$OpBx zv-5gdX)Cac0s-tS#oKZy99k*2o|IIUPJ@5}UrChnjI4&b0PZt!!odd^0;9v<_N^zd zYID0Kk!-tLVN+_n*K(;$_QGP0AtNpp1O=G)6lt+~7iEO`Dv=)44&_H{(%7iG#BoHu z3ho{$+NR6EjMe#g%oAO)<@3iSR3^j{ztnqNFYbz3lrgGb1)S-#o-`F7Dv(zuv(sAh z6nTOyR`>pDw?!Vu-}^2Rud1 zePFv}Lr<*rvwC!I2GhMbo+J$^z?U5wfSodyT^w&byLvZ z>?m1~{@u20{hM7`@eQv|p$Ledfr>z{owM(y3!OEJgE+?7<7k}zm`N*I zmRDp-(FUl_MQN-I%W1QrPzWdPOIb0qO-&PPFiZ5y6|-DvEfiQ4zKfk~moAN>_|*G% z%x!D9ZubVH<1`4BAy$Otyc4nO_osT?wj(LernwJ+une@7#^u!->+J68voZr#T?`-; zh*ibZZZ7fIYv-kT-sZ78xSWK;fTAz0^{~R=o{~ncO$*b@k9Zs~rDed}u zVUcjp?Q?BU=Kww2@!#A?Mf09Vygmz|5!nqaGgGaRsieMjY=+fd0-Ie?p6-B_2U}&b9e$!~oJOpm-CYK|&fThJY8r{$3{<^!(CG@$zzZ z1(&6$TXSA^R?WBXvpSqw_K{6)Pzqw+0#*D7&>wOecpPzW5;yE$LJjt< zcIFA3vJp+O-e31TRR+GgJkf6W-XRA+MFxN6%M7UL8nSKxXfVB)!FM$E)3Cpw$_jIH zrbL1!uk-KFeg1!B?XdxvA8Wh3La%l{?r@XIN&vXQfW9T=-(UXlXw34{<>YBVcG&A} z4LrBdY`6jR{IK|Wa*`~e>u|l39-HE>x!f*Ros5_O!$kcpdafEw<>v=y`Ktkb)lX;g zS7DGhvy>LqV{SxjmYqdBD){N4M8)OV2_Y=+B;F^B8}gF{*z4BWG84C%QBu98xLKjN z*DX079!wnLj#&l9E;(fK+WdbOAbgNjM~XrZKhK9=$jeZhJB4aks~#pTT$Y@ezTz&Y z+f@4tw9G>Iv16A&??0Pbg$5J0w&OS=&FGO)ft8A(TN>i%dDFNhtKG+IJsp{v@7dH| zR<1gNmhcoYW7Oo4$N_lVPl4$RL4gVF)SValfIDWX+QUI7tRm=gWeLcd_`(>uP71wR z&YZDaLq{fLfgPR32&ibvLKK; zo?@iKp(zv!XZMud50^Oz%ae(XR4i$;ITQ@K>5F`tJ*8cs*BK|Eph}jTZ%>%MC40KI z7mxCB*BfRo%&lb4%mxiAXHjoXBxK_+Xdwt|K#Uw6f0mwGYU?P=6xux>+ZkzV9b5GE zL}-XH{B5U}#r_%2PPi_~{7y+=(Hf_^-tugjA|O>qorQ$p1jXgqD>F?Ag_42z@h|h& z{Op>{^B?qf4r4{u#}O^F_x>~xLN(1| z>o3y}GTM!2xm6?rvJ0E%uNB5@8F-Vs3+tK|k75OU_n$%Kff(8{$@@FRk}sXUEGaf&O`n=x&dCi)LT(%Yc(zZYmxipTe zbujU{&LZ~fY`r956ET2bOsXrS$2WmRtq3bH0g-$-Pzrk5I(x+qzRmI3dLcg){QS7> zq2iofUz?iux+@9w_~oSe(VmLOSa;O`CoUhW-JMQh*dWZvR+%?-Q-pGTq{MEdpK_a( zhVr?;ZfAcj&3CV9@&0Zu^65A!Zu!J}f(r0Pe=!MijawT{9?YQPL01GL97q8NeK zdo)20I}{urF`17d*6b%0ecn-(HKk6?%SPByTTyW`pmkiQCS5~z1_gi*Gonk-buy`s z>2^%Z#(w2+9#_Q3pTfP1$h^xzfaVr{@@W$0ojN`qJKm3&MQUggbdB!{iOdV`n+))= z^ENckHlvgS2dJLfBo z*GW`-NVy?)hiXWOle{cc;#Ht>c|+M7>T{yx#EP}?$R(ms9+Jwz_uMfr21`T@t~oU~ zf(A_OZpl&&?zQ$(t(J{H8lCt`(RRK$2g|Rq4q#@z`w3r&O-BdDGe6?(vLgI44~M>4 zEY|7QjLLfmqv=%+wkQtFdlh_(u}optInUrIkqB0txDrEBX~$Cd>^@-$a*Hq+4Ki9F zis*~mC8`leUm$91O3#+(7(1<%s-kThwW>rmR#+MYu zCoxv#5d!1A_l(ML<2Ml!p%1z<&#V^Gu!=cE){rTcW4#$<8nc*cKfXqx5dl?id*|?? z`LUL*qRC-@EIP>X+1TR?+Nrq`eMx#PhjM_j9$Q7RBEGe(KV$4pEH7vDYR@8BX3q-; zKO~#po!+|gxoqE%N4JAF0!j)j;HTU3$F=Fe@EM7@kQm zZ}Sagc%55g_ns0wklo+3mpHqnsrTnfc*jvX__&%OdT9RN+)HNmK^L8L-8!Sws9;j! zKx-`3`Sy19d(}!GZZGAIG7!%=(f1v4OVzG2P`wTj9U)_yz z#XgT5(|AB}ytS9`ohzi@V)uJV*$!H1; z$E?MYmXZ=UO>SK(y=z#&;UY52r1kE|35>X&*y1<)i;{x7<|d|%KaPLQw)F?#fV;oO z>J2N1#j{EGX&+w>4kDfu;;%y>+*bBxuswbxTAx4mjn}*G8zv?uIM&n8LOvN034{kW zN)4r1*85-v9qEZIobeeKu5E6b`t7_WV-}&P__v%niOsZusLT&Oam(?6FIhA%T_B)E(k3cf4xd zgvD0I`m1UzB_E;xVy2EY0HPP4_I#Y7xu0YD^l{@kAUMwS!%I!@Q{3G_&-2^Z=L8td zj_2-ZgDfy$KCs~14 zYrrYSTiE{r%0L^t6K2>$>$mj64Vu)2rjwePWg$GPNk;^ePIT zutMx;<##_78*MQy%~vZ*mQfmIkINOitVju|+LeG+ybom%K2d701x4b>eFircmmB^R zPD53xM$=3_(@m3!GGVqekT6eGX8FM^nsT5GW{<3nr2lAcD1eP@Z~Rn1pFT~VPRCnY}}%Tj^o@uy4_G_dQ{gqdJ5av<-yB$@H1YT{xE z^=ozKhjm$vixU(FBjo&Y6|x(e$8ikZ8U^#!%a-6HQL|gc;5S#IuUz%@UpoRyf&V*VhPp!xBbB{2*=LB&&KPtgHD< zMfUnDVUwhH&v<23g(k2vn014J#aNd)R-(}fBWs+9qHZ1RhuN%*5$2J!;`w(5#Mppu ztoN5>XmC?Pj46YM{sj9IIVw$U^c{M@-rz0|nIZomo=~K4sA5edGeY8o0qo{$O_(`G z5VIwR(i%HY_QM2}g#BKiZa2(WgI|8h7y4vH^w%XtX*&^>iXkrku3wKu5B~j2-gsQw z*eZ$(R?!3~{O4aypQe1$A7XEV?#_T}ak^87Wt%NAX2|nzRze($L-A563$ki2VId(o z*FYrZEMQWuP*4fks^7VsxmY1}xt#O~`o;k5R~KN7t_2nu>ghXvU|z{fJe9jPUz@C~s%arSp3p{wrYV(ha=3LzFkH zL$^{F!01;xL5nGOEBX0%!n*;i&d1$Eg(%^C9@GPaVG?uX6yL$ls zqXDF!xu$XHI`CV3m{x}B^;q0aAd-BSPl40--8(j-!FqDiZ{0HWU0RAQaIKE-+vsJQ z7SNJPIWerzrS1i71Lbxpjh)8ckb_pV{y5h0JXF(!X+6P6@nU!QIo_+zu~Io;4Cjvb zCrsYFR~eOdYd7?`vSczj;CA=ld9NUy3)EL7P=1VGq3WC8GVkDz{ILZ}fl7-U@K>8?NCfMtRAKD5x&ySwwXF#X2k zQ&{X+)L2(1&30VuwukN_c^-CgKqj&PS2z^T*`&Z>R_Qgm+dN<%g5{=AVp46FQAzV- zKo|q3T3sM{!SnI$yu|GKK2fi2VcZ=h^&}p(fuVYrY}_Qo+5#!b%t$%n)c1#R)jNHI z1^mSdk1Dk>PCvL+)P8?j4HNOO{p8FoKjX?;>Xt8kQtaQANEfUWe|$>2E1n>}Q3IHJ zM1?o=F9}LPC&iKP?Ru*~vPQZ87?1C~sqVQ$u4 zCP~1>hi<4}N(<>gL^}4v^dFMbjev}1`!*@+p%^#e;2`f4lEa%wcMSa!^8o|dor*+8 z``ThL@^+I2A_Yj%ir~X|f0G4GNt9~Fyg%xD$9XgR!-#}=>&Y2(UjSEfV!KK}A-FB9 zz8I3x^x5rD2*xP^5$fs8w_{Wnw_pBl`te3M;3e$rW$c#9&lO`^PP6H^aNB4!;eqg% zhit1q|5a2-5E5J+i|jDZmuSX+Vb))6co!C5wuoAYq9mzmJ>-a9T}>PvMajg#3(Pw_ z-}c;gyz<3;6xlv|l6|EbH{`ot-*_MmJYx$?3x3*oT7>o|GysRA*O!3*(O7bW2lCTl*b0 zo_Jr!UoYOi9Cq0(X+~C)P+5i>!K_(yLd9=Ij7NGGf5cpq!S zpVNJWL|UC#k*sVXvkZ5KpZ%Y#cNV@&r*~f3X)f4{wtV1p*LwNAolzIy7^H9yTD~}} zv23n&sE_{NkNW2#=}Y#Uz&$JG5$WeE#jBl zF{PG4L8C?N_n_m^_V!cP8Vr&%I+!>8CqBXQpY+q;cR}g&Hf>)sD}J^?(*6BX(=?bD zoJLht5a{bm-}Q@d5N76*Or?V1&p|YX@k3z-X}Ba{}xd-6)x@aK~bpFb0PXr zz*Rz4H-(efIV8Ze(oFTFVUdBi)(9vF4Pp!qXO8$J1ca_z1&v)Oo@%r{4}#h$gFxS#7< zl@C;%>Cx0QVx+qzlN?TR?kkE8piefYeaAR%V-sU^WiX&F$1zkZVJm?jE2(v5t1*=# zr&MCa7^8|np79a^on>hMs)z7$qB``=PRfL(;cfyfyQGaOU_<@NkC^%2hlu84CoSYq zsR3Mx0%tTyFm~p%EMwn%%1#sQfR3k%ag4_57yf?px^G19gTfNvT9j2T7!;sCaIb}o zHpk^}#_So^?JwEGasLh%;-*K&>^XX3o;{O9jyC*2 z;4_y`cCnQH&&-GqV8Us$!wFPpe?DGSp8lz|cCucPFbLms<(NG;+_ta-vaFMg5) z$IZy`DGxOi4Ko!5gSJULwJ6RF-=$V@qIaukR{&EK9^?yKEBqr;4 zWmK7-%H%3Cwj=u6>i0M>u-*AtqFvyVJ3gm z1zv1!3;3Ai<%<%3ZS7-tRotRw3?HL_oFmjl9#f~tPE+Ag!$7<7G)KKD7$ z74mc+1;DH$NaUi_p_$foU1!R`5gP@&6fDmgnz)IW$-)ioF@QI-=RRrPS(pRr|j>55PAY*VZr$CKJ4klS3B z3ro8hStOz;?9~N{2IAp7qeH%bNb663y*pgr@cdr?(%CLPddV!ik+wK=jahf@o@_I% z?g6SELW^kt)#BmQYu&UpeBL=syy2C-!{>DO>f819a(+E5`kY||aAmBdov{d6YBv^+Gq8(&@*nVMN`^Tl!Sn7>F2>n(q#T&;b6*NXadn4kTH~#q3eMxG-x@mxgsQ1pxx*kIbM+oaUg_(bujD z#*eurwfZ}82Z>{ZYE?goJ>yoJ&2BGOFXumSYQoZ<1Fmjn<(Nt@)C1mUxr-xH`GSzC zK>dOGcY^`a(QGJ zuHnV>-6lifBZCivZfI=u+agX-vy8go6d{V zh<;y+S3$3ot`v;O9Hj|UBMxmqwJ|-{UHDkph>XS=V3cRBAuhyNEekfz9kP_S3^-B8 z$poT!c*oIgVJRp(ipr5U*1`Gk486{E)bteov2)D5Sp4ZBpCXy7D!=-4UsJ#S1EI(< z>s6YKD||nj;Q>;K|McS*!#q*-^iKH6yvyu2w@-2`RPqu`sFV5E>^xo;kc57FtG89- zdfYzq55JChHKjt$U}?Zov>lq5VD6IzRaUFOW&a4jICAGUii{y;o2KwbTOWW~E(*l3 zdVj|p|FTdJZN@kts|Z2xWB|*=FV+ut$}@}u4ki=ym~~EN&VFj#7M%gtRF|qHCMWca zC|qi8MJr8Nw~^l3Skqc6hjdpSxuFR^QvtI3Gnm80KCc18r!187Ic~Y}uj40(rktKC zBMEYPWNi0CEgQRRudB6A#|ujj1l=!e9*-w6*}V1~Zlu>v(`;`KE%)neT~dnT2P=BAx}`_ETohBKw|s*AL0--;M+r3yn<#)5dR_|?O# za%!-K8OCaUpYOHCFsNzL80LmdXI@`(VwLSF($;-t{gFd+pP56g@x4_K979E~Pbneg z?jYZrqW)}))0 zlLjE{>X+>^B}{Jvf$fE%uwT$Db}u8MzEjJ9?A*MhAzW0WYh}{-r&_><5n$YarE#(b zHm1XV)plQ zB{tz#6sO;>Op}vBmM%Kaeb9`*@wo%z!qL)*K&w1QO`6Td?UKxW!UNMQcRu%l971!7 za%+=cHGPoSJ5CCj`mpGloq9nI4``UFDYyO-_h;S+O~;%Iiu$j1>{?n{JG=aG@IzyS z>#;a5Tt+r@f{OW}=BfKArJQsymIiWuNUevv-_W%GEgt!EFZo3^(s$Ww$?k5`wW<+@ zl;9!gT~Zdl&j8V|J>64bWe?(|9cpnWc^F5%#=NviEGq>Lil#@Ci`}P@E_J5mny*Ru z%lX14Swe;9s#EM_%;Z9E42cseUH1%zKDYee&;C%-PUb#ge0t9spTuJtW0C{EQ&(Ic zw`Lyx)7m{2hvz2RrLCr)Xwcj{d!cB%7~pH~sEG6}et-=|jT0OkrVzH}k^BEcNw)xy zbUP_VCmAq#S~7|{TWxfp2fr2$|BHCGLiltxQd!#_bcItrt0(f1R6S~0{s26{SKj{4 z$|M$gqvJgCV0W3-wm!>H8g>5hoDMM)>%U|`%}`)@bo3S3mD?|ETk<)FUiHO*!S_JK zna`E4_}5rncTUD|@$(8b6{*v>lOfFI`nyjSkhQbqcs`nxjuS6ysaU&}LoMS2iSjk`HnqtQ>%x5$a}8U^l(?g#&dQvU6NXgPp_xWBW95^0BqRJ3Ur$(b zeNdIQMBGWZjcW}?BCr@e`r1gYE{dyKLZE7v#;wCcq-5Tt<0zEF`4o9-JYIL4VbS{M z$bIxrq^32=``cmoRQ!mj#VpPCZ-6e{$ox((fDBZ{5#4@W)wSo#_xU8;_ zOvO1#fwRnm#1lIA@hCI71wj&lDz_7NI-l3Qc5(}u2 z9$Je@M_iVOurOA~F%G1fISbJ$t5zzL0--EvV!83du+z6IPJ$!ZtP72pU8}Ue22c^R+8Vo_#iY#Pcbd0~PPZg%Q%>@uF@3rJp9M$^vgp(|a^60h zgaHypL_4ckGsx0_XHgU0O(bUNZ^ zubhC&{NCWLOTpt&d`cnIzX2`j=m_#dLpVmO(=pA^OI~@t z_u_cg>lH~OkOI8l-pRi_s${#a^xsOq&)s-JNyo8Wee|-hZZe0?bM!@`W`vNmFASgm}f>7g`j_e{fB{JWpBiW18hl4%Z2=wnX)bPi!I5zLTZzp`%a zA=IUJBC2FbXER`TBYiQNjupJSS9#k3YP0UkfQ{GOjlFvRK0czeKmGyWI6u$|Gk(q= zA*^2G?gL|gIat*fIgV|!MvIKT{4E1Rw*|<_x2%u_WW=$r^;n5 zRJU9ecBQ<8o<@Z_12e3%0WK2`g#1XOAxlp?mJDq)>5J*tuA*WexOr>8F=c3({rmS}e!bEUcAQ!7Up3Y@oQkoZYlQ0vbpP(vw( zsCi~U3PW*}R@C>hT((Qm8myU`sZ zQ4?b>x1JkKul?80WQ)hdZT2$gaUeY)0#voQG+=3Ejt4u{8u1#XFiJ6pxfwgSz=Ic! z%Zcft%%yqxYw|^Qyc+gA>Zr?nf*ob)|AcSpWX4Fmw4DIfc&hWyu2U8CoL)> zCxvMZELUcejwhSM)P>`%&M0hg3t$WtaVoUHzTg*q*|=dLQnKgdU~>PxiO6CXBMzR? zAUyAQ(W;;L`T22|?*{2ZpL_eDc~(Su1ye+n(V;2>y3AB$4>KNCLUJz+-1d!`?=evFf7q-_$1%;$jFU%6_9Pj9sI5dP zW^PEOZHA0`tUu4qGasON+yZ#)pVvt@_B4@ND+ZfXfScRO4O z1T<36i>n314H3_&X5yaUaooe4`YA^ct3$|7-Dx6w9-DQ)JAL~#frEugZG_T?Lm5$^ zU=iIq-FWk@FrVr__ctuUGVI!|obKLKdA%3CzI-Bg^z+M}_J1HyG`OELO2VqjhC8h} zct%&oSHS-s$Co$l@o$ig;W#S%ymR_^Tw$nY@3j-w@iJuRcln^+=z?n&7*+BG1Kt4I zZcrsFbycdO#=p_&o84BUE*7ZwZ(Y#2(y}7z#+|ACYqHP00i8pw-e&vc2WiB8IvEfR zKCUQ#O5AU8%yNqN_4Pe*I1Oc6yN5bL6Q4g-NEXY#-KMxF4UhBF4J!<}E9h$h+)|CG z@g-e}gnsW@`HhApfZl16{!voqL|{y4I2OlKbh9k6!v20VUUUzjc~F`bEc z^c;`d_yKog@Vu~|hc%OZS_=V4eVgBeJq~?zlu&wqFCyD^o2y3(M0&%menVaTC}zL_ zl2-a39#w{k7b51t=a=CD~SPCzK=+G zh5X_%-gt6abTktWFEQ3j>E(|x-0$b>B91MeG2LEML_`S?bxiGcy*l?V8_ILK9^Uuz zuMF3`^d6;|5h6_Tow9K`H6$#4ipyYCqd{tih8%trTUda^)IJn+lT)|R;TpnFT4H~;+CR???3BFI>``0N> zqmZc<#oz_GF4+Zy<%=ol498r`*wfeD;$-j+yvEgDM_Ur03i)M)Ui)e0kht~WN?hx7gi*VbsA?c zk4})?_&#l7SHrBw-d-ywFOSy!a-{j3f#Y)x`690UzM(LQ-Io@#VE zEMUzHhzbHaN<;@V-r;wupl$bQ)&x|4Ud7!-@;-v1Y>!(@>eU$UmU!gVVvtxYf-u;S z#OXX1X3LX};5Txqtd7e+$7gKk`TM_|ixhTltDFp=k+|m^+4UBHA^Mz9@kmMtZcpe_ z!Jem{MtC^tZcovxCk#T`-Jpy#m9omCrIH8T%4dGQqgL%q(ylG~&!h3RW^?svvPpR= zr1Sd{yszBNBoHw_N2YFB*e=uf-X++$y{zwQj{Nz}1A=IlRwZ z{2fu97<4-pCHf{YGkE4>3j*(**cD<=RxG{iHOp-BJqRSa7R5#U_-n$O}}1 zz%k%41Ip=Nn&Q0ZD07xz=`Jf#FM*AQRogF+G1X=OIWt=PE3sNDX~NnNw)P-|99n`AB4jN5R+Jek1O4 zb>V$pc-|T4|B$4=#1VJ3&2Ua%RlxH(p&-S|)(V!^@neKjZWEijEQY9De3A4i;6D>| zPlj8({2~1(S*UN+oJatrG}gam#R_x&XX>7TW%T3&Nh+#YqYV0^_oe8^r_!t@OeWP( zevOEUqa?;@ohhPDA6^NWR1G>Jw9hs`IydB=N%PouiODNLD!PR3Bi0Ysv?N66)RvukA6mbrDI={oz z+=YY6EAGYeJCSsj8s9y|?s6Xotw%68Oi{N!0|ibEjnkWiwAh7`9dKY0!lc5C24Zmn z#T0p3DW{QD6$tQ!G84gNF7?xQ;BP_364FBg$phS-SFPQ_t2f?x?(@Nwp&Dq3G7v7C2Mki@+E>qV9fPD zJgK3YwJ%F}q7R!U^{~4OJ0$VhvMO$LyKn~iv7&ELfuo}o2`uqol^1`hL}2VUBB5{^v+4wKqd4XjLmmWYi{>K&9#Am>cT(nDTRG!U9)H zJR5Wj(fSsJ9r>IZM0cz9jGMV!@K{r9Pt?{-#YxytuZO9NtCKul zSFr4k^HulJe&8?&^P3|!XGcEC$#B275y98uY6)Vg1r2)AJ<_YFXu9bU)OW1|R;Dpj zCQIbA{X$r$0|!bK{&!OC&xA|Yx+zc{{crV(UwXeL zoAFCgBwLBy!sM}JS~-h(DEVBA6t(45mpCgb`b^WZPvfATVW-No@73iC+(iOc;IbzH z4~SY@Ax%S=5%z(UJ!QilHYvBNO$|oM7QfMJ{`Lq{0EoG7S9*qq9ys#fW1q!#M*kl zKS%WKfeloiH*1=rnaAigUIi(^_(Ao%r@?~liynJSTycYovP!(?c`*iq$V&t{K-KL# ze?ImfWb=Pe=(>CLW=_Ks?;Xzfoj8s@uni||kQ$68NIab>@{OJi^n!pzvjerz=LRkx z_|3a^7dyRka`NQZgMwPtJ;QY!EMGUvyZfGG6(w+Ss4uO$a8+fO;=?~nq|!*4L*>=k z%w6^AFg(!vB4q|>kJs??14!1(*9;PZXBZVU33l5Gtd8JCT$gB%Qv(Y)hd{{Un6a9P ziA;oYMQ&GcDn+Z(0OYp!V|+ z7xfZgzdk(;!l#1i%bX8h>zZpZUW^tdy{8EIbhxfDF<3y|%k*C3mnD^-^&TF@nF*!Y zonRalRIvWjTo5K)Cca%CS&13}O)>#=f$tv&zAe$#Jul)E#-C1K>3>v)ewPHeX3}LJ zGMj#8Fkp~)pOgOR>_KU(Np)@MyE-~TTxw5?w+&=v%Ajp?PdM=Oj~wdskP%a{{}&$Z zvHDccna#1axBZb~@RXXZ<^*jIE*?rQ;DbW^sEh^MP|6;Vn0;VZj1yu54aMECe>sfVEEW56i?bRRK23%2kzkOWzm1_lZ`!B1V8k?* z`{rY#6fWHrrwyz+qz^RNb~?iGHz3@|l%x&UiiwGXd|>t%#gd!-W1Qs&U(wlS(oha; z>(te)6ZT~v{_tA4tc=j*4dte}L=A|9^m z%!JojpVGAx`lF;?C3>1$0Rl0rV3p|}vO*$bMg3oLx7-ToYRfioAj|JeR}<_G=8F9R zkzo(EfeK8@kw>gf2B>@{2u!dhUB{imK$2A!p5&2TMz+I~5wAl)P@sn1NQ|$flxgu# z>uSr+V7tSDh?X5c9PWU+jzt>adEPK5rQ;nhq*+QneZdWt6i`v)YV?&Ulf?Yq3c*oA z-5sSyD7VusO1FoFqu{}pa#tgW-8oA9ocnbw@44eJ{Tjpq??w+zhGZu*VN zF>zdA=4tw{xf`lVqy8f6jOl}AMRmLnYaR?oQ;I$Jc0ja~YFu8~As4$WF?_>6U2Ipy z|I)(e>7EJj3yed3#4`!>^z|-xp(Ys}2=8`hH3vSy(WTD6*c0)Iwhz`E|1Be~sF%-E zl5uJ%s<0OEdHW1-6Y0jOrs7n7dtBlYOGh!%F)?G1bpU7lK0VWKyB0pzd)mNlP(ms| znR-i@z(=1O>EtErdEmz&7osLY>z9P^I^MC~C=EBSZNWRw$i#yI@xUeTQ)2UdM0jS&NZ#T(b>y>`PixfkP*qB#MvI6pHdM(p^LnlH)b8 zaHL9xMzeo;ek38>HPjE5Co=dA@ApV4;uPm1rdfh<0;f~{W6b*GUbG37#@*jBH0FK! zF~DT!vZCSQMp_nMyJ4LBE!(U^((lt~)TBXCia_?BYXBZ&JgY5|dP zF#k%6`xWTx=0BJ^E*m=ffkSDiiPoP8$dj2pVSm62HGrzII(p zU}d^qlNI%FZ%?xZ7msi}c9owBSKe^D*!-%rc`O|K3fQ7jDYcDVQ2BB&>Nk{%n9Qh; z^~>EtUEZ0PRpWLd|NI!pXJBhh6kET4@vLZ2z`+{juS0M}Vh1B-j6}W5Tow0iX>XEO zgDIN-9SUUsxZHu6Cp?090yoWCGb6*9mRUMN^=`2F6lDsWKh5A=m~hh>@iDrnZ&{I+ zON&yy+^P?EJCsYl9+Si5cZUHDsbb`m!Xtp&TuCU6)T0(7+DUeQX|GXfBNYQW32Z%g zHaJOgc%JW@LOWi;eVi(eRJm0N-e_g&Sm#s_gRuxd)R@n7hkJj1t=kclGdC>v%+rgUw9sG1Tz53svU5OA{@cH<)GZ+!ko|IXC7 zK4v^x;SX0~Dv8eawY@5>#lJu$7)K1%x(uqWtbFz&`jqM--W1{@;9r0Q&q^TA4qZGR zWp!AC%CXLAul`(Vza2STZiSz#E+J;SPxha8PwHZvIXPVunS5}AY?nu7FKItt5p-`J z4I;L(s8SeL7goqu;YCM7vl4VBJt6FI!Vn`uSX!Y?rnJf)+}rJU|M&y8JWiYa4!_Hs zOCXZaX1s3>pZD*Fu2 z(O<;gSjRR=2M{4>w52$gg5~kCq91ZVW`7oySu z%$SZlz&xE<7PvMUr6PJSfQ*a}J_x?LHm77CF&ypapM2AM3Q}F%eNaZo5 z?Uz|;{n-BrPSAw#B}Dt3N%ix?e^PmoY|oovI45O1SryEta7nkN@`1#pTCiQ4mJ=SE ztg^x}H0H0URn+^=;*#z=)J3HrtmYQAn4N*aJwz!;QIn3YNdO-rhc4Ot5t#8ypA$Ll z@NOvax0J*_;XWvo;}U0pDV|%>=CBNV&u(Sn{O;*TG$YaMjf$>O~RGA<+yRTN^U zuV_eJE);hL>|ub&VD77SVKq%9qk(}Q6yxfd zp3**x9#u&_eO{?|rbUwXYJbgpw^{Z>H2b-szCkhsi_n2rw`%nF-B7mk$5=|^(+)vJ z(IQ2N#!c}z~n)lhu7xOZrIp~x-V#=2p3cg5?G;7@k219&(5l`X@%&IHuiq7 z@Sr}7p8Yngs%GJK*i%WUXs-NJag!0>q7#d_O$yHNQUhycjVHxK-8IkSp(Jv`w= zE=~s3j~-%*m;t=v9u#H6=O$w~KL2Vz820D-&eOv$y5lFrVKL`EvH@lRf0{lP2?EWTw%TM|}{So@QkzxzGo zW{tMqip(G1V>^-Ob$EbYIohIPfTmi-3USaqDl-4WR89KYpq3*lgMBCh?Pu|2VDnn! zI+bi;bP}3EBji2g(%L!M>3n?+-W#}@1kko3?`wE z2>!hN3-@?J+P&$frdLqaTox*J;1*{x=6U22M8E;O#f9lXGi zUklp*&jPr7JQGX1mcznn`mgfVxY#$nYok>++oVcpgMy(&??QHnt)6a?C^@M^@;BX% zX*IeN2`ERgEX2O-qWPPkBD2EaWe3GwUL9<6XMj(!pd>i&{llA1rP*u=OLDr)G%kLn zdR#!(g*SN%_IF8*4J*X@ssL(|+=Wz+``mtfeosw~M)~vxNZ=ABa~(kc{<^Yi&KF( zct7^KxH?BKu^C)X?$B8wRMSUiZBp*cCz^Sm|0Hp5#oG-*i|bmeU$4nnz$-5=w{6i~ z_qitfzTuIaoo!RIv?M76sA`^f{GTx%t_`1afP37y_;`RC0Bq^H9*;zw{Je(tDv7n0 zma4Rv&N?4x$=^0{Ky<)1lPjI+51%oI>W{^1eiF7!L?j*)aAl+{ylG59Ev^Joq`_^m zH)4(4kwNh-J{L+#Vs84f#+4dqAvyW7lN`~3nC|CURs}7>JHi-o1M}4Pqfei!(2Z;B zBi5)?BEIn|>x68H+E}CKaj;2Qky5vNwRZwHM=tZs02}8Z4D-2nsqHR%>cHhsvPI;_ z)Q&M_=i|t*?3=6=LP}LI)l|p%|bA zyz*$+0TvMV|AJe7M&}s59$^*prnFMrzl(L8FSqK^x%45T{w~DC8Tl!8HWl%}N?$=0 zp_g_XC1~n4G5#I7bQzf4ofV~vFXA9davxRvggulS3BM`l$Z9ELQ>?`II1jTtB~fRY zOS-G8V|y`Jml>Z^uSMV_0l@9As%dcJ_YY2HdDU(1O#6*MSHK;f;pQ#D*2)b+Lr)`{ z(pR&^VJHOLWj{O~uY$4{-d8ivQ7<+zPt)rU-B>GaxM%3OpT3>l`NbQaBZ)jr=J%XL zocq7|`n_$ur2tDemj}hB#iEciBzJZH3@^!6D2|4dk?iseCUvM1gO4L74b=MW<)D?u zYs(;bh=w3SbsOhamENT{8s4b829Aayqy(#L^4C{<2sUcz=r~*{LcUPg$ex#sdJ30% z{{+3)UGBm}0kpYbp0W>b(7j{=-4jB>9Bv>!zljNT`T~w!XbORbblONnSPeHIs#@t` z;x>RIH&k$k29%e#JoC1mWfKpUs|tv{8o|bM8WR0ExRNF9OVYH$t3-hpma$;CHK#fY z=X#NfdTes|_DN*~XEA$MN>%F)tOGF(ECM>{H$23zOz2TX^n@~U7dg^(65hPP3`u_p zi*~rmek2yprX*SsU|yyf1QpN@uZ&t1%@Ily|D~H=@S>@BsW19T9JG;t4l(vbP>ypb z&e;JlggI>KMVyy7WYe83>j-A|kI)u$@x14Ju z#;Rx=w)-Mf)t9(cA)S{?m_s1FJ_FG}6dj(C;pM8nNICr$S8^s8Y$;hMoIedF z`ZFKhC^};Q9hj>eLaAPFH(msvha6sL4SjDu0O60FYuymc-yJ?m20VYdyLZP8eM7T_ zoKm8?e=q`8EK;N^>WJW!;F=G;AO5woutxcw?w*8@zYN9y_Vq&}hks$ebaotjm5!pA6>(ptQ~WCo|CO`s zGDkIv0;RNZHscS;Je1M-mz0@jT)wobD}Jj7D-}}HC08saw_7HfUlTcUFPKT;O0lrG z*joPVPb(m^*xNT(f_>N1ul*8H+@louO-aIExlf$cx!EopBd&rGB#i|h`}aZBauKFw z=^l#A?662228G^GjYWZm2Lmgtem^Z{ldxG#9AWc*$eBu?hzhc}MVvP1+}$f?`|a{( zC*pBOrr*6YnvB*4-VCCZerSq+%Porp`&jschi1Od>MJz6rL_LMQ&bKBW!BH~ON*Z} znnn03;?idyx^P?~CyVZm4Id&hCq{8q?ggERK5VpUcGj?8agPxv+WYuc-a3%tylJQM)%%dU)l7^7aTR4J%X)0C@?u4iL zM|B}`lW!M_R(_pG+&4PovNlQl6H1vq5(f!bdI1pqrcy zW*z3#>+mDY~QkgEU?r~sz0@Snynn~lxxvJ*U^q387IXrfr^V`NdnHpPA5!a@W^QHP1DwuWYM z7ca8O@WMV&L;r0dmisX-@5JN^xX>u1RUGrKVJ)p~zYA;t$Hbu*>z!Q;$jp(IV<>S- zMX!o=bPTm!B_WAXhgpqw+EHXSERR9)WR+!Y1}<>#Dnq}W2A^AG%-*5XfKxF}e<|u> zbOcR%ny9T8iUB_)W&A6|pyRZ>eAv}ZY3c4B*&dZ6i5sk!^x6=Fwm+v162%{(*GbGr)7J&=bioS=UwAa+o@u`6VG7+BFAp_jlP@-M9CMZNt&=--_rTck>g) z+g4Smch%A9Bcd#2#mF(NPBArlO3c5Vb1x$I%^%^OU{Omf{uFm#6L;Q<#ouLQ=;Imc zVUKlv@t|jaUVoIv4Q&Mn5oqGHI~AQGd5MDAoXyRKIwqitnD6Ph6suLs#9%^*mzH4~ z0}mmFJVThE5|dl9^SuXT)ToMqTE-?UCV-vRu zQ|z(qw>o$~#)D?@2QWcxxk5WbSI_%V*_Afy9d6Q)v<|9=vtVBuXM$(&S%uVq2h5M;=Co|HWwg zn?^<-C0wLYAGP(|;rsoDFj><&J?f29*$b?5pe-mbLinDizqIukS8|tc>>eGE>G65B z)eO@oZ;RncGx20|x4YAAxTZxG@$yMrDB5q|=E5?nHWzc-(UW(^YrD(H>45id@M6|* zJo)v}0wU}*%;?Z_C)OL#xs6*)KipP2P=DtcC!|#ojZqXyAV4(B&( zuz0c>w`M;+uFb~JFTAIn?>`j{unZOC79L*j)&Y`jhC}xYQK*HR%jC*mEa0rA&szn8 z>+^3b94_+9OpC6>KN7;acTUGSCZ)e!?szJ1qN0}wo{!jGgARocFg6DDs~?Ji>EFxY z=(v1a8*{po3Z$g}6FW_yURMiCNe^1KnX{!=xR&#eclVotvT1t($So;}3;}f;o;gk6 zf!#Gt3S`{=k?CpQ-v;`>-VTKYk=TYW2PDkF+Uk-d01{K6NZ-qqy>iS}l4f3)bx_l?h zLHFwp&meq-eb2ziUn|Ye(f*hIJHFrQ^rG(72*cLmR;B&!S7dTXSseXvFV+7O^>l~D z0m0y+n!nP+3zI}hIU8-CUEGJ9RIj>UYTwYm0Hppe&g?h+1ANMG$HEGMhr6Y9(+P^!mt!%x>wUW-d1sG=qLO92#HyhJjJgz==*tg+5JkFnXDZ9p-RCc|b!zyCFn6Xl6dNNpt;!MxOqPT%pw7GB zMg`|>^JYkKacQQZg;l7^aq)wNxNuUC1OmJ=X3xiM?o+-p^6X@Q>~r!E>POa@(Aug+PsKGbWytJ;Rt9z0fMVK)lQjrE7o07;`&t=hG^N5tL0|Ng^s0R!GOjyb7cxg|~*g zZ%q6yg31497i#bDddOmCTDAiiT74yZ+Zm$@%()$W+mM_N6M4mRj#|l3;g6Uf=4O%^ z__DYGJ({~+zO*6uT|BjA(Rp(fuOL4r5S2z^HR#+tIf?PUJNxz3?tVKOjZD;Q^x+bV zZ@QSRYkM%cocTazw{2iGr|8GB3^}9Sq0CBy?5esL!{6B_tKFMpg)bahUzzdmohb7U zfZvvL>u&c85%Z|7bc3wy4^+ zZQlw=NOvRM-L1sXARsZMz);fNAPvI+(hW*W3PX2yH`3kGUEg}XZF_$L!-{L2=W*u&N^HUZ1|x z;Y0gQ{w+=QV|FV3!MSLG&l#>3i(reZgw+sF|F``WL`3)U5QmY&FrI|pipl1=QCwkP zSE$K*gsBlr_-Mi+cog0Dsq<&Qh>1}lV=KX~wmN_i&cbp$%kX|PMb7JH%G0`~TrZC4Q14C2-Za#pnXz3$B}Pf%!}s-vcM=;*E@8 z<5}Hp1C@IDm5~oo)P}2nQvEF6Qse3H1&X zTNpeNkwx1RGa~04GVV}|qx?;eiU}WVPq!tG+R0=zb3!|lfO`_L)IjLJRi*kiG7s04 zkJ^dAePD_$Ka%~18V~v7Aeve1?CdIDQr9^A8`*<_`5rO;9w9nbkq?Hp<8b;b8+j1%mGor>Rg%Mp1Silt6Zfv$-~0h$jdXq zWWO%~m00RL&+4kZ{yVC3_31>Uf_Juk`wZzNAX@)Zv4gb3CWvzoGp8+w#5p#}-x&91 zY1-*-w&4ahZxAewXxvzRhF~~Pcx7U8#PY4-FuITe+~@vSc-D688{p@#utLhnAXuf3 zrwy#;n1Tp=ua=iAlDV@+Lo1y;3Aqo?@q5idYgE4R%=gQlgys$`+RiNpIObfo-`+Z{ zN$di5?Qhe(Uo19%>+)25H;!g8fK{ohYtO_jvCTn0P8KLqOZ#hdE(@KJCUY7(z86UH zYP*pjUb}?QE&2RnhoHHRmchXx&0NgqA#rw=pBuFLe5|?pye>}Z_rm(+%okv4tnVZg z$uLgl7_PyUw${Ydxcre!4ttNRzB47~ilwMF9D&jcH|zZ`E6)~znMsSsDP`1sP}^y7 zdOVi@2_6b9kS~yCv|3sM^{`a}#gf>UGc2&NVRh=LkgxA-7lAHi(>&T|lOoXM7Lio;77c;A)s5BFy7 zOa|HSH-gLW4oe+UeZN-eI=;U6S-^$;mM9VZrx%LE&4mn1&B4yDzEWT@RPV_2zk=Tqb3X zl$g-THnjZd*t|LxV#?+jY!L2*dQ4%p6c+B-v z>|n}La4k}83Q3$oRY&_vP5<^VQM%&G;Y}^|@X4?D$(4(r&}ZC|n7+~H1^?uW>8Lmg zeWVa~(@I!G{He}hBCb*$6X_@v_TQ(n)NVfYSpswL1Qvqf+VEa3q_)5<-$vi`j86qY zei|}GcV*FvyObY`@AWBd$5YUxjGEJVk;tc?tLDx+{v3+Fj3qF5Vz0D@75^rVXhusR zc?UAL9`EEzx!R>o;bvE%+$hH_$6MSAvH6mMz!Q z{iJr6e9LC_){APH79J+XTce`Vx@J;7F%4bT(B{ppt9kAj&1wjQc4-JHq0@S*T>(A) z&qG@TER&xKhy7aCmXC5z%l5DGzITxh!pz=qgf#2oLFk ztI=g{lSeuw@rjz{urQ8J()=I{m5SC-(j==2A3SE^7v&BL5=!L)Q@3^2?JQ33`2v*D zq1b>Y%{h-pnHuX)HUbJiKKwckoUb%?@$wq;Y}QM76<}=A6C3?#E{{NtJ@s>Q2=ov}N3_w!hH6v{tr^FB!jz z_@@Iv3{;1fOX5sb>UWs@8BWiK1#~4@ISI|MWfAv!n{3~k#LH<-N-^&qU$-uuHSgfI zQ_u55q`54YYCRrSmx{SctD~^~)0!{CNWUm$0Mw1C@1q&t{MD;7h$@`0`l zL1)2gk(IJoHLCY*9>gEaQWaH99GjJ?%px^}m%?Uk$u>Dq;N{btEbb@?*nv`Xx0v~@ z6FX4t-u9Wd_`8jow&mOC0d)6}ot9h{XFhs8IN-}S^`IGijQB6(lx8~vB z4N*~7>^_#cqw5q2Y+xT2{ z>-IhfeYmatLc@H~J>2n@$;J57+XWppB+_fSwXWCd!`o)*Pfkcd@kw3yjPhp`Hg4&p zP5D1lnA8ghaHLH}Qa*?UIuTbj8mOx4t>h(BgQ~&+oty{BkS<{qY{frThm`7FB5&Da z+`&!y;Uw*D+Skuo__<%NX#JKHEqs1Neuoq0@n74ksV4$yNA)kf6-I0F+q_Vd<1|hd zi_o)f2ZvMQ;Jwv*zlur+B-|Y~^}!lCIvJ~dpz8RuI2m2_LN2vG=!>~8;Va2FXu{Ag3x9Q}tUv-?(@!v#QNwsKkt z8M37r8p-{XIzr%9KFl>-;8+*J*Txk7-K2uq^*GQ61N;S(j}>ogCZai1g1z zvkIQwl39%@Ip{)c@1N=v-(y=pB*t$AUg^{1Pa_jOOwrsV%Y47=U~jL{1d(!Om0g;> zvQx64$kQ1~eqUHfjl2C1^_@<{b%izZP+7;*v$6Lp6|k@Ta)Eq$NFfmYtvo44`X&RA zS8t?=fd>8#d_sGny*YF zqSvYp4gKQw_~Ex!TJ4A>{oTj4S(&upL3u6a^g^|S@31{iqv}TQ7)sE~)#I9F^U}qO z&#CkIzJ#VeTvwZ|1h~*pE1OP#R|l06aW=NLZQOvqiZ(xIkGgjcnxe9NKCQ=vBg5>* zr^hAt0Qq|Xiy{s5^z|O=?rG7cx+Mr@Or)?z($kIXXUuBu^ z7W`JQ0mTXlV?_3j@7SPo@51o6pGQ4m+J#oyr?hic8`i8UT8Tn-#D9~IQgoQa)BsK9 z$!<)g--*rBCQ*)yo14-a5)5xiBQ>an?C)3CYWxz;F8gh`^WaU9#@_;19J@l^Prf1I zGQ2lQH03Fn2m02GBrP4P+m|?cnIaWQvbuy?UBxUI(*rZ}PltkS&}ql!#oQWtkhCPs zwodZSpFGT!6*GyDg!qu&bMoq|6NIH`2Cwwf26C3uksbs*sCENEW;8PXmO91 zX_9gwk4>m+xapbz#ET=#8BT=!83su!?rzO-9Q#2ce4J4;#a4Z&loM=0Y%W73{qyA8 zQ1#a~-SrDtU4jBoJ_JHUaeL^}oT~XUChw_D%QmnBe6fF0Tu_Yt%Yv`iTW5gKe&>Js z@pgb}Eu8kMM~`q8rfh?P#}a|rMbcZw=IQtXt8gcPWB@U-tbN|7>pNGXpsB|-$?WfP1Grr(3 zkM0+&-sKvB>XN1Z#<7tN?+K0@^JoDlB8nrZ@Yf>DEF**^SdxY#;^ASB?QHd<=gEoo z9~>g)(R+JlGQdVj66nXmJGcf;Pm2P9@P87)pu5;t-W2TsoGl(6R#t!#{9bVq6G8j? zyU*GLD-()HhLI~ha-lpi8O<2u*{vUjd9;fxw`DtpJpa}eWO8zKcT}uSxlvr(M{7VW z>KQ#$8=AM|m!P+w8;^-mDr*<$(ha)-0)TLTwWAf4I;jG>S;uyme4qc?4|Cz+wBtIR zB39d(WusP$`bAT|%<^RXGlEt@q zd_z9|7YS+rEJ@;5IhpGC`2JGhb19kcCT6VS-4$ncJ47JE>3##r`1L`sA>fqq@kCV$ z6mcw||1wMU^yYcS#owuKr#rk%uIj(G+f^SaHt%a_?>*8O#Y`KTB|Y}~A32-!FzJTj zjkmGC^OAqU0JK1lVA@ii-mFM)3@&1Bt-@rnbK18lBO@h{qY>nSCJokI%lQaqVl~N8 zli*?^`ITbcxlgYLA8=9D0)p8g0!eS3{;N^n7Adl$&+|!VxG-Rusj%PIywzq{8X6tN z02YPsW2;lE#3FN7DUlzXI=-P|c3RCf^P3CPYU(YcDLQ2v{#h*>gwezxWQ=@urJIHh zNBIDd>khV$nRi2EvAm|BV~j_TeZ zowhoSdcL9Nm=2G`X4pibR<@$?O2Yju^#L#fpy4xcu9Wd8A4n0c|5&Jp@yO8R#ftg0 zZSA@%U9Y2;^YG|w)@;rmk^P&~PvrlzgyRO<-~k@@cY|t!lm@0jYHt-sfvLLad@^yI zSoqY%B0PoftnmH<28(lC$d^#v8m`qDKAqN0qnUr@ewO5Qy_>AYS`?qXj7 zw~#9_<7a3wE%kXtIX5iN;DbPd>YPu&!~iM{A@%Iwf{uIVhg>OUZGuJ@nbX(+io6Ew z&$!-nO>vwequo$N#0!bVzh%cAdHuq{blLO^)9dtZ!(dc<4YZx@V|4%gEGcIUnO!&y z(!k(29i7t8+YnS(a%4~EI{`2C06cTk#oF3+Ni5-O?GCBtEGupR4}0y$srX1tjF)An zye&c?z8ZVygx^z>V4b7ftn58r@Fta^3WGK8Ae_+7Wv*HDZd(%-d61`UisvmRWg-J^ z?B*ETFqirrq1iFh5X=M!#}+osp<1$aFI26`r8il$ufYvC3O=UM=x`bj7wn+ahQ9R>1dC_#NjAhYQU|F&eQeTP+?)m%nl(EU=!#5La+avMP1d?gKs!E%ZZy>EP zaE5sE3T8oQHxH}x;d8dH1S1S@YeFNL-cXUI_Ai(52ywGE8q{Fs_3~aL-EiBdR}J0l ztNLi8nB>N#&itKqPsO}V%WY;>nZ^!F>Xg`S|L4%)S{0BQ^BlJ-bGb4{P1EXN1Rv*T zbm58oXu^LBFY>lMVjjrGzfh0D<9h~@XlEia8;2uL1!2zX6*jD0Wqr5 zD{p9M_(|f^SGT41dglYMltV@!5C$`H88#lA*g!Vc@`r_B}Lz!uC zpz2e>=+(&f>FL&_gUX*$#l|Hb$!B^@!9OfX31}SJZ#ky<&KHZ?KZXwkKi&#^z4~QN zF5A_anh}Gt#k{&6Zo;ZqydFDgp;5dyl}6`R|B$Hsu5gz8Mt63Q9NMl^CGRhDe&xEN zU&Ie=)D~NOrEAl?SIE86uxP0zB%qa^FUqQQU7H$w&qS}9{p%=JHfZj_N>=#Grrpw} zrgFhu4$yCgDtCQFvzdr+)}rtA1(IY$6Uf0`xFov_DQ`1W#G_)<{;>10aaTPmKH88)(3|kDBN6Y#RbIm+Vj!sEgY`= zxO$VDFrmkbDb5nlM@Qalr15rBDB>rJN6d2#;~lCw#v~T;&k^Su=#`;#M&D{5(_vFy z4yfe*xL7JhL07R?rWhviJSI?pj5!^`n|l_k@cY!jAD>;XbU#e{A0lv@XGYwOq|zEz zkMO3q<(=pcwR~X3WOH8}6SXVm3D0@wY{@j7S-<9gx$xc1O`3|{uG~6(YkPuNZu+@81@&gVleSr@{VChi2~OYI}@rph?fGHW=6@0I}IyJhxWM^tWEWoI=Y!S;9#G zhL$?(?xkW#X!plyEOct;`*mutj>c&nI?zrPYpgOZQ#JdUhV}tf5_7xoBi_EBnwDN>r0Zz% zo|;W|o2PCk^Ej$9=_Vf?q{G8ABHr^w1s6 zb>%;5)2K{$a;G`$!nh0_K`XrbZFo+VE}`$ymT~UT`(1cEkTeDAe(mEEe2HV93Fv2A zw%uKZ#{*tmEEbh7B5HpbIe6XNJOhI<~AuCnwoIyrKK=z>?ZqigL;r2tUrvi zR#%%E*ZaOa2)Bk;JO5-`WZScEx70tiPLH|w9Wxb3z$C#@cK7S1##=QH8zD?ob%9$C zz;<4`mD1L?V}>7zh-vCQ=KmOJj-nA>3Il1~AEP=?C#O#$vJzX(0XMV^1e0|iro*^m zeiDo|)P&Q6-SPvzsDG}**>DcOdLF3YpzBP69ZJE9_tPRmW=1J-i!leysO2YO=rRk2 zm6>Ncao!$`M=zj*IKS}eY}25W10@RL!bo7sQNprttoI}|IVal0bvE7pz};>D`GQ3i zl`9_i0;^h3J}Xdx@3_Oa?Da2qcTjJs#Bxi}fcemY;@{-?dK&%kTj?$&+qC zr1u+s*XsD?6AFR`l+XIi7{6H20EI=d0UF`>$hkOxiBpP-T>4fs;y1Td6_}&Jkl=hv z9z7Q$-IBi9$yDl!o`aRx_a~R$oZd@E#Or3`gd$aF1&7PWd^@r}r=Lt{B~ql>m(#rW zW4@!NRUecdPf9Z324jo$#@K|RGzYqgNLIrW9yNab`?NdCPs@y#Bmi`!F5?SIbia$a zVzMrNKj^K@A3&asPoIV@*?Jq4F-D;%i-M>3X(Qk2Ecn0Srn-JY4d2sSpR@tJ(HS*} z0MB}rHj1qYF}>NZbQ2X&vOYkpHW!v|jtBJF87oF;g5{C^5J17mdMWj%bx0E;oIu5t zwf`9t!%9BaLGp$PX}Cb<2wEqtofOq8^-%*gSlnIwU8jSM<)AZ89=H^hcCIFJ2cbcw;PLIFtGyEK4s_E>En(zc5<`|$IxM08 zTffj%OOyAfD?CNnvfAW9tg_wrzy?Q)cCNPjO#%^Sxh1e~6gZ-gr4D*)@jsnW`mVf|NMB~&(imxH0V1_iPl8GmZ3VCt35ylmBCC!<6KSQuE zvXPO#mm^v9aU*l1yYiXAt=^>G7_L_yF*)r{ahaPxz?<&f-~K#I1=kz%y6Q6{)EfNO zwhmXznXo6@g$Dr|(z67r*O2yy()P`)%9iduwVYg7K_O_p#Sp{FwlR+ zvrVQ-TDMz*8oT5BM2;?}FffKAC>NAe5ZTviJ9`$&uoU3SGNjFfbNep|$k1hWFbR`O z%M*E_j|>HcJ4i5$BZgG*H_M0*AEc{-Agx8KvvT7$+&Ovt%E6K`IPfxgO@#ZHESLS% z_y-0QbyEbQs8EA2iE8k?^6^2pqwg-z7l!A`$d3BAQ`d(j_!N~9@-}@!!aRZ_mNk%g41H3!h+jq`4%B zJ;T75y1^TocT@dw6?}}*U)O zjiH~l_&3z|O9cyTGRtJaWn|JnHrY44i~fW6YP|U1&v&&Qq$UZIlH};)TbAPeB}P@` z>5m%P(8|%6&OgHVbhoP*NQLahP}b6IIIm8>RKkxI3Y;XtoXo=$w~=kBz(ZCbBl-t% zFr#1$vy6!*-N&dZOq;h$-chVd>1}34N%-cSC!;nb*Xiixd`qMMJi}z@^Deo2(bT48 zELP&cI1zl2D3-A9ZwHCbLXiz32LJ{Spxn{mO?F3Fa)$Q)BTtJ@`o8VW8fKr*q*SfU z;Dsz@28$cDkmdyiYWGH{c(dB@O?&=f9}?ZKX>jbK>y^`=U%n4~v@Gfw)Jzt(TUozQ z*7ij#H0p^0UdWCbD8zj5+^$#+zDhwdRn-(3NhgoX^y$k-T|RSWm6Hw0yaOlh{{9Z& zTXpG~gSrX1YTZ0}$C-Iyecw8r)Q-MH;GLSqu~W6MKF3)b(F!z@2FUD6N?7Gqvnd_1 zl*Z)EONV~gA080GO!VS-a!A1|$dc1|B0MlQ;KYnl!XJ>C z>$Lc~^~MHVN&D|?zFE6FlWuz~lBBD2es?a8#)%p6Wxc{l~3pZy)z3bM;2;@DPJ}$3JI8)>s=>iB#0C8vD zq=4BKGp{IAD}rhB!{YDwkeIGWoiQAZ6cXGx0i~{-*mFw|8TWKn8}{{PZpRUF5plpLd|~l~H!?0}fMf20CRqcsXN5g^_0aW9re8 zD7CZopa+%&lx9KbuXp&N$Ugxa|0@Uok8wJ_7nf=S6nuu^!#q&ucX}_vYO31GTM^K6 zrIih$I=;~F@!OY5lWhH2l^Y#RuTs$*9|;T4yB8Q8r%a$o(n1saQ?b=(2_$09sAMN0 zm6SopRnZoipdc)ODI3KYhu=UwsyP4N6?lPoXEwBgUH*-w4WR0o28COH$46qF5yde9 zqi-!R4%3WS(3_+ahec=y`Npii=Q1be0^vM#@I@;1;}Q2~Q#0M$#!GU_{27|K#WNSq zE7`Rb@DTI5F$ntJ7r0~Exh3bIQBTpy8a7kT+SAIT!cH8l1ie5=*6$lkcfyZpqLRD! zn-D5@9K*#8WP-=E5wO4IR^;7Anv4pfVYPmYDXc`b9ukV7og=Q6nK>#9^qXEc`&yT( z^kz?vZwhs(i(+1#o3bm1VMvPOWaS|&Y8o%Iir9S6EjjbO=9EuFmx0w-Aj?5}dQK zM*<<&z=1=QKjYSONl8OPi@ZA{&_w4!N9Z<^U{jxz67*!C`mIk=G;cU;nyk5-ri_sZ z!+WeVYcoIr)jBNN{bWv{tD^@Jxs_m?(KQajd+C4+4O8B z_$myoBPNO{I^}=#IFj2=xfQux{S*(Uj13B_-!bxT^8L}?`Vs^Ego#{0&#X)a)9NZ4 z)&{veM3Y3~;G{e=h4(t`)I+?+y!7r9VHto4J zAbjmH;PprQ0{}6qt4B;wFV|LhW)uETF*NaDG!Bh{=*eUpO9IwErr(=-(MEB{4Sut; ziCZ7u$4K8=7shqvD$QD=Zx%~?XhJ$6@p(IDv8?Mc?%6+z8+tjN^i!@mrm&(B2)3{k z=jYxWdyu&|Q-n|o%>NIfB&O;t6%QPbP_{zQXu2-)7V1i>dsvhNlxu?bu20zez^Y@~ ziEt7Xoy-1!E98-6UjIvv7s}UzfD5XN*q5bOR7n*pqW!;wrTEejiC|U1d$Zf3S_Y=* z7?#c|bj9~21dxl3)^(LF6X#!8zX)jJ@kIYd)V`zI>A0Du%R6NY-fnT4Gp)TF_e)nr zu>#@IDzD<@;!;~kYTzUFK{Glbm?rLlEsjuFLS>$YE`H5PG{(#uZ)+aYC)F~6U?cW|AiKz-LqipbUac@`+w{cU#u2 z)!|!H8*%{<&D!F*D3fBYT7!TGeVw{|-DqfW7&kEz8Sk>2Gsq4;`wWVBq#+a>cnix% zLxswVq2vUu$Hy*mX`;|&=Q@`Ao6091EY8#OthFcpmpPzL@N`uqxpQ-^_q5&#UtA8< zf~0k`bgx`vTz>02N~vt{aYN{Iadwsx&d5_4W6beYZLJ(EV{qZ2_k3LO@H}e0-7o5} z%n>*7^Hb8SuUYA+AZu8yd3w4mDyyfs{HB^j1pI(jJwXfujGg?)cC+`#DJiAR%7TRlljdC%tjQ{e)Z{Cz-~NB zrxKi9Aq2$Qk8KAhW{w3sikT+E=Y;#zxjMs5;RC!MZ{h`10%{0<8EVe|UdSlU$iA-I zogHPDd|e#(a=MPMq5=XBeWq1EZOA%nVgS)r%*jd^53AQ@r!)`1txIn^nxgz-%D6*9 zhyt5}TC^9Hu~fZb?w*O>Fa8r=ix)Q;D~FRFfrv3Dgpxlt%%zGTO%rmB>TjY+ZCiWH zUsPeSfbrB<={vCYbZu06$JUNGPZ6B+7@kCmXU~D*txWcsw>t>NViz{PmT(WZntBT&3+OVK~MmyrE zs64eIbNcng3zVjhg6CIV9*Vsv$nPgP01=>(*p8PfF5gx-KGG}H0PFf7xRE#K~dvOZCNX3a*=&>L{{N& z3S2gw+Y0V7(HhApEe+nI7VUf6+xX=eODowWY|Pa`)>n|RPj98&4EyhU#anJ$np*pW z!iV37VV@7cfewd_s@k}2R@RUR&p?wqv3Q@5M8E~&9y*Yb1ma2Qe4aOt>0P_Z-90TM z3E#zva>VL0Fq-Rr6|>mdSB1xw!!af4D;n!$XqrVA)i`u6A#psB4HnGHK{|r-&R)db zZPs3Xe&N!=)!X2~?eLI7vOhz(S)IflU-;+UFhC*?!T*`GueqFVN>G0nh`|mOn~kQG z<(IaJk}`c4RSh9U7Ne9LN@>v@8Mw?eK~bj0PAvQvp7;3^Nq->Ij@%+@>-j!+?3(vL zZ!4bvQy!HgPi2FUAr}U}L1uN7e*f*0JtSZB{taIKkjoejzFg*3 zD#w8R{$$9Em(V`}vfWEB?+v+!!e4Ak7NPj0ev&^@NJ?iBo}waGu@b`#iT{Tr*+vGY zb3ju5*`0ARCQsM+iHVx~(zmZWoal=C;_wFZ2ww$m32&uUp7PrB8uT|FzMCUjwCIin=;-VfNZEL~GE&-T)3IuJeX7z)33 zBK_Q?Jz`e-$Tlhz^*9~mPk=6kpfxANXs7jRl!1VoY0%e*ef{XPecZp<0^VkpOhCM) zJIWGfLNhL73&5gAy_>tS;x2bGPux`it*+L8HnP7@=s`1$u=P;Af*?y_O@r0;{)d}) zXvVGGW-qcgKe6?CNrSaMc%~DF*ms6oXHYyhy_%_Y;cz zFQ!6iv$(Bm@q?fIrJ%glDJN-3Jdr}mPndfPzqlym(vllT21Ie_3@6lr^D8Kt#NKi% zn{FvL7}4~6F&HwZATdj)WD1_5vCk|-rHJdJE`NA?F)#gNmv*?P$X7$C8e-?#NRLh% z-cwUd(;4M&l?p+(t5x`nH+dPGg;?$SsrW090^K$>A;WC^3m2BY+Mb(?7N_z(d$Tke zQ(8LDRQ?+Zz4)k^5x*cjymJ(>(V)Q}tXLMwNsf#xp5z?E>{*i#(#(t`L1I3jL7H8q z$`r1cC-qgB)oZI$SbELGHYPT{Paq=+fDg3XUbPmjoH84L=2g(m5VX}BNLq7*471{n zVDlcL_vC>z9(N}B7zlQ7Ip*Llia@K*Tedx<%iOQpT0yM0UFB5LkUE1u4x)2M>_COQ zWQe=3fUm=GMk`{Sulq_I_YJ%0*HVm6KhG67X-y~Y4M5j!OFW^{KjKX?-+C-zyhK`R zgSATu{MM+7rlfNTEx=)LVXunCvfFK05TIn^s>b@wB)8QH@!&#J72ze(?*9Q=!y5(z zmPyhbuk@>2bUQ{Lhdgk(wyR;d2FOS#3v|g~wqF#22}|@+sHZ?Nnuwlj!k=YSylkV| zf259XWgDJF1l+mW-~?1Au%CzF08{(x|6HloD%U zEJZrHX6LNTPS{DtTJxhyu(Zuc9?zDa7%;8c{Pz#&yEQC1r0v8cO~O94Y!RirPp>Fk zMF$SfQ0Kn3TZ2|l&@P{yVD3e{p~j~^;>bR(dxgZ9RlGt4u}Kjg9`2i|dy*9O#-MK| z!dV3PsJc=gzwF9gmwd_BM87JJFxVX?F^}V}!KnA}Xt~_SFaWPRI3RWYrtQHg7vs=G zH~V>VlbLCB(Wj5q*o=3+`MDkf?z3gM;w_+=E&EC?qAbv_7Js3W~TDhKE=kzHlL~Lqf`wU)Qxf-_h{9d0SLylg0PF_x3t;6Y=*o5Wv~6JS(5 z5mcQ2hUnHT^PG@(iGp>gYvGTZ7F+cIMjP`RCiHH3RgLY4vAX>WtDAf3MY;7Iu zb>HVHgX*b~3+n>FFKiOkba$-3(d;;h*;A{~9qVY;*px~LRqv9NpUh%TV~JQ3D{Q4v z)W&<$XcfCzT65}lP=?$2%QSteM1h3lnc=z1B-C*Nqql?mVzK{6(`#_O_#z%0JuGm) zv!A<>4|~}3VG;4XE_MZFPGg6_oLXw+dp`t8l{sBiY*}44kx=;%A5o38ABO^gMJQ9< z^i33H7o9Bv-=|1jk9m(`E)(2oX>M*znu^QcAJkc@b;s@x#{H%EOJ&~Jf6aW$ts0r1 zqK+S*K^ZJ$g#UKWsgc0;;zK%l5{=Ck9n`fTgyKh%aGJJI9;&ojvP{T3+4=Vg9mLY$ zWLpoPic|ZzkYVM`^k_43+Dk9lw4MKK>jHNcp|@=>)H&ils%wM!>a4@I8!MDr7ij^b&+OvV}4z_&EXiM$yO`gZ>!Tkj6Z_;c1nu z{P{*qHJkNP_K5uX=VYWYU1zhjCW_&2y+RRnJHtU%8Nu{uGpipau(3C$I=y#cu%^W1 zV$i(_yB%x(2Xpchy|YSL^>y1Z3wZYkFv9(MSd{mltPDD8j|oqS#xGa8VHX@0;_kz% zkP!ka*2kuiNG^^_#V~BTUU@=M2uG0(*(TkWUqCUP0?Du0aI|*^frCnNvw7{67kFV` zRCm!Y^auTDGb+F)F3QYV*#lIq8;7%dPg9%$ z(SGoq6#sjhYQ}(bz#w|}5N^C<)BdEAEg3L&xi>zTWmdnWj!#0Aay!VQ&N27=QB?K# z)SgSU-=coQ=k);#JhJx`efmVmc)Kgs+E_S%zQm+unvwgE=_16QOq2AbEJQxrT$wq$ z+WrQcKWd1}MfkE8x~~63Eb}pblOx=O=11zVTd-5QKRFXi)rR4+sPtB&kK1Tjy28x< zH9vUwYz#LG#Ya0zII1^jzP_??X%*<53JZA5G*h&ZY4-Es@+zU2R;G?B_D#C@)GG{` z2}9TqQz;~J#=V{&YRRFW;s%dXpYh8+r{~ihHC4dVyyw|Ej-5Wb>sEBSOj zu5Kom#!m9|9W(nk-dGpcb*4e)05upQQxKcB*?kk^LAktD|GH~zsZMZg-}83vn%S2L zFr}kUKg!>W{!7~k-He0UTHQ$5X1N^W({82T zdjj#LmGtRpP1{}1hePOf+wNAZc#z=M7xV>t&N* zc!y-k9@m5nO--Y&U!I1FF0_`Ku4!xI?6e;zI;fc5goUN#+n74GB>^|iSWMa>%BB|R z*l_@)qlflg8ox?)T8^Nj^x*w_^&d(~w5h!=7dGDV`YLcv|at;j<9T`|?fOyf-=q9qUb zy!rzwH**;Q_5FI0|Bp)%zX0kG$O#>4DH4<0ItLKE*B(2M7@f5s$?zM66Y1Ex^GiMt za$5bRwBarJ#*u3CmSre$@9N3`Eg9m$R-IWgFrnyqFFhZnKg`1XQY0bHh$n)CJ?o}o z2)L~bxKwJD?Q)Cv%4;F+eG4ATZe1fl_<`ALz5q;tbR4XB0L4>jO$ZxAUiH3I$u1dq ze!NX9=-L9>53|>#d3=_PMf(sWe7=8l=?n$uMx;Nw$Hjjb_N&)Wdu0PrG49tF!L^rg zP^1uKUq4b;`J2*j)%Q3r%6O_|eIazmKuutv6k0(ARFkd@$6Kd0NiZ;5k1hMNQ%i_! zfF}P&W-m!_-NXK1VsK-(9;(7QclFYHO!cBF4Z1=$hxdIz-qUPtlHcc{!i?10fTP`Z z4bAfLVuQXjc3V~z9Z#DX7G%+Gro9V1Mka5wd~ry3wLWE&0P0%L$1D%)$2jAsO;q61 zCgB!fkQbJNM_4bG&o_{%xLDre=<2e&(7YgJtR4B z>z5Cd202}zn`~aKidW}CpxLAL!<-V&A-Mydck9$edwXKOTiiO8_IJmFN;QL_^Wut4 zv6E>0kp*2H0DuKC^g-T)$HGh1oVS_}_xRBWs6y~$u>U!5$(H)b^qvOlL@FdIyaQ>> zcMS6>VvTGvtn3}vtIy2N{A0lGIEGf*5hV!M8|frb9aCeD3c{v|>Ls@%2?7@s1c zrpXu|jiz(?1?FK)%SUkObEI+tmx*Y4Q?HN`IElD?ze#)HG7{{Nh2l`XtQbo5!9|0> zhx5fJ&s9Ud8<=^3wz`>CDxo#ZeI61S3Fd@07?-m2u3QLz!H3>z;7G@67H92J;W2sY zW1jxm()p|Bj}|FGjM%aN_hfFN#&C_%HqsLv==@aS7ON>Q(ub$FU4D%`v zPtK^i)nEV3q8$G&%kk`ZB4JC;P0dJYe89G7@7{mg1iY88O&yU`x0L=ThEmeO$W12M4<8 z<$kJ7awOv9Ym@%Mr0%&AZvTA7c|^{U@cfUsUU7NRG^J=I_vn&duv+DWy~A08`O3=TA@VHft5f`#S|)MedeU|qmG1Q_ zV`%{jZ@-h+6sdHC^O!et4L%oVscRuiZcdCmq?Ere!o^CUGL?t~+xl;E+X+*(7(b!n zlz_+eB(=sof8OoYRu88{KwrhbMf=+ki}%17BbK|#ggosb8$O-XQm-u)mpL7xKx3_N zR!HMvot}H{WJ-+e{zxGLDybF$soWZlJ9D7l52}?Vvu3&g{nC(Xw%>|4U&$;<03QOhJ*cqJJY*6uERzw`5npbW-9xD^cF6x@MidM{MSNK32<;tf*DZeqy+0 zw3cbsa(a3z7PCOAZgCs4vLS@?fNwSG+}ih4lq2z4HjL=)wAZ{HoAj9^V)XnBh zLs5#hPw~5=waQYBZaJ89&s9aXaV;uGVBB7fOHjf4m!}GUmV)vbMgrJu8dhTKXjFn@ zojmwWiR6i{6$O^Ne_3sV-u+!;!XwKup*HvQe_bu$Wc{M=dn>xO;kckAj}l7uju4KN zF@5biL~=h?-`>r*_VA;yqQT>ogE5v84t8L&P|6m6{a!Sl?d;_CW@{jPJm+$I(Pg)k zpUBd|x;dLo$$BZQ+h46#^bff5?)X+>YoqZ*;eYT_h>6) zEKua;LK9$Q)W!Q1ZSs8grYiDoE9VIv&r+8HHA76HO7T!))hno-+HCM%Cl(izbqdC& z5>ab@g}@oNA5mIoN2O zz~IFFxB@H03DTAdPgTI97D%Rxq))WM=(CFHr-+O$?9MG1a1s7|!)~}1LG@Ay4kV5b zs|Z~moDLCXBuflR0HB9rIhb#gflS)=)t9MV`R587(#-)L*G+q)95yh=+;N>KW;3nd zJPxyb*)Io0WnxcPkM8hs%CCKaf|dUL2ZQk!4Mj&RZMUs!TRX^VUe|{%ZBI|oHc@Qr z#XabwVTWj+t}nKU0K=3DL+pI01dAyzy@N0aL_Syc4@qv@=JqI}=)|3(_6 zyAc)^WRdQcZfO?j?(US3u3b`CK)OL%TDn_Ax&@@W;rD!gGv68hWSH4y_j>O8T<5$F zM2df^aU6StnAdfdy!TgnPMi;6fx$}qUTUU;X^(j`;iSR+$*XhD-zJsYu?;gb*W}2x z>e3@g{Uk@oKSDU(pq!A&sgd-929`skK!2Fhle>LC$~t&X%<`})N*awxxZ00WKFPyK zsYc-VG64SS?RNu+fR3Cp0kF+@zzMquIBR2vR;fi*E)zI^2+qt>Z?7b5fPI`77*Sa! z6V|48t`l0bQJv*!+mVnSFiZXBnO^@Y32j0^)cn^T_~M(g2k8ZQo^uHPyl~Gi36sse zNo%F1rK3X4v?o9QH`^D29h5AiIHLQ;k)}yfd@(y_s)a-)S=hczzF!tZNY%A17@Y|R zc|2vvc3KMJ;SSQLDB|CZs-X~)K6U!!FGlZ4Jq-!v%oNP21k>bV=*>Be<$pAt>_>)x z#>o){2mV(5aea%QuAC6^Z11C!S(MZZ8p+;~+A69Owfp+ZLWiqGRS4k%RvGQoSe(0z zu044oGoEZv67#Aery|!75-!sfzCz!GJGtP~BU)C*q)E^%YY^*1&Wu&O@SOlb!7w~(9Ss;a3zzo4wG}Lg*Iv4B^s43`A9sTX z=5~nnZ5NxeoF30VORz32IPZ=ny_A|X<6}^dS(#%bO(%_u6fKDrWQvwoRnv3gBT`VLlH0oq-CH2cfuyzH zubkX&HXDDWNfZgV{R{{}FZZOuJ$VkpGeqVnCf|tZr7)67W=3M!X55q}H_6y?J~V_h zIm^6z6~}*B;p!)-vZX*dtRl@h(~SKihbLx;=|43Ko&xXnuz)k-aP`r*tjr_D1;=P! zgUDhiF_02x{rje!?`zy|5_rZl*!~hkiO@_hF2}I9dp8@SI6_p`E{>lVZS_wd!$=RC zK1oCwxLQPS$v@NB!uw28FO9B-3i})BGo#sDi3sJUiTJ)Y6s~f!1IHp_T-s&p7Cjfg zR#UMom?e4EI9e4^q&bTTPL`YBE{zmBNRqOj`OU!<90Xe*8+IG^YsqIxY!CLA)TRE| zxsi;Udp?Y=b{g2**6h5un5icA95rVr=^}bTzcCzZ9q@RLdUH(F2iy7gPw_Xcrim>1 zm&P7Uu!J4&&N0H;o1{G;AbokHs^%u7JMmX?D7TWui3rLm*56TL@!PO9>+7mS-{*C) zNm_BUT7#s(b4MNZftS0aD0P6RDKa4?>pjn73OV| zm9HF*dk(KY@VYl5OR$ugYk;$2GT6eWz1YIse;r*C3~7!O=X;9g2J904y+GAnVpaWZ zpC{lY+70}D#^D;`#Xq+3b{GuJSUTb(*i;rBsUS@KXzc0(#y1DxpNVrZ5WYU0je8RA z=`k{7<&J}D=bfKz`cvAxZAWR{S8?XwAgr|w{Ve)r``H{**qbK01Dl+`stPEVQy`?9 zd;3-lc~k1j5jrgQMktz6^XjSS(5f9lMah+4xBFjgok0@G@`I{mMpbVD=T#c{$W2LQ zLgM=dKU1jB8c!%O$bFI`0y}trP#UX$gQ^vYWtl>DS)A@ez!-WRU*$tli89!{#1>ip zb~3i?Xm-<(ebzo)e!-J1a!Z|wlMl`WClzsCY4Qj&*E;v-d|9u@4HkJL%3$=3RrATA z#enltG(BB+^GK$g%unbHXJXn5dtl&FGtyuxmjMOW=UfZkS)lXFu~*>V(q<4;+XpP- zbGL3*-kO#hiFxeO(J}A`g;ItJ*T2Ox9xGnpOV~-RxrCayw3AznuH~?R<$qpnY`$rx z4r5)9>A}j-v_dFnKa|LkRaDGz{U~d`J?MfsvNz=1XZxs)`}r#O3D6GjjK42Y57i;+ zfbJ`A&;T6F(s|%}agPma3^?tjg{w&x0lz!3mR-BzB&Z|zR+SNd?mEWXIGE9#M1mLl z`upy`!#H;Fmr(ZL2h>U9_VtMlVF-=rM&k3Hn$OK~Xulf^5*;bZ^5z%fZ}>J5IZ>uo z6xO)C65^M8e>OwGY8s*Gu=;pQ|%~krlhIs zv&-_Ad#2q4;Uug*>*DI!zi=nGyZgUkK~H3;O;|joYB;Z@&8Qt;970F*F8*sn%f@w+ z79X}(9fo5K?%~Z$8BRB$TKT8Y!M2bgyG89moe^heal$_ zX4Q#JnG}1~&vU%M)&5N8?%2TPI*d4#P&%{^;5vI@2iXD@OW9RhUD0Z?@k|2EJX#<)#rSvf%K2w%F&vS;u;IYLDK7ikxU%v%FrQd)vHzaR{ui zq@u3S9%NnsF20Le)-RBEs#A=9PYTw~_szs>%}id1E5W5r8mN0m9ubn~tNGY8;605xD}l`1NK?Ngzjg_~o@* z-gJYZoVG5J@5JzMgejRo3h~3ae5N%$CEPh&%ZyiGR}Z2~W)2_%wn`4;veu;|>pm<+ zIgxFD-bA28YW-IP;DAh95QH+ae~uNTbFA>F4z4m?FEve#?T8=DRR}QObTh}#O{tpS z?F{Qn5E=c)zO`3863@tLRf<0&(uJ*J0hK*n`=%WG;T?ARE~&J>sT`8Q5OY0~65AV` z<87hy0$k1M)y~QMS{-5^C(Np{|7Y%_#peT0`pnP zsDn=ly2f3Wo^@9BVmtrr)B-D8I)D5e8!rh z5pYwVC~#O^Hi8VB9#d5fXP(m{LmjL$^Y>KAoQSI0cs#^js$h-DryIpGYWL~(?s_n^ z@;=cpG*AwKNob}flbO&Z0GPW63t-Xyt~>Fb!;=bK^*Ec0V*JbzIGg=&GHEn2%a5w7 zESb*N3aHdBonDVXjCT!6}cP}bw~U~R-ttxlzxioF_7bVs#|`XH3G zqxsGCTiLrj2}^RYs|Ter0i+~()oXqlmk^}a#mrq|s&5RO zaeJ1Wg{LTXsMM+4OVKj^lZ8^%BF24ho|XUk%9_W4?vF~N&EJZ9X);;u>1XJ81$oR4 zX@=976Cvfi_2EHkD7r%aZ4bJ5oG8e20x1IV^x`HbdH4cg?QOG z7pC9Mod>R3Z^8^dpYxc$5zPzpKOmNY6GS9DonYD=LPQnP;FhQZ7+)LgC|hJmSyaQC((0UwzM8S2 zMVW=Eb1kM{hZPKw{;1Bre!joHBPiPZ!OwpSrQB%$_#v`-Q1Grk_~|bj6mh!QuQbvj z0)E9;kVXj(3RU;nfYl;$DvQvFwk7q`7`Fse>BBy|qian83c-(@fvfXSj?AW`{%hX; z#s(5Lnnlg+3(BMgHW&__s+j|kW-~QV@AE^JU-Rv?tiWJAwUc4#pGh5;!=Tm~-BtCT`ib;&%6(d2yli zcQkz54#?XJIwS(`dw4y6&2Vz~?6_eNz*e(p6Lk|Aif#2dO(Gkd@4CM_V&VVKH^=?@ znyu?`=YKmL7H@tqfQGl~D6XdCXMx_@Bi*3FYpN$2a*KKS)V9w^~NB6mHUyUz%0TwbR9iDS0c%W){A>6bV3ynXwnr6Iea#!?CtfRptGwOMzq)ayfrX_mpW5vJkeA{$-L>@P?! zXTg`=cXPQfak-DvFJY9TLhKw{C~W`Gt|Q^G6-woH-!9;e3bQHyNy8WwG~f+%3cNLw z6GIo|gS`p$qpYD9r5ptP=lQAY^v#}}qCH(KRAvNUF#eOpv4W4g_Q5O_%Q=5YOyQ}G zQ;CjPpCEdbL8DnKE<7ub&PJE~rY67mn-!|QF5|h`yQ}*BfvGc#n}p2H#mE3P?=tQp zE`N^pdxzHj%h*&UmqGCvmgFe5?w7Li-rCy3?*q*|$bcFvypq~m4hr>aed;N`59CrO zOnqz-#df|ISN232ksX}X@nP0!7XO2nS2CAo;_&-T8Hok6D)`^sr4E<=>i$t>Cb(Pr zkN{DV&nNma_>hq2-R^Ur(dNx3;(PlUsy@XhY6-oV)2)%u58rX~9o=X2@CMDW4%{^wTwiV4(pll&;$UQWf^sy8;Qm_zW7ddC)D%$&j*R$K@YxzE?Wj{eiEh>do za8|p5C-?Wu4CLcU{0vAr8$^X-d{5VrIw*a-U5C#t#vevsr^TY$=A7LQOEqw|2fySr zaV-aXHOM1h(vRam>D6++66 z`bZMrpvf8Xg9bQ^*>)uLPljVsc+^T0c zt4o^xc;y^4YFA4a%e~qaIJsl|6!GWQxm;g!s7C&^QAc3^-GV=jsE_;_Z@akvs8xMh zQjYtfx184lfZO)%9Rw@ohy{)m$R!Hs7@MXrC1`}E;vuxU+z1?P+x!$!g+mUR$??-1 z0Vynju)J<(!m2x{YuC;{-aGWiSY2FqBb*B-VTgj{B5vGICJjT+q7fk_k68_l;Q?e2 z=YAG%KL7H%t>+bVU{Q15x%=nWEyVOvH8k}}g2+Cix~ST+d>xTabo}rdU<-uH@={wo z3Yfu(m@4$<`E5#U6R{QO(aOrpOGn`VYl1hT$<{^nQyO%v%+mYnLFpop&0JoZZz?YxLdhW+a6&saT(5}ke>*<%-n|HhT97Zi-& zUTh*=9m3sVK z{-~FG_S~mY9^z3cs!5PijtXJADoaQ#*%DR#eua;P+~Lk#q)v!VC$%vrvDU0twTB?> zv4($alpARU2%y4$1d7S2{NT+EVI~gQH<}}X(x1L`FRQ8ymKB$TmDI3?hA=md)kj&v z&NpI93V&mESD+u|xTLxku2cT)|DSCp9E7R8qH1Gqo3yOABt-iiI5|P5uW=nIy7MgI0w{^DVb;L{ zCUG0j9q2u?^Z3;VX9WdEPup10L%V1N7H$Q|DUF5C+3xxF*CAJafvi(?OvR3VA7Ph3 z`c|Ncr-Mf=A5?5-`L5oGZRjG^hvJlgPd5e>WBWj9n%tgj8JMz+l^4eekZc#bT_H-D zor8;*?XG{QF}qD0O&b@I2JowCF#_daJ9?>8JZzGb^a5QkP-?%zh!_0d6 zb9#M+Y72LDb&YmMD%vSDph?hJ8lG7SRK@^|()IvCcxyVD5crw{&%UXc-cF0;9g!b5 zNr3AIKSIKeu*U)}~FXWFaM8&Rk0f>Fb`Ui&5hz zRPmSk+&UvRfM11kbFyaHgs62$J8YU~rpA}c#G@oiAS3t8nyv*fymQzUSD~hRg8nxV z0{Gs37CXP77J`Q0hpS=-vgOaw1Q;>BdD}iB`6@h&$-KYcAx;3_6u_5u6C?foSQw9D zla*k4su5fMX|WSL@dk$PJ7_0pEvCeYRR@f6yohk%0q9{Ux55Xpa?h+TDEq?LwM6an z@+>+!oBFXTY5|hI-1hLf*mmz<0(<8zLHy=fFM8b8Pt#_w5?jR`Lim7iv59Gt5oI`K zQ`Mo*u9GfW^l5!RP)<|Fp{D6GeNg6yob&TAFocwIcZs2Ml(UIWm3~p(%eL$8!1&_v z8BRaBUp#G2_4U(&;u`Pa+A$~0%KOi(2ZQh1iZJ7sf1+2Wqpp;km%vK!gd@)sC*biA zsV4a56OQi5?Z4O>kVz3kMEC3sjwOQ!sG=D#dq#ii40^~BVJ*!{0}Z3l9)3~=Rogpa z8?I?Kk5{$RH*p4~D5m~228B2_n({ChAq~v52DK{SY8N| zyPEUl>0|obtUIFQ)^pr|ZBC^-PD9x$=&IF$Pdc^SaCa&*? zyuAAcSfET;(6u>~n(r_su1ub$z2WjS5NFUSeO}qlwUCe+f451TdUN_9U}}Ohn;C6u zc}7!ccEevN6JR2fJJ17B)6+s3RkQIb$y!^XP@QksvMg_{NKgY$$iQccb2kktYB`go zSqb=so^VhGOY<2p9<6-ic*$XN77B_>-dxwTg_AUDm7&v^q-*-IbDRT;D-RKIrA*9` zcMrLuFPw_5fu1T<;B8ygoWGZzQWkHZ@4g4dr+)fOIVJm!nxU>9!KkMoyW7}i}*OR!YDI|SpDxh-DvKXmMAu5RVhoTyQ?eX)w`e4X?5^ZH8>N>$!VYz z5jh(F`rv;;`P67BaIs5{O9GLZn03EUQj?cGs%m>qMWX7_)XVbu3c`P_c@Rpgeg`;B z)IDci+H5kT4uGg;9lz>Ft%pu*fpIxGms`Ah3gm9eD&Xbi^0T4nxU{tfHFuBA#xA}= z6W*OqmcxLs{A45a)ltTW8>VhiPa}k+OQdDy7eh-=E(9OZ04r!Z);`oc9 zpk$bY@>(NeRgf`(FfN`9VcoW-*~sRKh(c?kjiOh|#0c_k)UV5koosRbR3>gGMJ5;V z_FF^u0OrV0uOmPqt~E_#EM5OtP%vZ`BVsBxdV9H)%fXIy-&9g*7h?uQ6B04HHK~<8 zejIb(gfPxT%$X(V#N1e)?6-xqRx>BcEf&+yWbRb1TQt(~ox5BC2Kv4uF!pp z5>dhs08AQ~-p8w36WMKl1m3C=5WFt^nfvruvprDErf#v{N)o&EkQ)@6K1oApz`sIf z7n1YMW-$}Ou2-o;W`Aa+u~C1Am;^eNtDSuwx8JJeift}zp+Cm2y}ZqRS}hT2wZF>> zJ{2X(0WOso_6%Y#2Wv1(RA}ZFngTe{#*ZJbpS&$lVO}_9LHRO=ut}RGc7~*~$Z2~c z2$I8tI;}>0#c}#w88^q4xRF*fC{xUL@f;BI#PG2z;t(88I)&{m$C4H^I_%lr;p1kAx zXl#INCa57W4DFnGa53sPsz|1o#O!MtUggnO1(un^WO!ATvi36kms*|-|CZJc4czm2iln~f439od-&Q3w0)Jr;3s6QY& znh<9&rpXRy|X+hYD}(LsP!d|;cIDKZJ% z6IA(2I8?sI(34u)Iz(4VIJYMgJ#q}86rBiNKOk3o1KnPkm4#3Qm%!jvked278KJt) z)%J9fcO-6(nT|`P{h6%=izQSuRSxics%2a@n7*-L3z4iqffuIyx+*spq!x%%rYCa4 z(~1a$ZmQdue`m<7E02Q539y|?2GO`qSEAic2!M5w(B~||3wYvV4cq3 z!~D44=|Hk?cIDkoW_1`H=I?8lZwC>d-dGp!6mB6^FkDAcP+CHCxFR$)G3b=s0m-;+ z<$UisqEFyjS2uLLKGQ0Lj?WiTVk0XXt`<~K#eniwlZ6fZvEq;6kIZ z28ea3ZKfdKzL1n;phzhm?8i4wR}4;<*$_?&J2e}bE} z^{&>SzEi(SKTvyqaYsNI{rCI9cCjG@lC^-yXSO+jcREMMnWdGaL^9~6lQvi1LR5#W zxUVBK4WW6Q%cVi-qX4_$tHxgq@x#TKYV1qL@rs(x?P(xp!AH4@=m0BlAFp+>qy3cU zPQ*H1X#u2Vby+4AN8dtwyBMCWjTP*F$7u837V6=$APGAyz>h-tdUQ4M{6mv$AE{rc zOP_1szEyw4yz}k;%T3McYQ26U`O6Tux+{Mc68-=}k$C!YjX#!Cvu{hE&N?3V_a?NTPk z(2aoF?2_0Wo0Ats4RZ5jsp+j1f~70{%&U17*ha@}yo)!}xgZ|70^sXu(nPi~2PLA9 z7}W>Url3;wMG4bFN;!&M!8G1ge=8X#RwQ%OgBSxUGSP{vH%7&13OTd5$OW%W8sZMX zL%I|)8Ma;GZ#qy+vI{bHEEM7ngtc;3b$0$$GuVVp$8bud^hp3s1fOv)rNFaT;5;#N z4ZZ_L+rqMI;e1y*HHbGKW#w;aTgVhOA>lGi-~Jp_lxsi`gR$%PA!_)-fGORQExdh? z^5pK{cFITZJ_T8-Sk-wObs^m9ETBaWOrqO+pcAe?sjE8c`D_gB51@<2AEWwtWgFaIQG)|a^@rM85f-1iNv$^)gDZj;nV zT-E%|h?W?CRApnCasRCwSKw9H&31k0y6p8JvbJ`#B6l*oem;X8X=z2sjvK09A*BeP zAx6u@a9KdD-jLSM-o&6w1})vQ$(Pey4CDp69PnB_L*4w()P8ZiV|6KDT9F-K+h^CsFsV7ES);`| zP;TK`XWAlY$=qfezGeFlr|Qk_Zn_BY;bk}K+;(d&+1D2Xta=JFMEoAo(4MW5NlD6< zyMavCUluUNOgrJ#;SD;n(;$oH6{Q~TXz1V9fG;HBi34vZt+UM8Uf7kYV1Ok~AU>4u zfSg_2ue;tl@yyiZXI^qt-(ScA(EjzCS<3;svhcmNK5tn`BdAf()J8b7^DEUnH8khk z;W?#vv3C#3W);5fw6YAWGNl)%aL5PC`yOa0p@1aJ9K(#&>*x7_X0WcUIkWQug_Ids zGBugjL+g#+?|j=Njx~#zIbW}2^<`e!CIr%JIQd{I%mzpBCRvrtpLMwyvk9{Gqa|*I zb^X|;n01l13wH+#2^Jh(U8*MGf%V~C?lJ~XY#4bonM6Dw@Y}mmT3?VOeQ9Eu@ymJ@ zT@WYS_Vm7a;AaH44GeTY&W?ge;>XevY{z)rF)h(PxGeJ9x5?@UQR7q*Qm11DULIx|UCW^b!bHhdoe z)PF~J$Z#3cBzjCtb7M95dti+YQJI1j zXD~|FO2%jMI~!dbUs2xYG1k&g;8WKm@yp0FM2>U#C=(T=YLOV8{z|QkC$SA_Ov`6x z!j<_U%KWZ~tldDTc?XFYS{d)$&mP;-{@9V;+mgUzC^&@!T#Z?N(*RH_B7T*)CgM=U z4HB=)No6A$5|+vH#9(4jjY|W36u1MO5mD_@5!McU{4g{cnEU9Fi-*@k?03yb;+QmRd1$|H5rL^A~7uW5r*H zWe3TKF=>Nc8Vn;Z5;*8{E0U2FEf}o&5j+ayXmU%9Tw@Jsc_&etXL^zAEV#n=og1s! z*nqvyyT#pFYW`-Xx5kbt1dmFF)4W!H%8PBV4uqoS!f>+Iwfix(PoXc_S}kMT+Q!kQ zP1R_k{*`D#U$lq)$#M&_qN}ejX2E}Et$F>}qTVN~K=FA>v_J}@wkFd zH7~r{9;CM5;gJmr5XNn*+wn85TR9;s$>pY$n?ah_7dk`&8enbdo3Edo*v-A@7oCzY zO{g?=h=JQv5E=8qebc+YJ@QoGI=DQ+z_c2>)7uVIu*ZjuN){xox9rdBUtWJ>5{&&t zT9o_V1qX8im9#YLZ`0%<*v-VEtCsy=G#;rfLlb9}vvCmDipDRMaW_8eue;$*Z>OUy z#{}U#OtrNh(SzzkQHrLUWQk^Lyi{#DflK&I_VZJ?HmGGPDCt6~L!U$x(vphE!_s#N zhx*v!X2E&SZF*TEu7 zhEH-ffr73+k(TG^-CScOQoDt}8BmCY_%9^LMqM$vnEatPVRY2J`u%%4lwmUFC^O$< z1#|hIkYP|H1;Rz(zIyj@^DzzT0yHEa3wnZINt!WeTP1>FVUJY ziD|n1G)FAvqx!qvx>iMrzT{?b8q zX-G24iQf#UI5Sfy&h$gEJ%ZAWZ`O z;nLnAT>tqiHzAJ@Nc`|j#++S$P_wmnqounWm%_TGwHTM6TfEijrd;AyxWD(YxV!IFlG9Pj?~+~sinKuYAf`;n>mbrOj?$w6ZP zSc^`PepBEBRE9IlJQ-zI4vl{k85loy`keLgNV`uB$OKyZ6*ZGKi)l?28EjlZz)5-_&yTR5fpad2RJIgqui>$S!qOqBx()t*yl|k`-WvIhR)3f2;-@n zgt_zZ$4eYt=gHgQ+(-LRera_`K@ivsO?>1>Q#tE^x`YrE_Ifo522>{jQ>BFrIY+{R zXTsBAat$sUlPG?lMEkUd3*2Ckm8qt$L~V7Za1+dQK3WJm&QJN;;tiz>nx$DU2m9n6 z1&to?*8n9#eSmQbd2}cA;>P+mdgXoD?@XA4_B=qzC5a712gE{XmEG6L^h?8a05%l7 zT+kTh4+r(MkjVVJ5ry)#RHPninw$S{KcN|r4S4#?8`+CgL94&*xhp3=NYNe>el9mS`bJ4~1!a8PIeOe%sK9LXhLIek{Id$^qKR<~83 zC-Ifcu>{F58Qy}5X@PWKXmy!oq0rZi%37ZIr0VeW6&IlAuzq)v<*&P5l_aIk;%Q0n zIpOuZ{{UWwHK+LFp)dks{rS&#;5u)LN4O@C@F74+BVRy)PC-!*CfD;MN zeL9>Z*Y4YyOQ;A`(BIDB*)eP09e-eL=b}m=-pP~Z=E@@0vmBZUZ9OK}_K4-0>C@t>yKm#JUGTRX1~KM{ zw;b<$S8=4&VB0`);15QD9FT=W-1tpg%?a*oNTh*@pgmLGdmO5htDm`&Kxu#vdMV{c zUV0e6(VvrEI`kZ#0dzG(oy(5&D?&8N-GJvS)=V7(LMS}HJuBmcBBi8SX@-aN_rnx7 zJJvZ*j~&^4!h%CWJV6RCGj)ON1{$-aO`A?bx1^3-zrpXc2pBYHn*W^Mvo~rQ-zSle zKCJv-CP1Qq#>7KL$Qo!+Uk*{#+r*E{vVhFU*1!AE{2>gK`!bxbAo^JKxC~6~oPp4b zgspJDJjYf)nL*!<{m%nJ?!0q=0pp{V z2?Evr!fy9AFzx^+U{~xQn4cqpMO4A^XKMp)F_o}FE)Udf2W`ZR(61iK`q~ndf;hAtwl!?{O0$cwSKAsNq z|L*Z8YHkb+Ps)S=Pz~>*KFLLvx(D8SeujzI(e@+MfN7p=ldFdAJ0zgUxDKSm1?Mq! zK~`CE6VbwZwd%dx(q`Ieq<$s3_H>AD5sNxcdUCtN{*0JwU+={gr;D5N!iMI!o;(LC zQvsQSCypdy!RiCDWxCUsYU{@PmomRurlqEOp^LBM|Gd+WY@ODWK42*5ei-=Nt%r8V zp)Q_R{){PJ5p};_Ui$gJw;aWs@ak$O_xt1{Cmr#u`_l>KgFsG#O|Zko~Lnr9)DB*AhTIQp131A39+jE=43}7lMg8^mmT}anID&5&iY%9(#gqL z(BCCtnCm|58*5GVdzt%1s*5u@T6JDV!==sQ=z;=lFnG}HRNi-FGU$wTQI+fWia?>w zryk52{yjXFSglSI?l>6B_Vyv79pZEUh)Sa}3n@FuEEtcG(VR{Zv`k~vh1|SBJ>g}l zVW!xCsl9b;TN(*ZvkbrdqJ#0dmpS{n8vo==Sg`d3c?7KP-S9bLVfdmGS`#AAf3-K3 z@0f;{bS`2&ppnYBXmc*oOE#=-&nQ206f{^dpWgm-EKIbE`<5H=G|&uH;SRpg6}QY3 zwM1LH`x}XHAQ{tCGa~Y#_f1oW+7_@@054vW{O`gn_T~>yv6&m>mnYg6Sl8X~8kb6r zEe=^$?IM-?`8rWDu}IesE3cgNNn7LKtu%_IW)nl^k!8BCw6)$y6%PK|t9~_t|gAbCRV7ADoq z{Z7h);BUx==0?ARe?{z=4WC(!_oD9tv@2USv9Fsrk!c0voaXEt<+g6i2FB{TyjxQx z*5e=Nh}n%hO{P--R2PhR+t>Fb`1}3)=XVwOjy#Go`7>Icu(}82*tt-vX@K%!xQ3bf zOWxCN4Of7+7MhUoz0_VSDy4;P;3?%dgT7WI&{CEKx;C80mVwP`5j*94W!k6wnr)r~ z4ozS6HRo=MBuP}h`-{6O{&GP-c`U5E6SU_t3uu_2NsCBCk)Djx>y6+CjDeveYqA}w zD#i9#kHEp{Y1!{_Mo!18qqKI2{^;BL^O)toGd3w?KV?|NBQr#iV%gwa?zK_Pd>v(6hNdhusiofRNW`w0o zgflNF+smw;)-#MkW_dm&Mb1t#c&1)#fN5d6jJ_S~w~vU!GX@f-x=N+{>Yai_v2CE- zoRr=8qYfi&(Bs?4>!0(JIWrK-O3oA&DJNo0Hzzb=K_S7v_nUxuaz&g&@XPRPL|2%N z1azB>5k09f4Z_Z>xUVWsB@{PYI9z&i8Uz}B!>?O|5%f1w{5ECnA#828%6oOg&VRhq zxmHFpjns#ZRVg4&c~%*!Ge+|fkj76ZxZe=+H#bAFP-Q3zfwQj7Q=S@ zq;z!J+uJv<=CCDgQ--Hx)#r&vWu&xqY&0AT(-bDRTOmDUtL?$Pv$?h_&P9fQfBb&FRt*tOW{H3YP?(cerm7LCqDZ4#*fj4q}N_P5&T8!Gw zM!jqVFq@86R49>TVSmA$YO>hf4LE%|neOr%PzyRIx1_mUp?zZdnil)HPz}`U7~h&` zE>oy%o3pc~u3z}G`b6*$SK6dQY~yjm{GV0#p*5eJ97LBA;8F}%#LhQ7AYX8}1k~k0 z6a(>eKq4;6ucXw|hp~dtm@&&S^N*C1v zi~|`4hvzz6vgU+_Z1kvE0cp}>BAZ=Ngecqri{|21&6|v=e;?38+JX7%u54L|flrOj5sGD+TkPYz; z{obio(MZAYH6H1rZTH9ZDpSnENN~29VMU`0N%#nrHIFYnk~g<@)XQ6F&kXSwF!k z;2UlD`&<~Gldk}BuSr#PC85_DL2QI=A2WfQ4h8TG2Fle1f?Z;I z-2IohZy2Vr$D|VJT|8ZfN3AEn4o17?>@DJuQeFHaBs8(CH_A(K*-~I4Dk7#0yhU;r z^Xr?f=_; z@pbu|Z~W8n3KIpT<%)SpN!j;h2OntLhr1ra#McYd#ENa~1{5}l>7M`d9kz>0l~Vka zH?DF4@&CI(II}i2$&E{cm~9r_;yJ(DHU5_J_o#W*GSdp6*$i)dFZrG}m`Lju5a33; z@ozA?omnvO6ps{038xdy0Xy=wZ;-;kDi(VZ&t8G}LoeZxIy&}#=jlX-bpB?8)#L8% zICm2qjjr;rA7T~xNtnW()wpGhEbOd+GSei=H;O48AxWRmD*zHHMPjhzbn@E%D$-SB zY`l)lOvHKbUl7;$kEWtUzotl{7*c3Ql$yED6_6tTi#qlbOFxeq5OVTg7D<=Fg+4i` zPGU$TlMCpdJq2G#bv_Pu(X09gy~yRxIC%@~?(BLIn8r*iDVgQRkTbZoy@o9);P`YH zU99@ko_5Qvtv_y19^#5VJmu6e3yKPFS+#BH0+s9DHY~9~)l5LLTGtE9=o~&1JDIE; zkKnW(6Yah~=hS^^DQSELJF$)V4xakv4NzsDql%d!f)p2yMfyzYwzSgVzZ;sH-L-b3 z$nLG2um<6*{&H^V=yhV^ZA8?Q@mWG~-@_+NF@Aqho`-jU*@eQwnL=Hf@nNPIGF%@w zwigcd0s!zGsFke$j2!r@sZLOo5{9?M+D^^)7tkN_|ATN9d0%qTQV zSw}sk9%D;jb0toDCP!~4BFH9s8n_uD#?K;bFEd2I`7J97g;T6=|Du9U*s8+l*GL9H z$sCjUu?4DH|95B*1~g08ImW+wnd~vr4I_^{nZ! z?cB+@OvLsRq!b^an-Cik2Zh>F*yy$Qs z=Xz>31v|DM%aPmZM!10sSXcs*Q0Yde81E?80MxIc-vD`avTs^yBo3!HJS&9x9O%}m zBRVPv&aS0EB}S*u2$hxC?Wv*I-QPh7zkN*p`U>vqF3@`U*l+xZYW#Tqx;+2y^c^{X zpS?63ocrG~tKG`qz2B}e|NZOk{=ejEIe@&xP%(%0rP!!OkO~KdUtO1Y?Rfxf(C+g= zyy4KfnL{`~R=GE7oJbNl`WE=>2JycEc!55iXNv#P>DLf^qa@c0d8udk1mmGZJpeRDt-(@!cDzcZqeYl;G&-}yh&cG}% zsQ5hzfhm<7@V?;$%FTO9W8K%SkFs}d-rhz!$RSa2t^8u$jMLKA?7jRg+!;3`+}jtE0SY~h{~M!M|}8*&ay zITbHwuZNN4q_of)nAjCJex7&(&!kG;ZA)aaDX+kHm+DkF=#}b_e~AA4JX*%qI%t*N z`}A-!OXtOFGoRU*@}vw*pc{bHlq}*w3KaesE2OTnEH-B4D2<;+q>qPpjQh~*yZ*U< z*Mn40?HKv}bvmA5W_ej~U+50SuUd)AxbF0UlpgoX*QMMRnwpD_JvwQ6KJan1FODSB5l zJ*An|k@{?iw|h#1<3GKRK@%T$BeR#$ z*15sCcg2AZ%f|2@uBeJLF~=ZfDKyJ<)d~cq-rFoCKEL=idubH#92FZ)qLg=Vb^iy!Y=5Rxz{NOA^H2j!t?PD^qQ_0mU zwDF+bX-jvtB0`erQz?*{J|RQ;E;U0J^pyR)W4#a~A>54kxt`{#7Dro^h|5a66m z{Kq^nWTlQT^#5o&3$Li&{%d~?M7mQH=|P5W>27f7knZjnQb37e1PQ63B&EAc9BSy0 zl4gKGx)G`OJnve+f8nhA+_67<@9V^nn!+=*x9pd#<PThCR|n2m#)$Xot}HIWMg~s#lw|MWyeAlMSbi@x^zv~2V0oedF8%~aj^)7{1|LNx z3l3derZW7Xdp6P?Vts*;f7E5jl=s0g69ju-ajuFlW6IHA-)1y~q-B&0_!rts8;M{O z+M~!Aoq7os&tZ_Gy{j&AI6R&IgwGbiZSJPtG?pA120V+?5xt$^v zB>kPWZ)k63ZaPKqQfa_h@~+39eK-s0re?Rk*@H7&kQ6=OJf;4gOKpB@b z6NnOX@BZZdM5w;wZp>Qp_HW2aD2AZxdNiT6vvmVFu~eF=q~WtPwnoo=9d@BUe!Z8M znQ7c+9wFXHlRXM0Ha2+j`8Si7P>Eb!StO`rAf~ zAR3pP;rmIu8p#ce)V2HVnN(O0;NY)MqBrHzcM)<{x1;ILm=w*C3>%xdp!n_Z4w!w* z%)OdFaKAn*Sw)9ENZo7QpNHLWiwB$oDbSsPL@@WxK=`*KU{`C1e)3=3R+6++@s#2v zMlYMyU(Se9Ada*^KyJ|s>MLW%KQ=a2x)-&F0HpJd*COMnKfEeMR$=ofW*TuQWXexs zPS_;$egPvMc7j_CzT;Wz?C8Mp`cV-tETDnh7e|Wl1|=lWR&y@OsTm0hjLH^H$>Z_& z7fP7^aFS`>R?svP?zlK?uZY(QxIazWJ0NuB9|A5W+V>of)ras<*Y>2M{IgTP@bo!Q z19PS96Rg2SE!_RbSLuWdRVeHa?C zznFU9Hhy`brmy5I8F2NItLyJ$bmVvEA!eiBeDEg@C(`n+&mqfNx%CMSOl62#nz{B= zs_Lr0yMOTP=oczzQ_Cr4X`7mZ_?$(>B(^>a(|h{(^j>UnE}9M}Q&o%NKjG%CZk0Ii z2;>CEj82lo^(8rZ&TR|xk593>dkt?sbr;o;q{&m)W>=2x+V4MN^|r?U?Lc@SW7ecN ztMTRo!lt=$ikxfIz>DVv0u{&ej1TdM(Q>uOPCJbVH_@+C?E|fLSYVR;`kZgaikOe? z_cbGZmW;{2j*RtFeTVjcth$jKFrVC%4+1K!Mr*>hX76km7wi?M2>loSwt-QVSVugn zsPW1lAn$5jL!YDp0wdNS?`%M;Wyy8Odroni$n!d3@jL$fk0W1cz%*h^>tyM;Mxkp}?DadPWrL(PjS znay@|t$5W-S=7;4_aS{7%xWu!$iH5u_=XETOJ>nFb~2-j(zNo8dqy8oVG&~Em%}UH z6?zFvRcAAibqBl`)3|g zEFxYc&SEn5mQ$Nv$nPd3_CVLE)8!*ggb3cCOkEf2-e*CUW;|G#3?Xy!0^T0yNFRE# zj48(MH>y#V(xuw6m%gJH2LuMf2AlmGI5@Kq3-!E_Uek2j(o>#3`C_QeqF>4|fpO;7W3o5aH| zo*q3xjPeT2xoA>?g@MM!t1p)O0q3(g59?a@#C)Tx_ZQts_DstnkS#2Y?1G3dHKAu> ztAz)bxD8uLeY$O2g)`dQQySI8KeQpL|B{g^WtA( zW~T4o39Cuoes(8ztJ?aIt!RfCH0w@<^%8FP#l$AMuv5i}1E%p*)aOm;lecx^#@ghf z$O%v1i_Bv7zlT@%FT?(s-@_BS9wb0`O9vD)RvHkl^krpJPEbAF5uMK5#&+VJCEJv3 zDh?xG{hyyjF{<93fYO?Ifx^hQVagK_<{~XoU|E4aF zfPbgplJ~I$`KU~$WJ!qhk&DWhbVPK3dGtSU1HhMbpu7geQaomvSzFA?!QoXP+WRu+ z$H@sVLm-!Vw=5!}&2g|XwW6KmEJ^8oBk$118A2uvBk742;y;104o+l{z|>gXg`40u zNaA9-vm!wm*mLM?X7x_uD0q)-1-j>&6LK#aSJ%Id1@ytjr3df@e^|KQv>2QI#YCo8 z#a9t))AX7{RUNVxVbj7ASuQFjhV~FqmI| zD+`Y&UL6hBV0~wej|M{uf7<>1^)p)YT`nlGP*fR_+9u3+(V#jq>)X(9;Ga#Z5?b+)v8{Ro;?DBjqrIn7Sb0*4G*B ziMI7?=K*r7SNm?w`~RHvjv4X(ei`Bdce#wCZBfQcq? z%TB|HyJh826raEQc9({*k6h3QLY!iYYxM!BzN|W!d`{|@Nv8mr{G1q9Zlau)K ze_nu=dVhR5CH1r+OX}y|d4qr%9OKt*?H6A6Ec(YP9SIeazQX!d@rricNWM?+8|`;F zHUH=!kl-<;{ao91#GaA&IP+0s6tmX&6z@?y_P zyF22+S6`_$1bdibuc%~kDaHz<5E!fFJzP)QFRi>k*`2`)y-~{b3V|Xgj;_b9x<+|? zT;eIcGHOzf!v2}^nedFqE7T`Z!NLdJ#S4$bgaGW&*qB2qUc>Br^8@JJ2JLejM^dqK z>{nUYJYq_8*iGI4D1@5D1J39uB&ezZ-_Fg^$)VWMw5y3`!uSMr*X@kKelvEHu-Ghu zp!@p3o&UDE+upx@>+&?y&q35j`=#+F0UO5Ms_|PXgHC2~6?AX3`AF*Tg4piX;}o9H zpY?zPS*{&zQ@=eRbOOIs%5@h3{qvXh`l^fhQPb6Su z+^YUWl?I>&WE95&$%#Z*mYvtTG)j}%j;nR-+gp1nq!@QI=H$av&K4jndY{(iy$Bro zS@#}B7D6jeTUiFQ?eCER2c4FgDZe_C@S=&|&0yIesW`&`mWHVyX-{0Hc=^c)m{QbL zSejf%Gxe&*uF$jMQ8yEi(gf3urGLrM04Jloc~?%*9Um3Zj!W3vu@PU3^_;9Oev zEI(1w3!3+7kV@iACNMMy8HhyY$Y8lhZ&fRtL{6_fCtlb`dDsXZAyt&t~QmZ?bm4{@5kjLyTy+q z<*~ksxC~g@r7O068RwTwe$oI^4b~MQcMZy$O(c%rxw-F(W@yf6xM5d2_6VtGkym(L z^Si>aJsgd;c5&A_ymr;KP$B2;+ zPoopB5*qT^`MzG3w5nEGMXG<2{P6YV-(`k`*`M0aA;;DIq&jlBYA$DDH8H=mW#tL2 zmef<#Zbw&p0+pS6<<;7qe@qz znYvF+%iz6e8*Wa%PuhHqyEZ<-C%Y8DyEfPU-@-R|9~wudVCsyub3^p(*Saa=C_5+) zu0%8jy#>G_koNd)ATPf$Q~t!B?M3Xj)>tsre5@c(LMHT;2%RxyT=ZkA%x77Mq6>AU z2=9?t$u?s*YD`98?M9lG+1e92`drnwNJCYQt}-ayA-?Y0P1@sI@Y@f#8n!oaK8llK!wU# zkUXdVW}J7+)=x~_PmX(-h7=hsa2Ko>!Ak5J-oZl`^#-?ht9ML9WAvwMw+yN@ZJ|~^ zgp~@$KB0EXJIl+LnaOCTdo(=|>)&f%{r2Knm0QzOdD=|Ya5i0E0u}uPOV$?iqffn0 zxN1{u>zUQ+yq*K_I`*jgvQ(Bd%82B~%;8}J-LJhgk=`!xLP2ngESjxJPOSF^ma*SQ(Kz2V<4TblAo2x=y3+|S9KxHfJrpZb5j)U zhIk^4g5DPSry?_fED3Qoi@(uf|Jb;yn&-jTEb;s4yW&6|Lh|WuSt?5Er$~_E(SI6x zX-^r^;z`wJwcT9%td zs7i5T(@l@CtD1w}$8-drWX$hnu7Isb+frI+K(f?86rOC<3DsC!G zt#!s>FW-FPa@AgVKKM}txR|hjbTaJ7uU}@)tKoc_daJ;V?CjB*+N^QNG(Td}QP+6E zTlk6k&w!-Dg!aDPz5}T8s2x8g^&AEv?basgcOR>?UV29QIlsnH zZ>MA5=LE-=Glv=@AvY%nw^5AqZ!;3 zNNJ?BTBs65n;O3a{qx+kYi>91z6SBIYyCB!#b*fQeKRDWw0bBaYId@idrv8Kdw(3f#Go*j}4w?@(q9tf3YCN6R9Z1ph5_1-3joV^KUsVJzc9P z_0v|~)1yoN;FC?!JGxp01?Kz)D_SvqwLgY2Jq3-n%@RCXWWx$icx#qdrU;)9(M$A> zlljiX6mKP;%!rhPcq};@UjpY znAkqA@Y-iZ1og>$uZqY=>r|+IgCaA>((R(_evL@-jA>dqX9#{=GvcNK z6&f^gsd>H|_@K31V`OFt|GF6+<(c#P`MeAnJ6Yi>ZO{3|T{!WYLw(PiPm`<)bgWii zxF=GiUon@yd8(CYK&(>ROp^@9h1#)DiTc`PP~_{vfBDMj%-r4|-Md9R96|r>I6pUEK zk78iEb6I=mqHm8-aanDYm?Cwx#~Kr=IuuyZP3Rgii-w{KFHJ42?+BO^Bza2|Ex@m( zlYhhsw00#`=ZY6pP=PZQ2S2`@(4{bb!~Pu9!6z@kV2i{oBo=jMz1Qp@-=SuLAG8&g z@u!feA0Uo8l=Qd*JU#mk^sP)lpS>Sf55{HX6E|~0yb2+!FHZl{QPt4{44`1s$ z38MNoX`Js0O)O%>&G^#qNiIDkz$UFX(_{aPY z`F8vo;&&T(UYv&qo|@Xwl#A>sMVPnUfVe1Mvd#=af%jAtKov^n9Z6i28=fxFYH90O z%NAZ;n~d~c5=X^>`@&%PHd(C2DBe#W5@d%nJ4*I$elb%S>TdM#mSVk86qO#Xd(6^X z1I>(aIPF;bGLQW{hLaO(ir4mBLUB6X+^e3hAMA+b@bw9XHIgirPfX)^3d~&$RHZHmCEyk;)mf*oexO@qbLQtI^*u zd0U^?XDi9XKT}XqlCLZuH+Qbp_;#aBs%$^I7~|RRO)CIIT&F zIs;E(1o;<1qdC>Y8Ig0FH`>O-c8zP3NbKN;pl(z`=rMcrT{zS$_Kg{|0Z0xj zjGozRh5z_-5>-D<2B$=BWFNiec8S;>w71n}Yxj>p&ie1=5~Iqar~oY*3Jup(fG8sE zS~mmg^Gk7Ce>loyaZ%z$#OdmNo&u`xTRJ)tQ)1P;{EbK&DDDTVn4BWVPH$*`^CWbf z9K&sO$m9xLvCX;yV`YYNA`tIrg$7;-A(%Q43rBtedY^yRNYTZ_8u7$4DI{&#vlR=+ zx@iSqsBg?1ppwVu*Fc$u61$4)!BvoG&7QGxVgD47gzBazzo z6-GPe*#CxF zbb=gV&+<#?3Hd&)B||D~I?Mi;t$6u)^`1;73Df72MIZzIJP*CU6%9K}?#5IKuVN+( znmv*?PPYWRTkcs#^DP{(LxHMl^v*3q1LpvOqT0M`^Zf6}qucG~zw`|6wy_MVt9K}$ znBVR?`z^-%uLeXfZOR`QzO4L?h}zxH0;V94Il-bg)HmS<03Eq0C>6-bDSY-P6E@%k zeCtA3Z|eV=h=>LKa9a4_4Loue|Mw57mfVVr{_Gj&fR?spAP_J5Yca`MlIv0r7^$tu z1gZQNfn40&IPztDTIrhO^9eR_6hizqP>sbyR2-}gl>RUL&QIys%lXCc#O2W(G@4At zo7FfI*jqB$%dpA|_@n&d8Z(Q_S^_TdBiA?gQ-%XRvw7`^HAPFzoT?WS9vM~X@B4GE zU=v2a^i8(bC_M5@QRo3YYOo0Pa0C<7NVPmQdA1b#iaJWhETspMDtgAFN*M5pVNRat zt=;JjHFA6BW1X8JSlA_AGaWNt=utExqb5~P1h6TeW&B4OM{(o#BN~VP^)rn*tpIuu zd;;(Do6@+5Vn@&^ex(kknaHpx_V>HF83}%A>!~xYI>$NR@9Jefws~3H74}y zNu7uSXCm+}OqgDZylyo+TDF{dS}Zsp^o(fk=4AmC#-C*In~S}S^SauUwMk$#Ud(wn^$!mTAc60V^rG%3Z8b6 zT1)pyuU^V?UZlP4i9Eb)B~44lQ%E!`lZQgoG|JhAaaFYCuT8Xg^GXNd(x$l1ws(|d zzXd8u-tiP0+ZS#1lUlu2b2arheZt#ma3)R#il2fzKI}4)>w^MXNpEXCj#%{ny!+Sy zi;*M_u{o6?RaO0#!XU4tM>IBObB0N8yoprd)W<`3_=xU1bnLOjNr zL(ybroq^$JOnYc1z`?iktZnD{E0-LSf}#rA%jAX#J-t2=bweije^MH~D6*8EZzA~o zhH(b8FS9p)dnf0-5XH-PXZcr~ zhJxS^3`<*bY;B&exycn3R1x)toP8(XDZC{MrdAlAMk9h6rZ%CPInFUw{|(^{i#%J} zPoGJlTg8oQ;dQ?h>-V&Pw1;=Y6Rz{e#YXtUHw`fYkG{w{RiMig8`(N_t(Gz-69HDl}DSL+Ym zK+Tzx1aFqJnR|!cf3epx_we#k1k9UdNl1@K99Ul<=RPKKADQjtQwq-m;f^KAx0+Q? zMn6FccpN9it{(acH2RDlnRRb_hzx4lr59pxFOyGZcDep30leyA=jeyQqua5B0Q7+{ zvn(2n7O!7*Lsf!^kRqr1TX?C%g7m>alWPJ!&^6~56g$QTIQKs`rUF39f1ztNi{Bcz zH)hm!`;yS3B-5{Pp1N`h&zS&nNog5ff%j~QGYpK`xK?Yk?8j0_f3kv7TQH16fw_K6 zp71s|ivdMLqFmmy!z}g#19VZbOAbEx+QB5D%donP3rQQhXebcjvKkef8R4! zb^8~OsIOGnGwvvry&0O%3QE9zoDX}>%%Pb5 zer`incsA+9#a`@-7*)fw$DcCfLt?&gi2jHmvHp6Mv$V-x{LGbOVOPxi+tjWkfyEhI zZk2y|X-I+NO@6J&mqYhTc}KYawsiFDM)}{hyJk_7YEQI$2He(L>a5&6l!4QcI~A>q9lI5mIF_>%TOcuefiA9Wt>Lup)(* z_AlQryP-H7KX^~Wol>apU=g+M865?y2`)kdDhmhmF8Xlv2%wh}(M$G=4ovu2;L=4^ z=XP&SXg!r*J|C=yYyjQ4^`9#j_Pl^%=3&&g}{M}|jA#Qd&xQW5qDuF^Um zzk?-cuf97#U}lr|zU-7$3cUrKS%Wx_o{+)R`kHT2(k>udgLuCPqSM2iSI;;fB@g+Z-PwOI6KFU$qhtu&D?M=>|-*9Mq!5|*61q}CT zyEW|rRq41>b!rFj+s`m`!+oT# zURCaXy|2Ib)+aM9)NW(dd#i+!qfG5Hsi$|bYmCdpVB!T6u(ly1AqwB+2@R$l_<(yC z64|`M60{f6zxNWTwxk;2`m%+^AZ?cNl!`Q5E2|gzT9SZDoa;3UP}MI>c(_J~%j*{< zu)NqodTM4zqdnf{FVle)`=8#Xzb=QI?nWNvif>|95Kx}1lKRy~2)((J@(1wtJ`78d zVG`@nXn|VVEF#p_D;bq=rPQ=9sBfNWpT|xknp{sJ;AAPbdc=|F^@3>e&|{vvBa)(I zpGudv;?qM+KSR?q-dhlEIQh9H5gvHjw7xISZelIWIuOBq0%T#nxf)dp{j%-bryCnZ z5too=Yv_i@yk|~{U>w(pOKaJYI}MyK4EVUIPPBppnfiUcf`hYIdIA}-16|{Xyy+jT zQ$Ia|@EH1+Qzo~S92MKt_T$u^x^2XhR6u?yd?I3K9b|G#)q^PxhYG9ItYCXq1wnIh zMc&n+3Xi_O+mPj(Wj`G$yhxUghd1twOc9Ztfm=gud(jsB3=(gOwwB+<>X^++lEkG2 zZl3Yy``ZYy3DZoeaY^LvM#@N zV@+SxI^{fUKA-t_62K3kFz*PEF%wGi<@S1&on2F*!1Age#}y2PzywV741uwhR8MP0 z{-9B1LOMozk#MJClm6ktKKOo%Y$#C0Olaynv27~yMeUHzcIw4$OtCS~=lDB6H9f=G zVOrt1u#Iit?klQb=Fz^oE>~FL1T?Od&yW_8-wD)ocG_mzyQJz+3N|-4|96Gl_3GT% zy?mBTVZ(kH>=y_?vZV`0yxN-DqYGn2k3XWYxvGHpaYkL$cNlEhZ(#o79Qjl+IqmB^ z`spi2KYmjw;&=03+<2*jRu$-Ee^81ts7CoL2y}F{7K5Axk`6{HWlHgL-({-?@i9gB z@Zg`{bRO69p5HysXyLEd)uLWjhd;9gwxR#bZT=y`y!g$DAMe+zR6 z4a>+?Ss8HI-?EaKBLq4y;obLpxfXn*i$~p&L`-O&8Z)VlfB#aa>$4K1?$a-JKSIv| zs)Bc_2GX(_c;yKHy=?9potbgA@~EKvU%hE=*aa3Z^-9r0R?xCq}-=L0JYllM^vjTP*r$HlVhAY$K&Ffg>`%omgPtraCXq# z0?dIi<`Un4mx#}+kYIT@tggc0=2}wpe_1v<@uQGquCTvK4>?4V*Xef?>z_CFPpnV# zt^DW7WY;z~pT6wq_}wlBVb!{nvTPW!xr zV>+(45#+5!Qt%cCU75lp58+ELfZJtv9=;&P#l;Qv@KS$%iZxyrQI}-z+P!L>vfuu)78OeWE8uW_+V0&ws^5p+priytMn-0y*UD5xvD$F?9vM5|`v%AbEUpVk17w zAB3@#2Gmj})gQsfaLg<#(iM;R#$NlIxz?rFfwnAEC9#hRT}!jUt{_?T>+Wdg$SYcD#8oHmjP_0MTH0I zG84F!Ud6wJUs8a$HUGBz$KK?Q$m=`mYU_P`L}VOmj3yh^Q;7L~bCsx^C8r%oJ{bvn zt6@okQSc&yeD`$t%6Au!5)0<}1@#S+smnMXWO|jRoC3+{{YGW*R#NYZwXerPZ9s-41K~fs#5${L$oeUkC$@=39CW-ak?8KqJZpQZR1>Tsx z;BfJe%uLU$8htKxz@R1TdzNDWcwpe1Ms^~ml_C-nMMwU0enF{t5DTFJB_GoPkg@=S&RBQSAqp>X!MXPP}!0A`o|v=zFlPO$~fC5?5mTsqN?iIqLKw`C?llGuu9J z^~h)}bfsw4Oc|CU@3@~RkrTT?olFzdubd@A`WmG)g{>Cx!*7FSaQ=5uqC8CFQr~pA zJ^NzebReWmK!*0Ubbjn%S>QM{C#bb*)z{OLVT_p|ImZnu0c`0Ss={V2f= zGW=r?*2zpcvxY^YNm6caDFqYJRnTv*&X_-R3M=485>ahV3t8;J%H(>H5?TLYsnyP0 zNub5ix99Rd)FA)qa6Ln9*5rRaF{9Icq|gbJ@tLoXn7y8EOX4z-=K|E2i`kk&@!K^s%i8Am zj_|A8;_%|$7}R>e*?u=EIzt?Wb7^oGRIaKDe-n~K7!2bTEBsA;{S0Uq^vRaBr?q7s zHezGRsOI(XTS-DF>rRmje1I#Y^n51Epi~`4Kfgqdavr&@@P8&WG3>vW&aMX4ry>sr zc>-ZzbTvTQ_-PIT;_46Ut9L<~(Jz6GbiBC(dIQ7Etrl>3Y0{69YakQCE_LolyKkgw z4Y_79n?~_(hJ zgD+;%&ZEg(7d%2j!xcQ=W*G`6U3H4R`d-GlGQI?0N5{w>{*K?Lbl*~i^%32pay`5s ze%yr)AWP9aKJT-E+BZ+mrW%&k!Ju)^FdI6hOvP7I>)S8wF)xG+Fi(X&cN8k>jVpQR zIr0$!4~H+71iZSIkJl{+O7}$RE-M66TA#k#zq%~C;bN_U?R*r+|zgStmY&nlG>Ko(8Sp8pHLl$1&{CG#T#B>+>2*0O*Dg!1~ zx~l^J&kMjkJ`Ussn8&^2L&g`b1;>Gn-96-=MCkQdH#!X95fXIYw{t72O#71^*s&<1 z0hKOvpMm`Q`^#|Cxo_}5<{(lXn=B7ACKIrZ*iH{c1}TWManL7`BQ^@a|6L&^L6}%pj(Z zRkm4`DG|g}B>4f6IstSj?qnpEFo#f^RKOxuI?HRIvfCJE>K7}+q$3MtJi+-TJK%6yr*TcV_ewU&ghY!%9DL|(-{%J=>*UUHjdu&B_as_Sh$U1 z<_s(^rO-nk>rDLY{w`=J-z?MR6QbDGDd#(a^egFw!Z4y)*bpP3p+}m{#-HlBgM#}g z*wwy$p2-#T^Ry4tehB6+O-u9J#g?S=KL$_e(@!>428@^BxPAn@bQ^fAKv2g6Z`vT4 zIx463=%b}e<@enahAaJU6!^ni6S!f!mFvE{kO$ zVhP0%6hc@y#THevde5~y;Vpiim2FyM<~sSCPb;yy>t81Q{jpZ;WWCeu?cWlqp7f*& z(6yG-9TsZSMcAd_@@vHl>vrM6FVhdSFc9|AKz4Kde%jVL(=&Z znj`Nct*yYrR@jABYv{!;&dXR*bBw^}ytlF*!MBxKf2Zm1*&jBe!xTGLYL2u}J-{+#l1jzjkq zwaq^>s(xz1^zYa=(w5HKTq!9Um_xq$4hs;ujB~9O*atUr0kprX;EVEA&hgPY{);dR zUm|NQReK8oQ>mmhQcb?r*8zIYpLz=eV3R3ss=Ye>)cIq_Za=SMr)U8x#)R=SfyC_g zrk;wCVDL%b(e>)XMfX-5x7l>Xta^bt-HSt&20aSOmjE|fKqvJRT(FXXQ@2Fj`LyiY zcQv1!#5n@strI!$C(F`fzvSf}7bY1))5yuJ68EvmskQ^^0q_`5BUz5>LFf%i=EPPgdt?{FTIp+{$Wk^9Lshl`1 zK!64%$AX8C<1W!YZzr2r%8OasUI{Bb&uLobf#V$YS{cr;*p~-BQu3X*Df+vI9eOsy zVJ0aC418_}mVmw&ZMPCjSsKU9en%D7>1PP2ix59NJL`o?;#VyHo5bk5oY6iC_CVa^ zWP3#mI|Tnf%MA}wk}9pl{6XmDEsf;$C&asTQ=3)aj?k;{X`Xy_MI+(!Xoh}#e9=<3g6Q5vgg}FNE92`GY9jL{djxyMMK@DzT|`TDkscW$;5y${v6ik zM#U0pW%llm0%YRq$v`v{z1tx>BGs>x@vT-)T8rbxfyofZT-={?4``yyFy zA9VyI{Iu}x7k{fu3ja2hik95i4nJsHM~;4uF-wge1*LMSw)|iob!tqKv&pO-tolC4 zG1RtwXh~%F?@&3%xdKQ1O}@^?eJI;=X;+6#3JBs;Tk7!@o8PkhT!Or{%`d0NMMA;X zeZtH~Jo=vgXVQ?F;Jbek{#QYdEWp;;ft}lDM+sR#ym9BH`Rz6Zv~!!!(CyHlIeWbk zpnJZD(_IBIk|0!kR-|rwr1D(7%tHTV&2;6NZut!4OxI%W?{l2=>P4kYLUZ`9+Ohk2 z4myo zYin!K-rKtTFN{N@>0s;5Wxg9}w*yjtn$|^$n#(8b&vL?UaooEDH5v`i%D_sFpAm{n z0`F2O8#X40=t^Q&f}Bk9Dtqi&dCF^TaQvck91nBfk~nj+WFGP;8_Ma`mw63=2R`#V zC@AA*lS|#8#;*^`4T4)1A*q5HoV6Ut{g>fCHpOk>>d7U)BGejZ`QphQv808OS}qD` zrub^;&FX3>Kn%psuhjeVb}6R6$zkynY+r_M2V2LiOg9PIF7sTnO+>Zd#kO&whMw7O zc@gz^?qEa65?(@c&QNT*r^mUe0z>^R(j&+(afZa1m|GnhQhOCDIo-&u(r|FL*dq8u zum{jF`Y_a}4K%Ne*=EB-geRWtQ>ExD=Fu^&oHEXxHnOI{1s5R^%sf32F_Q6vu3CSG zEXTsMR&w+w)WelR&=k9hL5$G+d&SkUp#FteLq0Hr)|qlKe^&Bsz{f5XGaDe?z$U;0 zM9EEoQUfS$p~VG1btHk8tN9YW;&^C%VNts2V= z8!6b;4I4VBdaSj33#HY=n@E-wi!HNW_KZ{88VVBhP!zgu^bO=5pEP%?)xQy4S&a!> zv8$t%Nj6|fMxb1y1Y!A=H2;#&kOpzIc&$_xs4SDQo|r5RLgdiG|+#o1eBUEYEas%9NXyYV6faWMGIfLGW8g$ z$mpki&;P-~{&uyqecfZXkJHlD>MmfR$yLLQ(oly4`*W?Jt=s(3QS4c-Q{y*BgZ)bh z6?>61<&sC)#Cq*bHmoJ3yKF;CTNhXZXiu3ij#)&iB`sxTtWs%`{MyC_yo)}g|5c^8 z0F0VZ!vvy-g%2_0G>W>m=N=EUY20vXFRF?92ITDf9ZJEA#gw3~uZM3rdhLH_E1rVo zIOOzD-<&HLn={)I6IZRP8nj_`;B-u)=lhfuC_7s02$+EX)04PPT0Q-PW2 zDT@Rjhj)O!tD*#ncvXoz>&W$<7x91V?Vn${%X>z4?a&>o@j;ix&C6Yhr>_cN=v1Q&LrcgQEv=tRp@i7k%)tLQLtN%NYe@@(lg@avU+uP#B+Af#^?S}^O(wg=cIWYVoJ0c!4lgG*jlvrN zrC5C5@9|?}t|8z$oI{naPF~Li$b0BlTF0j&N0KU-l0CF5t|$_fJ5u!UY>NM*C(&p=Pz6 z9dya6H0{|Xv^!#W!TcS!|PJjY{K52P6OnpHSxW+bpYSZrMGZ$ zI4V~Al{teoo!oPJ(9avCMBn+ETL2|G)UmOQxca#BcQZNR@3MjUnTPkdU;EZVJ=Iex z=-tJOq%dOL!)u^1wqx^hoiN#GsLpD}ZDRJPfLEyR=>LLzM8T&A;{alY^JevyHhD{+ zJQaHBgM2+?RY?;S>$ua>(vmmAUp!(#F5rt2@S(;UujZZ{im3fHiu+e03F^YW8EY-)C5KZe{Eb3`)voPUD2+8ks_u)jmaegMj{F+ES}LN1hwfz zPcG$5{@*>6P*Sx%xn9kT9BV@##usf)-&>s1{JK?afi$B~{~ zeCPbr%v7Z^)JtF9>3da>B`$nUDQ1Q`zOp(7ZZ+}CIL?Al2BCqqq^EUHA3lElIvlj1 z_2NP|K)k=k>2n3`^Pd89l&<*Gbw7DBo{!wt9Wl#~Fg6JH6KAR8$un^4w+;|z)f840 z4Q{+5PFG$0^@Z-!R3Q&ZaDeK+I7VYxXVDrq`pxlpAPFQ#o*IGcz=xxZ^1cpA&FvJ@ zuj%Puvw95{QdqwnABpRirh%9&s_PibB^s%p(!KH%H>sYl0(u zcWcEwJ^eK6jVRAH%J#oe-Qv_k%}W!F`KYL`zF6Q&mFw zZH6$~0_LqLD0Ev{O?oVXeAc)ipK)CEnOz6bJ|?_X$_sj-Zexi0&z!v4Ytav3PV>vb`_PtSbB3l6*RrdyZ{VUEzAii&A+{d|_K7g8G8an(064N4ijX%iS4wa2I z=dmL4QYJzxMtl8Iw?@u-L%Xf1HFfn=O!YumwhTfUYgi6n>>mrh!?lyr(Vt1;OMcf6 zGi73bG(BEVPPoE9%3pHdd(u+!23I-4bL3QA`8}SWI~}$i=3T$XZkw$>fxORw- z@QH1XP6|sar!)(IWTFe~FHJ)#$0^u#OM!nf4hxI{3l<=iD%Bh7Y>Nu95B;>#&KElb zrYHvF{ZslB?KdXBi;D+wn=n*anlHm{nx(e4m$4=P{k1mh3P3q_vzZ)MEmr!pLRgyY zO@i?O+2viee#@jKEGcd;Ei2o6<5peQ33WNsOFVz%AApJNsdX}mzj-OQT5DEKb(9bK z*qCl@)XWGL72gL@k_-p7lO)aVKcD`%mo{DxZVA53+O!KjYhU&9y#Tgt8loGfG3>E% zZWUD$9g9w*MD4<(pjTwWNkkQhsKq&V=+z}BXud)iC~a_)S~?vy0I~s@6)rJDr_EB= zfl?{bW5gdHuX+=nq zON!iQu9^fcUh?X(qUu)eQ)}B9jLkMinmNNeh8%H_%tN1z;P&-`v~kD9XU?C$5cyj9 z6wEh*;b>_oe7bn0ceu$$LiU(n<%(WIWPA#*PuA}U^o+;~(!|fO!rs1>=?lGFC~?V^ zKp)I?mmFzU%yM`k_%Hd#hIb6?Kkb(-tLK<-jRA>f0=z;wYh}sWReI_H2<%f+54Fth z{UfLoXo#+$^8GGq&8{|@!k1-s%#m@J|92CE;^^I7qz?>qs_s?xHPj|L&fo9yk*%ON zv8yzk#F-iMwn#oPjqVEjpXZlnR+D@4EDPM?*E8s3YHjLmI|funN!Wd;G|a5mPjNWq z1X5J>ITYrm$vZ@251s|XKiDpxr7wR;`i}WD$JzhZx#6|O8C~|%2^~N(V$^4e@HVvR z(>1u>V3=!BIc{bs>dWO0@)91m$>})(ZwF_9%sX#dVGOHb6HC}H}Fv#lYr$A9M{XK8QGU9Kyl7s*8s4BGry~sLD8tM4 zpYw9!vZxsuSO}w;6d0TW8+TxJj7TL0uE(It8vXrMw1}6;1>fD+DNB^Ge7c=V5Sday zVO80u7NcYgRx*`#ev|(9oPuCGp{LQD-YJ^Y96_zr1z&Py^Kum-?|!>L@Fb&@K*cJ$ zEwif9;k*mU*}bjObJ@LI#Eg*PNKAx%nD~$;)#yG;WYY^9IIVS3XN}N2GX69PqTy!H9Y)&?qX^=;XAdV0maqwYwOhSp2_?C@VXu5=L*_U35*}hG!%>T z8lpz~SSEq5(+>hxSUmFZ2hd3*DNhnB$npv0c_y#3d0tQ;l^q}!4_M}bHiL7r+kx@c zj+URhS*28Q@v5-q>ebW#N7GrjMb*7u|B;XqkOt`n>28o1Is^o1>Fypg%6 z<#Ss9op1AT0Q|>y;`$ok?wq~J2vh62Bq{&)l(gE5l}$8T&R36-)fRaz>mrzQxA(ko z<*(K%UckyCHB0swNmEVCaJ%FGQ~vr1m_@96&1!{a`ncEagjx{4_4|xKjId)apv zRV#4p2B+V9z2VqO;+=#cmPVhok$ut*;HSCA#Q@puvlJgGV+OQOZgBG@#vJGuai5hJ zFk7gq2rv`g7=Fn^ED5J&{xFH2XtlVKmxx;SZ$(3A?6TYq&;kf}q1YR}*Yw8y(0{{idtq%(3`v!e#SlN;NqjF&FW2qq? zy+jMb0@i?>5VCM;fw)65j4z?6v+`S~Xmn8>H1{=kXS6dlf&a8A73`>)Js%ON`{|K6 z6G}skORij9et~8-ovHJZAlGJ52vt)lqvlFF@lYlt&fP?v5(=+*N8Rq7zotB)+$5m6 zxP9c?+gq|2axX9V{b_U6efat#*#qL^Oib;Bf}VPXo;@>ra+|HX;#3vs_yF7Q*9#>; zaP8vQ({3|NP4qFRF#*r9BINjL`%}6;w*ycJQ-#W>>;jXDZ=F7a&!_UUZ?pAHG>Fwp zOG1xRp-=BFR-l;f(JgmVY@7bZ7h+sYSc6!0xS)6iA9KekSjZ;^{Vma<3i^6Wl0l@X zGW_G}`9&HztCSUUGRm01@5UCm3lPGv*31+pBSP12ac}AKi#Bz*aT>UESV|Mck;*g> zbg@c|a)L|>f05Su(LDW^Bw35!@S3MC;p6EtzT^|C{&~k#EgFUuhNSCgG1?iT5MZ-yyD2y(~iHuA3^7sKjI^PpAGXU3f z=}{CBN6zKTs)$kGGvD%DMzP`falae;w~mdyQ!#M-<$1FN-Y>c7v<@kYRw}&2icqt6 z?wx+Wt&Z3nQ${oj1SxK4dYF`oZJ=eK6JOEOr3$^Wx}BR|OaZ5LHc2)-ewa?R05Pp+ zQQIi^>eE;|kuC7)Jey|@uuPG_D z9TDBGk*I0^J-A20ksH{T>15>g>a3=o@)Z7h7kHT)c){bde@SKf%2J4 z;`x38Nc~H}$CK?9jWHjH(~q?D+u7c4wID-rw^TsY_Hc6<&V9Z9=Jr?Ye=W3}*1S&Q z6uHkA4SX#ni1XzpB9|-xwQ?{G3T?yCp%ImLoKq_ z@W+%Q(54ghQU2J|_g}G5NC3A<6t(zIZQX&2=}?Z)#p%Y^=Y#3rxsB|BDc@KdFl;7$ z58KqE$CO`QX(l2ivD|R3{vme+SKKG1xXIfsT@QY8$CA!tR{DY-OcC=Y8(P?kd`RIR z_iG`9rjX9~qn(Rm@hHYfg$@}7%|T|i97}IU$YLJIJ$%}m(I!=o1L6lKTB+>oBINI- zLmf{fQF%vEzWMJV>%^y@GsfD13oL82w*v-AD2Jf7n=z7aY#|AH%DI;RF9d<7>vd`H z*l|69ya5ZJn)tWqId^>UpHP?AnYMmR+m>rS_T~$3&1hxE8$F@ zDNW=hE+8q1r{PFZ4=OgO(9>n0JzhQkju8YDV~MxCV?O!vD$%Qw9JI8(wWNf{g&_K$ zq>LJ0x@a=`U?nsEl#F72ZaGhGu z#*T`+g%}Gem=Mxj$PQx|i%s$>KTP*14yZJMWStA{6dM!bEl{(tP^7Lj42VHX^9Bar z&Q8bl0gv?9^)=-u?D^Hy;3^+0R#=h`k^_I$NRjcr_ zs|R@8wy{SjmW!U1zc^&C_c`YIu&nD?@)0 z<+(x>r`zl1ph}U~Rfy+R-A?$!nChxNm&Y1D6KS?DnB{W;auIDqv%n9nHBYC;IX4-I zE8IXh^}MB-=Jh$}VT6qJfodRs{qa3oYwIR%Fbv1S|J)oyfH{D3B26S+J_lM>Ziu^O zXgoC%?DZA(<$V3JNXPr>x#s;&MPmY1>muEbTMA5Ae0rJi<4VDIRdFk}hZGt{9?M8Y zf&+j)RX9D zeo2K*9ZY94klKv)c73UX`vSOMw1>X);wm(uVCY@B2Me+`D$Q|*6;ur%*U3Bkdw{(D z)#!G^yPh&!T(cZF%-c+MDh`31^ZE*HwqDL@eile=ma3RnyV$pYOUqjQ5ilE6`JQz} z6t|;y3{US6*^Fuj=0fc4=`p4Hup^O^!s~6h8g$g$Wf+$#e_J{^5)UnB}c+h zqj4m#bLTjw1E{xc$OY6mqce`m?EOfA2CV&nQ@fb$@|gKTIZxLzsFgl~sV#sC0hk5* zu;sG?GK*u8rD*-$W2=tXG-X$U;w2M@w~8MY1CDp@AL?Nja_jfUnmw%A#Gr(c5$lI8 zvravZyKaL%dTMB6O*BaNLnXH!v??cd^E=i@Yn<~}poCteK#620M^s-X+Ux>d`1L&1?PP_vc_Hwk#g)h*Ci z0x~LT{mF_*|6hMW#;2qLx(2>?;t^>dqc(P(1;ss(s2Nr?8buhXGHu8NMF6yXwu}zQ zw6iSI#F9b;nE5{xSc$$qxnbRUwSc!0)g(3n+0tq+B9KU9l_kd@py}|TD#tKrx@F1D z*G)}#0sk6ZKWVWHnT!vqv$?9f zhdBX&(PZg6;Mq>kp~%0?lhf%fsZQ8%L{Rb~LsKWd3~dm_VExk7RskT5$!>h*-&DpS zYO(;k9;P~F1g?R2kM^ya^(kz|Q%5HzSD0t#-pP@`(~iWe6?gL8(<#|!R6cob*WX)Cl|0ib~5q{&04am~PjWNDUz&oBS! zb)3u`e^wOk+32a8fT*pu@@0%#@3|z!r`!@7x7#3nAXuf`pyRh{G~!ajv(WmKWUx&G z6Qsa4|9J7VoO{mka>1dncKL4(o*tI7Z88yUH9>FbRZr*^76xT5{TEhOCYaNQaJeM$ zOf9-{k^8d!+e+}}7hS2*%nmWipk;mhY^x2lR1pAf4vlh;@Djoi3N8Udyy>{XOcNV5 z{YYI;_#dB6(+qQbag=_WEWzv$`_N$4`Y#|=XT0>r5GI2gWfpEk2mQ;NXAvNlJ3=v| zaM$^I4N%~alx(7*(i-~ewQ$hj`nq@a5d+R@n-4?L!D&x3j!(5puf2LfC4W-oB(oZ| zT}M)}bi9$3Y%`l+g)*r6v7agj*C!zO$RPG|IhX&2`e=q%klMcOm*v3!E}OHx^OCNg`%MB|WC9~-H7=(C zQR^P{Fy7`I zOE(QyB{a3p zhu=$Z&&a;NCMD#>M>($O_Kf%b|19-r&c-ZQVL--=yW=`K!fSBms}fv71FTjiBli8T72*bQeYYCiu4LD5V_m zAr=pC6l^pZ4kH#-`h8c(KY?$#z0s2EdkHg18L>I6`AQ z6cHl{LFR~t{Wb|^5z4*Mf|8!v`K|8^{xgx+uEfZs?hN^HJ2!JapS~~>y zf$lW@o%{|+L3^)-Q&W3Mv+IUe2r_Iwy-fy}@XI^0lA1og32wFjOK7*NQ70??9V}@l zRXBQ;KxM_*T9k`84%j}SRY#zoRgn>z78wi~vd8K38AVKW(~-1z#a$9?k5`10+2%5= zsUGU0F^6-SE}SZO-HiYAE)aubafy!U83V{Fhe;!YiV2x?^qZHvfWm$V2&p3$SoosPEJxg&b3A$l=+X8#rDd1J6AN zEwdzRiia*doa6+82)iT;R&j(VC=~4)3#(?lVcy}Sh63#f4Bxp=JtG2 z%VJ{U65Td^OpAEUUF3ia!JHdwwyQrS3~Z=_5@CO?cacN+$ZmmKREkvEU_21ty@d8F zk(Gg=L7uvfS-O?ndUTa_r(O^uJlI^kuuo8pSA~|VOEDz1ck*&djw8J|$c18Zj(^(EITp6N< zKJ?7M>t`Z~w#5p7D%AKz9Hh=lA*-UB0`#Ce=^=F}a#5m7k>+FgrAO%dmK7;c&2V9L zIytqO24Ik@LfE3%IBCjesZJ|7_%nNQ^q{8=|$qbs|9EeJ$FvVmuc zeytHnnt2HW`xTqzl;?9)w11u;uYH+|bz%iB`Z8*A~2K&w#F+ z%-apaNVLKg2VRmH!AWefOfA^;96dE%8=y@i0Zaa%4gDjS^O+0q5b`lIbiHg5{C=LR zp8DwG;Ub&E%o_V#`UPv>P}{U!K{EK4W|BNNuhvh=QqnOdMIrLV;nW5Lsc0)QI4 z*{d017OQQG))&X#KOHd{SfFeKZBM=*pzm`Mkm|>?T6DPevNeu>jT*i&iA@1PYX)b(ZZP1sq1G<8N z4ptI|@Nu^eB9C^xVCB!OXwf$|yha4{R5AZ;M(Ug5hge4>+#YxO;{Fm-g?$HYzJ!lI zsms%m9NP+6zvk`M4zRaqKjWicGkuy~N_c8I&H?E#L>$TY;E`Ak*Die0)tOi6FDqlJ z9AGv5J2**LZf;+l0_7-V0-51{Vf~asIz?qpGErSMTwy>nLwnA_AwOjDGk6qTSdY2Z zllgflgQ&;qDrn`yVTM*hm@S#hjB<{`R+<;B<7sMg>Lh*%vvbpG!ag$P>FEKAf;`zi ziT=(``tIgS*mf^@;KdJ#Es@;L5YG5GsXi4vElpt9G1Xg*|G$7}01klV*V0)us)$qi zH+Z=nWkq8MXD2--S zDt6hic_-a4O1V2rK!t6mRceK6`*;aXp;P@;rxLkBOUoQQ{^D$W6NBCC^@}dJOUCpA z3bS%Hqt9UYEj+z*-(7gxqchJbxx!fkA=9D|sdv%rWk2xZKK5yLTlP?K8pyh%h^hF> zf^REXsfgvIz0(&5wE5fTeY_*5jb-$2!jSYxpIAA%Xn>m1x&9dSs|rh*{q2F608CX8 z3s76w#S^$Qwnk(;#Gjw&RxSVvYYEkr6HoWvAse!^j(x}G{gZItV&cyXsqbq05|cl| z-Z|zdeB3PP0fDAT)R&P}&1#zdd)Hd|>oS8F-*$77#e$1LZuwmjHN(2zFZ-{M*w-oS&zGYdfiFq{ zFZJJ?|9S!WFBM~V+YZpOjFbs8E7U`U?up&mo=VONXBOu=A za`V;VUuOm@Z2GdpD*Yr@>1$PcTe+2wB_}b8u`Hc@M4mbmoyP1>DGBR<1Y%Pp@9y_9 zli$fAesnM1tj^8N=_V(ira7d}^f&XM5cz8w5~PD&;f>;#T@$|dVFAR}DLkhO(Sw3T zG7?vi-aow8apvK_*D1W8uaT>b{KhOhO&fKLE1}Fv#U|$M%j#Nu(bpN#<)ryDB(>Nl zH@=S8C|RlR<92Pk4-eztmnT$cK?~KQ;?O5$?R65}q;zNAI)vO)#JyS5#XDD$~rm0)V3R`0|cuBQ#04J97cZq zoL3#!cW54L!|IB_IwSi}m=qO*oU(cYj=1yn-dp&O3b_a*fnf@dgy+ubFq4e5f%vv6 zPNWKeX{YV?x87K>wfDvef?D(V&NOZqXwucE3mS|<8a*AgiJ}*0 zKOU}(l3!0UNnNd+I$G#y>dbqLokR0Sx!vFC;DRmF!yIoCh+NaKpUI9B;=j(ZGNfD% zjn1GIU{YxUh~e}xPF?mVF#XX;JNq-c#n{9VUnPh*Rd?wywZ4f;_Wso?)j-Q!2iKz5 z=2nD4%x}n&KGj>oyRPFu%-)TbPVq^#m;f^QOJol>aCh4<_~wR$!RLYu=LLCUY!}l) zH%?z6wnH;(S=qjy87+?~6p2_l<-8qRVrOiZ0Gv{5FgvS7Z!QNvfAiO5=ift$wRSwM}=Mf`P=5ftJoof+iRl zxngdvtFY`z>`+Py76^ASZZ*OCGmtX$|=Z z$w&R=RPnpMFj(U&C>_}{3a4`Et-FX18RskC4F;{|LEdW=Km0^;YjA)85CngYuE{cd$|8)M-u!-{CAr}o-7mSIcU6>Tf2s4woPoI`Y1c0J9;Ag% z#yFPaVD>JSLX@sgMk}S`?m}t6XfoYGx5l2(-Ct?JlRHc~@}{Q5LBAuj&^wxZ1V0w0uu$>0ISf!Mld09J`s3tbWqMm*St!m=M3uBFg=}vG?OArkjhE~DlN*Q2N;O_ecB1ody)U5K%5WdXdrh$yj*wj?mU@S#c5gkb0>(5WY z^33bb2voDldDqmWe%2VJh+6}e5H{jnsO<0ad$S59bw`1Amr%j1C)N1rbJq zSBuNWQ7Q+}oKZEWjQOY-YWEl&^f&+Y==r=@p^Xn3=Y@n21CNfUS`urn?4!;+CKtm^ zdrDc-dL%YrEdgpk>kOcZ3zJ+ypZ^fUZx{1b$<^-QZ%Rka&RcXlCN~)Lqjg3GfW?fJ zc!t=xlKpjI$QjmIn(#HLY&`agPB1w@E*BB81u!dIbz^&EXCwzw56{T_UPu4wEj>P6 zu1j0AtQV|zhd0dK+I_0L5*t#qiSH$`Q@Sgg5A4Bx7)%QS4VLMfl&l&Hm)J2 zVwaf4>_eaCX8kaA8JOYn`Ni&n!P?4}KOIYdl>XPP$R)r$(S}x3 zNo6CAuWpv$hvC4trxr7kTehK2y-^$wGK@DhZ|>aP{DBgJ4-o2$t1Rc}JHVG=brm)r z)aeu>Lcf24)bU*PDO!*r&hVl;%a(v=+2*pDJ|SA@MmYDQYI8$dTDy>uGODfKBzPt6 z;F3zKYZGK60amKj&t4+pF!Pxm>Zed-WMBau5EAI_qKV~ok?^fYwYxN~b>G`Wp^lB?AvoLz> z-_H&SnRHtm3f=DK4+NBcXK#K#o;bC(cI|9E*;UK~fL3l=&)kloL+OpH9mvxZUf*2C zUPG0jRhb<`X=Jie@u;z%-axJ z=xQJF4Gs?Og#MB9i&Eb1n~c8b5^FfVZKlbYjw(N5qh_$TRR5T7`iFx2e7xSNhRHSH z_J0k}H48tCK3Ze?ydoGtsT^IVCV{||meTm~#q*x0Sb8gTrj6SLn2~*)s*ps8^yO%r zsk!<>!Y^WklNYL^Dxu5HvYpOkZ&|tc)OY@j(ElaN2z^u)l&H1+==xLC*E>QZ%duG> z%WY?eca@rzXJB~Du=Triu}c>AF7JM^TVPu0lI1+M*tXzC_MkOOD6#GM-*NefUaHaG z5|g)5T*EKgmqSK<8REm;US3mniEj|96R@NkaC8~k;WR`I?&U==v67>PT*D+S_=hFu)S@otC$?%9wlTZ zqUDGE`ln~FFhAlhW5b%EY?DzJk`BU=rt=1?*0ItG=rQ2w#Y=5WZ4bJZGJqnY{6#kW z{=-~eCf~+CD2`t~VbhIwSzN!^xQYmT!VVm5V{Ywi8@NW~hgtul7bdA=B`TIu7L?!` zM-Vcr_%AC7s>dt!jZ{`jxx>eQ7|26ZnW?c(>7hK2Z=yUb`GYU|1H0~H6j~Ae`$JVS zlHfrUK+-;-AmhQTC?NWi2Fk0KAIX{#rEHfH9R{$?9#k*h<3}BkV~@v_a@QWUb#Hd; zd$yao)BgRlXZ>T0ja@l}YWo?8oG5t%r&&W@Gw3oQerp=so8P%#|Goe<6{Z+fT-Ucp zUw+MHp@o-tU;@1Fy^B2etu~(`JWU(F+)7QFxZb^AYV73AczO|PPVax3DH)XT-#=m0 zK^|9Wv1t+~?zL@8&-GTs{P^6QVc9*2i4RiMO~JR2)Z}PcaU_x6*%X=h^^d-(g8FTk36-GS zI(Z>NW6G{+P@`wDiUpZdjG&MZfSFcwoisGI_7#7;;%RG2hUQl>!Gf#A-v9XJ&XcLW zLo&0-13^^LsuL3GQNs&=K7qTHRO0+Dy~WpJFPOVO`nJ9jw~Nc->*E>Ll;Uz+RCY}} zA@Ldvgwz@*XAHW10GShm@-%no!E?rL`PwSu(M_iKiffMR!MGT!KkD%`-q(%_Mup$7 z3oMTk`J^O!?~@FuBk)0`O$q5|2g9kPc=tmxl{dPl{+Ha_V;kYN#{chS8g=tl2$B6E zy?CTpE_DjIp_Ar}bU{LO-xKnnS{B zjyKD39!cUHI8d6Jo4?E!T%maIUY$9C zd6GFFsvIV>_%%X>Tj7m$Wxq~zBZ(|Volm`i#sX&K5HG|uk=JM3oyejg+GHR(O0bR; z1&2(8(X%~m5-m!kE;|7Y&ux$r`gEMRi;ziDT$Sn}sawDuDMC?##E+-_o9l}QNQw&* z@4uj^EtPLmmH>dSV((C1HwFveFB+~-V$yPv1gjx&B;poWR8!84MkwoD0YqG(BU$tW z6Cmt4W}%wHMclPP7|Lqvr>M-ng$prq#Y~#N{D_~PGgeLr7h8)YR*65Au(RV?*@>W5 z6#j5H=;00@b9 z9C=!m%a*&s={C|rXo}>QPe{UZwi7kAGck3IYL*oyr(9cs&zJf^0X;OtG)?wlOu91g6(9{j z`*WEer49$`M>X(C{-O?d>;3S$$lGn|Q^83j`KMP?J;R$oM5FzoIKKSIE-O}$@!yOn z2VL-#HP-g0MqR)}d%~#B&dAAx8l-GfR<{MD$<=S0y`1T;$-6)mJ!!qfOz=HV)PXPf@Vcm=0&m6D863@ff z_cOVExf1uAUP2;Ed0$LjX-lwGbsSRMPhu*Dkp9L2YlQ{Mp|0{F9ZK@ehaisM-s4kK zXll7#y{1#21?D6XQ+Fv|+4-=a|uNAm&0s0KTyLRBt z@5fM`XQ9X~1Hox1J zN6iT!_IA4tdyf!32c(TLhr6QUgT^t|hQkxp`%2UkfC8wBaws~%k?b%m=h}66>F~TG*v6(Et0*77A6#u? zj#MTY=NwsfJPRDH%OVKBBhEG6s{gw%r2x? z*|$YP@Z)x|BI#C_WcG<WlzTCPU z4ZQL{58S_N>Fr*7etaKVRSYcrqIK7K5UrEW=AuRA`sJN9{_M*pk|-7PX{E3BT8=0W znS3ns?NmUu(U!e+MYEw@iJ=M>tb}~}@tK&-L{XL$l6)9Bogq5$Sym9^)G@>WHDFPM z`e$jMUpmIC$U@k`sxnnH9X+x}F{U0%v57I6NLk(H`LbGs9$q7Ei^hKzMT_csdE(M= z!3Hs~g`k+op2)gSu2a`5W>u2_85Wyy4TD@}FjOaQS@DX0K#{Q97L;RE*W^wS$K@yC zxnuE0LHOXLs%RCvBGoR5|LTX;6-71gV;9lGRz=wtMPBr^pLFJ-^ztS`Zg5oJHSmB@ zG5%6TsV=J`ka{qzFclpZaC{a(1DZIT%DAqhZi_Fj7}`UfjYF_7e7_ySk5<6eOBG}u zERo{!>bdUf>KfJ*hO{_3%}U5qEQ;GBW0*{qo28LVFe6ykxoTQ(kVdlI$9uiFl*#^` z%1f=*e4H+Vi&Gg3_`6mUDr~n#Wrra+UgNJX;S&LR`*j#160iTdq}UXNh&ylJ{kW4e zjCf}zG05)e`evNKQFGz)x5{PEhx33e1-m#R`bTM{94qTgj9D7$j%(u9&dy|=erOi6 zhijT>zy+Z&tc6_IUU%D%#^g*=mNQ*lr;`3RzYn3-SYkLf@Ntr5BlJZAgrJ?dBLU#A z8V9oRycW-ovzw>5&coNAu_W%+ZWoQdMH=SWr9V)R(+UO6XaNPv2FlZY?z7oTN#KnY zStWoE(vJZ!g1{o9cYVr(&FS|gzr;OdKo5WUx*Cs4u58pzZz(G@T-G^%TFr7!xVtCf|LeQ}%#zZ`SwocJ*q zD=03MQ%NEw2MZf3W9T1xsp&_F`#TowE9Xo$?$1N-R?|zUn!=j3H^BT8q_EMUb6N9(2t$-eJrUb|Z zOm$j&@1NF)UbB9!ae$xxDfuC%O_viq$a%Fh?+U~~l|Bb>WILiCW7UyL7*(II;aK^( zS@K4Mq&1_zSDpw11xn%fRtz- zQozT=KPHAH7_KsD*|XKzV40DnlSMLKx=W_cwdVx&Ei7*Q(+ZMgPhX%xg`Mm{2% zbV{*L$uZ-z`iHFco;T*E%#e5aHaCW9ntZqBqC)FP#q^O*#t<4hAu|<*33%6$IsKoN zmb*_E0XM8fzl26wGi#Vkhz-y@}kA(t0__|7h_PrOW#~D))J89WeVpVTK3vu>kq* zfXzXrQ)=Q}$Z+hAMNn;6e(t33pb%`~TPMIKEPg*673?qJdLYA?xO+d!gL9`AAvykK z=blUP3de962hUu0T+oV_4j063T&dja+WLuc=zr8d8PAd`P}7 z>(0Gq!s0@6rFl*>;>?Z?o51n%kHWaUtt1ymPcEIv|FjikqUWuPT}+!LMio7%lbcp4 ze&D-23!)#eMp(GE;?ECx`m(ehDva||(s%|8oOYZuqmd0gT+M(kkzQQLALmj9gC41hmxfKf?BWVjNCX^zOsZeiGe>$u->a=WMJqHr9 zoxxyWf9gU9vVrI}{kS^9PGYbLJ>$k05=qZ@Xa`c(4zu;6!bNMvAS@V`hJ_Vtb+ zIt~X3cgRei$i&+Ai52|fVos^bsY*~x+|rd+;H#57o#U{*EyBT}W{R9#gEaPKKi?G_xVSKQHtOW$=l74ecM9(BRp@nkTyWnH4+j!s=MGH|IAO27*JK8F0ktPUYj>z%60B6f$*vtGkH9ERL9 zzdo=ewYG(VIzFyFj;P7o*dgj)!09~`fL{N~OFQmd_`cPO$=Xhx8TV<3dtwntUkKiz z4-|!2%M5BHHj{*^C6cD7cl$ENU+ zTa{c(v*s5IgkY}a2xUanY>C(UYK8h5VMiTT5qFP{-|U@*rS6{4>gFF4FDee#6ctdE zk-dR7JMqs5`fq;s3H#r2fZuHS>Zz5?O+Dq-Q9AaY%31u%9_v5Z;{c|%(@&Q4ExXQ( z1(lM^Sd`4OLphWbm2>_j~Z0> z(OfZJS2tQYF~T{S#)O0+^7cwq+-w&Q@PzIoAAx?T$89NtXJ{zw_j@Fn!QUcdcI!4* zz1H8bJ%v_OsDCVQ)aEUpv(LU*S+OU{KHJL1X4NLWIT>=2xC?o`ssDD?zV1H)Tw22b z`+0c%`Nk~ZdK2KUUIcS=1@t;b_?;cv1zZmA`(53CJqEOU{v%7hgAnP7{8dTUBny=k zwwBcx(ZGOlM~U~zP;0`gaW15ZE=n$4cBozA*ljccfp64R=j28(#x3oJ*)3#g&gTZgP^tJ5|%*>f5{%*PJz+S@2#v+P}#75`?k`K4;Vje zK0wsJSg2|!+}(|vSx%j}*3yAEQU+);)31Mgvac{{wFY9oXkbi==jR3ZAl*n73(F%$ zj=!-TWqsV)Bv}3voT@vapO3QKyd@$24S9C7xl4Q(jeEe-?`QaREBQ-&dAS|dW9R1-jf})hbOT67YunbOCqja5Wq;4+ zZvSW5r(J}opf#{xl2YLiI(H%vyw~^Jv8Zgq%A%C4DfG*fwAy-X!=q6#x`N+qDiP7s z7SZp$6GrU&o7lk7{y|D0#cF|W|854LFvFj_o2h-oUp55%fM;{|?d4zfU3>0p7AzX0 zNnpXis0$zkyuMk#OMOi!qr8W|K065of>kxOAcliujfLN}Ec$n`1=b5et3F6Y+zkVA7eKQ3nMXw|;Dex1wGKyW&y5jVB>KyC z;0wpoa^NkI;J%>H(&UNPv11jN9^kH@ZbJDIRkz1k&xk+a=_L}~)HkvEh0lK(kl%tj z<7TThx?dhL{>MJ#e4C+YR5&w33(VNk@CU78mppQQKeuDwZS}J_IyLL)kCxhmy@=C- zCDnIk!3vPygMts7c)L>gYfr8U5i|oXMhL78@s0!FZlv2zNC$5a$kG~}#YQ)PW~_gU z*Ml1_)1z*TWyL8a+J1x|PGWJqKS47P(gYw6>Bh>Kbe!gycD6*t#EL7FfO%bf%iM6S zQH3D*RX@!UfG&uaz!{aR#W?KnCl90P|hv|78dfKul5l= zm-iFz){4APJ9QRbwU1Gf!TQSQ#jG+tscBQRleemBstW8ion0mu&@FZh^-)rbgZ7lF zBbV(yli%Ano*dmo;LwE+xrIMG*CeO8(bH|b#-Q=N>UNUpAEebIn#{5+Gu5;s7#DHkLJprM z5oSpmsIKV`9fgDC}*9$b6djq;ise- zOINc2ey(n8NV{Z zpiH&XYot=|x#IZ%NHwko)Xrk~+X7!JTZ9Q+9C44#J5E8hX%fdIza8G!@4cK)VjK`&F#T)%3VA%8V+fDj_NC)hRk>dawuGsK-;M z{r(6Wu3RK@W$8?r(}OCML+WQ}vD(Fe6*^tNyr#DMBjT#b;OleXGpPxVTt6?Qf{@QK z%lm%Gtt~&>;|;;NuroFg$9V64c#^q6tMt% zfHV-o1=q;p3FxI40N*t;h6z%23{f0&8bg%E<=GThyELr)>o^eVYP9>_2 zn32!X1zb2}^MKM`k79VUIL9W*{%Qs#R;GgoxeSPb(Vg}ZxmniNE=LBYaf>IO^~MU( zm8!{wXoR~s^X%T&dw;&Yj#b~!IZ0S_3Kf;jGnrXf{X8p=RgKYQ%@FdI9;0E1|Bu z;X7}Ck9BpPRdIXu<%kN-JW)jlcsBo#7iYcjzUBVjylJx1NDWzz9(VCp&q2#4y0C~iAgt@{cGBKY5e~9jC0hbA*G|Nl5!e9CvCGkMzy$DII!SNt?yV!&`v9lhcITt@=!rYb&9b zj!#W6v&&Y-A<(M-1LUu%>d>70 zIT+M!tlBTlMBPl{OUT5fnNpe$C-t${8tXBFS=Qsc$SSA3Zll1Tuf{Lj26MFZwx!J1 zDHcz>zF730KcrQiq<5e~WI38RlG0CTf@C+q z02LcZI@`PX7sV^|#EYQb7L9*O>AnA4VNZT{L+KYDcr)>e<|GDI=BFi$>{)3V7(aGY z$8?N8t9{6vpDt=a!~5#`yuKin&qm6hf4u))@K z_m3~|{;R}xBF6+ZOD!l=3V&#{?R%3$=z;k=BngZpnK3b}I!bBS?T3!fg98dr(8SzD zxMPHRg%raC*T@Edn6Ruk%9uuQqyx*fMeAdl42(ue=#71;Af}DJj%v;o-yLpOE6udL zK|skUGwIahQN?Rs)<;u3?C%v;nWp|~0g&?+i)p^G3Hdx4&NppXz1~;f-v*w;1z#Vs zHcYZa6-ftNG7>RDZ;!JU4^Hoq{RbD77#^Ti@(OD~a#kfRCZ@z9rl>n$W}~Z<8~~!B z80kW+Q$5d0$UR45xRa=sd%1V>DJA*c52Rnj1yc$`)?Bg=O{sCHmCWT)nMb659rGNu zSz}aNJ601L`oXmZ^gHR7=P_zI>-w&z+q|8Hkb7dwzj^M-%m}jVIt1{v(^11Id%Me* zfablfAG` zpKqXBiEyh%Jw^T&AYAhQ(R7v#QFUz_zD1DkM!JVi>F(|hrBk{=kdPdP?vW0Gp;NlM zQ$V^K>E_+fhxY?N0GK^{t?N3^1}iiA@Aw{4Fiokw?#fd=f6~5ua)Rt3RD5gvCbje7f&JmRuFB`( zDEf2I1psHbx1g^(%4?4yJk7l`rax-`yU>p0(Y5d# zaa#6T*!bdp8sseI8>MRgkZk5sTS3v->i;F=Dmz`6aPc!h zJnWr(UHP13JSg^Z71UE_GkJfojd_3L95{SM_?b&kLVqD9e7;vseV+xQX7KqO@RJoE z3lfy$1DD*rTY?lL<%ChCaH^&cgE!+J^S%FPz*r$eJ_HkvX4d4mIPL7l z>}xj`_FxS}Z7|4|Uvz8X)i!pKsOmWcUKAkyVo6iw^22Clt;AQ-$W~ZrkBf3WQc$?8 z(^7;-pyD^}d`^Uw8GKb8t|fJFAdqtyApCss95eYa!Pg;SO?$OWB&EB<_;VH`YM-6$ zzDn!~z4P(Hz3k?LkuJ`J1@({dsS$PFc@c1LJn$6OwJdS}h{}&YBkkHFW?+yL{&q*E zN)FXXBwdc$n2l&FY@oV*X}XbB$5i3nk+9$gZLswDMN;HINF3>7R12eBCY=Gj{V8bD zfTy1{#om=|$}^Nyw2s}YvwidEGO-kCtYg{6k7C zqn2CgRvFccDZ+6w8sl4*zOPd9)P}76Up4Uhq11-*HAP{e*iQ+kuj1=o*WV@q@#wHn z<4S66J)QxGnUXn=-O~h>Pl6eiR#!EIR)DK$N;!q;-xh=lQ zw0KWagQu@uS))pDc592$%BkZDu8=a8rB!3#a_Ds80DwLi7_VHh*Kg5GY)d`ADxPI=>KP=wcQHOU;+sn8IDC+7YbI;K>V@u^T zF~K;E+x%3bIaF~xb?@S;NH36}pelPDY?Z)ah1Y~4Pg3%fI ze2Y!oBU;(t9QwR`y}V@W91kKAR?Wl++c7N80(zofoF-3iVqrmL(IbY>JV=%Yk2rj2 z)aep=a)ZuqM`D+RZ+q)o;lVcN!n@Ze(r^J_Iy&rQEUTuRNr5A)Y}|I5*=Q{KGOiN4 zuspKRNH+o%nQQaBMBWIj^$^rK9T~G96k_N!o(6TRjenht{0NB)dgx>nckz#iJfg z64xh7-R+X74d7%vZ)%#F*!4-Oc%U-p_bpe$KdLV_F=aJe*zt~+t^9gQ)^)_{J2urZ z#S~;F=hDnPv%@&?&(aAWGiRy|dG2Z|d&saH4$0{6&z|ND@$Rw;Xlf9I;y4B9*`pMb z@GQOP|Gc!<)OUFoh8kD#Ng~Exm2pkVz|x7$ukUbEIB0xI6rxEe`qe1JPaq>$IL(Yp zo8#tEUFMf?DXVnUC_>bELv?UQ$vZM27wE>1vwivu$}t&e4*M+<4g{X7LP_B-+eFlV zoYG)fSb}WgoTU7g_nqp76t{QBxsU{`av|iG4jg5z;Uy!+6PfLJ-q+!;qTDa|RvJLv z0yF|oGge9NpB^4i)e#b(9?`d*%KW$M~h6CS(W7@W0 zsB5HvBX&-7g9A;D;vPa49xHDB8G?DmuY~81tpe0zQLeiV{L2KBHiAVHKgKF*3BpTN>iI@J{<(2QVbx(gR-7gLpFC!%I?JR`MFtENSLi z{H8Vf6g9@Mnon|c{bzdwUzK`##AF<8Gfl?=Hb)l%L^ zb)0g9wt5J_4r>6~GzO#IQNtTJTADxXEwy1`nBqkuTN)yROn1^HO zpnIAo(DmPx>-B+Z1x09@h%qUk3B|!NF^kd+_v3!k@%h%B=f9UtFReQnh+^4L=-Jms zl1FWYCTX?&Ykp1F6@kLU4cLb2H>b`RnQC~xLKe~mUXG{E?oS>D|2nbPEX*`Xj(;3X zcxl{zeAL_$kG1~ISObdR{&k5~z?~1d`!hZ)lPpWG08+^QhL($;HH({=;hmw;6Wg<~ zWU{*P7;MSVKngbkQloC?ToIGwtc&%a75S@?xXVoQkBrFMe&ePMbbEHYKpzo4%(nS}d8&Ej~ zA;zSSNoJ?U;+9()dgiHv{%TryjOEtJr<6~wtY!XW@NhhShb{%F--}(NX}|6%k=Op6 zA-m=IvFlTpS1XQYd+qo;i6c*l5u(2jXQhKe?4C{JOGrnu=%1YG*|+mv@wYF@dOBT3*Yw(G&Jh&ESVdmX~aBn=e<%315C-G^fy6#!>nOXR9GX^ruo zBsA@82_(3PTTeaeX7&{=Ntx;@L`n>+z`7krU9S>c4|nk6&bmGnD^HXwx^bX^cJ*z@v-CX8#!{NEN2f`YA`>e#;~FoGXuMw z=5ofAg&^N$ETi9Cf)7l3dr9TEl5KWWlKr!ysI7B_E5F}jfvH<8bf2Q7I$3yVq_S6VS z1puphK`-IJNAkDJ&o4^hXMIiU0V*pwg;nKrrL8Mx@L%;)g`4>;enYwMvro_D>+Jc1 zF2VNg8~@^h`W$QWS%Ui4pM-+a_NH;yzFm#KoK=4{O3mUu-TV&6MlM=xN8%UMBiMU; zL?RDW71|pmRvad@=ghL07oZwKU9mk_mgv|iDsV$sEiHoKsHX8d3{jyJ*PU0(D2PEc zd#PqU88qwllg?i@rv1Ck1UJKi-nIar`X(ZHMmX>}GUx5Y29_nTEN+L2(S&H~hzTWw zc$n?X17eBG>A^oRM(F0=sSsz+PrrIr{va0&tMS&A_Yu=tf85Flhnb2#TJ0QKbC z=%~*pk`$LsEueV1Y|$GF2O!a_kxYQyGdF%2yPnWJw zVL2Wea%gop_?@-TJ|mHKTPnI)VSh=R*C1F{YdKMiKvrBe>gEyn_j7;Hy_oNv*XV478l^&xC#kMCP;yg5WE&ykUug4jh=d`eWF_!`r}3_7tI*V zS+P_67oBDVlm90tiMA?qnWlq6zD__8RasguRZAIs%Gh1ap;?$27FNcg`F6E7x=Tej zBfVVvqt{Pq#ag{~@zcnc*a9{bH}Eeg2NBej(ZR*GZ9%&DCB0TmZ*y#ANa?RFD2hnK>yU zxiG(+Pz(jlK$I|3zXGbz&3S7j4LJM8PldGoBzOh)YALbbUSUO%=*5F1@F>!|V+HT{&Te(f|uQpSF1o!SgLg-!LTY+~75o!u5ytL)b8z zRvML`Bj~?hwT!?(TGH}BaLl6`ohrV*yD7hR-jF+MoN-k1;OhWZ_&W-m1;GK@$Mg9I zgt{_w|5k?kgt~dfOjFQIW2m z19Cx+$eqC4Q%tT5F0E)0Kj{39r2TqVUvRvmx*1F3C%|Uv5K&QtNMZcT5927*^l2{Z}XOtX{Arrm|f z4*eylWqGVtsgjH*o{d(&z-~2b8r)kK=g4p=ViF{s;@K z0@kWm&V6rW1=|`Ke;pB9>BJ}5w6;@+V~YXn1}rVgYtw<^AGn(FGs!XvW~gm(&qrb} z(K7_XzkR-|!d38--(81xk@w6wV@M1nTOF!{hS!>p&vpr|Hg~8JcZ;eGS^0&G>N3Y| z;}A*orYQ`!HhiCs&_6%F-W77VEuSO33@trK8SB&l+w9}cXQht&EhUtFmj#u>De1^; ztVH#iWIFTWsUjTJn(+Pr0J4UsnMS~+wW26_gOPO{9r9oven+EY;_B6Cw!p)q!u>;+ zCFmw=-HqQ%+e*rgOvTI=MaoJB*{;|~94VUv@+V)K*-U+aHhZ@};2mvCo)j}36`_N{ zSnBiXx#(aVjon3`Yp$~qijD8<8gA`~@%q|K+N*@R*+EgnJeIc~j2h{OU2qN*F&9tK7R|!y{&;J_J_tSBrRQq=4S=ep{ z3@(hdILAq~$#wV!grrZw_BFX=2m$%^7v*%eX}bt9`PG@eCS13yQtSUVx~0ne2J%j) zCKS)Q{QW58iR!sDIX|}7t0wm_BGcymm~^VJBJu}MlVT#GluR>e2`n{CW<`_szZP>P z7l})Q6IbeHNz4mb!mP3j_5%d=yB{)(*)%}n7&{zp9me8dkCKA;aU3_A$-judroN>A z#~{JKIYGqP143pfwQI4fHzOVJmjJtC81cJ8h2#v_4+g|PK_acwdFB;CEw_=g7x&!= z<^6DC*L|EwrhLqh!R_|-0M49YGu3irgJXKkA1N!1Ee;TR?Dx_Is|ZDQ5ngU1Imjd=cTYPu{D*GC{k{nRgUX+n3z;L z$vX}J;G~qC_*k4mX#h@`Mr~X)km4pjI;!nSp<5<_;qz9d@3oQ2mM9Nk2_JUain3TY zzzmCZdd^&ODL&x1{rUJTjzk^E^fSrE9&IcQ75jk*=yIZk+Lp^v3~78Zi+D+>tvtiM z1IfX-lW-|xo_YW z%t^(;y+FW{M)!@Kd~pL8gu>-Y3MVl7tMIFlcBv&^9+!&7#dc2Mh??k2ve+ADP`8(N z3@a1xs-`RQ6#jM*SzP&WHs^XQ67=fanJ04Uo3f8?s=;gQoinJR?(K&&S#D0SR;yOw==#Fm^i&>DAw}n|5W&mT+G4n`maiv3P zEaOs)Nr#_;a`t?FH*tSDZtu<#D-6Fb9w#b_Gd%DB^s_r6m}8`uQ3cR@;PhA2un_F? z-=*WpLY{D|0)4tit2(#$j!Ic;1$WVhVTObJJ@fYN3ca?+P5)Y57Cxnbi=8vd zF&mts=;lAJf4tMpCEE3)KFsQmAp4VS4RLrdny9M?#J1)d&(4iyWsuTh_@|EkzG&5= zv@{q`mg!w-a`w5}V^stx9=q71=stim4?+cG!!<&FP%%spxc7LRx=jRg;}s#~AP=j3 z(=J_cY%&4@urA9}K3W6v zD@Bz+FQYFxJRe4suV3wi!Jyh3$>;S*u7}M3g$~A|6mF%qP8P;(Mt0>(W8sWru~?uH zM%mO;oPqnE3x}QT>w3bFaC`HYy7c!^2mYkUdIF5RoM3+DNwM;Jn4cRx8clne2CU(- zw%#zI9rH)PX^_R1w&B^yBQ$NdW!QEFv>ZC%vO`}6^50xZN%w59n;md^bwEq zU+)kp7$$_mKki)#0MfN|zCI$_m4p=j=F?;mm()rMWU46ld^fZLB&`o(8zg4>L>7$Y z(fw||K}vi-Xu?^BmP+@@ENF2uba?IH_;y*?$<9kW<*EFA_y6)70_=4T`Q0VM(srgD zlY}~|J>jAuUdGZ7n7!ZQ%x7b8Tg3+C2}LZ3ETe^2pJNWIJ@2^gs5o*a4~qvR4q2{> z&E|Qozsjv&qlMaZu8&^lxfOD*J{`rCKuG;yx&Xn(@f`hxQq?`VsROR@c{e z(DN+$0fXNs9Ezcoo_9AF_HNa2W?j!Qm=w=k3`?A#Tt?|o!)8tXxgmwTQipH}kBFz) zsNT|ko23RzE-L}#typ-&N3)GvFSW>orGO8n#+_FWiLT)K5>+@73(7uVc1vKv8#lq{ zn2L&0(7a^oE|?9Zrsk}=-8czx|DHld_*-V9^wz&ko;_xkF_xmpUA)(GuDaif0k&$F ztbDDh9jDWv%eA_Feuw7Owadrxk8JE!k(^0MiR`@LfKue;mNnuf_%2&4uR4{(gXpL4 z{l+`B98sA(jpct2>w&#NuWD}@i&a(h9oIkMsw^9pu?D+h&N~@AMARlG1)Q23tGwEL zZW12?2FgbluUDgTUY>2*zFnnaioGIPk+ry3irC>Nd^B74Ji$bS48Es)%9-+C)*8LF z9=-Kb;*L#|4#a%`YL0`LVgZBpqH=@sm#=}>#1{FLOl5|*j#S}?1CAQB1a$(OA5>4@ z$pxY2SAX^l5&9^dVS_cnD z#lO$0;~j@3h>yGu^;?gtiN1c%dAZig77pkN(B-`S9|<41p;~<`E2Or5F2$l9o8cb^ z23laBGDiUs{qMoT3h1Pb*6KucI(s@Vy53^b^SpE5=rP~oSQf$$_c3O<(syt_YT}c= z+YKZLBUok{NG)LHSK|-l4eHYbGnX4w@B#c7f-Ab5w^vLkM6Tzcv|LlPNu#BF+^>HY zb8WvJQ*;yfDJ-?`xPNy3xB8z1ETYKW{N~uGtOY7OZ7$WO@9cAVPqq3_9O?bHMYlia zz84$8^168SgQ*ewm{ZG_H{N0wTm8VV*oBX<1L_x*MhmxC$*Z8UliGi;*ZO|(iEQ|L zh2rgLlm&xsX&G=MqydMXj0_);@*A-u7yMa;GI!fPR=!72p=zFvXO#k5(&5RU%Upqm zteU3WuUi@|eiM+@keb5DGG~_c*!~#C%^etdudDVY53fjcU=CiBxTcBf z`Zw@-f8n4~;2j}A6XguM{v4T$<9bjEHCxlhqUJ=2O<)|T$!DsWSaYWtsTEIRGy#<( z6mSmU&{L|UW1M>GME7$cUl*3yLz(3T)NsQRBS~dPYLo5KdHMbK8#rvg4q3V-BZqxq zvlJ<+_@1Jkk=%Q|+KQ?n*i*>QE33kOrA&>BYgyE+r9GOb@JhB1e$L2Hs4Y}b918T- zBrlhl>A{nXvGfz;0*hQdKBWt|`)JcZ)4V|zL6H{KP+l^{@7ESql<9L-bTE?dN6k6u}{Rk7axi$zUHwS{`ZIL04N0$w;sZ*>!3xB=;~~5<>3ZKOh#Ep(z|$>fzwd%M0sI^JZPN81 zYnXUey#Q!qWONazSqXi*iY^~ze!bx9+r?pf`A*k8?nS4s5gFnsism*V-*1}Y}FzZKAHUss$xdB54ud}}gzxdm1W ze8#PGZn}3ZoGRjoMdedb1}dmGXtBMR!BmJneZuTznr@f?{u*-n8ojjl?#Fysa`o~M zL{J{3#gWNREML2r!cbmgE>4O;mhsqNf*BcvT=zlD<5#lp<2^R!#N>THd*NQaFRu?}?m{&-88B zjA8HCYCR9kWpa2h@54^qunDC&D5i|_FyhuR*%%3NY7tSM@qoJXsJs{0ei8Q;)<{8T zUwi5D{v6b6-A=#LXU-{AkPa+Y`k_}0ag1s1IN{~xtW}*)+0LEM(IX_VL|wUo**Szd zUj&eOJ>c;2@~F#Z%BUUv8pq%^!K2bU-}=#)Gug=;yB^#wuiEi=^bw{3t+Ga=iVtl$ zUkVX7dHgf0_B}a$H?_DSA*(p;XECsP;x7-NS23g2YWBxn=TL^PFT;DbQoXMM&|&fQ z1&-E4L)Sf`suxS3|P=|*Kj=X+ks2Oz?y|9++#u^F!3RX&;JLdU)+4BO1> z;4ct>XI0mU-6!8g3FM{ZS2{eL`6>8DP>#bD?br~9Z<1>loKIcvfZ~f~*a~wBIIl8|NcLR@vK8PuPyR6)d@7GQr_#TsBU+c2=!gi`{FeZT7#$*)|Zmql7 z{>-O6;#17|ItPkFVpR)-V0=y;i_Y{IJki^GwL$LX00o@BV0^}d!G#EBW9T#EvKZ;2 zZA#bab7WO@$%`2?D{1J>N{j$kbITc5#|&P40UPTWfp5&s*WP-1wm|hspMaL<#WqsH z=}FT=6HJxcAhV=whoCv{KM5<jW_8E0)H+l6x#Bp}z(flVav)c8!N_gKhtNe~ zzB5M-8cnoO%TX8V4fGGix274aEOE34+9hL-9asX-^9@7D+J!FR^KIRX>P)jdbXHWJ zp{@r4jXzIwDcp(V3kU+t9Z#=_$zB1M|Kf=K;-=_|JdVqv=iOMVqp>(gqF+kO^efUl zq}0X|^4aWkm9j;xdKFOrKMN4pw-k!%vFt`F}vd1=RmSnK*L6>n?PSHWp z&t?KSb!)H^#35uGUOPeTkUs}Io0*`IkeC>E-D7+iD+NK^g!L-S;E1^Fi=Anj#wMeV zpnvH9#Zica5e-qP+p2(ZL^%bys!+*I9rY(jficj_z8e2JjCc@(yGTOp;hsh}3xB~N zyhE-?n3tV)EJJI{u`aJnDY|D1akKkPtn<;qwDb2n9$g~>6_u}ex@uT)hp3gYJt>fu z)Y4htFtg1#aWPDuH)tNoq^AIagh(dH&o|?U%8Pml_Li|DDrv zB|xjLu#G0jpjhC#Fy+l)em%C=pxvNp=`9@34NFxjtNqg1T6AtGc>$QBz%6AFUh%OWTU=Pm)SijA*?c_rv@LLoG^`@@5c6&V9c(by(`{EPTth^ zAmibOr9=*tD3%Cp3$B5(L%L(eEWmgoQ);+iS;XHca!R!HQ}FO1l@7&>YKO5YU1+?x z%jWV$N(4SmH*!l?#Y_lq+TUa1z)sG-{x8cm&rj?>5g8aZ*-o9kO{`XCcA4R~K0q%n zUK7X*xVXN4-~Kmb)|sQLX`Yl!n1Ta;?6Cr-%EQNLp3jX9;B!;Wt+!;sNmNrO;Q$D! zjUS2V-y5LSj+CMHTK~>v`WabVj3x(`C?>?6;E`5HEIB-<+V68~Ajr8j2Qe$tKp_Xa zvL)xapNRnwouy>)dv&nn^_VyNG-I|`@Y;Whzr2a*eCE@aPB9r-&3+5V_O{<~{k|;t z-ckQI_gnloABqpj)Awe{gb&wn6Y_NmYQgQTM<2Dk@)$>u_33|+ILOEr)xqGTHJFG= zOq8`!O1}cO%r%}lt9MC>cWifC5!hl79?#HeU_K~shEAA;Zgv8KQT2;+lLfkg@8hQ$ zDQSGRp!heit*tGn)}q^y(Xv(?CIIW>c80&sucwl!(J&QmPJd;iyI%5o-|w+~zMML{ z6QsVJ2WyvWFQa{*6Nm(D2~>P$4mYFSQP$AKQ=Mz#WFG6hzu!vp(hN^+$R*U^xbNDK zlVukRxX7+N{@t+@Jr0tWOCmBD`?xU5yDN>~`aYtN)|0;?1xl1sOeSltdC!==hb1zB z?;|Fux`TBdYO+A^_rxpU=>;?3;il>N*7>!o_1MVz3Sq%salg5lKdD!K^FpHQW#Bgm z-qrjfVP#dKjHg%LU=i8^@zyh9TQ~W)cgb3^oj{bRjjwF2n+8>tt8CH(_YS442TtyP z{x*3o`j&XS0;%eF3D;UQ16zE`u}JQ=RazZVa=V7xY?@W6blz2`U0nv)bR}gD3u-xT zEp0nTN15Y$A?HCp{Z)ZCA9asWMPHV3rth+)RuYO}?0!SFc+y3mxWW~p9?UsoY0$0c zHWNCI^_@NmKi$(9tNva4>+2=2medh@umw(@DDD*1`jfI5?u{6x|EB4ynPKXVy z*w#&J*Vp5-6mH3}w?CH_^IWqs z*{Cukl(XofW{dhNYv`-W<=OIj$`}w3m6xJ0Xx9??USCj6%Rx$j5DHfoZy#0^a*NlF z2Y*evUh)q!f%3yvj2JqbAM>@7uuS5nCy^2hwWUb^c1C6=r#MZTF}Ro+McG>w8pNXX z50~2WS*&|#fHh*Ji8icHZ_@f&^m6Yg)#>_Aeit6K6$yi$ugR!W(6xlUqgJbA!oQdA zHIIRsli8%&yLaZvVW;7)g=I`-Eg`UGzdMZb z!b*qY_@Cf_{=U6$SfAc_mc0!_G6agAI@+?G^6idXOG>4xk}c4-Hg%UbULxzFi<5aH zGciV|5eGPxztBf$e4uzKe2&$!rc__N;i2Np@#aTXFSmwGg`NPAo%|S^%?hQ|%Vvn9aCh~hpEMDR zzx0S7LO~BRgHE7l;Jx?UOi!WvG0h_bs%0)JzKyWHCbvQzNLL50fRgs{5G{XdD;Zsm z$1d{@agcy5V};DGLLMuV1kJ5S>j-y9-8k{GzG{h=;SU8-J8%>h18X(GFc?#!Cr|-i zT9i&w`R+L0b)@4*di8=~4+mHHyRUdftc=l#fnY|U`tSuR(=RRXZdWSWe7cM@bIgs? z!WMCv@q3s(z4CS5F>wo|)`Pl(FI7uyBgv-}bwAAiwEaXeLcCRM^FO|Kj<>5(oYqYH z9IB#`5gi2|{ZdsFT;1k$hIdz(&05vUCRVY0+}%e{Yxd`EZ9U^_G8QB|M>Ccj=@;l& z2AwAF%Pbs)&^U6K%d7{2Ugtjp`)OxnMYAJ;GNkmffvk`jf`GeA-g1M`fvKCVV}R8S z;k3Elm|m_CyKM`&^52_>#vs}dwz4wWHuCv*ydL?pt)JZQ9TR@vey-~rwf644 zbs3#s(Su)i=O?cj_%bw>B^F+=cNH$`cRQGx%T;F`O!2<**Zq>%Ly2(EW7yj<`zs9~ zGbfX}ZYHWm8JO6Pd+iwY`FsA(_9$`o-_ZCt?|@ylh`%f!Mjxrc*VJn%IfFE`?WmW3 zl&!Oc{HLmOp0V7iFSn^qq%z!p$n`69`HPlvAit7-{p`le#1!?5%Xe$@`&>h(m^y5ayF zDx}QF>RNWp>txj+hcMpWDXqCnu5klSW|FcQ>~QQH;guKGx+Sp1V$I50;(8l>SXY5u z9RCUou-%ka?6A0`vsjETIflDKW^0PR0*232F2mTVvpAdyO_EqE-7(h|$=R8^?UzU& zu!Pgjf{SaQthywPgBqN@B9(beV!qq`&al7~glu&KS!%TR250_etawGsU?IIHK^+>N zkoB?|*LEwJOTm>&!Kh6A1FpVb&<+Q@O_4NVsH9$Tyd$H-2k{l5v5Tcg?dxYu96<|= zuPLw7%u~#${YC#NsK?-k=i{1^sUE(fQHvJ4iFuKJ5H6{%uHH;BRlT? z-jJ+Al~&L#U`JvMT5hU2=Rle+ z{%V9#f(z)mH*OzgIU*G=Jb>}dFWPsR?gYm(*W#sRDCZ)p8?G8SWlvg4+Q3zdF_E5L z#$R}NSd2M8e8FL$+@Y*&%ZnZ1S=3(nfZy0uYn~gjEw91nwk(64Qf#2u`3=qcCZ#KI z{c7#X{q;mGD2y{B{e$T9J54%{<@>+qBhID3QVX9HRo^w5bYw|M-vR5 z1}TPj@jG}RhtU|q?1(JZD+2`+JePw%9j*C51Ga&TZ$%_#H+qy$@1)9$MeG@=-Dl$W zw~2>&ix$u{sl`t9>gCa@5R=VsenKKO|D)Y^VpJ9}WqtkdD&vnyYWFr)-OlWR0FNRd zcCr8~rA@A64CW*~5s$M^_>oD^#oxczQ8!faZhN5BY5!&%UurR5LF-LOQ~!{CANes} z%iNUjo?}BwO$aHvhKHMJ|ThGg9vUhJ9h0|3-QXPKNlbN2Y~V}w|Khou&Z zCGsi5zdJs&?cL~ZBG13sdA!G(g&H6y4}?wdCTdJ4N)-nKgJPIbYc(AwCW#VHo>BD7 z8uCsd9wkG6&c7?qYX1+~xpHcjs7z~+q#x@^m$eIa0({qZ*;F4q#+qkbUT(?0iYb?V zHj|n>5@=6r(AP-$r9khRCJPbNA~IkfgHbUnnXyb;sSe`S-JoQlSE?7@o)MHp3QS|- zK%kR~)>bMSd@M)NXLB>!=rR2voQm%YDBvuy~=!qh!abN{B;R*Z=ZLQp7<58`0M7Q&nZQwhBgxG9KyV_Q~L& z6{|I^0)g?39pHY3p&Ygo#>Y0&^2YuOZDxw@QT)S=!XjPTdM%opQus@QD|k+`X55**eh`yorkET~E4o4DLg0J3<1~K&*U4U6KaneCV>jWbAE(Byd_)brIZWR9o zxFt=S*wA@2n34YXZT(GGu^8J8f4UHl{vlD8n3=|hhQ4>|cGlEzhepdz8P0tne@gNQ zH5-;Pr;+rRUIvC!f}F0t%!TYghr2cSy@vE2)q4DcdT3eS7zQukU^Dsm;Dfxc?EzRpK1^}W$cW|XPkP7 zTYWMM>Pg0LiYTBxKSmZzl0gETCv)D?I|!r&`3{JXr%?UVT3F1Pp%uvHxt^kG9~Jtk zHhp75gZEm0`DV3f*3kc zdRUTc^e2w2`NH%aYm)ARklxp!KbY4AB{1NRy&0Y8J0CAeYgwaXXOI#vt6)K};M%%c zYmk!%?$ySBC)0?a@iDo4sxtF7%WX!xVE8{`tdtH z!BxPTIv=-N2od$DL2uC0`g2Ioi`c8u>!H}w;Pdl-&gIhj11H7nft2X;2JYJ1!TS!s ze>kutttMWJIwSGKIleRm_MIHHs_Dw@tB))7><9Okhh(F7`02cE42> zGhikr?p-f%y9sS@2Zkth>!w%DjR7|+pRevu&k<~-deX+;~z zBD9z<-U16x{RH@nl*Rlm`SWR#fzibC=KIuR1YHIv=c+%aP70=8vfYR%Hor!r|3zj=(s5a9_2K=)9k%o{Ki^lKAE54=}(o|8xC0=e=DXC zR{}tJw^-NIp^GCI*?me&d%ijEFmL=b#LxO+1gbwbFKw5|j`Te3LkIGTVMh1VQfoDc zk*$MH`glL20+$kX{?Ug}cd8P6$b(z37l9Ez4p$70xyLN)N}NdVpIT_jeV&!>0%@bs zfYX-~A-0K6W0`O%a>jOc*6z!VQp6Dp7(cqed!A96F7EzHs$Zb}#Q%Z{@GLM$9G62bZgA_nBm9^#|?9;WIpYt8~- z!elwPh$*sQs~&D~?0a(?9ghwqV+S;KceQzwQ!o|HU`f-C=bVP{X%W2`1vn^q^}{NC z3K7lcmTE9`0qQ)B)AUIKmVMNoso4g9;9&a|pSwgq`A68vqbhI-HbWhj!kaLk##_ka zqP|C>d734+*g**J)~{YrH$)yE&cPivD5wRpCtM1be>orJse6Cgb4zWbEQ}k67z`vP z!uYxE{klJ9mYEY7mOc~>1$<%%|K14c(djwOc2lkGz!Gb03_mqPG}N3NZ0z;Vz`A#( zEfQ+<^$iM5{+4xvm;#bARAVtVmB}l@Oql~OOKj{#lKq!{q;!@MRj@`D#7K(v+p zubE}jaU8KO=dwFu(&uUmSaP0W2Hf;7-j_EC`&`H;mg>zsK-n37sStczPb!JaIFHlz z?A~*fF+&5uNvq84=gm`!pu_J;zijXUB&~Ixyh31!Y;T(rV>AFMV3tIJO)QXJLawgR z&pY3sO?rHnZ$JCI{KwNizjkfjb`?bICl7paEB1l_V3V7(L=JHM*FhLyeKD&^w?L7) zcwf>Rys~0sJ~s1Hh5FD%G5Pnje@L=-VR1S=u|}$vE1bt%QV+M5zTB>2;|go*%Ez)9 zr2mFUBydL;;|nQwrB7tm@{+e)gn?a6X|Z)gZ<1u;)z2^`!l=qqqGjAH%$&=EO@UB~ zQfqFELC9>n0O>98phovZ@pT(wAeJU#w8K>QJVU+0VK}2VA@hDzh!>!Fv?+8}`cYdB zde$Az<6mWcrDOu+aXfX=WlRU*T|~0RUOT`}b07oR2|FF1M3cT$e0J_vRL8Gmvrk4? z;a&VgD)JHF36fLVT!Baac4fGRq;HKg(ZDy#CsWdO!5K^%lk36_eO5yLg2On(jE?$u z4pwMtMAJ-e9flWQ>bmy6t0ZnUF66ri^%vTI=$;8~evOzwwGyZieqiAAH=Rw~U< z2JzVzYhN>lv8DXVl;xQmnv+!#u`fcmyWV19NV2fh&{L*BgQdQH6T+yyqF0SN@8iF{ z2PJ9pg?O4w@-bR59utRB4BHtV?nrZIDY#4-h`Y9~Y?hH!uvo;m*snCgbeaEKZfwW= z?spD~$!t8=Soo_3mroe84UD8l!j%1m6}rX|d-&r+N`#P$h2Xmv4IOHnsL^Gy7yd-S z7FDX5xQDZMUT8d~YRjq{B~{S8=!hi2sc4}R$Rzv<73y}}!;L&9eCmQy1`C$!>v1h| zbhsD=@P{jytOF@%+v0p^^{YeXy2CsIHp&|2jtr(DSce5R*BQcj6Yjcr1NlEMuG;T% zaiq>cX;)9@3nDY~B&vfDEUt;6{qpJ$4tb2M3JMXgF8p7h#*PgmP>4u`)Fc+Gj6rm@ zb!IkdlsXAXNoC4(kb#@0=MMk`yU;lX`V!kMfSf<{%HihjPZNyMB@la;*a4l~_b>sD zw_ivLlhTr^;~I2vFtm`6ZE-px&vltNzp_7x3Y;ngHBlCi3Wp5NBIJ7=K21b ze&)V?k4Yg)Unnl{`CqTM^Zn{cLJy@A~Q_hakmU$CW%LoXs>?rA$ZyDJ`Yd0=e=}KD=E=qs(}eN80ghc9*7Ly4pjwReWda; zKpnvj@rdDzp)>4uZ7QfHKsOIQ797ckV*P~pau>i501!#qdTsmfJZBlq7E|^mm|hE62&&4tv$UvuGtPN%I1I z+ar4KIsXNgZR&&1WCK|21<2xnkMKwfo+QCcnvNpQga9*fm0f8osT%8qz(P4)ok1*x z5CC%k2nsyoU?S?l)$IO&fx417yQ63zS43piD)e9K%cl56FkWH8#>&~F4y)ZN{2DMt_vg~Bq(7WSOsc0G+|(fql8-ikF-zJin9U3l$_ zin)eBlWBi*dB(42g?7 zsA%S{VYLg6E`TwKotly&Q`nRnJ5+dDQ0}R~^ zInv#oN`oMsQqnbacX!FqE!_-p(lp=RJ<^KQKSc>{)xQ&$_Pj)Dhy-|yx(c%%m&7n;S^a+2sn*6!-<>}=|o6xF!Y7v_v ztsLn@S0--pE2J8tkLPLu=iF-4&>}Xrcxus~-mA0MA_14rTB|*~3)xG9%NNJLwTj|P zN`Pe|DYC5UFvUt{Ew;<&0my{iCzPLds~HFnySxfJ&MbQ_j8Am=1+L1vvmQ9u31YB# z0?e=fHOe}N4A0$Amg^43j*~cmcM;Z$pK>f3jL&|JSscWGhJ~r1KK<9%Y1!GV1o-3| z`r$5nfA>LqlaNdIzjpmarD1TQvW*E_+@XX?5a`{O=r3oej?qQ9s>}?7S6o`6!rFJ43$t~j zMYD*mby0Jf;z&r&8j9~GaBJPT?=6bg{lQf8);ePMeS69OWdZ8lD84LtC=X2DqDm zmNaL#VW52U%5wxV^`DB&{C~GTgQRj=f=yGBxA^EEEMR=!zvyV`5>6AgDNntl)r9!O zPX=Cu$WfK=hU%tNdOzm)toXUK6>RYiN?x8);SY~`NWds@W-)D73$-69rT!Rj&AcklV=WTQx?o)`Ls zx1~_ehDVue(j{w>MyIjGZ?OzP_a{GGTFp8)kP-p0Rr*K&v7NpzcV-v9=EkrI zsjC?ukHw&IFq%0<&}<8R+1L!XI`$G7hbK@Rkm$3g)eyadDINo*n2sGFP8UECrO+VW z`>9dHwQ(g0>AzIbN1gDUKtHt4z~JjimPb-uq|#>)R2xi zYAw%OZE%tXQv4a+Dmf3x+{w+I|Ymv*Lz(F{_V=D8ck@&lYvc!&YZR)HaOxuG! zUx(mJ8o?jQWnRO>=JXm4Rf}VSeP7JJLxqgx^P0q0IsHOuU;HObD_CDI-LCMy$5*i5 z?!o3kA?pykspqhJhuUb1bstc`Y>%g)$*9GEXGhHLp@RosKp3)XwUeA(3iT zr{Urslj)Q%Xae&lBRR*Bj##2B*nvfTQrC3kbAxm-$})b~*5}&9ttH=CeG*oJZkiX< zl&~BFL$l|-+Q#?;yB`SrdA=S0QEc)W1PAbPPeo(WZpo3ZM7tN)3zwanPm0G3QBO~q z(`Q20uOleg5=FGpm2VbQjz_~Q;Qbo7DLW8M_u>&bnf^~o5*cw)@i|SBgkmkOaX*Lm43ObclGHAr3LM{vvej$HT4zB$jUTY-tvQyC8?g-%SMdRan1*oT`num8d3Jg20sd2f(r}t8eST3B z1Nf=12H5G+Xy_|iaKi(kSPXa`S~0|nXskv*DAF6|A&Nog)cTRFej&D(;nFGtBjlCuw^68kQPFm*Lt0c0t)Isr~ zwM2T-ER7|d6JbzBNgb;>X44m?4QAEONgyL(vUJ-e!eJtzk>>MM-WVW#`HEIiPB~?w zG(lb|b5n;QGnH4pUVPeTM z_=zSyMN?b{mjsbbRehY0Qp_UtAyRTQ-I@`2FN{pJp8B(@@D$yR25g6vN;FX@ zkTu|fFmL_<0vX_;;eMZ}&cUbTK3ETd*8ynnR)@Gb!&TXn0(cFV>U77xYbKLNVvE7g zn*ICxaF?`oUn}DSXr%YNp#t%L){7E|rd(C#`(B`c( zi5zCs*8RVS$Lzodr`vr_=s~UEsYTPl7yzI5@JSck@*U(1I8*BRdY|O@k69}?X@>z> z%^>CRpBxkbV9X3hdhwv#@8;F5;SazBel`_4Gy296PD3>3=pfNaV(b5bWN174(LS+R zEzIPYoDV;>dLMP)+%0{mIF8!1t zt1UY|Js&!!DRKYn?$1#@shh)Y;Suvh^w!-rHkYnvniO=V>7D#N(GQpC+LRNNGP_Uh z1Q3-q4(>%4PtU#s>w&Xn`~z?DrrH1A1I|q2dhgxZ*1Pi~8^7y)i?j*1DC9c6FZ=QV zKo^*rDSFP#B+P?@)$Pq+*D=>-hv9;UV%WM)@P?+2sL6RgeY9iw|*Ao+E%kO4nXD zhA6foDVOk5%tG{%AbDPQmvu(hv37OzQ8sxBf6m7ot#tmz{4>CXf*)Z9B!js0A-@S? z8?<%87#r4%-Flh;Nx(oL;(VGgAjA7{k1+6z`Z-!H;0l~QkXVGX;Hp88B8x#*-nS>I z&KiZyKF*Uo#!x#>sFUY_e4yaBV6ufTN#GSHw!*0vWij`~NIG95m8V%je7gp}#ha=y zK1A6Vrg=xhcqET3&NIdPFpx-ql8_XM!vHl-{JyG50O;dLr&HUCEOXu{+MleqD?uYk zCWzvE#>vWZ?m@)GTqG$Pu3(w=ihY>ttzBB9D@BPjf(DfSE+K^>b`ll*^Pz_+PdZ?w z=x_iA$2;GRM%q<1ghj@~&2E6?v_>kt$ zT~|Msz>83qGVQPn&=M~Gq^>=!X{eE7RQ$U$?x&RvK@l!#Y!%p#T3A*Mzi1(8RU~CbS#2p zBBzl;VsF5qOJD`26ENZeWGfkGQ5dmqJi3lY(Z8P9Ux7*oxh~6_q;RiNK_eSPHde;& z9t{WB0q4G=_ty`8_jiY|UHJ{Z+m&Q<>C(ZKyI`+PpJcln@3TkJ2+Z9!h>@Fz&-B6q z%4yF7m7Aid&wXh26p@Y0ol2znY~;2lAIi*sv1me?g9Zb4`=l`oS!H(Khq)01vKL2c z0aGh~U_(Pf_4R^}k9xg*1S)a93r!PgD+mWc-xS4~rFWWHAW<3gtS09>%_$UR19?<} z1DefQhK){5bf}upj?QrC?jGp~DOBzeqSd0LU-!eHMJ@0A=%auC!M)+RAO56JrabG^ z4CRWGr!8o(h9qQA%5Y+T2qp0c*QL7&sv<|44Fbr>JKp^{v$%c`n^-`iru*oBSL&xK zL+csqaD}EJzGg;HcePBpe9~&WtDm3ia}H>xN~BLk{o}noOr?JrRO=^X3Ooe zbs2eN6h0g}8cv`%x?|ZyX_s#A9K&2FR;Wb$%=O!vn84pJA0pcQN_Tgn@VY&*5rNUl==CbX8gdYg7kIM)_;< zWbYIU>Ex|9pU6fg@o{>a_|wb?)^r6iF$aK+R!%L#fZb{}VMj21H^YDE3-|;kzcWLb zd9QJ7bTP>_uBcHKvH#`pFK7yxnvRySOo8JWUgO9q;iG1?k(|WP-269b7BwhNKSC`k zz20tPj`y2Wa!&oz-HAyYjF9 zGBngWkZCNuk?^d`IoM?Y{wOxE;z6 zjNj_9T}t57)e)D3g%G^(PB#?YPb>twTf=2UvKY|>g{Sd%r~8#vSv?{%DRC~4BJCn~ zPzxKc{}=NuO3+JJr6btgke;JVfrRi&W5Sg-?S|_bMmfluas@0Ea4biIE`eP!k;c3! zKCXzCFr5nPCb+F*8dijrX~Z_Z=C zv05m|1(gjB-3Nyvb2?o7YN=vTrM)i2Hyh$pYb};7{UO(24*6oY3L1bE!iESz{##Kt z9W~z9_k>cBzlwlUB5q~EuLpX!aA*OaZcJ}|)!=EmtKZT7J_<3h{iCR4mI0^z=ELHe za>#KgH8fxtg3z30(&uM|srub+IPH!k3Z87>q69Yn++K5Xa|w9Mtu8cj`uMDN+vgM* ziA~@8c&l~Y86q9^S;Z)oq&BiWtC_=Vi5mmUeJ_ zIrtNtbBq|yc_XUELsk_XedYSzHqK<^`rxgY3IWE6F?!zB{)LTb;4>_M7L~d?wl(TJ;m`Ngv)KR0`G=j6u>*f9QG{TPPT{L_r1_9l*c9YUt;t{UF zsF^3F!y^e_uQkl1dA}3m>ZJh<-QAHAA&QckKfri%j@ehOU%_@`QL)tx&u-5wg41!We=Cj`wXqvYwXl}L zd@*T%x&>z(%k zHX_qIL#&ZGiRbu1Vz?(v3S99{$%u%AP=DdQu2iQ(M%TBB=|%gdps%x) z4P+x0Mdl;#V`*x$6ts4X*$iaPUsk8x#sMoqH1y|~QDCKLO=q~l6aBxqfCPslip8Cr zRFfmFb)t}ILfD1${AgGpoHMtH!%cPVXav`SV#1Twd&SQa8Op5&R4m*)IVAVQ^HXW- zC8e2=JD*IE(}do1SK1%Abg(0j8W6H;?ejTsvK@pD_=pdd;IU9uMT$d-dG~E9jUtKqZ4qP zKDTMM%ny&aHZPb z`(#Re`j-cmZDP&na(0byp$RqcY#ENqni-)eWZIo{$=my>7u~w`HAcjX<8He6M!!Cd zK((PlX&jFC_$gt!!5u~KkoZ5VC|dZMUTOOwBd6Y}7#p?rfTw8Gn^V`G z&$d)OeW!jeZyZg<2mXwpJi*n%B}FR63|>qz!tSY1sO5K9mT>KV%?f9#b{4mzw8r?0icd%1~ar>=_sF#)F-! z$b~{(SZ_t9j|+oW7)<(fpq6lyv7B~KJI}UsnE$P$FuA%k8h0PBH}izC!9s+1m5eV69WjbfWVRp`{5Ng z2u9bwGvqs zsMgHU;z^c#PB%WqatFQ<)B@S-_4#G3^th{{VWBBcubOJJOqrx?s?*YIS1co+ zBjR4l5Xdl`L3oQ1VrwoRB(r8swx~7$Dy@u5&dp!1ok{o*hwu%HyRB!%j(|C$w_$`pLw55aHNRwkU~yu z1LT$|A9i0KDf$Jwkb$d#!Lj91wj|F=H}($QDAHf#jKIrJXBx>mU9Y*%TB||xZ0oCL z6wZri_5Nh=B6VqW>2~$58|F8NkAV9}go~^cQ!tyobA!sBasnt{iuqn871c2V68UX3 z#Rg$0v5vFmt>2lU-kzeNBzJfnv50yLgrbwmilMZ!j+}#Idd0Ez)~=)q|h8iahZ z)vKnC0aZ)DBg1ti{W+%h(e>$E=;$gK#|99}s~DZF*z}q;wjWFhp5V?6?!!Y{Pa5KQ zfj{}1=l$MCx1Prxpvx5Cx@Hy~54HJ^v7wG3)PJ3i6+;iccA}qO+b;SsX>O7a_816# zAl1{mv0VeLZRE|Onj=;7+r*@8J@rLkKIKha8?v#!^?aZNOo^g_{mCOA=NFS`1J+M8 zz_{JzB2@ahxwF`Bz{EJ`nJmggRCjhj8Y4?aYK`OjV#Ah$9ndO04IGU)?VULDw(M-T zhEPE~QH79ekhM~3XKsh>N(}h^^O)j72eZC@=%Kfp;FBG8Ie=gS*6<{sJfIMHDFSp6Oum20$T9$g1EZ*OD$2lELs)j%#@aNj$UUOFQXZH4$2kU zfd}b8m4GEc-O= z&v@|6vM3oF@VxyMp#a>a@Jux;N<+1TRJ4p<&tN7q=o1PVgCfPI)OciLH|IGFl{IE# z-#k%dm>>A$OPergVmO%g{)~U_!@lbSP7n~$fa$H59sC2K+4mOL9jFJDa^<1(WXUl{ z{VS8V#IMtq12Fq0{`_uY^^l=mRO2*tIK-&IW7WiL#2Gj5(5bVpjgoH_yvr<0bnLJr zZ+XZ~z|NJ%AE6=c!cMXYpzAPTjg3km6!YK0EiPx<_`6Sb(T*z*GiVl%lUnQ<%n?lJ zUKajXg8O>e`}ba1jU1Z9=0FA>t&7sA76y#pz%2>d+CO&x-$TvEB%3E>3&l|sqg29S zf}-Mc^IiOJspG^i;8K+yt=uKzqJP8<`&_D!qkqL+yoRj9W;mQaz}&L#1Fd9d5u2s5 zld)0Z9o}hmhlgCW3G=_-`g0-jDP~WUFLY!H?=uiLY`{B(@Z97lm zkVV|!vy5qruyE;&?nX`U{HXQ*4J;a@-IKk?}Hu>@3+G!)EjA zAfbK&q$e(G!ZLi^Z`kK_mhC-Ls17=d`n!%^FH1}HK976c(^*E?<@rqF505cy_rEKS zvH}A4HWw&Qj7{e#0hG;iiu4b{xQ@DtH9(0eqholo)m?CUE&6=V$^jeH6RtKeHU3xq z(Qnd8{E00@$ub2m?dWlbE!n~P*vC!;}D%Unve>3)6bn1(t3KZ@ia1^Tn?emG z0JNGiW$aPkh873`()1CyDygcHImbdZxKR`)#kkd-MgU?(S^nId5+hK0T&*MOeW9X| z6P*ah>3MN&z&QxgCHd>>P=}ThUdVKtS;ZoRC1yvkv$)}V^L-HxJ#OpiIRFNcG3oW* z&yOeo5H0(yz1hZp=bm(wD|`spE<+K*K(=wwfM^25)bQ)Kxo9`_YQ|cKz~DE5@{O<8 z6SAOB?{n?KR<1$6&3HCXA0*5*pQMfWA=SK8dhR$+eB6_!9sF&Slt#r0X4b81JeO~D zbdqs2_8Q1-v%<^jfU3{H*{ct0EtmdkOO$r2M11{bGjo&>qaqmLpY^DZT+_D&5G*(+ zVVDPxmoh9#%Q&-K&ERj$o;+=xrT*;*3b ztq8|xW^uoJWdUoAGPg1qLrF}%b2HT-%2c9ZdlR%3I?1EH;;Yh=5%c(v^SF8bSjM(9 zZ_Bz-CfxourD9X3)8+cprM0e0xig;XS_2`<>~72@drMicf*Pq*H%wmoBv@z zLKn#}?=QaPD2Wmb-DuTeS1SYBu@q3!%vdRH5Mx{9oW$k6e8Qkn#XKVab*?!)5=z4kfT@O4`dEWT=n3A0x3)7YQ8S8r^-?s}ZJ;HW> z3fliHv9XBB^h@Ed_vuCiNp1V)`llKTK(<6g$MW_07}WcCRZc3Pb-1BO5SPZlj}xq2 zY={mk5IL!2ow(Tw%`*oD-~F98s}5O!4=s< z&PAqd@Ero(?Z&2RFy!#=Ug1&Zt)6&yvfhcRD~TNE575Lsn=J#6S199bwF*+U?+>yr zE|f^kz_|0FI6i0hpegex7bFBT4?hcNj9l<-hee>sXXDy5yigw`uSm?F z(KGkD1bmY&OUj3*8>E}l&ryTRW2Bg5Xq#e9@pU*LrA>{UjxP1aUzYX2?&naW4S|lt z0^6%t#D-2HJg}2Mxwpc^?O%zCCm5MZ^dEqn#!(HQoBR0BpEbT2!NSw5uak zaf`L5uZa@>6ji#&?)YIpgt%uKax|BjI0yKkGe1%ww?~<0A^WmThOxX`p+g7R6Qx=n z$GO|NWymY&8g3#m2Qsz<>CcMAc~p0N#K9Y3H?+y+bA$#Tn26ds3<_!(1mlu%mXM8; z;8(Nqtj`|!!F0=&@hTCQtPukzRFfeROp>?Zo2;)yuL-hligpGn^ z%{d$ERhV!`YnN;YT7E(e=usp9Na~zE>O}dsthY6 zg|wE5GC!BRS238^PWmW@XjE^g!S@465+y@K8Wb}gc?|3o?xga|Gs{f4RC&Qh&UGJq z@j^>xb8QAQ|od`Z!p9ceNhfLkC^0U3Tf znJI+r>h(V7Y!pgmBO%?MjiPS(jG7y0X~!+xk*XMJ2)@?=!s0#(Xn9p&u$y4eIJN^U z$s5_$hGu^w01a+*%{xu%5Z-xfM{rh{{{0)bnt4rQ5e^oWiO#yutpIhvO=pgYNm7%! zzsuO4G4NXp6znh0%l-0A} z<-Ob9ze!(69skXA*?;3iPAHvA+HR!`@D zcv213A1;jDbtX9auUka#TO{w%K*)#!RkI2m$#J^_53CUuqBX+GCSWuvt?qQfUc=_iy77yk9g5g_vFcuT)xUfP*`qW30CnhFXbth23$l-P(;R22h7p{k{gXX2@Y8%Ji#-7`xBB-(o`(BA2y! zRp`O!R*3x+IEfWgAl_75KpHRm+ejoe9_DDaMQzOpYyKYP$|5A{Qk*k}D6-~oc%_D{ zyf-fV<}TYVh#;Ic=EAbx$+gE1sv>k6@XUC>Y?}jIrLyBT8RF9$xNurRZQi-WR!C>q zG!U}NXh2qU5L#G~NvBZDSTz&Hu8O&6nZ|@%x1<=pg3RHl!qavypP)tz%oL9>o;0(6 zliZqmE3b=z=a=j9%`V@La!)S|mr8CLL~6siEpL^0Wm{B6T^3dFV`Pv^1)$T&a;qg1 zNE-IL4!e9P{2hT?3#!zJ7S1;TukTE$*-V)?e4+p?uG+@j?Ftf6=jPVSfDidtqQ20C zhw{P)AQV6zFtG1vDqLnBZrs$`Ih{TAKH^Ct$sdbyZGhYBfX6gcUTZOlvxY5Cdg;b} z{rlBpz-tx-QqPiopq)6^nPYKD3 zF{hpcZrM5Ifzg8lGN4AJkA~M$=R6JH*yM@@&QE17Kc@sk%b#N6p=Prj6|86V)0@Sx z{oRkxS=m$JKo)2*x~c}GCd67k!lfjcs|nl4JM;e8CgR#tHzRvCOn&42?|SX=X)AD2 zFFwDxiMjk{jht$|caQq{?6lE%;oHvfPEJ`Z_cTyADrr<+K{e9ZIjkMe8N@#eC_0k) z!K{v*yU<$nU+rg&;*%Dmem2vCjRXGq<=vdZ=`C_wV_+=#m*hSUUTK#;AsWX`lAB#=>PiYlq>cO$4O_sJK-_$p2ru2z^}mIM0T-%guj$eG0t(syoW+ zLO&mrCt7t{wyp)Ik7|ZVt4CKLtP^07$Ewdqb?y8F5N;Q21A-!|?+Y(xri7@vQ!cc)~$%~faV1v%fldw1`{NGJ33 z>}|Oge;giFK(R_R*T*u(zO>2fA=2@8P%Yr$J(X##UD~@%{rbDRk=~sHYq<@Mvqm|) zu*Il`Q>&C39ioA#`i%#+3?4~W7|U8+LOAF?veDd!Wx}CBF%ieQ%;#-sWi>`pTH*=% z2cD^ft!f;xh+PTUgFWRa8jEX^y*X0>b~1%XOrPe;T4VjiQ7;nn{&EJFT*X7mTL$7Y zibi2$Mt|DywG%b_%&sx~)G!xC&5?VFpX>od*KZ{VmhhO^@n_~s?6Qy~#)?-Ed0=F} z=vLykmT(uWP~>4iz+$tV=lxGB?=s<>nabl~60uoa8%bE*LbT~iAlv!LgPpr%vL$`Y zUn5dIiQxk`c-ft!N=;=$VTBXmuVu{&&;AF}*>;}hiO8JtoZwPPIw}8RT`7HHnm6m= z`xa_m6_+{4+_@Pk0X1HIV!BAIg8qH(?#5*imx$n zny?R-yw#o(R_qqg(YTRO>J~N(ZiH{V&L5%=yi@oO4)qe`i#9e1NP?x@ILq&jH^U@pQ;JyM90VH|;rewIS-Kp8^yWqQlyy)F^oz-D@4fF^yuNDl z0`42YP7ET_+fQUptN|Y3p2oBJ6^)V0B<_Z!o)UIjVFG^1=XOnSil+>G@`4^hpNG^) zu~CP20WSxT+3DaQl_hnN;mkb~jgb_w%$|!<=Er&?V}Q$JreOa86n-Lah6!BmH(t1D z1`~6BRM5-2IF3=oBFPTXQ{QP^SW(>X{=}FZeFrD{6}GH2Cn(~^&YDjmbIV8^jS6}; z^4I~9r02du2}q0kTXMdb=`6cgJIpL&w83VH!LQodDSFyFrtBPcY%M5A?w8T-brT(P zg>lMM)=+->)`k933;7YG+hr_MVs~|I@@X{g=`b;4bYiweCHt{iVIQ^rzm1+`PpGdVx8=X&w9n}aYu6x~{ zM?8Kra2_SU2|H8Ap;nejMu&*`{RPBIMS5I&G@+c142p1%=$0NKi%PsMR&MT6Yfa&6 zLcR*cvHL@&a+0>~iOtD&pTTLHVZrdu*;)0Kx*3*aS#v-cm;N%%jiZK zKEIc+5b`-6SlVnR-gNoFWND&Zo!|U!G8rxRojOk8rl>DCy!cyZP0JvI{TiI00D<0? zq}h+4*JaHr8^25b$*$UMkB_2N%H|WtlRp zHF7x9-)+0Wc&4(tM^Zr%J@^duiHGy3XPHh|l!AgrX@7&OI7siM@>U`D79+p&e}`gB zlcL77;5Hb`f{a)xF!3_A1!r2`&qKKHNG}kZoevsXx+?=LT*QQlO0O#v+mBUfJ3Wlj zx_Var0SmaPQ_D{Be;*D=w%R*>{xP50|Eh9sI_M_OqfB2m^NWDFwrGmtbM=4hM(u2@ zc#5WvY~naIpMQ`r|A{VPn}s-N@Wj$fqgN(iGLvp&b{D+TJ95L_r}RDGp3!~pVd8pv zLa7-Fplkw>YOsl z5+hE#M}}6Sf&B|-@7GB#lyI=Me$SZqJcGp5w7Q}9?IOrYwC!hKNGHXONKH#qswH_Z zz|~IY{3wM+K=yo`|DrWs&Fk3n9BcuMq#R_{oR4t^k6?BBPL5<=g8`)|Pe!YL% zRrL6pF95}K>VEnbflYnBv%*?e@5O9nd3BB6#%qyVTmecLWH^fh_EkBAem2*>$(?>l z(q_ZVdsSw~06W0*n3Z0K6igIWEaFLVBL^c|OSs{seIo&z)l48!nQx*1Zr=eBT_0l3 z|F0)}S3nodb(hZ~Rr*^MfdTvH6Vu#c9diod1D`T#*-Yzw$)-ws+Ts0XOk076?oU<| zSpg)>4icE(4fDD0qii@oszVI!Y-`)v17tGZF!Yr%)(Sy8+rlhK>`4z2tykd8_Am`; zls*!wEr(x?oI)T=lYKUBmOoXNn@;VGRlqzUFng6WE?ea-f3x3tHDbk+x2#6NdkiyQ zHivsMxqS3tDrLUE%*UK63|3wXVzfQdrJx>VkeMmSI`K}am~r?m(lEBw=9|7@trWQ4 z_?di;qM{lJioWJgVTBa5c$@HRMB;;5yYtaVVnV0aH?6OhCW~`d2shKC$eX}la^qDJ zR-+1+rq{fln_m{ptoUFYZ7GY{s&Uyrrf61+zS}I_7@6k#x zyeSwid^3LNhl9U)Fnn32jDsaxwlS4*%S4UZ(^e?+P7I04e;`If;k^IGI>bTV_>Xh& zn@c!+Qo9+mRfzCoc{qF72c5L7$oZ5(o`@W6-Bdyk9k@Qn@3%t5_l4=9DthXIgdS$# z=Ax#zHcie#Stx+VO^Yl>w!y((8&9=U*F09+a6hy;l$vRJdhwQv7ZpL$^`Yf$!&^fp zpF<71EYC2>LPBkwRHh0z6ktVM!AqG#gK!cMsv-mMFTd^+OL*2mV@#h@gN_SWq7|nH zaJT}WpP%Aki*v6ZGWYP!un2}VbU*{%0L>K7@8`nR`wd9r#^3f82OwBw-TuQyzKgD* zh8*`+I;!BZn1ay_<3Eo~Y${w^@Sx;@MH{75;hscp7vc@ew+~uNYee(V;=+p{q&b zKRn7RBai?Bm}>1_9;o)1r=nk}E!grO{{ZlP`7BYJ!*^6YF7Z_yzuszqh&?9mh6ryq z0q;*yRjZ+=TtHTogy}ak3epkUQv=rF0P}9+?SV-kD;T+{wLl0S`!$Z*V4o8z>q5nC zIQw5}MO|(X0Z%3e7k2XTMa{v&1hJ^kb*Kw4oJ$+|2tBx}Cazhur}Dq)^tLUyulN;vNj7niNuu1q zw7kTzLmvO%_tj zepZEam(*KoQj1J$glFIfqX-wm0X~UPLN5q9>DlnA{p;YvGtc>KfP#*T z#@Di@X6=t;1Qno{M3ww* zPK-??M!B*K7C>J#G!=!Gk80r|Md9W9CGPtwd#Y#EjFQSlz2jG83wHd@mx~?U$|QI2@Os$x!)WVZL! z@uk}}vo#X0f!{u<8IlGQ95b z9E|1Jo>~1F9GY5^=zp3s5(h_>jd|kWj9Gql_p9D(c7kJz7XOM^f#US&C;hVZtzH06 zW{agyoLlg6cSi@(&%M2j{}^s(lS=0n)2^Kd*4?t8tgpg^sa?cY0pv`B$TIWIx8G(IM}k`LF{~Z&##sA!ArWq-6_r%s zs#tEsI5x6NvP@yfG_{NNxb|d09hvoF!uP_+(QwOOZ-2WrmoY0w=~L8*s#EZF50#*Z zGq1K-iGNflGJjG?8NQ~^R4B!0JU>#IM;Bs^{r)09cP4M@Ocp{;@j6w0x-FK_Fsqaq zdDF$uRZ>T_&7f9)b5q?CJ-O{)Lw}c8 zHnEpuQ*&iffB2@tI%c%?Wx#qZVV~51@pgSy_>LmAB1{Ui5nZ)|xm0xXJ**{$11anR z%jy$}A*tAoT^9e^-?xM#WByA!-S{3pIKJw2?~~y_u-KvZWAV4o*gXhKf!*g_x%Kt+ z?_DNv<2s0t(6-yhJC>1!6a@_lw3Jc;F})_Ixqu;m`ue;#*Ob`FXZ` zA`4wXEUtaRaubEhS^}}mrL0s|^n)a=b2NN(a60MGHu)lc>)z(M*C`;qdOz*XLG?3V zC04&jp6b8b3@#>0)ub`n{ami^1CWz)iCf#P%VW91N(C8tVoO*SF^UxD_`+A7m~rj* ziYGUeTqAL5EvFED3g@q1B{hgJ7hMCMB_DgOqTb=LW-|}Xv`&`uo{O3pF8OjriWbNa z@GU2Png3LqoNIYJ0&-@OEx#69t7GD{XT-%X~q?o9R4+a63I}> zib}xZ^gW@)$bOIr9ms8j1z0-MXSZ1W!y*^$CMT8p(Dai`O&J;^^kx&)F0Cj`(R0#p zZW&fs^SMLf`@Hz5M9&0NT`{y{5erV`EKVe^Py^@RMCSr-lDcAWXivcwfXQ{2-dbo? zqFLAdON>U=)aM~f9y3jy6d7Evo4B4YLK)OJIUtoGk<(oK__ownAUn+W1Ca5rgGz~i za^$k53C@JKJ)4K$%6+gY=Pu zic){iyr`n2F}A8hZcu)yFjzMw0Edmm`$z&w88xiK2P@$|H==+`|OEGE6&1%hL zHp31AJ}9f2G)YL5CeKo`tR%}*>9*PpRZ(!~#~n7Zj8T5xIo8XS@bbMwR?mG zW9Yj*!m}zIXw3isAOJ~3K~!xT$sC?cQ99%A|I0Ud@1tiF)fBuZjFvJ_<-S#dw^a~7 zU#ZB^k+B^+t3-<)!8wNylH`>a1-lGrV+=O>cg5uqbrk`+R-#A+cH;It2NAkRYT;(R z;@Pw3oS(ly8}YOr%nv?A9)~e1@Kct{r9?I+$)4q1mZfmRt&BzUvWgG?gkczP&XSmf zw(aSk?4SjFX+AugzXB{T1uukqLu@v=8>k5Kmw4U`kCbcd&Rs?q@A<-IZdqy`BT+jBV;g9~{3w-GdZ_;#Y`o2S(jP0i3 z!zZ8c?EDhqvE_q9d0|zcR0I*ZXulozyI1Fh>7AzX>!QeIj2gipy%iVDbUv3(e!F4l z2b2mFX@XIjgV{V@H_C40fJWD>~zwM(Y#+D=sRG4>Srbb_R1=Wo4Z zL<$V2l>FLSRGMOg!Ulok5Q5y#5ofCtBUso-W<-f2C3umZkKQv59Xrt|guNnP=!|l3 zn?xMmK6dshhzPFC3!HP}wuwi5l0>`nztXzwg{(?}4@}CE!S>W;#o};*4*}cvQ4DLT zs|wqT!($jMUDVOoxU%T_0i|WysiZx?g@7GA+DL)fcLS^SMksu4+<&i?()geV+Aw-Y zJ*$~aCv3JYZP&{LO&Q886ANmd;*fY^&^RlI=MaC-!Hs)rU6u>qesr?8KR7sGTGtYz z?fl4g+tNkB$a1xj5R;;y9;LfY^FqdH*0SC-81K<(LRsdbj!s1_T$ZI&8c3I9jH0Xy zS}Tb?((Snjc91Ft0*vduS}wTv{K!#ZIS-#a;8!cB~l;E{2lDl$@|=^A-o)9I8QfBs-GVd!CG+`$i|5bxc+kzWXB-|LQ01V5=lF0zmS|o+Kc}7_kW?jgDFF#M zVW{Ut8W|d%o8^|WtjUTAd7jdATQ09&aJyXMy{9NM(19Y9C>1DE5g;~QPg)7cWf(f@ zGUv|SyUgcv+HFI#-o&mzf(?u|_%K2+*rA~=GZ-zmH#dCr!3R8i{0hV1I61w`)zu~6 z|Nam0UgAJ+Z*O_v9uo%3`Q-&KE?%jZye*j7nS&6kRK`Rn1;w7&&!HWmidr`dtltmpem^$vqJSs`aRA95&NN%}KqIgI! z%G>RhEGtBt6>XboqxQiL&Cg>w?-k{V4_6-=j7&R=%4ZG$!` zV-QcU4Y1v;xV^riC^EsXDnpMrOAd|>2}afxLoZOLVHk1NbGzKI?Hp-Y0WwwES)ODk zostydFSuT9==+o+OURRyBxu|)pn_O*#=#O)OQI91G-tVK8NIyEYAW9sV`L|qrf~P( zne5-EQ}QI0Zq~xt(VX#T?=swmJv-Y*FMClGG=5|g@7c^Gq-h@Y4dN(Bla#W`xp#Jl z7thaGtu~B4kS00P$sA)+E-o&(yuM;GsW@63qP?I*lT>qkbxRl>d0x_wjyjj%sBRD^ zgiaH=zXq|3ZJUNPEd&vqiufud(rNa6Pj3fIsv}G#<@oeigs#D%oRgh-Y*2hW)U}QQ zC>RFo2!l+M_EQ?z3nrCP)J4rMq84CqJ!v6Ia2GtS9kJ2YW$`lRRf^tu7%VnIYrGHi zcG!#Ryi#=W`DKg&=V_ZxiV75)>ubt9qckaIHyPipxd4q8Xp~8SSb&Cjj~Q8c8DnVM zc0YjyeC z$>%fjdP3iAX$K*nqQ#YQbacec^%9-JWHx2+P6%{f@amh*MnvXmM&EV}N|EXW^EYqZ z|N3?-eD!)ZrD;3i9#1Bblth%ri{h~BT6Sp0B2Q6q%%gOykborBa@hM(s>r@)wc0S7 z9biYxYQ5guHjFYTov`U7SJ#bUuP|(zmg%IH2kS5}olkiCGjHH+&$Fi=V*8Hea>-`1 z5|6VJ@8`}Nsgxu`DHKIyL{~)xO4R3*S6DX`yF7jVl4s9e$j)AChysQzO{LRymdq%oGqL_z z+p}EW@aW+~UVGy;d~mFn8-DqVpR$? zw@eQf937vKmo=a$%8Ii)XHqEX-6%`ZY()^b%k@&!97(e0V{SKY5Oi-cS#G| zbzno^MtYQBNq_#U_xa&Ze$KbQ^WXWx7r)FOe(h`AJ2~amH(qCPe8kI_7p&H6=}dr= z<6|x_FKPQN>-CbZ-}3O`J^tYL|A4;jc<=r9_~^+;~dDL7`=H4j4v+DF{6 zbPie>e0;e2fOKM6hBm_KZU=#aIQQu|a8LS*dCA^KmU^_|=t$P`e&v(GD{70RiT0t z)pU|Xo_Y@|0WG`k9oN4fdWy23+=W&-*=J{Y$z&qYz}_ncYa@$$+*`~<;VtXOlapiC ztCbXsN-(mb85!b!J;m?tr}%sxh9Q2p<=_vII=AB@G@E9BZwD>Yq9jXYayNQ{QF0BP zXN;NcCd;ut&<%F)d){e7bW9EN(KVp7h|2QW{nLtI&chrj2Y?C61$slB#EJ}D_QUS*`wLlm+KW? zDaqX(gz_X_b2*@mmeFG0b@WX`nx#}#&ZH~>LA)l3U@`ll7hp-M@yG*2s9-Ri&oNq~ zjiM+EvNXdeAxX8p1q^jvV^qR+yQXa$rd7>!G9fJz$|B|7*%5coj<7=`)sOAiwk;tD z>ozY+LhSa_G@-~!ln*E`))FBJL)&fT0X~XV=Ji(}bNB8kr^gFs^9jdihoo7;$=RH$ zE^%(;%U}L7+1+~_R*@c-WNg=4>=3wJxBT{lPk8qH5`~Nz6D45*&W#Lx$9z7)jsq{x zpR?U;WE{NRaQ@;slS$3VE3csk%e%k$Ik>=REr-WP_~2-pEqRtw=DCO|f`BdDIPUkJ z0gW<}>21;+ou(9JO*K8>=Ew03ZlO`f&+=V1`eJ|n?W%dCo-aGNz#_@8V zWfXah?JdKmArLq?T=4RC$&1Z~7ppZ-FD_Ud9dl4k`1q5jG{eB7S6=0(Km8fY<%TbR z=_@4K@Y<`dljSLArzezU%AK=Q{^~FPk_Y!5@{iyACg1G+jmACH-3DOnQ7u2FG6j$#Aa+4z)Jd!(r(rFmBC73L3hzh-`tLSp*1>}TGY-A^E_q4SgfzFQ7kyew6 zwrgpc4Mi;+jcwD!gHd2nT_+f2ou-lk*Z0`Cvf1sVVTXW~cj_a0HpvnJ-cKm=f4|sv{zH=;PWzbUr(w>28m%h+X(F3enOe(E~3By;1U0^EgcsL95WtO3p=%8#o*wa)vFGZ1|ji+h1 zn7?}U^y>jdRf}3(K>Q)9KYjH78BCgzWJ1F#%ZxmgOz@#^#ZzcxbRsEP5(`+@rC2~B z00CkUeDvgIx!9M`5)~M2=4>u=jU9! zyx_B+{Vc<+1a_>JD`xWt@Zdhv`GnuR|30JbIan;B$VMg@ zqqW$601QWmM~q&v*|zef@J<9vP0P>^%nugK4i1=1Cxp?nTCE7)k(ngscN-Di?ETjQ zqsX$Hop92Qju$VlNz;P5noyOZjVLA){`rSL=G`aH*z^NI8$N#el<$7;`+W1;-{Ixe z4coTmonO9-NmBmeFTTd@^)2uI>RnDwPx<42|EJVd$;sI}pv2Fe#N?!=>*AxrFgn98fB6C5{BPeSD`wne0!;oTeJ1!d}$3*=(b~+e8+(jt}tu)50;Pm-SIOju8*HF-Zi& zh?pu6z37O-JIOQI+uDI7PdU4DLN%$lxxOR>z1MMMnb?M19K-L>uf~{vC5Vh#kJusa zU|hQcV;8Mz(nMmKt;Ox1_KIN?sLHk-#GT}V1kE^s=Ipc~+qS{R%8N!N6fF$Is#MFo+a;`-A5*iEzQUMvHYh+S)r7;q(rLHQpmnV`^(6k+wH`k1I#M%*~(g>{zc%7h9#d5PEFNA6-n7n}X zqZ9+)QdT*i`RwbU0?#j=lUQq6t=3GH;VkY=$e9!@yf-L}mthR0NFwp)_a zFpdL@#Su-@@Z_UUaMm)bb6$V_6?D+N{`#Bz;+MZ<7zU1xj%d~!E-ueeiM-z9<0D8i ze)J#z6YqcYf}0z8c#hW7G!2s?BUmTCRU_6b?*er-<^G)`6eC$#aDRTEmp?t{$&(K` zJUphZ3p(4A6lKZBF=MeA8(5H44tQ{1d?!gc*v&f`N2=#!8^^{ zZ@tZHj~_9aPWbTobKd#cyKHpIz1QB1+cAZ5p0t|s`ZNnzqc zr(@_k`o8D>{d*$V8b?r`qORDq4XH}W@{-NAVg z&~#lxS_tvY7{xG1Cn!QU$#c&0l5Nv*d%KGJ@E!3?*6(=;6}c=9}FGMSJi z5_I7ZdtaSr*nXg#P3ildp|_;QFb3(qRSI3##C3w<_+-KL?HcbojusP4@PyG(m=rUe zhEg`FZ4dU0`y)*0O>Nn>XxM;JWawx=u-g0)O%Gp?JSG=a>^GbXQub~cPq6d8T9 zV$*Et+6_sXkt7M*uEi|Wl+DQ^XTR6d|K={TThQ8A+Oe63?<7EP0W0dUDJgufI;B6Mpf|JG4#1@$n(Xq$I|0bF<`E z@BW%QrzgDi)@J~ZF#(epCUu2LQ(m0E;DSONTyUWnGY}PkSClyaV`H;46Su74%94$CGIpOB|nopiQ!5G8+d-uU8US3|(wz79D z%ly-Qr*qOZDd`mQEX5dP5&~RaUf``|GMi$OgnBlktS5|CC{}IES#Fvw0MqGozti2t zglZ#QC&b+R;dij#C{?3FB*zNHLk@!rLBwKr2HY#cY=^FS)(BCC_roEGJ9F%4Ub2;GCc}#Ze-h zaV@J3rG%$FSQ+UxO+%6-%;uB5a1*2>m)KPi%muulTdm{8ix)h3@`Pa!)$H-{DQQ+v z78NFeswyd>yToY83ReVl2+Zm!eiW{Mni#sSp~$793SO*7I!RE*pf${@isQotd4yl& zdCFu`3Hd5Z@L|Bak-98V7}{=Ruw%UUg_)lwV26gI!#T6rjLWNQ8aom&G+obVNBVwC zu%7?pfB$Pf_u1EZ_Q@0SOaeeWkY$F!j`Tk8qo4kar!TKbvH~3>(>_af&YH02SnOVN zk{E(xPvcWc5uy)zH$Js?;9x%G;9ySIH1u6dyWPgHDGA4MAxKD$iNQw-x?WaKqm!wa zPErOpMrVMyQLK{#$Rx7o-?7R~BH9a`8lFA7ASlbdduR9%xV*f^#0kZ&5ekv)xD#($ zYxj!v-5)xJ{Sf`;S)K__c_(B{5=@fek=?QLfzbs<55p({Ax$GBP#;NoAcv=oV`8l} zi8gz6d6tQ=a+l3b*d?^}R3S!ndPmziRyV-8!T8sl_QSqg({4VQl&$el)N?CIa zqgVmOJy+dH(e=C=M1!!tiZHkv^SG zDJt3Pc&+G1$KXU=X<|GbUet(rmZQ;P5vVFO(%~0b!7$hec1g&yl$)Dd`o5E$VD$4U zG+p#GmPJOMCiHD1=-9euwc4O`!ok6U<;^u^Uhw(1Kf`2N^Yr<1{^^_Frt3Z1c3|iQ zkC+&uS2x}OIxsrnZ<{O?bl&JljN>@BRbU+m4&-TaqMYFv*@R+Jkk3c@^;1LjikQK7Yo+w z&0h654wkmrN@qB9Y&I)2p6R4!Iw?6iUXYgs-8gW4v!rb;MKK{s3w$sHZA4V!1y|Yk zUEDn-Xd|O+JC1DImaEm8r&o6lN_*EXi_7=;VTa1=i+urt^ z-Mz!--~K#W8P;vfy*p>zozJ*=an4u2^fs?Ne8BB;$z;CZou9qOkAC_~Zf>^RJw4^k z#}E0R{_Icr{ons8d6Bbi8WD>`yrTG)2M!MpP%6-Mtsqo`qRb0s(>Y}|;ql`)chRl>QkMuiauEZ0H$2>?YfsZM9imI9k!&=LOwC@L+^@h!ALtU0ki;^XAM3U~j_cYCxk3as1v1>RvUNEa?G)*Uy2N|+Tik)pql0c$^K$o

3eRMTXd3<7nJ~A@`SM)_}ah!3U7Sw4Se6yw2h>01rdkU(+P{iV=k_iy!)#U@ZR8& z?1&_i!@?+fgVYFi*vBqb$ZkFo?xbZ*5~1gfR#39D*+eLMy%b)l$w<=zI|^!ZcbI#K zV|4KfJ0I9KJ0E%}T8p4)hh7ST5MtJOwj}P%LzI&1T}Pc4B5F)iioA-UCn88zi3t3 z0dad&RY{%;FMd*0tXFIDETgVVnF1M&QUbf``aXi3BsM$GB;cp*BneLi(ZmeSk`*as zkyF>^)l}9L3p}a3z%W2ZuId51~;-|#dpr` z;l1Z)@BEzAdd-`!y~*c3_c`AC%`=iD+uJ+BC>2Yd?~;2GOd?;dt{te$oVu#GczMNl zzVjVkd2pZqCueOy!i@eXW}b9c=bMKnJlZzXkpUd7BG({TFN|^s?qDYjeY@L!3p!bmE1zq=P4zy8{qNjYI z$_vV@5PF=G1J4*kSrlyShOX;nV&G&Av+HKWD=k*c`Fzg7!GWmOt=)I!Acy#Fr`Jag zdsS5&A0Pj#pVcv$9HLY#9ztNd-BOk%lX`}CE36TZcy9+$0xO9XO_M}iBFc*bSf$aY z9>`N8ggbs=4>z9v3feXtw>{ zw&lIY1rLt>HShaAj(yYE3ETZ%TPekMyN&A{**BwwuO8wGsM`#2FE8rzo#h_w!JDf3WZO_;{!gh;J4DE8m$ImVpwwCpBL*l$AD`n5% z6{tj0R25#qa=Q`gP@16wq`Bk^>*yEMeq^R9vOGcAfUXL$-z(X(t+pGKiV0wTw?|2+ zstU~*qwXZ#O44Y=)-ZIkH#EkuZ91~7kZ_2rmvSJS9&>SVK~RDFk6-2fo%{Uu!xyAk zfr?CdqFOl16M`4qV&C^DADC1HsS&`2)|xwa?(q2WL(a}l_}M!)R?doT({O!z!|}-h zI@O%sJ)^fPo}WMC?D-iu&(UH5SwYuq>6l!w)$- zU9jF<@n6634gSYJ|5F~n{t8)IViIWjj(Rrb{=)}6``{DS>owb^qby5~kB?a{Z)ls2 zvaA_sFvc*c3h5Yvmp}%SkR+l4C6Pr_@PVs~=eUqCnNFi0TCwdK%HC5Qo^e{%Ts;4T zrKA$r+n%BKct29r6Pz8R|GNht$TPu=rfEvw3H2!{jCkEg&n_!DIPt&d zxrp9Y%N5h zS>bNuoD@NktmnNWXv5$}nwuNy$(;Fg!eD!j<|oM7SUxx0h(}g>)=F`vQCR2EIuX^q zAL;uRlk708F!Vj^^_q4QnGQ)V;3eyYPp@`%MiC+^lb}q(DDAi?uj3e8o49UJO2U4k zx*R3N!)^o}f|pTr@Hi)7H%-$J@SL0;(Y6E4R`SnLM#P8lU~$nuEie=H=^-};K#7+- zj`n@(rQpyafYVx7;6re9Lr*XYohE4K@Z%_-r{4L*<={2ONJAEX9~XV&5X2_xy{wrc z(M_osLgPog04pV8!7H&vdV$pJ?vdTKvMz#We87#OY1kzLIwz9}r4%Zz9vq;Rp(rv^ zZ3uBR-;Wj@KpQFChC%+htc3HZP?sdnT{O4RS~v>YMC`J~YRP0!N(zsv5~^VcZXXGq zWI1|pva`1%Wsv5e?FNEUF*M5150>?M&0BAOk=|+M(+OFY@Z$0U9Wsi88EB0UBS%LI z@;v9svuCt}ubHwFo@2+mQLd0g;Ix8ba) zZ}XU?j7el?>qW38s=YvxhzKpqQ$i-YW9Nx`k(eFrBq~y2<$3`NIOioWp>1i~mLw!(xhPF7@&Lt1b!ohbUTe)b zT6!B{h5?!g2e`hy;dZ&gp+q^GWvrVmZ!TV?>skgYd(PwIWAY^DyWjp7&L3UyM{oZw z1Fd2euh2!x&{~o_y~{O91#36tmN zy!qrg%gb9lf#=VkqEZ>-BuT>g`8l)MjH<}dIvV=GM|XGCfJ@j zTJ#ca@D9o>r|Cpkv)ODYvW#7LgfS_j7AjV6r9iZ9WWC)0P}jBijU&me@B2N?E6cJ7 zrx`Hu-|c+HVo{Pw)uwHz>zdp34U<^WeLLtvG`EFV#yTCNtgKpe7a&&Zr(FsFu$umP)mTZ~`ezdkmm)?ON6NifK#j; z8C@H5!~=O=>>G@x@3_3aq#s&}bVgBR3`0+rX-pFSjcR?Ta37*aogK41ml1z(vX51s zsL0lFWUe4Fs6>;ZF=jxU1WY0UD?!Q1M2W4{ByyPVI)06Oc6)Vwd`&y<0wAk|sAw0w zsyH=>P63$?h%Hap^lD#_JLmAo^f<|j81%uX_Pn6>`|{n?VhkSb;`G3cBsxaYdJ7JU zEFoy=@O>B=x|X11>X90SDMXp>l@jfVF<2`Ap*+upBR>vwUBj#@F-G?4X_}H172Bp` zy~qc6O)J%AD9N*oQCq;1C7L`dSj;AD`#uVWVw9or_z^jj zw0wc`Jf+z>7K;Pke*3drzI?_{fBIAMa?10kPh<5q#?e!P(PGC3xp`RWk1M&N8}zX4~=dAX8w{6cfi{ z>(z>~sPT5dHn$9Ttn(~48)ox4ZQFBxbw!bB3a#QOd5|hv$B71tfBC_`@U8E^!`Z{v zsq2~#e)Az&qPctbE~`z)^~ELKW=p%=vc9>*jTW8P5>PXl(={tDZ>~v4$D@-wxKT5i z%t=#OCmbIhF-Z*F%`M;k_P3#1vuf8ARmsqga($5L!{x;Vn_0`*@sY%6YRRJCZd;5| zOb@0UpB+<{B}IM6D_{IP^KbnNKmX-N%ooR)EJu6I&|7YyTWc;lrmIx zO+Y@+ZPTz>H=G_GQym>~_wE^5%MLUs2>?L>I$+|T0Y^|?_LnA=Lw6X+Q&|C)x$G`I zK0;$e(QfTXh@*Ik?zLdzfuRgaNfd7I1BuBPtz6IG6=|B2Wf?;R|46s2_tr1zK8eMJ zbaKPmqEb23+O{PxQr7D=7uQ!Zz8*)C)c>19&qS-7i{0_=uk0+S@xa?5X_F+uk6~{G z6D+%-oRpB{_@D&g8+t}BMWR-LacE`w>PM6tQ4zVSB0GN^EeYmRpq5gYD9V+Ay2e`h z9=O5L2Ov1gJR_u$^FGKVEYEY2B#zr<%p&1iTK}6v-+O`D?BHj17_cfxwnq?Mj2RVn zjNjdHH`QmcjnHS?Ykf@B{z+2A{QLe*aF@=s31V?W)&Re>!=kWN1o8_9W zw|L;_@K9ELLm#h&-V^%*5R~TeE3e@R+^m)qg%k#}=>&^sYb~all2tYRIPlSvXEb4? zw;jO+&dyHRHVuPwB)MX=j-$glZm^g?JgvT-Mt`|6nljJCqv;(|Y}|&x>bIsGFJ_*Ke?CI+p7-&O5RsVQ)I+^z9+dx{^>zA2~j|V7^{M2%Nt?nEH+^_uH+3`Af}rap(0TacHDCVz zOOB3D$kLS5CQK)@;UHXzkt4JhF|55I>l3N%A2Q81>%zI}gpmxJpEELUqT z<_pTvgrX3|Ylx6$DcV5WZWxt0X(G<|%qH|*PuF$>Wl>VgYIt!b17{*c1v(iBTAeV^ zi-N2yDaK<=DmAsmVkK;E@99FI^8u8;nmTm7{Cn04UCRZ<@x`3e#ez0O+>i!WO0!-q z$gJnVd-sT;BQerFCMvW}De^IRO<8X9=+O&)`}vm?lNm}|(j*x|QR)gR5<@TJZtp0I z5oMYY`i|5l6uCSLE-ub#>KdC^sqFbU>{mT5h*d7eAjZQ~Qp%gPjK!7Gw2eSsv@xV< zPS>}?OWTXcBx>@!gdsHMh8yjVqj|xo8e_l&CbN>AYrC8rpK^L~PH+mM!I(r+>PDW~ zm)Pjb@it0=a3}%jpaqt439|{o<9Z?3DI;~`&UN?zo2F&4UW*#lIh3&wp=oN$qWrN1 zF+|a%^(`7_MI5~3>Z(R3BXNchTtW=;Ld~;mn3za#O+|2BM~Je5&9a0L16|t?gJf2$ zmWIaV$U6-Cf2D<+4#V$7nqda`lf87(J9!q%%pua&72~oXNi5cyLD3v(+md1MSPU)#mS`M{bOv#D#GmmFEOsYRDM985(3gyhc@!$ii@^p174A<0r+y?HC( znXVhmoPkkMkYoaQTh|Ru*U=AQ%ero8>J3}lTim#LlX5g6FLGHS4%15W&+hO4ayFe} z6C(-X;ne4RCthOTq7)=1p{X~NWg(%2;K|cO0P}e&fQq`I?L55;D4o#uj;3!>MoDGE z47G=@8LA{6V+|J^AVc1AHqn1#Zyu4_ z5e%a~V+@V!XuFQZrCv_S57rObKeWO}CxM7d2Cq%f+OSwIFxK+&)e8u6iY!vg#px-# zvmG8kdd!PwuQ)rs;Na#BCR;l^d+~y&PhT)DC!{u^%u;;c(X|bU(GZ<{uoFw$*PNdn zbL-}HKKa>CX}gxUr)L}=FBz8wzUk;T8?No{kY$#$^HYjMEOx8)nj$Z7PNB7>C^NCY z1&>V=qF3~-V>aG}D5qtkHF+^&JRXxI!hRRVb|83%G~9amT8oT>>$}uVjT^ubL{LGX zD6`pw>j&4kaqBu~^Ap}2p7D?W;xBmc@FTj`aqVEA>o*RVPDi{vd`Yjs6d7q=a(H}9 zRFEYJlPu-z@CbwF`t|F0A2~f=uxWdocNEt0=fC)e{OrS@pa)}~j)B>D!tTxvDnecs zeE3Hnl4L3Cdd>5fFSxjvQ;sK$%P|-8IZf;EeFPJ{I#z+P8OP^y&d%p#WkDY#Cyq!MG5xS_B^Uij&ZhXDQYuZ0e5rvZg4v2q7|`F9<#` z+uFvYDbHTK;_&2@Wwjv&&Gzmt^`@q&JCZaTlF*h-Q#y?Y#NkJ+r2Vk^wY5Hn_zeNr>Vs*?ZwtIzoIo9~&-cIo<_db5$r z77=SS%f*7srf4r3;Zz$!*AKufx$UjjE3`I@$0L+7Lkd06bpEOy=7SrWTLP%r)EnuQ zBk0?G;6tzi+%2GGtLswR6Up@#Lv=|qhUtG{_ z0%4<3!SBDd;0hc=q|VlhmUB2i05V%@Yf zPF6rlO9b2uSlZq@q82HL9HK34+mj~QfHyWn{Vm9v!)g?PuB#h9b+DPN%40O=#^fc~=aFAOyxD{996Er8%V#4vCSUTb3j!FByuc z1U@v%bILTO?*yu(jA66cP~;^VbJa*_x>~4)MM=|2HLWN{LI4wrmhJDR+|kMt2H5N^3jO# zXiUUl^ODJQi?;0tzC~nfJi+|p+US=`3;F2u^i+0Ag^1nLL`F19D|w+0JFCRXe^_aT zw7LX4F8#I6N6?C>6rGn7$Y@-$zrRn{HdLz>Thj@yYdAkUy9x_P#ln*1IeA%L=_qZI zkQW&-^z2SY+`4{1RaH!bj;FjivTM6kl>8tl+lk z=)K2ki|ZT^2c%+yb3GU5=S)T;X45IvYQgqw#;aG)`R#9h%WwYn8=gLW%};;!5q;Xx@}Pf)?}==<+@ z`siyOzW*+1nex?F-%t*>?(uX=*EwFiJ{)dQ5?slP0;Li{uw>bkG#ioF9EHUs1!@sRo!%Mx>*X)QZt5#>me0Hj~jr#&SWSb;5LO zhn;KJxR@_kErp%`@Pqf+Ke&cT42N$HNfTkQpIl>W-@G zX}u#WOR+J*Fu{`jV%PU*qgkyN@_;r187YeqNg^h^u5a-K_V;$#)D=EJSxl*#Rzw>} z6-m0dTGG!(F)rn^h+NjuR(6Mr<%)==EK5eEXjGHbG8&EW(Gi1Vdo~rNwwEANmLx*v zazjw3ZO~eg<(4!{a6ZrnSgdDz`;o>OEAxwR5pQ<0*`(Z*13 zD)Cf%kB>^mrb?4$`PGCLy_0|Ms1HUwpv%Fx)sV$#Zgu=vp^i8e}!AwY>aM zayzzWNRxNc`R;o$a;8Zld~_ot{TMub*AV=0OHUJF*sI~D9VHRp4-y)wvg@I-V8yUT zloz@-m|-;rf<+EpkBU)RJH|2{4fSdl&_9lMAkF%}i#e^DuO zL`=Md^&4UsZgU81L20mAf=&v#4fLM#!(*K9D2tqSQ(=`PiRBkTDrLQoXe%czqajZd z>b7BfG~?dgcX9QaCr_SWtz~Oxm(#@tN2H4Zt7Z4^f|sfgP}McTXjDKdRW?CsD_Bk~ z-NiTnb*xUXseHhu(=j@Ds&&oL+Y=Jq^N;`0pRt<1<;&lHPTRq{f@-zl)r%93-kdTk zXKalpL@zsgV>LdP-lpq%%6vp(5{wOu_714#Yd-tU=bX*w@-QA*vNGc*4<6FBOFG{% znar5(ZnJ3}L8Z*nlC9YmZ%;2!CShmqI_DR2o<4iZ*?hs-*@}Rr8$S51Yfvh(yS>HD zTQ~UhlaIJ{>jo-M$g%=s1Riv7Fk`-4(6%+NUM{GrioR=DuIBvpU;j1rs$q9`mrp+a zDc5h_z(@G_r+>`hMbE$fxBs4h^Kbqy+Mp>WW3)B2F|w%^%qC+(?3gbbCb!<9$PHWD z+x+n-pYpr5Quw|L1=sSMcsThJX5JKjWYL;!o(h zhQ8^!SghFH-(#!qQ3hh)qe5W4Tv1n254(Bm7Fwk&R!e^W?e}zj!zjxLi!+Q)`QXF* z+^#yhrjlwc z%a`YydH*rPA12|x&)Iuld#%|47pVra`exs_=NxbWPm^H&pxQjzvCouY&)xsB00U*m zNT9Ka=g&$2O<) ziN(rKL{V8n>U%eVQTawbS~J=?X(uA}TO=)2T9Dxa;*$k=M+Go>ix-PVd;>#Mfc$gi zJoc(xazQ^cz{x$oGt+v)lB=V}q+ZuW&WY%1m`*Q>I}o{G(c{bbnb1yBjlliaoU%^senPI8?f)USDmd|^a@ajkog%w))yYQD&T1$pRv1<8!%hfBF%4HA{iMnx&1rT~?bNwPG^zoeModU9 z#Gmx!r_ZZ2<@`wHoxA;zW&ssH%nmT_Dgsiu=|DEKV}D?=BWWHogO1FFdzY@|qL^(D zL)j$l)8;%y+!xhuMMN_z)73U^XJ?JezM{8oZq9R@rTzSI@`|=_RJrTBfr#Mp>C!8+ z1d`RAJf?Xa^hN2E`Cib}m^0a3*%tA%4ugL&e}yc^rVA04ZzFhFK*}+qt0^^zD(YUY zTv6r>?Ry^ZNWMlwBcf9zYnYkUQ^lKAiF5jVNjme`Nn9mf%W<=AhO z3t0&uKjrlTm1m^NS1fqx-%kw} z9dP&E#`oN3^_XxI!;ke_uggo?4gc4a0)@yLT1Mo|mZ7IP-_9OkAt8u=7D$%e(O=v{ z0-FAywTK$jxV1nQ;e#taZpVw&+Nio+0S(nzlKhEak&DySbr3@(fvAMax!&3*Nbr#?9MkZEv;ju4zf|9b1I62|4nEr}(d$zuJu`~4F*mi>4u#SgI_-;UKbG?_WvD{KP z{^W%8e65ha%kQ7G!?@`7M@pGbBByU=9gn0H_f-^=)=IWb19}_xr{K+#5{&=4CUGQ> ze|lcg*Kcum078p3jTJtAb-&REA>bCzTOF;>lnj}?mwyjZ9J~ETEBn;aj?-E&?0KmU zG5a$Ao^Aoyb9;72AXdUYPoawu5eybf%j*`L86%nR!+6ppQDlDF4%kAe##}O6{=>7! zLgrA8*qrJs?hhbh`PueYeU*H_tEp|@3dtT~IBazF=Dmc7VO=}$oJ5BkSQ4AK*Kck= z1ve31b=LN5c^U=wjof1wQo%Vg_d4=M??he9*tfQPZ-H~61E!N%>9w+|BaZ*!;^5aA zImlbI{e7#Gle0$8*SGL(tk}N?Cn*!s!x2{dR;1nD5*fvRI-ElW{3aXs*$=wTQ64DR z%!<)OnL5ha%9s?><>RL&`9(x5)T%SgKk!QHF9xZ)NeC`tja+_B?ql#%W+6a{F8H}3 zX|0m;es|VSvbkKRn)z$j$vk@bHihV8155v!$ccdgc^Mp_3L{F8Tj{12^bU%bp&kim z7#La3U?A%Z7iM2tSx?KfUUc#C7(5&qF^;eU@a7YyTAS%;@LUZNs;jLJU(hnWnew zi__;Qbiaog3C&}HMf4k+ho2iyM<{6;5~AytUC<#nJH5+~bj6Oglzl{D$Hbf{8L6+1 zDZvbg{#nE;EopQ?GqWa(;T?z5K&r=GP~1W|i+n_4by}!T?oM_nxe&SX%5YQutt72G z$9{P3of8Sp`-&l%<-MbxTd{IyZ~cv#e`wxGvyW*|5+Tw*{KhRJX5HG(*MD(~2lVn& zJLGQlXoUlC8Cd5cYH;3ZCu?68yrJcr9!s}RF8K|Xmz)tAGKH4F!nihW;@vf{u%by+ zbP3YcwDF#uD!cs3W1d;A9SChukm`?pf^Ylo^mZQeeee<9N$QI(dMg&7HC8i%4CZ*y zkb&W2qsmwzWDW1aF$ph~E^nhLF_VBFhAWssYQf}3L7XgfT=>5TT*Ld7YWthaNo5!V2|Lv#6y4XYM>Xr~W@YXun~PHt`rhP!{@un{}qe4Xlg+fSzb z`PU9j;$dDEaxOV17twCq>MY?YrJC9nh-r1#rb3I!$FVfP@>TQ=8TH?AFE?YD9_hmu z)Xe^(K2ePdGSF(071F%zyN=Rf8j3l0MQKfgDFV1Dq0`gBG}gqJR_I zWGK_5VPb#b@`V|QqBS@^Z0%7iP9_YGk(#k;7(j?XNu}>888=Oh=UTr@y7~aDtn5bN zft62qB1TVJ@@)95G*${F0+@G|uXlM~j~U!z>NX&avX))9|268ZMjt$0WhLzQ`Zmw+5{X>YFRyy} zt*9IShVr7_N)1(9(k*O;-#eTQ7jKYS`oQ?9Q+dJpNE8WU*{rut3OkWN1eOTz$LFMG^eC;;D z`^u-6Js==G@Luf6)ll>~H{#au;$@A5kaa7=Zt-S$ePy5oNrU=9ljpPR;{qD|N=V-Q z65aDq`TFyiFXE|qWNEEO8j$Psx)uR{d!e#+eNyJs~D zxDB1Vhj%>i*PQf58Wk|x4UH+I>c=l*4@B<0#s@4#vahA$P3N+^2vy7lvf_+sLsVxg z|9$2i0nU+vS>Y`{9~otrv8GQ95+q^L56j@S{KD)bXgvQ1-VxbwU2`?CEH?FLN4 z3CyL0)H*8IsV3dHEs~MZbB!pPV`#0?A0QWLvV6Qe^CcD<8rRU@tZ}Kt2`Et6gxOFi zRK$nC*?>L!QCz4!oBbl+ij!z$eSS1f$@?D8Q!D<*X=$W6+c{+UUKnWU+)c?tOkT_- zy1Y_Shm#h=qd`C40T*tM96WqktKJP$bNpm5X0Bck;y>W!_<_c?3gBTQH)*HELsgX2e?Z-T^(hltOQJ&oq3(54R-*i-?-yTg6=GD*?r z6OZCac0{sfh7afdZhj9J^uO1lVR-@Yep2ij+&tv%AAE%+71J!>orV$^$kAp~jl^Wk z(sp2@4@yfr=vURi17?nG{ql7S6>hu~K%I3-%8n&|(#5JwajR&yXtW7;xc{jrqd4w! zr_0tOW}#BI%+2l3Wo*puyOT@;PZacPXJfYmZPmWM!Ly+6F|3_gNW^#vwx!-IrGmWs zUE)x$Bd7eUX;JXyZX9v?7nX72JV%wEdJ2b&m( zeV*^k40R+_cAMO3#iqQX7Q^;@qFm!UUB@ukNfAW z3MzS)&~HGwYmSSW)%Y5tIsSwOq>Kp;Iaf2QgdYfFd%=DkQkmKrxfq*2W~@W+=boR^ zDP^Z=iBu7#kXowVlX?EoFnpDAi!^v_B`XL-v!|+;7a36O*Do zscYz6Qez58!vxIx=V`BJ8G|!=6Tw>i0(yJqYYzrrJxq{DLs+~0FTZPOxSno)v`NGA zPnqe_>_3Po>WnptuKMAq>tY6sAb?wDYdnj}oi@x)0PpoToWPFhc8`xw=evmc$ao*f z1MU*-d{;TLl08^Oz2H}nyT3DL9Y02*0Y2IS)>NWC>ZTDzft0ghEM``|gF>y2S2E=O zKb6QtH#Z-6=Pf7lp8LeM`XXSElC+TH#o=hIsSVPrPBG!Vy)A%MC0cDlJY0ujY|!fE zX#MzwkOJ+kluDWx0x)xwY+*E>o#E{*Ap{+|1s-Ptk=}!-u9(tSG$TsWs2Dx<(#a5BNUv-8Vf%p_GNq ztngMxL#{ke?bE}RaCLh4D<`DoY#2QHj0l^PsRNEaZ3j0N@`$}2koDX_lzmC~V`|yQ&R}NtkWFh|yv5s=yXze>)AsB}eLlaJfm?3FEe-^G z&ddgedSv8EqI5>*GJM*ow=k&$lCUIf#PL(wWBuh68fNWkzH8C#)HeFBsJlASnz-1i zF+nA+*OT(P?OtoL4Ee8_OAP9 zAdedG)$a0+$)(Mq-c%)lBT<5ki}kfi;<8)_CvG8v*g;C8u!XOkkNb}UAHLt6+`weH z0%7Cq?g?Ng}jJbPXomzFt~>eJ4Wjuxe5U z=4U}UE~Y6?9S}AU8|jue?z>>4dR>#js$449`xI!=<_FW1+hEnc$PJ{~f7mTW1+uoW zN#ER^avO$gpRO0IN8yvddr|xytU>h9;TsnjcKxUZ(wTps_pDi%tMjAjUa+wan`-DM zxKi4MoBpya+TG`T3Yzhf%(XNxPlXx0FO>X{ML5#C1ZQ(MpriN6iZUUI#)#@XeO|Dg zw+*!{N!qs6S*f%0o2oNAnsLkF7496(@Y#kx{&G52Pqydm}fvGY?Jj0Zv zntDyiBB+wl4TRD$@snZVPCu+yGl42{7d@W*`yzI+^Y3XX0+!WKo&3SF$~1C~JouZk=TI8v6jR=u?T7Gj;@J2q zP55#PW8Tv>&U#ls9|YDzeHVUuigaq(=aFWNep9}`zbiE|b056Z$g^xcT9$2$BX3Bv z>pkdZhhnCd*3xoYu4)?fjFp3Tl7 zrMqYH?!R{j-)r29bb8%7`pi4RW{?-%PtHyoT6>0;@AVWX;V(C}0xXt7)o5qiyTcH; zNwep!w%v1wxU~j+0eOU-Z{CQKuLq_dclzp+<~2f_+2uwj3*CS18~OEaJU=iW&1VLn z%{A;TG>fRW{#PcAG-gBQxcnBAbYpnJX+YM;nVX-z(=fB|QaxL&PV61!6B}(01tY#* zokWn|9UVK~pLN38T=&t%UhmX0Z725g{0ALh&$x1-UcHsAjt37PEvRBDOzV#TQ6~wW zo*qlkYFq(#|2ij?QLRUo)D8>4ia@ovr>xK{$o2>E0t*Ncz8GjJ6tb?pzf@4BZ`S z`-k|BL`geHrAL} zUS8XNdG3UNB4c@uI2|?gAQl}azCSg`=ai_K<|d~obYBMd5j191AKjr<@YZOs(`Cc) z>$>>c(BXZ=U)c$&Hi{qha-@@pB+@=5Rt-y0&>FZC>9iV1z!1BiG5Jx&(S@GBz4Ay0 zVb7$i=(_0Y9!<*u@udcW!m-U~DO$lc=%{6+*oDBY8FpVK(`{S198~f7YHY(k!%o#<)%6`Yb;4 z2NMPur+1%xOIJ%uc2sY!sndm6Ge;?>(C{UZKlx~EL6etzlGE>s#%ELvGW=FFf09U1 zR;}*Y(z58YQ}T(Ouycg3-mY8J*LXX7Mb;nU-EhdOWsnk!9UioP{q7K`N0A4l=<^bipCW1bC{bl!P*yXVzEv!z!f=9RGgBDxBjC$9CR1~l6In1`n(i(YK6of%3UHzk+kEUF`Bqa%&b?x08 zT9y4Y$TIrPGc|>jZ7GK_Td~J{a_{d@Qd<7LV+!Vhh<99w3$U+bMs@5Fe zw}UguHc6C9y9z=2XFKsA{g}XKgzTt!zfY~NFKV( zk@bo9x;Ka9Pp5aB*vqoW*`F@BlP|$SKii4{l|5Ii?>>Gl2Yk3jMeSvV3RdGHi?fg+ z7q%+3f~$U``xb|U1Fl2a17Ce}U(d5+27;;NiPC8sN4|Hqo;d}0jM~y}!dC(P9saaU zK9c*%#s(Eaa9UbD5d)wcXMB~kD+0@713w4u+kfYla3!`VEJ+cIKY?wy+DqbI`KItaPwdJJ5Iwxp+$?dZlKnWr$) zapX-Y#Bw;e7$nqY!H3uO8JHGfT`UFZfNK3b4!Okg8OvF5rHFulHPsZeWOdw>F_bNy zKd&Q7+AK^jXN~MSRlElZ3qJm0zs0MmP_vPW5#~$sZHN#5(INS7Z2H)^|G=eWY65*4 zRn|bO)P2JTTFg(eH< zN7%IOVildb>7_4hYb)fKG%ZG7;zZy=F7f7?yGF5RF2yM}3Te@oT{E~cIOd+TT52zv zR}xRh5x>cQ=;r3Tr^Ck9!6^V4luIC?r8m>zK+*jC$!aFOZ3&KpYCr$jfuBV~2wwW# zte~G0dRqnG0w)(d9hD_y17v6;Hzy-8Ao#o;=6Xw_QyjWY@U$sNpx&$+nf*6esuuUi zr8@uj<_=*;qa3=7Wt)9wkX&iAf(j0`6V1jyR3qB*)Ry5gTxluWz2HSp)%e$sd7FrRowVZjFq@UkWjDDU;*M#T(*;qzPMj7GPjSYF^|_|cR#sMj zy8LmjVvcu=48J1nhR|&VcR#-#ayRG0gdV#4=#cixFw4XfZFO?@yy!cI`{g2keGvPJ zk4g-|+$-b>!w%U#IEXyn0koXXu$|8nY+RmtP63nQ&k+!{NU-3X0dWS&DP-%~E;)3- zXXM_m_x?Wn-fzU7x9^|GhW{gvl2O;@L$y$%vuVak#Xj5H36X)_IXZY?|zBzTdehh zy?jPTzmWt9hW72I)P7=9=F6&dCd7KEDTN8|S&z$*`}MzGi@nN=KHtNMZojLLglQ>5NDF5^q-)ah&dlF*VNUlHBwcWQi z2>hUNp~&`;U<_}4jDZV;^WgCgunDd5n5{B4;PJvcgr-MHr>wfASxM~c$GT>9i0d&2 z_5{V_haeQ!I;>NEYxrovY6!5_jKFHbI;{Yt2{VTspY9mXySnuKp8m(0X(t*?{8dBa+@@eEf8FzOX;Kc^+!*o!~yt|5ok{TDMtl;2!0QR8)) zQuTw3+Jfn^?tT3{lvbkyebxA^sh?aeSg_sFC8CKl5xg_eg&)XqU~-5};oQx;-fZ(7 zEhIj-(WdH~9flz$sRQr%wbAw8V3^W?M?miO;KS$12s~Dum+YJ{8rI4TPXR(d{7)--SnXvctx63)P`A}nOVi~esYJjaz6NU z8JAor8BSdvy(4JQ3MPGa_Ma^d9M+>l``Y>6dCFtZfbHCQ-&lI~OXtp`yVtwxecL}k|72a z6b~phW_ecT)f^Yl89he|CZ%hnfd>aA!cQ?(I~^@~eP*%E7O)QMeyq%g1agtTdlql~zmcDsoNQ^XY3%AiH{+rz9AQwq`+Wh5f*pFt^LPiuqs_^FhYS zHCH%rZ0nGb{tB;fnYZy&#N)Q+>H$8aA{U|k9Ow1#FOP4hkl#7vHfk;0qq#u0R>zUa zFef`d8ZZh!x#brK@W=z*@>W|NhI82^&l}K@4J%BeS|kbTRvH>RhnnpWPwZih-)s2= z1@dd`)&pM+N+1BZm3Yja*9=;kW z!spRAPSm@#wDpk*iw+)YL9tK(A3Q#NzB__5IXR`m)X>~Ku;4aWM2eQVTbBEhQo zwBY741a#U7mjPpX9Uu-w@B$0}swL|}#PeJ^N(ZJL{L5(g9nM-_r=o-=-`ur5I_-$-}e1nyQuSS%uXp zr?eyA5Pit}#uMEi`CFP0mO1UQ=?kc(l;$3((vI#*4DBG(q?VIZ9<=6U=Kj@kY%L_C zgWF&lpQIu%_~SrGrnw?g@_xMEWK+!A+;@LQ_rl$xW&8+xE>W=WwdS@m4qjs+3%>Kc$3O-y3;Nindv}3BY=zHmcD(=%_ zgH^tQE@iB537@ob7V3a)rKR5X0>p&O)bam|SKr;>RZ5Lnx<{iVac|_G;bzpA(O3wQ zB^77Vd{jWCDLCl|BBjSX8-W*Sjao8K+f%Pd%k~jkN_ncypY?yfb-BLERzc3OMYmz8Kw*dID}WJP?uyueqq z(y{206=m%^8Ti818Pqjh7^IWuIlFo-PKO6*$d;#&vYW8+AAIryX2vb8EbkjT=B3xJ zpAW!93vCv){EkPw!kdX$gRZ2;mb*+0ywNc>;BuXIZ3l+r6lcx4Y!sk_qhmy>-j@w7 z&a|9mHlbB6>B8U=*z{yR4s#F(Y=kqZuE-|du-2KfL0`kP^{c!H$mSk3;v0&%YFnTq z3lqj0koxqE$RN{7jYYdI*Ca}b_vCRQHJtul$8h7}$tcs#EgVeE5M*b~DrEj)*IP6+ zglE0=_i^0$P_+psv4oSUuxl>&h)rfVKZTs$KBL>Ok%8utWW zR;om1LUy>;yWs71Bq85U(wr_69o9pA`Z*qUQBP1217|@{^(iCo4C&|3_4;y`x~0K7 zYuv0Lde)D2P?~|l&_8Ykz}QcQU03E7gFb47)v-r$0Essm9d}YH(W?~AvX+w=1bji& z2azX}&3JRhxa|IO%|*aq2^AW~>xOt+#B_eS7o9?L&db|l|4}*St=W+oL?kUMop{$| z=6bqfT~>w$eKzY}z;Y&PFtNZJb7=@MNR;WKnnUm@@pUOz;lj{d1PuGmp1!+>DJl8Y z>z-kV%bcnsmm3&rxgvPv&YEt#M>|x2I1g7&#P_0Vm~xCb{XotI%_XH%PiNkYqB#Pi zv8#G3vX>P{PF8rUT}ktD>njR=FKaSiNSos?B39kzt~YPun(k(17R@L5d$yIePO{>{&;q%au-9h8c2d@G)AUjGH&li%N5U_3?iyx;{sRU3HEe6Y1Cd!jMEl8P*+rn znUHy!LBzOQrhmnQs_AFf0wLHIRP!!x-wqZ6vZNCW0mK1bFVfwXsZO^q5;y2IR|J7C zQw&zrgOK2n-nWiEB$Iy^XGj^D5Hix=N1K}Ws%gRu`eo~M&t4e!ui6txj z7}slz@(7@zIXM}z{&l!aM2Saut? zvC;$czgY_i=}*j-Z(=owHZtR_)+;c|CLuhIc=VR}-uA`zd6wd8lM4FD=>rY61d_182tf6#Bn^ zio+$Y&jPvgEv;GqO0T`n*v~#q%ZhQd;AO}B^8Q;H1TM5b=7K$TxipUG)|BgvTe9r4 z0%8^BKJ+u(Pk}-dU4DWfMTx~HWtAV61>x;}1tR?kLg9c_NRx>w2OZ&K5I|BOJFbse zUK!7SqT>0R2Mmu1bb4rCpy4&H43$fYh1GNU*(AOO6VUSBkUKoVtX6)xxK`YnFKs` zDdNhRHr6&}6r$>z2l4J^(+2#cCW-8rzh%L={(jN?WEF}kh*HE7>H0MQUtm>A9>+qX zn497rLst(=g-P;Vv7{F57c%bvtxCL%*qP`uAHCBhCsVQ4^9@?yZDY?~rB*G!NKXm{BC5aGaEuAJ z^QeU*ZW$O&UoDQa#&&oVb7y!{%4>Sks-LA7Q^2alUk3X9YAXVE1tAX{oRsUjy*)cK zQ8#b4zZ=0YYV2&>z3^4KgZsyO&c|L)duGOQ0mN==*riD}nM?W(OI0#-xQIf`9jAB( zi-6d-2EUwC<=l>06)o7})7n^B_!Zrtp^KsqvAb1L9iAU1{ zz{$&`nKA9tOVc<9Vu!Wvv9}pJjb=5x>B4^dWXIioZOD2&RgYwOI0mGI=hs?#=iB8k z*AS(Bdmjr?Lj!PamMgjNP zV`DrC8@{8*h4AnCnBDv8Arj2aKC^BbRG$_G9+^zaq1K71gnwS)R}i#3|2sAevNf4U z8XN6^qKc{|MZcei$10tqcQW(@sNy&Mh2-!RL(`l=4QXSNk8ZsEq(IR>q^d4$k)KDk z5l26<&08%z_xlLB1l0E`%>vN-zU9$XA(UD~2!CAG8O)aLPgeXmxe!W0Ndubu0XY$C zOqQLkoX|w)GV2w@2TAZ`VNJ&Z07VMQ6$d=>Q zE4+_L0DyGTrEJM=YG*XuPSD|Sp~DrbV1Wu?RK-mTZH_O)tyN-c*S{UF3?J3~$f}$L zQ<_>fV4W`6wuhE&j7Shwp@n^TifXL{8R_7q5C^=XC0`S;!^fX=2T}%>` z1)gHbx$#J^rdj(|kpR+ZVq&WSU4q@^F*S%Nw$i5#w^ z2fq0o0{hd$d8ds}PlWefYZN#sm|R!`KC2i#zT=wyuC_R{TpZ8Znye5ZL=tG z;i)+WCe^~C#&3~%(iJ6CB@Bnklz;A4Fm7-7g+wizwYMb9yR{3NEkq&mZr|zZQTvDa zf$sY&0zJ+3h9wqs&tiR+pI|U z6EI#LycmdjJ+Xn!?l(sy0-h_4&i`rk>~9r5j$7i93w!tXJ}OP~y1Mv{&m77tvSY9I zLPnN4q)B3`No!`ciw`?l2?$7XyKcXcKhGq1@4twwcYBZV8TsNjCaulKHtz8F2M!j} zC&&smdfMfAZUmBR!71I7z~QBr!@1HXxF`AKlbFNunoe|LzbubKRk5v|y#=odMceu6>PXdc2Pm|_k*O3X8Wb^lQ&@f5O zwN%~QIDDbdm{XqmYv1x;FVY+%>OG&jMhI`_spW)Hz!SCT^EqRsPT$<^`c4RjsIj}# zu$bRJ)~R@#`rE+>QDfK6Z zDK^^Bzx6;-Jz0FO#CM?lPbNj=bbjNpl*!cxe138YlqOYu^YPijlOwr0j3KO@|5&{9 zsPGjUH02nRTz*;iRVDcy{OhoSuKzHQ;*D;#vXXR*!ox$CGFaqxr{?V|P*Pc$=AIp) z(@}+}maN)eh^9m?R%AnFXLR*a_i0laAz46e2K6!fSjp{ae z^*-7${K4j4N$d24{czvCsa_2QTs|$6*d9Ag&W!J0n+ z#i^=>5`Ll8tPI-?A&hHuvD5({bX04zkHnfKc%bjwel6lSml}w#THEtwMD}lptyPoz z4eIlO=7aU%g>1d<3@@60>j%kf>(qkslen}4U7H@=vrVXVRg-g7XM6`(@?HL}m4Z%w z)xglO2O&@{D2;+6B}p1YQWu?QGUsV-z<(jv9||nLe3G6Sw`M#G4Pj@Fuc)Cx`4Tb} zb;>>Kj+1_z3yG2UVfXo{Cg~#(l^5vfNPeXSTYEXg?cyj4MXKwnY4Cv8IHcd+Ybh3@JTrJr*;<8Fv#hn4k<$DqFd-bU_k_yaxN;~US{VqkZd$FRGBsh&-%z())QoHpM&rD1B{ z)?2v#;$_3c*6ZboXVt;9#aczjFL7)+cHX}CG~`{tbzef8?>@Sa5OctFh|=BW^N{3g z<`6vf%KmztSKnE9&>^2GHDLsg|NXrY^1K+?sX*2f2zTCwC)1vxpGBX0Bc3+rFub02 zKi}M>>FeiST+Z7K0NIKO7(_}lN3IL2iuzs7d(5LH7i^>a@O`Z>9-Iu6hk@R->R zJ6Qa@PhWcH!qNSB4)9!WpQ?pVnGL%{N^Esi7p%btr9UnB>Mnv#`7hwjVJ$}`0g;W% zo0I6){m-?EyneSwp^k>R7e{x&1Vi*)0zy`@NtFRK%wsbn0tCmb8eH_9MD+Vw_8)aV zycgTbwru~NpK7}5X>E1*Jj^jNCNvmjp>}osO#i37IYATK81Miz}^IEO0WTEDuLbA_EjIpr5O)wko4FPtCuNJ}cFSFjqW z>`*3?Q<&)YAocaf~cZrCWgksPeR7ZLDNH)6E?M<47x7G8R*%;%I6a=|68O2a>aCDMkfcsToj@beqaT zJ!{*r^msvW%+7ySWYZNFiZ_#Ym6EF@`Ls-_)oA@E(yzykg*`C|WNNoCBaqJcF zlm_{SCqqD>f1}6iKV?ZA{eeDm8;_{-o)qr0){4J31 z2C{vT&Am76<&I+j3kV8qEytvH`CWy(FJ5f~JYx7=Jqdt>N^6LlX7#K23OH(5N@|o9 z56sQJ#Z<-dz2cc0ygjI%~4V5_7V@ zmRpXOP^p1-Eq#)+9i&Ui~ZEf zFy)J3jDiW$hdU=f|7g)Stf^1!>(IShHBZLgbLaC(DWBE|^9TpLKV);UL@tm0A@x0z z)7nm|KNCk{#MARbhFv!8`-JL#GW>>5-@Zmma#NB_vegc+VEGw)TG8sviU&AO3g}bo z;6N}Exf<_L#emYjlNl8b$iccUWfDx@e~AVeB6Y#dP7OE;CfFCL^A@(r8C_PF1@~oH z$adM&S6?k#wEvX##R2vZ=GvtB$qqjnT}FI{HA_=k&S(+Z%}|`<<anbJMgU6)(DJA$xBN})i_C%5k^&1>`KvlPNbWEQZ$mFY4 ztXolOmu9K3C;)h~6KG?0761Y_A!?+GC5gW?A2RLJzE4^8kHB5Iv`(ew{_2Bxa>i^z z4tmq&_k**9YHUYN6Vr~`Eq^%?^Xbj1|-*IbtL~YQB1Nq(PpvaPA#mqYZxUwB^*2!_Qh(dXplZ< z`Gm)bS>Bv$!y?%k-&#L%SxZyG{cB44#_?w<6e4ZH>ab z9Ro28bRP1}uBp||o34n2e1+g6^$5m~NK`RFCdl@!X3mKk+FCPUq4AyotABF}mT(VE zzS;U{NO7tZb6BIaUyvNY(KhLcd3ns*j_|p^1$N#CpJU^Vh1T44c*7h-@9JRU^ z8Pb%vHtwwbSUt@M+4J1)66e^OJHcx@?QdoR-`t>;&+qKVW!g2m>DC zl!2GdV>~cXuk-}bfL{r(cM0vjF!WL@D;E2>%n8c(4jZdho+?*&TLyy;eK~#pWMY2l ze2(ib&K|v0HSkEN@Z$@u%+QcM`;^WENv^O@#B!BMi|zeWYo4p0+jx$iCtSFjhlkAQ z#zY@*iCGW{MlfeL4jY(EPL#=90A#VZb#$4!w&RP5MU}9Y{hUa1K5y$7u;PdDb_w{8 z@y5aV0i(xrLFymaT60sN48>Zm%1Pr4*3<4X-w~dtA(1Da$yDd@Rwpt`YCaiCszdU= z?2&AKyvK0PBMh0vUu}B-110EcB7AHD4hbXsw|mj~6eD(zbk(x`^pv9Pp}dgFFj^HF zKv3A_G??5x_!|%0`DHaa`@OP`jvhm>sW_)*WZ2-RPd4i<2Mp|k{62#z!-Jf3ZAbJR zY3j4Z_>CX3YIaVZ;NXna09;eOInz{etNW)>{*+1qk)GZAO1@$U*^`Kepicb~-YmE{zI3DIVeT22)>s^naob>7vTA;wnn z_h@qsjQh2lLe~mnEn<^Tcn28x=e`3+e=yT;(pgC<6!Advc0J4R1jP5MoGMo{>OOO# z1{7sU+n*Aa2KVv&%1j*7GpjN?&#iRWJ-AM;oSXwC?>STtz>j&3(c$-X3>jw0V}G96Ro@ z3hcEoA1JG)^p1M5Kav(aazhJq9xx>!s-3&=qk0Jbrztns4@idm9K^n?`pY8K3woPJ zdo(W)GfHNKmumM`iqL{{mK#luv1LtDQ*e$()@f0>Guk;tj2@ShadcffPLruXx zLd9>*U7l%3ww zO4O2`v1U$e!Yyav9wS;Uw>n0Y#xA_gHZTC-S$@kykk}Y=V@D-jUoqP^j>-`5aD@HH zrX%6+?C94>egB}H!3`A=LI4v5Vnii%0V0Ea+P|B`bzs3+ZlMW!g3->IgyG_|T~*YQQ9*xnfOux` zY}NEwnNR!f<C^+C?KcM(F&WFme)_a2h@91ZJrKUtg{U5B3jjUG|D`+he83z&Mn2z)V$ z4H;UAR(idoSC44D>wH!69(MX)7U25zveM`!dC=a%Ij`($Np3VSb?t_)Y0!Fvi(P5%~KewF-_#C|+Z_ok=`GvdUTv#cYe{yEA zmmkY{K$b6`Z`r->pYVEREKg$z=^nbxx-(tvUcbni`cHA7$L@TYU*HB!%*-S?mG$-e z5HBfw?)1EAdp##3=);2v|Jgt56FNC*wqLO0wVUcSoLK8KVB*OS+5i7WiQlWgqLL9; z9F8yIBb+Vd;^D(&<9k4b&>nw^8)G(}tUw#BDIw-v!%HHZ;Q<)hR~Vc|gG90ok!cB8 z#t1<366YHkB+YQ+zrnZ0Y~X>PWm7upW`^`GHbbW{(lTlJ#iAx@5}6YHc-c{7wr(v8 zcX3}P-shi~R6siuxVDtjenD?KdVVq*7YA%m&t){DOW(asc<5Jji*p>1f>}^Ox!?bP zG@VscTwB*|PY5Kz9SRHXS`gfVI|O%kcL*Nb3isgd?(T(K2p-(s-R}NwYyUfq2a3IF z?K%4x-CF<`Lq|x6>O3uANDZ4Cu_oUsnoyav8s685&g&*IzGI__4m6S6WINU}jUi&P z;%?KdO(huTZ%CMClUmNtfz?Gz(-2e!$IV>Qu`-86_46SGsY%u)82_Bvr` zTh~E^)#pzT*TvCza?U9)rhM~9ScH8fI!j?BS<@|x3ZpAbIeK%0b)fY#MFpBlrm*HE z%j@p_xQknnjQF;s@RnL;$;HnLOp3LE@}SYPwTOwmh_X69&x>F70KOPm&p6q%bHxXH zjyEJ#gfG2X;44OaIjb@pCrt5oLEOFto<=cjtuGZJiL!eonI#3S@C!D&G1&vUptO^Q z5}HUsnH9;5%EB~ju#i!?c|BfiT8D!O4G&^eMWj(!5DDGQ5B#9AG8wmEl6++kl&Vab z!w}2W~Et!&t_}Gf?Mq&Q03y!{|hY?zqX+24aZD@S6TrBz%K)rS7zc#=0SFh%@ zQ-+7D_H&j-^1Xr6c6UHogMMlRZCjbX9( zU;L3$$(#DrB_;SaeWpDP>R+L$n>#y@xib_X%J=i_D(v;u$Ltg-31ck==$Nk6V7%00 zNuH%pAtN3Xw4yIv9E!r;XpE}eu4>hm*kQbD;?E+=t zE}0!z&%9oL!S$(A4+(yE)DMnZ$JJdsnJd8BDCV3>t(>Uq^$f53af@EBBW;+9?S{Wv zzdH%+vb(sVtEAcQy|x9}wDRc%Ca;=|I5toIvytoqzvgU5NG2Oj1DeuullBbG(eent zUz<&O*BY4D(s3kYtSag4 zuMgGl1uyhj#tj#_`JTW`+_9#Fs|1^vzhh|Do%n)U@C`^uKLm|Mvgvj48MPCUr04w& zDy0aO0)+!mGM)NngNECaUBNk}oyq_+8AaPan;KOy633-#?k=wFW85i_H^~6Qcz|Pp z8#bN!o~_)9%D5TwN)_g(fRtgKLNS*7Bom2Z(CFEp(cpY6UnCk;65_$Hdsf^7QO>g5 z#`KZ2v}QD7tA88n@w`5JsU+>bJc!=Slj0brm!uaXDMt?=-Bu*&K7V7)o}jqGNQGu) zkkOi()pHAkuNf15hFa!1u}?O}mlS@71mUT_^v>faCaoIG{RLUW?uO?PcrsO2IV6ej zZdOm>jv1vX+B|2`iuI=A_hShk{w!QsST@iZWRdSH4x6_11O_Phj4+KEnhZF9qRMo_ zES*ZND$}6DES^t78-fC&ZH6XnNCp)LoJBp4yCGw@A>dDCO}Tai4QdpW-*F+dxXwal zbgex}GoXf&!9b1YhCDt6DORdFhl@&A3zfsG{2<=}3{V1VQYDGhjpLU(t=jqUuaq+C z_|C$-z;dLE&{#-$pTascZNPd$1}8H}hQ3UGYEI=wiZGtEVkII}}oO9BUo>|IsiXhJ{Sh5P_*?$F0&P z;YJJ=q+vsrzg*2*Fw*=T9pU{ii0pt}{H+t!NLv{imL)2cyIZD}r>JN_9@m_Y`)nua z?+cQyfrMaL;tz3EEZNPgprE)XpD=0zA{$L6b%+2fT=*woDLx|YFS?Fe_XN!H71e(K z>0++>FD;8w5g%j3#5l)7bo#e%d#;+=hJrN4K_U)RradFBl4^O}w0m~~aBTAV0r@-b z700bR-g}MHGlTSq1$+JLr(1$HTLsyg)CsV-(z1$tLll~P63n%FjJux|B4X!aN};eL z`@-X@NqAW#?WnspS6hx*!lP4=GO#p%}NoE9b(oXPi}{4&AT|LK_sIgAr*kV%?jY@ zV?6^=38f-S!p27Lo8Hg=ze0)F=LP-LX7X~0yIP+pHwu=;`|WWb$hqh+C6sL)Z3V2( zWhC-b4@qcfJ3G98h&fv~Z*0!d6%E-eb7(WCLEh%N*tUe)OuL!8mLrPpUec9a9UWo z$TRa%_1vr`{o`eNdC=)YNF+B?3$)P`s*3LYBX5(@$N;y1CR@HOL59*vRdOtb$iiv? zBs^w*blo*P=vzo?z(so_BX5^h+iHB^i$bZMNa{sl&kbB`UZr6MRS`)*zvC59C_ZD) z@sEdZ$H5)dx)HKx`^aw+_9e+WgKFuyiIL8n&RU~dCQg;L`S}u6`Ey;4Q}2ez0G@W6 zb8AL>6*+0U(XX<2-A2?bh>N0hzmqwzmm0@$hB!mEhj-0HIKzP4MKkx__>cJc=sa`US%@GA6~{) zCOi`%boVN*%ud#kS=7@+Y@(z=h`(^CS0;Ii;Ou+vgBRmK<- zzNu5rHbF3oDzwz1Gap-``pZ@r^d2qzi&hJBw6%CzRw&4iB%w4>46PUf)sRzTb#kA) zx};V}n=m8n^oaz=o0K*TswR86+bgn1*fuA}xglj_XBt!*JJ;@=Y{i4HfPbLPlNU&a zsfu@vU*y;|qK;}pJ{_jwrBXQ=iSqE{*$MHm9W?o7B*WhAsHnvts9|3QQX(rr#hkaD zhtl&LCyHe*Y)fg^Y-Q4iZu;52q9digNvvEpRh-7lqBbBs9UD|;B5y&?sz-U47A_mH z#U*807F&N2L`}?+)c>sUTU;Uo~Z;?;^F6H80ZZfUakWPNth3lv3TXbzEwHzUx(ZYIZbUUe38$bFaMzsqB zAPwH{J}9FQW@lf%9;amJ={U{VhD#SMy>hY2lT(`yvGQv$0Td3PrBH2_?GKv^8FbQ{ z7j>!z9P4%0%GRd(zze^o@E45iGSdzc0dvKx5YWJ%I-&s{Rw)em?$ZIzbj+mshY?H> zQF=K+B&2?gvIq#fk**~7>O+x_ETq2?RcVVUT^#y#TDDY{UGxQ;+&sFZirH zIVI1{&uiAXR--lUI9TQA>MOOPwz#Zh4V2F{GbGEP*smI{xORBH2CVyB^2#$;{k*(N z#AQ}^*jrh6xog&+b^oY3SJPfkk1M!jBWK#j+oY}+a80DNn?O+0@$r=R*IX%)C<<8AA!*ET7&-*1+-{;M% z%fpQUvQ>sb)gbI<4>m-bmJSOCT_bm?m3eU!4wVk6R%s~0T5TE|WWb=K|58=$KRe5E zDWr{qq9g90l|;UZnf@3}6UTTa)+mlvA5V2*qb%^9Z9h z4MrJFDCSRckQqX_B?eekoF#+iu|rpgJuSZ>)qYmFD_|Dd@8aN`-{nD z3=m(nDyscEV!1>SIJsp6hi9W}Yg#g?Fmk%aQMs8D1@tlSNo>AXdCPP7nb=iTBk($G z67hqC^QuT)I`i`^a2^ZCMPk|#NZ~+DpH1s`OF5-FGRZH3>nU5hNxa-CW17~zzx1^I z18_U)WK~Su%Mz(@U0dBK{}!|`86}=e(mw9D*^P3G<$8}Sj-)gURbY?eKg|UGfh2ry zRk_5$ZDxR5mWjUdcvhVE`=lDAi9FxqK9z;&#yN6hSg+~q=_xt~%Hs2o?o5+^ z-1(WayAAQlsU^&9IEa8w%_XPkKS0z{BszL>Nyqh@sy0=I-!y^F?DJ7sUa6I0ow?<( z6VC4(S!2pKt$DsO(E@3-6vyZ`4233=0?cJ9oJhP9NwVa>@~ymi_j#SEMd{`y2Rz=X z6r=MJRrBgb>J4|$Nr_S6myDnkv_6-Q=Tf_wSKwrsZmb`a^6Ww18G<#Gx!v58gDee} z=Ktw2mNrm{TI|bkh-|zZMeG_yEBZ-pIG<+Nh=OpdYsd5k%JZsle`+q=o8nu}B<)^Y z%t!Ip{J|+lk|&72-$Aon4sn}jEeany4T)tlMxbaoaO)T<4!XxwKbCQGb8qo^PWD#s zSyVVVKN;h-%`hn$Ao*aV8vJ;Fe)^s$%;{7G1u?3mCePjDqD2p-=^4#uGpAM zC#M~VyFiBTnBJ{pBL7r5EKN6InHWT#n4A3xF9DXB(8GMGYC$E*q_o(H1c-Gwxp)UP zu`jDsEU1s0u_ewEem!$`b@XQonG$#k8fJ`gYhM+yiWgYR|hT*ethyS~VZR!*bQorQvq(+5X7&@d} zV{)Hi&zbI6V{&i&7{Q1ln!FJkh~P*{2#q-6%p}j(h2jhap7aJ)?I0+r8jh`%W%IRF z)wq6Cvyp`ddL<<^$FL}rxkW!%o-nDOFyJ)E$wU;=lLO8lJn2tAbr*JEB#$`wpS`>S zW^Ky1icu^~rtEZG+0wMCn=>-95`J)&DjA_-&M40QH4U{a`JKFEL!}(e67IB!{W{Er z(E-7xHCDMKp!QBADsN<+OKoPu^Vo-!6Undiv8V@;q@i$|a-`GGkXTH(wfEA{mes|- zT#tAqf@MjCYsJDNv}RSXtEOq3?=fuJ~(=tw> z(6VGtXjHkuqGnM}E?MNx_}A?C#KQ{<-iT3?dZH9Ic2Hy8OX7SApgpD`9%$pXHbE$N zHd0ePnJ`yU8HChDmsf5m-@7MYy;?+-(Vf`zf-uwVWOfPDqhvosCGX2y%ZcKn7P3R} zT%=qP1*YwJRp!T!#3M#FMx=_=l~YarWw9w=*o20+Wsck^;6Z&0N=?N&bT~4yvbTzV z^`R9HbIJbNy4Z-d1Slphb9;OBnxpr-&7)$GbxiLZCw3_*$p~iLYZl1^DP48AWHRaF zQSNXp$REdMTY9oAtXg@{39XsZxJ@&Wz)vhKw`1{PKANbRWM6#v+8ngN6vtL}71#bj zPsRt~d^{hZO9G4Zdz08E1H5p3lPTe6;ndW=pz<)cYNx!0V3B+m+zU=f7qXQ+{ti(Oo~N#ivFDf@ynf zqOj7GN1m$A_juuBQo8JMJE?=iMq5uL`FAMtjSJzW zcou18If-n^(47+rJqmlZjvfgihP=@_u9*}d)u@w0Dm==S(YOGbpQ>t32jo}{GhR=I zCiP1gojPA4mjbY0R^4PSKA0or6H`ttMM$!k(keMOL5vFssH-@LM)AK2cm^r4el5ac z!V{vDk#Dr%SuUb_2rqKOh{Yn)U4Ylf|Cw!!wfYN8hJ_z0gw-$If+VN=0jBxV*NE_w zQS7aTGG|_4_|`27=~@Os*(})) z@R@}E7Y)&!(V9VH&^(PLXhy7<^rBR;Ylvd~olADmm&%jG+!pT{KaC=BaViy|aeQto z7K{@to`k|+E=1Z~pH{Mnj+k?=wEjS z?|pwl*=%=So65}P;S6xZ#UNQ z)^vS+hT;@H6iG;%DI{*qi;CHkP&J;X5^TcAeIw=XR)_yvdP~3gbhjQ3-A-=^MH>z( z9XokIeN;r{|En3JVu7G`Qf`YQthc_oyHCr}UyOLku1VIIBuKQGs8y>PcxuU?on@ZC{{LR;W`_HT<^A!X(SC|1VOz<5K%A?2UC)B)jb#iRa?cp=P zd;j&1J$2XPQL{!Rw@bAC`;+?1Rf>N7Z*8RT&Q;1+H}Wj4O#8NBPbR!B1wqfz?DvWF znw17VuRDk#7Gf4n9Q}NHR{l01f@c1CtJR0sW*Z}qmw=pPU9wNVJjZmt);=|7)_-|P zpD_a*Bu*Z_y(7m1`ao($;e5TAm)BhFM=^JQ@0)H>?8Do$IYTm{z;kcR!{fT&Lj4DnvmZA)4*D;z4S6K7{t6j4b&uJVsX|K*(IQZlh64a**8b5#PS{q$BeK!aBII6e=x@bU05%P5$UcV{LA=eKg5yx{` zL=cT>&7gs7?UedDP&wh$X!4CKDNUqlwFz+}X6`i*BUdTi&sOt~J+r#`V8|w=KRrJ# zQT8u79#4{bd3o8iM~_9)>vjDcYt|>ae7H28na{}1MfSc}Yya2f6Y99l&D&bgggrkW zdySm`+IE~w)W$Na>u;ZH;*&eZwPGQrx#nqRj0Hek^gw;b)D6w7=#` zO+A|V=-^T?Y}6bZ7Aw2fH~^`p{7vd@4SF1NclSN=VF*pfthQH$5lHL}6`fQ0DYyzT zfS~{RT>u|$aCY(%P;n(k)4`ar+C`i;WzGu2fiHL~JcQ>}T7o`RB4j%F~e;Pn(+0b1*XNcbS32UqG;56$cz#RW~z&D}aJq zyg~2U#BgD?fEy7OKY=d@e}Do^xH@?Y#E2dzHB6BqpbV(Qb?e&i0lUierQPpc@M@$u zd)k)Q_tM>O>iS%-W)}eDA4PE(U#}yIgx{Tt;wEMo16qv#OmtDJ2zCvCMrtc zf#iGGB)&}7fBgt#`OFE|)_d~{+E6w5GBr0SaxBc)FtThAT>6Je)tj9I6qH`c=8HE5 z+t{N&f_2aD$sB)+`V%-EhV90OgSV)et#jIn>TqOn*sIG^y?5RMKNEiaT64&Qw}5|$ zRmI#OYj%-k%M8u|2P&jFCfX4IAih*ZhLmzUe!j`XUlqo&!T6ESZFclD6JZVuTCo#m z5;Q}D{)Q)lrC!iSZ=pSB2l6bejnshT+zK-7^c5-sM!`m31r`1G)%3v92dOOQfMfI{*3FTi3Jtk5>eyl8|X0 z^>gK2eN{cbKatM++hBI{aiXFKctb@&NhO*Dm_O&_vG2NgVRiB+&j2hpdV9P8Kww}} z$}W!!&~XsELl+lykbj+0$F(5N81w(J0C(CT+m`o7k>q{)(YmHR*gO2(oE3%^0;2MmHk!s>5$O2_z8Nhybb8 zjn6Ukg#9&xbd*ztNmxSKY7EQ%krO!Ch+%Csv=!6)4Ksp-5P0*7 zQXrbVeD0H=IHUTx7pH)zps-myi1@#)o%g zomp8(MIf;HH&X%{a9k6=iW$7$H=_tBN#-R#{QL-5uMGdGem4@-sGLtMyvPZMPcmW7 zM`Pa|H2NT2W==e?4q_`UWgrw6+C&OYE}05CL4~!W32#vd)W zM7m5|&r4Nm&h2q0?2jdttB|6FJd^&`9YJ%8(<}bqlpk~=fu8SmOQ3p64PX(z;RJ6z zH7Zwx;7(<4hO!TRmKgv28zcc`F-Q*pdXefhDt}%~kV9FVYBhkK3}qwg!|$P?%1W{g zr#)9jB5B1G6qJ)6_ERTNE{wOfyhqCSs~?Z9s~@+iv#*~8U;L-uFC?jV&EW?A12$JAdf|tr!aGKHw3Z`Ag}ltEAD1`=6_>M6+$}ywai)VTqy+ ztw5;LN&J1o=;EH%bf(YxeyZ$Y6Ko!t5bmGaQBk{t>klCE2@|rgeZH%+HhE!9qn_4) z*#zUu{rH2>eDWq+2~N)^SfTyNe^S3fb*Sp5mfCWm( zFzqiU-b@ptvh zsPOxwriIP(u-Pn9TfUjJUwk>+)UP_skGGkAjd{VZqlZOs{TG1i`sDHltyA{f@3y|@ z8ux&M6B7rq@Tr4;x-6;etmt)VWgGnot7=S*$$gB zWWlgG2TS+qAy9i=k|FBu$S{W5M;L9FMhJ8G(7nO)OLxQxcvd*GP7;Q8V8%x)5y&hc zd*E+`=TkQjsVgY_Sc@Ee+)1s%q^kG2{hen6oYo&FCvjxWB|z3}p^J{bZcyOU4rVHm zp+0(&h|#cNO3lo=n14Puj0~`C-#xqrss`5ZXKSFzunq{ zcS`9)*@f>{D&~KlTdD)2&)=%;xrqFcRlAQ{0Sa9$Q|8$|BTJDBgt9TDNqk;65LPX! zT~T4m7fIEHmOii>5l|b;1vHE=760?uCz|Bs2V`>!mpCq(dAk15S1kDrC2L~mWcUb` zQc}t|?4)8(hOw|*>e8WAIWEy;`dP~$AjhFp-a`R;Mu!WEt(1`7XZgteV1zZJ6d@JS znA)PDQ=`LhB`+gho8UQW!h=mw(TG)umZC(42sSM^u<1SEFG^GqF2sgvN>dXVhGAfA z`NWztjj}0ZX}E}l{-H~_{$47o8}4R+YRme`Sfd0m z;U~-XfrIo-__IF0v66x!NJo(s<*K!K!*JnWkNhPGoMY4M>Dy1iQFj&vatR#7)r^f}QP$NcZM!K;2R!ThPz4b6Z?lFMWUc7b%?{*qGQPZ6t++QB zr$i>hG*oy|&%!4ZnSh!)eD>wmI-Jv|-9cFLc$4~FRIoo3(ItBCo6;G_<}l0|+}FG@ zuh-AAd>b^FmYNuC7e;UwOc907`pV19c+yTJETpAS+P=t&I)ds<8ANL%lT_0>cfcZG zjLG3Ou=r(Nmq2$9&yY7qKJh0{X0INQA<)3od@5jg^l$*H&J}>cB_gY&GBA!1O&a!& zmHR-Gi5ZiJmI1*rl-oqwW|>CS?Yd!KagzZUPgS9DT)7B%;{v6dwfa*YXs>ajkrGw~ z)8xk(ps%^5&+qsOxgT*vvIj!56%?7PismnBiE<`N5gQHcbQ#;E`c z)9!Ahc?Ac-T8ncM@!OofgUc;K@j^8#H{Z_A4XiOckV409s%Y`u{^Wb&2zBuOIWTew zc2%wa`5JL*CS}Q3#-Ilgp)n*8*n}89}yt)$bo4 zx_zgtY7HMfKjfRUrm-Sr6#&BL>2KJ_gK&UacQGV8>{|_+rcJz3!Kz(2PzdJaFJlg>`(9Se@(0giz^*Xq zL5&;%aw6E?B|*>l0rV$U(&V&BjB-eZ{m=i}>4nb*0zU@}|`J?)WaJ)5gj`12-$I&?_GOCrY6+>^mbe^qI> z*O9`*N%wAZ3(H1rDid85kiwhn@t}&{uV63|>y_&86p?t$J-M_LnT{}1-v+s=>S&fA z0;jIEVSYXuG=$#b2tMJ^r2D?p@BR9v4Vk()^u{(@FcKVkrBS8Z9@6XJ=@jmGb9A$)BT=1&>R*Z)KUZ8B5uu>gcI&pX^n&zg5ksHSv z#h-j$*s{PJU1J&E-{RMzr7g=l5IxH4DH)h?2~hQ5k0*0AEJ5fW*(8jo9@H7vgjbOA zsIzI5orGmkiS39zE|Y#ZhY!a=)jNx5v)keS!a4%hs;MLWIe&}|)o5A)Y|mnU;I|=s z`X0aYlk(1+ZcdXmXD_yi-?$B94-NxIAS~j*yl-$i%4L;gxggH~bwF!uy= z9hrU|!?6-wR~D3+1v5Lsuri9_!|CwT;lHJ8+l-{R6jUrRAw?C|D*BVJJo!QR zidD!1k~d#}STNEpS+eC?;fFY)F%y3}CqHg7<`C@B46IMS^_1a6K_ZpR(4#uHu&#wp zyAerKcASe{>~;3AhQyVX&d@+>C4%F4{929BYUMS#8>E+-YSPcbdWN)8*u0QQA&F{i zcAOB~p~8OJ_4fOu=&@6-|2eDb zyoCDV`hB}tr_DEfkY&SENR~g%$;oNlTVRN5$qz-Bxt9wJsGvtb69d)W^wd~9;7Vz; zgx~4v)te2Qy$kwRlPmUDsDAf|YhL$6Z%608y@fKxFK4KJByf1gaeSenY$3imbc6|Y zMm%Y`SPi;UkBwjupHQ)HApUfS9Hfj68uGAHVY@=?~0F@Yc{mc(UQQn9}2&4w@OjRChsrmKxe0y{gvFj6Iv z$ftd&Zq2TcK6;BB75v46H6r=@fM4EF9DDlIGUnyf5T96CnG%d&#wz_|)SpEL@o%)7 z?f$&Yc8;%qOnvWH-V0cx?N)2GDh@apeOAVfk%UOBz>bGEiKlLZ*XD@h3e4EV!5z#C znl*~5ra1WFFixy#WRlsk8Nem&X5jra-s3sH!L3XA;#jN z&pO?1;VI_KT>4cWZ$}y0&Fej?*nW4LKt9dOz4iHyXsyjXw5^uU`zE4Tfgfzk&6Vop zF3iHwgB+0I@FV7tWyb)@JCW( zU~)BwD6f#k=ovpWt7M0*P7M)L$WoYasX|?8mt2_Hwn0|6v2P!toyH2Cb1zPNl=p8Q z1Drr&w~E}XgOd}?uky0aUCaBlAvDtkRgSI5JH-G4BLfhx(pN*ys+@*sDNQ9@%GpC% z*l%K_MhzR`hU2Nj!fo3drR6ZDCZkDf1Z`Va`@toLlfnoA%` zPP(S^fm_pj32rzs7|Txeuta*utkXa%g^Loi?)ut!FH~Y2CHj(vqhC^Us^spj=3ECu zNhh+5i!!)&{q>CZ{AP0VA~Wx)9me1@0jd6hmyih+<`YTE;3POd>PvN7RX<3RIEZB1 zRVn@q<8lJo*Q8TR5l8jwbs$HCBid0GV?>8va>+`Y<$&8U!+b;%Bdo$G4_SV&QnLml zTpB+47-9@@Ga+&2v^)R%)cdP;h@;3l^=O@eK>F-0zrNoqGM#3b71<`4hip>VH&wNG zbJ%jVK5R)vrp?^*CAUhffXSI=UHRBZF728nH_a~xGt&Q1>x@R;JZ(*U;)*H6tw$7w z$;SU^;b~iwhkG0M;3NZuFj&J=Md0Mzl+v~7dx)OX9{7r1{fKupV4h4KX-%2yb8jSw zZ8T9Wfh*%LMoNTmaU#L!cfw$*gM9CGFJ@(?+)}B2%P7htUB2=P1f|3rhGVChtU4yr z_|6xPIqX6jx!!!0K3b7=_jnw0Y%x^?6XWcmiraX9 z&-868pjGz1MaV>cg@);`Xp+OrNK*5m3d9zR@#a!{VV9qRsHIS|3%seWfjnPc>-NNid3Cr}l(kw5cuJ56ocp z|Ek@{hy#>ME5(TLAGyKM?<=;Y6}b!yE4%Uk>-BbV>H!=lBlWoE-Y=IQWpf{&-pDZ` zw43dnA4e&xRy&~W=j*$HsP9Jj<c%1EiO*7x?w*1d$(gRb5nkOFAkI4ug}aL zcPEg!LAcqajIrkR4ZpV|PVcK*Yn9wEE%f*=Y2H{WWlg}4S#)UV`!G=}Ed#lKiOD)( zsmDvlR?AoFqm2?4m__?2rg}z%P8#iTQW+)%Z#j)vT4l?-r0IbdV_iuR+U|l?cv3EY ze)wc(zpbR@ma&{#QG$FENP&+ml0(4fdA_MOo*p8l2&PALksRq zTFI>y`O?X(X0)z+Me@D{nU)A)@E=@ES@X}|>OY3W{`9Fexe3p~)@4%hM#^)W65@>` z>98-p416dJS4=!A3|oWLS>Rz~7#m%DH768PG)h8u(w4p9^|oZXYiMlAGgxW5(H-K7 zE=Yt$$}<>#HoOY9%^b6i7)XWpQ!9Uk6|*L#YRgN!2M_YiGnvZ8J>Jvq%;nr8z4p}O zGPk;)Gj_didZ~zw;AXET-a7T$zaP_6VGh}Fh*=NKl`nW)9DrAvBow!F z#KN-j8ej#@)MLD3+>S@FcDEFzg36_(Qus_}tRgTpWxnQ9yEI7#pc=o~S+?#Z?)*7t zT^Mv~YA3*)*F=)OT58NECd-eJHCO&_Sjm?@2`|lOQkMN!?n*OS@pFFyj)n(5 z7y)Lt4mwOBW4V_Q(!T_Yjp;}j^tB8_PF0yR%EBy>YIlRG_Q!lYy&XdMJ*7cKP-rU| zZk6VW@icc06|Z!_1*45&=~2K^M=nDJ*XP)v87DH#p`e2gA$H$GCAXz3l*W&KpSq3J zQ!CKQNg2|sjj_LyZ1C+ z_pir&$5KP7VBlgAy#+EO_W6jdg4s0~KQM?am~+(VTm)mfJ{8$gPU(!L%~ z7AqED(!$Y;*=Hj4`3i$pJ8Sb@XnQ}8<{8ws<4!mvZMI*f@|Ze*zc!xK)A@mgVc4Qo+3LHE4;ZiC z&naNctMwJtF~9QrLWi<_{mbz?Vq8{xq6ii=7}dQm2XV;+K9(uf1tf`27X)wa0zI1T zgIZ&oBVfUYONED>^3N}4_0$Hz?6Oq@N%6I_O}5T{vGuKuW-HAeCTZ?j(gOnGn&@0w zDfjkt)VZ1!^(wA%E3P&i=`Zi5JyuOCOd=2yv2P*2lrYLQlL~*#8pNczHW{?9#$R>e zW(LPB=VZW!SR7x36TXma(#A;|B2t+S_L@lB0&b`Qyrts>*R*!@DCxRqH|`T7!p~Hy zBQ89Kv%upt-h&{*i3EfP~jbT!03PRo7mV6tC+%s;r(lw9*%&014dS7l~EXT5x4Z89T8} zag~_;J8%4&Y$PDKh^`rkv1t#=-1*^t)s;^f*~x+t!n)_$XGgfMVwB6Kb+x76%~QPEl<}3AEo~lR zEU^M)eEY7O{hpPn5@@@h=Il$QM?Q1$a}O^6kG1_{%X{QR)fUdRH55H!B5YVdKd)s@ zOQ@Ndb!T-y6WPsYazDj&lNT9Qr!~!;&L@sumSjq6UJ`ftSjBSklnnYfA*zICtfm=} z%7ZoyQFOssrkR}5`;i2vyC9vLVjGDrcK%V(GJd}0&mK!6iCev>-r?}K9()gtMs~7A z6_~QpO0i;~`zGkSZqn7#!?0DOVf`xWCx7vgVZK^D+X1ht!L5?(h*Ad>BaFpA8`p&y zcODe;T1V2c?Y@MH(r;-q2*rq>1b^ZDbJ0{OAW7JhQr&*`w`5C75>A|hy0DtJAF?_s ze6uuO2U|)a7)ga2eSkOqk2u^|lsaidFB*+6VFWhQJxx*QoWGxCV>F-+16_3SgWf0fsl+OS zMH`wc4YL#NvgNJ%LsfG_J;^OU#td?gse-Z}@EpfDm5frmRi7+4Wo&Y#w0IC9xfNzX zUrx2C(1L>Mle>;t#1+-xg#TN1V###yWEpfPfLz_2{(jtq05^i`mt7gXZeKa2a2a)` zZOjfn-jAoLlY5D#gHD}0FSpiIvmpfT=hG^1>8CP4B8z+<;C9D zr_H~%=Z@j@1z$pB)T@-#*yU6mU08Z`|Aj0j9Fv5qQ6stq;WSmw4Cx7}_T4A~zb9mfAC-i+yHsVPT66;P^{zNs?fP z!TL~s8cF;>@6C$jDv6dC4#X%o0r$rjh%3!s-)i$ZKkW*I4}sH2p=e8XLDIO!qwSLs zOE&VW-%{&Hat?>$aI2@lVo|Iiax2Ceri6n`oJ~ZtbtXzYM_REBV#>LQ{TrX5h9-Yh zNGK`GW4ZI~*@;)ajp2L!{Vx z=@^+%iJkX^URTf9^d0a?lLuo<(!(KWy1i~Iqjo%_4<7p?sG5unzd+Gd(`F-cWNjytJ$>23BcKC z?xp!dPM@1n-ivm=vqRy-?Jk~a6t0*w2qw_@Xc*^(3hTM#sahuchW?KQ2TSO?mL#g&!q^2aw3o@-Oz` ze2mA!Jnz02hy;ejdR>X(d9IqhYugASmW(SC9Jo$-f+eF`MFL<+^mxZ{Bie*pnK_k! zmx*=kLL{xU*CXK--IDl}mQ4~S9Q9$7;$zQ|x5` zi0GzoKUUE=%JrLpXpSRxBwnWXRYY@(lB#l;2H$Xua?<2AY_-UY7AhdQbtsr{AImGf z1#JxPKd{H|Q2BjgzSD^3Qe3th^X5pR4dp=M-kJl|KHqlACMM0d@a6uofL38jn@vj4 zjE0bUhJeFJ+&TJb=#>Wv14M&-S8_2JQZUZyRuO7lfrH4F&U@X7h1TQwEM2F|J89`9 z)jq3h%Y><;mXF1=8BY z)u+I1N?dp_Gq?YniTNhiyXigZ&C{Q%Lzxd6O6_IvXYtfIi+FNN?;e0Fzm@JYdy2DE zzKQ|Hd}sf(-#oCy54_X55^BEWCNH15XIb`J7$|dMy94NhV&1+ z)hE|pZ~-BXfz{@-tGD|#Lyk;fyx6y^?S7!9{r0Nw2lx`brMq-MaBS`UwJcN@3}Tk(l6Ox#ID+k9qm>6~TK>j*po& zHS^hw!bq1ALtwkvuwJiGG0+rcc8b{VlM4J|Yt*six!Mag6`VYAud zW1?y1wB1NMdbWOKND<$US*@O}bJ}Ln+lUWA8VA0!2I{Ow@Ln`IJMor`-^u&+L|IMp z?p&q|8W@LxcDt5KEGAM264sI_m_fXeQsh`misIE)DT$V0^m#OGkpRv3C+Jq4rKKR)|}*)zoDH1PO#e6#wMUTPx9rly!~wo^cp(g%vi07Qvdz zlP~YRjMevHHZr-e)_iB5%zS2pTGFYUr;v{Cnv{Tx^&8wOIKyRn(LJFizOjNW`{?Vb;ZqFx4C-r7K>LG{PX|# z|M=A}f6dD$FKJgTKlt9Cp{!xM>G}9SKOqJY@Ejf-@ZpEws8C^m*+ID#1#z}%bri~KjIHxJf@yCoL;)bda)!9TR!~Y9e)1vpE93LDawLxpFF1T zI^MW-6F-hjCll_x^%m~-8&p=)tyfe{!}FIf8OKCbRZJ%}g)^8W@0TR2MF!tfR}B`4 zc-2~CwN(CES-HfcL`MoBj97q8BE_VgL^*_11nE;E@lGQmPRJ)^!8P$`u-m^I92)BS!n zWr3H<4ghPdz+8gtM|T(b&L-rvk<_bP8Ou&y?TLBAIPMD|pSygO{pte95WtFY7PMHj zcHZn=7IZ)M@_ox|lp;@Gw(XW-5N5qIl5XdUg4J5M)y5XQczMRAA4pb&vYWP*WIQFQ zZOVucce&ok=WpzuLOG5jJFdjeO6yD^lN=wUbK50HBKm^lBUW2XR-FeQnKjcaY?8gE z$wgvHBA7!7Sx;qAT*`j-*=&L}mW1&6cl5d4d1bAoE()xDk@388 zKRF|m&@u0|t;;LBIC6Y2=k#FCq;`zMR$N74WbC`VQc8quchgGZwN;+@P3nob5Bia= z?Q)}sU|Ed_7qu0;qqUZ#HS_raLqCXhHc#Z76HU+JV#%awvWqNbz*A(kUbDPdiultD z%*vG|tM!JT{q^7Q{U7{*Cy$?@(KN2)_~;mv&_iD>7d-g(8Ll*3y?U8KK^zCn-`$vh zqzxGcA+VLg2qd802%dGl*`o4?Q{^2*=}Hlwjh?a;UUSS?MCYuiJ@>v?xk#-w)K$sY z^{iJ*IpFgllal!Qj4^qa;dAz`r*3LN54sZTDu!{yda z9o?|y?CiB1h_)0VptgMb@-?5`|AuAPGd-B`#;u#E;F(n=P3hQdmfW~`jlcP)f8_Ox z=RCOoHP%|@vkC9N|2~htc}!d`FeK)ObBwe6;ge5z^7I8K$Hy{8A~6mf8V2z^QjY0E1yYE{{ zXDF;;=vq<~1Fq8FC1x38@JTMVlrQ_;*xhIeb=XDuDkET&o$q`chP_gJ_wRTwmddJ< z@$ya~F7cU?_dWE|y^o_L7HTbGQl+J1D{LX%`6z z_q~WPU9msML>MTqS%_nDj>H_^;>R9>r>;ussuK80jM(h!j#2bHCJUrujHKK==)7az z+3A80_%L#M>4*>_kG6^Q~}JbW=&dNwTIGNl8{6TB&@YD-t#w`*%>Zn=K}(eNax!j)N`>9(8tKXf1-sm=b+I z(03zaKW6uZ*afYYB)h_BEQv{BDXpSVk)|wA3YxmcTEncF>@8nAOWDrdpp?o)IZNF% zgcxOQ;v6CCQg&oPwTm^*V&Bnws=AU!Bqb>{td$hRoC@fJ1QxBf8>X`ZZr!}ijq5is z+R%2ATQa7^^ze}1{O8A3W5EANCw+fB=MwPENxQVbj(9Z0fKX0VgUAFgE_LbkR5 zO2#88?=%h$=Aq3KIYmiXS9JX#!o9h~$X3mS*B1+3 zygK8~TX*^4kA6ts_dI*?l*Pq@^?J?Y$4{uLlKJ5rA3ftB^tFT8A;UP(4-sn$=JR9L z%a*S{e?VbMnrcGV_0&zn>+=Px#ga=`uJOV5e~2m^ueWPv$49*Xmp|mn8@D(5Xg3HH8oE*-n>w-k0E(*T+ z<{O?qej;mwu}U3O-)r49337=Me4)? zH}>QHK=aXO`rsy4v1MMJxV^oR45ZnOg+mOOLX^=ed!tnr7Ns4~!kT=T7BYrKL{hSa zHViS*jRR4s93tWIG2{#ag{y0}!^qk40*tT?d_Q1NOv(}q7!tK}q~NK_f~u@gIn8bK zA^YqL>ayNPAa1r>R;x9y&tA!RRw<4T=bRoMFtl5-s#t?nnlKD(w=4YEaWHE*m`^ZP zx(PpeVn{i@GBISfbw3O;77sCZNGgxqMf8+Hl+-Z2i^I%pfIR&uvO1jHvB#a)TL~Ct z=zHnH@*X{S0a{qADU8J#DbhudmYCEHeb+N|14Y(1SSzE#vXJp>Akp?cV@Px%lAPo9 zV#%uOX!{;pRHz7A3szG==@F9zIZc$;H1s|Dot$hUvrQ~p+_Xkng>xlnjrTzk+kkE> z0?(=_NXVt6Gx`;!_B2bA3s4PA>YB2&gdpB=tA#2yjw6$%mQ_w}7JN5|M?PP2GPUv) zg&`@KvW#O-Q5x>P^(JrLdy}@?aJ!kZ_(cNYIi{ z5T(HD`=0H#qZ>w)wFL3tBDo$i;m}ruaGSQH%Md5w{|A;U*?}ho7?Xv%il7ujOt`vc zet5*)d+%_3aw^_+9~eSn*|q4R;9|4pe6bXvrqwj_18iLrjbgFg^8Dfgv|)B|$hB)% zSuU5HzrMiy{mp}qoU;^VLFp{p^+t9dt`s5Hc8#*TC_Wi+0F?Q#PFc}7hJnG$p45jx zQ%_J@vu!)6_7LT7Srlkg78ponri{ip#~6~l3ArQlQTB8RXxjm_MP=1+%m_Y{6`F#d z6f&Ir4rBg34JsiQeoP{i(~7RkF@kvnQWfIq7Iw7GwiU73%ns%ZUKF-y5DRt&){anJqCodJ1DGwCwgpR3y)vEgT`FTnLJXce~xP*{t#7K-&rh?_k<+`Sg^7 z`IMoPaERl>LvezHk$$_ysKlhHa8~cTX+Mlin(4m7-a$cR1a0;Xl(Hx&%aUC}op{}4 z)sXTieZND8{eHY{+r27$w<8=!QT^_^vtjho$)=PqDCy3n6BRYLijk_QBziL?5jy5e z%_8*3cIf5%Fh*QalU&KV>lhPg>#(k%s%wNmw%dj4%q5e8U80psd99gcFW6|g-*-ii z6fGjOl8#knQl&sqTpoc+p(%U>@;E#@)F8@a$!f`puv&cDIxDROhGGbQ*cYK82s6NF zlSlU{uiGSf&>FGGp`?qen~Lddiq@JZkDt3UN5+gm z-uctXuUiUhmBosgyAb8Or?O6F_g6|0wD_iX9lZA;yQajMl2qDH5VY2~vLHmU7LVRD z#*wb=8M~1bgy~Q^M`aaSMRW`t&8JLCN1+mgfu^vMHYwOpu|Qglv3bhyCmOG+sRi+y zKfjb2{8FG33a^w(Tffg~}J-y4wQe2tdWqw!%d(OF5XczcM5!Ya#oD6mgYA%5Aqo%(W;EBYU*+w0?{V*)dxRtjROMvCyfRF#UgN!cZ}Yp~{hn{X zd5p0F5}IV>;qFT}Yo^TVM!ekPKvl|~(-n^BM^YFu3X&fgx-B6{I-YTcL}G}ZkVI8F zc#j_gqaSJ8mZTFZ$=KC7ht-*46#_%w(QjLP2+ZaOXe$NbYP}GlU0q?E}h1q z7<7tEijqQ$a=)?~rqr(GEPL5qRuui%jnZL;eBrp;~*S5qga*_j74nx`b zTM^=%5b3PR!8iSPK_)SNr=)j9kvZiOiZc!gS6DXdjp%+t;PWrOV6|THEs4t7z1tBGx&gUj*$+Kew63g`p^Z!%zX3drzXL{a~nJd@0_dY|-Bj$l1K(I+Pr&g#fg=9%q z+fu6~UC1Gad}03%{tDkXd}B+#v?YZV9STc!M@!u#dknHk0w6KeTy?6>xQ8|6%1mE; zxp%>cs0$zpRp;!pRu1p?zRznV=9F2PVU%T!OR`MOBIm z-^*gJ0c#B7;6$Qya+4p%QMm6~({)mLxy3|wLx)T5&C!jVFE7#tZ#X-@V6*9Y{&daQ z54`!t4LiNhrIUs>)ifZf1BHTdra+y$B!OSR3$gx`x=Y7;^_G^{>I<@n~dIb@7@Eh zUb@VFGhSXFPRF%w_+qPx7 zT1!+(DXJo;%5pNIU?i=;976B}psH(;a}&r#>zB^+cC|*SNNzLgDktAAE@7hYTf7%! za$S^ERmEnrVjRXarl{oI3R2xV^dpm(&1Y~US#q^Y5k`s+rI^~b-Ec_wPLpk0pI*xF z&N(^krd#`VM*daj?lzXRodplWz_!gyX}zPQt(Gg$q`xEVVqzh|b;fRB7zVUabX`Z= zuQ@$GV;Fk0Hq_0G(MLuUQEfMKO^kB*$gO0eqt>Xz1dqTljY;uSyYH{>C62i5A6F@5 zP!=sRKKS9OEUGFF=v7t0H-Ub}`d+X$Js)Wsa^>HC(|az!(50LA(F8MklW z`{bX}T{OBX|K#q zUQy+i%4QfHQPDB0b4r`DXet(Ug&#*^5L25@3a>%!y33t&Vj4|KaY%|^)N-h`MJ{UN zI519*u5HP+p)PWYEXQcbGt1;h#%>@+&onw>N~aj5S)N}|rTDeARyZ9o(ziWDVTnFs zqB!E~vY@USh{8Z2iege_l6Wx+s-hxJo+>ZWfk70L-gQLf`SSh)R_hD0s1(tolDsM@>Vk0`B|f8+^uT6HX6;!i(FN~0y*Q^C9X@J|wM-!}TP)CRi!qwA&S}>d z%<7qZ7~{y$30hI5ligym5c$0*m=apDC@kJtGHuAM^x_tUr5}yVJ~MF)20t)`NM6>g z*DErmgeVqdZZ{^`|McuwBz9Yo=a#}QaL&>89ojn{A6-yXP!uJ@(39te!3lkA=tr6Y zzV*?&eE7k;WLh5H^RpL;UN#^mOnH!-*&%sZ0`T)+e9FT|N345?^NMosGOM;@?;vM# z0}~Smm-e}K^#<>~|324l-DNY3{NgWu%JF~rk6fHQqw6}3j!$@gbWEmUQI@>>_B*(r z{fu_A?TE6+4-y$yy?mfECvlq|sD)Q#nzmCZZGON)|169F)`A>eAi}Mx#=HL82 z!?>aA#Dfusi6XZ&MUIVu{i-B4ns)Rw$<()~a{9jK+Lf!!W()GN0A+Y~e8ReSS$!}A~=ydC*z5XEB1i^03ZNKL_t&twpK;W!D5etgT0;Op2?wu zqRw-ykrJ2HYDHO=RAnU3b95AaxW9K;L(CT_@v-yc9g8)(q1?RTQ+{ z8l5C{6(LL_k6W9`fj4Y9(o&ovh8!gr=5!z!CXrId^qy@OV_-Kw-^%V1_0ddmN~Xe+ ztN9f%y$u6pQ_A0oCdO^FXJnd2bf$1#P@hF5Xxv#dC(BAQ59_6@D;Y{WI7-l`K~VT) znWPt*vP#8IT4F*WnYy&5sB*lM@rTlB91>F`HHhMHv0CnK^IAzfc5s5(RZ%V^M6kJJ z=OtdZL2HSgg)rfUk)pJ+877`LL5hHyrs4GT6t4ogEhU>R$#;wvLsW>7JTH>`t`U1c zVCX$3=L56Z7i76*vsrWb>LqU6xWT6%|BCxxp5n$9r6LCh2N+{mcP*cO_G`ZQ{9&4z zXGtBEI95>z*0`<ZL0mwB(KVq05 zjhzZ>**~~MWGGSN?LmP_)gVzXY$dy>2-<1k1BG?`aNKM^L!H1sT*8pe@03}i*VOJW5z z$-d?sT7wR$@^|voR#GEHUNQNRpcSUbP=#jME_rzW1^Wkuyhr=jFR^@a0x2ilwkZfc21a-60SrKO|z@bVS>6nBw{mmKKi#to5fm~i7#NGy;{FJlB~>mf$U zydVxOmk#!+>zd7`+nqdBBK^3b=kRhZj?B^1%p1DRhUL-|rk>aC?(v%+{RUSL_n7(? z7aUb3n_C_&nwUTVfXT2XXL)|k(`Tpr;ul}CY#j$zud{Ij&ySu<(aJb5wkyE%gYSQr zs-E#@fAJT%Km7}whi)8b+YNj3oW)+vrM)?oH9ULzn0McOoBbbrhoAh*|BZkD@BS^{ z`rzv@Id0s%2FE8n_^Y4u%fI?1zyA0OE{;z*+&@4dj$)FTqT}_uw^0a1Yk7Vl#WlgR zYB#j&4L5Jz|Hvfm^X4e$#b}R8QK=sYq)ch-}wiBmxqt;^TiiWb}ws;p7nA~ zQRFx+n}sbKlpksG0&f&~)o?yJ)~ClX_SCZl2bT_c_l;L^)5PPW=Nz4!^6cms?|N~> zXOd3_u-f1=IRzI*!K&?uT9N4tPh^}Nby?wh#}o#pK|m=AnH@XlsH%!9SFXrRHn8I; zxM`qmW%I162BW1cB=!TtAmlO?zp?=iBP5?lo>f#;!8G(TTT>#-Z#Ped4uIKgMv-Sb z8{SwoOEyUk{kq|HdwDz(C?ono-LFe#pA4LZo5F*=8_8D(8DInQ#rB+rW7hK*LlX%Z8akEpQy z?9@(`h}$j)MB>ru24|EerpnK+{^Q-0qGb}bMJx2q^d)oJs%lU{@1$g+s3%jDpWzfH z;-u2=-;O{$nKm5Eg=#sU*Sz=MyA-9YBW0CiOQ>t9*j%qy+`M@M?>&F?M}La%6Qd$Y z|1Z^+j>(TqVZdbNZlj)(mt;o|+&))9U|TVIVw8BG6zs@NaC^7|@ePC&JKg^KFb={J zH-<>!yKiyC-lLVpN5`fggpH8pOkqL=Pf?Y!K^sdL1>%y`2Ah{GhYm$Rc~Q73TT<8( zO<-16WJa-CUQib$%4AHD#7B_2r4)5hrDp-MvOpJ>WxF8+X=uE>cR<^& zsceBYC3RKeM%qXkr`uhxjW~;hzjVvr^=JrQ%iKzW}2p6(5AIW zYx#K$gN&5r=aDLi-9$GIC^bkaP+pIl{8s2~JE_ZKSW?pA>n{yP7+>jcu zBC~mu9(0MRjKhTYuv~7~v?Ei{^ga?Y%jt5(>BUNbF^dI8L*KRBymfcSeuIj zHwMZ=vo|ZbcI6U2j?^St+sm$&G8jy@XMoauDjj)`XXxFW{v6X_^&mBNVs9(N{{bH{YkoEgDI$ z#Ay;TUKHb!MENpuYblEYt8^mKNk#Ii8xv_PvT0k;5?5=xKBZlfJ8f%Lik^S~T0)Qw zN~n`U2PClxqJ}AiWYXHo^TK}L0kU5p>{IUDdxX|- z_s(T*+`7VBZ@$GVuiPa}6GOk@=xD<<$)O1qu~stX0f)qqbxJP@nNWU@g(#WoFa`V+ zq#D&^$=D{($258|1u9_Inf}u77JP*C9L#4kG9#^X-aAY#?)t5~PHOk-hY_U>o-JBf z(pA=GDMK#rwoh2usG>BZ#ff&=kz2*QuH{`Tb1|K+Tdd8g%8E>zWSmuOy6&YBRH+n4 zmd!Uyo(i8-snIzU;08%ADDNc#r!-}0WnJE^B)%2|K4fxHe!Ememf0+MMgrTTbWk$h z(nd^#$|!lS(?Mw)4~<$1pj0waqBK5&526BU0?aLmaSV+T#e38C^81;P|1|CHNiON zm||cGK?JA>Loy(E?~?&zP2cr&U5i56XN-n@e7X10%LJ)~QaB;C@=zE&F#C1KH zHBx`)1g^p42$M@ME<1Ol6mj%~DWY?6))!^Di_LYNm;l?hhv0eZ&D(tEqi=HK@;-}M zK~-cZ?*LC#S7bJ0({8@f&Ljtz`D_oO=IH1IHwEh1f~XC%{XMQ-zscd@WoAvq&1=^& zD&V~1)}31fWMLZyAvM`tv$vR06d83>G7K%xUp(dJ&8u9wd4=mAywCLFh$_$cjrZSY zeQ|+`np?N-^7!!)559arRn0kmam;4DmK<;txv?%wqL<@!-*M?+U*>t!$Z~l>pGrvPvpMIdC&CtwQ97Jspe#y>LRpJSWGbbl zxi3$~7reX*(>Tx+1+%IWJZ3_F`b0#N+pX~D$8o}?o2;8AdgpLn5UO3@@#6RxpQL)% zOQ-pwsmU{)Vof>2&~b8n%*n~Ikf+i-ck*JiQZWb^DIr9I_snKST)QRqynELC(}i&dI=Q#1Ah?Pik-G>kZ_ql_OilMz+M5CUhL7Go`glLM5| znzBm188=~ai_J3O$cHIW+qO4gp^@czfkH|~whF`6*k`oGXhR5&M9h-dDkRz*yR5!e z309P5-MiY;Ae|Ax$FG!mO;s^p%ytI`=Nx5OasU29E??f~@L-R&UCRcm1x~Y_m2a8* zG04}yb=}9PQamjIV_l$uu~PDTbKTo52bB(P-$G=Tug)Kc7>V1y&n^IRBV6;zcmVFpZw|rX?Vy zOk1O#bK~ykGN!(REwOL%9$N}mWo&y6_7+sua_QgzKRH43dhrI?EKi&QwIkqZBQ?5{ z_eB44WFf>-A@D)m^(kxtP?<>^x{?T8-OMSgDp4Kf@{5r~N7qUErW-n@RMUHQe$MDd znx>&{=G?w@2lHF+9{kX1jZGx4+)9D_#l<;+NHc3do0PE&iDV>HpUh;~EGI8Y*6WQ( zVMbsJxy=Yc2u)ikjB_$G87I%##W`K)7$yNEWSPJr$}E#bS1F3jkZVJjCOHM?6;qh# z`hm9XDDs^B`CORslb0T4lo;qLDTLUXA6)Rs;Tlt(SwQ@o?FZF&48y>3xrQJ{i?`l* zmA77hjWW-ehL+0OR4^m+lHlF09x%_vETSTe!${rC=(?VVj~=tFh`qQt7gzo;(yi8n z(UEJ#$%`X7eH|V$45Pf%QE+}Llb304zF_DF%EEH<##IOtzyAE!eE9n7lvT|ye)^Ym zo0gyaFpW*6h#c=%|?7$gHX$dXeg{T;<9eUt=}}UL3#R zT7uicfGktO0vi;Qb7E@A^K=`Pq7R8TOU^sQzJ6LqT4t@ ~%a<(A8r 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≀_c5_qtDL>aa@JGt0s27`gr?L@=>P=Q%bsO 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↰)?<)&AQvYBD#M9 zzHou#7JY^S@$_oF`Ll=EwF`#z7P>Gu4ELJ=jC${FB7MwtJ{IZNirT86U4CaTTPSrm zhNytX#3vdsn)7m!Dpz~wK|!*h^{c33V}@|xFIn(md)r|SVPhxaK>)#E$=@?Uvfj%6 z3tjZ)2KH~%K@E@gz6SP7%WGE}2AlhI89T{^89%J8Lrl{gw+~!aymw!NCfQak$A25Y zUZg{zuKYXB4N^(cFx5?xJ^_QlMJd&Ue$_A$6?Phw$)=0{?S9U7yEImJ4lL$kR zB%?c5@HYEHXGAf)6PFn^>aWH@EKPR^Uu^k&w+Q6dz&n*y)xdaD@0$=^ZqN;80;Ztv zDe^_ukx*NqtBvrbx@LKGQzm9+EF@C0rUwMSd&z%eTxZcQaC`V=)#w@P%XaI|$}vb+ z;I&xN!_cl!XO-UzFU7g^ig%o>h7iyeoY~zij?VmV?SZ9O1hb)haA}Fe6*Gqp`Q-rP z`9HF&(}hIaC~(>Wxc7^~Vwax;Y1RA>5rHm*lV>4mb<99^(3|{qOAQz4t#|Z9V-QsY z82z_#+;ltqZBJ8=ZhGdva}?GHDO$qv!#8M<+zM4tA@0T(JOD49AelvxszTO^S?gvg zEiDzeo-?_;d8gazncnW-zd0PH749mKyoMwM5L)#?i1Ei`TotumKk;vI)P{$z7WpzH zr!7SKT^m10d<@QIuL&-xR0M%=_->;N#Z#fC9=_-YuUC~Kdc^=B-b}2Rh$+86E*{$V zUZD7%7X!U-AcZ=P-$2cRL~{Jl1@2wh%7-GrnpMOIl_AG%UJ_GL~ zO2wAZ6<@MmNAb&iVp@;(A|~)J%td(UuRrb2Jk8`;+oCp(MF^_7-66Kd(uI3dIiEqe zi;rnFW3D(5M+fgr>DZ^G9b2s#CLt$JTix08$gBcNUP9TVKOdZY3TI_BQlNN3kC)tq zl(6Dvg{g5X+F-`PSfr0O#&2EAtveiv`1gu`q$t>D+js>pmle}Mrj+Yq0?c^x#D5W6 z=zHG90gz(hmOjs%mw3)6t@c20y&x)3z~#xwgZ=x|uyge+sX^!6#+q z{R?gGm~1rMUqPySfR;lNbYvg0GBa=GSsGtz5z0v{WG>ANP(lKZi})7m=(>G$WIPS7 z&GeL`!2^O3W?TV729^A4Go7g^)3~>YT_W@sa479CDv>PPl1kDavalY1iMOR?@^X`^ z@%dXl8sfGmtt6vP6@ng-mU(bpw+yxq42)8=3_6RcvDkZcfNU?f9U;mDKK7f6iG}5C zXYo`qo@nuc0dQAxQqdBn6i|YkuGd$0*Rz(dXt@vzMdHNB=ynJ{D#^?Qo6?_D(#$&L9KQ+3P%<(p&FKU)qiriJ6!# zHTAU(J?x_FNH+Of6rJUW^U9q()6vB*@4t(?~3;88CswaR)jZ2vgNrH z^UkK}`t!>v*%QOp)YLSedo7C^@OgZDyHM>v-5;@Xd@pkz4a+QKEpGl#Pj61_ZPp%0 z&0peH4a=rC&O^w?Qcv0CX}P$7BSjws15jSi;{z+KXRQ; zUZ^XQxVFw=ozj07yfyZDSw7Wuugb6DKQJci1W9PZ!cP&in4l#_etdZdCEAl*Y|@<97!pinm`U z(lA&m?4I6#jb4f>*b{(Y27&LPvYxHY2nscTKaOIwk4PyU=VaEu zQ0iAr_1fCT+Z09F24LrvOmGNie%2kjLJWNM>eH6=cM;VZq+%s*7p<&fC2bR}4zPv_ z95OQ%4CB7CR48pN#$+4~3=6^&S#u#*qV6ON?GMjA!q>_U5I3E(_F0@dWDnW>} zGs6v*K)zvUu2Ph2#?B=W=SDIa^?KnLkEq+7gJRT?u!U6OK0{VdjuU$_k?P>sc0?-@-ZfF@T-9}jVfmQfFpW{R= zJ)y4Xm0R{`p=*LorGa;+205*(=GIOjcDx(6SQHGcWN=|Nh49J|fGPmT3bM?-~7 zfrHYnp!+JwB2vH&>CL&W|5j+Q$c*x`RH^VFXNt_p8%Zrbh@k9c71MrBLIQQcJnVZ1 z3b9_pXP8OcE+L5OUAHAiwrz)ci411DML50HrY31WwFw&mJ3+LAZHQ|rC}z7_hh6K7 z1UDi`uL24kIyqtSNXTWyh6T-L*gLmkFJM@qdH zm%+Z1B9mU!~VK<0C<&PrV%0Z+!VgU#5eQj!F5YyRzM zaJ}8TQ76lR6xY)3jiuKx==(>^MJV{`)%KUVj6J+I2v*Rs@)m!mQl@|`fdaK=9zEm9 zGRS>*I6NZ6i$vIyq!*fegf_Q8dVbPGB&Ka;-jt@;phgjg(v8eSHo`KTs7)eaDD!*u___~P z{S@|}wdM+6C6$zn6$BZ~BkD+c+g;L=PyJ%^EvoJme6Bg(^F*2Cn_}6?#M*q285;tayy|VC zg+<}4<$Z^PDNApRo=xOg`z1p!^Tn<2T&lP>cGpVrz)ovm>H&@{n0Xwr|L;56)YW*} z6s{cRdUUpDV(xwpcXIZ`GA9%4?l6va<}iBN`J#$e&a7!_HXj_{%S6!avaEGkD*EL+ z2PODNkhGqLB5Hc2<%iIo%HP^CS#C9BNDb*MBGkA|n++S64BfNBkw@vzOR7QbEnyZ+ zgHATRIZTe;3a?nAm`%zXxI{T$Z5wKdzEY#t?R}F^T|N!{(e%cwe~yzC@lRfjcY(eD7sAFUvYHN#yWVy&;6?oSGkNNg3h4|t!LO? zi#PRW>$V-RQM%`oRTGK`O-;?UaRA{Sp^A2J@JbgLwQ$p>$I;5Ds=WJIE9{<0Tsw2u z0rZik35e9xbU%=J|0H{x#^*sY3ajQrC`(Ed zi&428Nm*p!q$)#|Q>mmXYi_gk(y7WKi|m||ZBmhBl|@mOY>}p^0R%vRfB*uGMt7t8 zpZ`0Zb8Z&j?WVKBRQT(!zUQ8EzVCbA=VdgWp?prKoAUWDe2yrUAc}mR@$OIl7Nr!& zPn|&PfGp23T9YI(MPA^XC7;i@e*LOsPeTI)ss-m8PUg!gM+zjT*FS7*nGuyrsv&u9$^8f9Sw&t{RMruPQ4^PI z7|-TRrc%$FJ-)##E3HZ66dE9mX}sUo3dg-D?9t}#okZYjB~@ZkHKMr&>svah zxQ|epQAAec1SX^^3smznbj}gR5!pO%ASjjO);F#Cx~{RVA-j1w%)R$VSXt{VwW4tV ze0o^>S~V6W>6#cF$TL&I+Sgi9*{Z2(C8NUDmRec*{T?PXV!f-y9@%cU>2|xc(iW|D zr{RG&o4*&#XWD9`bb!$nvw6;ymtJP$^clYQ-S6@KKfK2;fAvf9EMs|jk=6A@k~AbM zX5__`?VX2Arenr~3A@|7#6e7)h!D;r%z9r-r>FMPvCv919o~C7t(IsGr zba|FZ(WMkoB&cfN0EB96}y*aVm$k z_cehEh@zOVh6hoZ0|s18Gk5`N=b zUwGrMzxxBSY0kmHhzEDKxOe+LcmDQ$;?acuGf#8;%xO$E<>Onom`*0N(w1bz1`6j2 z>Lz9`jUtSR#1^H+;rowHY7VDtPr9v|%T!3S5_+1}#IzxO3x{pvqsmXA1d{sJdo zdKpZF&noI!j_LGh*U*V0jvZU$i(mN)Fa6dl{Oljz#o9cs8Z7C1IeT%voDn;MG?@&wu#$|BlVe zm&x*sz-X2i`YbGVh!X>D$Z#;`_RVW--G9h%IAT1RHaXQoW1{xh+7ZUGfz(Q2n?pj? zHDy`RiW@itV)e?(lF4*RWi5-#%LIo27wa)v(J~RP%CS{JkDOs8n0C@R}*Vp64)c_A%mEofVh zbf79*39$~TvV$mWsuB?{}t0v1Q&t*%O`_+|9a#LN0x zSPV_eLpQ>sK+CAXn1EUdwca&=6Jvz)F3kWD1X|~t-^$E0GQ?hx*Y&s)~1G>F7%j+xj`U{vOW>yre zuC37Nwiq4^7z__sT3+PMxBi^#H$I}j(8k(=<<%uQ7(;_~j)TDgzV12e~GfR-2V7B z2M0qgZ+-?^35!ax(Cx6;>+@*qAxSI;Q54CHS5Y(1=7d4QbUG7Zk%GT|`>*ixDJM5C zaq-+42Kxu>@9%@JdFmT~$g|IGlInnBcc1M$cS)iaqtTeo>9f%5qDKSXdFO4ay5{uL zPxJic%RG7E9Ctst$!DK?k+mnEgsm-#>5SK2e;qZ?`JeyefAQ^a|B%(yl;8eW-y(nf zh+eq07*QMX< z(oS0>NkkNdP4r%Zsx{N;oH!QLVxARfr5KMUEG;Y(nt-Y(sT+FGY&Ind45v>X=j_I5 zy4?=Lg8>J7`@H+^dwl1ux43iXw!8pJ6GsWHR*${?0fXU~qLi?hPMXk8BI>fj6%|F6 z5k_ItA()XBmMBe0;nkhF$5ZiPF0D|Mj=P_1^JoWPO0V0( zR|R2Yc;Tfh+`M&*2M+ z&tKl;vzI@M)`nX*?|?RRx?Q}NKo8wqN&)fRRuyrSkhaohc50fgO+gsP%<_!UcuLys zlC;`n^Ni7WLhUSJs7L}s5{5^}Qs)Kz8bvXSy#=ThwsJ>@k|mzP;u?9)wC1_uMW?KWYkNZS!lJ+;A!6YGqp6SjA@ zSwFUh^Pb6cN}41r_IvcZ3*5i6MPypUQAY z@{sZet`?`DF&bqgebX4xC@C#5szs3>&F4Wd&RT0~>+nt-9fyKP`D~8X$>9i0v;t9M zt(4Y`2@UNurMJ*02t#&ucG=zACyEkWbFmaVZa@^6W*h@6D=Xxg2${>uVS*54KDDEI z=VhcAiVmUE>4?Utt}&6=IctT8kkb@f$r_BJ2=m{*^}BD>f#KTC>)hMgqbTRxxpRkB z+T!e)v$RaeX%bi}&AW`@ut=zVaf~ z-8*D?#@TaEFrCfGCNr${^!p3kx$|rCGG}x1Sx`0KfAdWa9`5qeAN?Et>6I7JYRdH+ z*ZApo|1Sr_eV*NXhB%IR`|Tg{%b)MD_h`c2_6^o+Xpe{d#s7JWI5u2)U=iBtb+wO^8CxbT+0e3TD#@2ak7| zPsf;A0zJwi$64{l&L$%U2UEhJrqk_W%Mw@B3{H+ zq!jZ~7Gn+QfZe^v*wT{3A(2s}Q9!@lCXHiMqyEo}g8hSi;xOj?`D48J;&UWv$XCAn z1ukB?z|D_8W;~v-x)@T-3ZB|H#p|zsjmw{XjtiGAa_^H*`1tn6BvDFPl7R<_$ z{o#n(7{X8pXG&{1fC6w;NnYgSMbXS>X%1JzJTEAUipu(CZY@r9+o-gCt*DhE3}Qfh z@RtOfLu4nS*z zD=WgL4QjL^G$FE zfI50-bOROws5Q7o5q{`|IEtPPG(i+lRt3IxR7J^jJYqhZ;%z0D3nQ)tV?;1_7|Uv{ z6}CQdfFFW{f*?3L&=2i;&f5k}TS0Rvb{;C{$;yJkXvD#AM1N@k6UAg%P85Z7I-Q2S zE(wU!*_675yeQB*ATOo!mLw_j*_<$pSY2IZG!%eP+7dUwJfAm#Omc8L>zL2x1VKoa z&+)z{O;gN&|IgoiWAitDgI8aBjc@$Xzvi{CzfL>Qj3;B}*_FtE{d>EU&Jxw7kN}GaHoJ^I&hAy@P#5(<$3KdsyfA`X9W`>iRk#UjK-@ zckl9OZ=db$ZT9wdxqa^*&%Jns&%OG2R#w+||NZy)!S{c})`MFd>$I@0VDR`c{e>PY zD=R#F@PLDZ0Uv#I1MM}R*}Tkpr;B>(BF~<`!2kZ!KczjIaQt_Ehl^kQGB3aWFL-|A z6k89sSwC@{3%~#SJomy2y!z4;eEy$&hD%Rf;O5Pb`0jV!VmO@e%5T5K+WH!+Yioo- zh}Tk;oZL7?7$|=A;Z>HXSy@{nO*@RInRrzjFYe;oen`HFa_aDdwRV#t}1!F zx5Liv4v!!2Q|1Lxpb0|5sgrAb?W=Rg~tICqX? z>&M88g34JmhHkq{uiK^FZnOLNG5dp|z-8JU0-&8l_^P0jCKzf$Wyt3<27?2<_iUUz z$+7iyYF{y*j#yq?^V{{n4q`QU?Jf`c;~ zr&(QE#+GAVerc2c^v8cptJUEz-~0{-qnX&Wtay+mQB5CJB_54!#9>M)R3HjrS9`2? zlnvA*x0cy#CeVzcz?Kru6Ndq|DwxkRCX)$T%RD}gQ@pR6gg2=G>jtS=Bg|`U0s*%S%Cm6Rf`R-5iA%jAf%!wFj^m3i@M!zBmR;(E_IEot$daim&|NFMJrfY zU1ByJGM{HSZ}HCa{PWNA!t*b1?b>ywqdECJqm#4LS-%8ZkOS3gbpPN_V5yvWpk>cB8lbVgA!5R>dH!U@hOR;1Z$-* z%=3&Sj96M)2H;@0PZWno&K9VN;~4KflgUJ4VztJ*nr^qt{{zc>*|5S#h5`Tp002ov JPDHLkV1kv4dBy+$ literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/background00.png b/engine/libraries/oglft/tests/background00.png new file mode 100644 index 0000000000000000000000000000000000000000..f26216820c734a085efc3340842b1ba98b61306d GIT binary patch literal 94419 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 a(x~p8mVhjE|OJJ>30P>Fd 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

x}GsMFxDec;%Epo!GkfZR!h#GzoI;wad5cL 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%0DT1C-jDdpl=BE^Jc66=|Lj{* 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≥5@GHutuS@#aqq8xHRlmqIX@p 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

yhD|zc&BUx;?O{tlxd7R+ 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

pvJeagkH#5C6Eb#`R0coh7p4)~ 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

1U0Ux~F{yC!;_vXqB6jGg| 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 literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/background10a.png b/engine/libraries/oglft/tests/background10a.png new file mode 100644 index 0000000000000000000000000000000000000000..3d52456fbc3ef261074ccb5b2254e4b22921017a GIT binary patch literal 102353 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 FV1oL3gx&xE literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/background10b.png b/engine/libraries/oglft/tests/background10b.png new file mode 100644 index 0000000000000000000000000000000000000000..b673cc7328949851b7f1d833806c2fe939ac05b7 GIT binary patch literal 104952 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 Ef?&md;s5{u literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/background11.png b/engine/libraries/oglft/tests/background11.png new file mode 100644 index 0000000000000000000000000000000000000000..bdcb8060035677f15bb55c0ea9cee6e200ae0c1e GIT binary patch literal 121219 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 z zqu343YOZ6ofig`Q2;OZJm6R`~uCvm{fAh^Z{PX|wpV6q?-+xe99VGTCHFp3=<$OL- zI}C9*?PPp01#cb4^GOy@FJ(nk7irivXv_V@6|PdHeXe4= zr`$1IMui53%PxJJ;*Oita@(1AB-9WBhusye84X!lBa9=yy9-OLl$uE;YhbwP9h|17 zF@5x8nV~~cb&zM6Uzc)hegnL`?N}46Njsb z@p{iw*CkB59kmZ+htV^R9y>V9TKY>n6I^4Nk5FgK*^}2Z&IP{w;x%bG^Xz(0E17@t zkN+3`>yr5Xt55jT7ccnL*WWM>9_K8dzWS8E`MbZ(I?w#skN=!s{PJt=AD?)9I&s+V zIqdd*^{JP?w#J%Pf(sn353HTr7;NQyIulD{UNf12Tq@p6SASks-u(L4-0cVE^~^Yo zI2=(tEsQglb)K{OewKN`SkE->aK_;6%wgJb7F$MHO4@Ur*jO^9TP6cJDF9N%7h< zC`$K;xc}k5{GI@Z8 zb^_~Rn$*X3nT)kUWzFlt(@C~sXLW+rQrJx$-(@wh+g3U`33y4P!x=<9NewaeOY3PV zo0ncUzv<>1Yh+HUm9CMNp4-|DWTBo&lhNrTMy%-z+mv6{drHZq9Q!|CXs6w7#926W z&S7x2!!%k4Iq1|Kd{9Z=ii9utj4XsY&x=?FoJ|B7U?2cNZ2B^(QyHg6^|K4|LC33yn@%;9dU;gZ8Jbd`T zZWuWoPYlDvXRlwg%rn7zUVrwQ-ENN$120~D!tJx?)TW8}x~>vJmD*AA+OTXlp>a~) zZDN?`FP`)G^h8`U!!$95kyN{Pcu(0|rNmiH3Cb8o;FvY}IFWm?nlW zFwZj&k2B6xUVn1Ov+FB~mFh>PX6o2BOb6o_M@&(A6Dw|t)0(c1pkmZNq>fQ!v!RB*dOq&|30M=V<9)O1bwZAb&bR|6UJV4EerD; zG0ySq*$tn3@(J^rxW2yPcv>(Ws&G1;c=zEQ2FrdLxqEd-S|ju6Ow3VxaAP^g#Bo_T zFAF!fcMM^Whra_vo%b{YONu-mpC~cn8XU$^yt!T}lqz3%E_5lX4yl58fYxdtcEMfs z$*3`wQWDPU;jXRr7g8_c8fU^VP(`-GbW1W;)sS)Q|wevI&e5iM^Ik9 zVj3q>F1S=VFOi3*Be_&Q|NL`aeflX+PfyYZ7)wl%`==w2an@rUOu>^&WblUH|IdDh z-~8?0;U_=+n*aHK{inRYe`J1oVDbiU47*_z*rWqM&$BcHfZEf}L@<4RG!B8mk2EZ{ zG(3%``y==7AMsy)2QviDdFh{%2A19_JSMfQ8xPHv)|{9C;{s)ktWg6^V=W~X9*;+M zqkg`5UdToGv@lJSQW-~WafWdqgn^RcMRQ}jl)L4Ef+!R=vOW7=`DsQw_BPOJVYl1y zDjej6wa({rh*aw00kPu8n0$Ow*p& zsS>poa@J&DT4%k)YZU9Ona+c6ddXWAVYSwF*_##&)oRD>OzWBgy&Uuv*p|CjyJ<-& zLYf3yyLt9Cc-y@4wPgW1`|iA@cCn3aS&6l1MYJUTWoPulzg@wCFz!-=INob#;ns=l-|T1$9i7_87!&U#fqHB)24b&!Rxm0;-#wFq;z5^NJ8UK223x&RuIz3&AwTVPLnPSk5QrW$j9}9?nsP6tf)}9(-WG+w=JJ zNREk{n?0rp?wV6&J};b3Gp|4Uf>tWO`039$>_?to-!jjdXS9;Je|+ML>l>lamxaS# zS&*o4L05f#70uJ zOB192_U4-7vhx1@nfu2xDMxlz{l52}Y%0rnA;w5tA}MFCZf_XIu~%XRS1LYhO|60W zO7H>a?4{bVv_6#X@R(_Wn%Pe~YSxA3ye_|#<45pE$rrs!ZIxkA3RH0pZ%`F;Z|JTJ_rCnjh4!$0_a zUcGw7KmV8iiVuJBOSKL|2X>-Zq}H~;Mu@erq|{4w@!o4~G`GpF8`VHD0$UoZ9JnsH zyMRhC=3=t3SPfuOp_=|8_r16GzN5+Y;g(WxgX=yaUDXPs_;>*MZUoT*BR%-KO4+!Z z2CeI|h&qE8sisva)#Ph;{bg!hjphltLeP4t^>m%w<)$&l?tSP3p><|iR~)WSbYWS~ zSkgs*&~jv61uOAhMlD*y8Ot;{OdlMYUY%KM>9%&P(S!v9%d&K~qM_AHss$fLu?tGk z;aX97pBp(=QmU+rs-hSZ#yY0m6)9K3u;Z`&@HhD8o1b%a*mHY#OPptgq;#a5L{g69 z+xLQ88W^S>Zk$+h<~XnT!BdUl{&=F{n05ya*H^sqBh8O|cz7T$iKpY4-EL&sT`}!E zPfw4`^NE))KjpKRH~e>h|L@`bjyJ#h1^@bA{YysESdY>(48byZ;q!|V$yppnr|=P{ z72Xy*HV&hD^#ZD|A1=O{hG0Zxxzhfe&CNSx4Vj2hT@9#+|68t0v z$KZQQtcugL(w`UQCalXsE>auDSQxyrCC1THgA7A!%#b#>XT`Uso+gAqiQ1i?mxaIl z$xm2Hg~9XXi)Y-tdc_ZZ@D>05-~X{P`wU%#puWVJ#{I(swnl#IM?d1f_@lqW-R&)( zfA$Ig>|gvF{`tT8cci@Hb^}oGHfXBfZ)XjUl1R3lOXqxG*fm{YaH{sa$X{b z5b)hNRC1!&tz6E1?<-b*tt#bXRv9?$cGy-p&ojYjtreqW#UDQ06T(0UBc=vQ(hV^T z0b1X5456ztWr$%2lwxs%21qfLjvAZDwPC%(I!|eaoEwAljQdf09bSBJ~AJ*C8HUP!I+^0U|YVZwz88v?_)6DPn}!Z2`JS3W$RxPN@){rv;y z^Q?XTIB9mD<0p!AJ$2Ad9^=C z{6iDw-f7(3np~eLE_e&qR|npG`z@&}FJp{q`5Rmv4lK(ebCp&F0?Dm1%yK8buTwNcyySpKm!hSb$`|Or#D$ZMW`<+5A9-sK|c;xo+ z$dWS6IASi?*y+*6GB1($AMUw-eBwOMc<;HozT)=wmJosl#i?S9^dR^5PvodLFjJLw zT$h>a{iqPn6tT|n;>9!8clVc#No$bPN-GXO2F(O=75~tf9>n7K@U-yu;fcGeE9e+_ zQya$S&cl%IA_Pw^g%nr75UlbTC`x=XRPLVL@b>LnjBTv(jQ4j8Ltu!Gd9Bo(2rhId zYM_NmHH~#mjDAp6QVQquN#2v*LTjm@O3s@uR%u!jN}U%1#v7i_Xa4v<{4sVn@ejZA z1xW+vD7=6B4Jjx7=pXze{?UK)5BU1mZ+Y|X zp5{F{CQZn_B*QjkEcNo@x=qrXwd*Za9&K^$P4C2Pzfm;{xU>(QK!j1xZ+e{c_OI3_ zv$a_;PKh$rDh8ZwfLQx~Y8@%dHo{9BR$ zCslbOa+MNt3?lJPyNNIkP_3xCZX_oWY$%2pGvhQ-Z6U6Obx}Hw(t9f28|G!zAQ}tK zlS^iatG+WAw5BZERI*@AWf(ke9981esKwx|02ml?>YOnQdeRIS9up^8EVF--l$S`P-g%QW$+qdtS4p%&# zPRwi6uy&TRGYpA!UU~QS9nCln*Ed`p4&2_{LaW4eCFew3R;duJ@)v67DcD*F){>VM zZ=Y%S+JZa^#*#|bb5}LbuuWpNwL?2vgAx&$i_TlNszy81fBkSWM-~Id*15GYk7Ej;%9&Hmppv^HGWXG zUh5(XIvv<{Ay2UIqrdijUcI>E-M8P8+4033(h%1Dw$joqlIZ2wRY@|KVzgR*pS-BLNTp_C_Ro&p}|Na zF$CheXvpL&#sz5ul5pdu3s8cUv1(Zt%}#P=jhUEMtmQJ?Ggdp_CF<7ngHhGO zHpy8_@Q#vo*w$KzNy)(0z%WRdHHJWpE02#4wAvWMAg%)%MlSQhZkovF#OZiq-0cbD z$hh0njD&a<7={ra0x>JV$2(`mzweWMHBi$NV!WT%f~FfO)vyo@~a$lF{TX_(_4jh3BWYljlT^Z`!06vbQP?IG|IW_SCGyes)%@+ zozxzGZ5sPA;EXa2k1=X!=sY%zG*f6KVY(XRsu!bH7(-)lL2J^YgVn~~1{qH(a9V_P zQw!Lb#sIZ&eRWW|n=;m@WSx6oo>Jy`6m;|D^Bbn1oAA?5UJ~!FNjdWF{Rfs)@wDwjw#1hrHsjBZNE#2Be)-PvlR}tXaP17|FTv*{7fK>8CF_ zzJJHOtTf}ezJ12cvu9kre96uJn(uu1C4cdgUv$VpBm+;UBg?ul3?oC(gX@fbF%gBW zoMKjYjcH2UNmUWs&}EHYUq&hN{@1QXY`uS{-`0}5!r%vLGm;*caxu>sqrqdTS!7%` zJeb5hrf(gZk^Y^oC(jsyb-hx_EURFjN}SPyx5i9LXN+;Isc>4(BsAm63& zQ?MN8h38`s`L-lz8H*lFYQ-=RyixSkokC^M=jSb)&PV*Tm)sZ2d7k@FxH6y4YRmdcR=JWYg?(^rzueHdlE!LNQClXb zN^`=wIUls8>Cbx2mGc_ecfbEMjU4uSQmy@WkrL1u!)}lnM`o%<2$ptB7&^V=J!TidFkn=^FTyU1F`Dt)L_RlhC-u``_7#8wLDIg;bT)$YLQbixl~w*)68 zP8Y@Y6&lC$Nr5Ja-jp}ztPhlwFeoF@S@9&Rby(4825xR{xw*Z)oM_WDaeZ~g;c(E+ zm=bq)w|w^cGtTo_zU35U5Xp(Vy92-d+rP!_%@w6e=30#itlz%-K#rN=`3qiu=W`i+ zV&Xin9M6(F8Yf>rrkD2pi!|My+&9!cuTR=$+Ybe-y9`&h05@Y@7XsP7u9DqW)E9eE z=d}*Mq+2B&w(AH!hHe_O{cjzl(FcyDHd>P@sfc``@Wv%-y=fGgT{>-d3u|20M2wwx z-~z!1OcQ9-^x*6jA6jO?{n)&?I9Y6Z&H8+QWk|SH{7Bt2_=(M)CjMfo+xD1PRfUBBTxQE00K@_V} znRa_(Dh#7qiJY~~%ANh^z3;dGAfr@@S_`(uZntAgDUyz$_TSy81<*vi;QXdRSH8M) zf$M{3&Vm{aL*V)I=cH76FRc@HH;uTV@cHMjDOJ6=^MO)UV#*v(XPzD&IC#e}?TAUY zbMuusCf1nc^Ke zbY9_)&Rc9T)LbZDLLwQ9Y_}?_%COd5`a#n{n6)(?9*=~&V{+FB)2s*3Sb-Y!v-g0A z+WCLAvdMr=uPi7+av3M#PL7F^HE><#qrSYH@y;si&OupJ`l^JK!6i6HJSUbI$rvUZ zy6svph}zR>Qi@nJ;Ef^1BnE;t41KL&oCq4M$6+*3J^F4I2!$8e*-?y@WR7K#7UnZs-?~p`Om9et3j12!>*6 zx79YL!SLPBU-IhZ9c4MQ0cAI0uQirj6I|q?i zJJx04cvOj@zC#?l-C;*Q&jjar@!|#6Ij(MR7!$mGSZFPBb=b4NzQTCVtM7bqp`Cc^ zsV!dyDjLGcLm}}GRQp%3*R5iTUeHpTV!Cx)D9TxjKn$9uTDD4}UbuwD7)4rdYfr#? zmFFdAz1&tef5|-poZ45C`VzL1ux70-my-DK1iN9!-PI1~lm)0%Sp5vORB}|9Lo0pT zfyH{U2OMYzT?@_$=?sl^StNX+BiTA+Q+&Yzmm0<>^rYm1brWIO;fIWk6>Ai-I*g4& zGuWZvmq^S7nqdkf-Wu{Mc!eM2sn`af!Fy~N`hn>QrAi#rDrN8(r=fA~HsGuM6{}HM zVW@Z;*oD9{pBenXcy-O~^}f$>99LIYjN=H#@vzQ3KAmaCNsfJSZR+!0*2EgiWg}3! zr@~ry(di51Y86&$y1CnXhH)aM+}j8FO8lUgu6Cxt{lk&B?;f}c7E=XQ*-ZgIDwHGT z!Y~HHFp!pt$&Dd6Y_pi!n0iEbHjNTh9dGGIt@}f^lx2~lJIR@ij$p=SBjn=a# zeD`yB=h=mU**kVaV2+7t94@~@Oj%Ie(kVgcclB1{v1RRC!;Xc|fHy{&Wo518?tOM$ zl4-M6bRI{}nfLGC%f8r4-Tl>p;60D06NlT0moHv$xH>S;GkZJo@)&tIEt1K0dF^lf z=tu0Y_MG0`GgL6vlKQ$3LBQpIe47%~HX^dV$81%uLF+z-+TCi1`gu@spopG?3 z#`S*BVVnp?xdydlECEwR7aE+Eg|~^mln2N2=U068*=L;2iErN?S=Ovz6W`}Rr7_Pd zsT9^VQL5=S@751@Js%R1Z6O|plqKk~#t_1Y^MN$aSm*RRI>$8bS`d5JKLU(r7U$-ph8(aV?Sz4vyS1r*)>RmBYI$)^$~6a!)g9eZA(4LQ+lBZEUS} zm^7)KzW({o*?saEch^^39VWhgr^#h0wXe|(-GZ(vv-|q>@;0_{U#W65)rQtunErBU zu(ib|Z+*V8raKB{)@l8Jt4O2ods$ywQP4&o;#HC|>Dx9B&>xU%=|P)19Bb>l@KiXj ziSwEmom5!9W6ZZ~06JFN*q(3CMTFVQS5cJwFp$nO!yvtX>(OO7=5E*Ri0D+hCqjdt zRvq)Yu%@JdmSM-T%&hZ@-;Mo+>RI(&Jf(H2L`s`+YMcaWS%UybV_0nDlxZV%wxzS-O+__etxfW_qrW!|2=v7ork!3zn(#n1}60E98 zjKx@wZ35RWaibYaNm@(NwxD*tpn;g+>A14QNI=^unpW4&d19O|CA}X8$})GmsxWLd z!DubyM5zVq6~e>m#JHPiP86W{YZOojzX|Ca{6WOS@%*Hq=R8c#q z7ND=fd>31kvi7JUgEdWl>zcTJe#f)t&-B4ME9SVdq-Dj^c=`N}93#iaN5vVZLW~Qo zWu6`$v^t5AF?ja75oaW=#JG!UETv5CJsU{FY+LL5eT^-Y(XKsg?bCSEb^E42(5cIc zH%hOz3GISt_Pqx$x%59<+(2s`bDFylO0Kw)VwVc5pW5u5&{c_jl2m}>vheU^nd}vZ zabUmOcN$Oy>gB-OXgU{`KUM3y-g9GYcW*iI=&J%G6znL*oN&-$CKQ!FD$Dy#SsUzb zCRmWL#LIpiI+o2^`aYXZ?sclDQeq5RDeCz&{UBB^8Jx$2LDJG~u0h4MN}OlvI1#1; z6`0orclNZJ*=_65l8Nie!-of+-(BNFV4hbVACKC7H<;IzIVM#?$hB$uLEoA{8?HMm zyEKdq5#E}@S)FmZEIQPMzV0CDwA(vWvnfudGm8_}`VnfqbrKU>4++}EszWnD4WvYU3eF_N1I zzDr!m>&ornnw%2za^^hGbR;z6G-(U6Bwd!?VTX|=%0!il4x{ZoD5cT7#R~E97ronUn z;XTw$jw}0d&)@};pn@MIyr^`!Z`t~^KI|)%mUU9vF4OIoeJ{&Z5i}(HDOH3XZyh1X zr_ku-qTzy_PPwQ@^Wp!OSsRX?+md%!fY6Yb_itc~E+o|LA~NBMx--W<gv?Z2JxE5NN<$}y5-q~?YV11Tr{e_damy6MS< zz|*X>=r9hKm@U_biK>!D<~8#8bmVkiSX1ts7J7(GxiJ51UzgF_L3;bTfnEB-O;aFi zdu+GJ$IdxSmH)vS!{9CZX@|Sov)@mQgJV8xz?*9$(HQ!7K8%4WO&U5M7h)|UE5$-= zV7;L^!yL0Nu@Ej&bHPgVnO7uq(~QZgOh?+6Fa#+Jml4%at)^_#!N z2OKF2gQeA0Cao*aZgza{i|-JZh1OQ-)T>J&_OzTNueI_m zIMWC?Rz%oo=nKSZu+)&}KF5gjR&i%F;f?4$C1*@gUtXIWa?UCNd5b=GrGU|9!C6P{ zx6qb`Y>c^VE?P4zOJuM{q}rT6f=HYIB1(Q1xd>~C9i(ckwgB*|6)N~^LT&*zz93wE%Kqx$l3&@i=>M(!H^lp3)KQnSqqc9X32tw_e5 zQzfT`lyWyn>9)_gu+9RlSR>CzXxjv85 z8obuZc~+q4ZnvW?k+jMqV4TJD%E)6)U!Bzpd_%c=j(L^f;CMO{V6(j^uP^80B9+KE3a)uP# zhi*;fXRA6bjkA}2iLE3>eRZ|%;|bTA4zZ3{62(QWL1RN`Rjn4AP+KwS77WfwJ=U$R zIVWu*T7RspdgRje2+cZLPtGmdu*`xV#I5tDF$Sl=iXyLne-+6kVVa}m zC^)JStR&?`7`y)*LtIx(D-a5!bHt@$n}%#!pJ@(b8<&@R8vq#ua;2MEN-5F}=mgVT zrSG!_W3c^bS^)_|(PCSCr6L>-p>%VoPk}XeR$y2 ztC91(^7j1)j`OOQ*r=-8hC$m3a+?7t&(ZhGKrIkfw|nW&vBhvW?AZ+itrT|Cf!%H* zt_wNIaal`Y942`z=8SiZ$I~pQ%hy}2q?nmwAsNpy7i?=>?2w^1WLP@ogs9MM6*{*GI#3gpLomPm!dyeJtqkhFXjPvZTu1Gas z*bZh}6`mK#0Q4kZGJaJ{_5tmHGS)Km5U0{NC^V4uA2} zZuWdUY;4cH7Ht?8oeLz0|d{=K2drm&l^i&sg<%f{Je0EBb3n7h7Qa>d*Nu zeCdh1R*;L@I{3mm+E)JdlCpK?KuNU&L;64lRTJJ=aRG8smVC>Y))>5#qON3e)&K9@ zNC*z+4Y?}i#u%{9;;UvHLvT3j0SJBdHjN|8Jgc-eN|nt`#~lW0-uMW8xY`qwoE0mt zRY$A#BECw!yuSDvtRk!wgKc};(+}rXaW;_SiW|m0=g=OTs*HzP>qUG*X9rj-^xIHI z9*$>>cf9=cGmhtlr{jsWR*VfF+dR1VGB)0Sy=*2nm0eGCtnvnUZ?UGa8v}P&JNDyF zUX?L0`oMBNs((gpudA{wud(5yhPmEWcA+sZ3&Csa;Clkprb{WM(5%0#XibBfD$REx zR~F+U^@Qy0Fq5FG^tp`&@9Uz<#|IhihA`lr<_9Sy0YP><;oP%6ll}F9(>#+SN`S6e zHtBwVJFD$o7)E_|wf0PnvGX%#yfK@pL8X-UvPqVTL_M}L?grAjVDba=a%LJG#yJhO zQsU*yXY3CX4^NITcAs-;ef^R-9Im;)f8_qnH(cF4HPHIRy3~9btZ5}El(Y4o zw5+;I`vVuO0HDFjq3ON9kdIa3tCb*S^14tE%p?q6ZAjBJ+#21?sj0RooGIa3EN9Lk)mJqsoZtz_1M|Q)YLwC2sTF(#$S`+l9 zRYRC2PA63a-gwSS(u%c5xEnSFr&`Mm;hm~s#1pF%p3Nw#ywyrv5;^7GLbskk)VdN- ztiNr=T}$auSmj>k((tWvbGVY8!Fgg-p1}V4KrDr&$iz0?T*)b0b?K~2%&9SE1720E4u!m)GduS=T3^< z5{u=mQ*K{R(4EhkM>K^%8sj?G-^uC>mlv`1md9JIP;=>W?Xt~H^m&&iBssNEb0en( z%?EX`$;4R!XaE2p07*naRA{1y_`K>+O!JI!j+!F%`XCAJ5@|)oCmNSciXA*HI-2)X z=lSq-;^FugJU%>%UTn-Z{<*YYu0LhF{xI!1JwB4t%(I(4`~8lqtGzZ%rr}-CGvXYWLaCWGuB4c` z+D}{`b|`5pvh*}6yYV)*;TxJ&x!@VCTGP|Akc)gLDXIO7V`i`euA}L&`uiVGN1jec zjCHuj2f$noOPawnqiVW>8$8C*+h0{t6*@ddGa{c`!y7{wMpBJpmgQ9gH$tv+wel+qe;k;zAYjpMN2EA6Nj;+m+FxCk*<@Sf7=DIXr6 zh|41FdkB|xtL-n%W^8TS8rSp+&Tc1!c=_Aynsdh5oemqP0rctd%(^Dd=at?5K<=NZ z#}HG-`ylt_vQSGTFK3=#?|QW$H=eVuf9?;IthRFt|D1-(7vFi!i|2Q8q4q;7_Z9Fk z1VDb8&HN))-^iM?sxD`=2}oJaL#G437}!#!=eYJQSH)IX=0#Zph-YD)?}>1t7?&hj zb)wsg`vJQ>rx=4TRT4s6Va=I&S$R4t{dF9LN&4wu{)EE7ngi$4%n(K;2?dWu65w3K znb*|42YvJ%WvP|7@4w~E+jq<*WA}S@M&XV*Wt>xqYPV^#wLotHdWq+Z!8i|WzG)2) zop+a;zxI`o>GiekBBIvUinh-Yym!)(Behj61#29eC);#nb1C%_4$}7xnkg6*#nh+t zTPQ`Tnk!Uv!+xAv^q$XZN$6C%?;h(2-d=2<)^;*%ij?BGxjtwhSkh(4 zHw3?o4MWEEG1Ga761*2+9H>YmB{chqs7vj2h7>wG4nhi0n zk_UV3_g&Ygix!XaoH3EXd_TlX| z2T*h|G$mV2)4(RII-brzV_hT1ZXC*`G1^9OfqK%PqtCmM>*g>Fq*)ec)0B6(`9eyT zh-#a6sN#?z>+bf7{ch|SIJK>|HCij$Dgk8hPBWQ}-dmgO=lW+s2%i03`I7Vb%rp!N ze#MYhtp#5^8+m+u>dwBxW_WWUkZPgW##)kEvJj{>_dwKMNzrA(&f#0*62Y{_#OXZq z@bE;#aD9D6X^P%DJ|1~IRjnq*g9IwA;Jxi^x6HCE{pF-52RTX=Wq7)};{IvjG|wva zL*VA_846%f1hZtw7F(4?XRO70b9uqU^ZzIW*i1T`38eKVziq3zUInmCPFoKcsUK~< z?sAjRr?6e1Q@OnSW)u5VCD*d`&9u%{>udrkQt(3{ID;)o#)fJ>dH@=_iR;D%P?x-M z_mryCw>efZ-Bsi7E;<=H??413YNHyhG+j5v#9qOPKh!wBxKc~x=4yv`o^?%n!OTWq7Gb9}+m{OZo^mPDh?HI(R7IkdS~1l?a2&3#Iez<& z^Rg-}DNHzHy8CalCYwGC?Y(QiAZpnT`R%aS5}pS3(~j1(UVDr)aoK@Uc&M?4>)R{# zS658a$Tx4_GA}E}XvJ!bz5{DC2=;ybW&qbWCQpw~eX!ZLOGb2SOT~9SWlnMj(x0^r zoT}gzr;5{b>2lE8cA9qFKOD)qG3|GFA4qEw-1H!ed}|Hw#n-UjbMA3xt!pM~6D266 zRV!E1Ju6ivF_}}{g{k1I>p`g2L6;21l$0|UE8}j*?cFohb>aBycbuP2y!qyVnj6E- zK%)`k!Vp@g-l*Sf=3|ce)WbusZw|cv;(Mg#$u98nlTQdQU-J6PFS)+i@$|IFEYT;W z*7lIcW`VxC>m^q|d@nm;XQf!A*~?^K?ajOzei0h%Y z#)^;7`{nH=*eZf*40e!gCg#c#Gr=1M8mHV$vO>E} z*I)a0U@mSw4RJqeFt!IBDy?<}WtEo1S%Y_mRxHK`yw#1_OzSx86=P>Y8W^YHBNlsb ztWmiPwG>+CV#c+be}WDLLlc>)Yb(mUl2gJ`xx3!6pS1SNSu-Hb3emw zO0ECC| z))>dYIj$Jn_|EIs+n=JrB@HB7UrB; za>iGkU#5ugs^O{crLkCr!iGyw z0MLN5B#A%rIFb6zMQaMEsEsg8SSxskHQMbP>w8-wW?@YF`&v~r+0Y!NDvrIjjfo(C zeQmABjnRj7a&m?-(5!}>rHQ|9oz#}({LwgMH*m^^#?s5awHCB(Wo@BvCv4ATtR=IY z&p2b4#({B|Sl6XjD~88XFPWDqXPond!Leybj2>L9_t2%_l}%MAc7W;qg)uVNV3e8g z^4TrVZm#8xK+@fh#HKDy_PY7kq~U9-g`py{@x0Qk%vl=HstTHRJ8gY}=eVAjW8{=n z&Q~jgQA$Y%iSaDULM|(7T673G9Rek*Eg232eisBrF={z{2z}C>GXr#<`I=hzsD z^CIO_+d93i!p>?l*)#ScP3QKL+4*y)!+M}r)DNFOPrik@} zkXvr(H?9&B5dVxx8k#n_4}YAn|^!g407<9F49+HEsu{E#%YoWF&9{i z1VlP(8M@s*9NjL6SZ3AXY*9jyk5LCuosx z`(Y68$ht@+;X0@JDnXhCjC0IsRf=+DA055O(JGc{_4`w?-KuM?>%2xyK3WwR9sC+2 zL%-nUd-uwE02!vrU|60c?;Op`rYEh5VHfytIx{bc-F`&>c#A`uLU6WDkZDzh>JB-yQcHuPApMSJPW^?K#* z?jGxh+W^y482yfl$e7bw!HCf**M`idg`ymE(mU-&`S)2UG&peqnw*90*bLx>Jk%Sx zRVal?KO66jl68#^t}H83nOx?TaoW*aXB-AFMtWM)ZautHh)8ZtZo3efc7xoespvpd zR;F|aM)K;UrVt%OZG|CjIfhN=F-8qzjn@55EE9%E>y2f(a#>b-t&-#uM|y9J`w5Jt zTf^h|LPOB)g5<7@qhlN*&POh%%$ipkhH2Q5=LKT|YpTp^5ebO|M~-C}V#+nMtU){?2DURXYSU^?swI={M{&Ui#a;;hqnc8hnN zR#s|R@ph2vwF}Q-Erl`2XHLtMBwWHUj8gH?@EwUaY9`>qz{_XP`NeO3&8MG#D$oK9 zemwGzfBqg9BN&g5QEpXa$Nl>4TjoVF_STem`r;+M!F*ka&hy>tH(XNT-Q#P%`T85~ ze)3YL$3`P-aqTV&P)!-&8^&YD67%Rvtqw301bU#Tnb$;Vjfhr_PT0z=l-s~=Hx8tAB?PGe$8ls$86OAI zvNEp=DOdJ~BQ8#SI9<73FT%8NRv;}+K`1^_TH}1VkW*m@1A`ZYyK$cGEG5mPTqtW| zh>`Ph5#iT3;^<6KR;`zHWq&-9E5b*-oEe8eu${~4k>l|w$;=kUArj&wEI}u;9&|G! zbDV^?E-+4>^CA?USD${ykALnHj5OBXAR=3eb6Qu1Fi>0Na-DzR8r0lIYpK>y5iLROVxNsZ$QlvR zA#^O^R)NSvy8$y(6$ZjIj5@QC&$eA=mUW@)YT5w%ags{`OLCog&Afd)v8*7@a{b+T{-M0 zsb+d7Sj!Ni%t5Y;I0%boaVmyxhz=J5YhK7D<648%*$)wlCKsi|=bwJco40StxnN2q zI?KbGchKPOa3E|7P$$G63k<_38-^^0Z0%K4t?R;dS$LdhdDW-+aUAa#hD%XE%=Y4yTkUYr(ODCEO&H{Ra=exw-#jg3WDr%r-5CAKYZ> zjBBE#vd&2qw+<4U+4Sw(G@9GZ)_VI$@ZDe&w$n(Iw94R2@If?V`EX5?^oGZ2;K^76BsCd69H zwA*RbChOK*3u|6)gT7ovIk+8M?IxTtsv{7#Bl_JNR8eUlczDB_#lC_nex=5^(G*zx4)9oE40bQXZ?IN-cv7y@_q2QHUIcmz=f=ru2-wBUQk_s;!p zA`X+TiJ{CFmUCqqN78)7nNA!cyWO5OC8CoUx>g#;r_Z>a&&=nAS~G(t8HpxA9JRR? zmR5K;pJZFL%&UMTLuARB_YV(z{uh72@o->SuDD@GnX`rynFwF zXHO>4iaSAH_uf?%W=U)2^5!j1OrTm%e*Z|nd&R%}?Z4vHt50;gT{z zU$ek8!F)8;Sfe?6{pO@ADf6%-mQuKu#32R_V_*s%+a>7Jn5wc?88mH1qBUz;ahLvE z!XQ?9FHnudspmuk;yB=f*gI&MB zkQYwm(^cCuDZ_7aVq-OStq@~mnkE5>TD|@CAhrrgp-aWH+ZhhKJr+yW?T2Y{7%L<8 z24A5|exY|#ITb~adGCoau&#@&l&1+d2oGe4ewJZ$LvF{_t`+KJSfew84-FGa@Omj{u z@Y2~l0rIMJoN)vnNmYC-DOC;C0Uv@)yd7{ko%q|o`Om~>&-v}Y`)kJIks(f;-o9rT z2MJhoFy7q(hS^y1+1>WH(=bxY!ufQ<8W}Lv+*p@H*i}+%eD&3r?B|)!U%z4Z*-!Z7 zM=u%1fi)#cEd(dw2O1zE%+#!8919a61tx0RQ4(X zB9av2g2$Gud)=<)4@n=w8btTA5o)EHs7>_Mr6g4b%35+uE~>qYUfww#b7!e5bFDnt zO-wF8OVl+HW5Cd<^LndT~<4AY;oH= zYF_BI2q48fij_;LA&mZM92kS3zC`($NG;QA=FvM$tK1)CW0TS0<#^b0f7r3kSJI+??y?g6AZ@DYjQhy> zl1S@9&PnM>j)M!#^NjI9u8czFFrLLRbk?3;=}KuYyoq}ABgI&zCS ztqyb$rvKU+8N`Xu$lcU`Tlhk)mEH?M^Vw6DpvWH{3UZ({wv4t?3Y!J>rVCIWf&t<% z5TdLSYpe8Dw67G8MOKI3;62TF+MGD}M(ha7O?S(!D{;8X?;%=ob?UWF@Q(R(W!igU z7-=N(D!ce@3Q>bDTC1!{!b1#(v}9UoGElWaO*}~tMpe^w!G9TJb)~72D=W^o+jd2_ zA4O4SrDV#wvaXphjO=!MdQGHdk-3ZF$fVh@2-MTzjl)#o);lX(ot))Co<@-c7j)~} zbq}hgtbEVVsSGi4JnWIJPhuK9hy9-59L0C?A}Ynl>&mrtF7p*12ds!6DS3hF*iRG3 z;~wuiwXE1)nY?3oa>sGMr{u!*I&)n!sYqDMVK>md6Mwyv{<{{{-y6wsl!H0}PI>?G zOsv-{$yv#vNTTg{{&Yu9nYZuWGwt^rj(e{2m1(~dK~->28r}_j_x4-H-Ja9=LeyEt z^>o&YO9FA?=m8@^ri$^G;kd)ONa%*pj3B|JTyN}mBli6RU;p{feEsE@Jp1Bj;05(G zeDaFt&z`c*-zi{2mR}*r0H-5D7trlD8%3kBniE&a1_&`^GLkK}6;kC0Aq1*NI4X@2#vaTNQUCATS~r2^-^W)AUTK9rYvn0 z*|B61im962O!&#?-qfE!?I{Rw0EzGgG3b5yYyR4Zh>{Rynpwe&tCjY9){lNHM7na zN|n;?>9ZI7;xGP^<~)8HxI65z#{+lI?-(W-e3e#Zh2cB~Pns8UlL@p%R(dtp+e=cq z7@v(7W_s1QWZ8RGaB^FR5apIIP35SCZlUys_g3ST!fn9lj1HP`41+w#+rc6_0+kPF#+hFDvJZs0LdXIrZrx%!d#H z4-XIGN;OJw0@gIk(A`*awM_d7hp0P!5S#emM_Pl+ykNVC3t$Zj_=9*;bI z`V0UwFZgN4v!DN*U;XM={FlG|JDENXBhh*&D{mhjdHw!9wf>ma8rS7Y2$7T)aq70h z^>SgIul(09zoZ$94UsQ?_H#b}{4+lN(JTJT@BTrv)K)r@&t_u~cwtpx{ifOeK`+0_ zkZ(KyBh%gO;kfDe#TszyO}+Q*_oAo^&d`c@8>HWrm0qXPYZq(nwmq<-Ld&&iJd_G- zsw}d%EJ3=F)!^oPaE{WU(pZ{Ur-R9?weoB~QRgnFv=Qo2&|ATILn}_nLY-k4D5Wr8 zFO=E{PSR&F?e_c9gqyITvue|T$lh-j<1N-a>m+=db_~0TTpN9n|F7|K_|%ZsHvj-2 z07*naR9RrYUZ^Dz8Suu)cj(2Y+}HJ{!gS8vGU#)b$$Zddx*WEdwq^ZkJr=CR#eop5EW{c)7@7BszEE?ufAna;ta7 z5UEAb+pUYEaSV}Q9k~@QmkaH3Wps|{9G7|KaJ(a5uUwWZ`~6-*ZF7?LHw29BYzbG+ zh<4v9U?-?5vF41`$}6XYwT@{VrD{=ltnd{&$NMKNOXB$CDTCJ}E~VO87nlxvdPB{7 zNlZz-6Yq{3_6OEQ=LT7xb-I|~oOc+_YK-2Js*wZWGSB!BaP4D2W`6fT`Th<5u#?mo z8OKo@80&AVvN%rE`NW^U`JQ>nv<43k55yQ5qNmo(6g<1##NaG-naLdhDM8l0CFVAE zpMT1~`w#ykzx&-k@OZwc%dN?3M|m1bV6e{KI~;x5nmB+t`F#sED;dZE`@UcA)nvQ)?%xxu)f%H4v;3i)JY_>o6{Y z3lwK=t3G25aT-LsuZl;S=;B(fv;xk0x|*)M_msL~ZAW;6mbA_oBD-NwHlEBE)>&>2 z8Lddg(-5awZdH3~4Qgo}dZm;kfh0Po_{eFHlXNpx)vA+wXGwVh8~AWO@#jDMQG_fZ z;MFKqRX*K~2zsPClQkx_QCq?cLAD*eup6WD{S3x-77f$5oGX{UKiFmVXYyC zfz}L5%Dj2^$XYB*h7S)X&>^DjUZPa0I305OjX``)+J#^M{Avwlgv$;xbv>dOpK0{GAXT$EM~-oEASci;2rpZ-Yr`LFoxKmSW!K7Y!?hX=wq zP)gScH`o}kX#cKn__k6q+Y8>rnTP!d1~u4QNx#8EHnkkcpsiIy??sb$B3q=mVn}ol zrcN~dnG#+0!$YIpfhV1VSgu|u@$s=DI)1zdSh8vNtKEbTDz@rjS)qk z=?!Z-!!+>n<#S^2l$>d$kkcYsj35(m`P?Kw;xf+^)!Pr#$Zj9GUK8&hPFz!=Tgzc5 z8H?UJOfQ)3WDwU2-fPv@gsxLHH)0qDTCc>xv1m5FLtZ6LsnRg!^`EZ)~^!bq&uYSaCH*tA*q?W>YS$O|==6ApQf4Qt; zvRIad^L6IGeg1+c_eWv~k}^Ar{J8dx_42=Ma?!2yxBBu+SVYs8R4Np`&Taq^aklAd zu*>8%#&~1gixI@%_S-1t%-Dc4!f@-olS;m|4;yoTJ5)LwY@>*RPN%V^gR527m7PId zTrFj)N^Y$WI4oASSUKd%5c~6@c zyf;kKh;>Ho-a1@0hGCi*lqImHB*d31S#*t}=lr^zlFA`+gx*l@%2JzhF$pT3c z#b(K?7#2;M-!>Yi|TE9+Y`qZtmHxA~k>z9LM9HIE*|#zGJ=?UcGwG z^>W3U&VIk=-Q$UQo@Gs}PFZgTBn(85b=^vCNADunrb&tuy>dQ%V7^{}hHqVVu9xeK zRcWfBv!5nD`{Waz9FK${!X;_XCLd(ZMJ$s}`oV|GmA4-r`RtP?)YiFN7s(Q+@&QHb zc|5(tXt*e)^6AUxj3J5uLZ|#|$t(@J!Xj`+zhq^?RY2)ELW8l|66gzwz4eA$sVe2G zwnMe)&89DJfo{9(`fvO|iO#AWA@4M~4V;pS#q@zdN34ijL~{VnM zncf+FU_2c0IZ?X89)hJBr3nLTT10BBKJuzR-+F)Btq*Zv8b_kHv?4+rYeeB#vt$y4 z;2Fn3LLh=1N>%?`ip*CM@^eKIn#sLj2a(+91Z{>9f#33@o zKre;X1cQEqZqkWP4zyM~YfAKzvEH#RGfOIryFH<~8^2Kgn<+kn6Q$(C!+Wg+P(@#$ z_{8CGAjw0?JYR)fp!$AqEVX6kr4xpM)-!9Gxh_TI$lLmS69+jZABnD8*m}mwkS3>9 z4KT7VHP%wr#N~8Wf@*_WH5jAQtl{yTc>Vef^G`qF-NOf_Arg^TEIJHv!uv>CE;JIC z>xDo5*MH*qtH0&pbf%;$waN;`#)<9&TRxxZQj%?0udN){x0tSxQ9=JW5ij{>2zVfTtpFBEBD7co;-QR`8w0ugZc;LGqT1} zt6;>v6AF>I6$?Iwn@l-Ir{OFO*Ue3Zh!xDM_g-$>B3qk{#V@8O%R=?-owWTQ7=y5S}y*%<{zZVmf@pvOzdTOI< zT%5$$S(RT0l}C&ABZkN@7;;V@MOs#dyH)iwt?4seB@uh@BXJ1SUZ|^Be$(|LZ2u65 zt#f`nk!og&nz&8pdOb4+AsywCpmvUT6E?`<5C@TIuWRFck^yR7GA&oU_m)+4+hGi} zA|aO6!1Z#H!AoAazWI(n{qc{t$#SQGKAgP>Li+J^qNIW|ju;}rdO|8Jx$)t225Z?!T}6^Ke$$yOC%I&t2FA?Vuf zh6e94)atF#aP)4uc>$cKtJp_CnnJp5`Z90QR?1RUcjK(2~JDO8s+8wmw;&w5%Dq8<>9Pn|FNmeadUCTQl6-U+l%7$-gA*WR& zgHBRTVhD_f1N;4+`;LYr_}~8b|C2AjdyDm1ZVmnL z+Lrcfl#~nNsm7=bcN3|I4?u26ITX5nK!Xn-C!tQ=hOOX(rPeG5i<1Y{>IX%ugeWq~ zT%>PzO}Y?iH^8XMs`QQv8?uhGUFnVGy3mcm>E}#qIHP6^gKSaI zl;18Mh23tDA*5;_s)(7%xvKM0UtVLix2~kJ(tTqovoa2aCbdz1ytnwlGX&2NcY-*( zX0FT1G>q(bd%P7O%90YscxpE|KL~2ORNgv^&5_d ziE$d$_b(UN={)PZ+=;>y?Hx}Tgl3ap3)+#qu?NT z0SwAiLv6M4rBMsV$@1*!J*USHn3hS|(T(BoAgra3s%Qo15)-D&IcgHvX;B`3t`cqL2N8pmQt(DH z4NI4Z=>1{GVSnWGcqZj5TMk`x7E2XYfRUfmw7<4if#oRL0XEzR;7!WcZypBx#yen3X@9c_pEr*}7>#<~_kVjB_J)Skd^pi9ecf1vq- zeK;#munT6r6cR;Z>5*tOnYSd2sqA-=F$7|~XT8oM2RDY=1)|}6;CfvdhKxT9geZgL zS~YV)2hz@Ys*?eqcb<+6;G$Qmv8q3DsBeDfWT zkB?l=XO<5ixO=?dTx1w_0;WJ#9VKUp?k=5Q|K{iX#XtKc^W$5g?Q{s^#IJw*TmGNl z{XKv85C6cjEf z0m(_MnpUK@sk1`s#o%;W5B)aewOy(!XDz$^j`KxSo6{~bMoBkrr2<0#jl+O9Rx%{| z7R{xDHRrI-Q%bvO0%XY5bfeM9Ym#cpYR|6~kQQO976foTk+HSu^kv#f$r+qMb4 z8QpWsEu3oVoD;1UcDs=$PwpAV0ZS(>GfUAq074+P$|>;9Q%un|tLet1DnLcZ$W5OOgJBq= z@&o~@&KBfZ`R@DgiNP@q_c-gA=Y_NsYBP+3So397DTY309nl3{L3Vmw@k7Kp|AVw5 zt6H0mpN0V&BB=w$^7O?MjCUMPkNo0`FSy_B=noI{$CK)}rCZBcj39&Q{OH9U|N3A4 z3wG1M+wZR&k9%AQym@>CANY%3|C;aKyynT1C;T`6)Bnt29LVn<$V{Yc@DJ`onuf-ZnqHPpavs>uJ|F) z5#&|YBwHH;w8j(%cDqsN%uN{nB`1O#Zat$2yCm^973o!NklV0n(vo$Xl++M{V8F)c zH7up*97VGFoD%}jx(Y+zIVV+#-g=g8W$Bd0WN)8mr^)w+R1(39(!v_yNtD(oxzM7& zP4cCGt$++e=~@A`4qaB)E_k9d)J3umTq>L{Gv9vumSxTKZisP^DvOR$a`bL@U>Zi9 z2T7*D7`}hSvwXI-$Xv{OaU7PMnJ+WPsj1k=nIAHZJ#~8;`hJ%d;ae4|B-2b$J3{chs(@TiUv;TO|PZBF;-H7ke3-<1*Rr9$PfpN zdi`bcZ3Vzt8`ChbEf0c|5Yt{7y^9*oAgiU?WtOmojr1;T|KOass%pU+7>0=C*f;Vj zp(tV)GCKIvilRwU%ocqWLSV2C+bgXU<`tG8f}z~x!N|E_yBMV8CG$8JaW2WvEbT`0 zEnV z2vafV8(I1M_JRE7J=Zn!_;@D7k#U@)?Co9GqJ_J|j%l|eSf}gTs?O4)>tB0Y30enh zUMNNU1!Byaw8GOhvL29hY3H0VEc2CG3j5to^dVIu*tfM`t2)bR`iyo76t!L$0U>zC z7$F+ov_?%ChJoD}x!dje@NkxA*h-jfD^=*lMiA*^7}SAV2#U4qt=~dbtdwuE1~mFo zS?9Qa`h+ij@e4xq{OOPX#KZfyynp|i`)4os@=t%{`|rP}>qw^6BE@FSJU#BH>y?$p zG>q~P#EHY<$d`ZqQd~{BGM{I@`d|K6QkK2t!}|+gee*3}ee*4sITPc=@z_~Pr>?8W z|F_#ngF&{w)9Aw_@!f*K1`Wfk@|Md>Eqi^Vw^A*IRtnB~k@upxc)fk}u(xf!Wps0( za$LV*|tmUR`KMwP@M0aX-1zP)@-?VT^b{F+)b-bL2sDwG=U z^gxt~3tfkLXK$e+a%-X+h3x=tw^qw(!c(h)T(d^1p2IZCnhni+um-x2j*Ws(rfHHX zcTu;XF&L}Fqb`1iRw1RUh`_8Bx0~#$xm;%EHDhd$cCl*uu`26K$=o0B8Acg=#z9kh zH1{v?j1nQ?dIFdg{EKm3W;-@fI=iPBbZBTDrBzw6bwuISl$EGcaf}QVO|J^#0Ndoj+D|*CVIZZI z%jpB>^OgH)(iX?wfEguc4eM~^2Dx^YB?E>yNDS4Q6173VGDNvSmvzg-t1`UpmAtNm zY2?+@r<~`R$Hx;P1eR;37LBv|!3+V6LQo}~MFcoTa~29l!%sJ1l~<8cSKWqi2MvR_ zL?@dNDN}VuqJNHLFE)&k)z)%es3q%ztKkaXv08#t zJGErc&j#J-++x^K)O+vL(sbKnXt~gxv`oEKj>o-L4Ps2|MKlE=2Bv98LlNdyL}nuU zPAtnzshQ#}CCk=l^PIF?HB_YFOU+WkcEh*dd`15o&*wk;89N^c`y&nusq&-Gf6U95 zuXsHFnO-u>I%87i>63|<&!5s;WtpW{jVW=we~#&fk{g%PmBT)>8x6f0Xh!YEjxkQ) zJk5G)sqChSXZm7a(?V5BjC_HzqecfQk|5mZ>H&}&d%LZaCEvQv_PR0ygeTusa3fQ3 z4e2yL;0XZ6$qONwcLl+BsiUoB$sp9e%Nj{_+3cytO8;AHC74cdmSBWDe7`^N;^{NI z4_xOfWtquo(M$$=G?BYn}PJ;HHVvivH||^OnIy zwXPcCI5Hjf?2kw8?(TSac;I|qgJv#yp#e1 zxHvGctC+!P3|?m~RW%0N1=s|^J`4kspKwOQLk8%@3~;xy|*4{EJq zO(!@fk;~5Dhe1<^ElmLnTRH2nGW63azw<&4>grTPhgDv8&do@8NUt9y%T0IQ-WqH# z3?{PQkKFA>g6%A`gg{s;lF#>#?|Jd;o=&4wDc5{Z9m1UCM(o1kk8wc28;;3Mk04||*sVhu(Iu^60pSjD2F z?m+MTZLrk3NTbDmQ5k&1AhU$|dcyV2-G0XqrF1^*4;m>3B^RO^nOuw_k1Yb$a6Vv- zlPEN!)tMUvr`^FgN3Ifw6@0`QgZD;&r>$r^Q-vg4Hx-}dItz}=ILl?e-UfIvdO@%C zM%CMr4j(=|(raV4KZ*pnqk4NCQdgNDH3iddx|EGyXuT)gq{3AVSDutIyJ3%ykxAz} zr_+fgCsHniFtC)uvSta(X+;4y67mt^#JdmgMK@tY`!enXEZR!a14;sNf-iViDXLWU z_s64{TCWSGL9dPFe8CyZb(USIopyw~d%SU!+<1Av=imSL|AycE>K8n``HqM0zowYZ z6eBSNHT$ewuQT(qu&#yEb>^}rI>-RZ$O9GPh$}{Dtw_JWCNY3??E|qEF$1<+@2_W` zo@jkzg~~rSiP{zjg_QYL_tA|`sNRQivkmN1GhPQ^}G;$nAf;G(N6Q}cqwTkuDS|}xvmKpD5wz2&@gQC@nsQbi= zkum)v5Oc8$*YgPs;`p;lmO)#n)=BfqSAYHr>#P7U`$ug*IzSB}5T}V$nz%mE#fUX} z07)rojHT6ruNzHRXwGXbc<|adIP54%JOB?L9wo->aL|=n z7syPK_N(c4=bWPyB{W%C(+*?Ab<1Tb%*rJ2niF7brAl zRuOz*$l3o?&tr@5uFvi-9-q-^=DA2JY|g7{@yQ)A20DUuUsKZX zkP1q}64 z@bCYMU;XM={M~>48~%^K|68JW#HY{E^`hv&b;Xl=qpnFb?Op^$KI(_>RWPE}!@AC# zFIRF}*tm8^Z~AVP3=9P0F|BE4ywRIMR&(ArFq#u5T^kz_q#Nk93mvC_EYqcf(4JpE zu-glc{WvVtHlZpHz*zxp7L_04MVQl!Y6O7MJN9E_a1Ps~?@RMcN~=VP$C2PCT`(}n;5AOJ~3K~%ZY zOTns=YO^?}Qn}k7c=F_l2!7@TW5n@SyU3q~RNR5eb}m-6MjN{35hQFEi?C^(=wJ+n zpML%+_s0YK-NXKKg5%jGl0SY2C+wRxN-LiC)k7wYNExZCmlx8H&> z?52?yFQ3y|thxg=kH7OqqG}%^!Jq`yKP;LW?8iD61tG zB1w~H?(U8>8+dq}vEGxGB$;csG#JSxY+W37IjyYgOzTxjYQ23O=7#5%RiMM_0brV> zt!^tmYb{n^fUZ2@?H2Far?(2#2uav>ZUes7H-EkYFG>d|t~X=0nuFWVl0ZvQcwwX; zlL|qA6Tv&~c02aNK(B>d!~$#(huZG2lf-3XaINcYqp3N~$bhnTnh~n6_flb@rFqJk zP$bl%Rw+MA*KpCQvRUsi&ERq5nlN1tN4;5V>vSgvU#Ws4&!w>BBy2!rdr@1vnW>DC zpMVG9X@yPGi2DDRIF0peagO zHSXNzGny+_Vh;gJTnm%d7y0985@7}#*`s@?NVUXF9cdSY01YHhcZzVjZRe83Z56bP3Syr%4 zf?a0O1o++&dt{auAh*PacaPLsIPNEoQ{-+x@Z#AM{`#-}1>b%5o?rarGxB_*jX_pw zE(lPgNlf)HH2sA-hy9*;?eu;X@L^f>25a=LvDlkjv}Wc-+J^1RXg?TQU}P0#HnpB! z*v=TbbEwc!S{nVLMVSY^iBV-+O`(0KMKNJrh9cqxkxBO!W4pYsa-@VJYS;&sFe5Yw^}&ZI)I?H#8kFnYEOJP05P$ zf@j-LI}EZueEjep!z)_JIBVIf^KnZ{_Q={aDeuu@#LZ|$)!Lh0gk3IC?*o1q2XgC# z+(gq}GQ0hbSD(D(u%9r!ad&s*#fwk)XTSU5a5{-Sco;|N6LXS&$VFNMA0sv=>G9U}qkez8O}B?t&w=ef+w{`{!RRoqi{eYP zKp+2voa96IF%op|Dl*SXw;IdciYnvOJD@@$L37JXhvp0zefYNty8#(Y{@|~9*zI_7 z*b`01>WLklq~ls6xAVsDLqCrSq;6Q7VOd2?GsGa;fo)T<{cL3y3Q}Es?}8^64ZhPY zjNCkOSQxcNmr@mmD%MnEWMVDwjxKxRQY56sOZy>fF%eYB%thp~B_~Q=nTEh|H*(l1 zbKi)}cQ*<_=dj=5j2M=dIq`Tp>Do+Mtls2Mc3SDwR>{jsNeS2b$8E+i;Nn1T7UyJU z61>;8L@tP>w{lqZyC2Xq3GU?qq+%a=qfLBm-G1QSn~GNH>N<41p2?=O!8$qkmSg zPV^N;<(&FdmQqRUsw-5nk8ikcZ{<6$rRZTZVEsb$f%El3%9U{(b%@s)$5CcM9l{V9 zV`Q1HYPoh=X&AhZ)I5u}zy+3i#i*|3d}~j6U-A^*b)}jPobH{q`;A>&!F>ykfW8k!$_`xO$H!*|IB3 z?>q7e_Ym*B6hHzcP}Nn&rjbo!_lOhzcp5ov8fPpPy9+=jkmAXRaKGY64)(qt*+dx( zg+%5H;rE`i#aiE@=9SCK3zsdkTo>*izfzW(qpgyzBW~HQ!wG-$i64ES*gnNnbjWd! zvfCUFw7&2XY}qhP`fj-?ML>eFlwQ?LVvy)7xgneBGF4V(l&}NMZDn%f4E+E8Wo~z< z%qSWnAnFK9-x&$s^wvX8^xCmedV8FhoJ5l#kzu{VnhU8mmYP{oV%fx{*_@^3!W5#e zGez--t}>gX2;xIT)vjPf&34d>g0qC^=|&QbizWw)jo2}cgNV4sfucE)MFr-)bK8X< z{cFov`(LeioM9XS_ve{0SbE9yS{R4GJdRT88WBf1Bf~Ib6wd|J0?nYJqken%t&*Zj zlQbLIJRJD=L%bzZ8gFIjDvGztfj$dSzOToJJA!xo@cj>}@Py@hB@P2I1aivsRv4lu z1Sg@JE>KG5`RSR<%L{KFgV_lZQmO!lV;tiR+ijGx6%-9# zUS8N%G2mUdjjrC($vV;+ zym9zOy)odd&eO*E#JjJ);n@iA;LE2ce);(`KmPm?;~cdW;xtpZ@biZ!u3Ms8k9Rx6 zIPr45(puMEt#X=XqW98Y7ulz`2HPfKl|DvVZG;esA+c)TDW!h{BcgSqgSyuArPX1P zIi~zwJOV~LAR#mbl!!1I{@urxfO(Wz}&j zHx-f0!-O}EmJ41t0|Yh_7^0t`NK%>`4HA+INS7tw)C zmxI&8NB%cs#7K3_J9=wE8`44RA=WuI2CV30$%k+Sr(wKi(0y3LVUWl)K^vsQ8x_DmRpt_eM5 z6Dm_2BHh5{dKH3iQ~f=%;vI)T+EFu*(-4@-o)e`M?i6oVb*0>O5WH*KIgXJqdiH(3 zc}G5e{J`_Gw8hR!o`ONDm0F5wQ{>r{KTuZ!yk;|&T*w%hq|#_z%JkDDi1XYkF$S?! zd&ib{tym<++#oOZvaaa3S++fkYE;zq*qTUvV-Sr-F2a2@Mr`add{o6|tN0Kjr4>r5 zw;|Zei`as%%g&w~>t6Zz@iYE;ypTU#SxTe3$aNJP;yBOv<^>Jy1a&oP zOi?r9aBEdg?`8yR92I&If@hp2wo>GQHWGYz>t%KQClXaDyPYw&vew+>!tzF1L7;*D z^&@SkDkQ;qkLzMgsZDxZXUuIzA!WLTQud>~G_N$51Nvcv66ZuPm{M2t5y2piwNA`pV_ZZ zq?|ZU10CssOOpMx)750Hg%}(q3Oc(}Wo6iQoPmDZqE!{xg1@yip- zmPFER#J=q{?YOl}%JLbdTuA%MzAfZ!q2(R)WimEMijrPP1{ILW;Dde7&@y|;_`&1- zBrj4ax2jZD{l~K@2X0j%lvTe$FhMFPBV0h^#5=Jp3)3*rnp8*ABoG=75moRyu+EIp zGkP&0c^^o%%D^#*h)L!NvhuEFBY1Jr;;qKFH*B}`+HZ%IF%BQXKqHXrhS8nox@`RE z&p+_j@4x52{ONlvj_X#iH8DRrVjS6?UwHrd3mwCjJCs7u{!z%ho?2v|opX`om>9u% zQr_A0G&k0Wp1O;9<|xI}Ry0Do-Be~qheKUoGF{f|piUiJ7}S1QsRGwlo8^%f zgsR58*o(VBNUb?2IUP*p78zy{Wc)7~AmK^o-eDa=ZxszwG5Nq`_+xv zoA52~&oj}B?9l`?sAbeTKoq?lnIm2AATr-BWGgFTZ?YSywKXg)vyUCAzZD_bi@!V_Ek^w4O|1S$Fm#dU=dto+ol??AmwY zMRjNN7OsMt;n)H=_sZ%!sK2i;3XOHraSnnyw$g zqaa!YxIrx7wsF77hfAqw@hvE8Yly+gu(B088lQI5y*fd!wX(ND>4Ft&O?qXSFEp&a zct(5UW{n(at?KRbYMa){rEm-S;Wuk$HQ-u0a%~>y2?p#Hg>7DvZ zI&>S@a%J5Us4~!5aff;<*_N$TMXCv|d%l|)qL(bcyc4Wp@Sc6!sLgP`f20*@IYW#* zKYd}EBHmh-eZx#6)=EIgNpmCxZhAz|$qcL2MoK%ai|7ZP3pg(a0K2S);}GawD9zg@ z>&tN*ZdInU7K{^kt#MT3XE{w1`??bJ-3Z2Txn3}Oz|}1Dr!dI8<#JuYG|3C-I-KsW zEr8W_#cM|?phRym-RacQ^7Yr>a{us-=tmty?E0YuLJ%X&%kwkVi2wPU-~5(woT$~X zr9weW8mYo|-6(YvHlQ-oLHf|zq=&H`DQk|wn=!W`&##KC*WT@QEf1PbYmmdBHZ6P5 zQ`k82u7j)IaW33m@YRUT8ZfIOocAyW??y_Tsy079%S1ft;&(FAPzn`T7#FJyYnOAh*Iwj?<1$vEQ2!diDAIh zCKb(|Sl1naUdVwhS_iAom8_=rBx0G|8dy(lkZLD)N7@ow7Ph`@lH}0$y7xbH4Iu=a zb&~Llh`x+*cxMUDlT#+dKr2~^IgZvWAx69g+2khjxrIuUr4_!6>UA7hs1JOCEHSB2j`nhZVB{vAx>36usa_JSqy2tRQ#q;+`w{IT#$3Of%|M-VLu&2!Ry7B(w7m9771~iU!OVAB*m;`ERt#II5 z7mad^k}uCe*p(8-c?E#9t`mBl1RUfYYi?zYtO2EbJV-%ChdkD5Pn8Q<13%?KmuFhK z1HCZ?C?F+y*VEFx4%N7Q&3Z#P9k)XC64H4DJT|&QJcZU`t=xysTMj7aZO72Nl7bw) zip1FC2nN|}D|(wI2j{Vaw=&vQyte#X04M!+J31rcB5dd3@huPc4=l?r-i(Ia%DWiD zP)&uP)-^+*$$BmrgYAvr<%NwwR(KTo-ftUg=vBFXP$97obBX+*ko z!8uP1@?UIDxA{nJm37^CzPzyKMDXz#sNk$6dWZM&pQXdy`9$!JyVESx-I6t^Q@+1( z9O>QO4m$56pFVzOE17et#5nM9XLR7WV6DU1K=8tGOl7~Bp}LpDXYzquxcx*v}x#7B3bzM>3+Si?HfY)ffyX)G|_UWDnRofEnC#c zR~f+z{k>mD|{e*S`wj)mo@sKryvuwFx&-Vs?=8-{OMf>ALX# z%M&>zLU26ZotVavS}T{{l^N-(WxHraJ59U`sn#$1sc-V!`FtMBvM8miLkjfuItXHr)R!AT^NTTr)nJJCJzH&y?x6tL>}KfP)pTqRSzgAD72<1~;}|TM+S&7}rL<=VL0S_%H0TmGS*zsINg^=V zE>6m-vl6RfAq!doh-Efn@zJqv8|$7}*2KCM&Asn*Lv$DhLks~-Wv>WEecR;) zin50vhroFpBx$&bK&P3GaYjOGj65qC=%$NHZkk9*s*YMKB^O?{mG_^Yd0sbq@4PHK z&cHZ`t@bp{T%WG=2G&UMXETMD>jfJe=hI1u)%BS43%s?~iuXZ`I$f#?r$#g9+zlpz zZb)iJorjXSXq-clgOr*DMA9^=8Gg0nmu*YR0wURxWF>Cfj*kO-l6;0^c$i92YI4Vm zIYD|-=^G)sh_yjZm=Nhsyw}Gb*BHy2$48cBk<=jI<>kUKOr(-o_MIhVzP!A!rOe&= zp1a4#n}pP=K*JpayW^#7U>k&Bv=_{;LpTl78!cZ3+t_PC0IWXWR{uWpn^3r@y@o7iEwr<-Tz8E4dYHYD8ym zbBhBt=Dg%4+G>ejB&^jqtcy4+ljM?<{M@ZFL@#pVEC**RnFB#4zC&qyyfs8G{5|gs ztr=X1%y%=+d-h!DWY#1-bu&UVsz6q_C&nmKzRK_{IKhN>c(^<9)w{Q(lz4f1=F6v# z%;Uh_>7HryJl@~ojo6{fo-h=gl>;^ovwlvUVTz3N$hz%%vq@>@eUt~*HJ+bd`26(5 zo|CHSEYUfl3R+C>_$d1Py<{*jhJcF!8)X>ibnxeUXFi{Z!wlDj_n%+*{-^iCqpjL|NW07|O08_0Q~=(Ki?P(gwo9^CYfU8Kxr&b=2G*2>HQ_zAL+Xuc z#1Q9eku^{*l~Sq>eRLXb9JNEPjl5oYnBvWrdbo<5HM%nw{r}75inW2(3iJ6yUpDUV z??r{CrA<}DSBR0)JHZF6kL+!s6;Zhj!$`^kvy{RA>kj^Sd5&SA^x*Q^-k_oFwMuXr zaU{YYk(ur~2RNqkM^2lyR?If-m?szxAri*WD+=)$d&Rb#nf zvi$4(vP;$Fou#M5DFk{5@(`v?UqUH~k9@|KE2hbfYz`IzXi%uT9YEfT0i`NQw_~Uk z)@{`?FtHa|l7g`JyT-6f;Dx^piyEEbbmGn3Omv3((;biZ58`F`>TCYT3F`wMX;HR46XS@}%)aQY zGX9U&Lk4iI!Rb8n_1C{)o<_EP6(=f|)>m>V48w>Gp6UF+r$7G0bt??#2^T%B2#R~s zyu>32cA8GIaWS%?DW!2;Rt81^(AFxlZYQR#RWf(`6b)mIJs)yrEt9pk70}v<2(+-wytCivoJ`O-jNzCWq*g- zbUF?>?=&Y~^nDd-Ztb0-?n|t=9FMI;H!{%{34=tAS#1oye)op|`9J*kJe*Ga%m4i^ zyu4h9Vc?suzvkclyMN^SKmUovDTN%3k`7`N(%BJ zGnNC?I#~<)5Gnh{mzOK4b!?Oy&RZj?Q(n3D&Xd%X<{U&nk@m_kSaRxEBV_1tn3eA* zvz%qGEPKZI2-ZWB;M$anWKueTqWTy~PZwG$?AylX9eLjwhJo|>EZ?`aH{C()Ma^3p zWTPS+?H6zE&v}|y7lDnoTyZM(t~t|PXIZX%`t*s*Me+^S6&@cRndVWUH?J1;`;*d% zd&7^OULmJSxvc=@`x%A-Y^7$QANy82aTsN2m&+{{SuCfWls29|f5P<2=`<5!WLw3m zY5gk;Zr^tKf~^T~!+YW|V3&n;TQR`H`NUdu$E;<}=`>@#M}ja#)m2NmkyEz1(W;`vLJ#qHd87;7FJ0waTN_yFekjBkR7{8%yaL*kFavfA|rsF~9l{3l4kJ zZ6AZD+m2jk78X&rrCKq;VuA>FBw(W5+>bJ>lji1-8}}|>@3{4yJ}|8msaTXGD~G9M z9~dip@=n26IpDnFqH-1*%rK4g4$HnvA8jmlh;(apcdaqoM*aO&R*fZRVhGIRz~jT2 zuim}o+i$+&yKlec>GKo6{QQBx{N+b#Dg4L(^dI@%@4n^#`al0OPtS%w{QftR)7J~N z7D8~eHsFJ!^}@Ekl4^Pv>0*q5UYh*=T7o#S*UDBZxi%ugUYug&{(Rzm8nKAC;Yg2; zaZnkDVc!!e6)w*&j6=Y6iQo!x;<{%(eEvki;p2$0o?6OnDK;E8sj=kJc)47}TvaM1 zC%m_O^VM6%S=yQPdX)is7)V)phDM#AI?plI>IMo*Rjo*^l$>!PvM&oCK763{#yAB& zef-3-E(CvI(EP1h4c>DQj{)X+25U%pCj=2PVHBX_9a}D#*70EkHGY+n@t0-gY#m{o zI87&(WvApyuaeQ0_l=TwzIyY>S8v~l;h|}`W3!;;P*to~Yn>-OvAeDwF4qesiCawe z^-fD|iwiQ@%zM7wzDLOBF%UUWTt3*_D$ZC@21=%Tm7!rjsH+m8^y@i+)d@E$9P;+i z3J3@#=R`9yI5e){w8iPV`#<`7@4Tq!`T-T?wtu(I-oiRd&9v&E1)%~d%{Z4zwR*#v zW4a-ShP6Pcbd5I)&S^fK9E!q~6Yqp@P%OJL=_;tnM4XY%ila@0wp|i|u~ehd)2;N&gR=}n zAViG~D`INuN3~ZQE{X&f;O_2@m!}u@EfbvO&D%Ge@9+5WkALRJ_n%o)CO6B_rJeNN zGtMKeW-x~7G;>*YI^ctVPQ0$M_mV(iA5mk@OA`T^4}m==Qrcye?JPy}6k{BS(X(8y z!X)UOahh4y>n%iN8Y3}8TCGg;#25#z%Od(U@tObtAOJ~3K~ys=9~g#-r>7?Yrg~vV z8Y`O$?*cu@b(ETTB(_}0wP1q`N#*zD@WxtFO1L=OcKoGQ_O!AsSJL$YW#{4k#57HU zOLiV(nn)paogw>sCD7JNLo(g4mgVKj+A8~c<>BFhhc^-D0vO3E>xXQ$w;RYn%E8yE zdsj$;2$&8{fW0~2taYLzXdO&N*!e|MQKW}=U96f07^3Xdb1GPCd3?ARY*rEO+AVBR zC$5JA3q4>CC7e4}f8E}ylS3>d)sTo*jLrnaUTbx_ucf!PA59cQvoYc-c_r};0@n>{Tl+6I7H$&b2=s7ynV}H zVHyK5TK2rNZ7ah#y{0}jNp)JTSMhmxdlQribW|+3<2GtBeMIE>_7LO`X385qV9vZ_(7 z73i#Y_`8RDTB#hVuA)m9>goAB^S6KV9jEiiH(!5^(I4d1ZUDMKMZXF(>E(3tB!7;U zO|2V-X(I0{P4U&echa8dT`GVhETJPVF*(u1np)0slOFrf+i_r=96qYW7B!pzD-WVi zYgHqt`%OFnV0slHhUo%`u*iwnCDDggxrI|4h6^t}WNRW0(pOn%uEyN95*=<#L5v3@ zmRbWuZ?I}DEv=~6Tq=}fy;-}Mq(CI04haBn*oK_-MA&{gZ z6`eu!4OWCF7O8fuii{3DMy&;bvj!gTXCCGg+p-Dt#TpFy;wByBhJX*ApWeSG1kc06 z13!Du&p-dn5a90a1jzO%XVKAn?+HVcJVooJKQ6NVZ4JT@2rlyS@tI#fePYWQA0yrx zPV>b5`9$zSK$6(93GV{qILhq9JLY-35s2Ttd&e)od}PlnpPm=~_`~=7@Y8$dyEjZR z(6_8x6k%9gE{2C$o)R zK-x3wx)NfFF3LJbP}N%qN;Q@h*rdR!NiqDw~gy{<>B!SwXb~s^g>RB(^-N@ zua|{=-PpIC?j12|d|MG0W@*xPwAS#V6PBALrJ^sJ1M8W`iLbx;ihpQ-$G#^$Bn~FL zQe`^gimO5^O}UA122pU$bHuhLu!7c!F>+m2{E_r(Eip>MY)Y#R*kWD~ZeVXCCK)^E?1jF*zfL z_I14wf>a_OK7Qo7FF0#>dp_}S|G>UqxxQSuzdPZa}ZQIBx;egZmj^Ia1X&6&j zk5ZmMbe=FwY(*l!T1OGu0>m)Dwr%u|s25x1{v0SdLo*Z&hMC3z?>*BnbGiJPzx?n$y%RS+anSQXkRS=g!~tye)~nHx_)%I{k1Z9Z^Yz43Yw znJymcpb{mc{rhoq9@U9a@k!HPzleh*_dOU{&DC6VaHTfkZf?_DRBdMwEqp}|IVs-{ zM76XCu1U2~x=>()7vWOVNph`ShMm?4a>{@oq8wuSz17_0#cwiWKm|C{=oy1$2v)zo zXfuqqMn^`%>F$ng-}vd5pV_u6XYcSm^WC>^m9)EKZP&;!M;k_|^4x%RK`gh{v6qB( zj+`rdDHvC{tSj9}c&7KB$GbC+clQk5$zf9Efga<)ILye@ptGl)QVPQmB@)aF_O3O{ z^W};Q1A_*NcyCmkW7*RMYY(}(6QD||*Ju z&VaStHe$!huN65Q#JOnY=P6l!0wcVG&reUhxw~f=2bRl9&Yhg3Lf=xQ*`4`(mgm$b zqH-bLe|W+ghxMLr&21=dy37NDbDXA$bx(MZ+bh?`UZi(7&Je5sx3*2nnw&GW$^%-9 z5NHnSY|E8YGByrG7dTCZmqj@C&(F_PEZ9L_2!e-TbI}mWCK-sW-P(bJ08?tGbZI?m6BAOeO;%sl5QahK6Q!y?U52`8+vvS=ng@B1 za-!yhGcXJz+b)A%XAQ$NBEm~+a|Z> zmN3pTO%o~C8}`fjKnj^ugePHLAqW5o0-dDykFd4(PZ8F5_j%_Uns!KcxIln$I7{juz>`9}dg(U_}Tzp2B z5tLGO71(vnDCN2y1LQ2Xp$nSpR|^qZ> z7{o={ThT)zkc+^w1jC0vaD8YtGFgF z%QOm#%9<`Aoi*c(PE#_{17Qsght*O{4`Lq zOtts4V?yMTGOZh8j11m!f0}rFI1@u8mqIR0!ef;*WrG)vo@oqIq|u1u%;%?-fB7$e z;`^U}VLqJ+gCr5nv$P*gSHZm&g15{u(sJQ)dFC|V$;HXj~_nLkv=xp z#-0-(hfOPnag-Ofc5$uM(iw(ZdHMEju=L~i)>ji$t7n6jL1;1xz{0IN=aS@j3xz%XFW#kr<)AqWK)6Aj~X0d z9!>&vFt+0~w%O?3*;>mm2x5B}BEujw+Y!q!jV$X*&IO5W zRdWvqcVGWciM+i@8*-GYA&4NzB4Vb&IZoqDPKB~RV{Bv?BT!kci}aE<^8ECSRj!@0 z0Uri_`Sis1KmNpb-#+4c<>l!E&JTnGKpO-5vXOG-&6~F@%Ss#v#x#i}Ja{gjpSWDF zGJvErhDQb;BptYDs!j;>Qh9!UA}3KDzI*$?tCecr_61K&YO}om@P&`R{6g6`rg`RZdXN?-XZDl`HZY%N;t+8r(pzV_ zE~Gs%jNx@)+&j-t7iwwJ9z8rVkCEVCw>hm;X`@PJo@b#r1xsw6^W97gBYoXS4TfP5 zxNEcO8L{lW(Tj-ujCaHsL=dJCYu+1tT32#`-i(x4PNvZ)Rc6bpMnQ`Xzt&1G(5!3$ zmVLYRceP6tQMZo!yGK60T-cU{F-kJ5Gu+DXZOw{OR?mJ=IjeHOd#jY1@R|@By~oZI ztqQ;*m!vPe2y;w1#0}-u-Kc}P*M#5Kl2=*^a9&^)5`N)D38sgIReoQ}Nrt37sW=DC zb3c@b+AbhNM$kT7Pg>JO$mE=3h=DOo*j@=huZdP0-F9Kw)p{enI`2tEdc@kYAkAuH z7y`vKEEXT+gYCxBt)*Iv05)_luI2tQw<)cNZbQve&Wj^FYCL&#Q1^wBEAudNo@ep! z>+o?cvUB%wpd)hGbzOKnykS0_aemx&^xL&X1oSEi{^ZCRu3>#fVF{X zyywfym0$krpZVd(_k4MNWkz`~we#wclT^XmD zcy~t#;%&)Qp1YJXF+@tPIM*pH@%-gVDVfte5}K1B8Dn|+{DtMZ6M{sddus`U(0i6` zl^8ZJtwryZoOfz!Y}+QQ#5mlBqiNf)-jS{7Qk?a&jp`~f?*gkSCTqnhe@@B`Pw%*H z*w&q8*=WWx&1d2;kV}&qc8T5EDL)dpFklzSKOf=vJI?beN9Ag9E2T?CM5bk)`mt-re^$^N?Um)qXl zZvI1eeGq&=Y?Qq>hUjH|)B7!S?2s(GCYuOv-Hm?Z?4exL-FeXU`uAI? zBCs+(U=R6lZ3F{jhzx_L6bYQz*Nv)%AE&CX7$fU-p*CSA`WR&ot$z7jrRNtG!Linr zJ-acM5Cb;X&<;|NnG(_+coWNbAP+`3rHHU>qrXXWbK}N>s5(3caSJCb36$r)oZr4;HJx z)H!;hw|x868(v;sc>n1|`FWM3D?0J8clMB?b{JJKt6 z#C9sadwIEn6JW$atDy-5B{qxap zMA{%hv$d*%RKrZHgQYd)Gsx#xYa{I&rNZ^Pk@JSLBbVz!^s<7bYx-^%5tlWu83pu) zvk;@GN1gM8!4tYrwbClphYtbgodmdIWS*6(UL?}CwJO8P)(sdh3dSNNEk6vJ^H7Cg zWGvTB){CV!To}l;NU)2M*08B+*6+KNwayymAuygsyo2kyvaCBkMCN%GCOKl1sEA-i zPEN;`R$3QZYpa3iEWIR#F!DFweN8EaWld!DxgT2iaXLxaWo5{QifNj{6pkvusM4>t zs+1ZTy7bm=D5PKW1MII%8ETY!l?CeyalHI8EEHpmK}16xSt;sYlwGSaH*P`*fnGJU zz02g^cBv$cTAhtCHyoE~jn)e0m{S;_RccXqqm{#<>p|Brl%`j72bxqH+m;wY#2b$d zhIP->mSjC^jeffammU=}$!l&@>33u=^e$DFQ?5W)v5+-#*vBD?Vz4zKHaUxnUa)aE zmMxK6Q!$TYS(clY<2+CNkN?BJ=l8$;hM)fUuR?|%yx7TWhT;@t(Wo_(i>Ls-_k8^D z0c+LZR5Rmv;(R&@#TO;=R-y8?R@h5rj~lBOfz9==zwpziFZ}%eBOP&K)+(RSMc2?NXG)W{E|3ar)(b-xl@5A^tCmd70^gFQ_b9G5|=qUas-G!v|#w03n_dMoQeNfTDGjTN_GQW{e4 zl~y{zd&W^7;@~6C*DIw;;K{B(hYy;+(BvR3rC_b*3)V(SnW`vn?=15mC3Z`~xUa~N zYR{R=<-%9*9y#5gSXO~?v@B^rpFUskabg&SHnZ&+V~sd1+3*(jeWlclZ5fN>{%)r9 zt{W6jOFIq6vWlqZo3Fm+@_ZrZPVnl+R53*@RrUXfrFWVLNT!}Oj(tnKT&}$T{KQ{B zex}N9m|CP&jnUzZd{0$*{`O$@*TSaSfkXIZTVr2$O3jpB@WEkxU|lzC7d73oEqEi2 z%n%~ZZ9?DeaxwKikHCCzAf@ucRGQRKp=G`4X{`^;-E<00*Q*RXT)-$0R90{z^)=@8r9TdUxcB=Wp9Sxr?MrdEQ1V8xc}O{b=fZn}hn7}=+f zLu6lfTCakRMh3E5+F7@qVV-3^QZnN(bALXwTvvKc^wMrS{UZ-B7z@4L`~?Dz2zVFB zJqy+gnPmhc*fD2>1|aBk`PnbmXa4eI=j(TmO!F+|tMj;Ed43iGVdF;feV8Sf?|w>yGm}P zsOn@wp6JGLnor!{-&1Pi{l_P2H;m&<>B4RB`e%TItBBl;^~B7`2BCc zCUy9-B-VXrKKa|u+;%Q`4X{L8kz@y!;@0nqc6-muSjWJDp1KqyDLY!D;kDx`bGl=~#5E=PE zT1uFbnS$ftG&7AO-a@ZgvH}hpr?<2s@Y7No;~0fGP?M}Tz1VzPlVRmF1i_Y-%(5p% zn~4!9Wsw4xEH{hHBcz`{ybv{K5r23~@J?R5B5=sw50qI&e1lCZoer&2Ql^>A>}HW} zHwi+;DhkaSsm{`h^Fpt!tuf9M%k_z28ijoqJo}z0C9_;thH1vCEcyEK%vWE1&F_Er z9l!m}U-{vu54ZBUbseAr!3muwM91U(1J+pHfB3-Xr)Sn&UxQ5jF{}+l=g8Z}wl6qm zZk1uJikEK^ntITcmg|L-Hg5DuYcO3lA#ol!-`x?d#V93c+g3_RoaPBx_bQ+HzJisPwYA2&UOCSbqw)@;7d^=3dZjsorLk`-r+HLu1@w{_qsO~Q zN{O73@-aFoWtMfNRj^J|q)VmNf*;06-BuC1_#kA_ZKqc7gOeeVF`VX+%htF&KXZ9m zFwU{UiamZ4<2S&7l{?b`=l)`X2apP!bSVduDw=XqArkb)C++FnYg zR$0Rx6dq$_gw=1l|6dD#UN-}Wj5me|i0e^q{?4*&x6?ZKK?z7rsJ4m=FF}AFUFQ$I z9rT@Jo^afoom3^)!1j)FhA|Ax(aVQo1<_@V=N2W}1T@(=FyXMJe9LmjNY-Ar@;iO| z@CMT@ITf1v*1h)>I#j8YoaXAGTM`%K#m_n6bT#OV;IzE6$}7z56@qmP(P530_y+{! z^8CyY2T9$TC%Q3QuNR@(^h%)-hlsWC^y!K9`H6r3&wt08$9r1K7z`nf>?tt}qs|>< zb2LQ9X&MN_#C2JDdXm7|dA{fOzx$3KfBD4EAHJ~fo8}`_rYPBZwacjVa=Gw)S^4q( zN3L6@S;5U4i&k@nUMqXKlJ_JBycN&HRx(FOMz0+o20%Ch!zgRYjv=QamqV%y!@x91 zz-;s$Q#;ja0#a#|(#TYj!d`ok-h4Wrn5I!6p`~!(){W`-;5pe7Ni!O@>xFl3-`(1u z;6-O4|5a9`!C79OB`CGF#=2!`aee0L`B~;Yy>aAdv|GHJ%(A@qZ2N|mkST~XB~*ab$MZo1AZK^qJ+VQN;Hkr;29j;Pa@A; zb^%OU?^QmlVwEm0i^Li`e3UJ~QHBfiUu2n%*R|g9uUf0xl|{Qx7l>r7T@L^U2)@jy zufaJn@zA@-Q!z9Ixs`P=Cyvji+WrGC*7UaR>}jLa$~;7-A#y(soPsCF*hSWC21?2| zT5PSAJta_^sPT@v@A_FZ#fpjMpw>!BJGDqj?Xg1h>96TUsT7R?bLw}H_N8Qb7=yPG z2CuSkV=3>MRt*qW^Fy6Ft3nSI+h%_DCg&uo_$ z+{s~$3`)N|J>$LSJk3N^%^hgD ztJ#pXff0vZh>?BII9sqb;KPVe*&A_;B3N@y=R&a6OsgVCx6TlZs5sYUlYylbx$m+I zN^I;W(zfyC=>?1>hCm38S_-KPCAb?2xbfC;e?E)-yfsqEvMC4yrF6EGCA6iBX~~x= zW`${xZ2FZQn)I%w3;(><%IS26_an6~ENkLvz2dEee%{Ry(xlNIl*=Y_Osi?6O`wO%v8nJlsFv{Xp6!R?1mv$?i_~JUu7DerLh9 ztxkX$|I>f?@A&SkJJR)8oP&AC2TM+s<+@{PXBYyLasfJ(Qe=7_V zh7TXV@cH>FFH;B-sDZ^c!@d`mZI_Ld^O$bc&fRaR(R6tcj+_Jm$VkcWy=ToC5U;_$ z?Yvwr1WrUJSrvAX#NDDGj&YdhQUFr`03ZNKL_t)T2Z;u!iuAhbAtTS3lR<0^?7Oi1 zghJKX)`cUDxof~jN=dRZb5qk*7LP;k48c)y;p68o80%QqonfA2O&jA)U(m6HIKEa1 zy#A~2nq+A$xJFkHPD9+Y{z%Rlf>2nk6UnM`ik^0XZX6*>1k-77yg84oizg1AT6VmN z&?_-m<}t|d%NrbxUJ|Wrr1e5*67*oxY!Tli1z{X;Z9}O zb%rwJ4%@5<-$haAG()Frh=L2$CdoI4B2d;`vQiXF@iC3p6=cowAZa&fozatA^8yj~ z-V_}35SfRFHyz&_BC)JkCkXNoBR$AVU-GV&%}OqfR0`W(IA}$d&N$ymkb_2XAE`%z zCF`VZC6^{?K}Lo}M^u_q+OkEesp$Nz>~FQ)7!bYN+t-7xx7NtR!yR#$DBVy~rS^?( z9bpJ;+b(GACW z7-PiyAdbe8IL{-G_ji2${LH?t^t*ehr&=eMCV2+AidLa^vU(eweT^$S04L(%m*)m! z=($UBPH706<~8}LXo7Xl66-D4G{~*!5EW_ zxWeJ1wT!dHRqSK80X)R@jT>RW&{*DL4`nKPG;v)6dzVG`%$F z&Y`wetXU^#TvaU*J>JlkA6c6U3 z0z;!9#4P+I5hZO1#UoWf564h6xq zKIL-5DbI201rAf#kOynr(PhzxB`i5j8Q5`toai_(T4%kiEO~iOSdvRm9r|4vS8jGj z1G=o-ttneVFVqCDKljmvw0p^ow_VwmYQX9|9vjo`T-FXQXsYp^a_lfWm&=vw?P`?l zXPk??e7NvdQl%GhUfPH=RV!jjqt+z^iOI8E zGC2iO^5i8Fx}(%e^pFP3aaes*CkCb6%x1+H5zAcf9j1Q*X3v1eW#KrE_qCx9 zrkkdh_e$V(p3!t*Ol#WlL6ljy=&}?8$$N6}q~LItPv~*tvBw!_EIM^o{rsgi`{#=C zbMrm0wD$&6BB-+Kwo-8Bu-o4=-4G7KG+lm%5uPvinVuAVV6h~h*`>Mg=!J70!W4L` zV9J6UlYIHW_4SqE;FvItNeDr`b+z{=@;`^;dRzJWtB?G_@BfrP`jbEAx1T@L9tZj5 zBYkRDcOjCT?9yWda?0dOWX$@sf{!K(tUd?Nx+az-alI^D)W3u#ol~QG@>Vr1m_Htvrn()Yb)ZVs$=a%{?Z_8XEPzz+N5D<1SvM1(7$GYcY@;&$NfE75O+|@i z&Uo&;>ctLzaJw$tOU2K|61{>OXXn@s^5udL8OL}AVynRY#ji&fDdMMWa3Vqf2twotRF9}5mF?LLG6{n zU^_OlUr0vl=^)@4>LKb$jW(mJ*(Z9>C1p#UQJ_k%g?)QSxZ|Yk!xWS7UQi<7F&YRt zVGc&EEX!5@zd3155B9PwoN;3zNTqnH^V~os5T;Oc(&eCCq<>*ZWsROkN%i{_0!+uXp_JH zE**Cm?cx7>(YP40Y6`wpICqnS7 z>%!Mxf5Yw9pLsk?@i?^tY^5j^!**HhJM+%s=gT25)K;fHCi_vy6UlC?l9BM!CP@S7 zLeTW)0&Nt6CHls7;kqtd){L8tv)-#)C&990CbFqZyf&Y0QMD-L%DcdE6t1@$*UQz^ zd|F#_40r}(NCf8@)MMxIP$t6T{vbHdact_zh=vdO_xQ1#l?L?o_63}kxjHo#rIf)1 z+S!Dqdx?lwQ6)oKWIreCs#DkDDNP!4@YdiHxU36(NO!*khwnqZW5-TfG=9&~q<8m8 z6<0XQ{$Ts^iTn58ljbCOWNGy>s0c)HOl&`I(l0x+=e9W+-lMr~8b#Ph%WAjcF0)AQ z%w}W$fJme_YxtSc4GcFJt~0`b;H>Q@5>PN`cotQhySG$jZcf&eR7w$o)}1+s)0>k< zf}R`}F%IsG0-HRGN?c%e#aYh@txcFgfg}it?nC3^If75yW2dt`fvL5`Ii<_sJ$|YP zG)Bj|=-)rbH0iIHjZzg)m8`^6S@`hP$5%dl{2K2QeL8$xh$Bd-lM-90>_uV~u`*&U zmi2|Vd*wg=)!*~!`|kx_#Q?qXxZl~goq8O6_uJnxdt?1izvi27{+^%x>_`0TKl>y8 z{O5nnPk!_b_&4tN@9|@DjS}Rf=$PX(%s?NG(gz_-j?vkxWWYF0h#u>LGeAj7pb>rGx-ODQ2N|bSH!No5<$59Hg>Bz00QF8U z^(jIVz?nFmuxDsZGp+s^=;9b$W|mH1O0C!G&XNN;1(;3w2~j2gP5 zr2S+HLS(wZQFN=H2B6(2k2<=2sj|%0ra#YVO|=Gkxfo39uf1MqsS<=ID5D>Z!QE74 zF=*spVk9zfeTbj8Oglz5`pJ@ltkN)|4hZrQX zN{Lzr1C5lUO;X5=t}KJJWO7R66wOjyEudA7?hsX7?d)^SDRH~K@ZsaDMYIQ|Nn}OM zt<>IS3HItJ0BQ221*!b*?|;qbw>Q3g{vysg28Q7Spd0q^SD^FQE8qRo_x$qPFZ|U% z{4@XOSAWHy{mIYx*MIc;{PZUu$*U*k6`Vv{zxnMazWaQqv_ZHG(u6v78T2uAb0aDC z=!IFE9e6r$13CmJ7(HrH=q}*mWO7cK9haghP93EkwoU|u}0h z@!qFMZA|vZCT+uXw4nl+qg5G=M&Rh3S}HzR6?#rlyIHSt!X>Q)wN>`*zy+m@wo-sketPw@#~5g{5~~_ehIJ53OEvB$uEFHJvO#)t-vx<&rg{+Pn3e+S zY(E-`basy5g`(r635aWws7I5Sp^bfz`(^d&7@o0l^=;zr> z;iw8P3C7GQOy-OPpU=rr)9$oGLYIbeBGj#Tu6<{fm&Z$}H4Q{IiZ7*1Z;eOM;ZRG( zJFi~DI>2bs83QRSkc+-_k%cC69mekTLU^G%{BfnhfZQ3)fRBK$|`tnLNe@hC1 z$K%dk4@>tkx%-*uZO@dtDF$_R%CT!v_LFK8;Igc!XK|_lrqyZ+GPUMB?hhXK2hMvb zqm~OPNatT_<9FYE=G*VSP>LgaM>{H4@7ecC_Rx+0&}bq_HykeqWm>w2NKN^>6X1z4W{+~X)Rjl^sZmsT(DWaVyE|DKd0J_tCS4xFXeR602IJ*qk! zd=#FbT{-Z($HD*om;cDOpEv&aU;Tui{@#z+OXn~C`tSJX-~JBgBN@-w3+`x=OAn2? zJ|&~<4q-aa;#M6{XMJ3^2}~bIe+I>P1B;yc!GYirwn> z`-AYI}g*?rs8kM4uQFote^W&Z0hI!!)$ zQJgv5B+O7Lsl3ff?lra6xi@&kui8WK1ki9+^mtl#O$dXOfZgi5BH@oMHr%cD(aH+U>f^jC;s%}cx4nhbrb@PWCZFsQ^&O~n$CO4UTd8+fRL!& zv<|I4_s|$7DS2Y_w5H><+X3-3Mm?E|LB8C0eSP6}y(-n`D0Dm_d!`M&r%cw_B;%3& zw3fzt$)-4QCg9R{6LVreHk=#yspxYb6BTo24n4p#M7b2FCbz?R{`NPY`Sou<^Wo*6 zzz5zoDcn3tUz)Y!+)yRD5BQj^h^7gsu7!Yb8tFqoP?cG=r{M%(bXg|`FV-O${F;Y zSykoUN@Lp|e0-I6=WbGV?>xOWa#q^%8H5v@!&$ISPO@T4@u)-ojI)cgH_SU~sQX~M zONn&3UhRjd%vvFKj%~A|h)4*D!z`<31^5rvMK7Zoz zD3DfS%G%}oWZ<4Wt}~15m}bcF-fF#0QG;3LhkdwCd1%VVm*63ye`dGCqf01l2W8NU zYZ8BlLL5GPc;&KW9-qG_d9MS&(vqWhFq#B42uYu)<=8p2d(X}=W6`tw&&E<0O!PE{ zf<32hAZZ(nmFd-fKOF$2cHR8Wv28ms1!ijmH_0h*T`d|7?Z|x$8`qU~9HT@)OaWQT zn#s#T8{)eMYJ%?V)Q^v+g*1e~sY!Hrqf%D|y4nLDVw9I7dt9~bMF(d_g1$fOJ07}i z=cN0+MyHgLNaG(P^W1x)b&5 zrnD?MM$2K)ir@&ua_l%9`{SV|6&GklfZwQ%?!Cnc7gFrBqq9GbA0+xj>KyE)vgW`N zBS&kDM|147w+2|y*KOStA;!$<0swIWHVZ`Xsr`bwQRqb@U2)Hs%|JZ zJDw@kn^!{6aGr{UGo@A9?2`AMD40W1VwBsr9S?HOeD!)063gJ_vT_NIaQYAIG;g(1 z2NLU;E6;-kdkp<^ExbXpRDo_9`G-Y1y@Q0_d)kn&qw7qjwnnLw(#{)LH|f3=lAFAK zxNuzqONtuX?S?zE1KGXj2`aO`sfC@ zIRySO@BvFxJ`X>0435*LY}M}On48Y2LTwDzxZr}Cm}YSFQ}1D>CJ;U7ylUP`Q%bX@ zKmCl;>$nmK>2Q{HHiziX(KQ8y5b;6M-9BWn>O(qIZ?f8Q6xtZXAga3_g*7K`w~Hdh zn)CxH3LiR97lT+ZB`q~K2tIOIua+HHY~8kttV_)pgC@dM19c8c)v8fT;iyHaP2Lk? zQtKH1CLd4Ma+GnV;HXo#Hg>=?1j;bf1=k1U z2<><9En5|j5kAN+OGU_(NJ~M-OHJYdMXEe#OKNADBs|<@SJ2#f|);QY1 zUNz0Mt~F-5XB1J-O*fZ`Gp7oJpTe7-UlGXv)Z(GmE`Iwb=o60+pt|?0qP? zXG}sAdfi&1v`Wq^(MC$$JdWYf3gbklIpgA8bapf85NOT33l^;6kaKcOoBXECMVQQb z@d?2&-3}1FTxlq?P(W9E_7}LRkd}USR?hkKd`!#X^X@$pGT1a4VxX4Fx(cnI&f#K& zVSNft7fBxtf|8HNfL6r}r68)?P1VMAH%+J$@GcNsU<`@ndXuh&vq8#DYLiWST{3NS zO1IC)3x{g0fRmE+EU@vxv1EDvdlOZeLSQe)(^sQIDdLi_GVisb^f8PUg}5Ju4JBBDdMJw%i_m%B9jWu{) zrbfQ4KsCe0XjSn?Chwf*xNaE0S$ydX?}mUIdSRJc=M1{{r-47jG0NKuu#ik0j(A{KJ~k{dJto>T~|s>X*%>0 z2a{?yV-~!V52a8v70ss44@Vg8DP#iCzkrE&x`Jomd9XU?L>>ES`HdzccV{w?4v6z5 z7+qbE(K~WZ0tUS-wxu>o?{v-yr88RNWm#C(3)6&Zd0DK9*w_Y>H~XoBZn{ZtAUHts z<32jm4I)jl2k;4( z67vVo{d=9ABeo7HFT{E%Cdo#IPSe-~xR9j4nx4HB`h?qu7nY+LB0tTIC2%e{iCTh} zfFXHD@e=uXQ!c^anj?=CSYn{o$!MM7#NQ7bfnd$6vUB2|GdpLepbi#&i7_f5BPW@R zls?1r)L&wdTWlhe%NztCUsgW8+_+vA_Ey;UhhEa;o)X_vRAh|d6Nm&M{|u)fNSj{x z!AX05fu~<#+F5dzf?}g*8=5A3&}uc%&Cz?eJVJ;AmP_Wt%Z)W9O4%q!mjcipLxq)S z$MjCfbxxU(f=y1ku#L7^H6(Zw#HZ&tGPR+MQ&~g0{0V zTXVg3H*JlaW=D>~8oIvU7^5!5@4kQI$3HokoV3^ZV9F^)cE$&H-oAX{^JAmozy;$K z1y-%gLJEmi8gW?&UO!Au8jq@>qO}(0kf|l7%x#H0>f{)eGS6h8F0sZKxD>_Vc!g2o z-ZS%}4;tA9Ccg2cMN!>uNwh=755ppym*rwv1D@a{4UH-AdtZOWZC#|c8#3zTH4}o$ z8;{oLwX^0`tcV>h<19}J5$A_85Zt6YXAw+xAlTY+zWvTQQ~haIt=1I?o>Eo)HJqn) z{X={VqPBYDdRchAU4%o_LrepfW^1=sYgKuU-V$+qAjPCm&y?{|*5lC{K47DyXRifk zAwU9og@~`03%Ay}Z=02g2)hVTA{oI9?ulj#hd7H_jM5EqnvQ8qM^Xy$oDxpW7!`Kv zq-_AH7uy)%2hkZ2InVazVQZpB=xLE$bN1&N;$wP#&KRBSY&GyPFl!^{#BE)5A`J2#2RoGc^B2a`KZhQ z%cALdNm+pYIg`f^idURs$_&3W>Q>6i zZmYrQ!`22Bu8cXLH|s3u7-TBo%|c$z5|`FY*i$tTrkL=~+ktb^S*P81Pz?z5-Vt-+ zSRju4b(AhDT!cH^WZquzrtxj!E4rQqYDCZ+ZsbaM)Mf^(Fk z3U?as1~_RFl2*F4+=Q^c-shG#!9iPn&p4ul-^U zjc^{7Px$Mq3C3pJVJm@;5;cSvbc6Ip@ClxRoJu`*N>iw%Mo;nU0zDkvYhXK*R>XID zhWB)BE6>Tr>lie^O(VE}zKyyiLU1h0!eajXYPDbMWl^Ww7}QdA@_Wy^UO3B4%U+b1 zU`oZ_q|nl8@b1V9-X79n0tL>AKqJ4O%2*Iet3zNqnO&xhc)fLUbS&$I<)Z1vyGiRs z-UJ-UY{kP#Y&0=6yAP9<8l7sUmpLZAntps5TJD^Il`8UB@v@ zV;`L`AC1%6VY?fagAc>GQ$Ga=cj>(oeCBMHnrHIS&>_jtw0VNGoB+3XFtA10`MR@}$nXbBsMxyM5KDgvSaw~89gSUMnxWM(pmCJhN z?d{I-P=RA~hIyP|UNl7Zbo^-}m5#!n>P71ua*`eOF%96--(72^*f{I(!W%p+DX^v} zvC5ff)5rUZFwbY*CJh@C=N!b8@jfVbzy*s&tIvw>(_cS$2Y&sWxFC=E7-v9+MtzR~ zY2i!_#3(%*jr*kbK}_;_990uTX$@y$8yx`J$Gs2CUY};LUb`Kb4ty{@i8y*U-s!~? zNC_qu6ZX+Xa!%6hqQ?D7{32YpVW z$#eJPcqa9F2cIPckyom!N- z?2R`*PDD9)B4@9_xo^)WhY#=EzJfVzMHpSNRuck&yk1D_DxP~kBm?fvCM9)3D2c$S zL<9Bo4JNf0O$}$2n|uEZyG>HT%2uD#((F%Zv{ZV=Oc?n4ta}?%;IOTQ4tRZe<$77! z-abPs`rn*aHbw|cFO!W6&M0oBE9WGwNo@@`=5t!sfvCr_kIoW=wgmA>L& zT~~#OJI_%YU$%q2=!5q`$+fe0+m#(4h2Qx=F!bfsTFkIv`+e_t7fB&;TQZ~W%+c^c zopN=&Qy(tqCHHfZVoDwfKE#%CXJ-5%npl$Ty53r@lDdcBaMXWt&W!3P|rnYzqCE~g#;?220L(x$zrCpDBM>$*4b8U%+u)x`&coV;CE607 zpO=+vD#uzo+rIPlBy2UP@LH8;?srAYl9E@O7 zsw4R*rY4G(ttR4mCRX9hktwcT%!rD1Qi=vvD+qR7SL%TMI9E_zK>NPg@1?9twE}fY zld((qQ`Bm1Pn}YT(WEV?!aL0t8H=7*aHP$eZ9Mb2KZAK&GL^;;!=&6dPlZ z_i(5&Wvg74$TeqjUb(Cb$F`BvB9yv!^{ki9wpVHw=j@$Yb+Q>trX}C%CDP084QxA( zLMuBd1(uvGCr=rMAt|G<6=nY!CP$77&Owfe+B%Fz@`E)5^|JfGYUpr^j$Wb94yG_% zvhw9EbD80~lzY9IV$PuiBBKP2zZPi8^VSh4WtCzlvTT1H=2OF+QdYGX0tkmqJKhCi zlIf^c9iF{c>r@mFx2#t}R0zZwAbONTlx>RUnscOOp`$vfVK0+LRlK|pHqKrTDS``-zdsU5%KoEYpkD*-YtLO z2Wy}TLmX#qz1Uc9i;6egqCa2E93$J~K|gkK)c^l>y_);cCb_7a{V0W_v?r6`abjkg zE{@w}WlXql$CGmOLAXorVhyHi9JTS-_h-P3w_=gA&$6`2JkAUVuROoEJI-Y2TDR1T zfpY@Ydncq!^pTh{$K3VZ%+B-@g{38n&TT3L@!o6V3&|66d?K58Jq!{^1Y&Y0xy&@T z+OcgcuOGR+T=}x^)`lZr`m$W`W8l%w=Is{8b!sb2x?-uP<6b)ZUYO|Sa6yQ_vzMT| zGt|>RM|P$TiD0}nHu43h{lAvVeGUQxAM$e~cO#Ia$|2V!@m3C6sa%&UYlQ5giB2k` zNfV*lN-yzc&03Ytk$ZLtGpc;@F=m4sOz&Vjvu?T5b?6j^>M#eIK(cD_UOvb`bjg|Q z6`fTqwYGPm;>N&AoMI8pFmyVF=A+ zvf+uX{AaDo)6r_v_=)*ETH!bjxei-1ZG%{o93$;4V~LT`CcPILJY~4F_M{Cx-hgAJ z>x?m<&yYcorU_F%pt$(Sa2SB;acziUn5TqUdKD(j{%$W9Q_%=1@ZrNNtsLUeOQp0X zXC=l$hd}8nBMs&xY+V_ex7&@pB<|bs6c4!|-NM8vE5PugqpCvf1OlTK&z>TuV7(RU z4p5yOb1HT&Cmwr|!7WHw)`q~ydK8*#qFDnpH#kPK>8C+EaL!YX;~9INb0)rgc;R-t z5Tdw5FfVfLxVX@&jaVKjw)*6#9bXF9%fh;5?wi1?G?Lt=Rq{%g0_AA1MER9xGh45x zSE2DKWny<6ec(|5BkttVZB8HVY3(BaN*A#J=uJQGaEu^;x(3j_*Ii9F6b z1CT1M6y>y~AhVP0r9MOmL3{6fH(|}GVv*~z%DgfKavi0x*J2v}lU@{h-ii!4%Vi}* zRe*aR72!1nN}WcWU~%is(BM)lM>DJM6rVnN!w1hLCwdz)2YLULVV}}w53I|o)uS|W zh~zc%c--+`MV(vg7E~gPr*_$f$5cd@^QYNMyXt5ahvd86s6r5<5rYgg<&e=P=M|q! zgMhIC-l>1VTcFK+XJyovV7iNGEq+H27H`A5ylR z9`;(L*n_=E;C)y*-nCrZFkr*3;wIVrt0l8B&orr1EUu9$6YB$t}7Xr$r2{l>_|>kTW3a(V>k6wq}z}?bubpW(pm zf6ONcx~z)@XB4Ingq)f4OeM1Y-l$2=Y{g*%XGnUji0S}V?E zreK*Hy?0_t6pLL`K+Ise3~^=O3g3VELal{?RxB0Fh_RSXN%X~vNKU4#bzSJ*M}m`D zc9=IJUM~xmW#Q2)XLD{$3AZ1dx%utvm~)DPW;$9qsBLmvSN7|TtyGO*F|ou1O~H)C zPs-6rKH*%$J8iW~&Ri~&myY7dHu;r%uL7QI4?Own6Z{*~gf>p~&0l}K@IUiLBx4$CZK#-3>8`^6pS@6`U@Zg%0d$P61mhT< zd+u3$67XCu7X`IikwvjAyEz)pC(~jy%2A$U{YmvMS>~s1d%rWkLOBlJ-tIcokfZI4 zRGTKY8GW#q9XHMNC-1XLlbSvQX@{8XL>oz z2qz_CaNaT@GqqGczdiIk4O^X0DK3**EPG-aAJhgfR%CQ#u^A6V}XhQTt|V z_|d3GAux#yyi-I{X#+ySo$fy`KKw+far&hg3e)U$@&`ZrG5_O#|L^#>fBq-@)33kd z@Bi^P{OZ^L!Y}{nSCnH@lv8hbi}>&h#laShQ~Vkn{89a5hRR z*+@0o&Va<)8d#fbsf|)A!$KmaNnoEsn||18B>>VPnz!|;L|u1Qs5|8xpvk87V$+T@ zU%V$LjiJtamXx{Q?@a3$#K~)LPE*dm>i~qf>r#={;6%c;=Jjrdw9_xqyZK3+DJcye zHqQQ3%9+IAIsOYjc$d*S@9jGZTwh+`vhezHWyz6g??J1b8I*NUj$JQM?_821<9qFt zy-F@`vHG=1<>-1Kro?)Au~@wF)NGu^EWH+vZDW+iSQ`0y;dNbkyFX~XNTPhbS~65n zS3|$EEDI?m)+Mv#$YRY+ZHl%`3BsJjq~v4f5I%tMKHJZ@lE%IMVSJ_1V!(?hVt>d;Kjp-$d7;Tr+okUGv9vuJJDWPn~*y* z6-+#2=zfe*T)mszxAqJQm20mVxGFqD{feSUW0cRpo9=wh!M1Od)>Qpvy!n_@QeDaC zB-xm!j7Yapu)xkS2iMC=>w}}J`>t%8R?eJpmXI8+-uu-0>xI^T@6+0*f~3R4oO{jm z@Hr~GaCDiDk{$GGjy&oEkAiEuSNhZEb|;0%HLu*33vNvHRGgAq`<~D9zSe_5Cxiedax0|qvdeCa+YJokUKfTGe zJeAie9`J0hvcS;kndXcHNA0>8;^-PNi}|57x*1gvlu9cQsv!fA|&f8KMFz`NFr~eIliWk1tnVJ|x9l&&loeg_n@{-o5E0EtR8m(T{1c zn2XCH7gunOsuY!2c&}uk^X2QKQF>DrpS|eANsC`C6}XLNwct|1IeRFj z|9|J~oez3w{aJ3>h;gz^=}%5fz&q#-D~yrw>%@lIlrXHL;@NY_mUFW`f2ODAWMXYk zKL|bPozd*#aFdS0UpzR{QdWMCmH#ilgG9_ zQ-a1&e&D*U${~n$uz62Pj@AnG2o|+Ah(5B$#AuCu+gU!o2yZH)IM+3)__Is4Jg0mf z4xV}xCW@6eDZP)0m}BCYJ0N#nN~bkbHrKbugKfVv3EW<8v;j3tLP)gMxUCDvfI1Ev zwI)lB1kJsqoVZ;tv|4fD3wtfBEwP@alBv@W->Jv0ktKL?g5jfuCR(_mw=@^b;^-zz zOqA{5mw)#U{QH0ZfAN=p@i%?F)C}8fv?Yo<@>oE{oNU`>zHVpZytmB5 zNb6R-86z*ZSJri9PDNv%QrUVO#3*selCu(biYA7DXQoK$jiVTE8-m3;1p@*lMODa% zB-X7}mb}{E(<~inzMDvP+fklH6aVm!zXJ47w%*MyYdbgZEUBhv|e<3Db zkz>?Eel&tp^6&ZA*L9_oo!8eF)4fDW-^I$LDDA=%^>8MhIw!~|ugP@JBA{9dF_=y~ zr9@8I!YM7Dsw;@F)y8^Vd3k;1)8{vn<_@#sI-?1_oow>?FTpc=;g%N|jjz9cvB?g19zWK=Tp8Hm1H7!*-YZSWJnuIgid)s}jbG>(t?anpAhnE|F`!~PjfBs+o zSN`&^|CXFzNcn;bi|WRP{N=4E+;ZC<_)8+B$e4qi0!LNnVDfq(nYtCd^LAtC^9V5# z&TKu9PJOBy-n)r&kukfCoNDxKy(%lgiCszdMe>8&`1Em?E*h!UPK+zxeEjM;TGl!k zy)tU!<>iH!53h_dxNn<;Pfk)&XVUC#-(`+T(P*=%TiSv#&OfGc?I8xdi?k-ekY1j_ zSsy=#D&TVt&%;BEhou^M(T+YPlk~PHW3u>#(ZNTouDm^`h^NSi_plcw_<9D)C2*}t zUDrru*v->OB?)*mDK5=HFiLF5o8fz>HOB~vWm&X_dC#QcfZKi6SBa22u|Y-UqmT%{erzK)~MHwx+Zd32+7-xEcah)df*4Dj%H3S zONJQnWAbQ|aXc8aSlDJTIxuSA&55r+zVgR^`g2}?{0-Y)xNnu059bX%X>EIs%e{9N z@9;@H{+Nmy3n>uiq?FF>a$yDTZ*OedW|C9+rqhyfI9jPVKb|-090MP911X+afLk-C zo>&CkNM~04If4i86~AH}9SBX;T<^bz4!&u>kER=$U}`&_6PHR> zqBJMQzn{Syr^-d9Kk2jq2)YjSeUHy_?YQl9DU6`#K zVS8*aloS+#C#@@Qk2}xzFRPy+rG?%Hi)l8z*R6fuH&*BIDY8EvI5(f~?dLCdwtXY7 zSGrSj(2_E@mmB-G>HBT%SwDXUnKKp6W2>-NuDt)XBcstT@Q{6PgFa_%w7j?d*R+X+p$Xw zV)=9q15Z3$e)N&Ae*P!?;un9;-~9cr`1JV`+i`HcUYK3o^VzGrfT`Of1+VdL4vx}+ zz_KjzR@>g2QnKb7Jru!5ja|mO%bYaKgYHe~)tNyBmQu61CvdZEJ72!M5tHQ2V+;!x zHJNTLLZ5plXA8wdh_p_7Sl9e~5fy2s3ai6j`ce)Vc$n6JbWUYD0LMHXYZmFJK4U+^ zoZ9P8rQRIx6OwnP{kH?DmV@3ZIg3&8KG@#to(D%Mg=@Z81(!l;^Cc^lx->&RrVb3# zqLeBhgm(((9Mk*=Zm0!oy|O>v)B;tCoQudW0YeCVPKt)>(2$k=bZ;uRPYGA8RNRyo zC8R`Yjo<$6d)Ab>TrM2@gVu_s#SkER${4)eA38u{pw$uY9 zbdbzm1}s%<#M4T@l7~QU-t8ybf34?^F+thqNJ+p7(F8eV@HNfC(~l!0>RpY z&y^x2F*C;@d@F|dTx+MX4Wm|;kO(oDFzDdS)i0%J{RorMrs?vVRej&hN}PncTbqz~ zjv%%zCC!k zUTJOUUGkCGI-#Cm;KF^|m1Ee90yaHFbn1+7L9uCLPU4c~7hkNmyjhY=2m$96^;PY( z-?lrC(pfGS=$)e;3?Et77e4f>3JbOe`@NFGD<7|`ZlRzbA}yI^UG*Y%Sx1@e=`{0B z{OmAaHi*KQHnPBcrtL)ESrYhmu+GAt{`?R4FaN7Q=l}VSf5TRG(Q-iR(<;8E1$21E zXk?cKPBxi{zW@HSM)Lp!FFEn;mHXR+x3|qg9=pAa($uGvX+z^xxAz6awS%a$G0glj zra9~MqJ@~Ag8p8c9dhf_PZUG>3 z4Dxc(L1sAtVADzK_?Tb@sX(U!GNXQJP&>|bd6M)X!KKF^hy5PfZBBg0fs-Y0T)++IFNf{tUj$UX-3ZGXnNUoICe%StJQ+jZ45(uX+@hvfCa z5~Q9P@_*D#2hq6)k!G>5P;KweLrA2mWu$A zQe`3v?xa@&$G+1qiFLW)%nddB<95><@f&0&-t^T{{esZcmK%xav_AwzC8#`T00a}>E?figx|M~ViwD65lW3F zx@O<;G2@))dbx-XZ`BfZ)6?nIhPA*tec0FQmFs1t*UH3I;{@ry1ge`XeJ(0BpO{B0;TM<)@da;Dx(TPN23dZrjd+2-bREt1wQvw(lWO)v&e%6ydoS3o2OMZN|*Nl^n^Jhk) zcJ$Ue#TXDVGv@(_s|Dyx z167@~Y(P)+-m`5R+rCq3VcQ<8msQ4)(VzP5X*+nH@Oj_pD6A6i8E)|9{+VyT|DGi# zKHgSda^}acue26<`*P?0w)3m+KJ%-8{+5^9m5^83cJSNZeb1N2PFg0HsVd_~pS&HF z*0uYbF<(wcI=ya;qd@J{Pv7$P%fI1A-~5#S=D+?o{D=SdulU`ULd>hUV1Uqg><^ac zSd(K(0T&a!75emKuQ75?_1NW{sa*)Wn{vD@Pa4dbm9^2UcIK3HP@FMhZ@n>FSD|Q7 zhh8xWvHm?8<(uu^-h0+%;kv9shEZ$I^tRjC_!oja8%JsEtuyfi7ihf_#*pQBqKNk{ zgOT?UBL;{eYQo_RbkQDMYvHJeR%}ajmfhJbu@>K+aw=LvRUlwYnGPI9v0>{XyL=s8Mk*IsFNxRJSK4u~?+<-8F>yRLtvTxocgdA~ zP(jQbOb&&@z@(%ZG8LfcMPM& zHINAk001BWNkl}8|(%JstsUS4i^qzb!#`J}A>Uit33FB(VM;Gh5HpLy&m zp3F;DJIm~Bt+H9VjGAFofj#DAO#vU36uZX3@BRN&z1fc?*LLRj+hfEzIaL)&k-C~7 z8IYxh?N>L@f4yP!gP{ilw&8BK)wg9y_mV8KhRi%eMC{2A--?se1&I4VvY2^J#NKOt z~nTj5~DG8+w-dmkAY_&14K#?HSzSJrd*bSW1 z1k}5&!A?bx(MMds05F~IZ9v~PJ%o0%t=APl8Yx6g97)P#d)RiYNxymSRlj=*95i0EZCe+x>f^sbQDFr+ALbb7B0nv|=^&hDJ& z`O6pOCNQl2Ycqh)gkh+@JjBRy76+emR10-gT)1=$mdG3x@R8G`wP%Pma!riIWw}zV zxOFiwH|NaP=T|Q0E8lavVr>=YqCVhUZ!*grsp?3QdRne*W#B@Rj^1{>c{;GH7tYs{vg9q3|EFI* zvRv*JzkNMJ41DwcJ;%EZ=OVRtmMZn(lxAtodndTa`Q^;Z+91u!fE!kVIG_`R$mhu8 z-9fFx=Mz8v{vXNr-|$!8f6ssY{g0e33vrq#y(+Y#R%%u9=A5D;lo&+sG*X)TF=mx0 z9A=4GdKIrPUzrL{msPdt1PlKNk;jJzYN@vNJv3-Y_$@DWWl%F&wKruty5N&Z|vrjT}Q9l zYP|;QdSzQ3DQGHc1`yX`sWU$40S?~c*qS;5V_++lG-a;WiVG4AU7t^sV)~Bg2q{yX zRFODvUAYm#CXCkiKviWp1{aA38Do?_)WJFOBppY!IQ89mh~Lu#loXv(q7)@p`Tan! z_2YOvGQ~hX95}Bl{h|aT-?a))IpgwRlwwSUB~MQoPauauO!{-D5J!z10)go;aoslBXwr6cVKw{8yKNPpGw&YX+l8TEmJx!!|EA{WhvPvpVzm-;q!e%w zQVwi2*rjF9P?a(=`p9N=WzsO_ZYp_5dq_rE^dUJt=1vY~!3W8O^At?FTyG3W?}MBt_Iyh3-x{HtsS36Bm_NkC zULi=fycie%`uvpueEZ=&(Fu%I!jc!w*kvl}RXAmr=Zmg z;JRM9Y=wL{aJV~y4+?7S@;|uR38n{FOQUv8e#?3#3`Y);bx}KT-BqMxK!Mknlk~X5 z-E=)uZp`yRQ`Ne$tQ+|t(^)L7f$NqMs|TUhT@9!othUZ{xMP|Fucr&ODdi*|j+SvY zh-v09A9Zqui5>&%W#!AunWe(~aA2NhTuhW@qiltol5W5;ST;Gyj%je$plyxf6uQXp zq*>;Z);4^1(XtYGqw6T+bJ#6nVJ2<1o#3qlw8Fdn!;LHqt7T zGslSQdpLyp3|t7>`Mnb--iGzXHKK2ZoP&!28cJCjI~``cHP-xMhN1oMI}zj(203FK z3<;O*Hryz>Ry%drcVj)_thXr6}SvTf?jbI@p12Gv2c$pJ5?LA8Ux`-nqnxm(e$ zPv0{Tl2Ml2j7rS{G_}tU0|dK)x%%^BwB5G7nb=a!w4zIC*huZYXIpd0XzXCqB)Tcw!k zthJ8R=R2*j=U@VeX1*?0PM0%tw62a#O~^S%(23LF!j>$2LZt`Tr84VN9>CFbdl7!%j)mAiLO^f6d{ z<;&L-19(2IH}GXNsq>;6Od+u~)o8~Mn7mUG@3vC=P>=^oz3p4U^-9||e0<>jH}AQB z_rSKjQr5y&HqNhCf-98EtAahI35P@`&Rdf0wh>(;dC5|}_r#DzsdZ6lrL3~0HZ|1j z#+Dc(clY_C?zFo#L9W-p^njFCR-O`$h1haD2m1atf)E10}Re(}bg*V@>M0#RcKH}~Mp zC5o)WwO8uU%GSN`8tKuMFHn)HF(BJ;wN)nBLA#pPBwAfnXv#AH@U_sqy9t$ct-#pv zik$|$CFul$7tRs9Zt7|*N-`HIriZ|uaqP44UKD2^jyYwfDKn+ad^p_v7H==44xyL= ztt&mrTam6*c6x^4&C}rwDD{018*HVsEUT23y-~(u^xQ5hcDN`2_;{E|hl!s*e&YG% zM41v3%5ZRFka7^_f&ylP@7B-gEK38EahS*t7;giS7DK1&$9-I@k;m zO(}7`7S31ktHFg^nPss`DQV3U-+Xw_>E*=fbfz|W*yrg$&NJ6#;q%uojM2HjyJMPX zrW85M2Wl%Um&Nk!2DJ~xU)QD@D_be{F}76e+4IR>T&v*rnj*@k$Tc6mP+cE+djC!e zz}9fxOf|eojiu+%PCRbyyTxuOZ(}R$X-m2f_ZlrM;#!wM&Y3`>8oFP4Q!P6ECIVVp z!?{Wsd!T1$Gix-%9NeujN@36SUsqLL#~4{pCt~nSK5(NdaJ#hP_A~8oW*=`;Yp_dV z&+3ymV}IGl&D$^~`S!CNnDpHgCCub79~6>eVJF*Wt;0AWlqO{AU6FBl^2&nrf!a2c zO(zJB;RNy)>o08Gv21$oN>};HU@tl~+pbl(mF3E1xsvC}V)ZuRJNNfY#{;D-Y;99i zrd=eDk29C^N^eDGtf6iP=b`n&by;i@lo_cOP0jJwFJIMOQU!F(IrDJ1Bd5uV89c46 zEGL~@F=j9-A;qZZt5z6B&rEmXz?;!o>XO&!QpSKi7$YUxRym!ols$knMu-!od*-kx z_BbZn>GVaEb-}sHhY$BWJlqRG4uKFeX-fQ%X8x!D@$YzE3cvruuhg>QT)Zg?Q&u+L zW!aeX#Qi*LyzC7%!l+o{Fl(hbznlfk_^40@9M?S;U<`6fvH+)G29?gXtv5Q$1y6KF zp&3;+WyOxw)@)~t96}<-#IjXs1&SPGz*}sZSDS21iMzWa)08-$uh0t&-2~MDt`M|R z0JlE8wpDwvjN)_d_M+^n!CsXQ;F8QZ%1bcQa0e_!r*+YMqM8yTbWvxvMtZLz4uzHU zTZxMDOmr2}4dl?}jq|%ygv&BZLLnWa2=pl1YV2YizZsMTq?X()TpY znd{}MiKY)liv@KwT(4Ip{p5T*SYt>65~D5-AJrn&n}F0lOr&H}B6iUT=nb@5*^DI^ z&QYo;)LqFGytl3cGZ?wSS}ND;nL{|x7gI1!QWz3F^Zh-kL{6t?L`V+{p$TkdrBP{D z1&Z#4u{+?~d&9QaTi|J|y-^V5l7i=9dLX2%2h#*Iy)}wu=A{t1npaS_*KLQOACs(Fb*?&mg6E8~Lu6 zg`a==h1b_tN@+^m#j`Gz!A9?ud7ijC9+!P5^`iMg{??@ zvlI2jq@%+Hd$=TdZB-BcA!n9tmCblPD~a}UvB7*$N@q1nGUlvFpcF&ac^iREnRweh z?M26dPfDD%*;r%{X7qL%yLTYA52#y*(5VfUtuUqOMjz*#Z49nAGgL~6QM-koctf=X zxTa((#vyjb+s}3rF4+UE{6qy?wBG4eYm1BOAB<7OqrLT8n2ef-E8A8GHo80eXT2L1 zAQEoTXd#L*(j`00C$gKs1V|1$2#14^EVgX9(n7px0G4%w;aNl3c}_x%3~!FfQW$+$ zW`N9Q^iEwjlJnfnGcI_ZN9Vk*d_JE@9u<}haKll$McrjFBU|5?V!mNQ((`nJvg%c2 z8?^F8oVSMCd*&pos)9M+0tL07d!kPq4~beObZBNqz(rhdynB34433q`vTOt=zkdvv zEY#y&(g(Hbz!*-#hKOvwt*-Rph{H2VVL4xLNe4;mg=MYW-_QKX_uujO?vcyO#_{ff zZCUYANkm6K@%^8CAWwnkuV<#iy*UD%#5fM6shA}=1=Vmnr`rTCO+?uW-bd1;*m89M ztT;E!AfslR9Fwa?>=x6q_oH|SPxsBxBZZWSU z=3XcRdK+vO4d=Y4Z0aiLV1Jf>8@Y$TK`G}nF_cnG_@o=Uq55{`z2yT~rhsW6R9tHA zL0f$ont1g4_*+NBK0(a$;Z2EX_oF~Hr726}pNS!H-A>Bg2i&wzEY@U%RiWQplGt}$ z>E7SgtQ}+7N+CvzgzHdxxj7=S_M^Q{{r+&o2X{L_hjYwx;&i_9uRs69{X7#L98$u2 zOiKYSd&*VOcYT=K&eW96qR~@|y#Mx*!(rx^Uw$D5rxQQVlelZ=NkM@DisTx24^vii z>FD*QUc0-SIA7%#e>hIeApjkpG9C$Vyc>iml5@a^#OvuyAC9HUk9~ifi8)G469ULpBm~<80U4U(DfkXdjLf`H*<|d?qIy+&)GI>O9n>6>cxyEeS|_fuZeo zKp4)`*@Hj#I*q-?%=+a_%KBRYPan$jpVCBKi@-f^C7j05OH|eAZot@aif(Df3NqPS ze)~|7h}?SI5|43>YQB^Z{_XGc2Gzac8XgJAoDDMrNI{9uF$T(}z>{dEu55n(R^C<= zu_KY3B%bNLQw{i2hJp?gkaIFdmD;S^W;gq6qNHJK$zW6klkVzPMV@yFb{JOD(wKb` z$lOFP#}xSb@ zrLNLT&yiL#=c}ZO&RZ{CRp6(_>cruA$CuMe_Auu_SsLrQ;GCF=_wS$h{)ca=UGdyr zGoJR?(J9*kVUV(9%3Im+=wM4xzJ}5D!08m1MU(w@86EsvI-f?ix)V{e^xZrl#)PoKZ?@z;<1 z&ENbbPwyZ3`sG!!U-z3Vd|ib%8t|>))4jbg_SWnnC{p1m58rox)3)Ez`-Z4FQEtjm zESnBt>_BDgf1Zu!`)BI*41DqAy>}}0%_DJ>U1qSq-$qxmZ2B16LB(68W_f?9oA*{DT|J%;+-oCCtpj@TQmRf1C}$Kfzjmeq6$?xyjVr@RX+b9!KR zI;M4`Ol-x(KI*c=dF8m+>ZLvHO_;MwcO59Q-Dv`QdiOx78$bT>BimMRt)n&^>t1kg z_GIU+stU`!>)k59u{0iUB@^Q|Im9^KoPE;gi^=G`*@i<1B=nvPi|0}@uUF&I*j<=1 zTrG@fgR9PBhj{MH@{7acBt-Pslr9AX}2r-D_hc4j*-#})wB-6I#hFp6Ry*ZiX~bo zN{Dv2RP$57wyu;`NG_{SU_SD@Kl=-wpD+CM@fYUl$RS4swr(2_Pmhez`TqOw`HR2$ z3%-RyG37+5hO*iRIozJMBEEA!X~%HZl{b(cOL3Gr zIZ9ci*oul#cFt3`!sYzJJS7e}GDVN0(W-zE9vR@buwLvfL;Q?vF=)c>0!q|L^~2{_&rG<(E(ATef^{8bx(e4)%(6LX+Iq060tF|HO3-;=%KI}%u+2_!0 zpLMre*ZDw96Uho*+7O-Sk(y2~zYdrXqb$usX+k@;kV1gHtkkGLj3%~|?KZ-9dy@3K zcboAy(glr7rj-k=MzugJo5DI2iDkmZVTtSaXB{>%@FwI>xpeCTwbq4 zz`i`~KFN7vo}@W9J@YP1i9vgGDV0%-!!C^yB#wwavR=WEyuNCE7Tt+XUd~22pRD zjlg4AAGB@kvA6Jz-8>`1jcq;-tLbvm-domzpevepB;p)SHCXT74v#?1n>_@yRA5g|!Kd z4_-IEEY3FJdIjPR+wGOdr&#sj%yWP~FNJ(4EgPe6dxPYqHE>R&|GxkCp`Uk}WGKP} zceQn5vYf?Q8PQ1&9|Bu#T$d|<_LqN61yT$=-XA$%FEHeZ$x{T^Z~vXIudkffjpx&u zm-8zjCmx=j@ILVR{LJa)%=Nqy%T@$@beR}pP7H4;vBoFYT3D`E1ri(%I2Yv5@&lJu z7Ksy$_5AX}vK5Z^oje_RczPr!b?lw57y4)%4+oa2Y<1@>nWt1PwGo47p5(eyO;^O% zO7a1StbPx&(AXV9kZm@ETf9|issPj2DVNlqnA@GwiFBI?XsTV=^n3lZ#^s1dViOrz z0x4JIsf79h8z2iYY9W%z$>_cp2M;O;kI*?VW|M^TS`IHS9;DMhs0{`>5Q zM`zrOKsz1)`{%Eha4!TE*opKRZV%oRUCU79eTrU^W31<~Y=oFlI}o=r6u@NIPLXh3 zpKDAB?{uR(Jcq+f@6FhNh!079gPXwi*0A;Uaf8yW$*usQEX$1YWz=d^mEwzKYV@HcEq~G?vnhm)APs2~-cG zZLFIkPL8E$-`oogl2gdy=%N`N+V{KWWg4Az-MC&C-aURG&j%jv?{EyZCf8Vq(O!OU zyR=a{P7{RGcHVAoN6r(6Nv%J_4S}F^{T%zvYLmpU{nCy7R+l=h8&a-{Z`)_vkpIBU zMA%Ky`#M^$ENRyAu$2NCpwO;4cc&q+G}FktJG-~H$)untD5u&8aZ~G@vaIKR?=}u zIM$j%UuXiwg2$x23WZ_l(2g$Ivxg1S^1KKC26(cs9s7qd3~BE=RD5sb6bM~`wa%&M z@iwYknC)mgZ7PG2T7DGy7+#L=Kk9sV!J=-2mmxa^I#!^?-W#f0;SxaRp3+-BYSyoP^QijJ{FlC6Im(weM_`^^9>G$s$NEb~o z@k|+vq3pA1zT@HHQMaKGA(KZse0M6fbe+*RdvFRl9i(tvHyly*OL=15t^)7uR&ea< zG>z^z9@@R#-qP;tg?0!vZ(aYk4^bnb9kOch)y*+_wU_tp!M*jnId2Dv(thtA-|_YI z%IoPx;A2jnEn)1g^ZTeQ)&>o9iSQ-@q@dyoZQX!>4n z7ECP|oYl75Sgzm@WjmU1ogI8vxbc1vbNkMEN4kRH==L|89RMK&O(xwm1x^uWy7}F| zIRy95&hl{W;ND}`)IMBknu0^1HVty6Y#dX(?eop{rrs*e2ONei3^Us_a}0K^)wLD{ zczWx2bOGPH#d{B9)F#ouyP?Rw^Sx4B7lh}Z{`p_HT(A0GhWa;LRPjzl@pq#(PTR)P zDr;HT+QPf}iHD~LnUkDTWPI@CLniv)^R%LldVxlsj#t%sh^FG|oL;XyeRxNl0wY)-ArS~S15vYET>I?XjV5KK zZnWXwaEN_+9&P{b2WzX=d+%s?w%R#e7OrctpLyIUQXl7=R>IlX-GNd&dnC1}Ny9{( zNqUV2u1%`YWc`4Bci?$12i}m1P(ia|p1Ps+()TyRkPL9ONvwD9-Q5nB6hygc3(?_F zyZ&s~?f16=+M_jQW8Me}RD++O-K6$fOF=8w8r3=6`Qu>LKdUGN4Por++)bH zKzq+x8|$XV>MzgFoURLXTNQNLE&APycD$?`Ti0q?OshZu?-HYVVw^eL-CKuYXLBo4 zOezQ6OBMY8J5S{$V!*RY=mbwtUW2>Dh3O!zH=TOUX001BWNkl!yTa;+VFVv3oVk1B^~t5RjhFsPMV9$X9_VuR)gQMXTT0`*+AanePu>&ox{=|_J2 z@fYs?@>`a=5w}k1fuDbQCB_5C`H|<-!cRYcBBlc=X8I_UZ6W$haMpaYEFA8R!~jzY zdii@LMLl4pY@9DDcU03a!pv_#qBdpi#-0!rI$Eo(HzCqZOymB|F1L4T7%Q+%;!&EnD1tu-am5svf+B7<5g}sSlKySE}ukWgu_Ff$h{J_aJg+J&2~3o4Oy4phIeYYQB$)?0QTywPyG3NkobC;J`} z`_^O>ya8}_pzc7Xw}Ukx`ZqJuU*U(@b(_2ZVP^^~yRR3Ck%)>M z7pCFpRRt!ye?kDVMQnLTb^~X>r*o$I18N7~0iS4f#hV*;46Sp$HHF1=1+6M;MX0o@ z)-vbIl{-|8UbmGTBgqAvO%1MhyggU7cOIYK^X|iYdMjMk3#Ze@aD_G++g5RA{EEqf zK5D7P$#N5qh(1cxb`?Dlqjv446K1KEwr9@$#IzP?hb+<$V!##EU0tOz{Dh_(=>)P&o3%eIy7(j12yh4h2AJz0^om8beJvatf z;7ad;QV=``lW$$W0 z-i=o&N#P&ewQs@-UEQFdIl58~0w#x*KyM2AO-D@#*XJ z%(AZR%{Jcez)vtBt<#4>E``*pXmZ%7*_yfRY#)~eyP0vrBDsTTvDSy}h;ofjQ2C@uNeoJaw1QYy!=WA1!q}_eaP9?Hm+AW zI)~f)68F>}J=zKYwSbIjibMeigdmX9*~{N;1=zC>-QJqshv5cqIR#@>Mu;S@+`^m{ zCy)MUJi?}09p)t7I|ubyDjU(6#z6A)*85FCsuGZnH$6gfZ!NmA9S?@3I^mH}Ek<^k zXR~;>>?RyyRrZh)Zj`Ihf0poEiel3|Vo`jMf1?al?Nxg|oR0>C=n#)yQZQKhC5);iFnjF3T&w{Q4`s zbsnDXEm0-VhU0Qwcs*aZE{h_uLom8TRM`0}x1EoP;Dlz5E`iayD!M90r?GSxfM%$4 z^Z}neJtUUlslCzqpd#)yxV>o7Gq4w_tI=g!RxXzdwRaA8_oVrrI3MsKish({URI_U z@dnUM$&);kvJg!#zh~ENt3^{gFCO0qTGgnwM>P#+FR2MS+R$JnDpAftH#A~zrD}ZM zQ-Qn6GxrCrngY)LbwO1+A#rqSR}|USHh%cspRl$ItyiWw^YrdXYl_46P{nEmL-_YR zJZJ0fVDGZm0Vu_w1)q%Hm|VPh3Wi4AQYzhfTpZSMuTYHOJ+<`P%`D3EEtCSU@t(aO z!066y>b?OqV+I1^)(4fwu)-N#P{FBXd8c08?dUPV4T0XI9dJJ3qJ&D$Zcatjb(4Dw z=~q$a&_Oaf7>%h7MH5o3!>IADpwuauQODzl8JD(A((+y0<1IdoVN&y*m*ti$T+LCb zhNnSDmX*1#wi_g&1;%C^Y45n`1)z*hZ8A}`0oS$SLgF~z zae6&-dO1-`Bcx1s3ge)w@1DAma2!)$w1P7i8NCw__#@h<(wnpb-aESU;MKre(L=DV zs_}|ZF1=mlC(pgiNn5QqmETsIvflizS>HALgP7jbemi8i?l+7Id^L?fzq7y{8U9eQwO^24j(8Jh@T^%?; z2}YJU6P(n3F(q(;R#jRVO~^F5{icQ^cpJ@wSDbdW*y`YSz*IZB_s;wWCa;ZACrHPB zeq{i~WBK}Y z4wG7+x=lOU(#+3bPSBV$p{u-f*VOo+ORcPyD6K4FO_XILIf21DZ5v~_r7$@Ik$uuc z;LLLDotNx*E0iV`XO6;54p{}c*Sawf(?OT}HHH8o5(<>B#x!(q}m z+!W`ml8Q-G;WXo4U#(F`+JG1Y<~=?9o--OD@uiaX~{t9d1WlO;uOg;156l%1^(1=5PM`FX=B|We@FGphY6)q|wgX#NjmN z)n?fR-Xl&onx0!-hTSTaB$SaTXjzrT--h=82ILS)c?LAfmS$C3CN9y0qVe?RrSEnN zvQty;_L3MxX!Pp-Xbhrp^Eqe26xqtg?|%0^(|?=z^5rYPe)^SdYozE^8&w8nX_6MB zz)olD#JXO|!Sn9@J6dgAuSS73MM}l^R$1O^v28&wX7bvjw^B(CdNj$ngBWzf`C#;0 zcQBfTnY>Li$~YL@s=*9I_0Hc6X$-jpQ_}A|I?~nKOQH3ws=e0-njh3nJprJEoL$A( z4O3~x@9(VE8;B?TLI;taAF{hKGa*PA)_TJm4UK&-T4(l`)?&<@Eba{D5$yj{^ON~A z>@f8y7-gsf0M})Wj`nhU&sLS>oI}KQr6qT#XUKl}`=ntPmXf|O_6kQRLJt8ZnamqL!R!?JVBt!d}?f#3#r z$9rBbX8|LVL>t%ZqOj50H8~88Uv=nA3_b#hIVEx%Tw4XVH>+sG>n`%~^DDpqm!J3# z|KZ4YKirf5%fILWaE>%5<<)J)9! zmqrzuTzRKlqYq^7h(R{l3GDAC{Vsi&hDINSBU zI!?r#cnAmDXncMCN?8|*(1y&av=3iQ2} zTLGdfs95!a53IyNBc2Z?Tv}JQVz;Gtx4m}kia^Irwkmg?JOR!|)SaGFSDn>aIqkM% zC`QT$SWJR^y)43qYjBuYXlF3&&+|Qs0^Dz3=dD&P;=F)5Dd@({I3w!N z#8w7u^)8vNNAzs48<62}W6(plLqd5EstC97-(0S}zhNO`n7L}8f4|9Tnp0x8>NNhQ?mEKRHe@2 zz5SW!yYeO*_a1zVB&VOPtt-I|rs&y1Bl^L+?;d#i@B|_8_4TTl@!EJko#_nX!|}+& z-I2pQo7cPQ#B7QXl7COxWUUWgEP^UelhjzwD-nl4nr2F^Y<0zXl{=oV7cT2Y%2{cs zwGvZc%E`bbHMO{*zz+c?maWzcWw|Osx+~Cdcp@jgqT<^3nN&pwbKI;yhhB@pL_NzMiPPux_hv45t^Mn>glh%)I~b$iu@Ouclj<$f=8$N8Wday@;j& z?bR@f!L8WSyFE*=5Mp54ssXg-$FRv#2>aWbvm1Iq>)lSZMQ=3V&|<(oNg19JP5d(~ zy(yaOaqNmiQ`0pXt`9p9bZ9x8@s0XUE|-f8J0_%YXgAI|sw!>U2n^E05pNDcH@XfS zhGmoL|M%~Gw;8Le&zTKb(~cV|4LSF-Qj)rWN!p+nQy>}+Fcf9;DDHEM% zDTQA9t?RGV%CcOU4>My_To@eY%)1Zwy!+;X(mgMi1s5DCPpn(vbX|#04-YppL$g!X zIe$YgujeacII8pZ5J**bm}k-rMK*b8ZM>W=93LJaM#|Q>Y!@!uMs`*q9#v#1L>J;b zvH4-43XW--fW%TA(N*ogDBEt}a4DMON?{(f!GHSw|3`6wWm$PyL{&u>SX$%D`9klF z*AV#T@t(&ylVf7UNNJ7B)@bca8iVLM7<%9PV3o|zsDk0qbQKm1$8IJnCPR~>VT$% zu?K)SGgQ?Zw&NTY1*hjaP1z1EB|-Q47TDsjK$TW>n0TNW@HQ~e7&`^1X*>^u2WGnL&h?;P5u&#wtHd0PE8-BO7MLwK?1fdF$IbRpnQiwU> zYrjo5IConk`{>MvBaOzVFP}Nwzb8+b(G?HoLy$2kcy+&P>expe!vi{^zS^J%A)?2_ z0mmT4%rIX-sg*L+8`s9bhs@X0h09hsFBPm!IM_}#7{(E+&dLpw;ZDljZ{4%KUU5Sy z#g|gKt}AV5tX4tfV9tT=1OM{z6My{l6(0hZMTH2d4z@m6JNmht$1j@%L5E0-6Sc2w zU8M={4p}@pPTF=HYZvOgFDBEJ?c{&kN7u4Zx&?@M?XarC=Juj!igiZ$=`R6M+~^^R zN($aWLG~Vdsm!!Ph7=6UllA!J`IS$fK2d7t!#5wuQ{uX*Yc533DBVU~jqN#Q?(Prd z966m%eE$5I<+@m!kk*~8HcAt1*%1h;G1kiz)1Va{j3ES;>!PYK+u^62Y1Ki1DJ5#% z2r1A#H*u81atb=66wILYhC#HZh&Jyu2?q97{fo-24vS@EeEOdd*L; zw-KqVGqUvyb?gqrLCOj51aj6=)a>LOb54pf+dUf2amY%O&LL7pr(E{z!(bDtq`EG8 z)pm~#$WwF6e(c72cu$^Yc70Pb%%*jtG=t$qrW09jMah_9VN|CKvYE3J|;5f{g>K)Am z1MfD0I$^?xjEjj8l3qk7CEm7d6dVOu+YnV^R9ck~kwN6rWdFQ>$atjWx>Nx}t8~A( zK2$DgcF=X(xLi-P(FrLLl6(wmI4XAIn{3s4oY83Nh2KRkCI>dUYz%HGMBW8z7q1-l z962g)uv%I@bD;s`vy$B&$t+(;r_PZVqM`8$E zmts_^)R6kD1i&VHMq{wNgw}Cx5L{pchwrkd@AYzFL{wiHZuC2F6D`Rz0e5!~Tu!gl zJ~-STXst5M2U;7{ZL^ROL;72h!_k>OpbxfnBZh2hPG>lPm6tkh`j|c1%m>T7*o{BF z5}bl#b~|zM7TnTR%Db1qwju3GFnXG?r%e}}pY@%DzzBgd3YkD@T1~F&;K!doak*^5 zXH5R=d>{r(rm0A>+Pmm0HP3o=mN~~fO%h5Bsk_!vIA5-~7^yzsVrHH)ah}x_gQL1Z zH{pV6#+7DUfbKjgPK2S|H&|lN`E;gquf2CPlH~)m;MvT2>RhMPRm!;5%qX(qL!#m- zqvN|*{dSjr-T6Qn@cHG!b*W?@jB4^E2mk!(EAJlfNg=WZRvE%7#twja$%7ABW}#M9s@Z8)BHFpG z3*8kye*6U-+&|p&>z6P5^66Km?3w3@z7DR}jrF?7!kcDF6PjFFWNRyTcSr6Y9{Kw9 z%CeLj{a7uw9d-_1H}dXy3^CE2QftAosh98Y!R9_07X-c#K(L-&HWm{Rcm3+t?=LzQmFXxqCUVdb4 zjhE|%HXI=zG;vtTiT94^hV~`U__mc|<6UA|H(p-PQOq8lsB2z>q#V4SBIs3JL}3j&faTZI5Bj z1TUk8LOG&&48X-iurIzjjgis3=VLhL`G^mJ*Vik(7M|WcP^05?I&o=(`*|XVfX@d~ zFn}s&O)5i%oe%oCUsGeQ&R4O8y%9S&EOn$vv8Er**4LXc|NE)N>NhOE|zCMSUcDQzuVXQ z&C77UF3j_hyZbwEofI<5^lXa7yomzRhT+DG5mu$UXk01 z09yd~;fFuvoA2K9|NP_s&5u9*%zSs`!*?IZIh*=W4}46C?|%4RH{^N6N9q38W#NxM z|B>ajP?n)E3v+(0^6N?^^cOptee_j=HYWEOcl?Q;H9g*ftO3OlyOf^Nla> z-l=K02(|AGoR;aAz%Ho0;D(x=Z zL~Y<%){U4ZoO7&eWwgR;xpJ74M+lMPJAuUIx~huJoW9;gdiO;6hGpnkHzCc*tN63F&NR;q9LrXT(NXBQ*4SDn zOq1>3o~2gRhmS$2a?uf!Nqi+KUdzT>3+u8G^OcaZ6nG{j-UbBY&XqJH8EtKqbt{%j zA4oAW&zataMy~-rC!!Nq+G^3x9wOy@!82&3GUWqh+gPgn*mVqEFB?8OnvanK+Kui8;^%ao?pN4@bJL<_wRUkcwlRrY{bijDIYmsE^JF-sg-x{?)mTkhri{= zpMK)YfBlv7rLnC~j5@fS7uIWK3I}#jQVu$`__(g0*|W=dEr`SUn0KK@oawGLX!qN{Nn;!N!of@3WeDljD?vice>so%49>b7!!H{p{6KUj9v-ix5h zIoq>k+UvFQ+wiTv% z!VS+>mG$1b5>6VjP|}sa6Q&7=b;aA5rEW6$x0_S{d|5Y+(~M7vG926MGh5lX)WUdq z;gBXUA z5n_JZse`E|?J%Hsm8lMWR>LVuyNyO`n~kM`VO7zku55MVk3ap$beEV86Yu*JKWjL*0dA@w2jg@zIA2?12KEJ-OTsw@Q;!*>a>Y^ZuT{z>Mas@y)a5KfC zw@J|ZL|Hdglry+qR;Yv2nr<4Wmv?kEEOoSwNmmjWT`5NbXPZ_fZ~7BwdXP4RD+G^2 zuEg3p!NaI(@$pd|es%41nt^A|B)pDjx9?@G^wBA6Ap}iB+ZfdA!sOMt(43y->*++R zo2@~@0p{tz>-F_bAK`_EIrbFoXd$QqI-P0xeb+PPXV3L|;Z&~pn4k{M z=YX>^;2p+s12~7AGv@h# z`=<0)SFU%|oOHYoaB)CL8)&AWLcKAlsu^~OGhz*;s1#1vt)pz8#$kjHRN|@8e5(Ug z8kv3|`wd3Hg$P_oa0n=QMgj0J(Sdgik*qNN!jKdMcbslISZz>BbtZ zK|J{oZ86^gu}nH4A7HZ?m>*|$-wmXbe){wYzy8f%;N`0q_<#QXC+v1x{MBFn3Plxf z-u?t}z*o;aUc9=-_F}~K^&X{sg|Du!@o;~KoA)09b?CA1RU0YOwUS@qSWP zbN%%Z2!qX%q5B-jTNK@9gSo4-DP8Rj}QRnC2PTTy6q@C=MDT&Y7#mk~5+dbd5!86(M+x zn*dod4Gs?{oN__fj2L%2_!Izbm^Bj^q`Nu1kLJD6R+GrVR8!MTq+6U|v0#jxXDY-T zla2*~Y09g~2Wka^!;~AG&{9llca068{8ZQ7vkNAT7Ou;>t#q~Z8G|+1N#Ki}uey#b zS5(t_t5ZCG^&E$X1Ku5O5aWOpBF^&+m_7FM=g)Eb%{QysET2y}9S+zGBVImxfs5T1 z%d{Ybfafn>pw@y3YXlB7s3tMg4E!K>L zL(@{O?wWzF^HSDM!h0b@4+`%aoKyHnla)3R{9V2DTvtI-TQ6#$p{=ROx-%KJ0^LY8 z4GvNP=WOk2;uuwKXQpYfbseCnn3e_GaRV0|agwrNE@zyN2PCi93=tQbgww+jn{kKS z8k+N1mKhfgR;VhLnSgi&w@uCpMo$+?Dba#l=%&@c-wW{K7*fKfHI(~%w0VYWvI4ED zis(ngVTURWKiz(WKRGOU!Nci{PoHif;_>|Xb8Ig!Aw$6Z%`HBBxWU7L=>H~-NYNoz zQm=#a#xZON+si#-jCA-pok_ScQ;N>pE=?FTKj&i@y>=4nO)%@U$#5NQ*jW(FyY+YR!0B01%BGy{tWAESY86H0A} zk%+x_4q6&XMkX$eApoTyH$W^Kuoy>uEpiaHoec)vdDQ06lz`u?isT%|5a0qo)LMG@ zrx9BCCD3XCGdo#CyZS8G!nWVOFSGar5FBVN9If&KmhAKrhkIb1LdJBW~g zv&<3WW<*{x?(c4KJU$?Wfb+u%4~HYBbAjpy%z45%CTzDOo<4hqJPYn`Cy1JRPN~c{ zFzInH?M8|WrJy*94_VXh^G}{b-&6Ns%bW|UCkOs9j*LbeOhn@65fZ%(H*r7=5!0N> zvoJwTiV499>O9e{${2_}yFl=WxYIvD)*XFU#pTSXaC#0ho3aV8xW?cx#sJqygKkYR*98yf2{4CjC(1uJEy(I1F+s!=1FH1F2;O5HM}!b@KAmtp z9-(NcT2LL}$B0v25JJR$++y$%yZsj0=o^q*#csdF{(6tw!ySHle}jkf1J4eLCTJz2 zez?Kme6-Kc;p)j1Hroq)`g{wuZIV|I(-VbiL2Cv6fBEfqzpqU(O|uyWR;$<%;sR~2 z3fmtSB2#)RdHJ2C)=I;W5`Wmu7Oh#^2t{5p&hrEhz^SZ;m?4c27ffOqQ5yN&q7ge- z$=9`=5C{t)AcTlc7jB&{TutmF0(c=8qBgULqN^)}#v3q-c+aQR#(zKOOcY%erA#(T zHT>zPHz>8CHU7-U(*d78eLzTpZ@>KpxfL7_2Z#ukdBM%Qk2oGC+!XXx_OLg4~WH^3=mzoIparuoEk5Up~y zRC@6R>75$)W6=jx6-)gg55fD0aoixq5itxaL8JS=d2yB}AOJFI1I9FP=F66Rt31rZ zxWOdc<9iV-#h70)QUT|@S$UCOETy7KLlB1)x*M%IzBUDlVpN0+N3l*W1yeR%K#CZK zXxfHuVQneAj@0E`8(a(!rAbA1vRM^&&S9EPXpXINhy!ZTM_)ay<_H|1T5(=xw7g(9 zj@Vu7vE2dFG&7+oM5tENT^PRO`nt7QSHQGnQGG1XwW4T4nF}8h5p&+P#AY9{*=&(~ zk5gmOtzfo9E(P0RLnfpE5d^iCM5H=%*VL)p@QNAXxTvG)QDW6U= z@?vd&2pA*V@mvbJ^RA=i4FHZXK1Ex+0n2&9QVRqgDGV5s1&r7YSHTCeDh*Se8xS1X zXT@ZhrDkMPijBiSB8XLe;vhU=oGe&C_>U}_6bEsq>?Oc8hrBF6D;URs{eF*MeESWG zDn5Mrh)CrjTwOfDix*$xPk(ra6fbaf@f1J5 z{Tc5+-{6~HJi`y)|AM@Ja34QS6I*ZTPQc7&>^cOrzQ#10YoSqW5N{S+%FogU8W*?) znx=^>(`CjmCi+P@2iVw=i(<|h^F)9A>-`1BVZ@vn^vVk)L2I$gLm(!V_TDj=!$8BT zfO>NN)d@!LG0zKc_R{Q?=^Dt%+=gOgA(DQY2<6722fF^Ma{x1?U=uXe@*z`V=JwrokbF5k0NBE%x(6p_LT-YQSN)tuJ}Oa>|Hf zGS33V-~tYJ5A=9Yfpe7F?=LrSj>fbtH=Irf%u_`zKwcEb!e*3_w=@3=Rk@x`d=vo`oY<4*7uj*dkd;?nDfHqmKc#n zdi{G7Fziymv#V?D#}Uy)5`#HX}3KEar*6g<{{6sB5R9_M4sz zzq-CZF(%I7;2J8I2{BRM|NO-Z9FHgb^yUUYWtwrVxVwG8yqt0U)fKLvTw_@>4i5*s zfA;}@_~&3uXM2KGhFE@xrP~ZB2sYP zWWO1$7MLXn6^D&}4aLr|h_{izoOx6*jw1<4tr{^c1MtXsL0K|_Qy>?VdB)%a%93$^ zI9f;Au-%LpQbHO>WCf-M+?^-Pr84CyXL=`EN9Y2bf7C7lF+$NYFYL0GY*yeDM3ush ziR#<}1X~??x&zf_SsIS(aF}@S`sxzi0mBfn-)*tq?=ejT(47Q$M~QJv0hjwNw%Y+I z0{*}L%KyI9!u6HyfBV{Cx7{KJu1p>t9*`HdU%~elvYBSP**w;1qwL|kV5GPH({u(z z_~DrXZ9X4S^9&C%|Gv7|VH*Ox1xpmII4v1dCi$pYy-_3BXzd^y%#iaja0DPy9V4-e z6|uI1uC1b#f)oRsSBztV0}n|L_|VoEcW&aIJ`0y(GqER8M-6M}1|QuexV29GHBG)Z zdvDX%J44L-9NjI%Ys=W~Mr^hlTwPybx8LHAfBGjpJXDM+01afS%@ZzmTfBVn9G~w# zW11Jd|M>&*k~xCSXH3%xAt=82`URd`U*q$KJG_7M0W~*-z}Mc{gS|uX&hZ9=tgB19 z`SM_Uv+!!Im@AL2vSFHO*sNW2HN$9)QS1#gm~|l_rGbf0&dfGod4J}80DW`}TILz^ zbmsAL&H`8{&Z-K-0Mz8n#mG%%y#yKr=Xt`iEY^iAEX=hr69Nj`-o}(YPHZ)C9H5cyFgjQ+t+08_! zyugKsiiXoN;WSS;oo7?A;e^w+T<4?9pn*&p*Dy-KPhHV5l{W6JR4iM^U>MAhYY$K2Lf=^ui@V zKS3DvR-8jE3a{MB2Oo)uSAI4*6BO+<=~`)qp{?3`-pmb}Ovzy!$PY0diMKAUnyF}~ z4|C_=i$^bF=I$E;SFvV*BI2>xZAi_vP0?mZ*l$N{Q^XJ=6QUgT4#5GNAz~aDpBF-e z`hcmLpTBh}$wgdjb{Gb3qF`qwqyPktuCVhUhCg|8h60!v9OA%&N35xN28ypT6u3z`LM zc7x6sm{!wDMJpNGA>sMe6%qig1!GExL&Dwhh`ZAfOC!y=C$>^^%}2F=;ILKO+7f^S z9C7RKG$8~v?mQ&yNPIU$0cYPBBJ&HxG~1R30NeM6l#s>&&UwoKSA&q$U^f_V-xVgCnT*KAX4o|MBcD#9ihx0Kb`T@>Iz>F!OX2G>0B?M}F zQBXA7il_l_b@k9w1KMgfG7-oR@h$?*2v5y&6RUaM+It&JnF+;uq4Z!7h1!VsXz<~@ zC*^fB8t7LHz@))Pv2>ySHQ)qGwhfnarm+w#%YtUBI%yUAO~QV+!w{0m(F>OOgo`m^ zJDAAJSyqA%P#f#eNHzA-oPBfbVDIFCqjXF;mV`bVo}osK0*kHp7{e> z3ed=m8e+gEcnn5mtgQke;4sfP%nO=#t1^l$ARqFM3-o<{N3orEtG_!zA68#z&(LEA zzz_p+T`&%b^igG(!PSx(Ii_R}Nnha!a>+b+rVA(?fV8!bf_re@swAy6b0h}nJtrW) zyBIjt(};|5wb^az*4;kAO3O#+lxb%{BBtZ$+ZX3K!$KW` z8)zk08UidI0nR!_svzk@NGySjYO%uCrO1w-wRLvR#7WxSl@z2G_mNZCO_Wx-{QLKez=Dou(jI{PTpFzXV8OP~FI&pAz(Nq(P(M7AwGsYp| zx4-!fw!?sYnlOd|P91JP-QjeYFwc~Ncjx27;fR~}pK*74kI;cX5kprU)l8I!_I8kB zi{7dzts~$=!p5}E^f_yQceZEj>pHGGBr7(<#txM+x@u!UL7kv2qh^8nh*}oFd3bEG z8Adoc5FL+$*=*6Tz=?-6aGhr64c%hPTTzI%c3Cnr)Hql2Lt!UFw_$+ecWa6esD%h3 zq~|&ZK|v`CiZB}OxPEepZ@>Ny_jmXB>BpaN ze}6zRKKpjNgGj)epWfl-<|FDtl^IE2e2w;jL#+$yPCw1`_i0Fsc(<&;{^PrTE}9bM z2c2u)u<-<-%E!I+z#w{8a`Y{MK8gPQ;JY%i}RUA72VK>7MQIYFH zA&)pJXH$R|+LVz_4T`&BFn3!rFX1BR^{NK!#tn|s8SmbHK<{f;xV(tCJkO|8 z2GW4s6w@+W{jfEN&^AdcTRVtau%=%h?BFbu5I~R4YONt_wr+;I=-%Nt5d#5ry|ssN zK(NDFN}+|9aO~kepSyL*8PyJ0(~36JJT!&C)!=%wT8d8$EBB(5g6+ixnleY;HNp8@ zaese;1jVOMcevPH;_~tm+x-^HGGjVTc(~8_=}&L*`sHf?ihue~Z*Vx?A!mY#5BDcH z=W+LN!m?BZmq=YUPdNnzJl^~Vn=&D&lUiz}IY-Ia(wzc=r>{V*mCi^mlBW=p1#LRC zR?)2RIweNnZCrx^!73eBVZjVOpb43p%Tf@6gQ%<>nd`FKN~LJc#qfjEw>q*O8KweAkrfQ2 zGeJhR;j`IjBF;f;#-dawN~3d=11-LrQ+OW{Lt>Xx3JE>IBSVn@TyJ)$Q^CW>dt8hg zG)c%)MxCpP>pUddd4@w6B8DL$#xsJmO6;9q(`8m~bpzBoNNC8A?Y2#Q23_Yi=Nv+c zI2-3$ti6me!8wQ1iI(ESW<)Iu1P!O-0qCI(nH4`oR>>FwHZfom2Rxh$^U}~~e^NuW z83RoKc&4k0SVE7|@IswKiZlULc=WH*D$O>60Y1hUK(%?%c>{7REOPJ>=Vd}(sL8Ii zVo1qac?zRcfTGsYdZXGl1xy^{Z49Z!n2SO*oVSQr5-@l4B7HUIk>`qs+cSRrlTb~Lt+GEJ0W9FB9l_tZf&BbEu6IMh4+ zW)@!_vPQ*8W8|0*orfZ~w5j=__fzf@(;VeqI+#%9BHb;}KNnK8x>ODi{peXL1iz z*aM7C7T`g0bpHkD?9&r?dxw*|?YJStingk;M5q}EmPhApy+`&OSAb$)b8R=Ro#ed9 zwWDZ5Z4684nE+MWN_vT&?;ADTjjlEd26d=;^Oc6OC_dcW;&eLVtEXS#>GLND3HbTl z1AhJ2Kj3eE_cwU^<_$i4_<+0=ym;{vDJ6XR^wE3*gWXUWV$o4f9~pohy9qv^Z%<;h zjL2o-%FmfMe+=flYu@|Lvt2h=V;@L;W-fvlc}(bZ>tNAo*|Y$Ud)>zV9mC+650NK$ zhgAm7mft$hn4or>`$&@xZPnhpLQvHQB%cUAqalq0rkUFpr$F)^V~Frt;R(va2e$9Q ztn9Hagt4x^(fJ`tdVCDFVOl>oUOuh0l_=&MGZjNme=3E=wRO8P`cy2ILbcm&$wDo? zr4P_blN(Xse4fafwE)-iG$BO~rwz#qUOjt?moH!9$yZNto(tZ8xW)Z}LApU3b>@$v zmwsEC3Jh2oVa}v}P&m|FF{FX*udO19 z>r|*#1e;^?lFhIaHr{oyQ(3nr^l9iIoP%oRwnm6;EOSQDY#e&tbfva+twrNc?au_~ zeiH!&&)91?i$@C_1%QGWgla`As{OU7bmA3r8%P7E;?y}ZJ3}DADGh*Q`VW>qUp-q7MxELL>%qwDlktchso*5_L5QExAlRkwni`~IIr1diHv z`C`@;Cl=z$3!wWYz&Ya!P`M`Ev{cB7?5a(u7!bQ~acBfCCjxPXlQhc*Fffn}gC#aO zf__~updx6Z7$P@WrI5SeZPh%+h_Xz$*lutU=|oKFw;JHNP;?yVGvOUI6f4;1f@x(O znik}FL92o71H?pEy1uszETsU>`+#LxR+}|0RXjBm`Ggp$uGRipO2IN&r=W`HX~Gg> z#Ih88`~44i_ToAI<3Ij?I2{gf>aZEMaE@6Ir~6yHz4?s09{>O#07*naR6-8A$W(~awN zo*xBE$rxS2QkV)8LqyFByf}=BGRmIz11lQveq|G)RckbQ#vE5b$v#B3iQPDa3bC#S z(5CDJT7fjnO0ZFayo-X1{RN&reT8|R@b>M`fG&V*7)E9}e){kUU%!5d@4x>ZKmGIu z$I}5<*B5y8>MI-%Cn(g!F@{o_<^bx^idbjY)|!a|a`GHqe_ExH1q3Fxs%TPeg$6jE5Y3$! z!j7qAwLfctvr5W(@E)!yQgEovVHZ8NLqG~(2uW*f!%IdA0pmE*)3B0D;*5c)))jc; zO|Xk9_E@+Mml4#ob#z~Oin14?KEgW2Mkg#08q@$ZXHgNHmjy8mxZGXP;Py0e&0Fcm z7={f#e15=j%E(1gmBgW86A(5VoX!&-&J$b+_~Dn|V~i0$zxfHFmcq>OeslGfR48WY z;26~6uS85#!&IN(lI?Iwg^ej9MoKWf05K)THY<=~Kr4+|bgEc2WM&AdczmOlQmA%v z4ol5AEd|rE04|cl>~tk;IAsf|Xy(4d7O&L`iF~NIXE(irD9IVl!6lDqw9S^=Dqt!G zTn;H2U%XRb*^P+sdk$veNw`6P;EA3qlaJI2hInEKoO2CXFNHUiGeSw@ej)~sh6>Ge z!Ep|F{flofYzE|(@&4Th4C8=OD*o_?KjXvA4c@+egTMZpzr=34L5!Y}RFct<@$u6K z9FMb+XCmiu=f`@vD;r_lM>?12LzSJmVR}q(MR>wx=*)XGwcHE1J$dScMetf zkOX0(DFOPvSEmtVsTtK=Q2R{hKm@!hbLny}P=qN;V zB}TFb#mFTw+JSR+<0;@GTgkv~M;w2iVlm$x^y~*!T;E?S(Aah+@8Fc84z{J{^KU+b zwc3m-G{fwFwpo|tg#7u>P!<1HC&03IHWI313- z{d|XC|N1ZS{deEv<;xfN;~)NnaTBrKJx87u(>z(_>YsPV82FHd=m5_^Fu!O!Z6F-1 zsP~P4HgeF{`Q1iCfZLr`)M((mAjH(1FuwzSpI|Gy{-O0=v(NQ>UqbwniO3ht5z#ar z#<3TeAAuRgmYRt(sl&1qXyNZ^ts%OG=mi2r%?)vR zXP-s0eZLPL-ax_D>Uz_oDN;)24n(9f1p+_bJ1n^&q<#Z%hO13b&G{8o?Sti^PbSr! z=NYH-iM|Apw8~nTUFUs3@&XBwyYfZ=rK9n#A53%h3gEn~(ABnU1=|dmYM_XQ%OCDW zrN3rd+ZA*1?Jh)s+V5$`KxEJ(eJIt8NSNBfWL+})oZYkv?%iu;V(hx21Z-#S*A5GY z_~zX3{@r_oA!6KY@$}gNJM%9yADQQGo_|0JGnpS&nm)AN?#LuM2d5RkaXOwL?G|O4aXcR3;o*Yk+S@Z(OO+~K)QZ#T1Qp^X zhr@v(t}em*fWvvhvYc@$1py+DXr+NF_!6~rOjoU4-z?n)#u;s~w{Nze2e8Zwyypm^ zu-4fQwF|rjmL(eE35U=5k(VWzL5WIOPU?*;7r zpiGu4GzANS3g~4wGsi8a0g8$bA3kF)1>gPf9iBdW3WegJ_wd1Es`TLhr~mXXIG<0L z=7M>i;k?IYvq5VC&O79?(9Bf&fidZH;q2ONqyY0OwB-&*10F_>1V*N^GvmD{hrp6~ z`L%f9^U`gpP2^;TAbifcsH@rfm9x4^7p8TPwln5nrX&?rxyN^KD_?>0GgG5OAU7lk z%|oISf?mntVl!YnCX6AVEwpj3%VRuR?}WYcy!|bsPoccwt78yJt5EMSn$)}t-?S7Y z=Me4ndDjD88>G^xCK~(Dvt`9HO^D3u1Du18$wW>Sglz$-71Dq)Mg$kEi8Eb-6&h`T zX0A8+UXgwbP|#LO!Kcq3@o;>=!{PoB1e7m;jqZ%o#Vq}xTS+&Ry^Dt&oKoqhU^Et0 zT14|hBEl@j93+KyL0%U47|b4=tT*Rq8$ND!Xc90lW!+BDFoFfa`|!ATR(=rPbpnc^ z{&@5bpc>Hjt*+llEF`t@=glRr6~3=0t5)=SSfPL^3mbH$HH(2xjzR(`7$dD}|7;{h zY6U8#)h<5DK&5-|n}3}ZQU#f7P9mBD$KwHahcmXj-3p{$?04AjFLCqk1|M%8@c!lw zwHAE${dd^yE+Ed~)9q&*A2Q~7S#Ny0`&Kv~5e&iRnvS<%7gG08p)&<*<%&;?R!y{@ zou3E{#Oe`P>EG9g8;%SyG@%hskQ<-Ts#@5U9@}+ctmGwgc9$$*P7tlILboP|09J(wNXQU$8T1RuPy`vabrnbOi^$*h%# zH5w=9PD}QI+_fgGin`WsLJ5?K3wDLW_dH(^M?SQMROYHX>>@IegrV~DV zJfhTsztOo~$)=KX{q2Gau;SGlIh`5#WGDI_hwUwsx0af_fElWo8 z>@2lZL~+=pM3Wgj{?$1(5N1Gh{GvZ+DMogfRq0$j�wf97b|qT4S!C6Nm&dHkDin z@6BLFiE#uGGEkdEyMaL}KA6!-0JfLUaIxPT1^|JYp1Ssm+q;4<(9ZRy61z#7ajsiK z$qRyvj3KH3RIxG7^=icdg)6(@BhcuAnwJHYN zM|ayOzSA_zpp6~vqjJe4!}u?5-Abnx1*|9$p>M6)>C+BwqdU)nBQgA!9gyv_MFs!r zFI~Tk-6$+bDOe}d=N7{ca$QX5LT*KF^ulw7B75f$qsRGthDgKf*Dvw)H!pDW;XTgN z86h@Y?nmsl143|k`t%82fAcjy+JP#u&|X z7T)H0bG7M(+4$`oby#rwnW38!-=FBcIr+fOkALhw8=%Vbl&w?fj>R1J2v!E~;qA{m zf)kbm#hJX#3u?|729NDHAUH;Iz}#% z0t}uap;D+Z@QG`?C1>8cV9VcHMOpX|1|u3d!!rbcc!4zA7>L-mLf1Od*I{->EO^o? z`M)Xvz0T|7ExF#7_LYpftoo=$=xs9aSYX8oLgL(*3sw#V%~!2(wTk2Mh}+v+{N-PL zk9Y41fQlC{uW`NK;9|dpb3o1uUcPvaU;Xks+~3YP9nVOEx0M^Mu3D{l^mXhmONLVP zTVIW)W9YaOZ&<*JW>`V%7l#4GU#wm`#=&upAfI+Rx#wr%nu9i30WeiEIhh@4g-3K{ zcz$WoR%?MYPmoP0H;)e3B#%uZIn06Y<6s_$&Ql4wEDIV0i+L9Uq%C_}*_Kj}%`wS2 zcDe+9JzUEeeLxD{KycVX0I1$} zd!^K}q1jx-BG!64D9&=|XdhW}<_F;%L>oNe6>vwUbc${L3glRdPPi_xHf6)6a z@g+D$3NLr<-fn>&6wwUiYTZ59_kP1}OiK<{XJjDdO{v z3CxQkBO*eiAvxgUdXMe6HDV9LJ-j%CaYLb3Z4mKj;-KQmEdZ5@HFuL-!+JzlJ1>Q@ zgEe?Nc!%vUAo{?OvJ~3hD=!!Hj!LMrabWaWzcVOoBfXj$6hK>{KuwzwnR@1hGvCRE ztQFfGqtVZ&lM$|1D4Bws0ncy|#{?1NT=Dap8|;o}>@LsH<`E3;!3v|>8{BQ7zZ?O+ z!~)n#n+&!#Y{rcd8hX3Yy6qP4T#W(?NuS8Wz1LXcG*fup96 z?-o7rbbW9;BdoRV2;24Po!4*Q+c`iQ=>ANU*4g)6GTYwfNT>FmbYd3+Q0<{pLCwJB z#U9JN;Njs8=i`ha4oG9dX*%O@_kff(@Sb$${eFw<>nnWs!!J-;!H++_LoGl`0o}Tc z^kAB#x@aO5>tM7t-dZ;I^QLijR!Hay-t*yBwIENoc5mwjXWbY*u0ypn>prZI2J1$< zeRs*${jf&!7KOFVx^@wo7eGCd_tL zp)B3bYpEO`otd}f+>jg7grPt*%5p8dF#1^~(^TLkVLoS^&Y$q^<`#eW(_5|q#XuX_ z!R`bH*V|dEPHRkbvxmvEosBVJ7)Ru3rm{<`S%77VURnk4DA;g5&_qL6JeEA8he>*4 zenDunG&h=cRI^hGfq;_02umf?YFRsVnI3a}#&+WDYqE_F1MRo%d51Kv`j$%HLlRj8 z)%MS&*2gqkYx6tE*mu=%HV0d)F0QwnrjV>QBYSx~%=Wc9Imx@gbY%~F{R|#eo7c6` zcB@u${I4!A@%-5{{Q1v+z}@W~o;-PiKBI zPXq&7Z{dZcDs6UX)Eu0w^{&O*>`UcV1b?2x$LR4Y&% zrJ+XedxVWCSYvc18LAsW=wq$}Gdym|j&%#eA9( zcykJBu}b6_*nzI7>t7JC412b3tGK}!VBL=`mx>rXmU%%_>gj!Cz(Id;6+DCrtVWG7 zMv^%itCfPNIx5w3P6b*j;CX9N)~S3z_#{ECtuBsp7Npq;&- z3m9ABYHOq0+dJg^68rrH&Zh}4UOdC$e8%nF327Md-S@x3$D2?1-~Rpog}d8Zym;{x zpFZB>;eG;?pel9aKsSC7^HS)a(<9rjd(jh6f)&(WEIB9JZErVyv)%}{SL!1HU?eDE z7tv}%Ope?MdmkaTg;A3bD~nU~o^79p)jfpvv8=-A|4;r(5QN=bc0*E@K zkPy0?ZO-|N8JE=>w!>AU(`qZ|)2efT)5f?YRZK>oWw9UA-2XUwL!oD(o!-%6eANku*&uh z$6FXF*KBGanbig(%k*$X`2r*)kkwt`)tF22B-kf?)`F z^7InVUVer5?{Dzan|E*$5Sxb<7B#JWFmG?~aXcOI-7mjGMZ^2gH+b>lHD3QhF`Z}p z`OiP%=eO_h=O1q{pN|lDe7L#A{lf!k%*M-TR=Tk|!0|HzGZ(W9+^8K8X~Yju;(PsPR*Kud;Gx-so{8w|l? zlLorsT6fBp*~TX8x=N`K!#G0lnCFJzfXm&+6pke3h+$$*tmv$xuMy&uuE#M%cIGW-xRM31@@h*WM` zQK8a^x0tBTN6+!dyb#u53ttpM$doL29aPiU&dn} zj%S1rh*(zcHnn!rO*L7nqrk(_e516?ncvoNq7_4OK=fD+XSVu+m4K6TW)_|EXu>zs zdxtO#SQ&lRv1liBSekFM-8_eWD(6^N^N^3@jq<-hq2KHNOT;dF;j9}j4S+=CR-3Z~7O zD#lk&U*P%j3jgpA{|J?Y=m&^6{QW=tJ?=l>!#g@2KinTN%_jg2PI?%qNmi{BTUs&S z02`594{B}J!Ei;{w-^BD_?{#!07$;%&DY(IgQ3zKFWcjJ^K4Tqh=i8f;MC4uQXJ}{ifNuvmIWFk;;=!d(er_CJlp>9HLPQh-74ODq?k|wpBc)Z`Ha!E z7t9;vO(#A3jIAbKxEo>OB1t zom=D7b8BX*xz-wLcD3)-tVmT$0rt*e90r1O zg4LS*bYx&=ijf;1!+^R)dWaFV6r7Gn2n=vDFtB$#*^-jgDrA4pWF?nj9pPvQ0;ELC zw44h)075YH(?@VQ1a7hBWd@)a#u4K=u62+x|T39szq)1ZaP?`}}Vz5LPn{|2tF(%xak!RmSj32GQ zO8SsKe~Uu_Ll~x9P*e$msagmJJ*C7zGFexyEI=Kw1RPf?<_Aw;uG)(8al7FI)ri$v z>|Q`Bx{bF`tmBLuppV)D0bsN=#+I8^nClM!Y-^ylrgR3z*a7J(%bW|2#}i7KkW$3O zevhxeeu0Z^!nlc8=8W_Cgq#8A8=gIXf`*FI`2;}l;llxc{?i@2RQ#L&>hBOF;9vgv zEv9Kg(}L|T;fG&-hjF{b;c&8|z;P(XfRrM-W}!BAP(DO6Q)L_Y$OeV+2P(vqUfqko z!W?{*EiE@2u)|34Ood=tGU>e_sbxqBq75-Pgy5jHzzKExNgM{}v5g6v6fwp~l)o0s zDSUijtBs?8nsk}1{4kE#45K+&>-zuQ_HGzQJM*-Iiy<)u$ovON&d}P{)U05eif&OR zLbDX-{o}dz-bSa#&Z&d!9VKFMYO5h^Gx61uXI`v=6;$*_igS(+cU8q)3UX_V5o>k{ z32Tn zuMv9;l5>9598_Dm^|_h^5rwz_#vlon)-Ywh;FyTuS97Ut1~&CdL9s$>PeJtogBPRwT)paF`-c{K9Q|$Y3<=e?Y>@?IU!@anz9((SQa@>hk z&Uw>1u#JWQw|Ad0q<|m3e~rKT^{=3)`26V;9_|}L1k&JeUQWn$!R6&8Hk*j!v7pv7 z{`-IT-{I-?GyLQK`$wG42S5~0o?hZFe)CIQU0>twaKOXi0Un(Rzef>G=X2nHL(x3c7*5Vgd}+XJe6^6|gMGMZ;84bY2#RZ;x^$agxzCu&Q?cD=P17aEw zRI!>mQrTvQ+`vJafqL6xHj6Y;I_0)TwNzteSqf#DZavhUJqY_SOn785TeZ-hx!XQ< z?YOh{S)2gPbmppvA+F;@>#q-AXcnOGo*yW+*4_>TDadfTGWnd5F|@$;vpfX-HLK%B zL>fCG*C_N^v3;R44w2rTYHPn&`pT=B#TW@rumixwe?z5F9lx#ug#cnwP*zP+I@oJp}fj*B0Ep%eJEuXJ%XRLee^6y|$^VUi)Q&yxMk#TLPOST7_X@uU^iglxWa!|EY2QEcCA#)v{=cMBjstwn_&RINTjHT-$Iaf+K2#4z<{bq}E z`jVTb$*74K!>Xf~2VmLb<i5Q}MneE5&XGidD9Vcti&q%>BLBZ`B>unT6 z5zK6n@d}6Ryk_Uize;|ds>dC*{OA4{Wx9?_a;6mJ`k!`mo`>_uk|CZ|-MMLZg z&!0VG+i&>KzkWfj5PIlwR1&3DLhM%HUvdN8c?Z??LEM`4EWb8TfPysIuuNitV_~SY zGGmO#(eTdF$H1=ZG{)P|Qaa0Uo$Tb+E)r{%89Tq2`6#gBEQ?#vSOZ0-Hg60yt8IFD zMv$rWIGhBWt3{Y5WwX%3Kj*C4kHs${Oi{{0EeEr(2xeuTj9t``@^h6Wpt*G-r7jve z;u_3p#x+ZtGN*B5X~9}7$QAg>had94{a^nlkH<$o`||I+e)E=xyL)cl-0=PD@3_0U z6a1}IzWCxxKKtwo43@{o1Jf|kFihi!Z&k)LYeb<}vw%hG4y`-iazMygZC45D^4CP; zEjw>gcc0v}%PpyrktX7YW|q+#LE1}}5KU__&VXB(gMwi$B6VDX zOBN7O21wn-tzXr6Sg-hmMqfvVZC<6mW__@&>c6Q{$gl*6$dS(aWiBR|+T%rHNK@pRijJ!Ju0>mrtMR6WER@&a^SzE^mBd62II1ZRx zNivVhEZIbRu~QMt>h&vpp?@+WYIA%lYqY8as$@7-i}U@@}lXxP4}7A9k=ZL zPBh3>`D8&t&#J>zBqU@hf)F-90w6_uUa^SCLADb?or8vLR4dZZoFtdcdrt`Ra#`zC zbWzsdXQg46oy7HT8jC0}n%U8U3@gd)Q{R1~QCz_SQjDF{s#)&Bg zybbL7p1zMfd;Wyq{OeEo^*?<;$%!9cf6F+`+`PNz_U0gJvMKTK@W5`j<;l}asTt2B zSSYQKN@COZbej#+JYX~+)oO4>E&@bJct^t02~8Rs#Yn(uZkB4~yGZjy@Q#);IVbwy z*w}~%B8F{<#GuNyCjN=0x2W*ya_1~~izp98x^0_$FD?X9$uf!9v&JQ*L>D4m-!W^j z?IQ9ShCwR7j3L#moeWLJam>1(FGU^8`fIC~f6f{@A5;U-)^$KMuyO#1-b$$CJkRU1 zXchAk35l{P#?bFC=;y?grH?SxnN$lt1`fv~fBeHAq^8X|qV<>tFR!k#!SQ%J@Nhcd zoTK0LIO`avNtChPlUv4FgZtm#+x^ZWH~5l8zc{?4hhBg9204|L<}g_5dPrC?*%(P} zv8oFf7oM1UmdGZfkyiqe{U{K@opa!E?|`0aoBpLzQ9ilJV(D^WdpGyV&uh-*DOYL@VJk!6_ZRjP82*6xD1PD~D_;nR%MzrnP9dpNkN}$ zAH@7tk@zrU7dFah^|xi1CYp1&*zs^Y(5z>gXQo*qzxsYd@S-O$O_aCJI&w-3!$704 z-S635>~Svex9F`#<4tlDF5b!?YU0h|3 zDT$~;gdI+7i&^TnngU6JfG@!!X0_aUBV%Qy;=QFekhQ8bJt506=*T4J+|Lx!Z8_%wvF-#|NmFn`Y z>jjg>^rOxW7XZ=9rt$w#u%PG-?H2Gv{pGh9&lb1 znZDC*2xGavenuBJ9FH@CsY&JcM4}X@&x#}pb)9Fo+0)sM+@M-3Yg&_7ttrjaI^(@e zirc=U-$tJHTY4V|){ti@BB@E}$#dnqEEypP3ckF6Rju7C2dvbxsZv*FH7{Z{U0Jan z&-1)Wc3W$VO+*Z8DaIP@4J!3Vj0 zO(UmD&Pi&TyXjS`GMk+EZPCcf)KXi;JAL7+ zGZ%b95Du-TwZZ``9#W5yy4Y*FF8Dp+}xbFzngH@P|D2lI5AC@7caN`%Wpp6`udvB zKL4E8ufM13BE9eF;)Zb;dH3d)c~|KDj<;`bIX#}Z*lwZuvrDiU;q`qabe*W>swK^d zc@~?>@;#6f(HSl_o<2IRwp+H&vkx6)!GLO&Xt>rSLfc>n-m5|Byn+g8&{p%(3SJwd ziBF;%urY$JNn_4*i;qNKq!^=4SWRzkX^^rFXofCy^if)Q&y=lUu}O+)sOqHCYWR=34Ax}zO!(0lfDK3@;JWo}alZc^=^SVav_j|Uxy{zaZGp3o4I$pebj{U|n z98a_$Q*&jc(ip}O7Xl9tk|HdzWri;HuV&^!f!E^;=mTVa_`(#cYZ*pvDoi zK8SL_2v5G?7)?h$DS80hIh@3MyRIfEuCSOzLWtbn-tqW&r{kUH_WlNIq}pk}-_vy) zsD}UekH1pNM2wygxBTnB{!eUnPx;}8w|xEeJF1!Z`6pNGFM1Bc0qzaQVWMK#UtVy1 zeGN2j-rZ7C= z>KZf8@_gx~<(y+4M!a(bClqH^F_HCNYs3<^7J~CqR>DGa3pH)^Mjxk1Q+`C~H0$2K zzqr5$OUd%=3ENQF^%pFZ)9rv4;2h5{M#9ZZ4FoUg*1|)I)Gyy3gt|Ei}n$tA@~Z zSmfj$=7G7)0&W;X%1R?zBW9jd#HOf|1b~knrRFu1!8B1i87FnqV%`xo*v1-;)68j} zX-y))%bX}p^8bx~A${D4cu9du@1?s?a=f#4-Op4S{jP^9b!EYMmVUe1GR9e=@0jOF z4l!ql!6TY^+1FQ#u!2)Yfib6Rh1DB9rNzl5Y0R}GDe>SRgIH>ns;NdLXUG1cr|ULc z>}AJ}UEulEHNX7jCrrc4U;gqJ{_-DRv)LMc`m^`xg6I0>H7`E+fUm#)n&bFi@m=QU zAAdmKZ5U1?$J5B;VZc~H?#FQ;gvj&fFNki#+c&qA0^98c2B)L9upOl?G_EM$jFZ)B zoMw!-Ow%BjMs4_3xCk3I(Xs12jw-o*If)ujU)mUh9G1HKSA>FFCoZMrmNm=hP2SY} zf?g8M$^lYpW*p?_*zb1qQ4aX5z7W~L?LVxH#u&EStsEG}Qd5>`#JN?=l4`*sx|HDk zislu2hq8rm^okxpnoc5sLfVIO%2GLAD;`h3-HHxiku9#;{{>-1bn^yO zzN)*i-m=XuD7OYTsvyQWkq9f;FABjT62!S==A`mb>+vzJIs2wqS}XbitBlea#S$DP zW%4|cn~c}XKD_{F2FV+obA~2Os`DgSdqERlB!RSQD5pJd4jo| z_s7MlRoYo?wq)xIYp9b;7H@;onkq1OYl&WM&!q@mSW!owWu8RB8at`2_FjIb<;4p= z(wgD%@sVxqIrS6w_m5mXy(WZ?-L@n4j@`u*T5bIB<}D4!^>STHmvNgaork(s<&@ZL zxAgr6>pkN*%0;C4{$1CRQesTAvPRl(VUU-!wDZL3EVc?|R)rFh{0T*OYhA)VHL46T zK&LEq-(8HvAi%P#ReKYJCXXS=vulJQsOnFVOIEx#UQIY{10!)@DHo>GAW_dijBafYvR3xLIcLV>kq`pWd5n<| z5Rmb6ac&#k8CywED}CQ%y`!W_$Uoh?siIpCPNtlc#ffKKq>nw(XL6R^&bom262$3( zS71(PFwtmBRk$(25icN+bB^f4I^9qtnH3{?d)J))eTL#KB`2{?hk$e9CY;6@V+6Hs zHF0zWo{JC| zPDk$V-tpOIx7^=}>^PTuuCL#5b+KpDb&RK()8WABFko6F^ik+F9lL!WaK58iEiuvb z+@+3fI-S@AOCKGVmlDdEQj)giDmR-CNZ_Zwa2~P6T5G^LiBngh&pb^l&`JXdz*tH? zmn0o|@w~No7fC5e28FUI);j4X3}Kb~Zu}XnwbtUJWCGSEBDaOcO|>wb2Buu_U55`| z!cC2arusm`FwG-#7Em{(k*L0fW!%OzTFI*&SF&vixi+nZlZ&KOsfjZhtW!$CN6VBa zPN$Rb_e8dvjp71@-Dbm_3rR2RaTZK`O9J9ykAeyIcJO$<3h?})eXT*r=U64 zDH-obDX*NZ2y4(pA!#|OB4!{4PZt7R--}MvG!-KuCutC#lvXv14(;_5O37)|a?Y8q z@76L&Yn|4kOG)L@Z{VDQQ_3z_XR%(3RT^?QsB2L6Qojm+XyP4MWPwt)q764$3M#s; zLx9#yaFX#By_h_nU0?Idk3W{m@|5`YyVn>Dzx?PUuAe>?^G>t)(DCgz-|_hupY!(3 zTaL%0um-VXyR}?B4XU2ZSf@cQ8WebIm3bQ1iD6kgyV$Kbi*r&wYcXuPUYvH57;nZwl!2vGDN{9;5TbjTR zqYHAYx7NsWl7q?^#%UlGDHPprx9oR2Lhxs$q7Un{?A_uht=b?hO2H+ONrXfTuqTI8 zL)5l?-%F-J2$WhmjRQ+en8i?1qW7N5{g&V*f*(Bycl#ZE*E5_3(wxK%*fjr6S1gQi z)Mls%NRhQ+wP*%_jR6xp)jN)J;y5OZ3slt(1Sfjx*mWG|k=!H>Y$*W6TIO20xj#}H zgcxMHK>W%A@|D%6Z;fTsZ}C1bspq-tqN?zkj##2ZE3IhgLD2@{ta*JBL$%vpU@GJ( z(f1oED#c>0C%7Pon;u-wN)Dc+(fYH*6?1k^B8L)23_q&o5J5>Pawu8>rBa^t<`>E^ z=b335WbRVIkP8-xqt5EmbEH|Om>2_3E-$#ecp`1hox^pW(=c&74P0Gb@h|`K8?LXf znA60UUwp|Q{_sb>`|b^Ww~?lsRM_rz{N!gp<)=UUDZ6b?*IS-HyXN`x7v$Xd>Z|W~ zd>C;)u-ol0!7(LCe6H4MYLb9tc8OPO71t`e&hf#EYcZMRN=>5LGX-hnwL!fR5UdyG z#z+fOv2ytc;3`qvMx=bw%v&q5i-h3ikXISLX$^`{y?qR9cU#$)ja>y>HaI3-r}_}- zywm!y%$ySY{hpd-?F+satjN06NmrVH-xkYw5+|kifl`_V#$;*}yRkRt+``mE2!wN_ zoET06#u~gg(j3$bc}kR7KxXR%u#Q1;9iF{EQW=uTKC`sq3;MGGUm+v@x<-@ zf&0e;rAkG2^q$l4ktNr>wgyd3yNcXO%?A$S#Njy6_ZzmG4)0inC`*pKw@xd%d#te{ zXROPj0$q0&b%?eflClJ1Iue!N!plz6Bz^a#kaE@=TEZI}{0K;D3ec7HLtNZm%M`SH zRv6abQ;J92ij^$JBVfI;WW5r-yQKIowP#IOhqj#7+Ja*QugE2HJe@cmj~pHk+&|n? zjg+d~+}`o#het|E7#fde}17ne`Ce|X^8vul3)+keAY$AA9qE8e_&2c{5gFr{hL3|w4X$e!*U&IiVMmWw7QtZ4)%vUFSJ zFcUFbW*BFTv240t)S^bF42!t@Lg>zbb(7?zah`cNp5!7)vk0ubTRs1a0jk!jmqcT` z>G4)<(wDnE7|S?K4CBC*W*SD;V<#Z1mj|@2(pW)T!D$J+fN?>9EN4lj@Hma!KOPz8 z#9RUEcpOeR3)lM#;-;tbo;i(}X7R?6jNCqR$&A2hYB<+njmH{sg+awsFe=4G%{+_Q zs8zAux7wKJjB^33IMVELdyLYF7krfc4z1%_z{H?HmOf}P>fe_qO+(h~1LIe9m~mPX zTC&tNo3kpAR^`x9ryNGD$;eo|N~4v79>%Kc6^Hv1KfHN^bB$N;J;!*<-QAH|;Bvp`co_Kh+wYjB1G{Zc znJd$jkmRXI$(HZGf6L9gTfTpDgK0s8E(;ShPXuQr-rX%R){>sn`G~g$YYH_L5-?4P zE(E-h5xq2Vy$OZfgeB3$pVGwMU33(;))0bI$uAh40!{ErLnocML?2+R+@{`2nP*DU z@)Vr7NAr|n|TguY`gnP55% znmOBw4Xi0w7DIA{Jj)srLZr;IPLdH9I&EbV_GV5A@4O?YyzU(G@@b~M23t_&hp#y+ z=L*}+hRyB*oadAaH+Q$(JUrsPW8Vj=F|=ybV+}Y%u9hJ;9%p$;FRw1ycuzC4^6Cqp z?w5-|_~w$aR*EjA31$h8JlB93#WDJ>2Ux`&tu<|VF?fCX7sX>Kl|Bd;%px*zo)BeB zU3v^_O7gIIui+D{vQT3zA;|ApN@Y?7Sr;SL2y>9t5xC$X!FyuYu~d)ODw%DwrVq)K z;ju=>wt~b{mr~howoFONS9iM$obz1lFY&*OynFMO-Ngl6zh#;;Z*OjSdvnXhdTCqMZKzy9Q7o?TyYe|KOweoxnR+}+;s?YG|&yA4mDUUPVy(6A(0tJ<7Y>Ab~O zEt72q5A3!*n=UX8M@p8}%HdW$Lsgb3M7QD|=ta}8|6rOD4M12u6f)w==d`#kYi-~x z!S{4g;^kY(8Y(N%aQY>QoV`@~&{3_R^2_1fnqe9yuqd5rsYUuGcH14>(zD%f`EEl_;ZH(+UTdH;Z{kzvZ9*%T=BNtW`$Es8t$sajq<|I<* zW}B|KTdeo^62xb)?df-0ZeG8U_o5`c_w<{7EuG0Krn1Jc-R(iwwb~lPIDs+rn+>t+ zX_F`rJs6?u#4xWbY+HpvwTbN4*&u2^yQJb88jflmPxc+dbmG`D*}|Mfw!7)J%P~6B4@^NkaOIKYH)EDwgsT_b}f!z9q*U5>Fg@QTB#sYZh0wn*mk`n zC*{moCoLb5FKyO(?FOr?It0NZ5-`tM{q^#DS?{s6a(Q{d_0=^#z|$v}Z2F$ydmbJR zeDmEK<}{KEeDJ}C+}}U&{5pBJ{5G+fLE$pxDiPv|y#zJK?Y)+$}! zktXp@I3p5yne-I&wpK({UM{j!v#=u}NGFC5@^jBZU3MW-Yr$5Th&vzf{f1#2z)0HC zFyG3>Vb#DX*IGeWsqNg{Vn^8$o2I# z^OSh~`VIH@M=qc26w`40_P76qPyhBezI}beI8AJ~18?8maDVpz&2YKD;OW&9`b{AA za@*b9+>la|)eNCn=i`A*FEnP~MXYg(O$eCjOjucuph)}T$CpX2u9%7(tgxVX));)1 z24)vJsV-ONpH(n$ar31jA~F%MS;Yd4P8+g*(Tduwq3=7GX2BVoBh9mh-)aIA(mEu$ z2D9cM!f84w^(#~HG|BrBLtv}o965Z98hk2OPoMFdfBuAze)>KoCI0y5|Kx`^Z_tp$NC^UTJ3y!YJQ z9oV@oqtS?Bqc4!Jk|InI4yj%LQ6_^fjkT{t`_wG==f>O8hC**s{AtR z3vKjETnsBl#ej=l)o2wts!^A8Svm2sMtufVC8Jf!EcCpwHqiBv&8}mZNAB((Bw4vZ zt`kq6ZrJZ$;9UeJrg>(w?TMYlp%2qUjFG2TPx;MnJ|WFBd7gOk49I^SGoW!Q<|8^NxAkVV-jUvJYKP!uIt4QqW`)w3-7;1zIo&}t#WYGT&M~r zI;ZZrBIS`&n&|un?=7L*aXO7m^Q;+{nQL=8U57J`o40Sc zzrSUgj{N+i_ql(Zxw|`3iY2hz;RZ7Me9g9UKR!H`rfTMY{F1z9J+#YIcJtk!3E7< z(vg3hchGc4mJ>sB671PavF!BdJ}+jKb1n3bvj7a@qo}Q_rb1S&%cqyT+`VA`?k%@> zcWgI%uAg1fY9i;#S6_X@+qX9y4hOn^!v{~^6X#cwj=BAAM;ARY7`m&y#72Gp1Fv5{ zFq~$B7o5d8gYyw<#gv#F5%#ct7IOG%-o6MY2tJ6W1JUSbbGoc8pV^w#qb*G{jN*^5sjOTg58QlN+^5S<+ z-FmuxtE)|rc;}@$0An5D~p z8ShJxhhr)ASYpL%ZCb)1|NlN{q?c?yER8WDo7RQapd+Ye)9LiFL~rYYvp(F*TA|M( zL6dc*yH2RAVIIL1Uc9{KpMUdfzWeTLhUrAtMXE-m(=6M~j(`4_f8w8h{cC8Ao0}Vq zvAp;GdrZ^F;qbt2+q2vEs}JGv@sY#h5isiU7fZL(B&1+17k$sJi*(jVKmD=-=?at6 zysG@73aes}PKah87hzJQT3dcy=baR68Y_JS%1IkzM1&Qj%~^t6ASzyiQoE%VrF-kD z78GvX(?uE2=UJW!6tRfbEmHA*W?(*ds& zQ0z#qSs5@{0k<0g7T4}gnpmBkYBHS1$Bq~~(b&wgDg__tyN%N65Uf=rkgN;_aR1AT z{qHb8GFT`jVU!zHnbqoaTe$8i7mm}+kTL~J+-^BdGq(@-H0wwjEaCgeet(Izp4<%g zj|Z_m8hCoK<>_{VZ%rCqQ~^a*o2L<8cYQfE%4s?6YSr+HoP|?$ZdF(<>bj+o<{v7U z^}}^4&ahUZvZ}^{*9E24si&zpqUg_fzPZerf`pE92Ia3ge_kwm@4{UxzqPCnA_}al zs?b?UopD}d(Xn?te|g2rSId$z&j4cOLbwNTe~-?Pe7 z+JUVg@=fHdsYt+ODwTOoDxJ3U{f4gZMYyG7>mofzgZFvovBL3mV$KPiS)Yp~p&1O;1#+#NrWxlwvD=DeyO~u%D7Jdj2cb|l7G z#4pRP+fX%IPV2tA_M_#(;qifEN<0pufHAFN6!5XlaDSRKoFO3P1>)1+MlbnqxnT(_ zBHEg?=PqY*=d??9|*Di?t|HtUjP?G^El0tXc=z(o_UxEUgLpURzz+ zj)%i7FJ4~p)z@F}?KcB8LyV1KNO)(tf4Gz1v$2Xjj)wz%AG8%IvD>O{eHgjCc*fP$ zQ+{}TBU6{E*!G*AO&_r}lgCknRr>NcAJ?g=YWAb`9a0TuG_WJB)Mn0EYQ*f)9waMc zsbZ0`>csQvmaDDes)UCcBj&DBi)0MuC2Urx-KDX}dM%_;(HceDZ}e6*RlZxNI)P^7 zFus3yq#4WQ)fH6B;q<7YAaT7KC*N@?m6Qv2_YaKY%znSaxxn?aXOvQyh7)O?uoT|j zKJxc(-theSOP+uDF<*T39sl*;f6v$7zSe_7){->Hgt6#KLhzD8Z5lO6YZRc)Soxf~ zu2VIi5uhGJ*F{dlz?dY1(FR9W(~(EI7qNyIdS;c^I2U9!&l&gI>&@>{E=(zjiw>hB zN~2VHnK5D&&N(UgQ`eo!I!D)UZcaEx@Y6)BQf{0hN=KQ^>6?=xd|>quyL6 zp{4j@LHO7GUycOrCNQcdTs#MgC+JkNun1;33Y76M8dBmESE#kpZ8|QWUJ`=k{_&27 zM=AMq&fr|5?<~)rT>_Pxn-OCx*Vj*1Ijs+#=g+Ts^5gtBDuZoB94LHYuR zVdVDa9*d<90Z$`1=)A$Uf@v~#x^;3|ZX9_ABQl1Vi*SIG_NVW{bs{u-x|wyyJZ*#xon+E zs%v4l*{xZbk~9_dpOp(Q*GeuGpGv`CF>1spNPxu>kmxkHLS7DNtw56U)nmM(w5SYqz(N*2$>8gf7%pSI*zrMVul$tg*uH zwo=JeeqPr+PAcVB;n0#1zpMdLOda&cjAY;Yvq z|0g?RN>gsFY5J?k+~z<(i=yw_^4VfRlzu|}P-ZG98 zIVGN4?AY{?T4t^;cD(=c6=|4w{nfYBIb&=9b?9Lvs%;5b)ng5>XuQx(MKT5z1Cdr~ z=weV8okXWu%@@d}G7O`zH_oh8Uq-=3uORL`PZ%R&Evuh*)v_1omRu%Xw2Xj*Xn~0U zx3U_RBCJC6GM!0gpCN{hl(U$Ae#G3MW4f`15Dm6ir7hdqe&nnt6?tuQu8eacEDm;25`1H7b-b1`6aVUiK!3z5rdV;eIp@2k%8vnFITN z!>)@MBT6i&Jn21Y8W>U~k4+PQAvMcbM9kB2qE!*UI33yS0!SLG4J=l_;w3OrRaB)= zDmt1k5n@eIX9e%7rD=n)lv%p9J;vw@?VMjDr0SAlq(eanL05{bW8|_fsCJ?@&2~pp zj1-G#%JY_5|9UpMUmuUcUE&=g*&EsJwae zhKGj-tTCiHGfpFYza!_uI21Ph1utHF$j?9e70<4(nCFQ<|M62E?;n81)zt+*|HaSP zZaPvKxPE%cuHW$H>mMZO1L;3(>nDHKM69vrZK((o0htb4Xy%7ZT1{9ELtQDy7(01^ zG-b$lPRdJ>cBD0}SIaV&z2E3(XOQ%pl8yEO3a-*}7WPU_WzHB{t`t+`fL}s9t&uo! z^()MC`Vlr`H1{Eqa?@uf$W-F2_Fd=%)PQQpV`j<|ONW$q@*)am;RxPRgU6YMp!-}xIWXnK zQWIqnYi}(AD3&C-gQnT_kXs)3w(RLT616J%2S#7~rs0pvXJeI4T)Wt-mP}yQwQ1=t zT#{eJ*;UA`(#UML9dk0|c?Q6Dj{WYE+T>^N`#rB-UGw^N;{N`gS}T3m<6|V{!fx*w zhM93p#JC~G4R7Dx@b29k9`5gn(X-!gxPErYb{mM%KsJo|L_SPB93Gf+qH~>OCRVdj zm^vI`je7W7m6uE@)}~1Hbeh&fV);BvnaODu^_(?~<4kaYP3(!CwEc|J#1a>uQ^6Q1 zjal)PA`=$Yhy*;9bwaDHkWc*qA-7EgZrTPV2}q9UEyY<(%WS$Rbe#7XvQ83G0DdWSDf`0|F_cqz+^ zM2voBYZwIzoSB6}D|&is%$if(cbeA;M10@kEW<{Q z#{*bVjdk0e-S&ccth{@3hq0EYS5MgNHl&nS*JRvAUVV7Y>u)okef}B0_~kG7{L9by z^Pm0*rZMG_-M(jcvB7%7aX4}~6{h(_-$zV>@4tT|xqnUqDU26+E=|y9>Y{01XwwR6 z=t(KzgC_>R7G!E<&$1e*=OSS;T_m@5K~q9zTk6C=~2bFj5U}n>OmTK zV>wN;tZi0SnJLebI8`gdIMDYS{IYwZ56?v#_nt|?8RtBmafqkN;9VfZpySKT;`g=-ZDzq)8AYZ2^+y6CYemAj zstDVX)46_8A`F6t-1=D!7E5XAKLB=`{Ck%0D2TZHxyeL<9$E{wurL}w{?Ay0)%^BC z7Mg|zwraGQ4BFPp=a=S;_m1~oy(HC%!*SqnIB3Uj#LU=7wETJj>81TvVXEC z7|U=x^6ushpMLrm#`%%WF0k2loQ{@$QPb7@59xafQ4(`Xre5u&kr+iEFbo6Jcv2v6N2}mn#5zx@5~94&m@ELQZ0g9WdX`b=RwN^@YMOL| zMqR7ny|XKGkaM9G6%rY7TuP3gQ9HCyWtJso{j3ei+8yEiQr#ubY}KdI7_-X07re$g zi*b@|fR)i&H1skoiJqN^(|49p^n>-7wBY7A0Iov&c2w zrt==_B10-1Qf6#PI|e;1$S>z|!W0c>Y(nK=mXsiM4(iX5N}(2`=8w9@ia}e*1NoAS zqW8cOx?z-lYgNYdViv9cQk7OI4Sh%yurudFK)7%DoR;O-tpBHya?^}dl}dqV(a%A+ zT<;|9Sav7#4-d1mj*_Lh=f$gMeE7lpynXwQ`};fQG!mlcSHJ!hAAkHy{{6rIcgpmR zQ$5mI$9Oo + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#include +#include +#include + +#include + +static const char* USAGE = " fontfile"; + +static const char* commands = "a/A: char rotate X, s/S: char rotate Y, d/D: char rotate Z, f/F: string rotate, r: reset all"; +static const char* text = "The quick brown fox jumps over a lazy dog."; +static const float point_size = 16; + +static OGLFT::Monochrome* commands_face; +static OGLFT::Monochrome* monochrome_face; +static OGLFT::Grayscale* grayscale_face; +static OGLFT::Translucent* translucent_face; +static OGLFT::Outline* outline_face; +static OGLFT::Filled* filled_face; +#ifndef OGLFT_NO_SOLID +static OGLFT::Solid* solid_face; +#else +static OGLFT::Monochrome* solid_face; +#endif +static OGLFT::MonochromeTexture* monochrome_texture_face; +static OGLFT::GrayscaleTexture* grayscale_texture_face; +static OGLFT::TranslucentTexture* translucent_texture_face; + + +static float dy; +static int viewport_width; +static int viewport_height; + +static void init ( int /*argc*/, char* argv[] ) +{ + std::cout << glGetString( GL_VENDOR ) << " " << glGetString( GL_RENDERER ) << " " + << glGetString( GL_VERSION ) << std::endl; + + commands_face = new OGLFT::Monochrome( argv[1], point_size / 2. ); + commands_face->setHorizontalJustification( OGLFT::Face::CENTER ); + + monochrome_face = new OGLFT::Monochrome( argv[1], point_size ); + monochrome_face->setHorizontalJustification( OGLFT::Face::CENTER ); + monochrome_face->setForegroundColor( 1., 0., 0., 1. ); + + if ( !monochrome_face->isValid() ) { + std::cerr << "failed to open face. exiting." << std::endl; + exit( 1 ); + } + + grayscale_face = new OGLFT::Grayscale( argv[1], point_size ); + grayscale_face->setHorizontalJustification( OGLFT::Face::CENTER ); + grayscale_face->setForegroundColor( 0., 0., .5, 1. ); + grayscale_face->setBackgroundColor( 0., 1., 1., 1. ); + + translucent_face = new OGLFT::Translucent( argv[1], point_size ); + translucent_face->setHorizontalJustification( OGLFT::Face::CENTER ); + translucent_face->setForegroundColor( 0., .5, 0., 1. ); + + outline_face = new OGLFT::Outline( argv[1], point_size ); + outline_face->setHorizontalJustification( OGLFT::Face::CENTER ); + outline_face->setForegroundColor( 1., 1., 0., 1. ); + + filled_face = new OGLFT::Filled( argv[1], point_size ); + filled_face->setHorizontalJustification( OGLFT::Face::CENTER ); + filled_face->setForegroundColor( .5, 0., 1., 1. ); + +#ifndef OGLFT_NO_SOLID + solid_face = new OGLFT::Solid( argv[1], point_size ); + solid_face->setDepth( 10. ); + solid_face->setCharacterRotationX( 25. ); + solid_face->setCharacterRotationY( 25. ); + solid_face->setTessellationSteps( 3 ); +#else + solid_face = new OGLFT::Monochrome( argv[1], point_size ); +#endif + solid_face->setHorizontalJustification( OGLFT::Face::CENTER ); + solid_face->setForegroundColor( 1., .5, 0., 1. ); + + monochrome_texture_face = new OGLFT::MonochromeTexture( argv[1], point_size ); + monochrome_texture_face->setHorizontalJustification( OGLFT::Face::CENTER ); + monochrome_texture_face->setForegroundColor( 0., .5, .75, 1. ); + + grayscale_texture_face = new OGLFT::GrayscaleTexture( argv[1], point_size ); + grayscale_texture_face->setHorizontalJustification( OGLFT::Face::CENTER ); + grayscale_texture_face->setForegroundColor( 0.9, .65, .9, 1. ); + grayscale_texture_face->setBackgroundColor( 0.5, .5, .75, 0.3 ); + + translucent_texture_face = new OGLFT::TranslucentTexture( argv[1], point_size ); + translucent_texture_face->setHorizontalJustification( OGLFT::Face::CENTER ); + translucent_texture_face->setForegroundColor( 0.75, 1., .75, 1. ); + + // Set various general parameters which don't affect performance (yet). + glClearColor( .75, .75, .75, 1. ); + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); +#if defined(GL_RASTER_POSITION_UNCLIPPED_IBM) + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); +#endif + glEnable( GL_LIGHT0 ); + glDisable( GL_DITHER ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); +} + +static void reshape ( int width, int height ) +{ + viewport_width = width; + viewport_height = height; + + glViewport( 0, 0, viewport_width, viewport_height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, viewport_width, 0, viewport_height, -100, 100 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + dy = viewport_height / ( 9 + 1 ); +} + +static void reset ( void ) +{ + monochrome_face->setCharacterRotationZ( 0 ); + monochrome_face->setStringRotation( 0 ); + + grayscale_face->setCharacterRotationZ( 0 ); + grayscale_face->setStringRotation( 0 ); + + translucent_face->setCharacterRotationZ( 0 ); + translucent_face->setStringRotation( 0 ); + + outline_face->setCharacterRotationX( 0 ); + outline_face->setCharacterRotationY( 0 ); + outline_face->setCharacterRotationZ( 0 ); + outline_face->setStringRotation( 0 ); + + filled_face->setCharacterRotationX( 0 ); + filled_face->setCharacterRotationY( 0 ); + filled_face->setCharacterRotationZ( 0 ); + filled_face->setStringRotation( 0 ); + +#ifndef OGLFT_NO_SOLID + solid_face->setCharacterRotationX( 25. ); + solid_face->setCharacterRotationY( 25. ); +#endif + solid_face->setCharacterRotationZ( 0 ); + solid_face->setStringRotation( 0 ); + + monochrome_texture_face->setCharacterRotationX( 0 ); + monochrome_texture_face->setCharacterRotationY( 0 ); + monochrome_texture_face->setCharacterRotationZ( 0 ); + monochrome_texture_face->setStringRotation( 0 ); + + grayscale_texture_face->setCharacterRotationX( 0 ); + grayscale_texture_face->setCharacterRotationY( 0 ); + grayscale_texture_face->setCharacterRotationZ( 0 ); + grayscale_texture_face->setStringRotation( 0 ); + + translucent_texture_face->setCharacterRotationX( 0 ); + translucent_texture_face->setCharacterRotationY( 0 ); + translucent_texture_face->setCharacterRotationZ( 0 ); + translucent_texture_face->setStringRotation( 0 ); + + glViewport( 0, 0, viewport_width, viewport_height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, viewport_width, 0, viewport_height, -100, 100 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + +static void char_rotate_x ( float dx ) +{ + outline_face->setCharacterRotationX( outline_face->characterRotationX()+dx ); + filled_face->setCharacterRotationX( filled_face->characterRotationX()+dx ); +#ifndef OGLFT_NO_SOLID + solid_face->setCharacterRotationX( solid_face->characterRotationX()+dx ); +#endif + monochrome_texture_face->setCharacterRotationX( + monochrome_texture_face->characterRotationX()+dx ); + grayscale_texture_face->setCharacterRotationX( + grayscale_texture_face->characterRotationX()+dx ); + translucent_texture_face->setCharacterRotationX( + translucent_texture_face->characterRotationX()+dx ); +} + +static void char_rotate_y ( float dy ) +{ + outline_face->setCharacterRotationY( outline_face->characterRotationY()+dy ); + filled_face->setCharacterRotationY( filled_face->characterRotationY()+dy ); +#ifndef OGLFT_NO_SOLID + solid_face->setCharacterRotationY( solid_face->characterRotationY()+dy ); +#endif + monochrome_texture_face->setCharacterRotationY( + monochrome_texture_face->characterRotationY()+dy ); + grayscale_texture_face->setCharacterRotationY( + grayscale_texture_face->characterRotationY()+dy ); + translucent_texture_face->setCharacterRotationY( + translucent_texture_face->characterRotationY()+dy ); +} + +static void char_rotate_z ( float dz ) +{ + monochrome_face->setCharacterRotationZ( monochrome_face->characterRotationZ()+dz ); + grayscale_face->setCharacterRotationZ( grayscale_face->characterRotationZ()+dz ); + translucent_face->setCharacterRotationZ( translucent_face->characterRotationZ()+dz ); + + outline_face->setCharacterRotationZ( outline_face->characterRotationZ()+dz ); + filled_face->setCharacterRotationZ( filled_face->characterRotationZ()+dz ); + solid_face->setCharacterRotationZ( solid_face->characterRotationZ()+dz ); + + monochrome_texture_face->setCharacterRotationZ( monochrome_texture_face->characterRotationZ()+dz ); + grayscale_texture_face->setCharacterRotationZ( grayscale_texture_face->characterRotationZ()+dz ); + translucent_texture_face->setCharacterRotationZ( translucent_texture_face->characterRotationZ()+dz ); +} + +static void string_rotate ( float dz ) +{ + + monochrome_face->setStringRotation( monochrome_face->stringRotation()+dz ); + grayscale_face->setStringRotation( grayscale_face->stringRotation()+dz ); + translucent_face->setStringRotation( translucent_face->stringRotation()+dz ); + + outline_face->setStringRotation( outline_face->stringRotation()+dz ); + filled_face->setStringRotation( filled_face->stringRotation()+dz ); + solid_face->setStringRotation( solid_face->stringRotation()+dz ); + + monochrome_texture_face->setStringRotation( monochrome_texture_face->stringRotation()+dz ); + grayscale_texture_face->setStringRotation( grayscale_texture_face->stringRotation()+dz ); + translucent_texture_face->setStringRotation( translucent_texture_face->stringRotation()+dz ); +} + +static void display ( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + glPushMatrix(); + + // Draw everything centered + glTranslatef( viewport_width/2., 0., 0. ); + + commands_face->draw( 0., 0., commands ); + + glTranslatef( 0., dy, 0. ); + monochrome_face->draw( 0., 0., text ); + + glTranslatef( 0., dy, 0. ); + grayscale_face->draw( 0., 0., text ); + + glEnable( GL_BLEND ); + glTranslatef( 0., dy, 0. ); + translucent_face->draw( 0., 0., text ); + glDisable( GL_BLEND ); + + glTranslatef( 0., dy, 0. ); + outline_face->draw( 0., 0., text ); + + glTranslatef( 0., dy, 0. ); + filled_face->draw( 0., 0., text ); + + glTranslatef( 0., dy, 0. ); +#ifndef OGLFT_NO_SOLID + glEnable( GL_LIGHTING ); + glEnable( GL_DEPTH_TEST ); + glEnable( GL_COLOR_MATERIAL ); + solid_face->draw( 0., 0., text ); + glDisable( GL_COLOR_MATERIAL ); + glDisable( GL_DEPTH_TEST ); + glDisable( GL_LIGHTING ); +#else + solid_face->draw( 0., 0., "" ); +#endif + + glEnable( GL_TEXTURE_2D ); + glEnable( GL_BLEND ); + glEnable( GL_DEPTH_TEST ); + glTranslatef( 0., dy, 0. ); + monochrome_texture_face->draw( 0., 0., text ); + + glTranslatef( 0., dy, 0. ); + grayscale_texture_face->draw( 0., 0., text ); + + glTranslatef( 0., dy, 0. ); + translucent_texture_face->draw( 0., 0., text ); + glDisable( GL_DEPTH_TEST ); + glDisable( GL_BLEND ); + glDisable( GL_TEXTURE_2D ); + + glPopMatrix(); + glutSwapBuffers(); +} + +static void key ( unsigned char key, int /*x*/, int /*y*/ ) +{ + switch ( key ) { + case 'a': + char_rotate_x( -4 ); break; + case 'A': + char_rotate_x( 4 ); break; + case 's': + char_rotate_y( -4 ); break; + case 'S': + char_rotate_y( 4 ); break; + case 'd': + char_rotate_z( -4 ); break; + case 'D': + char_rotate_z( 4 ); break; + case 'f': + string_rotate( -4 ); break; + case 'F': + string_rotate( 4 ); break; + case 'r': case 'R': + reset(); break; + case 27: + exit( 0 ); + default: + return; + } + + glutPostRedisplay(); +} + +static void done ( void ) +{ + delete monochrome_face; + delete grayscale_face; + delete translucent_face; + delete outline_face; + delete filled_face; + delete solid_face; + delete monochrome_texture_face; + delete grayscale_texture_face; + delete translucent_texture_face; +} + +int main ( int argc, char* argv[] ) +{ + if ( argc != 2 ) { + std::cerr << argv[0] << USAGE << std::endl; + return 1; + } + + glutInit( &argc, argv ); + glutInitWindowSize( 500, 500 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow( argv[0] ); + + init( argc, argv ); + + atexit( done ); + + glutReshapeFunc( reshape ); + glutDisplayFunc( display ); + glutKeyboardFunc( key ); + + glutMainLoop(); + + return 0; +} diff --git a/engine/libraries/oglft/tests/demo2.cpp b/engine/libraries/oglft/tests/demo2.cpp new file mode 100644 index 0000000..6b48259 --- /dev/null +++ b/engine/libraries/oglft/tests/demo2.cpp @@ -0,0 +1,183 @@ +/* + * demo2.cpp: Second Demo of the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include + +#include + +#include + +#include FT_MULTIPLE_MASTERS_H + +static const char* USAGE = " fontfile"; + +static FT_Library library; +static FT_Face ft_face; +static FT_Multi_Master master_info; +static FT_Long axis_averages[T1_MAX_MM_AXIS]; +#if 0 +static OGLFT::Filled* oglft_face; +#else +static OGLFT::Monochrome* oglft_face; +#endif +static int viewport_width; +static int viewport_height; + +static void init ( int /*argc*/, char* argv[] ) +{ + std::cout << glGetString( GL_VENDOR ) << " " << glGetString( GL_RENDERER ) << " " + << glGetString( GL_VERSION ) << std::endl; + + library = OGLFT::Library::instance(); + + FT_Error error; + + error = FT_New_Face( library, argv[1], 0, &ft_face ); + + if ( error != 0 ) { + std::cerr << "Could not create a font from file \"" << argv[1] << "\"" + << std::endl; + exit( 1 ); + } + + error = FT_Get_Multi_Master( ft_face, &master_info ); + + if ( error != 0 ) { + std::cerr << "Font file \"" << argv[1] + << "\" does not contain a multi master font" << std::endl; + exit( 1 ); + } + + for ( unsigned int i = 0; i < master_info.num_axis; i++ ) + axis_averages[i] = ( master_info.axis[i].minimum + + master_info.axis[i].maximum ) / 2; + + FT_Set_MM_Design_Coordinates( ft_face, master_info.num_axis, axis_averages ); + +#if 0 + oglft_face = new OGLFT::Filled( ft_face, 14 ); +#else + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + + oglft_face = new OGLFT::Monochrome( ft_face, 14 ); +#endif + oglft_face->setHorizontalJustification( OGLFT::Face::LEFT ); + oglft_face->setForegroundColor( 1., 0., 0. ); + oglft_face->setCompileMode( OGLFT::Face::IMMEDIATE ); +} + +static void reshape ( int width, int height ) +{ + viewport_width = width; + viewport_height = height; + + glViewport( 0, 0, viewport_width, viewport_height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, viewport_width, 0, viewport_height, -100, 100 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + +static void display ( void ) +{ + const int BUFSIZE = 128; + char buffer[BUFSIZE]; + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + glPushMatrix(); + + snprintf( buffer, sizeof(buffer), "There are %d axes", master_info.num_axis ); + + GLfloat y = 480.; + + oglft_face->draw( 0., y, buffer ); + + for ( unsigned int i = 0; i < master_info.num_axis; i++ ) { + FT_Set_MM_Design_Coordinates( ft_face, master_info.num_axis, axis_averages ); + snprintf( buffer, sizeof(buffer), "%s: min: %ld max: %ld", + master_info.axis[i].name, + master_info.axis[i].minimum, master_info.axis[i].maximum ); + + y -= 20.; + oglft_face->draw( 0., y, buffer ); + + FT_Long axis_average = axis_averages[i]; + FT_Long d_axis = (master_info.axis[i].maximum - master_info.axis[i].minimum)/4; + axis_averages[i] = master_info.axis[i].minimum; + + for ( int j = 0; j <= 4; j++ ) { + FT_Set_MM_Design_Coordinates( ft_face, master_info.num_axis, axis_averages ); + snprintf( buffer, sizeof(buffer), " Style at axis = %ld\n", axis_averages[i] ); + y -= 20.; + oglft_face->draw( 0., y, buffer ); + + axis_averages[i] += d_axis; + } + + axis_averages[i] = axis_average; + } + + glPopMatrix(); + glutSwapBuffers(); +} + +static void key ( unsigned char key, int /*x*/, int /*y*/ ) +{ + switch ( key ) { + case 'q': + case 27: + exit( 0 ); + default: + return; + } + + glutPostRedisplay(); +} + +static void done ( void ) +{ +} + +int main ( int argc, char* argv[] ) +{ + if ( argc != 2 ) { + std::cerr << argv[0] << USAGE << std::endl; + return 1; + } + + glutInit( &argc, argv ); + glutInitWindowSize( 500, 500 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow( argv[0] ); + + init( argc, argv ); + + atexit( done ); + + glutReshapeFunc( reshape ); + glutDisplayFunc( display ); + glutKeyboardFunc( key ); + + glutMainLoop(); + + return 0; +} diff --git a/engine/libraries/oglft/tests/demo3.cpp b/engine/libraries/oglft/tests/demo3.cpp new file mode 100644 index 0000000..a7bdb45 --- /dev/null +++ b/engine/libraries/oglft/tests/demo3.cpp @@ -0,0 +1,1582 @@ +/* + * demo3.cpp: Third Demo of the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#include + +#include +#include + +#include "OGLFT.h" +#include "vignette.h" +#include "vignette.moc" + +#include "Demo3UnicodeExample.h" +#include "Demo3UnicodeExample2.h" + +class Vignette0 : public Vignette { + + static const unsigned int FRAME_COUNT = 32; + static const unsigned int FRAME_RATE = 16; + + const char* text_; + OGLFT::Filled* face_; + +public: + Vignette0 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 288, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + } + + ~Vignette0 ( void ) + { + // std::cout << "destructing Vignette 0" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 0" << std::endl; + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + glTranslatef( 0., 0., + - 1. - ( FRAME_COUNT - frame_number ) ); + face_->draw( 0., 0., text_ ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette1 : public Vignette { + + static const unsigned int FRAME_COUNT = 49; + static const unsigned int FRAME_RATE = 16; + + const char* text_; + OGLFT::Filled* face_; + +public: + Vignette1 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 288, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + } + + ~Vignette1 ( void ) + { + // std::cout << "destructing Vignette 1" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 1" << std::endl; + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + glTranslatef( 0., 0., + - 1. - ( FRAME_COUNT - frame_number ) ); + glRotatef( frame_number * 15., 0., 0., 1. ); + face_->draw( 0., 0., text_ ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette2 : public Vignette { + + static const unsigned int FRAME_COUNT = 60; + static const unsigned int FRAME_RATE = 12; + + const char* text_; + OGLFT::Filled* face_; + + GLfloat x_; + +public: + Vignette2 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 32, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::RIGHT ); + face_->setCharacterRotationZ( 30. ); + + x_ = -250.; + } + + ~Vignette2 ( void ) + { + // std::cout << "destructing Vignette 2" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 2" << std::endl; + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + + if ( frame_number <= 48 ) { + x_ += 10.; + face_->setCharacterRotationZ( face_->characterRotationZ() - 30. ); + } + else + x_ = 250.; + + glTranslatef( x_, 0., 0. ); + + face_->draw( 0., 0., text_ ); + + glPopMatrix(); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void finish ( void ) + { + } +}; + +class Vignette3 : public Vignette { + + static const unsigned int FRAME_COUNT = 36; + static const unsigned int FRAME_RATE = 16; + + const char* text_; + OGLFT::Filled* face_; + +public: + Vignette3 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 32, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->setCharacterRotationY( 90. ); + } + + ~Vignette3 ( void ) + { + // std::cout << "destructing Vignette 3" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 3" << std::endl; + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + glTranslatef( 0., 0., + - 1. - ( FRAME_COUNT - frame_number ) ); + face_->setCharacterRotationY( face_->characterRotationY() + 10. ); + face_->draw( 0., 0., text_ ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette4 : public Vignette { + + static const unsigned int FRAME_COUNT = 82; + static const unsigned int FRAME_RATE = 10; + + const char* text_; +#ifndef OGLFT_NO_SOLID + OGLFT::Solid* face_; +#else + OGLFT::Filled* face_; +#endif + OGLFT::Translucent* annotation_; + + QImage* bg00b; + QImage* bg01; + QImage* bg10b; + QImage* bg11; + + GLuint bg_textures_[6]; + +public: + Vignette4 ( const char* text, const char* fontfile ) : text_( text ) + { +#ifndef OGLFT_NO_SOLID + face_ = new OGLFT::Solid( fontfile, 120, 75 ); + face_->setDepth( 24. ); +#else + face_ = new OGLFT::Filled( fontfile, 120, 75 ); +#endif + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setForegroundColor( 1., 1., 0. ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->setVerticalJustification( OGLFT::Face::MIDDLE ); + face_->setCharacterRotationY( 0. ); + face_->setCharacterRotationZ( 0. ); + + annotation_ = new OGLFT::Translucent( fontfile, 10, 75 ); + annotation_->setForegroundColor( 1., 1., 0., 0.5 ); + annotation_->setHorizontalJustification( OGLFT::Face::RIGHT ); + annotation_->setVerticalJustification( OGLFT::Face::BOTTOM ); + + bg00b = new QImage( "background00b.png" ); + bg01 = new QImage( "background01.png" ); + bg10b = new QImage( "background10b.png" ); + bg11 = new QImage( "background11.png" ); + } + + ~Vignette4 ( void ) + { + // std::cout << "destructing Vignette 4" << std::endl; + glDeleteTextures( 6, bg_textures_ ); + delete bg00b; + delete bg01; + delete bg10b; + delete bg11; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 4" << std::endl; + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + + glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); + + glGenTextures( 6, bg_textures_ ); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[1] ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bg01->width(), bg01->height(), + 0, GL_BGRA, GL_UNSIGNED_BYTE, bg01->bits() ); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[3] ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bg11->width(), bg11->height(), + 0, GL_BGRA, GL_UNSIGNED_BYTE, bg11->bits() ); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[4] ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bg00b->width(), bg00b->height(), + 0, GL_BGRA, GL_UNSIGNED_BYTE, bg00b->bits() ); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[5] ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bg10b->width(), bg10b->height(), + 0, GL_BGRA, GL_UNSIGNED_BYTE, bg10b->bits() ); + + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + + glEnable( GL_LIGHT0 ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + + GLint viewport[4]; + GLdouble matrix[16]; + + glGetIntegerv( GL_VIEWPORT, viewport ); + glGetDoublev( GL_PROJECTION_MATRIX, matrix ); + glGetDoublev( GL_MODELVIEW_MATRIX, matrix ); + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + + GLubyte alpha = 255; + + if ( frame_number < FRAME_COUNT ) + alpha = (GLubyte)( 255. * (GLfloat)frame_number/(FRAME_COUNT) ); + + glEnable( GL_BLEND ); + + glBegin( GL_QUADS ); + glColor4ub( 128, 164, 212, alpha ); + glVertex2f( -250., 0. ); + glVertex2f( 250., 0. ); + glColor4ub( 101, 142, 198, alpha ); + glVertex2f( 250., 250. ); + glVertex2f( -250., 250. ); + glEnd(); + + glDisable( GL_BLEND ); + + glEnable( GL_LIGHTING ); + glEnable( GL_DEPTH_TEST ); + glEnable( GL_COLOR_MATERIAL ); + + GLfloat y; + + if ( frame_number <= 72 ) { + face_->setCharacterRotationX( face_->characterRotationX() + 25. ); + face_->setCharacterRotationY( face_->characterRotationY() + 25. ); +#if 0 + face_->setCharacterRotationZ( face_->characterRotationZ() - 12.5 ); +#endif + y = 3.5*frame_number - 55.; + } + else + y = 3.5*72 - 55.; + + face_->draw( 0., y, text_ ); + + if ( frame_number < FRAME_COUNT ) { + // Fade in the background + GLdouble f = (GLfloat)frame_number/(FRAME_COUNT); + + glColor4f( f, f, f, 1. ); + } + else + glColor4f( 1., 1., 1., 1. ); + + glDisable( GL_LIGHTING ); + glDisable( GL_DEPTH_TEST ); + glDisable( GL_COLOR_MATERIAL ); + + glEnable( GL_TEXTURE_2D ); + glEnable( GL_BLEND ); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[1] ); + + glBegin( GL_QUADS ); + glTexCoord2f( 0., 1. ); glVertex2f( -250., -250. ); + glTexCoord2f( 1., 1. ); glVertex2f( 0., -250. ); + glTexCoord2f( 1., 0. ); glVertex2f( 0., 0. ); + glTexCoord2f( 0., 0. ); glVertex2f( -250., 0. ); + glEnd(); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[3] ); + + glBegin( GL_QUADS ); + glTexCoord2f( 0., 1. ); glVertex2f( 0., -250. ); + glTexCoord2f( 1., 1. ); glVertex2f( 250., -250. ); + glTexCoord2f( 1., 0. ); glVertex2f( 250., 0. ); + glTexCoord2f( 0., 0. ); glVertex2f( 0., 0. ); + glEnd(); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[4] ); + + glBegin( GL_QUADS ); + glTexCoord2f( 0., 1. ); glVertex2f( -250., 0. ); + glTexCoord2f( 1., 1. ); glVertex2f( 0., 0. ); + glTexCoord2f( 1., 0. ); glVertex2f( 0., 250. ); + glTexCoord2f( 0., 0. ); glVertex2f( -250., 250. ); + glEnd(); + + glBindTexture( GL_TEXTURE_2D, bg_textures_[5] ); + + glBegin( GL_QUADS ); + glTexCoord2f( 0., 1. ); glVertex2f( 0., 0. ); + glTexCoord2f( 1., 1. ); glVertex2f( 250., 0. ); + glTexCoord2f( 1., 0. ); glVertex2f( 250., 250. ); + glTexCoord2f( 0., 0. ); glVertex2f( 0., 250. ); + glEnd(); + + glDisable( GL_TEXTURE_2D ); + glDisable( GL_BLEND ); + + glEnable( GL_BLEND ); + + annotation_->draw( 250., -250., "Hoodoos @ Bryce Canyon National Park, Utah, USA" ); + + glDisable( GL_BLEND ); + + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette5 : public Vignette { + + static const unsigned int FRAME_COUNT = 124; + static const unsigned int FRAME_RATE = 8; + + const char* text_; + OGLFT::Monochrome* monochrome_; + OGLFT::Grayscale* grayscale_; + OGLFT::Translucent* translucent_; + + OGLFT::Outline* outline_; + OGLFT::Filled* filled_; +#ifndef OGLFT_NO_SOLID + OGLFT::Solid* solid_; +#else + OGLFT::Monochrome* solid_; +#endif + + OGLFT::MonochromeTexture* monochrome_texture_; + OGLFT::GrayscaleTexture* grayscale_texture_; + OGLFT::TranslucentTexture* translucent_texture_; + +public: + Vignette5 ( const char* text, const char* fontfile ) : text_( text ) + { + int point_size = 20; + + monochrome_ = new OGLFT::Monochrome( fontfile, point_size, 75 ); + monochrome_->setHorizontalJustification( OGLFT::Face::CENTER ); + monochrome_->setForegroundColor( 1., 0., 0., 1. ); + + grayscale_ = new OGLFT::Grayscale( fontfile, point_size, 75 ); + grayscale_->setHorizontalJustification( OGLFT::Face::CENTER ); + grayscale_->setForegroundColor( 0., 0., .5, 1. ); + grayscale_->setBackgroundColor( 0., 1., 1., 1. ); + + translucent_ = new OGLFT::Translucent( fontfile, point_size, 75 ); + translucent_->setHorizontalJustification( OGLFT::Face::CENTER ); + translucent_->setForegroundColor( 0., .5, 0., 1. ); + + outline_ = new OGLFT::Outline( fontfile, point_size, 75 ); + outline_->setForegroundColor( 1., 1., 0., 1. ); + outline_->setHorizontalJustification( OGLFT::Face::CENTER ); + + filled_ = new OGLFT::Filled( fontfile, point_size, 75 ); + filled_->setForegroundColor( .5, 0., 1., 1. ); + filled_->setHorizontalJustification( OGLFT::Face::CENTER ); +#ifndef OGLFT_NO_SOLID + solid_ = new OGLFT::Solid( fontfile, point_size, 75 ); + solid_->setDepth( 10. ); + solid_->setCharacterRotationX( 25. ); + solid_->setCharacterRotationY( 25. ); + solid_->setTessellationSteps( 3 ); +#else + solid_ = new OGLFT::Monochrome( fontfile, point_size, 75 ); +#endif + solid_->setHorizontalJustification( OGLFT::Face::CENTER ); + solid_->setForegroundColor( 1., .5, 0., 1. ); + + monochrome_texture_ = new OGLFT::MonochromeTexture( fontfile, point_size, 75 ); + monochrome_texture_->setHorizontalJustification( OGLFT::Face::CENTER ); + monochrome_texture_->setForegroundColor( 0., .5, .75, 1. ); + + grayscale_texture_ = new OGLFT::GrayscaleTexture( fontfile, point_size, 75 ); + grayscale_texture_->setHorizontalJustification( OGLFT::Face::CENTER ); + grayscale_texture_->setForegroundColor( 0.9, .65, .9, 1. ); + grayscale_texture_->setBackgroundColor( 0.5, .5, .75, 0.3 ); + + translucent_texture_ = new OGLFT::TranslucentTexture( fontfile, point_size, 75 ); + translucent_texture_->setHorizontalJustification( OGLFT::Face::CENTER ); + translucent_texture_->setForegroundColor( 0.75, 1., .75, 1. ); + } + + ~Vignette5 ( void ) + { + // std::cout << "destructing Vignette 5" << std::endl; + delete monochrome_; + delete grayscale_; + delete translucent_; + delete outline_; + delete filled_; + delete solid_; + delete monochrome_texture_; + delete grayscale_texture_; + delete translucent_texture_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 5" << std::endl; + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_LIGHT0 ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void draw ( unsigned int frame_number ) + { + GLdouble y; + + glPushMatrix(); + if ( frame_number <= 12 ) + y = -240. + 490. * ( 12 - frame_number ) / 12; + else + y = -240.; + monochrome_->draw( 0., y, "Draw text as monochrome bitmaps" ); + + if ( frame_number >= 12 ) { + if ( frame_number <= 24 ) + y = -190. + 440. * ( 24 - frame_number ) / 12; + else + y = -190.; + grayscale_->draw( 0., y, "Draw text as antialiased, grayscale pixmaps" ); + } + + if ( frame_number >= 24 ) { + if ( frame_number <= 36 ) + y = -140. + 390. * ( 36 - frame_number ) / 12; + else + y = -140.; + glEnable( GL_BLEND ); + translucent_->draw( 0., y, "Draw text as antialiased, blended pixmaps" ); + glDisable( GL_BLEND ); + } + + if ( frame_number >= 36 ) { + if ( frame_number <= 48 ) + y = -90. + 340. * ( 48 - frame_number ) / 12; + else + y = -90.; + outline_->draw( 0., y, "Draw text as line segments" ); + } + + if ( frame_number >= 48 ) { + if ( frame_number <= 60 ) + y = -40. + 290. * ( 60 - frame_number ) / 12; + else + y = -40.; + filled_->draw( 0., y, "Draw text as filled polygons" ); + } + + if ( frame_number >= 60 ) { + if ( frame_number <= 72 ) + y = 10. + 240. * ( 72 - frame_number ) / 12; + else + y = 10.; +#ifndef OGLFT_NO_SOLID + glEnable( GL_LIGHTING ); + glEnable( GL_DEPTH_TEST ); + glEnable( GL_COLOR_MATERIAL ); + solid_->draw( 0., y, "Draw text as solid with GLE" ); + glDisable( GL_COLOR_MATERIAL ); + glDisable( GL_DEPTH_TEST ); + glDisable( GL_LIGHTING ); +#else + solid_->draw( 0., y, "" ); +#endif + } + + glEnable( GL_TEXTURE_2D ); + glEnable( GL_BLEND ); + + if ( frame_number >= 72 ) { + if ( frame_number <= 84 ) + y = 60. + 190. * ( 84 - frame_number ) / 12; + else + y = 60.; + monochrome_texture_->draw( 0., y, "Draw text as monochrome texture maps" ); + } + + if ( frame_number >= 84 ) { + if ( frame_number <= 96 ) + y = 110. + 140. * ( 96 - frame_number ) / 12; + else + y = 110.; + grayscale_texture_->draw( 0., y, "Draw text as antialiased, grayscale texture maps" ); + } + + if ( frame_number >= 96 ) { + if ( frame_number <= 108 ) + y = 160. + 90. * ( 108 - frame_number ) / 12; + else + y = 160.; + translucent_texture_->draw( 0., y, "Draw text as antialiased, blended texture maps" ); + } + + glDisable( GL_BLEND ); + glDisable( GL_TEXTURE_2D ); + + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette6 : public Vignette { + + static const unsigned int FRAME_COUNT = 48; + static const unsigned int FRAME_RATE = 12; + + const char* text_; + OGLFT::Filled* face_; + + class MyColorTess : public OGLFT::ColorTess { + public: + QColor hsv_; + GLfloat colors_[4]; + int phase_; + MyColorTess () + { + hsv_.setHsv( 0, 255, 255 ); + colors_[OGLFT::R] = hsv_.red() / 255.; + colors_[OGLFT::G] = hsv_.green() / 255.; + colors_[OGLFT::B] = hsv_.blue() / 255.; + colors_[OGLFT::A] = 1.; + phase_ = 0; + } + void setPhase ( int phase ) { phase_ = phase; } + int phase ( void ) const { return phase_; } + }; + + class MyColorTessVertical : public MyColorTess + { + public: + GLfloat* color ( GLdouble* p ) + { + int hue = (int)( 360. * p[OGLFT::Y] / 36. + phase_ ) % 360; + if ( hue < 0 ) hue += 360; + hsv_.setHsv( hue, 255, 255 ); + colors_[OGLFT::R] = hsv_.red() / 255.; + colors_[OGLFT::G] = hsv_.green() / 255.; + colors_[OGLFT::B] = hsv_.blue() / 255.; + return colors_; + } + }; + + class MyColorTessHorizontal : public MyColorTess + { + public: + GLfloat* color ( GLdouble* p ) + { + int hue = (int)( 360. * p[OGLFT::X] / 36. + phase_ ) % 360; + if ( hue < 0 ) hue += 360; + hsv_.setHsv( hue, 255, 255 ); + colors_[OGLFT::R] = hsv_.red() / 255.; + colors_[OGLFT::G] = hsv_.green() / 255.; + colors_[OGLFT::B] = hsv_.blue() / 255.; + return colors_; + } + }; + + MyColorTessVertical color_tess_v_; + MyColorTessHorizontal color_tess_h_; + +public: + Vignette6 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 72, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->setVerticalJustification( OGLFT::Face::MIDDLE ); + face_->setTessellationSteps( 3 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + ~Vignette6 ( void ) + { + // std::cout << "destructing Vignette 6" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 6" << std::endl; + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void draw ( unsigned int /*frame_number*/ ) + { + glPushMatrix(); + face_->setColorTess( &color_tess_h_ ); + face_->draw( 0., 72., "Apply a per" ); + face_->draw( 0., 0., "vertex color" ); + face_->draw( 0., -72., "function" ); + glPopMatrix(); + + color_tess_h_.setPhase( color_tess_h_.phase() + 15 ); + color_tess_v_.setPhase( color_tess_v_.phase() + 15 ); + } + + void finish ( void ) + { + } +}; + +class Vignette7 : public Vignette { + + static const unsigned int FRAME_COUNT = 48; + static const unsigned int FRAME_RATE = 12; + + const char* text_; + OGLFT::Filled* face_; + QImage* image_; + GLuint texture_; + + class MyTextureTess : public OGLFT::TextureTess { + int phase_; + GLfloat texCoords_[2]; + public: + MyTextureTess () + { + texCoords_[0] = texCoords_[1] = 0.; + phase_ = 0; + } + GLfloat* texCoord ( GLdouble* p ) { + texCoords_[0] = ( p[OGLFT::X] + phase_ ) / 18.; + texCoords_[1] = ( p[OGLFT::Y] + phase_ ) / 18.; + return texCoords_; + } + void setPhase ( int phase ) { phase_ = phase; } + int phase ( void ) const { return phase_; } + }; + + MyTextureTess texture_tess_; + +public: + Vignette7 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 72, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->setVerticalJustification( OGLFT::Face::MIDDLE ); + face_->setTessellationSteps( 3 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setTextureTess( &texture_tess_ ); + + image_ = new QImage( "texture.png" ); + } + + ~Vignette7 ( void ) + { + // std::cout << "destructing Vignette 7" << std::endl; + glDeleteTextures( 1, &texture_ ); + delete image_; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 7" << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + + glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + + glGenTextures( 1, &texture_ ); + + glBindTexture( GL_TEXTURE_2D, texture_ ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, image_->width(), image_->height(), + 0, GL_BGRA, GL_UNSIGNED_BYTE, image_->bits() ); + + glEnable( GL_TEXTURE_2D ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void draw ( unsigned int frame_number ) + { + glPushMatrix(); + face_->draw( 0., 144., "Apply a" ); + face_->draw( 0., 72., "per vertex" ); + face_->draw( 0., 0., "texture" ); + face_->draw( 0., -72., "function" ); + texture_tess_.setPhase( frame_number ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette8 : public Vignette { + + static const unsigned int FRAME_COUNT = 48; + static const unsigned int FRAME_RATE = 3; + + char* text_; + unsigned int text_length_; + OGLFT::Monochrome* face_; + + static const int N_SIZES = 8; + static const int sizes_[N_SIZES]; +public: + Vignette8 ( const char* text, const char* fontfile ) + { + face_ = new OGLFT::Monochrome( fontfile, 36, 75 ); + face_->setForegroundColor( 1., 0., 0. ); + text_ = strdup( text ); + text_length_ = strlen( text_ ); + } + + ~Vignette8 ( void ) + { + // std::cout << "destructing Vignette 8" << std::endl; + delete face_; + free( text_ ); + } + + unsigned int frame_count ( void ) { return text_length_ + 3; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 8" << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + glPushAttrib( GL_POLYGON_BIT ); + } + + void draw ( unsigned int frame_number ) + { + char save_char = '\0'; + if ( frame_number < text_length_ ) { + save_char = text_[frame_number]; + text_[frame_number] = '\0'; + } + + glPushMatrix(); + + glTranslatef( -225., 250., 0. ); + + for ( int i = 0; i < N_SIZES; i++ ) { + glTranslatef( 0., -2. * sizes_[i], 0. ); + + face_->setPointSize( sizes_[i] ); + + OGLFT::BBox size = face_->measure( text_ ); + + glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); + glColor3f( 1., 1., 1. ); + glRectf( size.x_min_, size.y_min_, size.x_max_, size.y_max_ ); + + face_->draw( 0., 0., text_ ); + + glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); + glColor3f( 0., 0., 1. ); + glRectf( size.x_min_, 0., size.x_max_, size.y_max_ ); + } + + if ( frame_number < text_length_ ) + text_[frame_number] = save_char; + + glPopMatrix(); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void finish ( void ) + { + glPopAttrib(); + } +}; + +const int Vignette8::sizes_[8] = { 64, 48, 32, 24, 18, 12, 10, 6 }; + +class Vignette9 : public Vignette { + + static const unsigned int FRAME_COUNT = 32; + static const unsigned int FRAME_RATE = 8; + + const char* text_; + OGLFT::Filled* face_; + +public: + Vignette9 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 288, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->setCharacterRotationX( 12. ); + } + + ~Vignette9 ( void ) + { + // std::cout << "destructing Vignette 9" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 9" << std::endl; + } + + void draw ( unsigned int /*frame_number*/ ) + { + glPushMatrix(); + glTranslatef( 0., 0., -8. ); + face_->draw( 0., 0., text_ ); + face_->setCharacterRotationX( face_->characterRotationX() - 0.5 ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette10 : public Vignette { + + static const unsigned int FRAME_COUNT = 108; + static const unsigned int FRAME_RATE = 8; + + const char* text_; + unsigned int text_length_; + OGLFT::Filled* face_; + + GLuint glyph_dl_; + OGLFT::DisplayLists dlists; + GLfloat x_; + +public: + Vignette10 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 24, 75 ); + face_->setForegroundColor( 0., .5, .75 ); + face_->setHorizontalJustification( OGLFT::Face::LEFT ); + + text_length_ = strlen( text_ ); + + x_ = 250.; + } + + ~Vignette10 ( void ) + { + // std::cout << "destructing Vignette 10" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 10" << std::endl; + + glyph_dl_ = glGenLists( 2 * text_length_ ); + + dlists.push_back( 0 ); + + QColor hsv; + + for ( unsigned int i = 0; i < text_length_; i++ ) { + float dy = 50. * ( + sin( M_PI + (i+1) * 4 * M_PI / text_length_ ) + - sin( M_PI + i * 4 * M_PI / text_length_ ) ); + + hsv.setHsv( (int)(360. * i / text_length_), 255, 255 ); + + glNewList( glyph_dl_ + i, GL_COMPILE ); + glTranslatef( 0., dy, 0. ); + glColor3ub( hsv.red(), hsv.green(), hsv.blue() ); + glEndList(); + + dlists.push_back( glyph_dl_ + i ); + } + + for ( unsigned int i = 0; i < text_length_; i++ ) { + float y = 50. * sin( M_PI - i * 4 * M_PI / text_length_ ); + + hsv.setHsv( (int)(360. * (text_length_ - i) / text_length_), 255, 255 ); + + glNewList( glyph_dl_ + text_length_ + i, GL_COMPILE ); + glTranslatef( 0., y, 0. ); + glColor3ub( hsv.red(), hsv.green(), hsv.blue() ); + glEndList(); + + dlists.push_back( glyph_dl_ + text_length_ + i ); + } + + dlists[0] = dlists[text_length_]; + + face_->setCharacterDisplayLists( dlists ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + } + + void draw ( unsigned int /*frame_number*/ ) + { + OGLFT::DLI first = face_->characterDisplayLists().begin() + 1; + OGLFT::DLI next = first + text_length_ - 1; + OGLFT::DLI last = first + text_length_; + + rotate( first, next, last ); + + first = face_->characterDisplayLists().begin() + text_length_ + 1; + next = first + 1; + last = first + text_length_; + + rotate( first, next, last ); + + face_->characterDisplayLists()[0] = + face_->characterDisplayLists()[text_length_+1]; + + face_->draw( x_, 0., text_ ); + + x_ -= 10.; + } + + void finish ( void ) + { + glDeleteLists( glyph_dl_, 2 * text_length_ ); + } +}; + +class Vignette11 : public Vignette { + + static const unsigned int FRAME_COUNT = 10; + static const unsigned int FRAME_RATE = 1; + + const QString text_; + QString equation_; + OGLFT::Translucent* face_; + +public: + Vignette11 ( const char* text, const char* fontfile ) : text_( text ) + { + // First, open a face in the usual way. + face_ = new OGLFT::Translucent( fontfile, 18, 75 ); + + // Now, create a second face, in this case, using a built-in font. +#if 0 + FT_Library library = OGLFT::Library::instance(); + FT_Face ft_face; + FT_New_Memory_Face( library, Demo3UnicodeExample_ttf, + Demo3UnicodeExample_ttf_size, 0, &ft_face ); + + face_->addAuxiliaryFace( ft_face ); +#else + // Somewhat simpler with new interface. + face_->addAuxiliaryFace( Demo3UnicodeExample_ttf, + Demo3UnicodeExample_ttf_size ); +#endif + face_->setForegroundColor( 0., .5, .75 ); + + // Manually create the equation in UNICODE points + equation_ = QChar( 0x2207 );//Nabla + equation_ += QChar( 0x2219 );//Dot + equation_ += QChar( 0x03a9 );//Omega + equation_ += QChar( 0x03c8 );//psi + equation_ += QChar( ' ' ); + equation_ += QChar( '+' ); + equation_ += QChar( ' ' ); + equation_ += QChar( 0x03c3 );//sigma + equation_ += QChar( 0x03c8 );//psi + equation_ += QChar( ' ' ); + equation_ += QChar( '=' ); + equation_ += QChar( ' ' ); + equation_ += QChar( 0x222b );//integral + equation_ += QChar( 'd' ); + equation_ += QChar( 0x03a9 );//Omega + equation_ += QChar( '\'' ); + equation_ += QChar( 0x03c3 );//sigma + equation_ += QChar( '(' ); + equation_ += QChar( 0x03a9 );//Omega + equation_ += QChar( '\'' ); + equation_ += QChar( 0x2192 );//right arrow + equation_ += QChar( 0x03a9 );//Omega + equation_ += QChar( ')' ); + equation_ += QChar( 0x03c8 );//psi + equation_ += QChar( '(' ); + equation_ += QChar( 0x03a9 );//Omega + equation_ += QChar( '\'' ); + equation_ += QChar( ')' ); + } + + ~Vignette11 ( void ) + { + // std::cout << "destructing Vignette 11" << std::endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 11" << std::endl; + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_BLEND ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + glTranslated( left, 0, 0 ); + } + + void draw ( unsigned int /*frame_number*/ ) + { + face_->setHorizontalJustification( OGLFT::Face::LEFT ); + face_->draw( 2., 128., "This frame demonstrates two...no three...features:" ); + face_->draw( 2., 96., "1. Drawing a UNICODE string (using Qt's QString)." ); + face_->draw( 2., 64., "2. Combining two fonts to cover more UNICODE points." ); + face_->draw( 2., 32., "3. Embedding a font in the program." ); + + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->draw( 250., 0., equation_ ); + + face_->setHorizontalJustification( OGLFT::Face::LEFT ); + face_->draw( 2., -32., "Thanks to Oliver Bock for the font-in-memory code!" ); + } + + void finish ( void ) + { + glDisable( GL_BLEND ); + } +}; + +class Vignette12 : public Vignette { + + static const unsigned int FRAME_COUNT = 10; + static const unsigned int FRAME_RATE = 1; + + const QString text_; + QString equation_; +#if 1 + OGLFT::Monochrome* face_; +#else + OGLFT::Filled* face_; +#endif +public: + Vignette12 ( const char* text, const char* fontfile ) : text_( text ) + { + // First, open a face in the usual way. +#if 1 + face_ = new OGLFT::Monochrome( fontfile, 18, 75 ); +#else + face_ = new OGLFT::Filled( fontfile, 18, 75 ); +#endif + face_->setForegroundColor( 0., .75, .75 ); + + // Now, create a second face, in this case, using a built-in font. + FT_Library library = OGLFT::Library::instance(); + FT_Face ft_face; + FT_New_Memory_Face( library, lCSymbols_ttf, + lCSymbols_ttf_size, 0, &ft_face ); + + face_->addAuxiliaryFace( ft_face ); + } + + ~Vignette12 ( void ) + { + // cout << "destructing Vignette 12" << endl; + delete face_; + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + unsigned int frame_rate ( void ) { return FRAME_RATE; } + + void init ( void ) + { + std::cout << "Vignette 12" << std::endl; + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_BLEND ); + } + + void view ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top ) + { + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( left, right, bottom, top, -250., 250. ); + glMatrixMode( GL_MODELVIEW ); + glTranslated( left, 0, 0 ); + } + + void draw ( unsigned int /*frame_number*/ ) + { + face_->setVerticalJustification( OGLFT::Face::TOP ); + face_->setHorizontalJustification( OGLFT::Face::CENTER ); + face_->draw( 250., 250., "Example of numeric formatting" ); + + face_->setVerticalJustification( OGLFT::Face::BASELINE ); + face_->setHorizontalJustification( OGLFT::Face::ORIGIN ); + + face_->draw( 0., 128., "%.6f", 100.123456789 ); + face_->draw( 0., 96., "%12.6e", 100.123456789 ); + face_->draw( 0., 64., "%12.6g", 100.123456789 ); + for ( int i = 1; i <= 8; ++i ) { + for ( int j = 1; j <= i; j++ ) { + double a = i + (double)j / ( 1 << i ); + + OGLFT::BBox bbox = face_->measure( "%p\"", a ); + + glPushMatrix(); + glTranslated( j*42, -i * 18, 0 ); + + glColor3f( .25, .25, .25 ); + glRectd( bbox.x_min_, bbox.y_min_, bbox.x_max_, bbox.y_max_ ); + + face_->draw( 0, 0, "%p\"", a ); + glPopMatrix(); + } + } + + for ( int r = 0; r < 360; r += 45 ) { + double sinr = sin( (double)r/180 * M_PI ); + double cosr = cos( (double)r/180 * M_PI ); + face_->setStringRotation( r ); + OGLFT::BBox bbox = face_->measure( "%p\"", 1.015625 ); + + glPushMatrix(); + glTranslated( 250.+cosr*24, 96.+sinr*24, 0 ); + + glColor3f( .25, .25, .25 ); + glRectd( bbox.x_min_, bbox.y_min_, bbox.x_max_, bbox.y_max_ ); + + face_->draw( 0, 0, "%p\"", 1.015625 ); + glPopMatrix(); + } + + face_->setStringRotation( 0 ); + } + + void finish ( void ) + { + glDisable( GL_BLEND ); + } +}; + +CharacterView::CharacterView ( bool flank_speed, const char* fontfile, + QWidget* parent, const char* name ) + : QGLWidget( ), flank_speed_( flank_speed ) +{ + vignettes.enqueue( new Vignette0( "Welcome to OGLFT!", fontfile ) ); + vignettes.enqueue( new Vignette1( "The OpenGL/FreeType library", fontfile ) ); + vignettes.enqueue( new Vignette2( "Featuring a mind numbing", fontfile ) ); + vignettes.enqueue( new Vignette3( "collection of rendering options", fontfile ) ); + vignettes.enqueue( new Vignette9( "and other text effects.", fontfile ) ); + vignettes.enqueue( new Vignette5( "Sampler", fontfile ) ); + vignettes.enqueue( new Vignette8( "Measuring the text.", fontfile ) ); + vignettes.enqueue( new Vignette6( "Per vertex color", fontfile ) ); + vignettes.enqueue( new Vignette7( "Per vertex texture coord", fontfile ) ); + vignettes.enqueue( new Vignette10( "Each glyph can have it's own display list", fontfile ) ); + vignettes.enqueue( new Vignette11( "QString Example", fontfile ) ); + vignettes.enqueue( new Vignette12( "Formatting Numbers", fontfile ) ); + vignettes.enqueue( new Vignette4( "OGLFT", fontfile ) ); + + frame_counter_ = 0; + counter_snapshot_ = 0; + animation_frame_counter_ = 0; + + animation_frame_count_ = vignettes.current()->frame_count(); + animation_frame_rate_ = 1000 / vignettes.current()->frame_rate(); + + connect( &redraw_timer_, SIGNAL(timeout()), SLOT(redraw()) ); + connect( &performance_timer_, SIGNAL(timeout()), SLOT(measure_performance()) ); + + if ( flank_speed_ ) + redraw_timer_.start( 0 ); + else + redraw_timer_.start( animation_frame_rate_ ); + + performance_timer_.start( PERFORMANCE_SAMPLE_RATE_HZ * 1000 ); +} + +void CharacterView::redraw ( void ) +{ + updateGL(); + + frame_counter_++; + animation_frame_counter_++; + + if ( animation_frame_counter_ >= animation_frame_count_ ) { + redraw_timer_.stop(); + vignettes.current()->finish(); + delete vignettes.dequeue(); + + if ( !vignettes.isEmpty() ) { + counter_snapshot_ = frame_counter_; + animation_frame_counter_ = 0; + + vignettes.current()->init(); + resetView(); + animation_frame_count_ = vignettes.current()->frame_count(); + animation_frame_rate_ = 1000 / vignettes.current()->frame_rate(); + + if ( flank_speed_ ) + redraw_timer_.start( 0 ); + else + redraw_timer_.start( animation_frame_rate_ ); + } + else { + // Evidently, events may be processed during exiting, so... + redraw_timer_.stop(); + performance_timer_.stop(); + qApp->exit( 0 ); + } + } +} + +void CharacterView::measure_performance ( void ) +{ + int delta_count = frame_counter_ - counter_snapshot_; + + std::cout << delta_count << " FPS" << std::endl; + + counter_snapshot_ = frame_counter_; +} + +void CharacterView::initializeGL ( void ) +{ + std::cout << glGetString( GL_VENDOR ) << " " << glGetString( GL_RENDERER ) << " " + << glGetString( GL_VERSION ) << std::endl; + + glClearColor( 0., 0., 0., 1. ); + + // Let the first vignette do any initialization it wants (though this + // should probably be called by the animation controller). + + vignettes.current()->init(); +} + +void CharacterView::resizeGL ( int w, int h ) +{ + window_width_ = w; + window_height_ = h; + + glViewport( 0, 0, window_width_, window_height_ ); + + view_width_ = window_width_; + view_height_ = window_height_; + + view_left_ = -view_width_ / 2.; + view_right_ = view_width_ / 2.; + view_bottom_ = -view_height_ / 2.; + view_top_ = view_height_ / 2.; + + resetView(); +} + +void CharacterView::paintGL ( void ) +{ + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + vignettes.current()->draw( animation_frame_counter_ % animation_frame_count_ ); +} + +void CharacterView::keyPressEvent ( QKeyEvent* e ) +{ + switch ( e->key() ) { + case Key_Q: + case Key_Escape: + qApp->exit( 0 ); + case Key_Return: + // "Speed up the harvest." L, Skywalker + animation_frame_counter_ = animation_frame_count_; + updateGL(); + } +} + +void CharacterView::resetView ( void ) +{ + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + + glFrustum( view_left_, view_right_, view_bottom_, view_top_, + 1., 100. ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + vignettes.current()->view( view_left_, view_right_, view_bottom_, view_top_ ); +} + +int main ( int argc, char* argv[] ) +{ + + QApplication app( argc, argv ); + + if ( argc < 2 ) { + std::cerr << "usage: " << argv[0] << " [-f] fontfile" << std::endl; + std::cerr << " -f ignore the animation timings and run as fast as possible" + << std::endl; + return 1; + } + + int argn = 1; + bool flank_speed = false; + + if ( !strcmp( argv[argn], "-f" ) ) { + flank_speed = true; + argn++; + } + + if ( argc <= argn ) { + std::cerr << "usage: " << argv[0] << " [-f] fontfile" << std::endl; + std::cerr << " -f ignore the animation timings and run as fast as possible" + << std::endl; + return 1; + } + + // Test the supplied face to make sure it will work OK + + OGLFT::Monochrome* test_face = new OGLFT::Monochrome( argv[argn] ); + + if ( !test_face->isValid() ) { + std::cerr << "Freetype did not recognize \"" << argv[1] << "\" as a font file" + << std::endl; + return 1; + } + + delete test_face; + + CharacterView cv( flank_speed, argv[argn] ); + cv.resize( 500, 500 ); + + app.setMainWidget( &cv ); + cv.show(); + + return app.exec(); +} diff --git a/engine/libraries/oglft/tests/speedtest.cpp b/engine/libraries/oglft/tests/speedtest.cpp new file mode 100644 index 0000000..b24a7af --- /dev/null +++ b/engine/libraries/oglft/tests/speedtest.cpp @@ -0,0 +1,1298 @@ +/* + * speedtest.cpp: Performance test for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#include + +#include + +#include + +#include "speedtest.h" +#include "speedtest.moc" + +class Vignette0 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Face* face_; + +public: + Vignette0 ( const char* text, const char* /*fontfile*/ ) : text_( text ) + { + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 0: Color and depth buffer clearing only" << std::endl; + } + + void draw ( int /*frame_number*/ ) + { + } + + void finish ( void ) + { + } +}; + +class Vignette1 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Monochrome* face_; + +public: + Vignette1 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Monochrome( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 1: MONOCHROME: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette2 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Monochrome* face_; + +public: + Vignette2 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Monochrome( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 2: MONOCHROME: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette3 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Monochrome* face_; + + GLuint dlist_; + +public: + Vignette3 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Monochrome( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setAdvance( false ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 3: MONOCHROME: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glRasterPos2f( 0., 0. ); + glCallList( dlist_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette4 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Grayscale* face_; + + GLuint dlist_; + +public: + Vignette4 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Grayscale( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 4: GRAYSCALE: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette5 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Grayscale* face_; + +public: + Vignette5 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Grayscale( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 5: GRAYSCALE: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette6 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Grayscale* face_; + + GLuint dlist_; + +public: + Vignette6 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Grayscale( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 6: GRAYSCALE: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glRasterPos2f( 0., 0. ); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette7 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Translucent* face_; + + GLuint dlist_; + +public: + Vignette7 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Translucent( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 7: TRANSLUCENT: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_BLEND ); + } +}; + +class Vignette8 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Translucent* face_; + +public: + Vignette8 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Translucent( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 8: TRANSLUCENT: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_BLEND ); + } +}; + +class Vignette9 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Translucent* face_; + + GLuint dlist_; + +public: + Vignette9 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Translucent( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 9: TRANSLUCENT: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + glEnable( GL_RASTER_POSITION_UNCLIPPED_IBM ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glRasterPos2f( 0., 0. ); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_BLEND ); + } +}; + +class Vignette10 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Outline* face_; + + GLuint dlist_; + +public: + Vignette10 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Outline( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 10: OUTLINE: immediate drawing: " << text_ << std::endl; + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette11 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Outline* face_; + +public: + Vignette11 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Outline( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 11: OUTLINE: cached glyphs: " << text_ << std::endl; + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette12 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Outline* face_; + + GLuint dlist_; + +public: + Vignette12 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Outline( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + face_->setAdvance( false ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 12: OUTLINE: display list: " << text_ << std::endl; + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + // glPushMatrix(); + glCallList( dlist_ ); + // glPopMatrix(); + } + + void finish ( void ) + { + } +}; + +class Vignette13 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Filled* face_; + + GLuint dlist_; + +public: + Vignette13 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 13: FILLED: immediate drawing: " << text_ << std::endl; + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette14 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Filled* face_; + +public: + Vignette14 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 14: FILLED: cached glyphs: " << text_ << std::endl; + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + } +}; + +class Vignette15 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Filled* face_; + + GLuint dlist_; + +public: + Vignette15 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Filled( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 15: FILLED: display list: " << text_ << std::endl; + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + } +}; +#ifndef OGLFT_NO_SOLID +class Vignette16 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Solid* face_; + + GLuint dlist_; + +public: + Vignette16 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Solid( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 16: SOLID: immediate drawing: " << text_ << std::endl; + glEnable( GL_LIGHTING ); + glEnable( GL_LIGHT0 ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_LIGHTING ); + } +}; + +class Vignette17 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Solid* face_; + +public: + Vignette17 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Solid( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 17: SOLID: cached glyphs: " << text_ << std::endl; + glEnable( GL_LIGHTING ); + glEnable( GL_LIGHT0 ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_LIGHTING ); + } +}; + +class Vignette18 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::Solid* face_; + + GLuint dlist_; + +public: + Vignette18 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::Solid( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 18: SOLID: display list: " << text_ << std::endl; + glEnable( GL_LIGHTING ); + glEnable( GL_LIGHT0 ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_LIGHTING ); + } +}; +#endif // OGLFT_NO_SOLID +class Vignette19 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::MonochromeTexture* face_; + + GLuint dlist_; + +public: + Vignette19 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::MonochromeTexture( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 19: MONOCHROME TEXTURE: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette20 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::MonochromeTexture* face_; + +public: + Vignette20 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::MonochromeTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 20: MONOCHROME TEXTURE: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette21 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::MonochromeTexture* face_; + + GLuint dlist_; + +public: + Vignette21 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::MonochromeTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 21: MONOCHROME TEXTURE: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette22 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::GrayscaleTexture* face_; + + GLuint dlist_; + +public: + Vignette22 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::GrayscaleTexture( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 22: GRAYSCALE TEXTURE: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette23 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::GrayscaleTexture* face_; + +public: + Vignette23 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::GrayscaleTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 23: GRAYSCALE TEXTURE: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette24 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::GrayscaleTexture* face_; + + GLuint dlist_; + +public: + Vignette24 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::GrayscaleTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 24: GRAYSCALE TEXTURE: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + } +}; + +class Vignette25 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::TranslucentTexture* face_; + + GLuint dlist_; + +public: + Vignette25 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::TranslucentTexture( fontfile, 20, 75 ); + face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 25: TRANSLUCENT TEXTURE: immediate drawing: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + glDisable( GL_BLEND ); + } +}; + +class Vignette26 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::TranslucentTexture* face_; + +public: + Vignette26 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::TranslucentTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 26: TRANSLUCENT TEXTURE: cached glyphs: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + } + + void draw ( int /*frame_number*/ ) + { + face_->draw( 0., 0., text_ ); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + glDisable( GL_BLEND ); + } +}; + +class Vignette27 : public Vignette { + + static const unsigned int FRAME_COUNT = 128; // Not really + + const char* text_; + OGLFT::TranslucentTexture* face_; + + GLuint dlist_; + +public: + Vignette27 ( const char* text, const char* fontfile ) : text_( text ) + { + face_ = new OGLFT::TranslucentTexture( fontfile, 20, 75 ); + // face_->setCompileMode( OGLFT::Face::IMMEDIATE ); + } + + unsigned int frame_count ( void ) { return FRAME_COUNT; } + + void init ( void ) + { + std::cout << "Vignette 27: TRANSLUCENT TEXTURE: display list: " << text_ << std::endl; + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + glEnable( GL_BLEND ); + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + dlist_ = face_->compile( text_ ); + } + + void draw ( int /*frame_number*/ ) + { + glPushMatrix(); + glCallList( dlist_ ); + glPopMatrix(); + } + + void finish ( void ) + { + glDisable( GL_TEXTURE_2D ); + glDisable( GL_BLEND ); + } +}; + +CharacterView::CharacterView ( const char* text, const char* fontfile, + QWidget* parent, const char* name ) + : QGLWidget( parent, name ) +{ + vignettes.enqueue( new Vignette0( text, fontfile ) ); + vignettes.enqueue( new Vignette1( text, fontfile ) ); + vignettes.enqueue( new Vignette2( text, fontfile ) ); + vignettes.enqueue( new Vignette3( text, fontfile ) ); + vignettes.enqueue( new Vignette4( text, fontfile ) ); + vignettes.enqueue( new Vignette5( text, fontfile ) ); + vignettes.enqueue( new Vignette6( text, fontfile ) ); + vignettes.enqueue( new Vignette7( text, fontfile ) ); + vignettes.enqueue( new Vignette8( text, fontfile ) ); + vignettes.enqueue( new Vignette9( text, fontfile ) ); + vignettes.enqueue( new Vignette10( text, fontfile ) ); + vignettes.enqueue( new Vignette11( text, fontfile ) ); + vignettes.enqueue( new Vignette12( text, fontfile ) ); + vignettes.enqueue( new Vignette13( text, fontfile ) ); + vignettes.enqueue( new Vignette14( text, fontfile ) ); + vignettes.enqueue( new Vignette15( text, fontfile ) ); +#ifndef OGLFT_NO_SOLID + vignettes.enqueue( new Vignette16( text, fontfile ) ); + vignettes.enqueue( new Vignette17( text, fontfile ) ); + vignettes.enqueue( new Vignette18( text, fontfile ) ); +#endif + vignettes.enqueue( new Vignette19( text, fontfile ) ); + vignettes.enqueue( new Vignette20( text, fontfile ) ); + vignettes.enqueue( new Vignette21( text, fontfile ) ); + vignettes.enqueue( new Vignette22( text, fontfile ) ); + vignettes.enqueue( new Vignette23( text, fontfile ) ); + vignettes.enqueue( new Vignette24( text, fontfile ) ); + vignettes.enqueue( new Vignette25( text, fontfile ) ); + vignettes.enqueue( new Vignette26( text, fontfile ) ); + vignettes.enqueue( new Vignette27( text, fontfile ) ); + + frame_counter_ = 0; + counter_snapshot_ = 0; + iteration_counter_ = MAXIMUM_ITERATIONS; + + animation_frame_count_ = vignettes.current()->frame_count(); + + connect( &redraw_timer_, SIGNAL(timeout()), SLOT(redraw()) ); + connect( &performance_timer_, SIGNAL(timeout()), SLOT(measure_performance()) ); + + redraw_timer_.start( 0 ); + performance_timer_.start( PERFORMANCE_SAMPLE_RATE_HZ * 1000 ); + +} + +void CharacterView::redraw ( void ) +{ + frame_counter_++; + updateGL(); +} + +void CharacterView::measure_performance ( void ) +{ + int delta_count = frame_counter_ - counter_snapshot_; + + std::cout << delta_count << " FPS" << std::endl; + + counter_snapshot_ = frame_counter_; + + iteration_counter_--; + + if ( iteration_counter_ == 0 ) { + vignettes.current()->finish(); + vignettes.dequeue(); + + if ( !vignettes.isEmpty() ) { + frame_counter_ = 0; + counter_snapshot_ = 0; + iteration_counter_ = MAXIMUM_ITERATIONS; + + vignettes.current()->init(); + animation_frame_count_ = vignettes.current()->frame_count(); + } + else { + // Evidently, events may be processed during exiting, so... + redraw_timer_.stop(); + performance_timer_.stop(); + qApp->exit( 0 ); + } + } +} + +void CharacterView::initializeGL ( void ) +{ + std::cout << glGetString( GL_VENDOR ) << " " << glGetString( GL_RENDERER ) << " " + << glGetString( GL_VERSION ) << std::endl; + + glClearColor( 0.75, 0.75, 0.75, 1. ); + + // Let the first vignette do any initialization it wants (though this + // should probably be called by the animation controller). + + vignettes.current()->init(); +} + +void CharacterView::resizeGL ( int w, int h ) +{ + window_width_ = w; + window_height_ = h; + + glViewport( 0, 0, window_width_, window_height_ ); + + view_width_ = window_width_; + view_height_ = window_height_; + + view_left_ = -view_width_ / 2.; + view_right_ = view_width_ / 2.; + view_bottom_ = -view_height_ / 2.; + view_top_ = view_height_ / 2.; + + rot_x_ = rot_y_ = rot_z_ = 0.; + + resetView(); +} + +void CharacterView::paintGL ( void ) +{ + + glClear( GL_COLOR_BUFFER_BIT ); + + vignettes.current()->draw( frame_counter_ % animation_frame_count_ ); +} + +void CharacterView::keyPressEvent ( QKeyEvent* e ) +{ + static const GLdouble ZOOM = 1.0625; + static const GLdouble PAN = 0.002; + static const GLdouble ROTATOR = 1.; + GLdouble center; + bool redraw = true; + GLdouble speed = 1.0; + + if ( e->state() & ShiftButton ) + speed *= 2.0; + if ( e->state() & ControlButton ) + speed *= 2.0; + if ( e->state() & AltButton ) + speed *= 2.0; + + switch ( e->key() ) { + case Key_PageUp: + view_width_ = (GLdouble)view_width_ / (speed * ZOOM); + center = ( view_left_ + view_right_ ) / 2.; + view_left_ = center - view_width_ / 2.; + view_right_ = center + view_width_ / 2.; + + view_height_ = (GLdouble)view_height_ / (speed * ZOOM); + center = ( view_bottom_ + view_top_ ) / 2.; + view_bottom_ = center - view_height_ / 2.; + view_top_ = center + view_height_ / 2.; + break; + case Key_PageDown: + view_width_ = (GLdouble)view_width_ * (speed * ZOOM); + center = ( view_left_ + view_right_ ) / 2.; + view_left_ = center - view_width_ / 2.; + view_right_ = center + view_width_ / 2.; + + view_height_ = (GLdouble)view_height_ * (speed * ZOOM); + center = ( view_bottom_ + view_top_ ) / 2.; + view_bottom_ = center - view_height_ / 2.; + view_top_ = center + view_height_ / 2.; + break; + case Key_Up: + view_bottom_ += (speed * PAN) * view_height_; + view_top_ = view_bottom_ + view_height_; + break; + case Key_Down: + view_bottom_ -= (speed * PAN) * view_height_; + view_top_ = view_bottom_ + view_height_; + break; + case Key_Left: + view_left_ -= (speed * PAN) * view_width_; + view_right_ = view_left_ + view_width_; + break; + case Key_Right: + view_left_ += (speed * PAN) * view_width_; + view_right_ = view_left_ + view_width_; + break; + case Key_Q: + case Key_Escape: + qApp->exit( 0 ); + case Key_R: + view_width_ = window_width_; + view_height_ = window_height_; + + view_left_ = -view_width_ / 2.; + view_right_ = view_width_ / 2.; + view_bottom_ = -view_height_ / 2.; + view_top_ = view_height_ / 2.; + + rot_x_ = rot_y_ = rot_z_ = 0; + + vignettes.current()->reset(); + break; + case Key_X: + rot_x_ += speed * ROTATOR; + break; + case Key_Y: + rot_y_ += speed * ROTATOR; + break; + case Key_Z: + rot_z_ += speed * ROTATOR; + break; + default: + redraw = vignettes.current()->input( e ); + } + if ( redraw ) { + resetView(); + updateGL(); + } +} + +void CharacterView::resetView ( void ) +{ + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); +#if 1 + glOrtho( view_left_, view_right_, view_bottom_, view_top_, -250., 250. ); +#else + glFrustum( view_left_, view_right_, view_bottom_, view_top_, + 10., 100. ); +#endif + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + glRotatef( rot_x_, 1., 0., 0. ); + glRotatef( rot_y_, 0., 1., 0. ); + glRotatef( rot_z_, 0., 0., 1. ); + + glTranslatef( -window_width_ / 2., -window_height_ / 2., 0. ); + glTranslatef( 0., 0., -10. ); + + vignettes.current()->view( view_left_, view_right_, view_bottom_, view_top_ ); +} + +int main ( int argc, char* argv[] ) +{ + + QApplication app( argc, argv ); + + if ( argc != 3 ) { + std::cerr << "usage: " << argv[0] << " string fontfile" << std::endl; + return 1; + } + + CharacterView cv ( argv[1], argv[2] ); + cv.resize( 500, 500 ); + + app.setMainWidget( &cv ); + cv.show(); + + return app.exec(); +} diff --git a/engine/libraries/oglft/tests/speedtest.h b/engine/libraries/oglft/tests/speedtest.h new file mode 100644 index 0000000..4463cbc --- /dev/null +++ b/engine/libraries/oglft/tests/speedtest.h @@ -0,0 +1,89 @@ +/* -*- c++ -*- + * speedtest.h: Header for Performance test for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef SPEEDTEST_H +#define SPEEDTEST_H + +#include + +#include +#include +#include + +// Little animation vignettes. The function calls essentially follow +// those of the Qt OpenGL widget and are called at the corresponding times. + +struct Vignette { + virtual ~Vignette ( void ) {} + virtual unsigned int frame_count ( void ) = 0; + virtual void init ( void ) = 0; + virtual void view ( GLdouble /*left*/, GLdouble /*right*/, + GLdouble /*bottom*/, GLdouble /*top*/ ) + {} + virtual void reset ( void ) + {} + virtual bool input ( QKeyEvent* e ) + { + if ( e->key() == Qt::Key_Escape ) exit( 0 ); + return false; + } + virtual void draw ( int frame_number ) = 0; + virtual void finish ( void ) = 0; +}; + +// Yet another OpenGL view widget. + +class CharacterView : public QGLWidget { +Q_OBJECT + GLsizei window_width_, window_height_; + GLdouble view_width_, view_height_; + GLdouble view_left_, view_right_, view_bottom_, view_top_; + GLdouble rot_x_, rot_y_, rot_z_; + + QTimer redraw_timer_; + QTimer performance_timer_; + + unsigned int frame_counter_; + unsigned int counter_snapshot_; + unsigned int animation_frame_count_; + unsigned int iteration_counter_; + unsigned int maximum_iterations_; + + static const unsigned int PERFORMANCE_SAMPLE_RATE_HZ = 1; + static const unsigned int MAXIMUM_ITERATIONS = 4; + + QQueue vignettes; + +protected slots: + void redraw ( void ); + void measure_performance ( void ); + +public: + CharacterView ( const char* text, const char* fontfile, + QWidget* parent = 0, const char* name = 0 ); +protected: + + void initializeGL ( void ); + void resizeGL ( int w, int h ); + void paintGL ( void ); + void keyPressEvent ( QKeyEvent* e ); + void resetView ( void ); +}; + +#endif /* SPEEDTEST_H */ diff --git a/engine/libraries/oglft/tests/texture.png b/engine/libraries/oglft/tests/texture.png new file mode 100644 index 0000000000000000000000000000000000000000..3d38bb6d54687f8bf2aa94934b42b25037662b41 GIT binary patch literal 507 zcmVFjcBxy^)}&X8naheZZxr9 zyvOq+czU}BK@ehn{E73jz%SdycyJXr(|1CFAD~`;Le3W`=Fc^CML;v`(2XMSeC)-~bW2;* zW-g;{jw4KYw4i7=c=dOkddJ7FZqiyQvN@V1eP;@xtOE^WH_&J*yB@*`Nh*VPBW-pb z=a_9zV&t=jt{4+^L`d1*Mo5DXW`((}GB>WDrC_?OsV_KxT<%8Wq=a+0plR)}qH1Is zr+L%&4bv8^4c6&ySX@hF81_=Qwguup4OZPcU;8Uelx$}GJQt%h7k&@mm$B zOpPWW!WSV6&UbFDUgBXY&zMN!U?9aoC?+V`+q_jjSnk#sDQCGaCz+B12#yB#1VN<9 xwNgCNLrkl4n8*KCTrd=!A}bOkuzH38{sH3tkzTc9P|N@T002ovPDHLkV1mdx-YozC literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/tosrc.pl b/engine/libraries/oglft/tests/tosrc.pl new file mode 100644 index 0000000..7f1f916 --- /dev/null +++ b/engine/libraries/oglft/tests/tosrc.pl @@ -0,0 +1,30 @@ +#!/usr/bin/perl + +use strict; + +# Convert the file given on the commandline into something which +# can be compiled with C and linked into an executable. +# Use the generated object module with the following declarations: +# extern unsigned char ${ARGV[0]}[]; /* Array of data */ +# extern int ${ARGV[0]}_size; /* Size of array */ +# Note, .'s in the argument filename are converted to _'s + +open FILE, $ARGV[0] or die "usage: $0 file"; + +# "Slurp the whole file" +undef $/; +my $contents = ; + +# Replace .'s in the filename with _'s (since . is an operator in C) +my $label = $ARGV[0]; +$label =~ s/\./_/; + +print "FT_Byte $label\[\] = {\n"; + +for ( my $i = 0; $i < length $contents; $i += 16 ) { + print join( ",", unpack( "C*", substr( $contents, $i, 16 ) ) ), ",\n"; +} + +print "};\n"; + +print "const int ${label}_size = sizeof( $label );\n"; diff --git a/engine/libraries/oglft/tests/tutorial1.cpp b/engine/libraries/oglft/tests/tutorial1.cpp new file mode 100644 index 0000000..e3c401f --- /dev/null +++ b/engine/libraries/oglft/tests/tutorial1.cpp @@ -0,0 +1,98 @@ +/* + * tutorial1.cpp: Tutorial for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include + +#include + +#include // Note: this will depend on where you've installed OGLFT + +// Declare a Face variable of the desired style +OGLFT::Monochrome* monochrome; + +void init ( const char* filename ) +{ + // Create a new face given the font filename and a size + + monochrome = new OGLFT::Monochrome( filename, 36 ); + + // Always check to make sure the face was properly constructed + + if ( monochrome == 0 || !monochrome->isValid() ) { + std::cerr << "Could not construct face from " << filename << std::endl; + return; + } + + // Set the face color to red + + monochrome->setForegroundColor( 1., 0., 0. ); + + // For the raster styles, it is essential that the pixel store + // unpacking alignment be set to 1 + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + + // Set the window's background color + + glClearColor( .75, .75, .75, 1. ); +} + +static void display ( void ) +{ + // First clear the window ... + glClear( GL_COLOR_BUFFER_BIT ); + // ... then draw the string + monochrome->draw( 0., 250., "Hello, World!" ); +} + +static void reshape ( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, width, 0, height, -1, 1 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + +int main ( int argc, char* argv[] ) +{ + // Check to be sure the user specified something as a font file name + + if ( argc != 2 ) { + std::cerr << "usage: " << argv[0] << " fontfile" << std::endl; + return 1; + } + + // Standard GLUT setup commands + + glutInit( &argc, argv ); + glutInitWindowSize( 500, 500 ); + glutInitDisplayMode( GLUT_RGB ); // Note: OGLFT really only works in RGB mode + glutCreateWindow( argv[0] ); + + init( argv[1] ); + + glutReshapeFunc( reshape ); + glutDisplayFunc( display ); + glutMainLoop(); + + return 0; +} diff --git a/engine/libraries/oglft/tests/tutorial2.cpp b/engine/libraries/oglft/tests/tutorial2.cpp new file mode 100644 index 0000000..c95a637 --- /dev/null +++ b/engine/libraries/oglft/tests/tutorial2.cpp @@ -0,0 +1,131 @@ +/* + * tutorial2.cpp: Tutorial for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include + +#include + +#include // Note: this will depend on where you've installed OGLFT + +#define USE_BITMAP_FACE + +// Declare a Face variable of the desired style +#if defined( USE_BITMAP_FACE ) +OGLFT::Monochrome* face; +#else +OGLFT::Filled* face; +#endif + +void init ( const char* filename ) +{ + // Create a new face given the font filename and a size + +#if defined( USE_BITMAP_FACE ) + face = new OGLFT::Monochrome( filename, 36 ); +#else + face = new OGLFT::Filled( filename, 36 ); +#endif + + // Always check to make sure the face was properly constructed + + if ( face == 0 || !face->isValid() ) { + std::cerr << "Could not construct face from " << filename << std::endl; + return; + } + + // Set the face color to red + + face->setForegroundColor( 1., 0., 0. ); + + // Use centered justification + + face->setHorizontalJustification( OGLFT::Face::CENTER ); + + // For the raster styles, it is essential that the pixel store + // unpacking alignment be set to 1 + + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + + // Set the window's background color + + glClearColor( .75, .75, .75, 1. ); +} + +static void display ( void ) +{ + // First clear the window ... + glClear( GL_COLOR_BUFFER_BIT ); + // ... then draw the string + face->draw( 250., 250., "Hello, World!" ); + + glutSwapBuffers(); +} + +static void reshape ( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, width, 0, height, -1, 1 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + +static void idle ( void ) +{ + // Retrieve the current value of the string's rotation and increment + // it by 4 degrees + + face->setStringRotation( face->stringRotation() + 4 ); +#if !defined(WIN32) + // Too fast even without acceleration + struct timespec request = { 0, 40000000 }; + nanosleep( &request, 0 ); +#else + Sleep( 40 ); +#endif + glutPostRedisplay(); +} + +int main ( int argc, char* argv[] ) +{ + // Check to be sure the user specified something as a font file name + + if ( argc != 2 ) { + std::cerr << "usage: " << argv[0] << " fontfile" << std::endl; + return 1; + } + + // Standard GLUT setup commands + + glutInit( &argc, argv ); + glutInitWindowSize( 500, 500 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); // Note: OGLFT really only works in RGB mode + glutCreateWindow( argv[0] ); + + init( argv[1] ); + + glutReshapeFunc( reshape ); + glutDisplayFunc( display ); + glutIdleFunc( idle ); + glutMainLoop(); + + return 0; +} diff --git a/engine/libraries/oglft/tests/tutorial3.cpp b/engine/libraries/oglft/tests/tutorial3.cpp new file mode 100644 index 0000000..9025564 --- /dev/null +++ b/engine/libraries/oglft/tests/tutorial3.cpp @@ -0,0 +1,282 @@ +/* + * tutorial3.cpp: Tutorial for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#if defined(_MSC_VER) +#define _USE_MATH_DEFINES +#endif +#include +#include +#include // The STL vector +#include // The STL algorithms +#include + +#include // Note: this will depend on where you've installed OGLFT + +// A Face variable of the desired style +#ifndef OGLFT_NO_SOLID +OGLFT::Solid* solid; +#else // If Solid is not defined, use Filled instead +OGLFT::Filled* solid; +#endif + +// The Bounding Box for the string +OGLFT::BBox bbox; + +// A vector of OpenGL display list names +OGLFT::DisplayLists dlists; + +// A vector of displacements defining the ocean +struct vertex { + float y; + float nx, ny; +}; +std::vector< vertex > ocean_vertices; + +void init ( const char* filename ) +{ + // Create a new face given the font filename and a size + +#ifndef OGLFT_NO_SOLID + solid = new OGLFT::Solid( filename, 36 ); +#else + solid = new OGLFT::Filled( filename, 36 ); +#endif + + // Always check to make sure the face was properly constructed + + if ( solid == 0 || !solid->isValid() ) { + std::cerr << "Could not construct face from " << filename << std::endl; + return; + } + + const float AMPLITUDE = 25.; + GLuint dlist = glGenLists( 2*13 ); + + // The per character display lists are executed before the glyph is + // rendered; so, the first display list must contain an absolute + // transformation, but the subsequent ones must contain relative + // transformations. However, we need complete sets of both transformations, + // starting with a place holder for the first (absolute) transformation + + dlists.push_back( 0 ); + + // Next, generate a sequence of relative displacements + + for ( int i=0; i<13; i++ ) { + float dy = AMPLITUDE * ( sinf( (i+1) * 2.f * (float)M_PI / 13.f ) - + sinf( i * 2.f * (float)M_PI / 13.f ) ); + + glNewList( dlist, GL_COMPILE ); + glTranslatef( 0., dy, 0. ); + glEndList(); + + dlists.push_back( dlist ); + + dlist++; + } + + // Next, generate a sequence of absolute displacements + + for ( int i=0; i<13; i++ ) { + float y = AMPLITUDE * sinf( i * 2.f * (float)M_PI / 13.f ); + + glNewList( dlist, GL_COMPILE ); + glTranslatef( 0., y, 0. ); + glEndList(); + + dlists.push_back( dlist ); + + dlist++; + } + + // Finally, copy the first absolute displacement into the first element + // of the display list vector + + dlists[0] = dlists[13+1]; + + // Use centered justification + + solid->setHorizontalJustification( OGLFT::Face::CENTER ); +#ifndef OGLFT_NO_SOLID + // Make the glyphs rather thick + + solid->setDepth( 10. ); +#endif + // Apply the per character display lists + + solid->setCharacterDisplayLists( dlists ); + + // Get the size of the string before it is transformed + + bbox = solid->measure( "Hello, World!" ); + + // Make it (sea) green + + solid->setForegroundColor( 143.f/255.f, 188.f/255.f, 143.f/255.f ); + + // Set the window's background color + + glClearColor( .5, .5, .5, 1. ); + + // Build an "ocean" for the characters to float upon (a higher resolution + // version of the absolute displacements which we'll cycle through) + + for ( int i = 0; i <= 52; i++ ) { + float s = sinf( i * 2.f * (float)M_PI / 52.f ); + float c = cosf( i * 2.f * (float)M_PI / 52.f ); + vertex v; + v.y = AMPLITUDE * s; + v.nx = c; + v.ny = s; + ocean_vertices.push_back( v ); + } + + // Enable lighting and the depth test + + glEnable( GL_LIGHTING ); + glEnable( GL_LIGHT0 ); + glEnable( GL_COLOR_MATERIAL ); + glEnable( GL_DEPTH_TEST ); +} + +static int offset = 0; + +static void display ( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + glPushMatrix(); + + solid->draw( 250., 250., "Hello, World!" ); + + glTranslatef( 254.f - ( bbox.x_max_ + bbox.x_min_ ) / 2.f, 255.f, 0.f ); + + glBegin( GL_QUAD_STRIP ); + + glColor3f( 0., 0., 1. ); + + for ( int i=0; i<=52; i++ ) { + float x = i * ( bbox.x_max_ - bbox.x_min_ ) / 52; + + glNormal3f( ocean_vertices[(i+offset)%53].nx, + ocean_vertices[(i+offset)%53].ny, + 0 ); + + glVertex3f( x, ocean_vertices[(i+offset)%53].y, -100. ); + glVertex3f( x, ocean_vertices[(i+offset)%53].y, 100. ); + } + + offset = offset < 48 ? offset+4 : 0; + + glEnd(); + + glPopMatrix(); + glutSwapBuffers(); +} + +static void reshape ( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0, width, 0, height, -200, 200 ); + + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + // Rotate the model slightly out of the XY plane so it looks 3D + // (note we rotate the model instead of the view so that the lighting + // is fixed relative to the view instead of the model) + + glTranslatef( width/2.f, height/2.f, 0.f ); + glRotatef( 25.f, 1.f, 0.f, 0.f ); + glRotatef( 25.f, 0.f, 1.f, 0.f ); + glTranslatef( -width/2.f, -height/2.f, 0. ); +} + +static void idle ( void ) +{ + // Use the STL rotate algorithm to animate the transformation display lists. + // First, rotate the lists containing the relative displacements + + OGLFT::DLI first = solid->characterDisplayLists().begin()+1; + OGLFT::DLI next = first + 1; + OGLFT::DLI last = first + 13; + + rotate( first, next, last ); + + // Next, rotate the the lists containing the absolute displacements + + first = solid->characterDisplayLists().begin() + 13 + 1; + next = first + 1; + last = first + 13; + + rotate( first, next, last ); + + // Finally, copy the current absolute displacement into the leading element + + solid->characterDisplayLists()[0] = solid->characterDisplayLists()[13+1]; + + glutPostRedisplay(); +#if !defined(WIN32) + // Too fast even without acceleration + struct timespec request = { 0, 80000000 }; + nanosleep( &request, 0 ); +#else + Sleep( 800 ); +#endif +} + +static void key ( unsigned char c, int /*x*/, int /*y*/ ) +{ + switch ( c ) { + case 'q': + case 27: + exit( 0 ); + } +} + +int main ( int argc, char* argv[] ) +{ + // Check to be sure the user specified something as a font file name + + if ( argc != 2 ) { + std::cerr << "usage: " << argv[0] << " fontfile" << std::endl; + return 1; + } + + // Standard GLUT setup commands + + glutInit( &argc, argv ); + glutInitWindowSize( 500, 500 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); + glutCreateWindow( argv[0] ); + + init( argv[1] ); + + glutReshapeFunc( reshape ); + glutDisplayFunc( display ); + glutKeyboardFunc( key ); + + glutIdleFunc( idle ); + + glutMainLoop(); + + return 0; +} diff --git a/engine/libraries/oglft/tests/vignette.h b/engine/libraries/oglft/tests/vignette.h new file mode 100644 index 0000000..3809d80 --- /dev/null +++ b/engine/libraries/oglft/tests/vignette.h @@ -0,0 +1,99 @@ +/* -*- c++ -*- + * speedtest.h: Header for Performance test for the OGLFT library + * Copyright (C) 2002 lignum Computing, Inc. + * $Id$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef VIGNETTE_H +#define VIGNETTE_H + +#include + +#if OGLFT_QT_VERSION == 3 +#include +#include +#include +#elif OGLFT_QT_VERSION == 4 +#include +#include +#include +#include +#endif + +// Little animation vignettes. The function calls essentially follow +// those of the Qt OpenGL widget and are called at the corresponding times. + +struct Vignette { + virtual ~Vignette ( void ) {} + virtual unsigned int frame_count ( void ) = 0; + virtual unsigned int frame_rate ( void ) = 0; + virtual void init ( void ) = 0; + virtual void view ( GLdouble /*left*/, GLdouble /*right*/, + GLdouble /*bottom*/, GLdouble /*top*/ ) + {} + virtual void reset ( void ) + {} + virtual bool input ( QKeyEvent* e ) + { + if ( e->key() == Qt::Key_Escape ) exit( 0 ); + return false; + } + virtual void draw ( unsigned int frame_number ) = 0; + virtual void finish ( void ) = 0; +}; + +// Yet another OpenGL view widget. + +class CharacterView : public QGLWidget { +Q_OBJECT + GLsizei window_width_, window_height_; + GLdouble view_width_, view_height_; + GLdouble view_left_, view_right_, view_bottom_, view_top_; + + bool flank_speed_; + QTimer redraw_timer_; + QTimer performance_timer_; + + unsigned int frame_counter_; + unsigned int counter_snapshot_; + unsigned int animation_frame_count_; + unsigned int animation_frame_rate_; + unsigned int animation_frame_counter_; + + static const unsigned int PERFORMANCE_SAMPLE_RATE_HZ = 1; +#if OGLFT_QT_VERSION == 3 + QQueue vignettes; +#elif OGLFT_QT_VERSION == 4 + QQueue vignettes; +#endif + +protected slots: + void redraw ( void ); + void measure_performance ( void ); + +public: + CharacterView ( bool flank_speed, const char* fontfile, + QWidget* parent = 0, const char* name = 0 ); +protected: + + void initializeGL ( void ); + void resizeGL ( int w, int h ); + void paintGL ( void ); + void keyPressEvent ( QKeyEvent* e ); + void resetView ( void ); +}; + +#endif /* VIGNETTE_H */ diff --git a/engine/tests/CMake/FindUnitTest++.cmake b/engine/tests/CMake/FindUnitTest++.cmake new file mode 100644 index 0000000..261e7a8 --- /dev/null +++ b/engine/tests/CMake/FindUnitTest++.cmake @@ -0,0 +1,28 @@ +# - Try to find UnitTest++ +# +# + +SET (UNITTEST++_FOUND FALSE) + +FIND_PATH (UNITTEST++_INCLUDE_DIR UnitTest++.h /usr/include/unittest++ /usr/local/include/unittest++ $ENV{UNITTESTXX_PATH}/src $ENV{UNITTESTXX_INCLUDE_PATH}) + +FIND_LIBRARY (UNITTEST++_LIBRARY NAMES UnitTest++ PATHS /usr/lib /usr/local/lib $ENV{UNITTESTXX_PATH} ENV{UNITTESTXX_LIBRARY_PATH}) + +IF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + SET (UNITTEST++_FOUND TRUE) +ENDIF (UNITTEST++_INCLUDE_DIR AND UNITTEST++_LIBRARY) + +IF (UNITTEST++_FOUND) + IF (NOT UnitTest++_FIND_QUIETLY) + MESSAGE(STATUS "Found UnitTest++: ${UNITTEST++_LIBRARY}") + ENDIF (NOT UnitTest++_FIND_QUIETLY) +ELSE (UNITTEST++_FOUND) + IF (UnitTest++_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find UnitTest++") + ENDIF (UnitTest++_FIND_REQUIRED) +ENDIF (UNITTEST++_FOUND) + +MARK_AS_ADVANCED ( + UNITTEST++_INCLUDE_DIR + UNITTEST++_LIBRARY + ) diff --git a/engine/tests/CMakeLists.txt b/engine/tests/CMakeLists.txt new file mode 100644 index 0000000..54f96ba --- /dev/null +++ b/engine/tests/CMakeLists.txt @@ -0,0 +1,51 @@ +PROJECT (ENGINETESTS) + +CMAKE_MINIMUM_REQUIRED (VERSION 2.6) + +# Needed for UnitTest++ +LIST( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake ) + +SET ( TESTS_SRCS + main.cc + CommandsTests.cc + EntityTests.cc + EventsBaseTests.cc + PhysicsTests.cc + ControllerBaseTests.cc + ) + +FIND_PACKAGE (UnitTest++) + +INCLUDE_DIRECTORIES ( ../ ) + +SET_TARGET_PROPERTIES ( ${PROJECT_EXECUTABLES} PROPERTIES + LINKER_LANGUAGE CXX +) + +IF ( UNITTEST++_FOUND ) + ADD_EXECUTABLE ( enginetests ${TESTS_SRCS} ) + + INCLUDE_DIRECTORIES ( ${UNITTEST++_INCLUDE_DIR} ) + + SET_TARGET_PROPERTIES ( enginetests PROPERTIES + LINKER_LANGUAGE CXX + OUTPUT_NAME runtests + ) + + TARGET_LINK_LIBRARIES ( enginetests + ${UNITTEST++_LIBRARY} + Engine + ) + + OPTION (RUN_AUTOMATIC_TESTS "Perform automatic tests after compilation?" OFF) + + IF (RUN_AUTOMATIC_TESTS) + ADD_CUSTOM_COMMAND (TARGET runtests + POST_BUILD + COMMAND ./runtests + COMMENT "Running automated tests..." + ) + ENDIF (RUN_AUTOMATIC_TESTS) + +ENDIF ( UNITTEST++_FOUND ) + diff --git a/engine/tests/CommandsTests.cc b/engine/tests/CommandsTests.cc new file mode 100644 index 0000000..dfdadf5 --- /dev/null +++ b/engine/tests/CommandsTests.cc @@ -0,0 +1,138 @@ +#include + +#include "Logging.h" +#include "Commands.h" +#include "CommandsGlobal.h" + +using namespace std; +using namespace Engine; + +int global_int = -1; +string global_string = ""; +vector global_values; + +struct CommandsFixture { + CommandsFixture () { + LoggingModule.Init (0, NULL); + LoggingModule.SetLogPrintLevel (LogLevelWarning); + CommandsModule.Init (0, NULL); + } + + ~CommandsFixture () { + CommandsModule.Destroy (); + LoggingModule.Destroy (); + } + + Logging LoggingModule; + Commands CommandsModule; +}; + +bool test_cmd_set_global_int (vector argv) { + global_int = 1; + return true; +}; + +bool test_cmd_set_global_string (vector argv) { + if (argv.size() > 0) { + global_string = argv[0]; + return true; + } + + return false; +} + +bool test_cmd_set_global_values (vector argv) { + global_values = argv; + return true; +}; + +bool test_cmd_set_error (vector argv) { + if (argv.size() > 0) { + CommandSetErrorString ("too many arguments passed to function!"); + return false; + } + + return true; +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemAddCommand ) { + AddCommand ("test", test_cmd_set_global_int); + CHECK_EQUAL (true, RunCommand ("test")); +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemRun ) { + global_int = -1; + + AddCommand ("test", test_cmd_set_global_int); + CHECK_EQUAL (true, RunCommand ("test")); + + CHECK_EQUAL (1, global_int); +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemArgv ) { + global_string = "oldstring"; + AddCommand ("test_string", test_cmd_set_global_string); + CHECK_EQUAL (1, RunCommand ("test_string newstring")); + + CHECK_EQUAL ("newstring", global_string); +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemArgValues ) { + global_values.clear(); + AddCommand ("test_values", test_cmd_set_global_values); + CHECK_EQUAL (true, RunCommand ("test_values value1 value2 value3 ")); + + CHECK_EQUAL (static_cast (3), global_values.size()); + if (global_values.size() == 3) { + CHECK_EQUAL ("value1", global_values[0]); + CHECK_EQUAL ("value2", global_values[1]); + CHECK_EQUAL ("value3", global_values[2]); + } + + global_values.clear (); + CHECK_EQUAL (true, RunCommand ("test_values")); + CHECK_EQUAL (static_cast (0), global_values.size()); + + global_values.clear (); + CHECK_EQUAL (true, RunCommand ("test_values value1 \"value consisting of a string\"")); + CHECK_EQUAL (static_cast (2), global_values.size()); + + if (global_values.size () == 2) { + CHECK_EQUAL ("value consisting of a string", global_values[1]); + } + + global_values.clear (); + CHECK_EQUAL (true, RunCommand ("test_values \"value consisting of a string\"")); + CHECK_EQUAL (static_cast (1), global_values.size()); + + if (global_values.size () == 1) { + CHECK_EQUAL ("value consisting of a string", global_values[0]); + } +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemQueue ) { + global_string = "oldstring"; + global_int = -1; + + AddCommand ("test_string", test_cmd_set_global_string); + AddCommand ("test_int", test_cmd_set_global_int); + + QueueCommand ("test_string newstring"); + QueueCommand ("test_int"); + CommandQueueExecute (); + + CHECK_EQUAL ("newstring", global_string); + CHECK_EQUAL (1, global_int); +} + +TEST_FIXTURE ( CommandsFixture, CommandSystemError ) { + AddCommand ("set_error", test_cmd_set_error); + + CHECK_EQUAL (false, RunCommand ("set_error error")); + CHECK_EQUAL ("too many arguments passed to function!", CommandGetErrorString ()); + + CHECK_EQUAL (true, RunCommand ("set_error")); + CHECK_EQUAL ("", CommandGetErrorString ()); +} + + diff --git a/engine/tests/ControllerBaseTests.cc b/engine/tests/ControllerBaseTests.cc new file mode 100644 index 0000000..0db8764 --- /dev/null +++ b/engine/tests/ControllerBaseTests.cc @@ -0,0 +1,20 @@ +#include + +#include "ControllerBase.h" +#include "keytable.h" + +using namespace std; +using namespace Engine; + +TEST (test_convert_keystring) { + int key; + + key = convert_keystring ("up"); + CHECK_EQUAL (SDLK_UP, key); + key = convert_keystring ("escape"); + CHECK_EQUAL (SDLK_ESCAPE, key); + + key = convert_keystring ("blaaa"); + CHECK_EQUAL (0, key); +} + diff --git a/engine/tests/EntityTests.cc b/engine/tests/EntityTests.cc new file mode 100644 index 0000000..31e8c9a --- /dev/null +++ b/engine/tests/EntityTests.cc @@ -0,0 +1,90 @@ +#include + +#include "Logging.h" +#include "EntityBase.h" + +using namespace std; +using namespace Engine; + +struct EntityFixture { + EntityFixture () { + LoggingModule.Init (0, NULL); + LoggingModule.SetLogPrintLevel (LogLevelWarning); + } + + ~EntityFixture () { + LoggingModule.Destroy (); + } + + Logging LoggingModule; +}; + +TEST_FIXTURE ( EntityFixture, EntityPhysicStateGlobalizeTranslation ) { + EntityPhysicState phys_entity; + + vector3d position (1, 0, -2); + vector3d orientation (0, 0.25 * M_PI, 0); + + phys_entity.SetPosition (position); + phys_entity.SetOrientation (orientation); + + vector3d origin (0, 0, 0); + phys_entity.Globalize (origin); + + CHECK_EQUAL (origin[0], 1); + CHECK_EQUAL (origin[1], 0); + CHECK_EQUAL (origin[2], -2); +} + +TEST_FIXTURE ( EntityFixture, EntityPhysicStateGlobalizeFull ) { + EntityPhysicState phys_entity; + + vector3d position (3, 0, 1); + vector3d orientation (0, 45, 0); + + phys_entity.SetPosition (position); + phys_entity.SetOrientation (orientation); + + vector3d front (5, 0, 0); + phys_entity.Globalize (front); + + CHECK_CLOSE (3 + cos (45 * M_PI / 180) * 5., front[0], 1.0e-5); + CHECK_CLOSE (0, front[1], 1.0e-5); + CHECK_CLOSE (1 - sin (45 * M_PI / 180) * 5., front[2], 1.0e-5); +} + +TEST_FIXTURE ( EntityFixture, EntityPhysicStateLocalizeTranslation ) { + EntityPhysicState phys_entity; + + vector3d position (1, 0, -2); + vector3d orientation (0, 45, 0); + + phys_entity.SetPosition (position); + phys_entity.SetOrientation (orientation); + + vector3d origin (1., 0, -2.); + phys_entity.Localize (origin); + + CHECK_CLOSE (0, origin[0], 1.0e-5); + CHECK_CLOSE (0, origin[1], 1.0e-5); + CHECK_CLOSE (0, origin[2], 1.0e-5); +} + +TEST_FIXTURE ( EntityFixture, EntityPhysicStateLocalizeFull ) { + EntityPhysicState phys_entity; + + vector3d position (1, 0, -1); + vector3d orientation (0, 45, 0); + + phys_entity.SetPosition (position); + phys_entity.SetOrientation (orientation); + + vector3d origin (0, 0, 0); + phys_entity.Localize (origin); + + CHECK_CLOSE (-sqrt (2), origin[0], 1.0e-5); + CHECK_CLOSE (0, origin[1], 1.0e-5); + CHECK_CLOSE (0, origin[2], 1.0e-5); +} + + diff --git a/engine/tests/EventsBaseTests.cc b/engine/tests/EventsBaseTests.cc new file mode 100644 index 0000000..8228668 --- /dev/null +++ b/engine/tests/EventsBaseTests.cc @@ -0,0 +1,130 @@ +#include + +#include "Logging.h" +#include "EventsBase.h" + +using namespace std; +using namespace Engine; + +int global_event_type = -1; +string global_event_string = ""; + +class TestEventListener : public EventListenerBase { + public: + TestEventListener() { + mName = "TestEventListener"; + } + + virtual bool HandleEvent (const EventBasePtr &event) const { + global_event_type = event->mEventType; + global_event_string = event->mEventData; + + return true; + } +}; + +struct EventsFixture { + EventsFixture () { + LoggingModule.Init (0, NULL); + LoggingModule.SetLogPrintLevel (LogLevelWarning); + + TestEventManager = new EventManager; + + global_event_type = -1; + global_event_string = ""; + } + + ~EventsFixture () { + delete TestEventManager; + TestEventManager = NULL; + + LoggingModule.Destroy (); + } + + Logging LoggingModule; + + TestEventListener Listener; + EventManager *TestEventManager; +}; + +TEST_FIXTURE ( EventsFixture, TestEventListenerHandleEvent ) { + EventBasePtr event (new EventBase); + + event->mEventType = 1; + event->mEventData = "test"; + + Listener.HandleEvent (event); + + CHECK_EQUAL (1, global_event_type); + CHECK_EQUAL ("test", global_event_string); +} + +TEST_FIXTURE ( EventsFixture, TestTestEventManagerZeroListeners ) { + CHECK_EQUAL (false, TestEventManager->HasEventTypeListener(123)); + CHECK_EQUAL (0, TestEventManager->GetEventTypeListenerCount(123)); +} + +TEST_FIXTURE ( EventsFixture, TestTestEventManagerAddListener ) { + TestEventManager->RegisterListener (&Listener, 1); + + CHECK_EQUAL (true, TestEventManager->HasEventTypeListener(1)); + CHECK_EQUAL (false, TestEventManager->HasEventTypeListener(2)); + + TestEventManager->RegisterListener (&Listener, 1); + CHECK_EQUAL (2, TestEventManager->GetEventTypeListenerCount(1)); +} + +TEST_FIXTURE ( EventsFixture, TestTestEventManagerTriggerEvent ) { + TestEventManager->RegisterListener (&Listener, 1); + + CHECK_EQUAL (true, TestEventManager->HasEventTypeListener(1)); + + EventBasePtr event (new EventBase); + + event->mEventType = 1; + event->mEventData = "test"; + + CHECK_EQUAL (true, TestEventManager->TriggerEvent (event)); + + CHECK_EQUAL (1, global_event_type); + CHECK_EQUAL ("test", global_event_string); + + event->mEventType = 0; + CHECK_EQUAL (false, TestEventManager->TriggerEvent (event)); +} + +TEST_FIXTURE ( EventsFixture, TestTestEventManagerQueueEvent ) { + TestEventManager->RegisterListener (&Listener, 1); + + EventBasePtr event (new EventBase); + + event->mEventType = 1; + event->mEventData = "test"; + + CHECK_EQUAL (true, TestEventManager->QueueEvent (event)); + CHECK_EQUAL (1, TestEventManager->GetQueuedEventCount()); + CHECK_EQUAL (true, TestEventManager->QueueEvent (event)); + CHECK_EQUAL (2, TestEventManager->GetQueuedEventCount()); + + event->mEventType = 2; + CHECK_EQUAL (false, TestEventManager->QueueEvent (event)); +} + +TEST_FIXTURE ( EventsFixture, TestTestEventManagerProcess ) { + TestEventManager->RegisterListener (&Listener, 1); + + EventBasePtr event (new EventBase); + + event->mEventType = 1; + event->mEventData = "test"; + + CHECK_EQUAL (true, TestEventManager->QueueEvent (event)); + CHECK_EQUAL (1, TestEventManager->GetQueuedEventCount()); + CHECK_EQUAL (true, TestEventManager->QueueEvent (event)); + CHECK_EQUAL (2, TestEventManager->GetQueuedEventCount()); + + TestEventManager->Process(); + CHECK_EQUAL (1, global_event_type); + CHECK_EQUAL ("test", global_event_string); + CHECK_EQUAL (0, TestEventManager->GetQueuedEventCount()); +} diff --git a/engine/tests/PhysicsTests.cc b/engine/tests/PhysicsTests.cc new file mode 100644 index 0000000..63c2ac2 --- /dev/null +++ b/engine/tests/PhysicsTests.cc @@ -0,0 +1,66 @@ +#include + +#include "Logging.h" +#include "PhysicsBase.h" +#include "ModelBase.h" +#include "EntityBase.h" + +using namespace std; +using namespace Engine; + +struct PhysicsFixture { + PhysicsFixture () { + LoggingModule.Init (0, NULL); + LoggingModule.SetLogPrintLevel (LogLevelMessage); + PhysicsModule.Init (0, NULL); + + dummy_entity = CreateEntityPhysicState (EntityBaseTypeNone, 0); + particle_entity = CreateEntityPhysicState (EntityBaseTypeParticle, 1); + block_entity = CreateEntityPhysicState (EntityBaseTypeBlock, 2); + actor_entity = CreateEntityPhysicState (EntityBaseTypeActor, 3); + + PhysicsModule.RegisterEntity (dummy_entity); + PhysicsModule.RegisterEntity (particle_entity); + PhysicsModule.RegisterEntity (block_entity); + PhysicsModule.RegisterEntity (actor_entity); + } + + ~PhysicsFixture () { + PhysicsModule.UnregisterEntity (0); + PhysicsModule.UnregisterEntity (1); + PhysicsModule.UnregisterEntity (2); + PhysicsModule.UnregisterEntity (3); + + PhysicsModule.Destroy (); + LoggingModule.Destroy (); + } + + Logging LoggingModule; + PhysicsBase PhysicsModule; + + EntityPhysicState* dummy_entity; + EntityPhysicState* particle_entity; + EntityPhysicState* block_entity; + EntityPhysicState* actor_entity; +}; + +TEST_FIXTURE ( PhysicsFixture, PhysicsModuleActorActorCollision ) { + int result = -1; + + EntityPhysicState* actor_2_entity = CreateEntityPhysicState (EntityBaseTypeActor, 4); + assert (actor_2_entity->mShape); + assert (actor_entity->mShape); + + PhysicsModule.RegisterEntity (actor_2_entity); + + actor_entity->mPosition = vector3d (0., 0., 0.); + actor_entity->mVelocity = vector3d (1., 0., 0.); + + actor_2_entity->mPosition = vector3d (1.5, 0., 0.1); + actor_2_entity->mVelocity = vector3d (-1., 0., 0.); + + result = PhysicsModule.Simulate (1000.); + CHECK_EQUAL (0, result); + + PhysicsModule.UnregisterEntity (actor_2_entity->mId); +} diff --git a/engine/tests/main.cc b/engine/tests/main.cc new file mode 100644 index 0000000..e9daeaa --- /dev/null +++ b/engine/tests/main.cc @@ -0,0 +1,8 @@ +#include + +using namespace std; + +int main (int argc, char *argv[]) +{ + return UnitTest::RunAllTests (); +}

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 P00000NkvXXu0mjf7dtig literal 0 HcmV?d00001 diff --git a/engine/libraries/oglft/tests/background10.png b/engine/libraries/oglft/tests/background10.png new file mode 100644 index 0000000000000000000000000000000000000000..1f6c86a5d4f692cd3197e768e308ddc84f50b334 GIT binary patch literal 102117 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 mh`1cACL5h9vk0$A5X4Lqfz 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